[pypy-svn] r68538 - in pypy/trunk/pypy/jit: backend/cli backend/llgraph backend/test backend/x86 backend/x86/test metainterp metainterp/test

pedronis at codespeak.net pedronis at codespeak.net
Fri Oct 16 15:28:51 CEST 2009


Author: pedronis
Date: Fri Oct 16 15:28:49 2009
New Revision: 68538

Modified:
   pypy/trunk/pypy/jit/backend/cli/method.py
   pypy/trunk/pypy/jit/backend/cli/runner.py
   pypy/trunk/pypy/jit/backend/llgraph/runner.py
   pypy/trunk/pypy/jit/backend/test/runner_test.py
   pypy/trunk/pypy/jit/backend/test/test_ll_random.py
   pypy/trunk/pypy/jit/backend/test/test_random.py
   pypy/trunk/pypy/jit/backend/x86/assembler.py
   pypy/trunk/pypy/jit/backend/x86/runner.py
   pypy/trunk/pypy/jit/backend/x86/test/test_recompilation.py
   pypy/trunk/pypy/jit/backend/x86/test/test_regalloc.py
   pypy/trunk/pypy/jit/metainterp/compile.py
   pypy/trunk/pypy/jit/metainterp/history.py
   pypy/trunk/pypy/jit/metainterp/pyjitpl.py
   pypy/trunk/pypy/jit/metainterp/test/test_compile.py
   pypy/trunk/pypy/jit/metainterp/test/test_optimizeopt.py
   pypy/trunk/pypy/jit/metainterp/test/test_pyjitpl.py
   pypy/trunk/pypy/jit/metainterp/warmspot.py
Log:
(cfbolz, pedronis) move the responsability of numbering faildescrs to the
frontend, the numbering is still a global one, now execute_token returns just
an index.

We tried to fix the cli backend too, but didn't run the tests.



Modified: pypy/trunk/pypy/jit/backend/cli/method.py
==============================================================================
--- pypy/trunk/pypy/jit/backend/cli/method.py	(original)
+++ pypy/trunk/pypy/jit/backend/cli/method.py	Fri Oct 16 15:28:49 2009
@@ -262,6 +262,9 @@
         try:
             return self.cpu.failing_ops.index(op)
         except ValueError:
+            descr = op.descr
+            assert isinstance(descr, history.AbstractFailDescr)            
+            descr.get_index()
             self.cpu.failing_ops.append(op)
             return len(self.cpu.failing_ops)-1
 

Modified: pypy/trunk/pypy/jit/backend/cli/runner.py
==============================================================================
--- pypy/trunk/pypy/jit/backend/cli/runner.py	(original)
+++ pypy/trunk/pypy/jit/backend/cli/runner.py	Fri Oct 16 15:28:49 2009
@@ -135,7 +135,9 @@
         func = cliloop.funcbox.holder.GetFunc()
         func(self.get_inputargs())
         op = self.failing_ops[self.inputargs.get_failed_op()]
-        return op.descr
+        descr = op.descr
+        assert isinstance(descr, AbstractFailDescr)
+        return descr.get_index()
         
     def set_future_value_int(self, index, intvalue):
         self.get_inputargs().set_int(index, intvalue)

Modified: pypy/trunk/pypy/jit/backend/llgraph/runner.py
==============================================================================
--- pypy/trunk/pypy/jit/backend/llgraph/runner.py	(original)
+++ pypy/trunk/pypy/jit/backend/llgraph/runner.py	Fri Oct 16 15:28:49 2009
@@ -91,7 +91,6 @@
         self.stats.exec_jumps = 0
         self.stats.exec_conditional_jumps = 0
         self.memo_cast = llimpl.new_memo_cast()
-        self.fail_descrs = []
         llimpl._stats = self.stats
         llimpl._llinterp = LLInterpreter(self.rtyper)
         self._future_values = []
@@ -164,9 +163,9 @@
             if op.is_guard():
                 faildescr = op.descr
                 assert isinstance(faildescr, history.AbstractFailDescr)
-                index = llimpl.compile_add_fail(c, len(self.fail_descrs))
+                fail_index = faildescr.get_index()
+                index = llimpl.compile_add_fail(c, fail_index)
                 faildescr._compiled_fail = c, index
-                self.fail_descrs.append(faildescr)
                 for box in op.fail_args:
                     llimpl.compile_add_fail_arg(c, var2index[box])
             x = op.result
@@ -188,10 +187,10 @@
             compiled_version = targettoken._llgraph_compiled_version
             llimpl.compile_add_jump_target(c, compiled_version)
         elif op.opnum == rop.FINISH:
-            llimpl.compile_add_fail(c, len(self.fail_descrs))
             faildescr = op.descr
             assert isinstance(faildescr, history.AbstractFailDescr)
-            self.fail_descrs.append(faildescr)            
+            index = faildescr.get_index()
+            llimpl.compile_add_fail(c, index)
         else:
             assert False, "unknown operation"
 
@@ -207,7 +206,7 @@
         fail_index = llimpl.frame_execute(frame)
         # we hit a FAIL operation.
         self.latest_frame = frame
