Ruby » Ruby master

prelude: |

Const = 1

benchmark:

vm_const: |

j = Const

k = Const

loop_count: 30000000

$(tooldir)/ruby_vm/views/_mjit_compile_insn.erb $(tooldir)/ruby_vm/views/_mjit_compile_send.erb \

$(tooldir)/ruby_vm/views/_mjit_compile_ivar.erb \

$(tooldir)/ruby_vm/views/_mjit_compile_insn_body.erb $(tooldir)/ruby_vm/views/_mjit_compile_pc_and_sp.erb \

BUILTIN_RB_SRCS = \

$(srcdir)/ast.rb \

return TRUE;

}

/**

ruby insn object list -> raw instruction sequence

*/

}

/* [ TS_IVC | TS_ICVARC | TS_ISE | TS_IC ] */

case TS_IC: /* inline cache: constants */

case TS_ISE: /* inline storage entry: `once` insn */

case TS_ICVARC: /* inline cvar cache */

case TS_IVC: /* inline ivar cache */

}

generated_iseq[code_index + 1 + j] = (VALUE)ic;

break;

}

case TS_CALLDATA:

return COMPILE_OK;

}

static int

compile_const_prefix(rb_iseq_t *iseq, const NODE *const node,

LINK_ANCHOR *const pref, LINK_ANCHOR *const body)

static int

compile_colon2(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const NODE *const node, int popped)

{

if (rb_is_const_id(node->nd_mid)) {

/* constant */

ADD_INSN(ret, node, putnil);

}

}

}

}

else {

/* function call */

static int

compile_colon3(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const NODE *const node, int popped)

{

debugi("colon3#nd_mid", node->nd_mid);

/* add cache insn */

if (ISEQ_COMPILE_DATA(iseq)->option->inline_const_cache) {

}

if (popped) {

case NODE_CONST:{

debugi("nd_vid", node->nd_vid);

ADD_INSN1(ret, node, putobject, Qtrue);

ADD_INSN1(ret, node, getconstant, ID2SYM(node->nd_vid));

}

rb_str_concat(str, opobj_inspect(OPERAND_AT(iobj, j)));

break;

case TS_IC: /* inline cache */

case TS_IVC: /* inline ivar cache */

case TS_ICVARC: /* inline cvar cache */

case TS_ISE: /* inline storage entry */

break;

case TS_CALLDATA: /* we store these as call infos at compile time */

{

}

break;

case TS_IC:

}

break;

case TS_IVC: /* inline ivar cache */

case TS_CDHASH:

case TS_ISEQ:

case TS_VALUE:

case TS_CALLDATA: // ci is stored.

{

VALUE op = OPERAND_AT(iobj, j);

wv = (VALUE)ibf_dump_iseq(dump, (const rb_iseq_t *)op);

break;

case TS_IC:

case TS_ISE:

case TS_IVC:

case TS_ICVARC:

struct rb_iseq_constant_body *load_body = ISEQ_BODY(iseq);

struct rb_call_data *cd_entries = load_body->call_data;

iseq_bits_t * mark_offset_bits;

for (code_index=0; code_index<iseq_size;) {

/* opcode */

const VALUE insn = code[code_index] = ibf_load_small_value(load, &reading_pos);

const char *types = insn_op_types(insn);

int op_index;

break;

}

case TS_IC:

case TS_ISE:

case TS_ICVARC:

case TS_IVC:

ISE ic = ISEQ_IS_ENTRY_START(load_body, operand_type) + op;

code[code_index] = (VALUE)ic;

}

break;

case TS_CALLDATA:

vm_setclassvariable(GET_ISEQ(), GET_CFP(), id, val, ic);

}

/* Get constant variable id. If klass is Qnil and allow_nil is Qtrue, constants

are searched in the current scope. Otherwise, get constant under klass

class or module.

/* for optimize */

/**********************************************************/

/* run iseq only once */

DEFINE_INSN

once

}

}

}

}

}

