Author: Hakan Ardo <[email protected]>
Branch: jit-targets
Changeset: r48828:82923819cf55
Date: 2011-11-06 16:22 +0100
http://bitbucket.org/pypy/pypy/changeset/82923819cf55/
Log: traces from interpreter now working again
diff --git a/pypy/jit/backend/llgraph/runner.py
b/pypy/jit/backend/llgraph/runner.py
--- a/pypy/jit/backend/llgraph/runner.py
+++ b/pypy/jit/backend/llgraph/runner.py
@@ -140,17 +140,17 @@
old, oldindex = faildescr._compiled_fail
llimpl.compile_redirect_fail(old, oldindex, c)
- def compile_loop(self, inputargs, operations, looptoken, log=True,
name=''):
+ def compile_loop(self, inputargs, operations, jitcell_token, log=True,
name=''):
"""In a real assembler backend, this should assemble the given
list of operations. Here we just generate a similar CompiledLoop
instance. The code here is RPython, whereas the code in llimpl
is not.
"""
c = llimpl.compile_start()
- clt = model.CompiledLoopToken(self, looptoken.number)
+ clt = model.CompiledLoopToken(self, jitcell_token.number)
clt.loop_and_bridges = [c]
clt.compiled_version = c
- looptoken.compiled_loop_token = clt
+ jitcell_token.compiled_loop_token = clt
self._compile_loop_or_bridge(c, inputargs, operations)
def free_loop_and_bridges(self, compiled_loop_token):
@@ -180,7 +180,7 @@
if isinstance(descr, Descr):
llimpl.compile_add_descr(c, descr.ofs, descr.typeinfo,
descr.arg_types)
- if isinstance(descr, history.ProcedureToken):
+ if isinstance(descr, history.JitCellToken):
assert False
if op.getopnum() != rop.JUMP:
llimpl.compile_add_loop_token(c, descr)
diff --git a/pypy/jit/metainterp/compile.py b/pypy/jit/metainterp/compile.py
--- a/pypy/jit/metainterp/compile.py
+++ b/pypy/jit/metainterp/compile.py
@@ -47,37 +47,39 @@
return loop
-def make_procedure_token(jitdriver_sd):
- procedure_token = JitCellToken()
- procedure_token.outermost_jitdriver_sd = jitdriver_sd
- return procedure_token
+def make_jitcell_token(jitdriver_sd):
+ jitcell_token = JitCellToken()
+ jitcell_token.outermost_jitdriver_sd = jitdriver_sd
+ return jitcell_token
def record_loop_or_bridge(metainterp_sd, loop):
"""Do post-backend recordings and cleanups on 'loop'.
"""
- # get the original loop token (corresponding to 'loop', or if that is
- # a bridge, to the loop that this bridge belongs to)
- looptoken = loop.token
- assert looptoken is not None
+ # get the original jitcell token corresponding to jitcell form which
+ # this trace starts
+ original_jitcell_token = loop.original_jitcell_token
+ assert original_jitcell_token is not None
if metainterp_sd.warmrunnerdesc is not None: # for tests
- assert looptoken.generation > 0 # has been registered with memmgr
- wref = weakref.ref(looptoken)
+ assert original_jitcell_token.generation > 0 # has been registered
with memmgr
+ wref = weakref.ref(original_jitcell_token)
for op in loop.operations:
descr = op.getdescr()
if isinstance(descr, ResumeDescr):
descr.wref_original_loop_token = wref # stick it there
n = descr.index
if n >= 0: # we also record the resumedescr number
- looptoken.compiled_loop_token.record_faildescr_index(n)
+
original_jitcell_token.compiled_loop_token.record_faildescr_index(n)
elif isinstance(descr, JitCellToken):
+ # for a CALL_ASSEMBLER ...
assert False, "FIXME"
elif isinstance(descr, TargetToken):
- # for a JUMP or a CALL_ASSEMBLER: record it as a potential jump.
+ # for a JUMP: record it as a potential jump.
# (the following test is not enough to prevent more complicated
# cases of cycles, but at least it helps in simple tests of
# test_memgr.py)
- if descr.procedure_token is not looptoken:
- looptoken.record_jump_to(descr.procedure_token)
+ if descr.original_jitcell_token is not original_jitcell_token:
+ assert descr.original_jitcell_token is not None
+
original_jitcell_token.record_jump_to(descr.original_jitcell_token)
op._descr = None # clear reference, mostly for tests
# record this looptoken on the QuasiImmut used in the code
if loop.quasi_immutable_deps is not None:
@@ -85,9 +87,9 @@
qmut.register_loop_token(wref)
# XXX maybe we should clear the dictionary here
# mostly for tests: make sure we don't keep a reference to the LoopToken
- loop.token = None
+ loop.original_jitcell_token = None
if not we_are_translated():
- loop._looptoken_number = looptoken.number
+ loop._looptoken_number = original_jitcell_token.number
# ____________________________________________________________
@@ -184,12 +186,12 @@
old_loop_tokens.append(loop_token)
def send_loop_to_backend(greenkey, jitdriver_sd, metainterp_sd, loop, type):
- jitdriver_sd.on_compile(metainterp_sd.logger_ops, loop.token,
+ original_jitcell_token = loop.original_jitcell_token
+ jitdriver_sd.on_compile(metainterp_sd.logger_ops, original_jitcell_token,
loop.operations, type, greenkey)
loopname = jitdriver_sd.warmstate.get_location_str(greenkey)
globaldata = metainterp_sd.globaldata
- loop_token = loop.token
- loop_token.number = n = globaldata.loopnumbering
+ original_jitcell_token.number = n = globaldata.loopnumbering
globaldata.loopnumbering += 1
if not we_are_translated():
@@ -201,7 +203,7 @@
debug_start("jit-backend")
try:
ops_offset = metainterp_sd.cpu.compile_loop(loop.inputargs, operations,
- loop.token, name=loopname)
+ original_jitcell_token,
name=loopname)
finally:
debug_stop("jit-backend")
metainterp_sd.profiler.end_backend()
@@ -216,7 +218,7 @@
metainterp_sd.logger_ops.log_loop(loop.inputargs, loop.operations, n,
type, ops_offset)
#
if metainterp_sd.warmrunnerdesc is not None: # for tests
- metainterp_sd.warmrunnerdesc.memory_manager.keep_loop_alive(loop.token)
+
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):
@@ -610,19 +612,18 @@
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
redargs = new_loop.inputargs
- procedure_token = make_procedure_token(jitdriver_sd)
- new_loop.token = procedure_token
+ new_loop.original_jitcell_token = jitcell_token =
make_jitcell_token(jitdriver_sd)
send_loop_to_backend(self.original_greenkey, metainterp.jitdriver_sd,
metainterp_sd, new_loop, "entry bridge")
# send the new_loop to warmspot.py, to be called directly the next time
jitdriver_sd.warmstate.attach_procedure_to_interp(
- self.original_greenkey, procedure_token)
+ self.original_greenkey, jitcell_token)
def reset_counter_from_failure(self):
pass
-def compile_new_bridge(metainterp, resumekey, retraced=False):
+def compile_trace(metainterp, resumekey, retraced=False):
"""Try to compile a new bridge leading from the beginning of the history
to some existing place.
"""
@@ -653,7 +654,7 @@
debug_print('InvalidLoop in compile_new_bridge')
return None
- if new_trace.operations[-1].getopnum() == rop.JUMP:
+ if new_trace.operations[-1].getopnum() != rop.LABEL:
# We managed to create a bridge. Dispatch to resumekey to
# know exactly what we must do (ResumeGuardDescr/ResumeFromInterpDescr)
target_token = new_trace.operations[-1].getdescr()
diff --git a/pypy/jit/metainterp/history.py b/pypy/jit/metainterp/history.py
--- a/pypy/jit/metainterp/history.py
+++ b/pypy/jit/metainterp/history.py
@@ -770,6 +770,7 @@
self.cell_token = cell_token
self.virtual_state = None
self.exported_state = None
+ self.original_jitcell_token = None
class TreeLoop(object):
inputargs = None
@@ -782,6 +783,11 @@
raise Exception("TreeLoop.token is killed")
token = property(_token, _token)
+ # This is the jitcell where the trace starts. Labels within the trace might
+ # belong to some other jitcells in the sens that jumping to this other
+ # jitcell will result in a jump to the label.
+ original_jitcell_token = None
+
def __init__(self, name):
self.name = name
# self.operations = list of ResOperations
@@ -816,6 +822,10 @@
def check_consistency(self): # for testing
"NOT_RPYTHON"
self.check_consistency_of(self.inputargs, self.operations)
+ for op in self.operations:
+ descr = op.getdescr()
+ if isinstance(descr, TargetToken):
+ assert descr.original_jitcell_token is
self.original_jitcell_token
@staticmethod
def check_consistency_of(inputargs, operations):
diff --git a/pypy/jit/metainterp/optimizeopt/unroll.py
b/pypy/jit/metainterp/optimizeopt/unroll.py
--- a/pypy/jit/metainterp/optimizeopt/unroll.py
+++ b/pypy/jit/metainterp/optimizeopt/unroll.py
@@ -78,12 +78,16 @@
start_label = None
jumpop = loop.operations[-1]
- assert jumpop.getopnum() == rop.JUMP
- loop.operations = loop.operations[:-1]
+ if jumpop.getopnum() == rop.JUMP:
+ loop.operations = loop.operations[:-1]
+ else:
+ jumpop = None
self.import_state(start_label)
self.optimizer.propagate_all_forward(clear=False)
+ if not jumpop:
+ return
if self.jump_to_already_compiled_trace(jumpop):
return
diff --git a/pypy/jit/metainterp/pyjitpl.py b/pypy/jit/metainterp/pyjitpl.py
--- a/pypy/jit/metainterp/pyjitpl.py
+++ b/pypy/jit/metainterp/pyjitpl.py
@@ -2114,7 +2114,7 @@
# FIXME: kill TerminatingLoopToken?
# FIXME: can we call compile_trace?
self.history.record(rop.FINISH, exits, None,
descr=loop_tokens[0].finishdescr)
- target_loop_token = compile.compile_new_bridge(self, self.resumekey)
+ target_loop_token = compile.compile_trace(self, self.resumekey)
if not target_loop_token:
compile.giveup()
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