-        return self.fail_descrs[fail_index]
+        return fail_index
 
     def set_future_value_int(self, index, intvalue):
         llimpl.set_future_value_int(index, intvalue)

Modified: pypy/trunk/pypy/jit/backend/test/runner_test.py
==============================================================================
--- pypy/trunk/pypy/jit/backend/test/runner_test.py	(original)
+++ pypy/trunk/pypy/jit/backend/test/runner_test.py	Fri Oct 16 15:28:49 2009
@@ -39,7 +39,7 @@
             else:
                 raise NotImplementedError(box)
         res = self.cpu.execute_token(looptoken)
-        if res is operations[-1].descr:
+        if res == operations[-1].descr.index:
             self.guard_failed = False
         else:
             self.guard_failed = True
@@ -72,11 +72,11 @@
             results = [result]
         operations = [ResOperation(opnum, valueboxes, result),
                       ResOperation(rop.FINISH, results, None,
-                                   descr=BasicFailDescr())]
+                                   descr=BasicFailDescr(0))]
         if operations[0].is_guard():
             operations[0].fail_args = []
             if not descr:
-                descr = BasicFailDescr()
+                descr = BasicFailDescr(1)
         operations[0].descr = descr
         inputargs = []
         for box in valueboxes:
@@ -89,10 +89,9 @@
     def test_compile_linear_loop(self):
         i0 = BoxInt()
         i1 = BoxInt()
-        faildescr = BasicFailDescr()
         operations = [
             ResOperation(rop.INT_ADD, [i0, ConstInt(1)], i1),
-            ResOperation(rop.FINISH, [i1], None, descr=faildescr)
+            ResOperation(rop.FINISH, [i1], None, descr=BasicFailDescr(1))
             ]
         inputargs = [i0]
         looptoken = LoopToken()
@@ -101,18 +100,17 @@
         fail = self.cpu.execute_token(looptoken)
         res = self.cpu.get_latest_value_int(0)
         assert res == 3        
-        assert fail is faildescr
+        assert fail == 1
 
     def test_compile_loop(self):
         i0 = BoxInt()
         i1 = BoxInt()
         i2 = BoxInt()
-        faildescr = BasicFailDescr()
         looptoken = LoopToken()
         operations = [
             ResOperation(rop.INT_ADD, [i0, ConstInt(1)], i1),
             ResOperation(rop.INT_LE, [i1, ConstInt(9)], i2),
-            ResOperation(rop.GUARD_TRUE, [i2], None, descr=faildescr),
+            ResOperation(rop.GUARD_TRUE, [i2], None, descr=BasicFailDescr(2)),
             ResOperation(rop.JUMP, [i1], None, descr=looptoken),
             ]
         inputargs = [i0]
@@ -121,7 +119,7 @@
         self.cpu.compile_loop(inputargs, operations, looptoken)
         self.cpu.set_future_value_int(0, 2)
         fail = self.cpu.execute_token(looptoken)
-        assert fail is faildescr
+        assert fail == 2
         res = self.cpu.get_latest_value_int(0)
         assert res == 10
 
@@ -131,12 +129,11 @@
         i0 = BoxInt()
         i1 = BoxInt()
         i2 = BoxInt()
-        faildescr = BasicFailDescr()
         looptoken = LoopToken()
         operations = [
             ResOperation(rop.INT_ADD, [i0, ConstInt(1)], i1),
             ResOperation(rop.INT_LE, [i1, ConstInt(9)], i2),
-            ResOperation(rop.GUARD_TRUE, [i2], None, descr=faildescr),
+            ResOperation(rop.GUARD_TRUE, [i2], None, descr=BasicFailDescr()),
             ResOperation(rop.JUMP, [i1], None, descr=looptoken),
             ]
         inputargs = [i0]
@@ -154,8 +151,8 @@
         i0 = BoxInt()
         i1 = BoxInt()
         i2 = BoxInt()
-        faildescr1 = BasicFailDescr()
-        faildescr2 = BasicFailDescr()
+        faildescr1 = BasicFailDescr(1)
+        faildescr2 = BasicFailDescr(2)
         looptoken = LoopToken()
         operations = [
             ResOperation(rop.INT_ADD, [i0, ConstInt(1)], i1),
@@ -180,7 +177,7 @@
 
         self.cpu.set_future_value_int(0, 2)
         fail = self.cpu.execute_token(looptoken)
-        assert fail is faildescr2
+        assert fail == 2
         res = self.cpu.get_latest_value_int(0)
         assert res == 20
 
@@ -189,6 +186,8 @@
         class UntouchableFailDescr(AbstractFailDescr):
             def __setattr__(self, name, value):
                 py.test.fail("finish descrs should not be touched")
+            def get_index(self):
+                return 7
         faildescr = UntouchableFailDescr() # to check that is not touched
         looptoken = LoopToken()
         operations = [
@@ -197,7 +196,7 @@
         self.cpu.compile_loop([i0], operations, looptoken)
         self.cpu.set_future_value_int(0, 99)
         fail = self.cpu.execute_token(looptoken)
-        assert fail is faildescr
+        assert fail == 7
         res = self.cpu.get_latest_value_int(0)
         assert res == 99
 
@@ -207,7 +206,7 @@
             ]
         self.cpu.compile_loop([], operations, looptoken)
         fail = self.cpu.execute_token(looptoken)
-        assert fail is faildescr        
+        assert fail == 7
         res = self.cpu.get_latest_value_int(0)
         assert res == 42
 
@@ -217,7 +216,7 @@
             ]
         self.cpu.compile_loop([], operations, looptoken)
         fail = self.cpu.execute_token(looptoken)
