Author: Maciej Fijalkowski <[email protected]>
Branch: resume-refactor
Changeset: r68856:faf703373bb5
Date: 2014-01-18 15:57 +0100
http://bitbucket.org/pypy/pypy/changeset/faf703373bb5/
Log: finish refactoring the world - now inputframes no longer exists and
we replay the necessary resume ops
diff --git a/rpython/jit/backend/llgraph/runner.py
b/rpython/jit/backend/llgraph/runner.py
--- a/rpython/jit/backend/llgraph/runner.py
+++ b/rpython/jit/backend/llgraph/runner.py
@@ -34,23 +34,10 @@
self.liveness = LivenessAnalyzer()
self.numbering = {}
self.framestack = []
- locs = None
- start_pos = 0
- xxx
if inputlocs is not None:
- locs = []
- for frame_pos, frame in enumerate(inputframes):
- self.framestack.append(ResumeFrame(len(frame), start_pos))
- for pos_in_frame, box in enumerate(frame):
- if box is None:
- continue
- pos = inputlocs[frame_pos][pos_in_frame]
- self.framestack[-1].registers[pos_in_frame] = box
- self.numbering[box] = pos
- locs.append(Position(pos))
- start_pos += 1
- ResumeBuilder.__init__(self, self, frontend_liveness, descr,
- inputframes, locs)
+ for arg, loc in zip(inputargs, inputlocs):
+ self.numbering[arg] = loc
+ ResumeBuilder.__init__(self, self, frontend_liveness, descr)
def loc(self, box, must_exist=True):
return Position(self.numbering[box])
@@ -142,13 +129,7 @@
newop.getdescr().rd_bytecode_position =
resumebuilder.builder.getpos()
self.operations.append(newop)
- if descr is None:
- parent = None
- parent_position = 0
- else:
- parent = descr.rd_resume_bytecode
- parent_position = descr.rd_bytecode_position
- bytecode = resumebuilder.finish(parent, parent_position, self)
+ bytecode = resumebuilder.finish(self)
for op in operations:
if op.is_guard():
op.getdescr().rd_resume_bytecode = bytecode
@@ -291,7 +272,7 @@
name=''):
clt = model.CompiledLoopToken(self, looptoken.number)
looptoken.compiled_loop_token = clt
- lltrace = LLTrace([inputargs], operations, None)
+ lltrace = LLTrace(inputargs, operations, None)
clt._llgraph_loop = lltrace
clt._llgraph_alltraces = [lltrace]
self._record_labels(lltrace)
diff --git a/rpython/jit/backend/test/runner_test.py
b/rpython/jit/backend/test/runner_test.py
--- a/rpython/jit/backend/test/runner_test.py
+++ b/rpython/jit/backend/test/runner_test.py
@@ -250,6 +250,10 @@
i1b = BoxInt()
i3 = BoxInt()
bridge = [
+ ResOperation(rop.ENTER_FRAME, [ConstInt(-1)], None,
+ descr=jitcode),
+ ResOperation(rop.RESUME_PUT, [i1b, ConstInt(0), ConstInt(0)],
+ None),
ResOperation(rop.INT_LE, [i1b, ConstInt(19)], i3),
ResOperation(rop.GUARD_TRUE, [i3], None, descr=faildescr2),
ResOperation(rop.LEAVE_FRAME, [], None),
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
@@ -124,7 +124,7 @@
jitcell_token = make_jitcell_token(jitdriver_sd)
part = create_empty_loop(metainterp)
- part.inputframes = [inputargs[:]]
+ part.inputargs = inputargs[:]
h_ops = history.operations
part.resume_at_jump_descr = resume_at_jump_descr
part.operations = [ResOperation(rop.LABEL, inputargs, None,
descr=TargetToken(jitcell_token))] + \
@@ -140,7 +140,7 @@
all_target_tokens = [target_token]
loop = create_empty_loop(metainterp)
- loop.inputframes = part.inputframes
+ loop.inputargs = part.inputargs
loop.operations = part.operations
loop.quasi_immutable_deps = {}
if part.quasi_immutable_deps:
@@ -198,7 +198,7 @@
assert partial_trace.operations[-1].getopnum() == rop.LABEL
part = create_empty_loop(metainterp)
- part.inputframes = [inputargs[:]]
+ part.inputargs = inputargs[:]
part.resume_at_jump_descr = resume_at_jump_descr
h_ops = history.operations
@@ -253,10 +253,10 @@
def patch_new_loop_to_load_virtualizable_fields(loop, jitdriver_sd):
vinfo = jitdriver_sd.virtualizable_info
extra_ops = []
- inputargs = loop.inputframes[0]
+ inputargs = loop.inputargs
vable_box = inputargs[jitdriver_sd.index_of_virtualizable]
i = jitdriver_sd.num_red_args
- loop.inputframes = [inputargs[:i]]
+ loop.inputargs = inputargs[:i]
for descr in vinfo.static_field_descrs:
assert i < len(inputargs)
box = inputargs[i]
@@ -338,8 +338,7 @@
metainterp_sd.profiler.start_backend()
debug_start("jit-backend")
try:
- assert len(loop.inputframes) == 1
- asminfo = do_compile_loop(metainterp_sd, loop.inputframes[0],
+ asminfo = do_compile_loop(metainterp_sd, loop.inputargs,
operations, original_jitcell_token,
name=loopname)
finally:
@@ -357,7 +356,7 @@
ops_offset = asminfo.ops_offset
else:
ops_offset = None
- metainterp_sd.logger_ops.log_loop(loop.inputframes[0], loop.operations, n,
+ metainterp_sd.logger_ops.log_loop(loop.inputargs, loop.operations, n,
type, ops_offset,
name=loopname)
#
@@ -383,7 +382,7 @@
metainterp_sd.profiler.start_backend()
debug_start("jit-backend")
try:
- asminfo = do_compile_bridge(metainterp_sd, faildescr, inputframes,
+ asminfo = do_compile_bridge(metainterp_sd, faildescr, inputargs,
inputlocs, operations,
original_loop_token)
finally:
@@ -609,13 +608,13 @@
# to the corresponding guard_op and compile from there
assert metainterp.resumekey_original_loop_token is not None
new_loop.original_jitcell_token =
metainterp.resumekey_original_loop_token
- inputframes = metainterp.history.inputframes
+ inputargs = metainterp.history.inputargs
inputlocs = metainterp.history.inputlocs
if not we_are_translated():
self._debug_suboperations = new_loop.operations
propagate_original_jitcell_token(new_loop)
send_bridge_to_backend(metainterp.jitdriver_sd, metainterp.staticdata,
- self, inputframes, inputlocs,
+ self, inputargs, inputlocs,
new_loop.operations,
new_loop.original_jitcell_token)
@@ -803,7 +802,7 @@
# Attempt to use optimize_bridge(). This may return None in case
# it does not work -- i.e. none of the existing old_loop_tokens match.
new_trace = create_empty_loop(metainterp)
- new_trace.inputframes = metainterp.history.inputframes[:]
+ new_trace.inputargs = metainterp.history.inputargs[:]
if metainterp.history.inputlocs is not None:
new_trace.inputlocs = metainterp.history.inputlocs[:]
# clone ops, as optimize_bridge can mutate the ops
@@ -817,7 +816,8 @@
else:
inline_short_preamble = True
try:
- optimize_trace(metainterp_sd, new_trace, state.enable_opts,
inline_short_preamble, inpframes=new_trace.inputframes)
+ optimize_trace(metainterp_sd, new_trace, state.enable_opts,
+ inline_short_preamble)
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/history.py
b/rpython/jit/metainterp/history.py
--- a/rpython/jit/metainterp/history.py
+++ b/rpython/jit/metainterp/history.py
@@ -675,11 +675,10 @@
def check_consistency_of(inputargs, operations):
seen = {}
all = 0
- for frame in inputargs:
- for box in frame:
- assert isinstance(box, Box), "Loop.inputargs contains %r" %
(box,)
- seen[box] = None
- all += 1
+ for box in inputargs:
+ assert isinstance(box, Box), "Loop.inputargs contains %r" % (box,)
+ seen[box] = None
+ all += 1
assert len(seen) == all, (
"duplicate Box in the Loop.inputargs")
TreeLoop.check_consistency_of_branch(operations, seen)
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
@@ -47,22 +47,19 @@
return optimizations, unroll
-def optimize_trace(metainterp_sd, loop, enable_opts,
inline_short_preamble=True,
- inpframes=None):
+def optimize_trace(metainterp_sd, loop, enable_opts,
+ inline_short_preamble=True):
"""Optimize loop.operations to remove internal overheadish operations.
"""
- from rpython.jit.resume.backend import flatten
-
debug_start("jit-optimize")
try:
loop.logops = metainterp_sd.logger_noopt.log_loop(
- flatten(loop.inputframes), loop.operations)
+ loop.inputargs, loop.operations)
optimizations, unroll = build_opt_chain(metainterp_sd, enable_opts)
if unroll:
optimize_unroll(metainterp_sd, loop, optimizations,
inline_short_preamble)
else:
- optimizer = Optimizer(metainterp_sd, loop, optimizations,
- inpframes=inpframes)
+ optimizer = Optimizer(metainterp_sd, loop, optimizations)
optimizer.propagate_all_forward()
finally:
debug_stop("jit-optimize")
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
@@ -344,8 +344,7 @@
class Optimizer(Optimization):
- def __init__(self, metainterp_sd, loop, optimizations=None,
- inpframes=None):
+ def __init__(self, metainterp_sd, loop, optimizations=None):
self.metainterp_sd = metainterp_sd
self.cpu = metainterp_sd.cpu
self.loop = loop
@@ -368,7 +367,7 @@
self.call_pure_results = loop.call_pure_results
self.set_optimizations(optimizations)
- self.resumebuilder = OptResumeBuilder(self, inpframes)
+ self.resumebuilder = OptResumeBuilder(self)
self.setup()
def set_optimizations(self, optimizations):
diff --git a/rpython/jit/resume/frontend.py b/rpython/jit/resume/frontend.py
--- a/rpython/jit/resume/frontend.py
+++ b/rpython/jit/resume/frontend.py
@@ -205,7 +205,7 @@
self.deadframe = deadframe
AbstractResumeReader.__init__(self, metainterp.staticdata)
- def get_box_value(self, encoded_pos, TP):
+ def get_box_value(self, pos_in_frame, frame_pos, encoded_pos, TP):
if encoded_pos == CLEAR_POSITION:
return None
if encoded_pos in self.cache:
@@ -214,14 +214,21 @@
if tag == TAGBOX:
if TP == INT:
val = self.metainterp.cpu.get_int_value(self.deadframe, pos)
- res = BoxInt(val)
+ box = BoxInt(val)
elif TP == REF:
val = self.metainterp.cpu.get_ref_value(self.deadframe, pos)
- res = BoxPtr(val)
+ box = BoxPtr(val)
else:
xxx
- self.cache[encoded_pos] = res
- return res
+ if pos_in_frame != -1:
+ self.metainterp.history.record(rop.RESUME_PUT,
+ [box, ConstInt(frame_pos),
+ ConstInt(pos_in_frame)],
+ None, None)
+ self.result.append(box)
+ self.locs.append(pos)
+ self.cache[encoded_pos] = box
+ return box
elif tag == TAGSMALLINT:
return ConstInt(pos)
elif tag == TAGCONST:
@@ -233,51 +240,34 @@
for fielddescr, encoded_field_pos in virtual.fields.iteritems():
self.setfield_gc(virtual_box, encoded_field_pos, fielddescr)
self.cache[encoded_pos] = virtual_box
+ if pos_in_frame != -1:
+ self.metainterp.history.record(rop.RESUME_PUT,
+ [virtual_box,
+ ConstInt(frame_pos),
+ ConstInt(pos_in_frame)],
+ None, None)
return virtual_box
def allocate_struct(self, virtual):
return self.metainterp.execute_and_record(rop.NEW, virtual.descr)
def setfield_gc(self, box, encoded_field_pos, fielddescr):
- field_box = self.get_box_value(encoded_field_pos, fielddescr.kind)
+ field_box = self.get_box_value(-1, -1, encoded_field_pos,
+ fielddescr.kind)
self.metainterp.execute_and_record(rop.SETFIELD_GC, fielddescr,
box, field_box)
- def store_int_box(self, res, pos, miframe, i, jitframe_pos):
- box = self.get_box_value(jitframe_pos, INT)
+ def store_int_box(self, pos, miframe, i, jitframe_pos):
+ box = self.get_box_value(pos, i, jitframe_pos, INT)
if box is None:
return
miframe.registers_i[i] = box
- if not isinstance(box, Const):
- res[-1][pos] = box
- def store_ref_box(self, res, pos, miframe, i, jitframe_pos):
- box = self.get_box_value(jitframe_pos, REF)
+ def store_ref_box(self, pos, miframe, i, jitframe_pos):
+ box = self.get_box_value(pos, i, jitframe_pos, REF)
if box is None:
return
miframe.registers_r[i] = box
- tag, index = self.decode(jitframe_pos)
- if tag == TAGBOX:
- res[-1][pos] = box
- elif tag == TAGVIRTUAL:
- self.metainterp.history.record(rop.RESUME_PUT,
- [box, ConstInt(len(res) - 1),
- ConstInt(pos)], None, None)
- # we can't have virtual ints
- return
- xxx
- if jitframe_pos in self.cache:
- box = self.cache[jitframe_pos]
- elif jitframe_pos == -1:
- return
- elif jitframe_pos >= 0:
- box = BoxPtr(self.metainterp.cpu.get_ref_value(self.deadframe,
- jitframe_pos))
- elif jitframe_pos <= -2:
- box = self.consts[-jitframe_pos - 2]
- miframe.registers_r[i] = box
- self.cache[jitframe_pos] = box
- res[-1][pos] = box
def store_float_box(self, res, pos, miframe, i, jitframe_pos):
box = self.get_box_value(jitframe_pos)
@@ -304,26 +294,28 @@
return -1
def finish(self):
- res = []
+ self.result = []
self.cache = {}
+ self.locs = []
for frame in self.framestack:
jitcode = frame.jitcode
- res.append([None] * jitcode.num_regs())
miframe = self.metainterp.newframe(jitcode, record_resume=False)
miframe.pc = frame.pc
pos = 0
for i in range(jitcode.num_regs_i()):
- self.store_int_box(res, pos, miframe, i, frame.registers[pos])
+ self.store_int_box(pos, miframe, i, frame.registers[pos])
pos += 1
for i in range(jitcode.num_regs_r()):
- self.store_ref_box(res, pos, miframe, i, frame.registers[pos])
+ self.store_ref_box(pos, miframe, i, frame.registers[pos])
pos += 1
for i in range(jitcode.num_regs_f()):
- self.store_float_box(res, pos, miframe, i,
frame.registers[pos])
+ self.store_float_box(pos, miframe, i, frame.registers[pos])
pos += 1
self.cache = None
- return res, [[self.get_loc(r) for r in f.registers]
- for f in self.framestack]
+ state = self.result, self.locs
+ self.result = None
+ self.locs = None
+ return state
def rebuild_from_resumedata(metainterp, deadframe, faildescr):
""" Reconstruct metainterp frames from the resumedata
diff --git a/rpython/jit/resume/test/test_frontend.py
b/rpython/jit/resume/test/test_frontend.py
--- a/rpython/jit/resume/test/test_frontend.py
+++ b/rpython/jit/resume/test/test_frontend.py
@@ -111,15 +111,16 @@
metainterp = MockMetaInterp()
metainterp.staticdata = MockStaticData([jitcode], [])
metainterp.cpu = MockCPU()
- inpframes, inplocs = rebuild_from_resumedata(metainterp, "myframe",
descr)
+ inputargs, inplocs = rebuild_from_resumedata(metainterp, "myframe",
+ descr)
assert len(metainterp.framestack) == 1
f = metainterp.framestack[-1]
assert f.registers_i[1].getint() == 103
assert isinstance(f.registers_i[2], Const)
assert f.registers_i[2].getint() == 15
assert f.registers_i[3].getint() == 13
- assert inpframes == [[None, AnyBox(), None, None]]
- assert inplocs == [[-1, 100, -1, -1]]
+ assert len(inputargs) == 1
+ assert inplocs == [100]
def test_nested_call(self):
jitcode1 = JitCode("jitcode")
@@ -165,35 +166,6 @@
assert f.registers_i[2].getint() == 11 + 3
assert f.registers_i[4].getint() == 8 + 3
- def test_bridge(self):
- jitcode1 = JitCode("jitcode")
- jitcode1.setup(num_regs_i=13, num_regs_r=0, num_regs_f=0)
- jitcode1.global_index = 0
- builder = ResumeBytecodeBuilder()
- builder.enter_frame(-1, jitcode1)
- builder.resume_put(TAGBOX | (42 << 2), 0, 0)
- rd1 = builder.build()
- lgt1 = len(rd1)
-
- builder = ResumeBytecodeBuilder()
- builder.resume_put(TAGBOX | (2 << 2), 0, 1)
- rd2 = builder.build()
- lgt2 = len(rd2)
-
- descr = Descr()
- descr.rd_bytecode_position = lgt2
- parent = ResumeBytecode(rd1, [])
- b = ResumeBytecode(rd2, [], parent, parent_position=lgt1)
- descr.rd_resume_bytecode = b
- metainterp = MockMetaInterp()
- metainterp.staticdata = MockStaticData([jitcode1], [])
- metainterp.cpu = MockCPU()
- rebuild_from_resumedata(metainterp, "myframe", descr)
- f = metainterp.framestack[-1]
- assert f.num_nonempty_regs() == 2
- assert f.registers_i[0].getint() == 42 + 3
- assert f.registers_i[1].getint() == 2 + 3
-
def test_new(self):
jitcode1 = JitCode("jitcode")
jitcode1.global_index = 0
@@ -242,7 +214,7 @@
descr.rd_bytecode_position = len(rd)
staticdata = MockStaticData([jitcode1, jitcode2], [])
locs = rebuild_locs_from_resumedata(descr, staticdata)
- assert locs == [[8, 11], [12]]
+ assert locs == [8, 11, 12]
class AssemblerExecuted(Exception):
pass
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
