Permalink
Switch branches/tags
Commits on Feb 11, 2013
  1. Fix Proc#to_s and Proc#inspect

    committed Feb 9, 2013
Commits on Feb 10, 2013
  1. Improve type checking for array and binding

    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.
    dbussink committed Feb 10, 2013
  2. Introduce fast path for nested constants

    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.
    dbussink committed Feb 10, 2013
  3. Setup intermediate attr_writer and attr_reader

    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.
    dbussink committed Feb 10, 2013
Commits on Feb 9, 2013
  1. Use packed ivar setting in inline accessor writers

    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.
    dbussink committed Feb 9, 2013
  2. Add JIT primitives for often used methods

    Creating a binding happens often in for example templating libraries
    where the binding is used for evaluating the template.
    dbussink committed Feb 9, 2013
Commits on Feb 8, 2013
  1. Allow JIT to run GC dependent

    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.
    dbussink committed Feb 8, 2013
Commits on Feb 7, 2013
  1. Add memory protection for young GC space

    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.
    dbussink committed Feb 7, 2013
  2. Fix GC issue when profiling

    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.
    dbussink committed Feb 7, 2013
  3. Setup String objects without the accessors

    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.
    dbussink committed Feb 7, 2013
  4. Merge pull request #2146 from ryoqun/remove-method-paren

    Remove empty parentheses from method definitions
    dbussink committed Feb 7, 2013
  5. Merge pull request #2143 from ryoqun/proc-subclass-new

    Don't duplicate Proc objects if not needed
    dbussink committed Feb 7, 2013
  6. Don't duplicate Proc objects if not needed

    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
    committed Feb 6, 2013
  7. Add failing tags

    committed Feb 6, 2013
  8. Spec ProcSubClass.new

    committed Feb 6, 2013
Commits on Feb 6, 2013
  1. Fix issue with invalid reading of byte size

    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.
    dbussink committed Feb 6, 2013
  2. Merge pull request #2145 from ryoqun/improve-bytecode-printer

    Improve bytecode printer
    dbussink committed Feb 6, 2013
  3. Merge pull request #2144 from ryoqun/print-bytecode-literals

    Always show actual literals in bytecode printer
    dbussink committed Feb 6, 2013
  4. Always show actual literals in bytecode printer

    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.
    committed Feb 6, 2013