-        assert fail is faildescr
+        assert fail == 7
 
     def test_execute_operations_in_env(self):
         cpu = self.cpu
@@ -277,9 +276,9 @@
                 ops = [
                     ResOperation(opnum, [v1, v2], v_res),
                     ResOperation(rop.GUARD_NO_OVERFLOW, [], None,
-                                 descr=BasicFailDescr()),
+                                 descr=BasicFailDescr(1)),
                     ResOperation(rop.FINISH, [v_res], None,
-                                 descr=BasicFailDescr()),
+                                 descr=BasicFailDescr(2)),
                     ]
                 ops[1].fail_args = []
             else:
@@ -287,8 +286,8 @@
                 ops = [
                     ResOperation(opnum, [v1, v2], v_res),
                     ResOperation(rop.GUARD_OVERFLOW, [], None,
-                                 descr=BasicFailDescr()),
-                    ResOperation(rop.FINISH, [], None, descr=BasicFailDescr()),
+                                 descr=BasicFailDescr(1)),
+                    ResOperation(rop.FINISH, [], None, descr=BasicFailDescr(2)),
                     ]
                 ops[1].fail_args = [v_res]
             #
@@ -301,9 +300,9 @@
                 self.cpu.set_future_value_int(1, y)
                 fail = self.cpu.execute_token(looptoken)
                 if (z == boom) ^ reversed:
-                    assert fail is ops[1].descr
+                    assert fail == 1
                 else:
-                    assert fail is ops[-1].descr
+                    assert fail == 2
                 if z != boom:
                     assert self.cpu.get_latest_value_int(0) == z
                 assert not self.cpu.get_exception()
@@ -724,7 +723,7 @@
             jumpargs.insert(index_counter, i1)
             #
             looptoken = LoopToken()
-            faildescr = BasicFailDescr()        
+            faildescr = BasicFailDescr(15)
             operations = [
                 ResOperation(rop.INT_SUB, [i0, ConstInt(1)], i1),
                 ResOperation(rop.INT_GE, [i1, ConstInt(0)], i2),
@@ -761,7 +760,7 @@
                     assert 0
             #
             fail = self.cpu.execute_token(looptoken)
-            assert fail is faildescr
+            assert fail == 15
             #
             dstvalues = values[:]
             for _ in range(11):
@@ -790,8 +789,8 @@
             py.test.skip("requires floats")
         fboxes = [BoxFloat() for i in range(12)]
         i2 = BoxInt()
-        faildescr1 = BasicFailDescr()
-        faildescr2 = BasicFailDescr()
+        faildescr1 = BasicFailDescr(1)
+        faildescr2 = BasicFailDescr(2)
         operations = [
             ResOperation(rop.FLOAT_LE, [fboxes[0], ConstFloat(9.2)], i2),
             ResOperation(rop.GUARD_TRUE, [i2], None, descr=faildescr1),
@@ -813,7 +812,7 @@
         for i in range(len(fboxes)):
             self.cpu.set_future_value_float(i, 13.5 + 6.73 * i)
         fail = self.cpu.execute_token(looptoken)
-        assert fail is faildescr2
+        assert fail == 2
         res = self.cpu.get_latest_value_float(0)
         assert res == 8.5
         for i in range(1, len(fboxes)):
@@ -848,7 +847,7 @@
             else:
                 assert 0
             operations.append(ResOperation(opnum, boxargs, boxres))
-        faildescr = BasicFailDescr()
+        faildescr = BasicFailDescr(1)
         operations.append(ResOperation(rop.FINISH, [], None,
                                        descr=faildescr))
         looptoken = LoopToken()
@@ -864,7 +863,7 @@
                 assert 0
         #
         fail = self.cpu.execute_token(looptoken)
-        assert fail is faildescr
+        assert fail == 1
 
 
 class LLtypeBackendTest(BaseBackendTest):

Modified: pypy/trunk/pypy/jit/backend/test/test_ll_random.py
==============================================================================
--- pypy/trunk/pypy/jit/backend/test/test_ll_random.py	(original)
+++ pypy/trunk/pypy/jit/backend/test/test_ll_random.py	Fri Oct 16 15:28:49 2009
@@ -2,7 +2,6 @@
 from pypy.rpython.lltypesystem import lltype, llmemory, rclass, rffi, rstr
 from pypy.jit.backend.test import test_random
 from pypy.jit.metainterp.resoperation import ResOperation, rop
-from pypy.jit.metainterp.history import BasicFailDescr
 from pypy.jit.metainterp.history import ConstInt, ConstPtr
 from pypy.jit.metainterp.history import ConstAddr, BoxPtr, BoxInt
 from pypy.rpython.annlowlevel import llhelper
@@ -450,7 +449,7 @@
         descr = builder.cpu.calldescrof(TP, TP.ARGS, TP.RESULT)
         self.put(builder, args, descr)
         op = ResOperation(rop.GUARD_NO_EXCEPTION, [], None,
-                          descr=BasicFailDescr())
+                          descr=builder.make_fail_descr())
         op.fail_args = fail_subset
         builder.loop.operations.append(op)
 
@@ -472,7 +471,7 @@
         _, vtableptr = builder.get_random_structure_type_and_vtable(r)
         exc_box = ConstAddr(llmemory.cast_ptr_to_adr(vtableptr), builder.cpu)
         op = ResOperation(rop.GUARD_EXCEPTION, [exc_box], BoxPtr(),
-                          descr=BasicFailDescr())
+                          descr=builder.make_fail_descr())
         op.fail_args = builder.subset_of_intvars(r)
         op._exc_box = None
         builder.should_fail_by = op
