Author: Maciej Fijalkowski <[email protected]>
Branch: resume-refactor
Changeset: r68855:8e03695f39ba
Date: 2014-01-18 15:41 +0100
http://bitbucket.org/pypy/pypy/changeset/8e03695f39ba/
Log: Refactor the world again - we don't try hard to store stuff on
inputframes, instead we reconstruct stuff when making a bridge
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
@@ -2,7 +2,7 @@
from rpython.jit.backend import model
from rpython.jit.backend.llgraph import support
from rpython.jit.resume.backend import ResumeBuilder,\
- LivenessAnalyzer, compute_vars_longevity, flatten
+ LivenessAnalyzer, compute_vars_longevity
from rpython.jit.metainterp.history import AbstractDescr
from rpython.jit.metainterp.history import Const, getkind
from rpython.jit.metainterp.history import INT, REF, FLOAT, VOID
@@ -30,12 +30,13 @@
self.start_pos = start_pos
class LLGraphResumeBuilder(ResumeBuilder):
- def __init__(self, frontend_liveness, descr, inputframes, inputlocs):
+ def __init__(self, frontend_liveness, descr, inputargs, inputlocs):
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):
@@ -101,7 +102,7 @@
has_been_freed = False
invalid = False
- def __init__(self, inputframes, operations, descr, locs=None):
+ def __init__(self, inputargs, operations, descr, locs=None):
# We need to clone the list of operations because the
# front-end will mutate them under our feet again. We also
# need to make sure things get freed.
@@ -114,13 +115,13 @@
newbox = _cache[box] = box.__class__()
return newbox
#
- self.inputargs = map(mapping, flatten(inputframes))
+ self.inputargs = map(mapping, inputargs)
self.operations = []
- x = compute_vars_longevity(inputframes, operations, descr)
+ x = compute_vars_longevity(inputargs, operations, descr)
longevity, last_real_usage, frontend_liveness = x
resumebuilder = LLGraphResumeBuilder(frontend_liveness, descr,
- inputframes, locs)
+ inputargs, locs)
for op in operations:
if op.is_resume():
resumebuilder.process(op)
@@ -295,11 +296,11 @@
clt._llgraph_alltraces = [lltrace]
self._record_labels(lltrace)
- def compile_bridge(self, logger, faildescr, inputframes, locs, operations,
+ def compile_bridge(self, logger, faildescr, inputargs, locs, operations,
original_loop_token, log=True):
clt = original_loop_token.compiled_loop_token
clt.compiling_a_bridge()
- lltrace = LLTrace(inputframes, operations, faildescr, locs)
+ lltrace = LLTrace(inputargs, operations, faildescr, locs)
faildescr._llgraph_bridge = lltrace
clt._llgraph_alltraces.append(lltrace)
self._record_labels(lltrace)
diff --git a/rpython/jit/backend/llsupport/assembler.py
b/rpython/jit/backend/llsupport/assembler.py
--- a/rpython/jit/backend/llsupport/assembler.py
+++ b/rpython/jit/backend/llsupport/assembler.py
@@ -110,7 +110,7 @@
self._debug = v
return r
- def rebuild_faillocs_from_descr(self, descr, inputframes, loc_positions):
+ def rebuild_faillocs_from_descr(self, descr, inputargs, loc_positions):
locs = []
GPR_REGS = len(self.cpu.gen_regs)
XMM_REGS = len(self.cpu.float_regs)
@@ -118,27 +118,23 @@
coeff = 1
else:
coeff = 2
- all = {}
- for i, frame in enumerate(inputframes):
- inputlocs = loc_positions[i]
- assert len(inputlocs) == len(frame)
- for j, item in enumerate(frame):
- if item is None or isinstance(item, Const) or item in all:
- continue
- all[item] = None
- pos = inputlocs[j]
- if pos < GPR_REGS:
- locs.append(self.cpu.gen_regs[pos])
- elif pos < (GPR_REGS + XMM_REGS * coeff):
- pos = (pos - GPR_REGS) // coeff
- locs.append(self.cpu.float_regs[pos])
- else:
- stack_pos = pos - self.cpu.JITFRAME_FIXED_SIZE
- assert stack_pos >= 0
- tp = item.type
- locs.append(self.new_stack_loc(stack_pos,
- pos * WORD, tp))
- return locs[:]
+ assert len(inputargs) == len(loc_positions)
+ locs = [None] * len(inputargs)
+ for i in range(len(inputargs)):
+ pos = loc_positions[i]
+ item = inputargs[i]
+ if pos < GPR_REGS:
+ locs[i] = self.cpu.gen_regs[pos]
+ elif pos < (GPR_REGS + XMM_REGS * coeff):
+ pos = (pos - GPR_REGS) // coeff
+ locs[i] = self.cpu.float_regs[pos]
+ else:
+ stack_pos = pos - self.cpu.JITFRAME_FIXED_SIZE
+ assert stack_pos >= 0
+ tp = item.type
+ locs[i] = self.new_stack_loc(stack_pos,
+ pos * WORD, tp)
+ return locs
def store_info_on_descr(self, startspos, guardtok, resume_bytecode):
withfloats = guardtok.has_floats
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
@@ -258,7 +258,7 @@
staticdata = MockStaticData([jitcode], [])
locs = rebuild_locs_from_resumedata(faildescr1, staticdata)
- self.cpu.compile_bridge(None, faildescr1, [[i1b]], locs, bridge,
looptoken)
+ self.cpu.compile_bridge(None, faildescr1, [i1b], locs, bridge,
looptoken)
deadframe = self.cpu.execute_token(looptoken, 2)
fail = self.cpu.get_latest_descr(deadframe)
@@ -299,6 +299,10 @@
i3 = BoxInt()
staticdata = MockStaticData([jitcode], [])
bridge = [
+ ResOperation(rop.ENTER_FRAME, [ConstInt(-1)], None,
+ descr=jitcode),
+ ResOperation(rop.RESUME_PUT, [i1b, ConstInt(0), ConstInt(1)],
+ None),
ResOperation(rop.INT_LE, [i1b, ConstInt(19)], i3),
ResOperation(rop.RESUME_PUT, [i3, ConstInt(0), ConstInt(2)],
None),
@@ -307,14 +311,14 @@
]
locs = rebuild_locs_from_resumedata(faildescr1, staticdata)
- self.cpu.compile_bridge(None, faildescr1, [[None, i1b, None]],
+ self.cpu.compile_bridge(None, faildescr1, [i1b],
locs, bridge, looptoken)
deadframe = self.cpu.execute_token(looptoken, 2)
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 2
locs = rebuild_locs_from_resumedata(fail, staticdata)
- res = self.cpu.get_int_value(deadframe, locs[0][1])
+ res = self.cpu.get_int_value(deadframe, locs[0])
assert res == 20
def test_compile_big_bridge_out_of_small_loop(self):
@@ -337,6 +341,8 @@
staticdata.alljitcodes.append(jitcode1)
i1list = [BoxInt() for i in range(150)]
bridge = [
+ ResOperation(rop.ENTER_FRAME, [ConstInt(-1)], None, descr=jitcode),
+ ResOperation(rop.RESUME_PUT, [i0, ConstInt(0), ConstInt(0)], None),
ResOperation(rop.ENTER_FRAME, [ConstInt(13)], None, descr=jitcode1)
]
iprev = i0
@@ -351,14 +357,14 @@
descr=BasicFinalDescr(4)))
faillocs = rebuild_locs_from_resumedata(faildescr1, staticdata)
- self.cpu.compile_bridge(None, faildescr1, [[i0]], faillocs, bridge,
looptoken)
+ self.cpu.compile_bridge(None, faildescr1, [i0], faillocs, bridge,
looptoken)
deadframe = self.cpu.execute_token(looptoken, 1)
fail = self.cpu.get_latest_descr(deadframe)
locs = rebuild_locs_from_resumedata(fail, staticdata)
assert fail.identifier == 3
for i in range(len(i1list)):
- res = self.cpu.get_int_value(deadframe, locs[1][i])
+ res = self.cpu.get_int_value(deadframe, locs[i + 1])
assert res == 2 + i
def test_finish(self):
@@ -455,8 +461,8 @@
deadframe = self.cpu.execute_token(looptoken, 0, 10)
fail = self.cpu.get_latest_descr(deadframe)
locs = rebuild_locs_from_resumedata(fail, staticdata)
- assert self.cpu.get_int_value(deadframe, locs[0][0]) == 0
- assert self.cpu.get_int_value(deadframe, locs[0][1]) == 55
+ assert self.cpu.get_int_value(deadframe, locs[0]) == 0
+ assert self.cpu.get_int_value(deadframe, locs[1]) == 55
def test_int_operations(self):
from rpython.jit.metainterp.test.test_executor import get_int_tests
@@ -526,7 +532,7 @@
fail = self.cpu.get_latest_descr(deadframe)
if (z == boom) ^ reversed:
locs = rebuild_locs_from_resumedata(fail, staticdata)
- pos = locs[0][0]
+ pos = locs[0]
assert fail.identifier == 1
else:
pos = 0
@@ -1303,10 +1309,10 @@
assert fail.identifier == 42
#
for k in range(intboxes):
- got = self.cpu.get_int_value(deadframe, locs[0][k])
+ got = self.cpu.get_int_value(deadframe, locs[k])
assert got == expvalues[k]
for k in range(floatboxes):
- got = self.cpu.get_float_value(deadframe, locs[0][k +
intboxes])
+ got = self.cpu.get_float_value(deadframe, locs[k + intboxes])
assert got == expvalues[k + intboxes]
def test_jump(self):
@@ -1433,13 +1439,13 @@
else:
refvals.append(val)
for i, val in enumerate(intvals):
- got = self.cpu.get_int_value(deadframe, locs[0][i])
+ got = self.cpu.get_int_value(deadframe, locs[i])
assert got == val
for i, val in enumerate(refvals):
- got = self.cpu.get_ref_value(deadframe, locs[0][i +
len(intvals)])
+ got = self.cpu.get_ref_value(deadframe, locs[i + len(intvals)])
assert got == val
for i, val in enumerate(floatvals):
- got = self.cpu.get_float_value(deadframe, locs[0][
+ got = self.cpu.get_float_value(deadframe, locs[
i + len(intvals) +
len(refvals)])
assert got == val
@@ -1478,7 +1484,7 @@
ResOperation(rop.JUMP, [f3]+fboxes2[1:], None, descr=targettoken),
]
- self.cpu.compile_bridge(None, faildescr1, [fboxes2],
+ self.cpu.compile_bridge(None, faildescr1, fboxes2,
rebuild_locs_from_resumedata(faildescr1,
staticdata),
bridge, looptoken)
@@ -1490,11 +1496,11 @@
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 2
locs = rebuild_locs_from_resumedata(fail, staticdata)
- res = self.cpu.get_float_value(deadframe, locs[0][0])
+ res = self.cpu.get_float_value(deadframe, locs[0])
assert longlong.getrealfloat(res) == 8.5
for i in range(1, len(fboxes)):
got = longlong.getrealfloat(self.cpu.get_float_value(
- deadframe, locs[0][i]))
+ deadframe, locs[i]))
assert got == 13.5 + 6.73 * i
def test_compile_bridge_spilled_float(self):
@@ -1526,9 +1532,9 @@
fail = self.cpu.get_latest_descr(deadframe)
assert loop.operations[-3].getdescr() is fail is faildescr1
locs = rebuild_locs_from_resumedata(fail, staticdata)
- f1 = self.cpu.get_float_value(deadframe, locs[0][0])
- f2 = self.cpu.get_float_value(deadframe, locs[0][1])
- f3 = self.cpu.get_float_value(deadframe, locs[0][2])
+ f1 = self.cpu.get_float_value(deadframe, locs[0])
+ f2 = self.cpu.get_float_value(deadframe, locs[1])
+ f3 = self.cpu.get_float_value(deadframe, locs[2])
assert longlong.getrealfloat(f1) == 132.25
assert longlong.getrealfloat(f2) == 0.75
assert longlong.getrealfloat(f3) == 133.0
@@ -1537,12 +1543,19 @@
faildescr3 = BasicFailDescr(103)
zero = BoxInt()
bridgeops = [
+ ResOperation(rop.ENTER_FRAME, [ConstInt(-1)], None, descr=jitcode),
+ ResOperation(rop.RESUME_PUT, [fboxes[0], ConstInt(0), ConstInt(0)],
+ None),
+ ResOperation(rop.RESUME_PUT, [fboxes[1], ConstInt(0), ConstInt(1)],
+ None),
+ ResOperation(rop.RESUME_PUT, [fboxes[2], ConstInt(0), ConstInt(2)],
+ None),
ResOperation(rop.SAME_AS, [ConstInt(0)], zero),
ResOperation(rop.GUARD_TRUE, [zero], None, descr=faildescr3),
ResOperation(rop.LEAVE_FRAME, [], None),
ResOperation(rop.FINISH, [], None, descr=faildescr2),
]
- self.cpu.compile_bridge(None, faildescr1, [fboxes],
+ self.cpu.compile_bridge(None, faildescr1, fboxes,
locs, bridgeops, looptoken)
args = [1,
longlong.getfloatstorage(132.25),
@@ -1551,9 +1564,9 @@
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 103
locs = rebuild_locs_from_resumedata(fail, staticdata)
- f1 = self.cpu.get_float_value(deadframe, locs[0][0])
- f2 = self.cpu.get_float_value(deadframe, locs[0][1])
- f3 = self.cpu.get_float_value(deadframe, locs[0][2])
+ f1 = self.cpu.get_float_value(deadframe, locs[0])
+ f2 = self.cpu.get_float_value(deadframe, locs[1])
+ f3 = self.cpu.get_float_value(deadframe, locs[2])
assert longlong.getrealfloat(f1) == 132.25
assert longlong.getrealfloat(f2) == 0.75
assert longlong.getrealfloat(f3) == 133.0
@@ -2187,7 +2200,7 @@
assert not excvalue
deadframe = self.cpu.execute_token(looptoken, 0)
locs = rebuild_locs_from_resumedata(faildescr, staticdata)
- assert self.cpu.get_int_value(deadframe, locs[0][0]) == 1
+ assert self.cpu.get_int_value(deadframe, locs[0]) == 1
excvalue = self.cpu.grab_exc_value(deadframe)
assert not excvalue
@@ -2206,7 +2219,7 @@
looptoken = JitCellToken()
self.cpu.compile_loop(None, loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, 1)
- assert self.cpu.get_int_value(deadframe, locs[0][0]) == 1
+ assert self.cpu.get_int_value(deadframe, locs[0]) == 1
excvalue = self.cpu.grab_exc_value(deadframe)
assert excvalue == yptr
@@ -2227,11 +2240,11 @@
self.cpu.compile_loop(None, loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, 1)
locs = rebuild_locs_from_resumedata(faildescr, staticdata)
- assert self.cpu.get_int_value(deadframe, locs[0][0]) == 1
+ assert self.cpu.get_int_value(deadframe, locs[0]) == 1
excvalue = self.cpu.grab_exc_value(deadframe)
assert excvalue == xptr
deadframe = self.cpu.execute_token(looptoken, 0)
- assert self.cpu.get_int_value(deadframe, locs[0][0]) == 0
+ assert self.cpu.get_int_value(deadframe, locs[0]) == 0
excvalue = self.cpu.grab_exc_value(deadframe)
assert not excvalue
@@ -2427,15 +2440,15 @@
assert not called
locs = rebuild_locs_from_resumedata(faildescr, staticdata)
for j in range(5):
- assert self.cpu.get_int_value(frame, locs[0][j]) == j
- assert longlong.getrealfloat(self.cpu.get_float_value(frame,
locs[0][6])) == 1.2
- assert longlong.getrealfloat(self.cpu.get_float_value(frame,
locs[0][7])) == 3.4
+ assert self.cpu.get_int_value(frame, locs[j]) == j
+ assert longlong.getrealfloat(self.cpu.get_float_value(frame,
locs[6])) == 1.2
+ assert longlong.getrealfloat(self.cpu.get_float_value(frame,
locs[7])) == 3.4
frame = self.cpu.execute_token(looptoken, 1, 1, 1, 2, 3, 4, 5, f1,
f2)
assert called == [tuple(range(1, i + 1))]
for j in range(4):
- assert self.cpu.get_int_value(frame, locs[0][j + 1]) == j + 1
- assert longlong.getrealfloat(self.cpu.get_float_value(frame,
locs[0][6])) == 1.2
- assert longlong.getrealfloat(self.cpu.get_float_value(frame,
locs[0][7])) == 3.4
+ assert self.cpu.get_int_value(frame, locs[j + 1]) == j + 1
+ assert longlong.getrealfloat(self.cpu.get_float_value(frame,
locs[6])) == 1.2
+ assert longlong.getrealfloat(self.cpu.get_float_value(frame,
locs[7])) == 3.4
def test_force_operations_returning_void(self):
values = []
@@ -2445,8 +2458,8 @@
fail = self.cpu.get_latest_descr(deadframe)
locs = rebuild_locs_from_resumedata(fail, staticdata)
values.append(fail)
- values.append(self.cpu.get_int_value(deadframe, locs[0][0]))
- values.append(self.cpu.get_int_value(deadframe, locs[0][1]))
+ values.append(self.cpu.get_int_value(deadframe, locs[0]))
+ values.append(self.cpu.get_int_value(deadframe, locs[1]))
self.cpu.set_savedata_ref(deadframe, random_gcref)
FUNC = self.FuncType([llmemory.GCREF, lltype.Signed], lltype.Void)
@@ -2482,8 +2495,8 @@
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 1
locs = rebuild_locs_from_resumedata(fail, staticdata)
- assert self.cpu.get_int_value(deadframe, locs[0][0]) == 1
- assert self.cpu.get_int_value(deadframe, locs[0][1]) == 10
+ assert self.cpu.get_int_value(deadframe, locs[0]) == 1
+ assert self.cpu.get_int_value(deadframe, locs[1]) == 10
assert values == [faildescr, 1, 10]
assert self.cpu.get_savedata_ref(deadframe) # not NULL
assert self.cpu.get_savedata_ref(deadframe) == random_gcref
@@ -2495,8 +2508,8 @@
deadframe = self.cpu.force(token)
fail = self.cpu.get_latest_descr(deadframe)
locs = rebuild_locs_from_resumedata(fail, staticdata)
- values.append(self.cpu.get_int_value(deadframe, locs[0][0]))
- values.append(self.cpu.get_int_value(deadframe, locs[0][2]))
+ values.append(self.cpu.get_int_value(deadframe, locs[0]))
+ values.append(self.cpu.get_int_value(deadframe, locs[2]))
self.cpu.set_savedata_ref(deadframe, random_gcref)
return 42
@@ -2535,9 +2548,9 @@
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 1
locs = rebuild_locs_from_resumedata(fail, staticdata)
- assert self.cpu.get_int_value(deadframe, locs[0][0]) == 1
- assert self.cpu.get_int_value(deadframe, locs[0][1]) == 42
- assert self.cpu.get_int_value(deadframe, locs[0][2]) == 10
+ assert self.cpu.get_int_value(deadframe, locs[0]) == 1
+ assert self.cpu.get_int_value(deadframe, locs[1]) == 42
+ assert self.cpu.get_int_value(deadframe, locs[2]) == 10
assert values == [1, 10]
assert self.cpu.get_savedata_ref(deadframe) == random_gcref
@@ -2550,8 +2563,8 @@
deadframe = self.cpu.force(token)
fail = self.cpu.get_latest_descr(deadframe)
locs = rebuild_locs_from_resumedata(fail, staticdata)
- values.append(self.cpu.get_int_value(deadframe, locs[0][0]))
- values.append(self.cpu.get_int_value(deadframe, locs[0][1]))
+ values.append(self.cpu.get_int_value(deadframe, locs[0]))
+ values.append(self.cpu.get_int_value(deadframe, locs[1]))
self.cpu.set_savedata_ref(deadframe, random_gcref)
return 42.5
@@ -2591,10 +2604,10 @@
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 1
locs = rebuild_locs_from_resumedata(fail, staticdata)
- assert self.cpu.get_int_value(deadframe, locs[0][0]) == 1
- x = self.cpu.get_float_value(deadframe, locs[0][2])
+ assert self.cpu.get_int_value(deadframe, locs[0]) == 1
+ x = self.cpu.get_float_value(deadframe, locs[2])
assert longlong.getrealfloat(x) == 42.5
- assert self.cpu.get_int_value(deadframe, locs[0][1]) == 10
+ assert self.cpu.get_int_value(deadframe, locs[1]) == 10
assert values == [1, 10]
assert self.cpu.get_savedata_ref(deadframe) == random_gcref
@@ -2987,7 +3000,7 @@
fail = self.cpu.get_latest_descr(deadframe)
locs = rebuild_locs_from_resumedata(fail, staticdata)
assert fail is faildescr
- assert self.cpu.get_int_value(deadframe, locs[0][0]) == 9
+ assert self.cpu.get_int_value(deadframe, locs[0]) == 9
print 'step 2 ok'
print '-'*79
@@ -2998,7 +3011,7 @@
ResOperation(rop.GUARD_NOT_INVALIDATED, [],None, descr=faildescr2),
ResOperation(rop.FINISH, [i2], None, descr=BasicFinalDescr(3))
]
- self.cpu.compile_bridge(None, faildescr, [[i2]], locs, ops, looptoken)
+ self.cpu.compile_bridge(None, faildescr, [i2], locs, ops, looptoken)
deadframe = self.cpu.execute_token(looptoken, -42, 9)
fail = self.cpu.get_latest_descr(deadframe)
@@ -3038,7 +3051,7 @@
ops2 = [
ResOperation(rop.JUMP, [ConstInt(333)], None, descr=labeldescr),
]
- self.cpu.compile_bridge(None, faildescr, [[]], [[]], ops2, looptoken)
+ self.cpu.compile_bridge(None, faildescr, [], [], ops2, looptoken)
# run: must not be caught in an infinite loop
deadframe = self.cpu.execute_token(looptoken, 16)
fail = self.cpu.get_latest_descr(deadframe)
@@ -3908,7 +3921,7 @@
fail = self.cpu.get_latest_descr(deadframe)
locs = rebuild_locs_from_resumedata(fail, staticdata)
assert fail.identifier == 2
- res = self.cpu.get_int_value(deadframe, locs[0][0])
+ res = self.cpu.get_int_value(deadframe, locs[0])
assert res == 10
inputargs2 = [i0]
@@ -3916,13 +3929,13 @@
ResOperation(rop.INT_SUB, [i0, ConstInt(20)], i2),
ResOperation(rop.JUMP, [i2], None, descr=targettoken2),
]
- self.cpu.compile_bridge(None, faildescr, [inputargs2], locs,
operations2, looptoken)
+ self.cpu.compile_bridge(None, faildescr, inputargs2, locs,
operations2, looptoken)
deadframe = self.cpu.execute_token(looptoken, 2)
fail = self.cpu.get_latest_descr(deadframe)
locs = rebuild_locs_from_resumedata(fail, staticdata)
assert fail.identifier == 3
- res = self.cpu.get_int_value(deadframe, locs[0][0])
+ res = self.cpu.get_int_value(deadframe, locs[0])
assert res == -10
def test_int_force_ge_zero(self):
@@ -3968,7 +3981,7 @@
self.cpu.assembler.set_debug(False)
info = self.cpu.compile_loop(None, loop.inputargs, loop.operations,
looptoken)
locs = rebuild_locs_from_resumedata(faildescr, staticdata)
- bridge_info = self.cpu.compile_bridge(None, faildescr,
[bridge.inputargs],
+ bridge_info = self.cpu.compile_bridge(None, faildescr,
bridge.inputargs,
locs, bridge.operations,
looptoken)
self.cpu.assembler.set_debug(True) # always on untranslated
@@ -4069,7 +4082,7 @@
ResOperation(rop.JUMP, [i19], None, descr=targettoken1),
]
locs = rebuild_locs_from_resumedata(faildescr1, staticdata)
- self.cpu.compile_bridge(None, faildescr1, [inputargs], locs,
operations2, looptoken1)
+ self.cpu.compile_bridge(None, faildescr1, inputargs, locs,
operations2, looptoken1)
looptoken2 = JitCellToken()
inputargs = [BoxInt()]
@@ -4096,7 +4109,7 @@
operations = [
ResOperation(rop.FINISH, [], None, descr=BasicFinalDescr(99))
]
- self.cpu.compile_bridge(None, faildescr, [[]], [[]], operations,
looptoken)
+ self.cpu.compile_bridge(None, faildescr, [], [], operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, null_box.getref_base())
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 99
@@ -4297,7 +4310,7 @@
deadframe = self.cpu.force(token)
fail = self.cpu.get_latest_descr(deadframe)
locs = rebuild_locs_from_resumedata(fail, staticdata)
- values.append(self.cpu.get_int_value(deadframe, locs[0][0]))
+ values.append(self.cpu.get_int_value(deadframe, locs[0]))
return 42
FUNC = self.FuncType([llmemory.GCREF, lltype.Signed], lltype.Signed)
@@ -4326,7 +4339,7 @@
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 23
locs = rebuild_locs_from_resumedata(fail, staticdata)
- assert self.cpu.get_int_value(deadframe, locs[0][0]) == 42
+ assert self.cpu.get_int_value(deadframe, locs[0]) == 42
# make sure that force reads the registers from a zeroed piece of
# memory
assert values[0] == 0
@@ -4341,6 +4354,10 @@
bridge = parse("""
[i1, i2, px]
+ enter_frame(-1, descr=jitcode)
+ resume_put(i1, 0, 0)
+ resume_put(i2, 0, 1)
+ resume_put(px, 0, 2)
i3 = int_add(i1, i2)
i4 = int_add(i1, i3)
i5 = int_add(i1, i4)
@@ -4372,9 +4389,9 @@
finish(i1, descr=finaldescr)
""", namespace={'finaldescr': finaldescr, 'calldescr2': calldescr2,
'guarddescr': guarddescr, 'func2_ptr': func2_ptr,
- 'jitcode2': jitcode2})
+ 'jitcode2': jitcode2, 'jitcode': jitcode})
locs = rebuild_locs_from_resumedata(faildescr, staticdata)
- self.cpu.compile_bridge(None, faildescr, [bridge.inputargs], locs,
+ self.cpu.compile_bridge(None, faildescr, bridge.inputargs, locs,
bridge.operations, looptoken)
cpu = self.cpu
@@ -4424,7 +4441,7 @@
frame = lltype.cast_opaque_ptr(jitframe.JITFRAMEPTR, frame)
assert len(frame.jf_frame) == frame.jf_frame_info.jfi_frame_depth
locs = rebuild_locs_from_resumedata(guarddescr, staticdata)
- ref = self.cpu.get_ref_value(frame, locs[0][2])
+ ref = self.cpu.get_ref_value(frame, locs[2])
token = lltype.cast_opaque_ptr(jitframe.JITFRAMEPTR, ref)
assert token != frame
token = token.resolve()
@@ -4440,6 +4457,9 @@
def raising():
bridge = parse("""
[i1, i2]
+ enter_frame(-1, descr=jitcode)
+ resume_put(i1, 0, 0)
+ resume_put(i2, 0, 1)
enter_frame(1, descr=jitcode2)
px = guard_exception(ConstClass(xtp), descr=faildescr2)
i3 = int_add(i1, i2)
@@ -4471,9 +4491,10 @@
""", namespace={'finaldescr': BasicFinalDescr(42),
'faildescr2': BasicFailDescr(1),
'xtp': xtp, 'jitcode2': jitcode2,
+ 'jitcode': jitcode,
})
locs = rebuild_locs_from_resumedata(faildescr, staticdata)
- self.cpu.compile_bridge(None, faildescr, [bridge.inputargs], locs,
+ self.cpu.compile_bridge(None, faildescr, bridge.inputargs, locs,
bridge.operations, looptoken)
raise LLException(xtp, xptr)
diff --git a/rpython/jit/backend/x86/assembler.py
b/rpython/jit/backend/x86/assembler.py
--- a/rpython/jit/backend/x86/assembler.py
+++ b/rpython/jit/backend/x86/assembler.py
@@ -5,7 +5,6 @@
from rpython.jit.backend.llsupport.assembler import (GuardToken, BaseAssembler,
debug_bridge)
from rpython.jit.backend.llsupport.asmmemmgr import MachineDataBlockWrapper
-from rpython.jit.resume.backend import flatten
from rpython.jit.metainterp.history import Const, Box, VOID
from rpython.jit.metainterp.history import AbstractFailDescr, INT, REF, FLOAT
from rpython.rtyper.lltypesystem import lltype, rffi, rstr, llmemory
@@ -475,7 +474,7 @@
self.update_frame_depth(frame_depth_no_fixed_size +
JITFRAME_FIXED_SIZE)
#
size_excluding_failure_stuff = self.mc.get_relative_pos()
- self.resume_bytecode = regalloc.resumebuilder.finish(None, 0,
looptoken)
+ self.resume_bytecode = regalloc.resumebuilder.finish(looptoken)
self.write_pending_failure_recoveries()
full_size = self.mc.get_relative_pos()
#
@@ -513,7 +512,7 @@
return AsmInfo(ops_offset, rawstart + looppos,
size_excluding_failure_stuff - looppos)
- def assemble_bridge(self, logger, faildescr, inputframes,
backend_positions,
+ def assemble_bridge(self, logger, faildescr, inputargs, backend_positions,
operations, original_loop_token, log):
self.setup(original_loop_token)
@@ -522,12 +521,11 @@
operations = self._inject_debugging_code(faildescr, operations,
'b', descr_number)
- arglocs = self.rebuild_faillocs_from_descr(faildescr, inputframes,
+ arglocs = self.rebuild_faillocs_from_descr(faildescr, inputargs,
backend_positions)
- inputargs = flatten(inputframes)
regalloc = RegAlloc(self, self.cpu.translate_support_code)
startpos = self.mc.get_relative_pos()
- operations = regalloc.prepare_bridge(inputframes, arglocs,
+ operations = regalloc.prepare_bridge(inputargs, arglocs,
operations,
self.current_clt.allgcrefs,
self.current_clt.frame_info,
@@ -536,7 +534,7 @@
frame_depth_no_fixed_size = self._assemble(regalloc, inputargs,
operations)
codeendpos = self.mc.get_relative_pos()
self.resume_bytecode = regalloc.resumebuilder.finish(
- faildescr.rd_resume_bytecode, faildescr.rd_bytecode_position,
original_loop_token)
+ original_loop_token)
self.write_pending_failure_recoveries()
fullsize = self.mc.get_relative_pos()
#
diff --git a/rpython/jit/backend/x86/regalloc.py
b/rpython/jit/backend/x86/regalloc.py
--- a/rpython/jit/backend/x86/regalloc.py
+++ b/rpython/jit/backend/x86/regalloc.py
@@ -8,7 +8,7 @@
unpack_arraydescr, unpack_fielddescr, unpack_interiorfielddescr)
from rpython.jit.backend.llsupport.gcmap import allocate_gcmap
from rpython.jit.resume.backend import ResumeBuilder,\
- compute_vars_longevity, flatten
+ compute_vars_longevity
from rpython.jit.backend.llsupport.regalloc import (FrameManager, BaseRegalloc,
RegisterManager, TempBox, is_comparison_or_ovf_op)
from rpython.jit.backend.x86 import rx86
@@ -133,17 +133,16 @@
self.jump_target_descr = None
self.final_jump_op = None
- def _prepare(self, inputframes, operations, allgcrefs, descr=None,
+ def _prepare(self, inputargs, operations, allgcrefs, descr=None,
locs=None):
cpu = self.assembler.cpu
self.fm = X86FrameManager(cpu.get_baseofs_of_frame_field())
operations = cpu.gc_ll_descr.rewrite_assembler(cpu, operations,
allgcrefs)
# compute longevity of variables
- x = compute_vars_longevity(inputframes, operations, descr)
+ x = compute_vars_longevity(inputargs, operations, descr)
longevity, last_real_usage, frontend_liveness = x
- self.resumebuilder = ResumeBuilder(self, frontend_liveness, descr,
- inputframes, locs)
+ self.resumebuilder = ResumeBuilder(self, frontend_liveness, descr)
self.longevity = longevity
self.last_real_usage = last_real_usage
self.rm = gpr_reg_mgr_cls(self.longevity,
@@ -154,7 +153,7 @@
return operations
def prepare_loop(self, inputargs, operations, looptoken, allgcrefs):
- operations = self._prepare([inputargs], operations, allgcrefs)
+ operations = self._prepare(inputargs, operations, allgcrefs)
self._set_initial_bindings(inputargs, looptoken)
# note: we need to make a copy of inputargs because possibly_free_vars
# is also used on op args, which is a non-resizable list
@@ -165,11 +164,11 @@
self.min_bytes_before_label = 13
return operations
- def prepare_bridge(self, inputframes, arglocs, operations, allgcrefs,
+ def prepare_bridge(self, inputargs, arglocs, operations, allgcrefs,
frame_info, descr):
- operations = self._prepare(inputframes, operations, allgcrefs, descr,
+ operations = self._prepare(inputargs, operations, allgcrefs, descr,
locs=arglocs)
- self._update_bindings(arglocs, inputframes)
+ self._update_bindings(arglocs, inputargs)
self.min_bytes_before_label = 0
return operations
@@ -233,11 +232,10 @@
else:
return self.xrm.make_sure_var_in_reg(var, forbidden_vars)
- def _update_bindings(self, locs, inputframes):
+ def _update_bindings(self, locs, inputargs):
# XXX this should probably go to llsupport/regalloc.py
used = {}
i = 0
- inputargs = flatten(inputframes)
assert len(inputargs) == len(locs)
for loc in locs:
if loc is None: # xxx bit kludgy
diff --git a/rpython/jit/backend/x86/test/test_runner.py
b/rpython/jit/backend/x86/test/test_runner.py
--- a/rpython/jit/backend/x86/test/test_runner.py
+++ b/rpython/jit/backend/x86/test/test_runner.py
@@ -301,7 +301,7 @@
pos = 0
else:
locs = rebuild_locs_from_resumedata(descr, staticdata)
- pos = locs[0][0]
+ pos = locs[0]
result = self.cpu.get_int_value(deadframe, pos)
if guard == rop.GUARD_FALSE:
assert result == execute(self.cpu, None,
@@ -359,7 +359,7 @@
pos = 0
else:
locs = rebuild_locs_from_resumedata(descr, staticdata)
- pos = locs[0][0]
+ pos = locs[0]
result = self.cpu.get_int_value(deadframe, pos)
expected = execute(self.cpu, None, op, None, a, b).value
if guard == rop.GUARD_FALSE:
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
@@ -15,7 +15,7 @@
from rpython.jit.metainterp.optimize import InvalidLoop
from rpython.jit.metainterp.inliner import Inliner
from rpython.jit.codewriter import heaptracker, longlong
-from rpython.jit.resume.backend import flatten
+
def giveup():
from rpython.jit.metainterp.pyjitpl import SwitchToBlackhole
@@ -300,13 +300,13 @@
inputargs, operations, looptoken,
log=log, name=name)
-def do_compile_bridge(metainterp_sd, faildescr, inputframes,
+def do_compile_bridge(metainterp_sd, faildescr, inputargs,
inputlocs, operations, original_loop_token, log=True):
- metainterp_sd.logger_ops.log_bridge(flatten(inputframes), operations,
+ metainterp_sd.logger_ops.log_bridge(inputargs, operations,
"compiling")
assert isinstance(faildescr, AbstractFailDescr)
return metainterp_sd.cpu.compile_bridge(metainterp_sd.logger_ops,
- faildescr, inputframes,
+ faildescr, inputargs,
inputlocs, operations,
original_loop_token, log=log)
@@ -364,11 +364,11 @@
if metainterp_sd.warmrunnerdesc is not None: # for tests
metainterp_sd.warmrunnerdesc.memory_manager.keep_loop_alive(original_jitcell_token)
-def send_bridge_to_backend(jitdriver_sd, metainterp_sd, faildescr, inputframes,
+def send_bridge_to_backend(jitdriver_sd, metainterp_sd, faildescr, inputargs,
inputlocs, operations, original_loop_token):
if not we_are_translated():
show_procedures(metainterp_sd)
- seen = dict.fromkeys(flatten(inputframes))
+ seen = dict.fromkeys(inputargs)
TreeLoop.check_consistency_of_branch(operations, seen)
if metainterp_sd.warmrunnerdesc is not None:
hooks = metainterp_sd.warmrunnerdesc.hooks
@@ -400,7 +400,7 @@
ops_offset = asminfo.ops_offset
else:
ops_offset = None
- metainterp_sd.logger_ops.log_bridge(flatten(inputframes), operations,
+ metainterp_sd.logger_ops.log_bridge(inputargs, operations,
None, faildescr, ops_offset)
#
#if metainterp_sd.warmrunnerdesc is not None: # for tests
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
@@ -615,7 +615,6 @@
return 'TargetToken(%d)' % compute_unique_id(self)
class TreeLoop(object):
- inputframes = None
inputargs = None
inputlocs = None
operations = None
@@ -657,7 +656,7 @@
return self.operations
def get_display_text(self): # for graphpage.py
- return self.name + '\n' + repr(self.inputframes)
+ return self.name + '\n' + repr(self.inputargs)
def show(self, errmsg=None):
"NOT_RPYTHON"
@@ -666,7 +665,7 @@
def check_consistency(self): # for testing
"NOT_RPYTHON"
- self.check_consistency_of(self.inputframes, self.operations)
+ self.check_consistency_of(self.inputargs, self.operations)
for op in self.operations:
descr = op.getdescr()
if op.getopnum() == rop.LABEL and isinstance(descr, TargetToken):
@@ -719,7 +718,7 @@
def dump(self):
# RPython-friendly
- print '%r: inputargs =' % self, self._dump_args(self.inputframes)
+ print '%r: inputargs =' % self, self._dump_args(self.inputargs)
for op in self.operations:
args = op.getarglist()
print '\t', op.getopname(), self._dump_args(args), \
@@ -753,7 +752,7 @@
class History(object):
def __init__(self):
- self.inputframes = None
+ self.inputargs = None
self.inputlocs = None
self.operations = []
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
@@ -1978,7 +1978,7 @@
num_green_args = self.jitdriver_sd.num_green_args
original_greenkey = original_boxes[:num_green_args]
self.resumekey = compile.ResumeFromInterpDescr(original_greenkey)
- self.history.inputframes = [original_boxes[num_green_args:]]
+ self.history.inputargs = original_boxes[num_green_args:][:]
self.seen_loop_header_for_jdindex = -1
try:
self.interpret()
@@ -2121,7 +2121,7 @@
return ints[:], refs[:], floats[:]
def raise_continue_running_normally(self, live_arg_boxes, loop_token):
- self.history.inputframes = None
+ self.history.inputargs = None
self.history.inputlocs = None
self.history.operations = None
# For simplicity, we just raise ContinueRunningNormally here and
@@ -2359,7 +2359,7 @@
self.portal_call_depth = -1 # always one portal around
self.history = history.History()
state = self.rebuild_state_after_failure(resumedescr, deadframe)
- self.history.inputframes, self.history.inputlocs = state
+ self.history.inputargs, self.history.inputlocs = state
self.resumerecorder = ResumeRecorder(self, True)
finally:
rstack._stack_criticalcode_stop()
diff --git a/rpython/jit/resume/backend.py b/rpython/jit/resume/backend.py
--- a/rpython/jit/resume/backend.py
+++ b/rpython/jit/resume/backend.py
@@ -7,15 +7,11 @@
class LivenessAnalyzer(object):
- def __init__(self, inputframes=None):
+ def __init__(self):
self.liveness = {}
self.frame_starts = [0]
self.framestack = []
self.deps = {}
- if inputframes is not None:
- for frame in inputframes:
- self.frame_starts.append(self.frame_starts[-1] + len(frame))
- self.framestack.append(frame[:])
def enter_frame(self, pc, jitcode):
self.frame_starts.append(self.frame_starts[-1] + jitcode.num_regs())
@@ -93,28 +89,13 @@
raise Exception("should not be called")
class ResumeBuilder(object):
- def __init__(self, regalloc, frontend_liveness, descr, inputframes=None,
- inputlocs=None):
+ def __init__(self, regalloc, frontend_liveness, descr):
self.regalloc = regalloc
self.current_attachment = {}
self.frontend_liveness = frontend_liveness
self.frontend_pos = {}
self.virtuals = {}
self.builder = ResumeBytecodeBuilder()
- if inputlocs is not None:
- i = 0
- all = {}
- for frame_pos, frame in enumerate(inputframes):
- for pos_in_frame, box in enumerate(frame):
- if box is None or isinstance(box, Const) or box in all:
- loc_pos = -1
- else:
- loc_pos = inputlocs[i].get_jitframe_position()
- i += 1
- self.frontend_pos[box] = (frame_pos, pos_in_frame)
- all[box] = None
- if box not in self.current_attachment:
- self.current_attachment[box] = loc_pos
def get_box_pos(self, box):
if box in self.virtuals:
@@ -189,34 +170,11 @@
self._mark_visited(v, loc)
return self.builder.getpos()
- def finish(self, parent, parent_position, clt):
- return ResumeBytecode(self.builder.build(), self.builder.consts,
- parent, parent_position,
- clt)
+ def finish(self, clt):
+ return ResumeBytecode(self.builder.build(), self.builder.consts, clt)
-def flatten(inputframes):
- count = 0
- all = {}
- for frame in inputframes:
- for x in frame:
- if x is not None and x not in all:
- assert not isinstance(x, Const)
- count += 1
- all[x] = None
- inputargs = [None] * count
- pos = 0
- all = {}
- for frame in inputframes:
- for item in frame:
- if item is not None and item not in all:
- inputargs[pos] = item
- all[item] = None
- pos += 1
- return inputargs
-
-
-def compute_vars_longevity(inputframes, operations, descr=None):
+def compute_vars_longevity(inputargs, operations, descr=None):
# compute a dictionary that maps variables to index in
# operations that is a "last-time-seen"
@@ -228,12 +186,7 @@
last_used = {}
last_real_usage = {}
frontend_alive = {}
- if descr is None:
- inputargs = inputframes[0]
- liveness_analyzer = LivenessAnalyzer()
- else:
- inputargs = flatten(inputframes)
- liveness_analyzer = LivenessAnalyzer(inputframes)
+ liveness_analyzer = LivenessAnalyzer()
start_pos = 0
for position, op in enumerate(operations):
if op.is_guard():
diff --git a/rpython/jit/resume/optimizer.py b/rpython/jit/resume/optimizer.py
--- a/rpython/jit/resume/optimizer.py
+++ b/rpython/jit/resume/optimizer.py
@@ -6,23 +6,16 @@
class ResumeFrame(object):
def __init__(self, pc, jitcode, no=-1):
self.pc = pc
- if jitcode is None:
- assert no >= 0
- self.values = [None] * no
- else:
- assert isinstance(jitcode, JitCode)
- self.jitcode = jitcode
- self.values = [None] * jitcode.num_regs()
+ assert isinstance(jitcode, JitCode)
+ self.jitcode = jitcode
+ self.values = [None] * jitcode.num_regs()
class OptResumeBuilder(object):
- def __init__(self, opt, inpframes=None):
+ def __init__(self, opt):
self.framestack = []
self.last_flushed_pos = 0
self.opt = opt
self.virtuals = {}
- if inpframes is not None:
- for frame in inpframes:
- self.framestack.append(ResumeFrame(0, None, len(frame)))
def enter_frame(self, pc, jitcode):
self.framestack.append(ResumeFrame(pc, jitcode))
diff --git a/rpython/jit/resume/reader.py b/rpython/jit/resume/reader.py
--- a/rpython/jit/resume/reader.py
+++ b/rpython/jit/resume/reader.py
@@ -68,8 +68,6 @@
def _rebuild_until(self, rb, position):
self.consts = rb.consts
- if rb.parent is not None:
- self._rebuild_until(rb.parent, rb.parent_position)
self.interpret_until(rb, position)
def read(self, pos):
diff --git a/rpython/jit/resume/rescode.py b/rpython/jit/resume/rescode.py
--- a/rpython/jit/resume/rescode.py
+++ b/rpython/jit/resume/rescode.py
@@ -14,12 +14,9 @@
CLEAR_POSITION = 0xffff
class ResumeBytecode(object):
- def __init__(self, opcodes, consts, parent=None, parent_position=-1,
- loop=None):
+ def __init__(self, opcodes, consts, loop=None):
self.opcodes = opcodes
- self.parent = parent
self.consts = consts
- self.parent_position = parent_position
self.loop = loop
def dump(self, staticdata, resume_pos):
diff --git a/rpython/jit/resume/test/test_backend.py
b/rpython/jit/resume/test/test_backend.py
--- a/rpython/jit/resume/test/test_backend.py
+++ b/rpython/jit/resume/test/test_backend.py
@@ -146,15 +146,22 @@
bridge = parse("""
[i0]
+ enter_frame(-1, descr=jitcode)
+ resume_put(i0, 0, 0)
force_spill(i0)
guard_false(i0)
- """)
+ """, namespace={'jitcode': jitcode})
staticdata = MockStaticData([jitcode], [])
locs = rebuild_locs_from_resumedata(descr, staticdata)
- self.cpu.compile_bridge(None, descr, [bridge.inputargs], locs,
+ self.cpu.compile_bridge(None, descr, bridge.inputargs, locs,
bridge.operations, looptoken)
descr = bridge.operations[-1].getdescr()
res = descr.rd_resume_bytecode.dump(staticdata,
descr.rd_bytecode_position)
- assert res == "resume_put (3, 28) 0 0"
+ exp = preparse("""
+ enter_frame -1 name
+ resume_put (3, 1) 0 0
+ resume_put (3, 28) 0 0
+ """)
+ assert res == exp
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
@@ -5,7 +5,7 @@
ConstInt
from rpython.jit.resume.frontend import rebuild_from_resumedata
from rpython.jit.resume.rescode import ResumeBytecode, TAGBOX,\
- ResumeBytecodeBuilder, TAGCONST, TAGSMALLINT, TAGVIRTUAL
+ ResumeBytecodeBuilder, TAGCONST, TAGSMALLINT, TAGVIRTUAL, CLEAR_POSITION
from rpython.jit.resume.reader import AbstractResumeReader
from rpython.jit.resume.test.support import MockStaticData
from rpython.jit.metainterp.resoperation import rop
@@ -77,13 +77,18 @@
return index + 3
class RebuildingResumeReader(AbstractResumeReader):
- def unpack(self, r):
- tag, index = self.decode(r)
- assert tag == TAGBOX
- return index
-
def finish(self):
- return [[self.unpack(r) for r in f.registers] for f in self.framestack]
+ res = []
+ all = {}
+ for f in self.framestack:
+ for reg in f.registers:
+ if reg == CLEAR_POSITION:
+ continue
+ tag, index = self.decode(reg)
+ if tag == TAGBOX and index not in all:
+ all[index] = None # no duplicates
+ res.append(index)
+ return res
def rebuild_locs_from_resumedata(faildescr, staticdata):
return RebuildingResumeReader(staticdata).rebuild(faildescr)
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
