Author: Hakan Ardo <ha...@debian.org>
Branch: jit-targets
Changeset: r48797:faab93fbbec4
Date: 2011-11-05 18:06 +0100
http://bitbucket.org/pypy/pypy/changeset/faab93fbbec4/
Log: test_ajit.test_basic now passing
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
@@ -596,6 +596,7 @@
class ResumeFromInterpDescr(ResumeDescr):
def __init__(self, original_greenkey):
self.original_greenkey = original_greenkey
+ self.procedure_token = ProcedureToken()
def compile_and_attach(self, metainterp, new_loop):
# We managed to create a bridge going from the interpreter
@@ -605,34 +606,23 @@
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
redargs = new_loop.inputargs
- # We make a new LoopToken for this entry bridge, and stick it
- # to every guard in the loop.
- new_loop_token = make_loop_token(len(redargs), jitdriver_sd)
- new_loop.token = new_loop_token
+ self.procedure_token.outermost_jitdriver_sd = jitdriver_sd
+ new_loop.token = self.procedure_token
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_unoptimized_bridge_from_interp(
- self.original_greenkey,
- new_loop_token)
- # store the new loop in compiled_merge_points_wref too
- old_loop_tokens = metainterp.get_compiled_merge_points(
- self.original_greenkey)
- # it always goes at the end of the list, as it is the most
- # general loop token
- old_loop_tokens.append(new_loop_token)
- metainterp.set_compiled_merge_points(self.original_greenkey,
- old_loop_tokens)
+ jitdriver_sd.warmstate.attach_procedure_to_interp(
+ self.original_greenkey, self.procedure_token)
def reset_counter_from_failure(self):
pass
-def compile_new_bridge(metainterp, old_loop_tokens, resumekey, retraced=False):
+def compile_new_bridge(metainterp, resumekey, retraced=False):
"""Try to compile a new bridge leading from the beginning of the history
to some existing place.
"""
- from pypy.jit.metainterp.optimize import optimize_bridge
+ from pypy.jit.metainterp.optimizeopt import optimize_trace
# The history contains new operations to attach as the code for the
# failure of 'resumekey.guard_op'.
@@ -640,9 +630,11 @@
# 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_loop = create_empty_loop(metainterp)
- new_loop.inputargs = metainterp.history.inputargs[:]
+ new_loop.inputargs = inputargs = metainterp.history.inputargs[:]
# clone ops, as optimize_bridge can mutate the ops
- new_loop.operations = [op.clone() for op in metainterp.history.operations]
+ procedure_token = resumekey.procedure_token
+ new_loop.operations = [ResOperation(rop.LABEL, inputargs, None,
descr=TargetToken(procedure_token))] + \
+ [op.clone() for op in metainterp.history.operations]
metainterp_sd = metainterp.staticdata
state = metainterp.jitdriver_sd.warmstate
if isinstance(resumekey, ResumeAtPositionDescr):
@@ -650,38 +642,18 @@
else:
inline_short_preamble = True
try:
- target_loop_token = optimize_bridge(metainterp_sd, old_loop_tokens,
- new_loop, state.enable_opts,
- inline_short_preamble, retraced)
+ optimize_trace(metainterp_sd, new_loop, state.enable_opts)
except InvalidLoop:
debug_print("compile_new_bridge: got an InvalidLoop")
# XXX I am fairly convinced that optimize_bridge cannot actually raise
# InvalidLoop
debug_print('InvalidLoop in compile_new_bridge')
return None
- # Did it work?
- if target_loop_token is not None:
- # Yes, we managed to create a bridge. Dispatch to resumekey to
- # know exactly what we must do (ResumeGuardDescr/ResumeFromInterpDescr)
- prepare_last_operation(new_loop, target_loop_token)
- resumekey.compile_and_attach(metainterp, new_loop)
- record_loop_or_bridge(metainterp_sd, new_loop)
- return target_loop_token
-
-def prepare_last_operation(new_loop, target_loop_token):
- op = new_loop.operations[-1]
- if not isinstance(target_loop_token, TerminatingLoopToken):
- # normal case
- #op.setdescr(target_loop_token) # patch the jump target
- pass
- else:
- # The target_loop_token is a pseudo loop token,
- # e.g. loop_tokens_done_with_this_frame_void[0]
- # Replace the operation with the real operation we want, i.e. a FINISH
- descr = target_loop_token.finishdescr
- args = op.getarglist()
- new_op = ResOperation(rop.FINISH, args, None, descr=descr)
- new_loop.operations[-1] = new_op
+ # We managed to create a bridge. Dispatch to resumekey to
+ # know exactly what we must do (ResumeGuardDescr/ResumeFromInterpDescr)
+ resumekey.compile_and_attach(metainterp, new_loop)
+ record_loop_or_bridge(metainterp_sd, new_loop)
+ return new_loop.operations[-1].getdescr()
# ____________________________________________________________
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
@@ -74,15 +74,18 @@
self.import_state(start_targetop)
lastop = loop.operations[-1]
- assert lastop.getopnum() == rop.LABEL
- loop.operations = loop.operations[:-1]
- #if lastop.getopnum() == rop.LABEL or lastop.getopnum() == rop.JUMP:
- # loop.operations = loop.operations[:-1]
- #FIXME: FINISH
+ if lastop.getopnum() == rop.LABEL:
+ loop.operations = loop.operations[:-1]
+ else:
+ lastop = None
self.optimizer.propagate_all_forward(clear=False)
+
+ if not lastop:
+ self.optimizer.flush()
+ loop.operations = self.optimizer.get_newoperations()
+ return
- #if lastop.getopnum() == rop.LABEL:
if not self.did_peel_one: # Enforce the previous behaviour of always
peeling exactly one iteration (for now)
self.optimizer.flush()
KillHugeIntBounds(self.optimizer).apply()
@@ -97,8 +100,6 @@
self.close_loop(jumpop)
self.finilize_short_preamble(lastop)
start_targetop.getdescr().short_preamble = self.short
- #else:
- # loop.operations = self.optimizer.get_newoperations()
def export_state(self, targetop):
original_jump_args = targetop.getarglist()
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
@@ -2118,10 +2118,10 @@
loop_tokens = sd.loop_tokens_done_with_this_frame_float
else:
assert False
- self.history.record(rop.JUMP, exits, None)
- target_loop_token = compile.compile_new_bridge(self, loop_tokens,
- self.resumekey)
- if target_loop_token is not loop_tokens[0]:
+ # FIXME: kill TerminatingLoopToken?
+ self.history.record(rop.FINISH, exits, None,
descr=loop_tokens[0].finishdescr)
+ target_loop_token = compile.compile_new_bridge(self, self.resumekey)
+ if not target_loop_token:
compile.giveup()
def compile_exit_frame_with_exception(self, valuebox):
diff --git a/pypy/jit/metainterp/test/support.py
b/pypy/jit/metainterp/test/support.py
--- a/pypy/jit/metainterp/test/support.py
+++ b/pypy/jit/metainterp/test/support.py
@@ -16,15 +16,16 @@
from pypy.jit.codewriter import support
class FakeJitCell(object):
- __compiled_merge_points = []
- def get_compiled_merge_points(self):
- return self.__compiled_merge_points[:]
- def set_compiled_merge_points(self, lst):
- self.__compiled_merge_points = lst
+ __product_token = None
+ def get_procedure_token(self):
+ return self.__product_token
+ def set_procedure_token(self, token):
+ self.__product_token = token
class FakeWarmRunnerState(object):
- def attach_unoptimized_bridge_from_interp(self, greenkey, newloop):
- pass
+ def attach_procedure_to_interp(self, greenkey, procedure_token):
+ cell = self.jit_cell_at_key(greenkey)
+ cell.set_procedure_token(procedure_token)
def helper_func(self, FUNCPTR, func):
from pypy.rpython.annlowlevel import llhelper
@@ -132,16 +133,14 @@
def _run_with_machine_code(testself, args):
metainterp = testself.metainterp
num_green_args = metainterp.jitdriver_sd.num_green_args
- loop_tokens = metainterp.get_compiled_merge_points(args[:num_green_args])
- if len(loop_tokens) != 1:
- return NotImplemented
+ procedure_token = metainterp.get_procedure_token(args[:num_green_args])
# a loop was successfully created by _run_with_pyjitpl(); call it
cpu = metainterp.cpu
for i in range(len(args) - num_green_args):
x = args[num_green_args + i]
typecode = history.getkind(lltype.typeOf(x))
set_future_value(cpu, i, x, typecode)
- faildescr = cpu.execute_token(loop_tokens[0])
+ faildescr = cpu.execute_token(procedure_token)
assert faildescr.__class__.__name__.startswith('DoneWithThisFrameDescr')
if metainterp.jitdriver_sd.result_type == history.INT:
return cpu.get_latest_value_int(0)
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
http://mail.python.org/mailman/listinfo/pypy-commit