@@ -495,7 +494,7 @@
         assert builder.cpu.get_exception()
         builder.cpu.clear_exception()
         op = ResOperation(rop.GUARD_EXCEPTION, [exc_box], BoxPtr(),
-                          descr=BasicFailDescr())
+                          descr=builder.make_fail_descr())
         op.fail_args = fail_subset
         builder.loop.operations.append(op)
 
@@ -513,7 +512,7 @@
         assert builder.cpu.get_exception()
         builder.cpu.clear_exception()
         op = ResOperation(rop.GUARD_NO_EXCEPTION, [], BoxPtr(),
-                          descr=BasicFailDescr())
+                          descr=builder.make_fail_descr())
         op._exc_box = ConstAddr(llmemory.cast_ptr_to_adr(exc), builder.cpu)
         op.fail_args = builder.subset_of_intvars(r)
         builder.should_fail_by = op
@@ -539,7 +538,7 @@
                 break
         other_box = ConstAddr(llmemory.cast_ptr_to_adr(vtableptr), builder.cpu)
         op = ResOperation(rop.GUARD_EXCEPTION, [other_box], BoxPtr(),
-                          descr=BasicFailDescr())
+                          descr=builder.make_fail_descr())
         op._exc_box = ConstAddr(llmemory.cast_ptr_to_adr(exc), builder.cpu)
         op.fail_args = builder.subset_of_intvars(r)
         builder.should_fail_by = op

Modified: pypy/trunk/pypy/jit/backend/test/test_random.py
==============================================================================
--- pypy/trunk/pypy/jit/backend/test/test_random.py	(original)
+++ pypy/trunk/pypy/jit/backend/test/test_random.py	Fri Oct 16 15:28:49 2009
@@ -18,6 +18,8 @@
         self.operations = subops
 
 class OperationBuilder(object):
+    failnumbering = 0
+    
     def __init__(self, cpu, loop, vars):
         self.cpu = cpu
         self.loop = loop
@@ -34,6 +36,12 @@
         self.counter = 0
         assert len(self.intvars) == len(dict.fromkeys(self.intvars))
 
+    @classmethod
+    def make_fail_descr(cls):
+        descr = BasicFailDescr(cls.failnumbering)
+        cls.failnumbering += 1
+        return descr
+        
     def fork(self, cpu, loop, vars):
         fork = self.__class__(cpu, loop, vars)
         fork.prebuilt_ptr_consts = self.prebuilt_ptr_consts
@@ -281,7 +289,7 @@
             builder.intvars[:] = original_intvars
         else:
             op = ResOperation(rop.GUARD_NO_OVERFLOW, [], None)
-        op.descr = BasicFailDescr()
+        op.descr = builder.make_fail_descr()
         op.fail_args = fail_subset
         builder.loop.operations.append(op)
 
@@ -342,7 +350,7 @@
     def produce_into(self, builder, r):
         op, passing = self.gen_guard(builder, r)
         builder.loop.operations.append(op)
-        op.descr = BasicFailDescr()
+        op.descr = builder.make_fail_descr()
         op.fail_args = builder.subset_of_intvars(r)
         if not passing:
             builder.should_fail_by = op
@@ -546,7 +554,7 @@
                 endvars.append(v)
         r.shuffle(endvars)
         loop.operations.append(ResOperation(rop.FINISH, endvars, None,
-                                            descr=BasicFailDescr()))
+                                            descr=BasicFailDescr(-2)))
         if builder.should_fail_by:
             self.should_fail_by = builder.should_fail_by
             self.guard_op = builder.guard_op
@@ -592,7 +600,7 @@
             else:
                 raise NotImplementedError(box)
         fail = cpu.execute_token(self.loop.token)
-        assert fail is self.should_fail_by.descr
+        assert fail == self.should_fail_by.descr.index
         for i, v in enumerate(self.get_fail_args()):
             if isinstance(v, (BoxFloat, ConstFloat)):
                 value = cpu.get_latest_value_float(i)
@@ -621,7 +629,7 @@
             else:
                 op = ResOperation(rop.GUARD_EXCEPTION, [guard_op._exc_box],
                                   BoxPtr())
-            op.descr = BasicFailDescr()
+            op.descr = self.builder.make_fail_descr()
             op.fail_args = []
             return op
 

