Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Commits on Sep 11, 2012
  1. Fix description to make a sense.

    authored
Commits on Sep 10, 2012
  1. @dbussink
Commits on Sep 8, 2012
  1. Correct spelling mistake.

    Robert Gleeson authored
Commits on Sep 7, 2012
  1. @dbussink
  2. @dbussink

    Merge pull request #1891 from voxik/fix-rake-install

    dbussink authored
    Fix rake install
Commits on Sep 6, 2012
  1. @tonysidaway

    Accommodate iconv library versions that have function names of the fo…

    tonysidaway authored
    …rm libiconv_open, etc (OpenBSD)
  2. @tonysidaway
  3. @tonysidaway
Commits on Sep 5, 2012
  1. @dbussink
Commits on Sep 4, 2012
  1. @dbussink

    Fix File.read benchmark

    dbussink authored
  2. @dbussink
  3. @dbussink
  4. @dbussink
  5. @dbussink

    Support handling 64 bit timestamps on 32 bit machines

    dbussink authored
    This basically reimplements the logic in a way that I find much more
    understandable than the old code ported from MRI. This code is based on
    a combination of https://github.com/schwern/y2038 and the MRI source
    code, taking the most useful parts from both.
    
    Fixes #1842
Commits on Sep 3, 2012
  1. @ryoqun
  2. @dbussink

    Merge pull request #1884 from ryoqun/thread-join-deadlock

    dbussink authored
    Fix Thread#join deadlock from use of Thread#kill and sleep
Commits on Sep 2, 2012
  1. @ryoqun
  2. @ryoqun

    Fix timing issue of Thread#kill and sleep

    ryoqun authored
    In some cases, a thread isn't correctly killed by Thread#kill. If that is the
    case, Thread#join on that thread leads to the deadlock.
    
    Consider the following example:
    
        thread = Thread.new do
          sleep
        end
        thread.kill # actually, don't kill
        thread.join # thread lives forever; deadlock
    
    Thread#kill does 2 things to kill a thread:
        1. prepares the thread to be terminated and
        2. wakes up the thread.
    
    Most of time, the wake-up is executed after the sleep in the killed thread.
    
    However, it is possible the wake-up is executed BEFORE the sleep in some rare
    cases. If that is the case, the wake-up does nothing because the thread is
    still waking up at that time. Then, the thread begins to sleep forever. As a
    result, Thread#join never returns.
    
    To avoid such a deadlock, Thread#sleep must check to terminate or not before
    actually sleeping. In addition, it must be asssured that the wake-up isn't
    executed AFTER the check BEFORE the sleep.
    
    The follwing diagrams illustrate the good and bad timings.
    
    Good timings:
    
                     Time
                     ------------------------------------------------------>
        main thread  prepare - wakeup (no-op) |
        new thread                            | check - no sleep - terminate
    
                     Time
                     ------------------------------------------------------>
        main thread                | prepare - wake-up |
        new thread   check - sleep |                   | terminate
    
                     Time
                     ------------------------------------------------------>
        main thread        | prepare |       | wake-up |
        new thread   check |         | sleep |         | terminate
    
    Bad timing:
    
                     Time
                     ------------------------------------------------------>
        main thread        | prepare - wake-up (no-op) |
        new thread   check |                           | sleep forever
    
    To fix the deadlock, this commit makes check_async be called before sleeping
    inside the park mutex.
Commits on Aug 30, 2012
  1. @brixen
  2. @brixen

    Renamed VMMethod to MachineCode.

    brixen authored
    This was a difficult name choice but it is consistent with CompiledCode
    and (not yet used) SourceCode. The CompiledCode is an abstraction of
    computation that is the focal point around which much revolves. MachineCode
    is a representation of computation specialized for our (virtual) machine.
    
    While there is possible ambiguity against the idea of JIT'd machine code,
    our MachineCode is a proper data structure, not just the format of bits
    resulting from the JIT compilation process. Also, our MachineCode is properly
    scoped differently than any such class/concept in LLVM (or more generally,
    the JIT).
    
    Regarding naming of instances of MachineCode, the following rationale is used:
    
    * parameters/variables have been named 'mcode' since the use of the variable
      is elaborated by the surrounding code (ie making ambiguity less an issue)
      and long variable names can sometimes make code unweildy.
    * attributes/fields/accessors have been name 'machine_code' because they have
      less context to disambiguate.
  3. @dbussink

    Implement rb_iter_break()

    dbussink authored
  4. @dbussink

    Add specs for rb_iter_break

    dbussink authored
Commits on Aug 29, 2012
  1. @dbussink
  2. @dbussink
  3. @dbussink

    Add specs for rb_catch

    dbussink authored
  4. @dbussink
Commits on Aug 27, 2012
  1. @brixen

    Merge pull request #1879 from r-stu31/configure_flags

    brixen authored
    configure: add CPPFLAGS and LDFLAGS where missing
  2. @brixen
  3. @r-stu31
  4. @r-stu31

    Use CPPFLAGS and LDFLAGS when checking libraries, after all, they are…

    r-stu31 authored
    … also used afterwards for the real compilation and linking.
  5. @dbussink

    Merge pull request #1875 from LTe/random_range

    dbussink authored
    Random with range
Something went wrong with that request. Please try again.