// When an ISEQ is being freed, all of its associated ICs are going to go away

static void

iseq_clear_ic_references(const rb_iseq_t *iseq)

{

}

void

/* body->is_entries */

size += ISEQ_IS_SIZE(body) * sizeof(union iseq_inline_storage_entry);

/* body->call_data */

size += body->ci_size * sizeof(struct rb_call_data);

// TODO: should we count imemo_callinfo?

}

case TS_IC:

case TS_IVC:

case TS_ICVARC:

case TS_ISE:

}

break;

case TS_IC:

case TS_IVC:

case TS_ICVARC:

case TS_ISE:

int node_level;

int isolated_depth;

unsigned int ci_index;

const rb_compile_option_t *option;

struct rb_id_table *ivar_cache_table;

const struct rb_builtin_function *builtin_function_table;

end

def test_compile_insn_constant

begin;

FOO = 1

FOO

end;

end

end

def test_compile_insn_once

assert_compiles("'foo' =~ /(o)./; $2", insns: %i[getspecial], result: nil)

end

def get_foo

FOO

end

RUBY

end

class A

FOO = 42

class << self

% # JIT: Inline everything in IC, and cancel the slow path

fprintf(f, " if (vm_inlined_ic_hit_p(0x%"PRIxVALUE", 0x%"PRIxVALUE", (const rb_cref_t *)0x%"PRIxVALUE", reg_cfp->ep)) {", ice->flags, ice->value, (VALUE)ice->ic_cref);

fprintf(f, " stack[%d] = 0x%"PRIxVALUE";\n", b->stack_size, ice->value);

fprintf(f, " }");

fprintf(f, " else {");

fprintf(f, " reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size);

<%= render 'mjit_compile_ivar', locals: { insn: insn } -%>

% when 'invokebuiltin', 'opt_invokebuiltin_delegate'

<%= render 'mjit_compile_invokebuiltin', locals: { insn: insn } -%>

% when 'leave', 'opt_invokebuiltin_delegate_leave'

% # opt_invokebuiltin_delegate_leave also implements leave insn. We need to handle it here for inlining.

% if insn.name == 'opt_invokebuiltin_delegate_leave'

struct iseq_inline_constant_cache {

struct iseq_inline_constant_cache_entry *entry;

};

struct iseq_inline_iv_cache_entry {

#define ISEQ_IS_SIZE(body) (body->ic_size + body->ivc_size + body->ise_size + body->icvarc_size)

/* instruction sequence type */

enum rb_iseq_type {

ISEQ_TYPE_TOP,

}

}

static inline VALUE

vm_get_cvar_base(const rb_cref_t *cref, const rb_control_frame_t *cfp, int top_level_raise)

{

#define IMEMO_CONST_CACHE_SHAREABLE IMEMO_FL_USER0

{

}

}

static void

{

RB_VM_LOCK_ENTER();

}

RB_VM_LOCK_LEAVE();

}

}

static void

{

if (ruby_vm_const_missing_count > 0) {

ruby_vm_const_missing_count = 0;

#ifndef MJIT_HEADER

// MJIT and YJIT can't be on at the same time, so there is no need to

// notify YJIT about changes to the IC when running inside MJIT code.

#endif

}

void rb_yjit_iseq_update_references(void *payload);

void rb_yjit_iseq_free(void *payload);

void rb_yjit_before_ractor_spawn(void);

void rb_yjit_tracing_invalidate_all(void);

#else

static inline void rb_yjit_iseq_update_references(void *payload) {}

static inline void rb_yjit_iseq_free(void *payload) {}

static inline void rb_yjit_before_ractor_spawn(void) {}

static inline void rb_yjit_tracing_invalidate_all(void) {}

#endif // #if YJIT_BUILD

.try_into()

.unwrap();

jump_to_next_insn(&mut jit, &ctx, cb, ocb);

break;

}

KeepCompiling

}