Modified: pypy/trunk/pypy/jit/backend/x86/assembler.py
==============================================================================
--- pypy/trunk/pypy/jit/backend/x86/assembler.py	(original)
+++ pypy/trunk/pypy/jit/backend/x86/assembler.py	Fri Oct 16 15:28:49 2009
@@ -789,7 +789,7 @@
         mc = mc._mc
         mc.LEA(esp, addr_add(imm(0), ebp, (-RET_BP + 2) * WORD))
         assert isinstance(faildescr, AbstractFailDescr)
-        fail_index = self.cpu.make_fail_index(faildescr)
+        fail_index = faildescr.get_index()
         mc.MOV(eax, imm(fail_index))
         mc.POP(edi)
         mc.POP(esi)

Modified: pypy/trunk/pypy/jit/backend/x86/runner.py
==============================================================================
--- pypy/trunk/pypy/jit/backend/x86/runner.py	(original)
+++ pypy/trunk/pypy/jit/backend/x86/runner.py	Fri Oct 16 15:28:49 2009
@@ -21,7 +21,6 @@
         AbstractLLCPU.__init__(self, rtyper, stats, translate_support_code,
                                gcdescr)
         self._bootstrap_cache = {}
-        self._faildescr_list = []
 
     def setup(self):
         self.assembler = Assembler386(self, self.translate_support_code)
@@ -38,11 +37,6 @@
     def compile_bridge(self, faildescr, inputargs, operations):
         self.assembler.assemble_bridge(faildescr, inputargs, operations)
 
-    def make_fail_index(self, faildescr):
-        index = len(self._faildescr_list)
-        self._faildescr_list.append(faildescr)
-        return index
-
     def set_future_value_int(self, index, intvalue):
         assert index < MAX_FAIL_BOXES, "overflow!"
         self.assembler.fail_boxes_int[index] = intvalue
@@ -71,9 +65,8 @@
     def execute_token(self, executable_token):
         addr = executable_token._x86_bootstrap_code
         func = rffi.cast(lltype.Ptr(self.BOOTSTRAP_TP), addr)
-        faildescr_index = self._execute_call(func)
-        faildescr = self._faildescr_list[faildescr_index]
-        return faildescr       
+        fail_index = self._execute_call(func)
+        return fail_index
 
     def _execute_call(self, func):
         # help flow objspace

Modified: pypy/trunk/pypy/jit/backend/x86/test/test_recompilation.py
==============================================================================
--- pypy/trunk/pypy/jit/backend/x86/test/test_recompilation.py	(original)
+++ pypy/trunk/pypy/jit/backend/x86/test/test_recompilation.py	Fri Oct 16 15:28:49 2009
@@ -8,7 +8,7 @@
         [i0]
         i1 = int_add(i0, 1)
         i2 = int_lt(i1, 20)
-        guard_true(i2) [i1]
+        guard_true(i2, descr=fdescr1) [i1]
         jump(i1)
         '''
         loop = self.interpret(ops, [0])
@@ -16,12 +16,12 @@
         ops = '''
         [i1]
         i3 = int_add(i1, 1)
-        finish(i3)
+        finish(i3, descr=fdescr2)
         '''
         bridge = self.attach_bridge(ops, loop, -2)
         self.cpu.set_future_value_int(0, 0)
         fail = self.run(loop)
-        assert fail is bridge.operations[-1].descr
+        assert fail == 2
         assert self.getint(0) == 21
     
     def test_compile_bridge_deeper(self):
@@ -29,7 +29,7 @@
         [i0]
         i1 = int_add(i0, 1)
         i2 = int_lt(i1, 20)
-        guard_true(i2) [i1]
+        guard_true(i2, descr=fdescr1) [i1]
         jump(i1)
         '''
         loop = self.interpret(ops, [0])
@@ -44,7 +44,7 @@
         i7 = int_add(i5, i4)
         i8 = int_add(i7, 1)
         i9 = int_add(i8, 1)
-        finish(i3, i4, i5, i6, i7, i8, i9)
+        finish(i3, i4, i5, i6, i7, i8, i9, descr=fdescr2)
         '''
         bridge = self.attach_bridge(ops, loop, -2)
         descr = loop.operations[2].descr
@@ -52,7 +52,7 @@
         assert new > previous
         self.cpu.set_future_value_int(0, 0)
         fail = self.run(loop)
-        assert fail is bridge.operations[-1].descr
+        assert fail == 2
         assert self.getint(0) == 21
         assert self.getint(1) == 22
         assert self.getint(2) == 23
@@ -63,12 +63,12 @@
         [i0, i10, i11, i12, i13, i14, i15, i16]
         i1 = int_add(i0, 1)
         i2 = int_lt(i1, 20)
-        guard_true(i2) [i1]
+        guard_true(i2, descr=fdescr1) [i1]
         jump(i1, i10, i11, i12, i13, i14, i15, i16)
         ''', [0])
         other_loop = self.interpret('''
         [i3]
-        guard_false(i3) [i3]
+        guard_false(i3, descr=fdescr2) [i3]
         jump(i3)
         ''', [1])
         ops = '''
@@ -78,7 +78,7 @@
         bridge = self.attach_bridge(ops, other_loop, 0, looptoken=loop.token)
         self.cpu.set_future_value_int(0, 1)
         fail = self.run(other_loop)
-        assert fail is loop.operations[2].descr
+        assert fail == 1
 
     def test_bridge_jumps_to_self_deeper(self):
         loop = self.interpret('''

