Project

General

Profile

Download (76.7 KB)

Feature #10423 » opt_str_lit-v4.patch

normalperson (Eric Wong), 10/24/2014 03:25 AM

View differences:

benchmark/bm_vm2_array_delete_lit.rb
ary = []
i = 0
while i<6_000_000 # while loop 2
i += 1
ary.delete("foo")
end
benchmark/bm_vm2_array_include_lit.rb
ary = []
i = 0
while i<6_000_000 # while loop 2
i += 1
ary.include?("foo")
end
benchmark/bm_vm2_hash_aref_lit.rb
h = { "foo" => nil }
i = 0
while i<6_000_000 # while loop 2
i += 1
h["foo"]
end
benchmark/bm_vm2_hash_aset_lit.rb
h = {}
i = 0
while i<6_000_000 # while loop 2
i += 1
h["foo"] = nil
end
benchmark/bm_vm2_hash_delete_lit.rb
h = {}
i = 0
while i<6_000_000 # while loop 2
i += 1
h.delete("foo")
end
benchmark/bm_vm2_set_include_lit.rb
require 'set'
set = Set.new
i = 0
while i<6_000_000 # while loop 2
i += 1
set.include?("foo")
end
benchmark/bm_vm2_str_delete.rb
str = ''
i = 0
while i<6_000_000 # while loop 2
i += 1
str.delete("foo")
end
benchmark/bm_vm2_str_eq1.rb
i = 0
foo = "literal"
while i<6_000_000 # benchmark loop 2
i += 1
foo == "literal"
end
benchmark/bm_vm2_str_eq2.rb
i = 0
foo = "literal"
while i<6_000_000 # benchmark loop 2
i += 1
"literal" == foo
end
benchmark/bm_vm2_str_eqq1.rb
i = 0
foo = "literal"
while i<6_000_000 # benchmark loop 2
i += 1
foo === "literal"
end
benchmark/bm_vm2_str_eqq2.rb
i = 0
foo = "literal"
while i<6_000_000 # benchmark loop 2
i += 1
"literal" === foo
end
benchmark/bm_vm2_str_fmt.rb
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
"%d" % i
end
benchmark/bm_vm2_str_gsub_bang_lit.rb
i = 0
str = ""
while i<6_000_000 # benchmark loop 2
i += 1
str.gsub!("nomatch", "")
end
benchmark/bm_vm2_str_gsub_bang_re.rb
i = 0
str = ""
while i<6_000_000 # benchmark loop 2
i += 1
str.gsub!(/a/, "")
end
benchmark/bm_vm2_str_gsub_re.rb
i = 0
str = ""
while i<6_000_000 # benchmark loop 2
i += 1
str.gsub(/a/, "")
end
benchmark/bm_vm2_str_plus1.rb
i = 0
foo = "a"
while i<6_000_000 # benchmark loop 2
i += 1
foo + "b"
end
benchmark/bm_vm2_str_plus2.rb
i = 0
foo = "a"
while i<6_000_000 # benchmark loop 2
i += 1
"b" + foo
end
benchmark/bm_vm2_str_tr_bang.rb
i = 0
str = "a"
while i<6_000_000 # benchmark loop 2
i += 1
str.tr!("a", "A")
str.tr!("A", "a")
end
benchmark/bm_vm2_strcat.rb
i = 0
str = ""
while i<6_000_000 # benchmark loop 2
i += 1
str << "const"
str.clear
end
common.mk
VM_CORE_H_INCLUDES = {$(VPATH)}vm_core.h {$(VPATH)}thread_$(THREAD_MODEL).h \
{$(VPATH)}node.h {$(VPATH)}method.h {$(VPATH)}ruby_atomic.h \
{$(VPATH)}vm_debug.h {$(VPATH)}id.h {$(VPATH)}thread_native.h \
$(CCAN_LIST_INCLUDES)
$(CCAN_LIST_INCLUDES) {$(VPATH)}opt_method.h
###
......
$(VM_CORE_H_INCLUDES) {$(VPATH)}vm_method.c {$(VPATH)}vm_eval.c \
{$(VPATH)}vm_insnhelper.c {$(VPATH)}vm_insnhelper.h {$(VPATH)}vm_exec.c \
{$(VPATH)}vm_exec.h {$(VPATH)}insns.def {$(VPATH)}vmtc.inc \
{$(VPATH)}vm.inc {$(VPATH)}insns.inc \
{$(VPATH)}vm.inc {$(VPATH)}insns.inc {$(VPATH)}opt_method.inc \
{$(VPATH)}internal.h {$(VPATH)}vm.h {$(VPATH)}constant.h \
$(PROBES_H_INCLUDES) {$(VPATH)}probes_helper.h {$(VPATH)}vm_opts.h
vm_dump.$(OBJEXT): {$(VPATH)}vm_dump.c $(RUBY_H_INCLUDES) \
......
insns: $(INSNS)
opt_method.h: $(srcdir)/tool/generic_erb.rb \
$(srcdir)/template/opt_method.h.tmpl \
$(srcdir)/defs/opt_method.def
$(ECHO) generating $@
$(Q) $(BASERUBY) $(srcdir)/tool/generic_erb.rb --output=$@ \
$(srcdir)/template/opt_method.h.tmpl
opt_method.inc: $(srcdir)/tool/generic_erb.rb \
$(srcdir)/template/opt_method.inc.tmpl \
$(srcdir)/defs/opt_method.def
$(ECHO) generating $@
$(Q) $(BASERUBY) $(srcdir)/tool/generic_erb.rb --output=$@ \
$(srcdir)/template/opt_method.inc.tmpl
id.h: $(srcdir)/tool/generic_erb.rb $(srcdir)/template/id.h.tmpl $(srcdir)/defs/id.def
$(ECHO) generating $@
$(Q) $(BASERUBY) $(srcdir)/tool/generic_erb.rb --output=$@ \
compile.c
return 0;
}
#define new_recvinfo_for_recv(iseq,str,mid,klass) \
new_recvinfo_for_recv_(iseq,str,OM_##mid##__##klass)
static VALUE
new_recvinfo_for_recv_(rb_iseq_t *iseq, VALUE str,
enum ruby_optimized_method om)
{
VALUE ri = rb_ary_new_from_args(2, str, INT2FIX(om));
hide_obj(ri);
iseq_add_mark_object(iseq, ri);
return ri;
}
#define new_recvinfo_for_arg(iseq,str,mid,klass,off) \
new_recvinfo_for_arg_((iseq),(str),(OM_##mid##__##klass),\
(OM_TMASK_##klass),(off))
static VALUE
new_recvinfo_for_arg_(rb_iseq_t *iseq, VALUE str,
enum ruby_optimized_method om,
VALUE tmask, int recv_off)
{
VALUE ri = rb_ary_new_from_args(4, str, INT2FIX(om),
tmask, INT2FIX(recv_off));
hide_obj(ri);
iseq_add_mark_object(iseq, ri);
return ri;
}
/* optimize allocation for: obj.method("literal string") */
static void
opt_str_lit_1(rb_iseq_t *iseq, VALUE str, rb_call_info_t *ci, INSN *list)
{
enum ruby_optimized_method om;
VALUE tmask;
VALUE ri;
int data_p = 0;
switch (ci->mid) {
#define C(mid,klass) \
case mid: \
om = OM_##mid##__##klass; \
tmask = OM_TMASK_##klass; \
break
C(idAREF, Hash);
C(idEq, String);
C(idNeq, String);
C(idLTLT, String);
C(idPLUS, String);
C(idEqq, String);
C(idDelete, Array_Hash_String);
C(idIncludeP, Array_Hash_String);
C(idMemberP, Hash);
C(idHas_keyP, Hash);
C(idKeyP, Hash);
C(idFetch, Hash); /* TODO: hash.fetch("lit") { ... } block */
C(idPack, Array);
C(idUnpack, String);
C(idSplit, String); /* TODO: str.split("lit", num) */
C(idJoin, Array);
C(idCount, String);
C(idChomp, String);
C(idChomp_bang, String);
C(idSqueeze, String);
C(idSqueeze_bang, String);
C(idDelete_bang, String);
C(idEncode, String);
C(idEncode_bang, String);
C(idForce_encoding, String);
C(idIndex, String); /* TODO: str.index("lit", num) */
C(idRindex, String);
C(idMatch, String);
C(idCasecmp, String);
C(idStart_withP, String);
C(idEnd_withP, String);
C(idPartition, String);
C(idRpartition, String);
#undef C
#define C(mid,klass) \
case mid: \
om = OM_##mid##__##klass; \
tmask = OM_TMASK_##klass; \
data_p = 1; \
break
/* opt_str_lit_data oddities, maybe this is not worth supporting */
C(idStrftime, Time);
#undef C
default: return;
}
list->insn_id = data_p ? BIN(opt_str_lit_data) : BIN(opt_str_lit_tmask);
ri = new_recvinfo_for_arg_(iseq, str, om, tmask, 0);
list->operands[0] = ri;
}
/*
* optimize common string calls which take one or two string literals:
* obj.method("lit 1", "lit 2")
* obj.method(any, "lit 2") # any may be regexp
*/
static void
opt_str_lit_2(rb_iseq_t *iseq, VALUE str, rb_call_info_t *ci, INSN *list)
{
INSN *piobj;
enum ruby_optimized_method om;
VALUE ri;
switch (ci->mid) {
#define C(mid) case mid: om = OM_##mid##__String; break
C(idSub);
C(idSub_bang);
C(idGsub);
C(idGsub_bang);
C(idTr);
C(idTr_bang);
C(idTr_s);
C(idTr_s_bang);
C(idInsert); /* String#insert(num, "lit") */
/* String#encode("dst", "src") */
C(idEncode);
C(idEncode_bang);
#undef C
default: return;
}
/*
* previous arg may be a string literal, too:
* foo.gsub!("from", "to")
* foo.tr!("from", "to")
* ..
*/
piobj = (INSN *)get_prev_insn(list);
if (piobj && piobj->insn_id == BIN(putstring)) {
VALUE pstr = piobj->operands[0];
VALUE pri = new_recvinfo_for_arg_(iseq, pstr, om, OM_TMASK_String, 0);
piobj->operands[0] = pri;
piobj->insn_id = BIN(opt_str_lit_tmask);
}
list->insn_id = BIN(opt_str_lit_tmask);
ri = new_recvinfo_for_arg_(iseq, str, om, OM_TMASK_String, 1);
list->operands[0] = ri;
}
static int
iseq_peephole_optimize(rb_iseq_t *iseq, LINK_ELEMENT *list, const int do_tailcallopt)
{
......
}
}
}
/* string literal optimizations */
if (iobj->insn_id == BIN(putstring)) {
INSN *niobj = (INSN *)get_next_insn((INSN *)list);
if (niobj && niobj->insn_id == BIN(send)) {
rb_call_info_t *ci = (rb_call_info_t *)niobj->operands[0];
if (!ci->blockiseq && !(ci->flag & ~VM_CALL_ARGS_SKIP_SETUP)) {
VALUE ri = Qfalse;
VALUE str = iobj->operands[0];
switch (ci->orig_argc) {
case 0:
/*
* optimize:
* "literal".freeze
* "literal".size
* "literal".length
*/
switch (ci->mid) {
case idFreeze:
ri = new_recvinfo_for_recv(iseq, str, idFreeze, String);
break;
case idSize:
ri = new_recvinfo_for_recv(iseq, str, idSize, String);
break;
case idLength:
ri = new_recvinfo_for_recv(iseq, str, idLength, String);
break;
}
if (ri != Qfalse) {
iobj->insn_id = BIN(opt_str_lit_recv);
iobj->operands[0] = ri;
}
break;
case 1:
opt_str_lit_1(iseq, str, ci, (INSN *)list);
break;
case 2:
opt_str_lit_2(iseq, str, ci, (INSN *)list);
break;
}
}
}
}
return COMPILE_OK;
}
......
return Qnil;
}
static enum ruby_optimized_method
opt_str_lit_recv_om(ID mid)
{
switch (mid) {
case idEq: return OM_idEq__String;
case idNeq: return OM_idNeq__String;
case idPLUS: return OM_idPLUS__String;
case idMULT: return OM_idMULT__String;
case idMOD: return OM_idMOD__String;
case idEqq: return OM_idEqq__String;
}
return OM_LAST_;
}
/**
compile each node
......
break;
}
case NODE_CALL:
/* optimization shortcut
* "literal".freeze -> opt_str_freeze("literal")
*/
if (node->nd_recv && nd_type(node->nd_recv) == NODE_STR &&
node->nd_mid == idFreeze && node->nd_args == NULL)
{
VALUE str = rb_fstring(node->nd_recv->nd_lit);
iseq_add_mark_object(iseq, str);
ADD_INSN1(ret, line, opt_str_freeze, str);
if (poped) {
ADD_INSN(ret, line, pop);
}
break;
}
/* optimization shortcut
* obj["literal"] -> opt_aref_with(obj, "literal")
*/
if (node->nd_mid == idAREF && !private_recv_p(node) && node->nd_args &&
nd_type(node->nd_args) == NODE_ARRAY && node->nd_args->nd_alen == 1 &&
nd_type(node->nd_args->nd_head) == NODE_STR)
{
VALUE str = rb_fstring(node->nd_args->nd_head->nd_lit);
node->nd_args->nd_head->nd_lit = str;
COMPILE(ret, "recv", node->nd_recv);
ADD_INSN2(ret, line, opt_aref_with,
new_callinfo(iseq, idAREF, 1, 0, 0), str);
if (poped) {
ADD_INSN(ret, line, pop);
}
break;
}
case NODE_FCALL:
case NODE_VCALL:{ /* VCALL: variable or call */
/*
......
#endif
/* receiver */
if (type == NODE_CALL) {
COMPILE(recv, "recv", node->nd_recv);
enum ruby_optimized_method om;
/*
* optimize:
* "string literal".method(...)
* "yoda" == other -> opt_str_lit("yoda").send(:==, other)
* "yoda" != other -> opt_str_lit("yoda").send(:!=, other)
* "str" + other -> opt_str_lit("str").send(:+, other)
* "str" * other -> opt_str_lit("str").send(:*, other)
* "fmt" % args -> opt_str_lit("str").send(:%, other)
* ...
*/
if (iseq->compile_data->option->peephole_optimization &&
((om = opt_str_lit_recv_om(mid)) != OM_LAST_) &&
!private_recv_p(node) &&
node->nd_recv && nd_type(node->nd_recv) == NODE_STR &&
node->nd_args && nd_type(node->nd_args) == NODE_ARRAY &&
node->nd_args->nd_alen == 1)
{
VALUE yoda = rb_fstring(node->nd_recv->nd_lit);
VALUE recv_info = new_recvinfo_for_recv_(iseq, yoda, om);
node->nd_recv->nd_lit = yoda;
ADD_INSN1(recv, line, opt_str_lit_recv, recv_info);
} else {
COMPILE(recv, "recv", node->nd_recv);
}
}
else if (type == NODE_FCALL || type == NODE_VCALL) {
ADD_CALL_RECEIVER(recv, line);
......
int asgnflag;
/* optimization shortcut
* obj["literal"] = value -> opt_aset_with(obj, "literal", value)
* obj["literal"] = val -> send(obj, :[]=, opt_str_lit("lit"), val)
* TODO: ideally this should be done inside iseq_peephole_optimize,
* but that would require a lot of scanning as the `val' (2nd arg)
* is of variable distance between the :putstring and :send insns
*/
if (node->nd_mid == idASET && !private_recv_p(node) && node->nd_args &&
if (iseq->compile_data->option->peephole_optimization &&
node->nd_mid == idASET && !private_recv_p(node) && node->nd_args &&
nd_type(node->nd_args) == NODE_ARRAY && node->nd_args->nd_alen == 2 &&
nd_type(node->nd_args->nd_head) == NODE_STR)
{
VALUE str = rb_fstring(node->nd_args->nd_head->nd_lit);
VALUE recv_info = new_recvinfo_for_arg(iseq, str, idASET, Hash, 0);
node->nd_args->nd_head->nd_lit = str;
iseq_add_mark_object(iseq, str);
if (!poped) {
ADD_INSN(ret, line, putnil);
}
COMPILE(ret, "recv", node->nd_recv);
ADD_INSN1(ret, line, opt_str_lit_tmask, recv_info);
COMPILE(ret, "value", node->nd_args->nd_next->nd_head);
if (!poped) {
ADD_INSN(ret, line, swap);
ADD_INSN1(ret, line, topn, INT2FIX(1));
ADD_INSN1(ret, line, setn, INT2FIX(3));
}
ADD_INSN2(ret, line, opt_aset_with,
new_callinfo(iseq, idASET, 2, 0, 0), str);
flag = VM_CALL_ARGS_SKIP_SETUP;
ADD_SEND_R(ret, line, node->nd_mid, 2, 0, INT2FIX(flag));
ADD_INSN(ret, line, pop);
break;
}
......
{
return GET_THREAD()->parse_in_eval < 0;
}
/*
* Live bytecode patch:
* - opt_str_lit(recv_info)
* + putstring(str) # str is recv_info[0]
*
* If allocation optimization fails at this call site once, assume it
* will fail in the future. This prevents performance regressions for
* things like #include? calls which may be used with unoptimized
* classes (Set,*DBM and many others) as well as optimized core classes
* (Array/Hash/String). Call sites which only use optimized core
* classes will never get here.
*/
void
rb_undo_opt_str_lit(rb_control_frame_t *cfp)
{
VALUE *insn = cfp->pc - insn_len(BIN(opt_str_lit_tmask));
#if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE
const void * const *table = rb_vm_get_insns_address_table();
assert(((VALUE)table[BIN(opt_str_lit_tmask)] == insn[0] ||
(VALUE)table[BIN(opt_str_lit_data)] == insn[0] ||
(VALUE)table[BIN(opt_str_lit_recv)] == insn[0]) &&
"mismatch");
insn[0] = (VALUE)table[BIN(putstring)];
#else
assert(((VALUE)BIN(opt_str_lit_tmask) == insn[0] ||
(VALUE)BIN(opt_str_lit_data) == insn[0] ||
(VALUE)BIN(opt_str_lit_recv) == insn[0]) &&
"mismatch");
insn[0] = (VALUE)BIN(putstring);
#endif
assert(insn_len(BIN(putstring)) == insn_len(BIN(opt_str_lit_tmask)));
assert(insn_len(BIN(putstring)) == insn_len(BIN(opt_str_lit_data)));
assert(insn_len(BIN(putstring)) == insn_len(BIN(opt_str_lit_recv)));
assert(T_ARRAY == BUILTIN_TYPE(insn[1]));
/* n.b.: recv_info remains marked */
insn[1] = RARRAY_AREF(insn[1], 0); /* recv_info[0] == str */
}
defs/id.def
core#hash_merge_ary
core#hash_merge_ptr
core#hash_merge_kwd
gsub
gsub!
sub
sub!
tr
tr!
tr_s
tr_s!
delete
delete!
include?
member?
has_key?
key?
fetch
count
chomp
chomp!
squeeze
squeeze!
strftime
pack
unpack
split
join
encode
encode!
force_encoding
index
rindex
match
casecmp
insert
start_with?
end_with?
partition
rpartition
]
class KeywordError < RuntimeError
......
token = "_#{token.gsub(/\W+/, '_')}"
else
token = token.sub(/\?/, 'P').sub(/\A[a-z]/) {$&.upcase}
token.sub!(/!\z/, "_bang")
token.sub!(/\A\$/, "_G_")
token.sub!(/\A@@/, "_C_")
token.sub!(/\A@/, "_I_")
defs/opt_method.def
# byte align the bitmap for now, maybe some arches do better with long or int
# we may also use a larger size (in the unlikely case) we need more than
# 7 optimized classes per mid. Currently this caps us to 256 optimized
# (mid, klass) combinations (tested with OM_SHIFT=4, giving us 64K)
OM_SHIFT = 3
OM_ALIGN = 1 << OM_SHIFT
OM_ALIGN_MASK = ~(OM_ALIGN - 1)
OPT_METHODS = [
%w(idPLUS Fixnum Float String Array),
%w(idMINUS Fixnum Float),
%w(idMULT Fixnum Float String),
%w(idDIV Fixnum Float),
%w(idMOD Fixnum Float String),
%w(idEq Fixnum Float String),
%w(idNeq Fixnum Float String),
# id, mask classes
[ 'idEqq', %w(Bignum Fixnum Float Symbol), *%w(String) ],
%w(idLT Fixnum Float),
%w(idLE Fixnum Float),
%w(idGT Fixnum Float),
%w(idGE Fixnum Float),
%w(idLTLT Array String),
%w(idAREF Array Hash),
%w(idASET Array Hash),
%w(idLength Array Hash String),
%w(idSize Array Hash String),
%w(idEmptyP Array Hash String),
%w(idSucc Fixnum String Time),
%w(idEqTilde Regexp String),
%w(idFreeze String),
%w(idGsub String),
%w(idGsub_bang String),
%w(idSub String),
%w(idSub_bang String),
%w(idTr String),
%w(idTr_bang String),
%w(idTr_s String),
%w(idTr_s_bang String),
[ "idDelete", %w(Array Hash String) ],
[ "idIncludeP", %w(Array Hash String) ],
%w(idMemberP Hash),
%w(idHas_keyP Hash),
%w(idKeyP Hash),
%w(idFetch Hash),
%w(idStrftime Time),
%w(idUnpack String),
%w(idPack Array),
%w(idSplit String),
%w(idJoin Array),
%w(idCount String),
%w(idChomp String),
%w(idChomp_bang String),
%w(idSqueeze String),
%w(idSqueeze_bang String),
%w(idDelete_bang String),
%w(idEncode String),
%w(idEncode_bang String),
%w(idForce_encoding String),
%w(idIndex String),
%w(idRindex String),
%w(idMatch String),
%w(idCasecmp String),
%w(idInsert String),
%w(idStart_withP String),
%w(idEnd_withP String),
%w(idPartition String),
%w(idRpartition String),
]
# for checking optimized classes,
# speeds up method definitions of non-core classes
def opt_classes
rv = {}
OPT_METHODS.each do |(_, *classes)|
classes.flatten.each { |c| rv[c] = true }
end
rv
end
def om(mid, klass)
if Array === klass
"OM_#{mid}__#{klass.join('_')}"
else
"OM_#{mid}__#{klass}"
end
end
IS_T_DATA = {
"Time" => true
}
insns.def
}
/**
@c optimize
@e put string val. string may be created depending on recv_info conditions
*/
DEFINE_INSN
opt_str_lit_tmask
(VALUE recv_info)
()
(VALUE val)
{
/*
* recv_info:
* 0 - str
* 1 - optimized method flag (OM_*)
* 2 - tmask (optimized receiver classes)
* 3 - stack offset (Fixint),
* -1 stack offset means receiver is the frozen string literal itself
*/
const VALUE *ri = RARRAY_CONST_PTR(recv_info);
enum ruby_optimized_method om = FIX2UINT(ri[1]);
int tmask = FIX2INT(ri[2]);
int n = FIX2INT(ri[3]);
VALUE recv;
val = ri[0]; /* hopefully, this is the only val assignment we need */
recv = n < 0 ? val : TOPN(n);
if (!SPECIAL_CONST_P(recv)) {
enum ruby_value_type btype = BUILTIN_TYPE(recv);
int rmask = 1 << btype;
if ((rmask & tmask) &&
(rb_opt_method_class(btype) == RBASIC_CLASS(recv))) {
if (rb_opt_method_is_mask(om)) {
if (rb_basic_mask_unredefined_p(om)) {
goto out_tmask; /* fast path */
}
}
... This diff was truncated because it exceeds the maximum size that can be displayed.
(1-1/2)