jit: &mut JITState,

ctx: &mut Context,

cb: &mut CodeBlock,

ocb: &mut OutlinedCb,

) -> CodegenStatus {

let ic: *const iseq_inline_constant_cache = const_cache_as_value.as_ptr();

// See vm_ic_hit_p(). The same conditions are checked in yjit_constant_ic_update().

let ice = unsafe { (*ic).entry };

// Invalidate output code on any constant writes associated with

// constants referenced within the current block.

jit_putobject(jit, ctx, cb, unsafe { (*ice).value });

}

EndBlock

}

YARVINSN_opt_size => Some(gen_opt_size),

YARVINSN_opt_length => Some(gen_opt_length),

YARVINSN_opt_regexpmatch2 => Some(gen_opt_regexpmatch2),

YARVINSN_invokebuiltin => Some(gen_invokebuiltin),

YARVINSN_opt_invokebuiltin_delegate => Some(gen_opt_invokebuiltin_delegate),

YARVINSN_opt_invokebuiltin_delegate_leave => Some(gen_opt_invokebuiltin_delegate),

#[derive(Debug, Copy, Clone)]

pub struct iseq_inline_constant_cache {

pub entry: *mut iseq_inline_constant_cache_entry,

}

#[repr(C)]

#[derive(Debug, Copy, Clone)]

pub const YARVINSN_setinstancevariable: ruby_vminsn_type = 9;

pub const YARVINSN_getclassvariable: ruby_vminsn_type = 10;

pub const YARVINSN_setclassvariable: ruby_vminsn_type = 11;

pub const YARVINSN_trace_getconstant: ruby_vminsn_type = 113;

pub const YARVINSN_trace_setconstant: ruby_vminsn_type = 114;

pub const YARVINSN_trace_getglobal: ruby_vminsn_type = 115;

pub const YARVINSN_trace_branchif: ruby_vminsn_type = 162;

pub const YARVINSN_trace_branchunless: ruby_vminsn_type = 163;

pub const YARVINSN_trace_branchnil: ruby_vminsn_type = 164;

pub type ruby_vminsn_type = u32;

extern "C" {

pub fn rb_vm_insn_addr2opcode(addr: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int;

use std::collections::{HashMap, HashSet};

use std::mem;

// Invariants to track:

// assume_bop_not_redefined(jit, INTEGER_REDEFINED_OP_FLAG, BOP_PLUS)

/// subsequent opt_setinlinecache and find all of the name components that are

/// associated with this constant (which correspond to the getconstant

/// arguments).

/// Tracks that a block is assuming that the name component of a constant

/// has not changed since the last call to this function.

}

}

}

jit_ensure_block_entry_exit(jit, ocb);

}

/// Called when a basic operator is redefined. Note that all the blocks assuming

/// Invalidate the block for the matching opt_getinlinecache so it could regenerate code

/// using the new value in the constant cache.

#[no_mangle]

// If YJIT isn't enabled, do nothing

if !yjit_enabled_p() {

return;

with_vm_lock(src_loc!(), || {

let code = unsafe { get_iseq_body_iseq_encoded(iseq) };

// This should come from a running iseq, so direct threading translation

// should have been done

assert!(unsafe { FL_TEST(iseq.into(), VALUE(ISEQ_TRANSLATED as usize)) } != VALUE(0));

assert_eq!(

unsafe {

let translated_opcode: VALUE = opcode_pc.read();

rb_vm_insn_decode(translated_opcode)

},

);

// Find the matching opt_getinlinecache and invalidate all the blocks there

// RUBY_ASSERT(insn_op_type(BIN(opt_getinlinecache), 1) == TS_IC);

let ic_operand: IC = unsafe { ic_pc.read() }.as_mut_ptr();

if ic == ic_operand {

for block in take_version_list(BlockId {

iseq,

}) {

invalidate_block_version(&block);

incr_counter!(invalidate_constant_ic_fill);