Modified: pypy/trunk/pypy/jit/backend/x86/test/test_regalloc.py
==============================================================================
--- pypy/trunk/pypy/jit/backend/x86/test/test_regalloc.py	(original)
+++ pypy/trunk/pypy/jit/backend/x86/test/test_regalloc.py	Fri Oct 16 15:28:49 2009
@@ -4,7 +4,7 @@
 
 import py
 from pypy.jit.metainterp.history import ResOperation, BoxInt, ConstInt,\
-     BoxPtr, ConstPtr, LoopToken
+     BoxPtr, ConstPtr, LoopToken, BasicFailDescr
 from pypy.jit.metainterp.resoperation import rop, ResOperation
 from pypy.jit.backend.llsupport.descr import GcCache
 from pypy.jit.backend.x86.runner import CPU
@@ -81,6 +81,10 @@
                                             lltype.Ptr(rclass.OBJECT_VTABLE))
     raising_calldescr = cpu.calldescrof(FPTR.TO, FPTR.TO.ARGS, FPTR.TO.RESULT)
 
+    fdescr1 = BasicFailDescr(1)
+    fdescr2 = BasicFailDescr(2)
+    fdescr3 = BasicFailDescr(3)
+
     namespace = locals().copy()
     type_system = 'lltype'
 

Modified: pypy/trunk/pypy/jit/metainterp/compile.py
==============================================================================
--- pypy/trunk/pypy/jit/metainterp/compile.py	(original)
+++ pypy/trunk/pypy/jit/metainterp/compile.py	Fri Oct 16 15:28:49 2009
@@ -113,42 +113,58 @@
 
 # ____________________________________________________________
 
-class DoneWithThisFrameDescrVoid(AbstractFailDescr):
+class _DoneWithThisFrameDescr(AbstractFailDescr):
+
+    def __init__(self, lst):
+        "NOT_RPYTHON"        
+        self.index = len(lst)
+        lst.append(self)
+
+    def get_index(self):
+        return self.index
+
+class DoneWithThisFrameDescrVoid(_DoneWithThisFrameDescr):
     def handle_fail(self, metainterp_sd):
         assert metainterp_sd.result_type == 'void'
         raise metainterp_sd.DoneWithThisFrameVoid()
 
-class DoneWithThisFrameDescrInt(AbstractFailDescr):
+class DoneWithThisFrameDescrInt(_DoneWithThisFrameDescr):
     def handle_fail(self, metainterp_sd):
         assert metainterp_sd.result_type == 'int'
         result = metainterp_sd.cpu.get_latest_value_int(0)
         raise metainterp_sd.DoneWithThisFrameInt(result)
 
-class DoneWithThisFrameDescrRef(AbstractFailDescr):
+class DoneWithThisFrameDescrRef(_DoneWithThisFrameDescr):
     def handle_fail(self, metainterp_sd):
         assert metainterp_sd.result_type == 'ref'
         cpu = metainterp_sd.cpu
         result = cpu.get_latest_value_ref(0)
         raise metainterp_sd.DoneWithThisFrameRef(cpu, result)
 
-class DoneWithThisFrameDescrFloat(AbstractFailDescr):
+class DoneWithThisFrameDescrFloat(_DoneWithThisFrameDescr):
     def handle_fail(self, metainterp_sd):
         assert metainterp_sd.result_type == 'float'
         result = metainterp_sd.cpu.get_latest_value_float(0)
         raise metainterp_sd.DoneWithThisFrameFloat(result)
 
-class ExitFrameWithExceptionDescrRef(AbstractFailDescr):
+class ExitFrameWithExceptionDescrRef(_DoneWithThisFrameDescr):
     def handle_fail(self, metainterp_sd):
         cpu = metainterp_sd.cpu
         value = cpu.get_latest_value_ref(0)
         raise metainterp_sd.ExitFrameWithExceptionRef(cpu, value)
 
-done_with_this_frame_descr_void = DoneWithThisFrameDescrVoid()
-done_with_this_frame_descr_int = DoneWithThisFrameDescrInt()
-done_with_this_frame_descr_ref = DoneWithThisFrameDescrRef()
-done_with_this_frame_descr_float = DoneWithThisFrameDescrFloat()
-exit_frame_with_exception_descr_ref = ExitFrameWithExceptionDescrRef()
 
+done_with_this_frame_descrs = []
+done_with_this_frame_descr_void = DoneWithThisFrameDescrVoid(
+                                           done_with_this_frame_descrs)
+done_with_this_frame_descr_int = DoneWithThisFrameDescrInt(
+                                           done_with_this_frame_descrs)
+done_with_this_frame_descr_ref = DoneWithThisFrameDescrRef(
+                                           done_with_this_frame_descrs)
+done_with_this_frame_descr_float = DoneWithThisFrameDescrFloat(
+                                           done_with_this_frame_descrs)
+exit_frame_with_exception_descr_ref = ExitFrameWithExceptionDescrRef(
+                                           done_with_this_frame_descrs)
 
 prebuiltNotSpecNode = NotSpecNode()
 
