How should marking be accomplished on arrays of VALUE* in a Ruby extension?

Question

I have a matrix type which contains a void* array, representing an array of objects (which are all of one type in a given matrix, e.g., all C integers, all floats, doubles, a variety of structs, or possibly even all Ruby VALUEs).

Memory allocation and garbage collection seems to work correctly until I try to create a matrix of VALUEs.

I have the following mark function defined:

void mark_dense_storage(void* s) {
  size_t i;
  DENSE_STORAGE* storage = (DENSE_STORAGE*)s;
  if (storage && storage->dtype == RUBY_OBJECT)
    for (i = 0; i < count_dense_storage_elements(s); ++i)
      rb_gc_mark(*((VALUE*)(storage->elements + i*sizeof(VALUE)));
}

So it only does marking if it's actually a VALUE matrix — otherwise, NULL gets passed to Data_Wrap_Struct for the mark function.

But I'm getting a segfault when I test some of the VALUE matrix functions (see gist).

Specifically, it seems to segfault the first time I try to call a Ruby method on the very first object in the VALUE* array:

C[i+j*ldc] = rb_funcall(C[i+j*ldc], nm_id_mult, 1, beta); // C[i+j*ldc] = C[i+j*ldc]*beta

nm_id_mult is a global defined in my Init function as rb_intern("*").

It's possible this isn't a garbage collection problem, but the GC is the part of Ruby that I understand the least — and my segfault is also almost identical to this trace, which the poster attributes to the GC.

So, my questions:

If it's the GC, what's the appropriate way to mark an array of VALUEs?
If it's not the GC, how do I go about diagnosing this type of error? I've never seen anything like it.

EDIT:

Turns out that this is an example of failure to initialize VALUEs created in C.

In other words, make sure to do *(VALUE*)a = INT2FIX(0) before you try to access a.

I do still think the question is relevant. I haven't managed to find any really good examples of marking for clean-and-sweep garbage collection, on StackOverflow or elsewhere. If you can provide such an example and/or explanation, I'll mark that as a correct answer to this question.

So first of all I would upgrade to Ruby 1.9.3-p125 and check if the problem is still present. There were some issues with GC in p0. — Aleksander Pohl, Mar 12 '12 at 22:15
The problem is still present with p125. I added the gdb output to the gist: https://gist.github.com/2024629#file_gdb.p125.out — Translunar, Mar 13 '12 at 16:32
Hmmm, you may also try 1.9.2-p290 - I have a similar problem which is present both in 1.9.3-p0 and 1.9.3-p125. — Aleksander Pohl, Mar 13 '12 at 23:51
Nope, no good with 1.9.2-p290 either. Except now it doesn't know what function the current frame is: `#0 0x0000bb69 in ?? ()`, called from `st_lookup`. =( — Translunar, Mar 14 '12 at 18:13
I may be obvious, but have you tried to disable the mark function for VALUE matrices? What happens then? — Aleksander Pohl, Mar 14 '12 at 21:44
It doesn't seem to affect it. Perhaps not a mark problem at all? — Translunar, Mar 26 '12 at 18:54

score 1 · Accepted Answer · answered Aug 14 '12 at 15:57

Ruby's mark-and-sweep GC works in two stages.

The first stage marks live objects. It works recursively by calling the marking function of each known "live objects". The initial set of live objects is produced by scanning the C stack of each known Ruby thread or of each registered global objects (there's a C function to register/deregister "known live" objects). The marking function of object X should then call rb_gc_mark for each objects that X refers to. In other words, what you do is exactly what you should do.

However, as you noticed later, not any possible VALUE is a valid Ruby object. However, I believe that initializing with Qnil (i.e. nil) would be more ruby-ish.

How should marking be accomplished on arrays of VALUE* in a Ruby extension?

1 Answers1