Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: rindex-offset-…
Commits on Jun 2, 2013
Commits on May 31, 2013
  1. @dbussink

    Use separate marks for tracking mark state

    dbussink authored
    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.
  2. @dbussink
  3. @dbussink

    Remove assertions that never trigger anyway

    dbussink authored
    These were either commented out, or I've never seen them being hit when
    investigating GC bugs. This removes them.
  4. @dbussink

    Merge pull request #2369 from LTe/piotr/binding

    dbussink authored
    Binding self context
  5. @LTe

    Different behavior of binding for 1.8 and 1.9

    LTe authored
    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.
  6. @dbussink

    Merge pull request #2368 from kachick/fix-module-alias_method_for_hoo…

    dbussink authored
    …king_method_added
    
    Module#alias_method should call {singleton_}method_added
  7. @dbussink

    Simplify inflated header setup by removing -1 state

    dbussink authored
    This is possible now because we initialize the inflated header with the
    current mark anyway so it's already set as in use then.
  8. @dbussink

    Simplify write barrier usage

    dbussink authored
  9. @dbussink
  10. @dbussink

    Remove unused detach flag

    dbussink authored
  11. @dbussink

    Initialize inflated header marks with current mark

    dbussink authored
    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.
  12. @dbussink

    We always create a code resource as marked initially

    dbussink authored
    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.
  13. @LTe

    Remove fail tags for bindng

    LTe authored
  14. @kachick
Commits on May 30, 2013
  1. @dbussink

    Set freed status before calling free()

    dbussink authored
    This way we don't have to store the value on stack.
  2. @dbussink
  3. @dbussink

    Don't use onig_data field for storing non managed results

    dbussink authored
    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.
  4. @dbussink

    Only call the setter for auto marking if the object changes

    dbussink authored
    This makes sure we don't go through the write barrier unneccessary if
    the given object hasn't moved.
  5. @dbussink

    Don't conditionalize write barrier with mature guard

    dbussink authored
    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.
  6. @dbussink

    Unify write barrier access

    dbussink authored
    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.
  7. @r-stu31 @dbussink

    Add a check for EOVERFLOW errno and adjust tm_isdst

    r-stu31 authored dbussink committed
    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.
  8. @kachick
  9. @kachick
  10. @kachick
  11. @kachick

    Fix Module#alias_method

    kachick authored
    It should return self instead of nil.
  12. @kachick
Commits on May 29, 2013
  1. @dbussink

    Merge pull request #2367 from timabdulla/change-atomicreference-initi…

    dbussink authored
    …alize
    
    Change AtomicReference#initialize to accept false
  2. @dbussink

    Mark data pointer as on stack before calling custom method

    dbussink authored
    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.
  3. @dbussink

    Revert "Update current finalizer if a GC is triggered"

    dbussink authored
    This reverts commit ce64f74.
    
    This problem was actually in another location that the next commit
    fixes.
  4. @dbussink
  5. @timabdulla
  6. @dbussink

    Sweep after unremembering objects

    dbussink authored
    This makes sure it works with the Immix GC debugging flag because
    otherwise the objects are already invalid in the unremember set.
  7. @dbussink

    Add debugging mode that clears memory to Immix

    dbussink authored
    This overwrites memory with all 1's in immix when a line is not used.
    This makes it easier to debug because objects will be seen as invalid
    later if they haven't been properly marked.
Something went wrong with that request. Please try again.