Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Branch: proc-bound-met…
Commits on Feb 11, 2013
  1. Fix Proc#to_s and Proc#inspect

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

    Improve type checking for array and binding

    dbussink authored
    Checking respond_to? is relatively expensive, so when we don't have to
    coerce a type anyway, we shouldn't have to check for it.
  4. @dbussink
  5. @dbussink

    Introduce fast path for nested constants

    dbussink authored
    We didn't have caching for constant lookup for nested constants, such as
    Rubinius::VariableScope. This means that when a constants was referenced
    in that way, it would not cache the VariableScope constant.
    
    This commit introduces a constant cache very similar to not nested
    constants. It also stores the scope it was used under, so we can
    properly validate the have the correct constant. Also specialization is
    added to the JIT to have a fast path for these cached constants if they
    are still valid.
  6. @dbussink

    Setup intermediate attr_writer and attr_reader

    dbussink authored
    This ensures that classes loaded in kernel/common such as Binding also
    properly track the ivars for attr_* methods. Before Binding didn't get
    the proper optimized memory layout, significantly affecting performance
    of create a binding.
Commits on Feb 9, 2013
  1. @dbussink

    Use packed ivar setting in inline accessor writers

    dbussink authored
    This can use the fast path if the instance variable is a packed ivar and
    is writter with an attr_writer. This also uses the typed check for slots
    like set_ivar does so it properly fails when a wrong type is set.
  2. @dbussink

    Add JIT primitives for often used methods

    dbussink authored
    Creating a binding happens often in for example templating libraries
    where the binding is used for evaluating the template.
Commits on Feb 8, 2013
  1. @dbussink
  2. @dbussink

    Allow JIT to run GC dependent

    dbussink authored
    This also makes sure that when we fork, we stop at a safe point to do
    this. Otherwise we might fork in the middle of generating JIT code,
    putting LLVM in a state that can cause problems, for example if it holds
    locks internally.
Commits on Feb 7, 2013
  1. @dbussink

    Add memory protection for young GC space

    dbussink authored
    Using mprotect we can guard the memory spaces that shouldn't be used
    during normal runtime by the mutator threads. By guarding this with
    mprotect, we make sure that if we even do this, we crash immediately so
    the problem is a lot easier to debug.
  2. @dbussink

    Fix GC issue when profiling

    dbussink authored
    We need to guard these objects on the stack when we profile. This is
    because the profiler should see them properly. When we GC in a
    checkpoint we have to make sure to update the references for the
    profiler.
  3. @dbussink

    Setup String objects without the accessors

    dbussink authored
    This is safe to do here since we don't setup any Ruby objects, but only
    immediates. This prevents a lot of calls into update_handle, since that
    is done for the attributes of a String. In systems allocated a lot of
    String objects, this shows up as significant in profiles.
  4. @dbussink

    Merge pull request #2146 from ryoqun/remove-method-paren

    dbussink authored
    Remove empty parentheses from method definitions
  5. @dbussink

    Merge pull request #2143 from ryoqun/proc-subclass-new

    dbussink authored
    Don't duplicate Proc objects if not needed
  6. Don't duplicate Proc objects if not needed

    authored
    Currently, when its receiver is a subclass of Proc, Proc::from_env() duplicates
    passed objects, even if not needed. The case is that passing instances of the
    same subclass of Proc:
    
        class MyProc < Proc
        end
        prc = Proc.new{}
        my_prc = MyProc.new(&prc)
        # => returns an instance of MyProc duplicated from prc
        MyProc.new(&my_prc)
        # => SHOULD return my_prc, but DOESN'T, rather DOES duplicate my_prc
        Proc.new(&prc)
        # => returns prc, by comparison
    
    The problem is that there is unintended code path in which the needless
    duplication can happen.
    
    Thus, the duplication logic is moved from Proc::from_env() into the ruby code
    of Proc.new and a new primitive called proc_duplicate_as_subclass.
    
    Also revert no longer valid changes done in the following commit, which
    originally tried to fix this:
    
    1abfbdf
    Make Proc::from_env reset klass if appropriate
  7. Add failing tags

    authored
  8. Spec ProcSubClass.new

    authored
Commits on Feb 6, 2013
  1. @dbussink

    Fix issue with invalid reading of byte size

    dbussink authored
    The buffer isn't marked on stack and doesn't need to be since we copy
    data. This does mean however, we shouldn't read from it after we have
    possibly gc'ed. By storing the buffer size at the beginning we ensure we
    don't need to read it later.
  2. @dbussink

    Merge pull request #2145 from ryoqun/improve-bytecode-printer

    dbussink authored
    Improve bytecode printer
  3. @dbussink
  4. @dbussink
  5. @dbussink

    Merge pull request #2144 from ryoqun/print-bytecode-literals

    dbussink authored
    Always show actual literals in bytecode printer
  6. Always show actual literals in bytecode printer

    authored
    Currently the keyword "literal" is used inconsistently across the bytecode
    instructions. For example, push_const uses it, but set_const doesn't.
    
    Always use "literal" to indicate the index to literals. And this enables
    Rubinius' built-in bytecode printer to show the actual literals referenced by
    the index.
    
    This would really ease my life when hacking on Rubinus, hopefully others
    starting to hack on it.
Something went wrong with that request. Please try again.