Skip to content
Commits on Feb 6, 2013
  1. @dbussink

    Implement rb_method_boundp

    dbussink committed Feb 6, 2013
    Fixes #1145
  2. @dbussink
  3. @jc00ke

    Merge pull request #2142 from ryoqun/proc-new-comment

    jc00ke committed Feb 5, 2013
     Add a comment to the assembly of Proc.new
  4. @brixen

    Fixed Kernel.chop[!].

    brixen committed Feb 5, 2013
  5. @brixen
  6. Remove trailing white space

    committed Feb 6, 2013
Commits on Feb 5, 2013
  1. @dbussink

    Setup pipe with proper default encodings

    dbussink committed Feb 5, 2013
    Fixes #2071
  2. @dbussink
  3. @dbussink
  4. @dbussink
  5. @dbussink
  6. @dbussink

    Add spec case for complex regexp with binary encoding

    dbussink committed Feb 5, 2013
    Taken from issue #1669
  7. @dbussink

    Add global symbol for to_ary

    dbussink committed Feb 5, 2013
  8. @dbussink

    Handle signals after pthread_cond_wait is interrupted

    dbussink committed Feb 5, 2013
    There might be signals that need to be run if pthread_cond_wait is
    interrupted. Fixes #2093
Commits on Feb 4, 2013
  1. @brixen
  2. @brixen
  3. @brixen
  4. @brixen

    Fixed Encoding::Converter#primitive_convert. Fixes #2139.

    brixen committed Feb 4, 2013
    The transcoders are restartable. Also removed the buffers for doing piece-wise
    conversions. The code had a latent GC bug in that at any ByteArray creation, a
    GC could occur and the Ruby objects on the stack (sourc, src, target) could move,
    leading to a segfault.
  5. @brixen

    Spec for round-trip encoding.

    brixen committed Feb 4, 2013
  6. @brixen
  7. @dbussink

    Exit LLVM thread when stop is set

    dbussink committed Feb 4, 2013
    When we are paused, a stop might be requested. This makes sure we check
    the stop_ and exit the thread if we have to. This prevents a deadlock /
    race for example if a just forked process exits immediately.
  8. @dbussink
  9. @dbussink

    Move static definition outside function call

    dbussink committed Feb 4, 2013
    Only in C++-03 this isn't defined as being thread safe, only in C++11.
    We should prefer using the style where we define these outside the
    functions so they are setup during load and not first execution of the
    function.
    
    For cases that we should not use static, we remove these so the
    functions are properly reentrant.
Commits on Feb 3, 2013
  1. @dbussink

    Remove peep hole optimization on JIT

    dbussink committed Feb 3, 2013
    This optimization was problematic, since it assumed the called block was
    unpacking the block. This logic wasn't properly handled in at least 1.9
    mode, so removing this for now so we can design for a better version of
    this.
    
    Running the specs for datamapper/dm-core in 1.9 mode exposed this:
    
    datamapper/dm-core@3cb3f05
  2. @warrenseen
  3. @warrenseen
  4. @warrenseen
Commits on Feb 2, 2013
  1. @dbussink

    Setup Ruby side object for ThreadState

    dbussink committed Feb 2, 2013
    For code that heavily uses ensure blocks, creating these thread state
    objects had quite a big overhead. We were abusing the Rubinius::Internal
    exception for this behavior and spend a lot of time for that code in
    symbol lookup for the instance variables.
    
    This solution removes the need for any symbol lookup and this also helps
    in concurrent scenarios since symbol lookup needs a lock around the
    symbol table.
  2. @dbussink
  3. @dbussink

    Fix additional deadlocks when trying to pause

    dbussink committed Feb 2, 2013
    The finalizer thread might have paused in a gc_dependent call so it
    might not be running. Therefore when we pause, if a thread state is not
    eRunning, we can also safely pause.
    
    This is safe because we also change to stop the world before trying to
    stop the auxiliary threads. This is also needed because other threads
    might actually be restarting stuff when they just did a fork after
    stopping auxiliary threads and before stopping all other threads.
    
    We also remove the gc_independent in the JIT, because it LLVM might have
    internal structures locked at that point and if we fork then, the new
    jit thread in the sub process can hang because of this locked thread.
Something went wrong with that request. Please try again.