Author: Armin Rigo <[email protected]>
Branch: continulet-jit-3
Changeset: r57656:32322883e265
Date: 2012-09-29 07:36 +0200
http://bitbucket.org/pypy/pypy/changeset/32322883e265/
Log: Test fixes
diff --git a/pypy/jit/backend/llgraph/llimpl.py
b/pypy/jit/backend/llgraph/llimpl.py
--- a/pypy/jit/backend/llgraph/llimpl.py
+++ b/pypy/jit/backend/llgraph/llimpl.py
@@ -1810,8 +1810,9 @@
def reset_vable(jd, vable):
if jd.index_of_virtualizable != -1:
- fielddescr = jd.vable_token_descr
- do_setfield_gc_int(vable, fielddescr.ofs, 0)
+ fielddescr = jd.jit_frame_descr
+ do_setfield_gc_ptr(vable, fielddescr.ofs,
+ lltype.nullptr(llmemory.GCREF.TO))
def redirect_call_assembler(cpu, oldlooptoken, newlooptoken):
oldclt = oldlooptoken.compiled_loop_token
diff --git a/pypy/jit/metainterp/optimizeopt/virtualize.py
b/pypy/jit/metainterp/optimizeopt/virtualize.py
--- a/pypy/jit/metainterp/optimizeopt/virtualize.py
+++ b/pypy/jit/metainterp/optimizeopt/virtualize.py
@@ -1,6 +1,6 @@
from pypy.jit.codewriter.heaptracker import vtable2descr
from pypy.jit.metainterp.executor import execute
-from pypy.jit.metainterp.history import Const, ConstInt, BoxInt
+from pypy.jit.metainterp.history import Const, ConstInt, BoxInt, BoxPtr
from pypy.jit.metainterp.optimizeopt import optimizer
from pypy.jit.metainterp.optimizeopt.util import (make_dispatcher_method,
descrlist_dict, sort_descrs)
@@ -392,7 +392,7 @@
# get some constants
vrefinfo = self.optimizer.metainterp_sd.virtualref_info
c_cls = vrefinfo.jit_virtual_ref_const_class
- descr_virtual_token = vrefinfo.descr_virtual_token
+ descr_jit_frame = vrefinfo.descr_jit_frame
#
# Replace the VIRTUAL_REF operation with a virtual structure of type
# 'jit_virtual_ref'. The jit_virtual_ref structure may be forced soon,
@@ -400,8 +400,8 @@
op = ResOperation(rop.NEW_WITH_VTABLE, [c_cls], op.result)
vrefvalue = self.make_virtual(c_cls, op.result, op)
tokenbox = BoxPtr()
- self.emit_operation(ResOperation(rop.FORCE_TOKEN, [], tokenbox))
- vrefvalue.setfield(descr_virtual_token, self.getvalue(tokenbox))
+ self.emit_operation(ResOperation(rop.JIT_FRAME, [], tokenbox))
+ vrefvalue.setfield(descr_jit_frame, self.getvalue(tokenbox))
def optimize_VIRTUAL_REF_FINISH(self, op):
# This operation is used in two cases. In normal cases, it
@@ -426,10 +426,10 @@
seo(ResOperation(rop.SETFIELD_GC, op.getarglist(), None,
descr = vrefinfo.descr_forced))
- # - set 'virtual_token' to TOKEN_NONE
- args = [op.getarg(0), ConstInt(vrefinfo.TOKEN_NONE)]
+ # - set 'virtual_token' to TOKEN_NONE (== NULL)
+ args = [op.getarg(0), self.optimizer.cpu.ts.CONST_NULL]
seo(ResOperation(rop.SETFIELD_GC, args, None,
- descr = vrefinfo.descr_virtual_token))
+ descr = vrefinfo.descr_jit_frame))
# Note that in some cases the virtual in op.getarg(1) has been forced
# already. This is fine. In that case, and *if* a residual
# CALL_MAY_FORCE suddenly turns out to access it, then it will
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
@@ -1938,13 +1938,13 @@
self.staticdata.try_to_free_some_loops()
self.initialize_state_from_guard_failure(jitframe, key)
try:
- return self._handle_guard_failure(key)
+ return self._handle_guard_failure(jitframe, key)
finally:
self.resumekey_original_loop_token = None
self.staticdata.profiler.end_tracing()
debug_stop('jit-tracing')
- def _handle_guard_failure(self, key):
+ def _handle_guard_failure(self, jitframe, key):
self.current_merge_points = []
self.resumekey = key
self.seen_loop_header_for_jdindex = -1
@@ -1954,7 +1954,8 @@
else:
dont_change_position = False
try:
- self.prepare_resume_from_failure(key.guard_opnum,
dont_change_position)
+ self.prepare_resume_from_failure(key.guard_opnum, jitframe,
+ dont_change_position)
if self.resumekey_original_loop_token is None: # very rare case
raise SwitchToBlackhole(Counters.ABORT_BRIDGE)
self.interpret()
@@ -2090,7 +2091,8 @@
else: assert 0
self.jitdriver_sd.warmstate.execute_assembler(loop_token, *args)
- def prepare_resume_from_failure(self, opnum, dont_change_position=False):
+ def prepare_resume_from_failure(self, opnum, jitframe,
+ dont_change_position=False):
frame = self.framestack[-1]
if opnum == rop.GUARD_TRUE: # a goto_if_not that jumps only now
if not dont_change_position:
@@ -2104,7 +2106,7 @@
opnum == rop.GUARD_NONNULL_CLASS):
pass # the pc is already set to the *start* of the opcode
elif opnum == rop.GUARD_NO_EXCEPTION or opnum == rop.GUARD_EXCEPTION:
- exception = self.cpu.grab_exc_value()
+ exception = self.cpu.grab_exc_value(jitframe)
if exception:
self.execute_ll_raised(lltype.cast_opaque_ptr(rclass.OBJECTPTR,
exception))
diff --git a/pypy/jit/metainterp/test/test_compile.py
b/pypy/jit/metainterp/test/test_compile.py
--- a/pypy/jit/metainterp/test/test_compile.py
+++ b/pypy/jit/metainterp/test/test_compile.py
@@ -174,24 +174,27 @@
#
raiseme = None
# only two arguments must be passed in
- fail_descr = cpu.execute_token(loop_token, -156, -178)
+ jit_frame = cpu.execute_token(loop_token, -156, -178)
+ fail_descr = cpu.get_latest_descr(jit_frame)
assert fail_descr is FakeJitDriverSD().portal_finishtoken
#
EXC = lltype.GcStruct('EXC')
llexc = lltype.malloc(EXC)
raiseme = LLException("exception class", llexc)
- fail_descr = cpu.execute_token(loop_token, -156, -178)
+ jit_frame = cpu.execute_token(loop_token, -156, -178)
+ fail_descr = cpu.get_latest_descr(jit_frame)
assert isinstance(fail_descr, compile.PropagateExceptionDescr)
- got = cpu.grab_exc_value()
+ got = cpu.grab_exc_value(jit_frame)
assert lltype.cast_opaque_ptr(lltype.Ptr(EXC), got) == llexc
#
class FakeMetaInterpSD:
class ExitFrameWithExceptionRef(Exception):
pass
FakeMetaInterpSD.cpu = cpu
- fail_descr = cpu.execute_token(loop_token, -156, -178)
+ jit_frame = cpu.execute_token(loop_token, -156, -178)
+ fail_descr = cpu.get_latest_descr(jit_frame)
try:
- fail_descr.handle_fail(FakeMetaInterpSD(), None)
+ fail_descr.handle_fail(FakeMetaInterpSD(), None, jit_frame)
except FakeMetaInterpSD.ExitFrameWithExceptionRef, e:
assert lltype.cast_opaque_ptr(lltype.Ptr(EXC), e.args[1]) == llexc
else:
diff --git a/pypy/jit/metainterp/test/test_recursive.py
b/pypy/jit/metainterp/test/test_recursive.py
--- a/pypy/jit/metainterp/test/test_recursive.py
+++ b/pypy/jit/metainterp/test/test_recursive.py
@@ -7,6 +7,7 @@
from pypy.jit.codewriter.policy import StopAtXPolicy
from pypy.rpython.annlowlevel import hlstr
from pypy.jit.metainterp.warmspot import get_stats
+from pypy.jit.metainterp.jitframe import JITFRAMEPTR
class RecursiveTests:
@@ -817,13 +818,13 @@
llinterpcall(lltype.Void, check_ll_frame, subframe)
def check_ll_frame(ll_subframe):
# This is called with the low-level Struct that is the frame.
- # Check that the vable_token was correctly reset to zero.
+ # Check that the jit_frame was correctly reset to zero.
# Note that in order for that test to catch failures, it needs
- # three levels of recursion: the vable_token of the subframe
+ # three levels of recursion: the jit_frame of the subframe
# at the level 2 is set to a non-zero value when doing the
# call to the level 3 only. This used to fail when the test
# is run via pypy.jit.backend.x86.test.test_recursive.
- assert ll_subframe.vable_token == 0
+ assert ll_subframe.jit_frame == lltype.nullptr(JITFRAMEPTR.TO)
def main(codeno):
frame = Frame()
diff --git a/pypy/jit/metainterp/test/test_resume.py
b/pypy/jit/metainterp/test/test_resume.py
--- a/pypy/jit/metainterp/test/test_resume.py
+++ b/pypy/jit/metainterp/test/test_resume.py
@@ -18,6 +18,10 @@
rd_virtuals = None
rd_pendingfields = None
+class FakeJitFrame(object):
+ pass
+fakeframe = FakeJitFrame()
+
class FakeOptimizer(object):
def __init__(self, values):
@@ -102,13 +106,17 @@
CONST_NULL = ConstPtr(gcrefnull)
def __init__(self, values):
self.values = values
- def get_latest_value_count(self):
+ def get_latest_value_count(self, jitframe):
+ assert jitframe is fakeframe
return len(self.values)
- def get_latest_value_int(self, index):
+ def get_latest_value_int(self, jitframe, index):
+ assert jitframe is fakeframe
return self.values[index]
- def get_latest_value_ref(self, index):
+ def get_latest_value_ref(self, jitframe, index):
+ assert jitframe is fakeframe
return self.values[index]
- def get_latest_value_float(self, index):
+ def get_latest_value_float(self, jitframe, index):
+ assert jitframe is fakeframe
return self.values[index]
class MyBlackholeInterp:
@@ -181,12 +189,12 @@
#
cpu = MyCPU([42, gcref1, -66])
metainterp = MyMetaInterp(cpu)
- reader = ResumeDataDirectReader(metainterp, storage)
+ reader = ResumeDataDirectReader(metainterp, fakeframe, storage)
_next_section(reader, 42, 111, gcrefnull, 42, gcref1)
_next_section(reader, 222, 333)
_next_section(reader, 42, gcref1, -66)
#
- reader = ResumeDataBoxReader(storage, metainterp)
+ reader = ResumeDataBoxReader(fakeframe, storage, metainterp)
bi, br, bf = [None]*3, [None]*2, [None]*0
info = MyBlackholeInterp([lltype.Signed, lltype.Signed,
llmemory.GCREF, lltype.Signed,
@@ -222,7 +230,7 @@
storage.rd_numb = numb
#
cpu = MyCPU([])
- reader = ResumeDataDirectReader(MyMetaInterp(cpu), storage)
+ reader = ResumeDataDirectReader(MyMetaInterp(cpu), fakeframe, storage)
_next_section(reader, 100)
@@ -240,7 +248,8 @@
class FakeMetainterp(object):
_already_allocated_resume_virtuals = None
cpu = None
- reader = ResumeDataDirectReader(MyMetaInterp(None), FakeStorage())
+ reader = ResumeDataDirectReader(MyMetaInterp(None),
+ fakeframe, FakeStorage())
assert reader.force_all_virtuals() == ["allocated", reader.virtual_default]
# ____________________________________________________________
@@ -959,7 +968,7 @@
liveboxes = modifier.finish(FakeOptimizer({}))
assert storage.rd_snapshot is None
cpu = MyCPU([])
- reader = ResumeDataDirectReader(MyMetaInterp(cpu), storage)
+ reader = ResumeDataDirectReader(MyMetaInterp(cpu), fakeframe, storage)
_next_section(reader, sys.maxint, 2**16, -65)
_next_section(reader, 2, 3)
_next_section(reader, sys.maxint, 1, sys.maxint, 2**16)
@@ -985,7 +994,7 @@
class ResumeDataFakeReader(ResumeDataBoxReader):
"""Another subclass of AbstractResumeDataReader meant for tests."""
def __init__(self, storage, newboxes, metainterp):
- self._init(metainterp.cpu, storage)
+ self._init(metainterp.cpu, fakeframe, storage)
self.liveboxes = newboxes
self.metainterp = metainterp
self._prepare(storage)
diff --git a/pypy/jit/metainterp/test/test_virtualref.py
b/pypy/jit/metainterp/test/test_virtualref.py
--- a/pypy/jit/metainterp/test/test_virtualref.py
+++ b/pypy/jit/metainterp/test/test_virtualref.py
@@ -8,6 +8,7 @@
from pypy.jit.metainterp.test.support import LLJitMixin, OOJitMixin,
_get_jitcodes
from pypy.jit.metainterp.resoperation import rop
from pypy.jit.metainterp.virtualref import VirtualRefInfo
+from pypy.jit.metainterp import jitframe
debug_print = lloperation.llop.debug_print
@@ -109,20 +110,20 @@
if str(box._getrepr_()).endswith('JitVirtualRef')]
assert len(bxs2) == 1
JIT_VIRTUAL_REF = self.vrefinfo.JIT_VIRTUAL_REF
- bxs2[0].getref(lltype.Ptr(JIT_VIRTUAL_REF)).virtual_token = 1234567
+ someframe = lltype.malloc(jitframe.JITFRAMEPTR.TO, 5)
+ bxs2[0].getref(lltype.Ptr(JIT_VIRTUAL_REF)).jit_frame = someframe
#
# try reloading from blackhole.py's point of view
from pypy.jit.metainterp.resume import ResumeDataDirectReader
cpu = self.metainterp.cpu
- cpu.get_latest_value_count = lambda : len(guard_op.getfailargs())
- cpu.get_latest_value_int = lambda i:guard_op.getfailargs()[i].getint()
- cpu.get_latest_value_ref = lambda
i:guard_op.getfailargs()[i].getref_base()
- cpu.clear_latest_values = lambda count: None
+ cpu.get_latest_value_count = lambda f: len(guard_op.getfailargs())
+ cpu.get_latest_value_int = lambda
f,i:guard_op.getfailargs()[i].getint()
+ cpu.get_latest_value_ref = lambda
f,i:guard_op.getfailargs()[i].getref_base()
class FakeMetaInterpSd:
callinfocollection = None
FakeMetaInterpSd.cpu = cpu
resumereader = ResumeDataDirectReader(FakeMetaInterpSd(),
- guard_op.getdescr())
+ someframe, guard_op.getdescr())
vrefinfo = self.metainterp.staticdata.virtualref_info
lst = []
vrefinfo.continue_tracing = lambda vref, virtual: \
@@ -134,7 +135,8 @@
lst[0][0]) # assert correct type
#
# try reloading from pyjitpl's point of view
- self.metainterp.rebuild_state_after_failure(guard_op.getdescr())
+ self.metainterp.rebuild_state_after_failure(someframe,
+ guard_op.getdescr())
assert len(self.metainterp.framestack) == 1
assert len(self.metainterp.virtualref_boxes) == 2
assert self.metainterp.virtualref_boxes[0].value == bxs1[0].value
diff --git a/pypy/jit/metainterp/test/test_warmspot.py
b/pypy/jit/metainterp/test/test_warmspot.py
--- a/pypy/jit/metainterp/test/test_warmspot.py
+++ b/pypy/jit/metainterp/test/test_warmspot.py
@@ -1,10 +1,12 @@
import py
+from pypy.rpython.lltypesystem import lltype
from pypy.jit.metainterp.warmspot import get_stats
from pypy.rlib.jit import JitDriver, set_param, unroll_safe
from pypy.jit.backend.llgraph import runner
from pypy.jit.metainterp.test.support import LLJitMixin, OOJitMixin
from pypy.jit.metainterp.optimizeopt import ALL_OPTS_NAMES
+from pypy.jit.metainterp.jitframe import JITFRAMEPTR
class Exit(Exception):
@@ -333,7 +335,7 @@
class FakeFailDescr(object):
def __init__(self, no):
self.no = no
- def handle_fail(self, metainterp_sd, jitdrivers_sd):
+ def handle_fail(self, metainterp_sd, jitdrivers_sd, jitframe):
no = self.no
if no == 0:
raise metainterp_sd.warmrunnerdesc.DoneWithThisFrameInt(3)
@@ -372,12 +374,13 @@
calldescrof = nodescr
sizeof = nodescr
- def get_fail_descr_from_number(self, no):
- return FakeFailDescr(no)
-
def make_execute_token(self, *ARGS):
return "not callable"
+ def get_latest_descr(self, frame):
+ assert lltype.typeOf(frame) == JITFRAMEPTR
+ return FakeFailDescr(self._fail_index)
+
driver = JitDriver(reds = ['red'], greens = ['green'])
def f(green):
@@ -398,10 +401,15 @@
from pypy.rpython.llinterp import LLException
[jd] = self.desc.jitdrivers_sd
- assert jd._assembler_call_helper(0, 0) == 3
- assert jd._assembler_call_helper(1, 0) == 10
+ cpu = self.desc.cpu
+ fakeframe = lltype.malloc(JITFRAMEPTR.TO, 5)
+ cpu._fail_index = 0
+ assert jd._assembler_call_helper(fakeframe, 0) == 3
+ cpu._fail_index = 1
+ assert jd._assembler_call_helper(fakeframe, 0) == 10
try:
- jd._assembler_call_helper(3, 0)
+ cpu._fail_index = 3
+ jd._assembler_call_helper(fakeframe, 0)
except LLException, lle:
assert lle[0] == self.exc_vtable
else:
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
