[ruby-cvs:69817] k0kubun:r62655 (trunk): mjit_compile.c: use local variables for stack

k0kubun at ruby-lang.org k0kubun at ruby-lang.org
Sun Mar 4 16:04:41 JST 2018


k0kubun	2018-03-04 16:04:40 +0900 (Sun, 04 Mar 2018)

  New Revision: 62655

  https://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=revision&revision=62655

  Log:
    mjit_compile.c: use local variables for stack
    
    if catch_except_p is FALSE. If catch_except_p is TRUE, stack values
    should be on VM's stack when exception is thrown and the JIT-ed frame
    is re-executed by VM's exception handler. If it's FALSE, the JIT-ed
    frame won't be re-executed and don't need to keep values on VM's stack.
    
    Using local variables allows us to reduce cfp->sp motion. Moving cfp->sp
    is needed only for insns whose handles_frame? is false. So it improves
    performance.
    
    _mjit_compile_insn.erb: Prepare `stack_size` variable for GET_SP,
    STACK_ADDR_FROM_TOP, TOPN macros. Share pc and sp motion partial view.
    Use cancel handler created in mjit_compile.c.
    
    _mjit_compile_send.erb: ditto. Also, when iseq->body->catch_except_p is
    TRUE, this stops to call mjit_exec directly. I described the reason in
    vm_insnhelper.h's comment for EXEC_EC_CFP.
    
    _mjit_compile_pc_and_sp.erb: Shared logic for moving sp and pc. As you
    can see from thsi file, when status->local_stack_p is TRUE and
    insn.handles_frame? is false, moving sp is skipped. But if
    insn.handles_frame? is true, values should be rolled back to VM's stack.
    common.mk: add dependency for the file
    
    _mjit_compile_insn_body.erb: Set sp value before canceling JIT on
    DISPATCH_ORIGINAL_INSN. Replace GET_SP, STACK_ADDR_FROM_TOP, TOPN macros
    for the case ocal_stack_p is TRUE and insn.handles_frame? is false.
    In that case, values are not available on VM's stack and those macros
    should be replaced.
    
    mjit_compile.inc.erb: updated comments of macros which are supported by
    JIT compiler. All references to `cfp->sp` should be replaced and thus
    INC_SP, SET_SV, PUSH are no longer supported for now, because they are
    not used now.
    
    vm_exec.h: moved EXEC_EC_CFP definition to vm_insnhelper.h because it's
    tighly coupled to CALL_METHOD.
    
    vm_insnhelper.h: Have revised EXEC_EC_CFP definition moved from vm_exec.h.
    Now it triggers mjit_exec for VM, and has the guard for catch_except_p
    on JIT-ed code. See comments for details. CALL_METHOD delegates
    triggering mjit_exec to EXEC_EC_CFP.
    
    insns.def: Stopped using EXEC_EC_CFP for the case we don't want to
    trigger mjit_exec. Those insns (defineclass, opt_call_c_function) are
    not supported by JIT and it's safe to use RESTORE_REGS(), NEXT_INSN().
    expandarray is changed to pass GET_SP() to replace the macro in
    _mjit_compile_insn_body.erb.
    
    vm_insnhelper.c: change to take sp for the above reason.
    
    [close https://github.com/ruby/ruby/pull/1828]
    
    This patch resurrects the performance which was attached in
    [Feature #14235].
    
    * Benchmark
    
    Optcarrot (with configuration for benchmark_driver.gem)
    https://github.com/benchmark-driver/optcarrot
    
    $ benchmark-driver benchmark.yml --verbose 1 --rbenv 'before;before+JIT::before,--jit;after;after+JIT::after,--jit' --repeat-count 10
    before: ruby 2.6.0dev (2018-03-04 trunk 62652) [x86_64-linux]
    before+JIT: ruby 2.6.0dev (2018-03-04 trunk 62652) +JIT [x86_64-linux]
    after: ruby 2.6.0dev (2018-03-04 local-variable.. 62652) [x86_64-linux]
    last_commit=mjit_compile.c: use local variables for stack
    after+JIT: ruby 2.6.0dev (2018-03-04 local-variable.. 62652) +JIT [x86_64-linux]
    last_commit=mjit_compile.c: use local variables for stack
    Calculating -------------------------------------
                             before  before+JIT       after   after+JIT
               optcarrot     53.552      59.680      53.697      63.358 fps
    
    Comparison:
                            optcarrot
               after+JIT:        63.4 fps
              before+JIT:        59.7 fps - 1.06x  slower
                   after:        53.7 fps - 1.18x  slower
                  before:        53.6 fps - 1.18x  slower

  Added files:
    trunk/tool/ruby_vm/views/_mjit_compile_pc_and_sp.erb
  Modified files:
    trunk/common.mk
    trunk/insns.def
    trunk/mjit_compile.c
    trunk/test/ruby/test_jit.rb
    trunk/tool/ruby_vm/views/_mjit_compile_insn.erb
    trunk/tool/ruby_vm/views/_mjit_compile_insn_body.erb
    trunk/tool/ruby_vm/views/_mjit_compile_send.erb
    trunk/tool/ruby_vm/views/mjit_compile.inc.erb
    trunk/vm_exec.h
    trunk/vm_insnhelper.c
    trunk/vm_insnhelper.h


More information about the ruby-cvs mailing list