Skip to content


Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Commits on Dec 24, 2014
  1. @brixen
Commits on Oct 17, 2014
  1. @brixen
Commits on Oct 2, 2014
  1. @brixen

    Added start of Rubinius::JIT.

    brixen authored
Commits on Aug 31, 2014
  1. @brixen

    Added Rubinius::Logger.

    brixen authored
  2. @brixen
Commits on Aug 22, 2014
  1. @ryoqun
Commits on Aug 31, 2013
  1. @dbussink

    Create global for encoding list

    dbussink authored
    This way we don't need a symbol lookup inside the path for symbol
    lookup. This would cause a deadlock with fixing some SymbolTable locking
Commits on Aug 23, 2013
  1. @dbussink
Commits on Jun 7, 2013
  1. @dbussink

    Revert "Generate global symbol names for primitives"

    dbussink authored
    This reverts commit e9d6f2a.
    This creates very long compile times for shared_state.cpp because of the
    large number of globals.
Commits on May 22, 2013
  1. @dbussink

    Introduce File::Stat as a primitive

    dbussink authored
    This was previously implemented using FFI which has some inherent
    performance problems. The problem is that FFI allocates the used struct
    for stat() using malloc and frees with free which causes heavy churn
    because of this.
    This could be aleviated by using GC managed memory for this, but
    combined with how FFI currently works that would mean either having to
    mature allocate the data or adding new FFI features for allowing a call
    to be made without going GC independent.
    Mature allocation isn't something we'd want for stat() calls since stat
    objects are a perfect example of objects that often only live very short
    and should be cleaned up quickly.
    Introducing both GC managed memory for FFI calls using structs and
    allowing FFI calls to be made without going GC independent so the
    managed memory doesn't move is a big change, so taking this approach for
    now is easier. We should revisit this if we improve FFI to make doing
    this with FFI easier / possible. Another tricky part about stat() is how
    it binds regarding 64 bit filesystems. It uses macro's for that if you
    compile your app, so we had to have helpers for this already.
    And now for the performance numbers of this change.
    === bin/rbx ===
               File.stat   286796.1 (±2.7%) i/s -    1447040 in   5.049272s
    === bin/rbx ===
               File.stat   722130.3 (±2.0%) i/s -    3633256 in   5.033514s
Commits on May 16, 2013
  1. @dbussink

    Introduce ConstantTable

    dbussink authored
    This is modelled after MethodTable and can be used to private constants
    can be added for 1.9 mode. This only replaces the uses of the
    LookupTable with the new MethodTable, it does not implement private
    constants yet.
Commits on Apr 30, 2013
  1. @dbussink

    Cleanup ConstantCache and remove ConstantCacheEntry

    dbussink authored
    We can use a single cache object, since the JIT now dereferences the
    pointer stored in the machine code so it can handle replacing constant
    cache objects.
  2. @dbussink

    Rename InlineCache to PolyInlineCache

    dbussink authored
    The original InlineCache now functions as the PolyInlineCache with 3
    entries at this point. We should investigate whether this is still the
    preferred number now that we have split out mono-morphic call sites into
    a separate object.
  3. @dbussink

    Extract call custom cache into separate object

    dbussink authored
    This extracts the call custom cache into a separate call site object.
    This also simplifies the logic of setting up the other call site types.
  4. @dbussink

    Introduce MonoInlineCache for monomorphic call sites

    dbussink authored
    This means the current InlineCache will changed to being the
    PolyInlineCache for cases of more than one receiver type.
  5. @dbussink

    Introduce CallSite object

    dbussink authored
    The CallSite is an abstract base class used for example for InlineCache.
    Future types of caches could inherit from CallSite as well, for example
    for a cache for respond_to?
Commits on Apr 29, 2013
  1. @dbussink

    Generate global symbol names for primitives

    dbussink authored
    Before the primitive hookup logic actually took around 0.2s on my system
    of the startup time. This was due to how the algorithm works, basically
    resulting in number of primitives squared symbol lookups.
    With generating these names like this, we remove the string to symbol
    lookup needed, resulting in 0.2s faster startup on my system.
