Replies: 1 comment 4 replies
-
|
Hello! I've moved this to a discussion, since the "bug" here has been addressed in other issues. Your assessment is correct... there are cases where within a given scope, values will remain referenced longer than you expect. This is a side effect of us using a register-based intermediate representation (IR) in our compiler, which tends to have a lot of temporary variables. In this case, on JRuby 9.4, your example code line
Compiled to our IR it looks like this: Because it started out as a mutable string, the original If you run your example on JRuby 10, which uses chilled strings by default, it works...because the weak_map = ObjectSpace::WeakMap.new
obj = +"Hello World"
weak_map[obj.__id__] = obj
weak_map.size
# => 1
# Remove the object reference
obj = nil
while weak_map.size > 0
java.lang.System.gc
end
# => Timeout waiting for garbage collection (Timeout::Error)
puts "weak_map is clear"The Notice the original Output: Of course the behavior of 10 is just a side effect of strings being "frozen" by default. It would be easy to make another change and see the object get "stuck" again. This is not uncommon in languages with optimizing compilers, so it's not something we're going to actively try to fix... but we have done and will continue to do small improvements over time. We actually use far fewer temps than we did for early JRuby 9.x releases, but we know there's more that could be done. We'd love to get some help from folks knowledgable in Java and optimizing compiler design! 😀 My recommendation to you is to use workarounds like you have done here and don't expect things to immediately (or ever) become fully dereferenced if the current scope does not dereference them. Do the work with those references in a separate call (to a method or isolated proc) if you want to be sure the all references to the object have been cleared. If you might find it interesting, you can display our IR with the following JRuby flags:
|
Beta Was this translation helpful? Give feedback.
-
|
Thank you for this very thorough explanation. That completely explains the behavior I was seeing. Fortunately this should only affect the tests rather than production behavior :) In the end, it turns out that for JRuby, it is indeed sufficient to use a block for the test setup, e.g: def run
yield
end
weak_map = ObjectSpace::WeakMap.new
run do
obj = +"Hello World"
weak_map[obj.__id__] = obj
weak_map.size
end
garbage_collect_until { weak_map.size == 0 }
puts "weak_map is clear"Interestingly, for Ruby < 3.3 this then breaks again during my tests (but succeeds for Ruby 3.3+). I guess, I will just stick to creating a new thread for the test setup for all Rubies: https://github.com/meineerde/weak_set/blob/67ce754a544b2aa725a4681f8c1bfde614ab3016/spec/spec_helper.rb#L41-L63 |
Beta Was this translation helpful? Give feedback.
-
|
That makes sense. Any child scope like a block will be fully cleared when it exits and any temporary variables needed are limited to one scope. |
Beta Was this translation helpful? Give feedback.
-
|
I would be interested to know why Ruby < 3.3 is keeping references longer than it should. I suspect they may have been keeping references on the C stack longer than the lifetime of each call. |
Beta Was this translation helpful? Give feedback.
-
|
I'll have to further investigate this. The failures may have been caused by me running rspec expectations within the block which in turn may retain references on its own. With just the simple example code above, I can not reproduce the failures on Ruby 3.0/3.1 now... |
Beta Was this translation helpful? Give feedback.
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
-
Environment Information
Expected Behavior
While testing my WeakSet gem, it turned out that JRuby seems to hold on to object references in the current method when they should have been removed already. This prevents the unexpectedly referenced object from being garbage collected.
Generally, I would have expected the following behavior (which works in CRuby/MRI):
Afterwards, I would expect that the String object is garbage collected, even if the execution is still contained within the current method. It turns out that this is not the case.
Actual Behavior
Unfortunately, it turns out that on JRuby, the string is only garbage collected after leaving the scope where it was assigned to a variable. The following example shows this by using an
ObjectSpace::WeakMap.Consider the following "setup" for all the three examples below:
With that, the failing base-case for JRuby would be as follows. Note that this succeeds on CRuby/MRI, usually after just one loop in
garbage_collect_until. Interestingly, TruffleRuby appears to show the same behavior as JRuby here.In contrast, both of the following two example work on JRuby. This appears to indicate that these object references are cleanup up when leaving the (method or thread) scope.
Using a thread to set the value
Using a separate method
By fixing this issue, it may be possible to re-enable the WeakRef tests in
test/mri/excludes/TestWeakRef.rb (and by introducing Java-specific means to force garbage collection in the actual tests in test/mri/test_weakref.rb.
Beta Was this translation helpful? Give feedback.
All reactions