This allows for using this separate list for concurrent marking. The marking phase updates these marks, while allocations can still happen without overwriting existing data. After the GC phase is complete we copy over the marks during the final stop the world phase so that for new allocations the new list is used. This also adds a helper method that can be used to update the mark stack to make sure it updates any values and removes invalid ones. This can be used if we have to update the mark stack during concurrent GC. Introduces an additional argument for process_mark_stack so we can partially process the mark stack. This can be used so during concurrent GC we can yield and for example a young collection can happen.
Ruby 1.8.x uses the receiver of #binding as self in the binding. Kernel.eval("self") => Kernel Kernel.binding.eval("self") => Kernel eval("self") => main binding.eval("self") => main Ruby 1.9.x uses the current call context as self in the binding. Kernel.eval("self") => Kernel Kernel.binding.eval("self") => main # difference eval("self") => main binding.eval("self") => main In case when we execute binding where caller is Kernel, self of binding is 'Kernel' (this is valid for ruby 1.8). But for 1.9 self of binding when caller is Kernel should be self from current context. Kernel.binding.self == self # valid for ruby 1.9 Kernel.binding.self == Kernel # valid for ruby 1.8 When you call #eval method, binding is created dynamically and self of binding is in this case Kernel.
This is possible now because we initialize the inflated header with the current mark anyway so it's already set as in use then.
This ensures that we always see these as used. This does result in inflated header potentially surviving one GC cycle longer, but this is usually unlikely for objects that get inflated.
This ensures that if we create a new code resource after the object storing it is already marked, we don't clean it up accidentally. This can result in the code resource to be kept alive one more GC cycle in cases where it's immediately discarded, but this is an unlikely scenario with code resource objects.
This ensures that if we do concurrent marking, we don't see this invalid state at all when recompiling. The GC still sees valid objects then and there is no race condition here on the initialization.
This makes sure we don't go through the write barrier unneccessary if the given object hasn't moved.
This is not correct for the cases where we have concurrent marking active. We should always use the complete write barrier and not write short cuts in the calling code for this.
This ensures we only have one implementation for the write barrier. Before Object had it's own implementation and the write barrier itself as well. Also removes the aux barrier mechanism for now, since we don't need it. If we want / need it, we can introduce it again in the future.
Checks EOVERFLOW as well for retrying. This way we get correct timestamp even for times with bogus isdst under NetBSD. Skip the retry if tm_isdst is already 0. Restore original value of tm_isdst if retrying also fails. Handle this way both calls to mktime(), not just the last one.
The code in the method might end up calling code that GC's. This makes sure we update the data pointer for that case so we use the proper object.
This reverts commit ce64f74. This problem was actually in another location that the next commit fixes.