Author: fijal
Branch: jit-leaner-frontend
Changeset: r82846:19da356e7036
Date: 2016-03-07 17:15 +0200
http://bitbucket.org/pypy/pypy/changeset/19da356e7036/
Log: start fighting with unrolling, make most of the tests pass in
test_optimizeopt by simplifying what CompileData stores
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
@@ -29,11 +29,8 @@
memo = None
def forget_optimization_info(self):
- return # no longer necessary?
- for arg in self.start_label.getarglist():
+ for arg in self.trace.inputargs:
arg.set_forwarded(None)
- for op in self.operations:
- op.set_forwarded(None)
class LoopCompileData(CompileData):
""" An object that accumulates all of the necessary info for
@@ -41,13 +38,8 @@
This is the case of label() ops label()
"""
- def __init__(self, start_label, end_label, trace,
- call_pure_results=None, enable_opts=None):
- self.start_label = start_label
- self.end_label = end_label
+ def __init__(self, trace, call_pure_results=None, enable_opts=None):
self.enable_opts = enable_opts
- assert start_label.getopnum() == rop.LABEL
- assert end_label.getopnum() == rop.LABEL
self.trace = trace
self.call_pure_results = call_pure_results
@@ -57,22 +49,19 @@
if unroll:
opt = UnrollOptimizer(metainterp_sd, jitdriver_sd, optimizations)
- return opt.optimize_preamble(self.start_label, self.end_label,
- self.trace,
+ return opt.optimize_preamble(self.trace,
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(),
- self.trace, self.call_pure_results)
+ return opt.propagate_all_forward(self.trace,
self.call_pure_results)
class SimpleCompileData(CompileData):
""" This represents label() ops jump with no extra info associated with
the label
"""
- def __init__(self, start_label, trace, call_pure_results=None,
+ def __init__(self, trace, call_pure_results=None,
enable_opts=None):
- self.start_label = start_label
self.trace = trace
self.call_pure_results = call_pure_results
self.enable_opts = enable_opts
@@ -82,7 +71,8 @@
#assert not unroll
opt = Optimizer(metainterp_sd, jitdriver_sd, optimizations)
- return opt.propagate_all_forward(self.trace, self.call_pure_results)
+ return opt.propagate_all_forward(self.trace.get_iter(),
+ self.call_pure_results)
class BridgeCompileData(CompileData):
""" This represents ops() with a jump at the end that goes to some
@@ -109,12 +99,11 @@
""" This represents label() ops jump with extra info that's from the
run of LoopCompileData. Jump goes to the same label
"""
- def __init__(self, start_label, end_jump, operations, state,
+ def __init__(self, trace, celltoken, state,
call_pure_results=None, enable_opts=None,
inline_short_preamble=True):
- self.start_label = start_label
- self.end_jump = end_jump
- self.operations = operations
+ self.trace = trace
+ self.celltoken = celltoken
self.enable_opts = enable_opts
self.state = state
self.call_pure_results = call_pure_results
@@ -125,9 +114,8 @@
assert unroll # we should not be here if it's disabled
opt = UnrollOptimizer(metainterp_sd, jitdriver_sd, optimizations)
- return opt.optimize_peeled_loop(self.start_label, self.end_jump,
- self.operations, self.state, self.call_pure_results,
- self.inline_short_preamble)
+ return opt.optimize_peeled_loop(self.trace, self.celltoken, self.state,
+ self.call_pure_results, self.inline_short_preamble)
def show_procedures(metainterp_sd, procedure=None, error=None):
# debugging
diff --git a/rpython/jit/metainterp/opencoder.py
b/rpython/jit/metainterp/opencoder.py
--- a/rpython/jit/metainterp/opencoder.py
+++ b/rpython/jit/metainterp/opencoder.py
@@ -61,6 +61,7 @@
self.trace = trace
self.inputargs = [rop.inputarg_from_tp(arg.type) for
arg in self.trace.inputargs]
+ self.start = 0
self.pos = 0
self._count = 0
self.end = end
diff --git a/rpython/jit/metainterp/optimizeopt/info.py
b/rpython/jit/metainterp/optimizeopt/info.py
--- a/rpython/jit/metainterp/optimizeopt/info.py
+++ b/rpython/jit/metainterp/optimizeopt/info.py
@@ -326,17 +326,17 @@
def make_guards(self, op, short, optimizer):
if self._known_class is not None:
- short.append(ResOperation(rop.GUARD_NONNULL, [op], None))
+ short.append(ResOperation(rop.GUARD_NONNULL, [op]))
if not optimizer.cpu.remove_gctypeptr:
- short.append(ResOperation(rop.GUARD_IS_OBJECT, [op], None))
+ short.append(ResOperation(rop.GUARD_IS_OBJECT, [op]))
short.append(ResOperation(rop.GUARD_CLASS,
- [op, self._known_class], None))
+ [op, self._known_class]))
elif self.descr is not None:
- short.append(ResOperation(rop.GUARD_NONNULL, [op], None))
+ short.append(ResOperation(rop.GUARD_NONNULL, [op]))
if not optimizer.cpu.remove_gctypeptr:
- short.append(ResOperation(rop.GUARD_IS_OBJECT, [op], None))
+ short.append(ResOperation(rop.GUARD_IS_OBJECT, [op]))
short.append(ResOperation(rop.GUARD_SUBCLASS, [op,
- ConstInt(self.descr.get_vtable())], None))
+ ConstInt(self.descr.get_vtable())]))
else:
AbstractStructPtrInfo.make_guards(self, op, short, optimizer)
@@ -349,8 +349,8 @@
if self.descr is not None:
c_typeid = ConstInt(self.descr.get_type_id())
short.extend([
- ResOperation(rop.GUARD_NONNULL, [op], None),
- ResOperation(rop.GUARD_GC_TYPE, [op, c_typeid], None)
+ ResOperation(rop.GUARD_NONNULL, [op]),
+ ResOperation(rop.GUARD_GC_TYPE, [op, c_typeid])
])
@specialize.argtype(1)
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
@@ -25,9 +25,9 @@
pass
class BasicLoopInfo(LoopInfo):
- def __init__(self, inputargs, quasi_immutable_deps):
+ def __init__(self, inputargs, quasi_immutable_deps, jump_op):
self.inputargs = inputargs
- self.label_op = ResOperation(rop.LABEL, inputargs, -1)
+ self.jump_op = jump_op
self.quasi_immutable_deps = quasi_immutable_deps
self.extra_same_as = []
@@ -506,7 +506,6 @@
return CONST_0
def propagate_all_forward(self, trace, call_pure_results=None, flush=True):
- trace = trace.get_iter()
self.trace = trace
self.call_pure_results = call_pure_results
last_op = None
@@ -522,11 +521,11 @@
# accumulate counters
if flush:
self.flush()
- if last_op:
- self.first_optimization.propagate_forward(last_op)
+ if last_op:
+ self.first_optimization.propagate_forward(last_op)
self.resumedata_memo.update_counters(self.metainterp_sd.profiler)
- return (BasicLoopInfo(trace.inputargs, self.quasi_immutable_deps),
+ return (BasicLoopInfo(trace.inputargs, self.quasi_immutable_deps,
last_op),
self._newoperations)
def _clean_optimization_info(self, lst):
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
b/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
@@ -24,15 +24,13 @@
def optimize_loop(self, ops, optops, call_pure_results=None):
loop = self.parse(ops)
token = JitCellToken()
- label_op = ResOperation(rop.LABEL, loop.inputargs, -1,
- descr=TargetToken(token))
if loop.operations[-1].getopnum() == rop.JUMP:
loop.operations[-1].setdescr(token)
exp = parse(optops, namespace=self.namespace.copy())
expected = convert_old_style_to_targets(exp, jump=True)
call_pure_results = self._convert_call_pure_results(call_pure_results)
trace = self.convert_loop_to_packed(loop)
- compile_data = compile.SimpleCompileData(label_op, trace,
+ compile_data = compile.SimpleCompileData(trace,
call_pure_results)
info, ops = self._do_optimize_loop(compile_data)
label_op = ResOperation(rop.LABEL, info.inputargs, -1)
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_util.py
b/rpython/jit/metainterp/optimizeopt/test/test_util.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_util.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_util.py
@@ -574,19 +574,18 @@
self.add_guard_future_condition(loop)
jump_op = loop.operations[-1]
assert jump_op.getopnum() == rop.JUMP
- jump_op.setdescr(JitCellToken())
- start_label = ResOperation(rop.LABEL, loop.inputargs,
- descr=jump_op.getdescr())
- end_label = jump_op.copy_and_change(opnum=rop.LABEL)
+ celltoken = JitCellToken()
+ jump_op.setdescr(celltoken)
+ #start_label = ResOperation(rop.LABEL, loop.inputargs,
+ # descr=jump_op.getdescr())
+ #end_label = jump_op.copy_and_change(opnum=rop.LABEL)
call_pure_results = self._convert_call_pure_results(call_pure_results)
- t = self.convert_loop_to_packed(loop, skip_last=True)
- preamble_data = compile.LoopCompileData(start_label, end_label, t,
- call_pure_results)
+ t = self.convert_loop_to_packed(loop)
+ preamble_data = compile.LoopCompileData(t, call_pure_results)
start_state, preamble_ops = self._do_optimize_loop(preamble_data)
preamble_data.forget_optimization_info()
- loop_data = compile.UnrolledLoopData(start_label, jump_op,
- t, start_state,
- call_pure_results)
+ loop_data = compile.UnrolledLoopData(preamble_data.trace,
+ celltoken, start_state, call_pure_results)
loop_info, ops = self._do_optimize_loop(loop_data)
preamble = TreeLoop('preamble')
preamble.inputargs = start_state.renamed_inputargs
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
@@ -115,19 +115,16 @@
return modifier.get_virtual_state(args)
def _check_no_forwarding(self, lsts, check_newops=True):
- return
for lst in lsts:
for op in lst:
assert op.get_forwarded() is None
if check_newops:
assert not self.optimizer._newoperations
- def optimize_preamble(self, start_label, end_label, trace,
call_pure_results,
- memo):
- #self._check_no_forwarding([[start_label, end_label], ops])
- info, newops = self.optimizer.propagate_all_forward(trace,
+ def optimize_preamble(self, trace, call_pure_results, memo):
+ info, newops = self.optimizer.propagate_all_forward(trace.get_iter(),
call_pure_results, flush=False)
- exported_state = self.export_state(start_label, end_label.getarglist(),
+ exported_state = self.export_state(info.jump_op.getarglist(),
info.inputargs, memo)
exported_state.quasi_immutable_deps = info.quasi_immutable_deps
# we need to absolutely make sure that we've cleaned up all
@@ -135,11 +132,11 @@
self.optimizer._clean_optimization_info(self.optimizer._newoperations)
return exported_state, self.optimizer._newoperations
- def optimize_peeled_loop(self, start_label, end_jump, trace, state,
+ def optimize_peeled_loop(self, trace, celltoken, state,
call_pure_results, inline_short_preamble=True):
- #self._check_no_forwarding([[start_label, end_jump], ops])
+ trace = trace.get_iter()
try:
- label_args = self.import_state(start_label, state)
+ label_args = self.import_state(trace.inputargs, state)
except VirtualStatesCantMatch:
raise InvalidLoop("Cannot import state, virtual states don't
match")
self.potential_extra_ops = {}
@@ -149,14 +146,14 @@
trace, call_pure_results, flush=False)
except SpeculativeError:
raise InvalidLoop("Speculative heap access would be ill-typed")
+ end_jump = info.jump_op
label_op = ResOperation(rop.LABEL, label_args,
- descr=start_label.getdescr())
+ descr=celltoken)
for a in end_jump.getarglist():
self.optimizer.force_box_for_end_of_preamble(
self.optimizer.get_box_replacement(a))
current_vs = self.get_virtual_state(end_jump.getarglist())
# pick the vs we want to jump to
- celltoken = start_label.getdescr()
assert isinstance(celltoken, JitCellToken)
target_virtual_state = self.pick_virtual_state(current_vs,
@@ -227,11 +224,10 @@
def optimize_bridge(self, start_label, operations, call_pure_results,
inline_short_preamble, box_names_memo):
- self._check_no_forwarding([start_label.getarglist(),
- operations])
+ self._check_no_forwarding([start_label.getarglist()])
info, ops = self.optimizer.propagate_all_forward(
start_label.getarglist()[:], operations[:-1],
- call_pure_results, True)
+ call_pure_results)
jump_op = operations[-1]
cell_token = jump_op.getdescr()
assert isinstance(cell_token, JitCellToken)
@@ -375,8 +371,7 @@
op = sop.copy_and_change(sop.getopnum(), arglist,
descr=compile.ResumeAtPositionDescr())
assert isinstance(op, GuardResOp)
- op.rd_snapshot = patchguardop.rd_snapshot
- op.rd_frame_info_list = patchguardop.rd_frame_info_list
+ op.rd_resume_position = patchguardop.rd_resume_position
else:
op = sop.copy_and_change(sop.getopnum(), arglist)
mapping[sop] = op
@@ -412,8 +407,7 @@
continue
self._expand_info(item, infos)
- def export_state(self, start_label, original_label_args, renamed_inputargs,
- memo):
+ def export_state(self, 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()
@@ -435,18 +429,17 @@
if not isinstance(op, Const):
self._expand_info(op, infos)
self.optimizer._clean_optimization_info(end_args)
- self.optimizer._clean_optimization_info(start_label.getarglist())
return ExportedState(label_args, end_args, virtual_state, infos,
short_boxes, renamed_inputargs,
short_inputargs, memo)
- def import_state(self, targetop, exported_state):
+ def import_state(self, targetargs, exported_state):
# the mapping between input args (from old label) and what we need
# to actually emit. Update the info
assert (len(exported_state.next_iteration_args) ==
- len(targetop.getarglist()))
+ len(targetargs))
for i, target in enumerate(exported_state.next_iteration_args):
- source = targetop.getarg(i)
+ source = targetargs[i]
assert source is not target
source.set_forwarded(target)
info = exported_state.exported_infos.get(target, None)
@@ -456,7 +449,7 @@
# import the optimizer state, starting from boxes that can be produced
# by short preamble
label_args = exported_state.virtual_state.make_inputargs(
- targetop.getarglist(), self.optimizer)
+ targetargs, self.optimizer)
self.short_preamble_producer = ShortPreambleBuilder(
label_args, exported_state.short_boxes,
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit
