ruby-changes:68718
From: Aaron <ko1@a...>
Date: Thu, 21 Oct 2021 08:12:33 +0900 (JST)
Subject: [ruby-changes:68718] d9176d9fca (master): Expose methods for inspecting Micro JIT code blocks
https://git.ruby-lang.org/ruby.git/commit/?id=d9176d9fca From d9176d9fca1af8750f9d8f97586e150d9261cc7f Mon Sep 17 00:00:00 2001 From: Aaron Patterson <tenderlove@r...> Date: Wed, 20 Jan 2021 10:50:13 -0800 Subject: Expose methods for inspecting Micro JIT code blocks This commit adds a module `UJIT`. The module allows you to insert the initial Micro JIT instruction in to an arbitrary iseq like this: ```ruby def foo(x) if x < 1 "less than one" else "something else" end end iseq = RubyVM::InstructionSequence.of(method(:foo)) UJIT.insert(iseq) # Add initial jump ``` After the initial jump is added, we can make Micro JIT do some work: ```ruby 100.times { foo(0) } ``` The `UJIT` module also exposes a method for finding all compiled blocks for a given iseq, like this: ```ruby blocks = UJIT.blocks_for(iseq) ``` We can sort the blocks by address and use the Crabstone gem (which is a wrapper around `capstone`) to disassemble the generated code. Here is the full code example: ```ruby def foo(x) if x < 1 "less than one" else "something else" end end iseq = RubyVM::InstructionSequence.of(method(:foo)) UJIT.insert(iseq) # Add initial jump 100.times { foo(0) } blocks = UJIT.blocks_for(iseq) # brew install capstone # gem install crabstone require "crabstone" cs = Crabstone::Disassembler.new(Crabstone::ARCH_X86, Crabstone::MODE_64) puts iseq.disasm blocks.sort_by(&:address).reverse.each do |block| puts "== ISEQ RANGE: #{block.iseq_start_index} -> #{block.iseq_end_index} ".ljust(80, "=") cs.disasm(block.code, 0).each do |i| printf( "\t0x%<address>x:\t%<instruction>s\t%<details>s\n", address: i.address, instruction: i.mnemonic, details: i.op_str ) end end ``` Here is the output: ``` $ ./ruby test.rb == disasm: #<ISeq:foo@t...:1 (1,0)-(7,3)> (catch: FALSE) local table (size: 1, argc: 1 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1]) [ 1] x@0<Arg> 0000 getlocal_WC_0 x@0 ( 2)[LiCa] 0002 putobject_INT2FIX_1_ 0003 opt_lt <calldata!mid:<, argc:1, ARGS_SIMPLE> 0005 branchunless 10 0007 putstring "less than one" ( 3)[Li] 0009 leave ( 7)[Re] 0010 putstring "something else" ( 5)[Li] 0012 leave ( 7)[Re] == ISEQ RANGE: 7 -> 7 ========================================================== 0x0: movabs rax, 0x7fcd014cd518 0xa: mov qword ptr [rdi], rax 0xd: mov r8, rax 0x10: mov r9, rax 0x13: mov r11, r12 0x16: jmp qword ptr [rax] == ISEQ RANGE: 0 -> 7 ========================================================== 0x0: mov rax, qword ptr [rdi + 0x20] 0x4: mov rax, qword ptr [rax - 0x18] 0x8: mov qword ptr [rdx], rax 0xb: mov qword ptr [rdx + 8], 3 0x13: movabs rax, 0x7fcd0180ac00 0x1d: test byte ptr [rax + 0x3e6], 1 0x24: jne 0x3ffe0da 0x2a: test byte ptr [rdx], 1 0x2d: je 0x3ffe0da 0x33: test byte ptr [rdx + 8], 1 0x37: je 0x3ffe0da 0x3d: mov rax, qword ptr [rdx] 0x40: cmp rax, qword ptr [rdx + 8] 0x44: movabs rax, 0 0x4e: movabs rcx, 0x14 0x58: cmovl rax, rcx 0x5c: mov qword ptr [rdx], rax 0x5f: test qword ptr [rdx], -9 0x66: je 0x3ffe111 0x6c: jmp 0xffffffffffffffa3 ``` --- ujit_iface.c | 102 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 102 insertions(+) diff --git a/ujit_iface.c b/ujit_iface.c index d759560cb6..412c3ace90 100644 --- a/ujit_iface.c +++ b/ujit_iface.c @@ -14,6 +14,17 @@ https://github.com/ruby/ruby/blob/trunk/ujit_iface.c#L14 #include "ujit_core.h" #include "ujit_hooks.inc" +VALUE cUjitBlock; + +extern st_table * version_tbl; +extern codeblock_t *cb; + +static const rb_data_type_t ujit_block_type = { + "UJIT/Block", + {0, 0, 0, }, + 0, 0, RUBY_TYPED_FREE_IMMEDIATELY +}; + bool rb_ujit_enabled; // Hash table of encoded instructions @@ -288,6 +299,87 @@ rb_ujit_compile_iseq(const rb_iseq_t *iseq) https://github.com/ruby/ruby/blob/trunk/ujit_iface.c#L299 #endif } +struct ujit_block_itr { + const rb_iseq_t *iseq; + VALUE list; +}; + +static int +iseqw_ujit_collect_blocks(st_data_t key, st_data_t value, st_data_t argp) +{ + block_t * block = (block_t *)value; + struct ujit_block_itr * itr = (struct ujit_block_itr *)argp; + + if (block->blockid.iseq == itr->iseq) { + VALUE rb_block = TypedData_Wrap_Struct(cUjitBlock, &ujit_block_type, block); + rb_ary_push(itr->list, rb_block); + } + return ST_CONTINUE; +} + +/* Get a list of the UJIT blocks associated with `rb_iseq` */ +static VALUE +ujit_blocks_for(VALUE mod, VALUE rb_iseq) +{ + const rb_iseq_t *iseq = rb_iseqw_to_iseq(rb_iseq); + st_table * vt = (st_table *)version_tbl; + struct ujit_block_itr itr; + itr.iseq = iseq; + itr.list = rb_ary_new(); + + rb_st_foreach(vt, iseqw_ujit_collect_blocks, (st_data_t)&itr); + + return itr.list; +} + +static VALUE +ujit_insert(VALUE mod, VALUE iseq) +{ + rb_ujit_compile_iseq(rb_iseqw_to_iseq(iseq)); + return iseq; +} + +/* Get the address of the UJIT::Block */ +static VALUE +block_address(VALUE self) +{ + block_t * block; + TypedData_Get_Struct(self, block_t, &ujit_block_type, block); + return LONG2NUM((intptr_t)block); +} + +/* Get the machine code for UJIT::Block as a binary string */ +static VALUE +block_code(VALUE self) +{ + block_t * block; + TypedData_Get_Struct(self, block_t, &ujit_block_type, block); + + return rb_str_new(cb->mem_block + block->start_pos, block->end_pos - block->start_pos); +} + +/* Get the start index in the Instruction Sequence that corresponds to this + * UJIT::Block */ +static VALUE +iseq_start_index(VALUE self) +{ + block_t * block; + TypedData_Get_Struct(self, block_t, &ujit_block_type, block); + + return INT2NUM(block->blockid.idx); +} + +/* Get the end index in the Instruction Sequence that corresponds to this + * UJIT::Block */ +static VALUE +iseq_end_index(VALUE self) +{ + block_t * block; + TypedData_Get_Struct(self, block_t, &ujit_block_type, block); + + return INT2NUM(block->end_idx); +} + void rb_ujit_init(void) { @@ -301,6 +393,16 @@ rb_ujit_init(void) https://github.com/ruby/ruby/blob/trunk/ujit_iface.c#L393 ujit_init_core(); ujit_init_codegen(); + VALUE mUjit = rb_define_module("UJIT"); + rb_define_module_function(mUjit, "install_entry", ujit_insert, 1); + rb_define_module_function(mUjit, "blocks_for", ujit_blocks_for, 1); + + cUjitBlock = rb_define_class_under(mUjit, "Block", rb_cObject); + rb_define_method(cUjitBlock, "address", block_address, 0); + rb_define_method(cUjitBlock, "code", block_code, 0); + rb_define_method(cUjitBlock, "iseq_start_index", iseq_start_index, 0); + rb_define_method(cUjitBlock, "iseq_end_index", iseq_end_index, 0); + // Initialize the GC hooks method_lookup_dependency = st_init_numtable(); struct ujit_root_struct *root; -- cgit v1.2.1 -- ML: ruby-changes@q... Info: http://www.atdot.net/~ko1/quickml/