Commits on Apr 16, 2013
  1. @dbussink

    Move InlineCache to be a GC'able object

    dbussink authored
    This allows for future access from Ruby land and for replacing caches on
    the fly with the new type hierarchy idea of different types of caches
    for different types of method calls / specific methods calls worth a
    specific cache.
Commits on Apr 2, 2013
  1. @dbussink

    Fix thread safety issue with constant caches

    dbussink authored
    The problem here is that for example the module the constant is scoped
    under can change, for example if code does something like this:
    If the target class here is variable, it would have to refer to
    different constants. The problem with the old strategy is that there is
    a race condition, because the contents of the cache can't be changed
    atomically. So "under" might have already been updated, while the
    referred value isn't or vice versa.
    This new strategy actually sets up a reference to a cache entry, much
    like how the inline cache works for method calls. When retrieving a
    value, it uses this cache object so things don't change while working
    with it. When the cache is invalid / needs to be updated, we allocate a
    new cache entry and replace the old one after making sure it's properly
    We also change the JIT to teach it about these new types of objects so
    we can use regular offsets, instead of working with global addresses
    like we did before.
  2. @dbussink

    Rename GlobalCacheEntry to ConstantCache

    dbussink authored
    These caches are specifically used for caching constants, so name them
    as such so it's more clear what they mean.
Commits on Feb 26, 2013
  1. @dbussink

    Create global constants for common encodings

    dbussink authored
    The lookup for these constants is a small improvement, but it was
    showing up in profiles as spending significant time in the lookuptable
    for these constants.
Commits on Feb 5, 2013
  1. @dbussink

    Add global symbol for to_ary

    dbussink authored
Commits on Feb 2, 2013
  1. @dbussink

    Setup Ruby side object for ThreadState

    dbussink authored
    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.
Commits on Dec 18, 2012
  1. @dbussink

    Setup specific allocators for String

    dbussink authored
    Right now the JIT can't handle super() calls yet. This let to the
    allocator for String to never be JIT'ted. For now we use these specific
    allocators. In the future we should teach the JIT about super() (at
    least for simple cases like this), so we can remove these specifics
    Also sets up Character like we setup the other internal VM classes.
Commits on Dec 5, 2012
  1. @brixen

    Added Rubinius::Mirror.

    brixen authored
Commits on Nov 25, 2012
  1. @dbussink
Commits on Aug 30, 2012
  1. @brixen
Commits on Jun 8, 2012
  1. @txus @dbussink

    Rename StaticScope to ConstantScope... EVERYWHERE

    txus authored dbussink committed
    StaticScope is (ehem, was) where constants were scoped to, so IMHO
    ConstantScope makes for a much better name :)
Commits on Mar 12, 2012
  1. @brixen
Commits on Dec 31, 2011
  1. @brixen

    Removed CharArray. Use ByteArray in String.

    brixen authored
    Initially, the thought was that a CharArray could encapsulate the idea of a
    vector of bytes and the interpretation of those bytes relative to a particular
    encoding scheme. However, in practice, the interpretation of those bytes is
    really encapsulated in String, which composes a ByteArray and an Encoding.
    Pushing the logic down into CharArray required delegating almost everything
    from String, which is a good indicator for a poor abstraction.
    One example in particular illustrates this: a ByteArray (and CharArray)
    contain a boundary-aligned number of bytes, the boundary being a machine word.
    The size of a ByteArray (CharArray) is always >= to the number of bytes needed
    for a String's data. Encoding operations need to operate on the precise number
    of bytes in the String's data because those extra bytes that pad to a boundary
    in a ByteArray would be misinterpreted in some Encodings.
    Essentially, the more Encoding-aware CharArray became, the more it was just a
    String under String. So we removed it.
Commits on Dec 27, 2011
  1. @wilson
Commits on Nov 29, 2011
  1. @evanphx

    Implement Rubinius::AtomicReference for atomic, well, references

    evanphx authored
    The primary operation used for threading is
    AtomicReference#compare_and_set, which uses the CPUs CAS operation.
Commits on Nov 21, 2011
  1. @dbussink
Commits on Nov 14, 2011
  1. @evanphx

    Code cleanup

    evanphx authored
Commits on Sep 1, 2011
  1. @evanphx
Something went wrong with that request. Please try again.