@@ -184,6 +200,17 @@
     counter = 0
     # this class also gets attributes stored by resume.py code
 
+    def __init__(self, metainterp_sd, original_greenkey):
+        ResumeDescr.__init__(self, original_greenkey)
+        self.metainterp_sd = metainterp_sd
+        self.index = -1
+
+    def get_index(self):
+        if self.index == -1:
+            globaldata = self.metainterp_sd.globaldata
+            self.index = globaldata.get_fail_descr_number(self)
+        return self.index
+
     def store_final_boxes(self, guard_op, boxes):
         guard_op.fail_args = boxes
         self.guard_opnum = guard_op.opnum

Modified: pypy/trunk/pypy/jit/metainterp/history.py
==============================================================================
--- pypy/trunk/pypy/jit/metainterp/history.py	(original)
+++ pypy/trunk/pypy/jit/metainterp/history.py	Fri Oct 16 15:28:49 2009
@@ -125,13 +125,20 @@
 
 class AbstractFailDescr(AbstractDescr):
 
+    def get_index(self):
+        raise NotImplementedError
     def handle_fail(self, metainterp_sd):
         raise NotImplementedError
     def compile_and_attach(self, metainterp, new_loop):
         raise NotImplementedError
 
 class BasicFailDescr(AbstractFailDescr):
-    pass
+
+    def __init__(self, index=-1):
+        self.index = index
+
+    def get_index(self):
+        return self.index
 
 class AbstractMethDescr(AbstractDescr):
     # the base class of the result of cpu.methdescrof()

Modified: pypy/trunk/pypy/jit/metainterp/pyjitpl.py
==============================================================================
--- pypy/trunk/pypy/jit/metainterp/pyjitpl.py	(original)
+++ pypy/trunk/pypy/jit/metainterp/pyjitpl.py	Fri Oct 16 15:28:49 2009
@@ -901,6 +901,7 @@
         if isinstance(box, Const):    # no need for a guard
             return
         metainterp = self.metainterp
+        metainterp_sd = metainterp.staticdata
         if metainterp.is_blackholing():
             return
         saved_pc = self.pc
@@ -910,7 +911,7 @@
         else:
             moreargs = list(extraargs)
         original_greenkey = metainterp.resumekey.original_greenkey
-        resumedescr = compile.ResumeGuardDescr(original_greenkey)
+        resumedescr = compile.ResumeGuardDescr(metainterp_sd, original_greenkey)
         guard_op = metainterp.history.record(opnum, moreargs, None,
                                              descr=resumedescr)       
         virtualizable_boxes = None
@@ -1012,7 +1013,8 @@
         else:
             self.num_green_args = 0
             self.state = None
-        self.globaldata = MetaInterpGlobalData(self)
+        self.globaldata = MetaInterpGlobalData(
+                               self, compile.done_with_this_frame_descrs)
 
     def _setup_once(self):
         """Runtime setup needed by the various components of the JIT."""
@@ -1087,9 +1089,10 @@
 # ____________________________________________________________
 
 class MetaInterpGlobalData(object):
-    def __init__(self, staticdata):
+    def __init__(self, staticdata, prebuilt_fail_descr_list):
         self.initialized = False
         self.indirectcall_dict = None
+        self.fail_descr_list = prebuilt_fail_descr_list[:]
         #
         state = staticdata.state
         if state is not None:
@@ -1102,6 +1105,16 @@
         if staticdata.virtualizable_info:
             self.blackhole_virtualizable = staticdata.virtualizable_info.null_vable
 
+    def get_fail_descr_number(self, descr):
+        assert isinstance(descr, history.AbstractFailDescr)
+        lst = self.fail_descr_list
+        n = len(lst)
+        lst.append(descr)
+        return n
+
+    def get_fail_descr_from_number(self, n):
+        return self.fail_descr_list[n]
+
 # ____________________________________________________________
 
 class MetaInterp(object):

Modified: pypy/trunk/pypy/jit/metainterp/test/test_compile.py
==============================================================================
--- pypy/trunk/pypy/jit/metainterp/test/test_compile.py	(original)
+++ pypy/trunk/pypy/jit/metainterp/test/test_compile.py	Fri Oct 16 15:28:49 2009
@@ -1,6 +1,7 @@
 from pypy.jit.metainterp.history import LoopToken, ConstInt, History, Stats
 from pypy.jit.metainterp.specnode import NotSpecNode, ConstantSpecNode
 from pypy.jit.metainterp.compile import insert_loop_token, compile_new_loop
+from pypy.jit.metainterp.compile import ResumeGuardDescr
 from pypy.jit.metainterp import optimize, jitprof, typesystem
 from pypy.jit.metainterp.test.oparser import parse
 from pypy.jit.metainterp.test.test_optimizefindnode import LLtypeMixin
@@ -93,3 +94,22 @@
     assert loop_token_2 is loop_token
     assert loop_tokens == [loop_token]
     assert len(cpu.seen) == 0
