ActiveRecord objects in hashes aren't garbage collected -- a bug or a sort of caching feature?

I think I know what's going on. Ruby's GC wont free immutable objects (like symbols!). The keys returned by group_by are immutable strings, and so they wont be garbage collected.

UPDATE:

It seems like the problem is not with Rails itself. I tried using group_by alone, and sometimes the objects would not get garbage collected:

oscardelben~/% irbirb(main):001:0> class Fooirb(main):002:1> end=> nilirb(main):003:0> {"1" => Foo.new, "2" => Foo.new}=> {"1"=>#<Foo:0x007f9efd8072a0>, "2"=>#<Foo:0x007f9efd807250>}irb(main):004:0> ObjectSpace.each_object(Foo).count=> 2irb(main):005:0> GC.start=> nilirb(main):006:0> ObjectSpace.each_object(Foo).count=> 0irb(main):007:0> {"1" => Foo.new, "2" => Foo.new}.group_by=> #<Enumerator: {"1"=>#<Foo:0x007f9efb83d0c8>, "2"=>#<Foo:0x007f9efb83d078>}:group_by>irb(main):008:0> GC.start=> nilirb(main):009:0> ObjectSpace.each_object(Foo).count=> 2 # Not garbage collectedirb(main):010:0> GC.start=> nilirb(main):011:0> ObjectSpace.each_object(Foo).count=> 0 # Garbage collected

I've digged through the GC internals (which are surprisingly easy to understand), and this seems like a scope issue. Ruby walks through all the objects in the current scope and marks the ones which it thinks are still being used, after that it goes through all the objects in the heap and frees the ones which have not been marked.

In this case I think the hash is still being marked even though it's out of scope. There are many reasons why this may happening. I'll keep investigating.

UPDATE 2:

I've found what's keeping references of objects. To do that I've used the ruby mass gem. It turns out that Active Record relation keeps track of the objects returned.

User.limit(1).group_by(&:name)GC.startObjectSpace.each_object(ActiveRecord::Base).each do |obj|  p Mass.references obj # {"ActiveRecord::Relation#70247565268860"=>["@records"]}end

Unfortunately, calling reset on the relation didn't seem to help, but hopefully this is enough information for now.

i do not know the answer

But i tried inspecting the heap as given on http://blog.headius.com/2010/07/browsing-memory-jruby-way.html

Have attached a screenshot at, https://skitch.com/deepak_kannan/en3dg/java-visualvmit was a simple program

class Foo; endf1 = Foo.newf2 = Foo.newGC.start

Then used jvisualvm as given above. Was running this in irb.
Seems as if jruby is tracking the object's scope. The object will not get GC'ed if there are any non-weak references to that object