Comments on: Ruby to C, a couple snippets

By: Andre

Andre — Tue, 06 May 2008 18:36:41 +0000

==19019== LEAK SUMMARY:
==19019== definitely lost: 0 bytes in 0 blocks.
==19019== possibly lost: 16 bytes in 1 blocks.
==19019== still reachable: 17,390,960 bytes in 377,007 blocks.

That was for a single run… for two runs, “still reachable” grows:

==19126== LEAK SUMMARY:
==19126== definitely lost: 0 bytes in 0 blocks.
==19126== possibly lost: 16 bytes in 1 blocks.
==19126== still reachable: 19,404,620 bytes in 356,601 blocks.
==19126== suppressed: 0 bytes in 0 blocks.

I guess this means there’s stuff being kept around that’s not being dereferenced, and the GC can’t do anything about it

By: macournoyer

macournoyer — Tue, 06 May 2008 14:13:25 +0000

If you needed to play w/ rb_register_address you’d have segfaults while accessing memory that has been freed by the GC.

You might have a memory leak in your C code if it’s increasing rapidly. I use Valgrind to hunt mem leaks: http://blog.evanweaver.com/articles/2008/02/05/valgrind-and-ruby/

By: Andre

Andre — Tue, 06 May 2008 12:14:16 +0000

Well, I actually am writing a large part of the application in C with the ruby API, because performance is really important. It’s an application that simulates message passing in a graph with thousands of nodes, and each message is a ruby array.

I’m not doing anything explicit to work with the garbage collector, because I thought that it was only needed for global objects and C struct fields that are VALUEs. However, memory usage is increasing a lot when the program runs for a long time (it runs for a few days).

I’m not sure if this is just ruby’s conservative GC that isn’t freeing my objects, or if there’s something I should be doing to let it do its job…

By: macournoyer

macournoyer — Tue, 06 May 2008 00:44:04 +0000

@Andre: If the object is passed back to Ruby you don’t need to do anything. Like in your example, you don’t need to register the address, since you return blah to Ruby.
Unless you write large part of your application in C you won’t need to bother w/ this.

By: Andre

Andre — Mon, 05 May 2008 19:08:01 +0000

Could you clarify a bit on the GC? What do you mean with “long lived objects”? Do I need to do something explicitely in code like

VALUE
foo(void)
{
VALUE blah = rb_ary_new();
append_stuff_to(blah);
return blah;
}

Thanks!

By: roger pack

roger pack — Mon, 28 Apr 2008 16:46:54 +0000

Also I think you don’t need to worry about explicit garbage marking if your object is passed back to some ruby object, or contained within another object that is referenced, where the ‘larger, containing object’ has the gc_something[?] function which tells the GC ‘these are my children, don’t collect them!’ during a sweep. Something like that

By: Stephane Wirtel

Stephane Wirtel — Mon, 21 Apr 2008 14:20:19 +0000

Hi Marc,

I think you can add the following link: http://whytheluckystiff.net/ruby/pickaxe/html/ext_ruby.html, This is the chapter ‘Extending Ruby’ from PickAxe.

By: macournoyer

macournoyer — Thu, 17 Apr 2008 02:05:41 +0000

@Nate yeah I saw rocaml, sadly I don’t know OCaml yet, but the exceptions interception and type conversion does look very nice.

@drnic very cool! I guess we really are ready to Rails to C then :/

By: Dr Nic

Dr Nic — Wed, 16 Apr 2008 22:33:09 +0000

If you want to bundle all this in a gem, the newgem generator includes an ext_conf generator (script/generate ext_conf libname) to create an ext/libname/… + test/test_libname_extn.rb file so you can TDD your C.

By: Nate

Nate — Wed, 16 Apr 2008 21:08:43 +0000

Also check out rocml!

http://eigenclass.org/hiki/rocaml

It’s fun!