+
+def test_resumeguarddescr_get_index():
+    from pypy.jit.metainterp.pyjitpl import MetaInterpGlobalData
+
+    class FakeStaticData:
+        state = None
+        virtualizable_info = None
+    gd = MetaInterpGlobalData(FakeStaticData, [])
+    FakeStaticData.globaldata = gd
+
+    rgd = ResumeGuardDescr(FakeStaticData, ())
+
+    fail_index = rgd.get_index()
+    fail_index1 = rgd.get_index()
+
+    assert fail_index == fail_index1
+
+    assert gd.get_fail_descr_from_number(fail_index) is rgd
+

Modified: pypy/trunk/pypy/jit/metainterp/test/test_optimizeopt.py
==============================================================================
--- pypy/trunk/pypy/jit/metainterp/test/test_optimizeopt.py	(original)
+++ pypy/trunk/pypy/jit/metainterp/test/test_optimizeopt.py	Fri Oct 16 15:28:49 2009
@@ -36,7 +36,7 @@
     b1 = BoxInt()
     opt = optimizeopt.Optimizer(FakeMetaInterpStaticData(LLtypeMixin.cpu),
                                 None)
-    fdescr = ResumeGuardDescr(None)
+    fdescr = ResumeGuardDescr(None, None)
     op = ResOperation(rop.GUARD_TRUE, [], None, descr=fdescr)
     # setup rd data
     fi0 = resume.FrameInfo(None, FakeFrame("code0", 1, 2))

Modified: pypy/trunk/pypy/jit/metainterp/test/test_pyjitpl.py
==============================================================================
--- pypy/trunk/pypy/jit/metainterp/test/test_pyjitpl.py	(original)
+++ pypy/trunk/pypy/jit/metainterp/test/test_pyjitpl.py	Fri Oct 16 15:28:49 2009
@@ -2,6 +2,7 @@
 # some unit tests for the bytecode decoding
 
 from pypy.jit.metainterp import pyjitpl, codewriter, resoperation
+from pypy.jit.metainterp.history import AbstractFailDescr
 
 def make_frame(code):
     bytecode = codewriter.JitCode("hello")
@@ -32,3 +33,32 @@
             continue
         if rop._NOSIDEEFFECT_FIRST <= opnum <= rop._NOSIDEEFFECT_LAST:
             assert hasattr(pyjitpl.MIFrame, 'opimpl_' + opname.lower()), opname
+
+def test_faildescr_numbering():
+    class FakeStaticData:
+        state = None
+        virtualizable_info = None
+
+    fail_descr0 = AbstractFailDescr()
+    lst = [fail_descr0]
+    gd = pyjitpl.MetaInterpGlobalData(FakeStaticData, lst)
+    assert gd.fail_descr_list is not lst
+
+    fail_descr = gd.get_fail_descr_from_number(0)
+    assert fail_descr is fail_descr0
+
+    fail_descr1 = AbstractFailDescr()
+    fail_descr2 = AbstractFailDescr()    
+
+    n1 = gd.get_fail_descr_number(fail_descr1)
+    n2 = gd.get_fail_descr_number(fail_descr2)
+    assert n1 != n2
+
+    fail_descr = gd.get_fail_descr_from_number(n1)
+    assert fail_descr is fail_descr1
+    fail_descr = gd.get_fail_descr_from_number(n2)
+    assert fail_descr is fail_descr2
+
+    # doesn't provide interning on its own
+    n1_1 = gd.get_fail_descr_number(fail_descr1)
+    assert n1_1 != n1

Modified: pypy/trunk/pypy/jit/metainterp/warmspot.py
==============================================================================
--- pypy/trunk/pypy/jit/metainterp/warmspot.py	(original)
+++ pypy/trunk/pypy/jit/metainterp/warmspot.py	Fri Oct 16 15:28:49 2009
@@ -813,6 +813,7 @@
         # not too bad.
 
         def maybe_compile_and_run(self, *args):
+            globaldata = metainterp_sd.globaldata
             if NonConstant(False):
                 # make sure we always see the saner optimizer from an annotation
                 # point of view, otherwise we get lots of blocked ops
@@ -825,7 +826,7 @@
             if vinfo:
                 virtualizable = args[vinfo.index_of_virtualizable]
                 virtualizable = vinfo.cast_to_vtype(virtualizable)
-                assert virtualizable != metainterp_sd.globaldata.blackhole_virtualizable, "reentering same frame via blackhole"
+                assert virtualizable != globaldata.blackhole_virtualizable, "reentering same frame via blackhole"
             if counter >= 0:
                 # update the profiling counter
                 n = counter + self.increment_threshold
@@ -860,8 +861,9 @@
             # ---------- execute assembler ----------
             while True:     # until interrupted by an exception
                 metainterp_sd.profiler.start_running()
-                fail_descr = metainterp_sd.cpu.execute_token(loop_token)
+                fail_index = metainterp_sd.cpu.execute_token(loop_token)
                 metainterp_sd.profiler.end_running()
+                fail_descr = globaldata.get_fail_descr_from_number(fail_index)
                 loop_token = fail_descr.handle_fail(metainterp_sd)
 
         maybe_compile_and_run._dont_inline_ = True



More information about the Pypy-commit mailing list