Author: Maciej Fijalkowski <[email protected]>
Branch: optresult-unroll
Changeset: r79453:9cb5d0626cce
Date: 2015-09-05 12:27 +0200
http://bitbucket.org/pypy/pypy/changeset/9cb5d0626cce/
Log: improve on having consistent names of boxes in translated version
diff --git a/rpython/jit/metainterp/compile.py
b/rpython/jit/metainterp/compile.py
--- a/rpython/jit/metainterp/compile.py
+++ b/rpython/jit/metainterp/compile.py
@@ -24,6 +24,8 @@
raise SwitchToBlackhole(Counters.ABORT_BRIDGE)
class CompileData(object):
+ memo = None
+
def forget_optimization_info(self):
for arg in self.start_label.getarglist():
arg.set_forwarded(None)
@@ -54,7 +56,8 @@
opt = UnrollOptimizer(metainterp_sd, jitdriver_sd, optimizations)
return opt.optimize_preamble(self.start_label, self.end_label,
self.operations,
- self.call_pure_results)
+ self.call_pure_results,
+ self.box_names_memo)
else:
opt = Optimizer(metainterp_sd, jitdriver_sd, optimizations)
return opt.propagate_all_forward(self.start_label.getarglist(),
@@ -97,7 +100,8 @@
opt = UnrollOptimizer(metainterp_sd, jitdriver_sd, optimizations)
return opt.optimize_bridge(self.start_label, self.operations,
self.call_pure_results,
- self.inline_short_preamble)
+ self.inline_short_preamble,
+ self.box_names_memo)
class UnrolledLoopData(CompileData):
""" This represents label() ops jump with extra info that's from the
@@ -217,7 +221,7 @@
enable_opts=enable_opts)
try:
loop_info, ops = optimize_trace(metainterp_sd, jitdriver_sd,
- data)
+ metainterp.box_names_memo, data)
except InvalidLoop:
return None
loop = create_empty_loop(metainterp)
@@ -235,7 +239,7 @@
loop.check_consistency()
jitcell_token.target_tokens = [target_token]
send_loop_to_backend(greenkey, jitdriver_sd, metainterp_sd, loop, "loop",
- inputargs)
+ inputargs, metainterp.box_names_memo)
record_loop_or_bridge(metainterp_sd, loop)
return target_token
@@ -271,6 +275,7 @@
enable_opts=enable_opts)
try:
start_state, preamble_ops = optimize_trace(metainterp_sd, jitdriver_sd,
+ metainterp.box_names_memo,
preamble_data)
except InvalidLoop:
return None
@@ -285,6 +290,7 @@
enable_opts=enable_opts)
try:
loop_info, loop_ops = optimize_trace(metainterp_sd, jitdriver_sd,
+ metainterp.box_names_memo,
loop_data)
except InvalidLoop:
return None
@@ -307,14 +313,14 @@
assert isinstance(label_token, TargetToken)
if label_token.short_preamble:
metainterp_sd.logger_ops.log_short_preamble([],
- label_token.short_preamble)
+ label_token.short_preamble, metainterp.box_names_memo)
loop.operations = ([start_label] + preamble_ops + loop_info.extra_same_as +
[loop_info.label_op] + loop_ops)
if not we_are_translated():
loop.check_consistency()
jitcell_token.target_tokens = [start_descr] + jitcell_token.target_tokens
send_loop_to_backend(greenkey, jitdriver_sd, metainterp_sd, loop, "loop",
- inputargs)
+ inputargs, metainterp.box_names_memo)
record_loop_or_bridge(metainterp_sd, loop)
return start_descr
@@ -345,6 +351,7 @@
enable_opts=enable_opts)
try:
loop_info, loop_ops = optimize_trace(metainterp_sd, jitdriver_sd,
+ metainterp.box_names_memo,
loop_data)
except InvalidLoop:
# Fall back on jumping directly to preamble
@@ -355,6 +362,7 @@
inline_short_preamble=False)
try:
loop_info, loop_ops = optimize_trace(metainterp_sd, jitdriver_sd,
+ metainterp.box_names_memo,
loop_data)
except InvalidLoop:
return None
@@ -363,7 +371,7 @@
assert isinstance(label_token, TargetToken)
if label_token.short_preamble:
metainterp_sd.logger_ops.log_short_preamble([],
- label_token.short_preamble)
+ label_token.short_preamble, metainterp.box_names_memo)
loop = partial_trace
loop.original_jitcell_token = loop_jitcell_token
loop.operations = (loop.operations + loop_info.extra_same_as +
@@ -460,9 +468,9 @@
def do_compile_loop(jd_id, unique_id, metainterp_sd, inputargs, operations,
- looptoken, log=True, name=''):
+ looptoken, log=True, name='', memo=None):
metainterp_sd.logger_ops.log_loop(inputargs, operations, -2,
- 'compiling', name=name)
+ 'compiling', name=name, memo=memo)
return metainterp_sd.cpu.compile_loop(inputargs,
operations, looptoken,
jd_id=jd_id, unique_id=unique_id,
@@ -470,8 +478,9 @@
logger=metainterp_sd.logger_ops)
def do_compile_bridge(metainterp_sd, faildescr, inputargs, operations,
- original_loop_token, log=True):
- metainterp_sd.logger_ops.log_bridge(inputargs, operations, "compiling")
+ original_loop_token, log=True, memo=None):
+ metainterp_sd.logger_ops.log_bridge(inputargs, operations, "compiling",
+ memo=memo)
assert isinstance(faildescr, AbstractFailDescr)
return metainterp_sd.cpu.compile_bridge(faildescr, inputargs, operations,
original_loop_token, log=log,
@@ -486,7 +495,7 @@
item.reset_value()
def send_loop_to_backend(greenkey, jitdriver_sd, metainterp_sd, loop, type,
- orig_inpargs):
+ orig_inpargs, memo):
forget_optimization_info(loop.operations)
forget_optimization_info(loop.inputargs)
vinfo = jitdriver_sd.virtualizable_info
@@ -521,7 +530,8 @@
asminfo = do_compile_loop(jitdriver_sd.index, unique_id, metainterp_sd,
loop.inputargs,
operations, original_jitcell_token,
- name=loopname)
+ name=loopname,
+ memo=memo)
finally:
debug_stop("jit-backend")
metainterp_sd.profiler.end_backend()
@@ -545,7 +555,7 @@
metainterp_sd.warmrunnerdesc.memory_manager.keep_loop_alive(original_jitcell_token)
def send_bridge_to_backend(jitdriver_sd, metainterp_sd, faildescr, inputargs,
- operations, original_loop_token):
+ operations, original_loop_token, memo):
forget_optimization_info(operations)
forget_optimization_info(inputargs)
if not we_are_translated():
@@ -567,7 +577,7 @@
try:
asminfo = do_compile_bridge(metainterp_sd, faildescr, inputargs,
operations,
- original_loop_token)
+ original_loop_token, memo)
finally:
debug_stop("jit-backend")
metainterp_sd.profiler.end_backend()
@@ -583,7 +593,7 @@
else:
ops_offset = None
metainterp_sd.logger_ops.log_bridge(inputargs, operations, None, faildescr,
- ops_offset)
+ ops_offset, memo=memo)
#
#if metainterp_sd.warmrunnerdesc is not None: # for tests
# metainterp_sd.warmrunnerdesc.memory_manager.keep_loop_alive(
@@ -801,7 +811,8 @@
propagate_original_jitcell_token(new_loop)
send_bridge_to_backend(metainterp.jitdriver_sd, metainterp.staticdata,
self, inputargs, new_loop.operations,
- new_loop.original_jitcell_token)
+ new_loop.original_jitcell_token,
+ metainterp.box_names_memo)
def make_a_counter_per_value(self, guard_value_op):
assert guard_value_op.getopnum() == rop.GUARD_VALUE
@@ -991,7 +1002,7 @@
propagate_original_jitcell_token(new_loop)
send_loop_to_backend(self.original_greenkey, metainterp.jitdriver_sd,
metainterp_sd, new_loop, "entry bridge",
- orig_inputargs)
+ orig_inputargs, metainterp.box_names_memo)
# send the new_loop to warmspot.py, to be called directly the next time
jitdriver_sd.warmstate.attach_procedure_to_interp(
self.original_greenkey, jitcell_token)
@@ -1035,7 +1046,8 @@
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
- info, newops = optimize_trace(metainterp_sd, jitdriver_sd, data)
+ info, newops = optimize_trace(metainterp_sd, jitdriver_sd,
+ metainterp.box_names_memo, data)
except InvalidLoop:
debug_print("compile_new_bridge: got an InvalidLoop")
# XXX I am fairly convinced that optimize_bridge cannot actually raise
diff --git a/rpython/jit/metainterp/logger.py b/rpython/jit/metainterp/logger.py
--- a/rpython/jit/metainterp/logger.py
+++ b/rpython/jit/metainterp/logger.py
@@ -12,90 +12,103 @@
self.metainterp_sd = metainterp_sd
self.guard_number = guard_number
- def log_loop(self, inputargs, operations, number=0, type=None,
ops_offset=None, name=''):
+ def log_loop(self, inputargs, operations, number=0, type=None,
+ ops_offset=None, name='', memo=None):
if type is None:
debug_start("jit-log-noopt-loop")
debug_print("# Loop", number, '(%s)' % name, ":", "noopt",
"with", len(operations), "ops")
- logops = self._log_operations(inputargs, operations, ops_offset)
+ logops = self._log_operations(inputargs, operations, ops_offset,
+ memo)
debug_stop("jit-log-noopt-loop")
elif type == "rewritten":
debug_start("jit-log-rewritten-loop")
debug_print("# Loop", number, '(%s)' % name, ":", type,
"with", len(operations), "ops")
- logops = self._log_operations(inputargs, operations, ops_offset)
+ logops = self._log_operations(inputargs, operations, ops_offset,
+ memo)
debug_stop("jit-log-rewritten-loop")
elif number == -2:
debug_start("jit-log-compiling-loop")
- logops = self._log_operations(inputargs, operations, ops_offset)
+ logops = self._log_operations(inputargs, operations, ops_offset,
+ memo)
debug_stop("jit-log-compiling-loop")
else:
debug_start("jit-log-opt-loop")
debug_print("# Loop", number, '(%s)' % name, ":", type,
"with", len(operations), "ops")
- logops = self._log_operations(inputargs, operations, ops_offset)
+ logops = self._log_operations(inputargs, operations, ops_offset,
+ memo)
debug_stop("jit-log-opt-loop")
return logops
def log_bridge(self, inputargs, operations, extra=None,
- descr=None, ops_offset=None):
+ descr=None, ops_offset=None, memo=None):
if extra == "noopt":
debug_start("jit-log-noopt-bridge")
debug_print("# bridge out of Guard",
"0x%x" % compute_unique_id(descr),
"with", len(operations), "ops")
- logops = self._log_operations(inputargs, operations, ops_offset)
+ logops = self._log_operations(inputargs, operations, ops_offset,
+ memo)
debug_stop("jit-log-noopt-bridge")
elif extra == "rewritten":
debug_start("jit-log-rewritten-bridge")
debug_print("# bridge out of Guard",
"0x%x" % compute_unique_id(descr),
"with", len(operations), "ops")
- logops = self._log_operations(inputargs, operations, ops_offset)
+ logops = self._log_operations(inputargs, operations, ops_offset,
+ memo)
debug_stop("jit-log-rewritten-bridge")
elif extra == "compiling":
debug_start("jit-log-compiling-bridge")
- logops = self._log_operations(inputargs, operations, ops_offset)
+ logops = self._log_operations(inputargs, operations, ops_offset,
+ memo)
debug_stop("jit-log-compiling-bridge")
else:
debug_start("jit-log-opt-bridge")
debug_print("# bridge out of Guard",
"0x%x" % r_uint(compute_unique_id(descr)),
"with", len(operations), "ops")
- logops = self._log_operations(inputargs, operations, ops_offset)
+ logops = self._log_operations(inputargs, operations, ops_offset,
+ memo)
debug_stop("jit-log-opt-bridge")
return logops
- def log_short_preamble(self, inputargs, operations):
+ def log_short_preamble(self, inputargs, operations, memo=None):
debug_start("jit-log-short-preamble")
- logops = self._log_operations(inputargs, operations, ops_offset=None)
+ logops = self._log_operations(inputargs, operations, ops_offset=None,
+ memo=memo)
debug_stop("jit-log-short-preamble")
return logops
- def _log_operations(self, inputargs, operations, ops_offset):
+ def _log_operations(self, inputargs, operations, ops_offset, memo=None):
if not have_debug_prints():
return None
- logops = self._make_log_operations()
- logops._log_operations(inputargs, operations, ops_offset)
+ logops = self._make_log_operations(memo)
+ logops._log_operations(inputargs, operations, ops_offset, memo)
return logops
- def _make_log_operations(self):
- return LogOperations(self.metainterp_sd, self.guard_number)
+ def _make_log_operations(self, memo):
+ return LogOperations(self.metainterp_sd, self.guard_number, memo)
def repr_of_resop(self, op):
- return LogOperations(self.metainterp_sd,
self.guard_number).repr_of_resop(op)
+ # XXX fish the memo from somewhere
+ return LogOperations(self.metainterp_sd, self.guard_number,
+ None).repr_of_resop(op)
class LogOperations(object):
"""
- ResOperation logger. Each instance contains a memo giving numbers
- to boxes, and is typically used to log a single loop.
+ ResOperation logger.
"""
- def __init__(self, metainterp_sd, guard_number):
+ def __init__(self, metainterp_sd, guard_number, memo):
self.metainterp_sd = metainterp_sd
self.ts = metainterp_sd.cpu.ts
self.guard_number = guard_number
- self.memo = {}
+ if memo is None:
+ memo = {}
+ self.memo = memo
def repr_of_descr(self, descr):
return descr.repr_of_descr()
@@ -180,7 +193,8 @@
return s_offset + res + op.getopname() + '(' + args + ')' + fail_args
- def _log_operations(self, inputargs, operations, ops_offset=None):
+ def _log_operations(self, inputargs, operations, ops_offset=None,
+ memo=None):
if not have_debug_prints():
return
if ops_offset is None:
@@ -197,8 +211,8 @@
offset = ops_offset[None]
debug_print("+%d: --end of the loop--" % offset)
- def log_loop(self, loop):
- self._log_operations(loop.inputargs, loop.operations)
+ def log_loop(self, loop, memo=None):
+ self._log_operations(loop.inputargs, loop.operations, memo=memo)
def int_could_be_an_address(x):
if we_are_translated():
diff --git a/rpython/jit/metainterp/optimizeopt/__init__.py
b/rpython/jit/metainterp/optimizeopt/__init__.py
--- a/rpython/jit/metainterp/optimizeopt/__init__.py
+++ b/rpython/jit/metainterp/optimizeopt/__init__.py
@@ -46,14 +46,16 @@
return optimizations, unroll
-def optimize_trace(metainterp_sd, jitdriver_sd, compile_data):
+def optimize_trace(metainterp_sd, jitdriver_sd, memo, compile_data):
"""Optimize loop.operations to remove internal overheadish operations.
"""
debug_start("jit-optimize")
inputargs = compile_data.start_label.getarglist()
try:
metainterp_sd.logger_noopt.log_loop(inputargs,
- compile_data.operations)
+ compile_data.operations,
+ memo)
+ compile_data.box_names_memo = memo
optimizations, unroll = build_opt_chain(metainterp_sd,
compile_data.enable_opts)
return compile_data.optimize(metainterp_sd, jitdriver_sd,
diff --git a/rpython/jit/metainterp/optimizeopt/optimizer.py
b/rpython/jit/metainterp/optimizeopt/optimizer.py
--- a/rpython/jit/metainterp/optimizeopt/optimizer.py
+++ b/rpython/jit/metainterp/optimizeopt/optimizer.py
@@ -239,7 +239,6 @@
self.metainterp_sd = metainterp_sd
self.jitdriver_sd = jitdriver_sd
self.cpu = metainterp_sd.cpu
- self.logops = LogOperations(metainterp_sd, False)
self.interned_refs = self.cpu.ts.new_ref_dict()
self.interned_ints = {}
self.resumedata_memo = resume.ResumeDataLoopMemo(metainterp_sd)
diff --git a/rpython/jit/metainterp/optimizeopt/unroll.py
b/rpython/jit/metainterp/optimizeopt/unroll.py
--- a/rpython/jit/metainterp/optimizeopt/unroll.py
+++ b/rpython/jit/metainterp/optimizeopt/unroll.py
@@ -108,13 +108,14 @@
if check_newops:
assert not self.optimizer._newoperations
- def optimize_preamble(self, start_label, end_label, ops,
call_pure_results):
+ def optimize_preamble(self, start_label, end_label, ops, call_pure_results,
+ memo):
self._check_no_forwarding([[start_label, end_label], ops])
info, newops = self.optimizer.propagate_all_forward(
start_label.getarglist()[:], ops, call_pure_results, True,
flush=False)
exported_state = self.export_state(start_label, end_label.getarglist(),
- info.inputargs)
+ info.inputargs, memo)
exported_state.quasi_immutable_deps = info.quasi_immutable_deps
# we need to absolutely make sure that we've cleaned up all
# the optimization info
@@ -209,7 +210,7 @@
return label_vs
def optimize_bridge(self, start_label, operations, call_pure_results,
- inline_short_preamble):
+ inline_short_preamble, box_names_memo):
self._check_no_forwarding([start_label.getarglist(),
operations])
info, ops = self.optimizer.propagate_all_forward(
@@ -241,7 +242,7 @@
return self.jump_to_preamble(cell_token, jump_op, info)
exported_state = self.export_state(start_label,
operations[-1].getarglist(),
- info.inputargs)
+ info.inputargs, box_names_memo)
exported_state.quasi_immutable_deps =
self.optimizer.quasi_immutable_deps
self.optimizer._clean_optimization_info(self.optimizer._newoperations)
return exported_state, self.optimizer._newoperations
@@ -345,7 +346,8 @@
for op in short:
op.set_forwarded(None)
- def export_state(self, start_label, original_label_args,
renamed_inputargs):
+ def export_state(self, start_label, original_label_args, renamed_inputargs,
+ memo):
end_args = [self.optimizer.force_box_for_end_of_preamble(a)
for a in original_label_args]
self.optimizer.flush()
@@ -370,7 +372,7 @@
self.optimizer._clean_optimization_info(start_label.getarglist())
return ExportedState(label_args, end_args, virtual_state, infos,
short_boxes, renamed_inputargs,
- short_inputargs)
+ short_inputargs, memo)
def import_state(self, targetop, exported_state):
# the mapping between input args (from old label) and what we need
@@ -447,7 +449,7 @@
def __init__(self, end_args, next_iteration_args, virtual_state,
exported_infos, short_boxes, renamed_inputargs,
- short_inputargs):
+ short_inputargs, memo):
self.end_args = end_args
self.next_iteration_args = next_iteration_args
self.virtual_state = virtual_state
@@ -455,11 +457,10 @@
self.short_boxes = short_boxes
self.renamed_inputargs = renamed_inputargs
self.short_inputargs = short_inputargs
- self.dump()
+ self.dump(memo)
- def dump(self):
+ def dump(self, memo):
debug_start("jit-log-exported-state")
- memo = {}
debug_print("[" + ", ".join([x.repr_short(memo) for x in
self.next_iteration_args]) + "]")
for box in self.short_boxes:
debug_print(" " + box.repr(memo))
diff --git a/rpython/jit/metainterp/pyjitpl.py
b/rpython/jit/metainterp/pyjitpl.py
--- a/rpython/jit/metainterp/pyjitpl.py
+++ b/rpython/jit/metainterp/pyjitpl.py
@@ -1884,6 +1884,8 @@
self.call_ids = []
self.current_call_id = 0
+ self.box_names_memo = {}
+
def retrace_needed(self, trace, exported_state):
self.partial_trace = trace
self.retracing_from = len(self.history.operations) - 1
@@ -2206,11 +2208,11 @@
else:
greenkey = self.current_merge_points[0][0][:jd_sd.num_green_args]
self.staticdata.warmrunnerdesc.hooks.on_abort(reason,
- jd_sd.jitdriver,
- greenkey,
-
jd_sd.warmstate.get_location_str(greenkey),
-
self.staticdata.logger_ops._make_log_operations(),
-
self.history.operations)
+ jd_sd.jitdriver, greenkey,
+ jd_sd.warmstate.get_location_str(greenkey),
+ self.staticdata.logger_ops._make_log_operations(
+ self.box_names_memo),
+ self.history.operations)
self.staticdata.stats.aborted()
def blackhole_if_trace_too_long(self):
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
