示例#1
0
 def test_liveranges(self):
     i0, i1, i2 = IntFrontendOp(0), IntFrontendOp(0), IntFrontendOp(0)
     t = Trace([i0, i1, i2], metainterp_sd)
     p0 = FakeOp(t.record_op(rop.NEW_WITH_VTABLE, [], descr=SomeDescr()))
     t.record_op(rop.GUARD_TRUE, [i0])
     resume.capture_resumedata([], [i1, i2, p0], [p0, i1], t)
     assert t.get_live_ranges() == [4, 4, 4, 4]
示例#2
0
 def test_read_snapshot_interface(self):
     i0, i1, i2 = IntFrontendOp(0), IntFrontendOp(0), IntFrontendOp(0)
     t = Trace([i0, i1, i2], metainterp_sd)
     t.record_op(rop.GUARD_TRUE, [i1])
     frame0 = FakeFrame(1, JitCode(2), [i0, i1])
     frame1 = FakeFrame(3, JitCode(4), [i2, i2])
     resume.capture_resumedata([frame0, frame1], None, [], t)
     t.record_op(rop.GUARD_TRUE, [i1])
     resume.capture_resumedata([frame0, frame1], None, [], t)
     (i0, i1, i2), l, iter = self.unpack(t)
     pos = l[0].rd_resume_position
     snapshot_iter = iter.get_snapshot_iter(pos)
     assert snapshot_iter.vable_array == []
     assert snapshot_iter.vref_array == []
     framestack = snapshot_iter.framestack
     jc_index, pc = snapshot_iter.unpack_jitcode_pc(framestack[1])
     assert jc_index == 4
     assert pc == 3
     assert snapshot_iter.unpack_array(framestack[1].box_array) == [i2, i2]
     jc_index, pc = snapshot_iter.unpack_jitcode_pc(framestack[0])
     assert jc_index == 2
     assert pc == 1
     assert snapshot_iter.unpack_array(framestack[0].box_array) == [i0, i1]
     pos = l[1].rd_resume_position
     snapshot_iter = iter.get_snapshot_iter(pos)
     framestack = snapshot_iter.framestack
     assert snapshot_iter.vable_array == []
     assert snapshot_iter.vref_array == []
     jc_index, pc = snapshot_iter.unpack_jitcode_pc(framestack[1])
     assert jc_index == 4
     assert pc == 3
     assert snapshot_iter.unpack_array(framestack[1].box_array) == [i2, i2]
示例#3
0
def test_ResumeDataLoopMemo_number_boxes():
    memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
    b1, b2 = [IntFrontendOp(0), IntFrontendOp(0)]
    assert memo.num_cached_boxes() == 0
    boxes = []
    num = memo.assign_number_to_box(b1, boxes)
    assert num == -1
    assert boxes == [b1]
    assert memo.num_cached_boxes() == 1
    boxes = [None]
    num = memo.assign_number_to_box(b1, boxes)
    assert num == -1
    assert boxes == [b1]
    num = memo.assign_number_to_box(b2, boxes)
    assert num == -2
    assert boxes == [b1, b2]

    assert memo.num_cached_boxes() == 2
    boxes = [None, None]
    num = memo.assign_number_to_box(b2, boxes)
    assert num == -2
    assert boxes == [None, b2]
    num = memo.assign_number_to_box(b1, boxes)
    assert num == -1
    assert boxes == [b1, b2]

    memo.clear_box_virtual_numbers()
    assert memo.num_cached_boxes() == 0
示例#4
0
    def test_ll_arraycopy(self):
        h = HeapCache()
        box1 = RefFrontendOp(1)
        box2 = RefFrontendOp(2)
        box3 = RefFrontendOp(3)
        box4 = RefFrontendOp(4)
        box5 = RefFrontendOp(5)
        lengthbox1 = IntFrontendOp(11)
        lengthbox2 = IntFrontendOp(12)
        h.new_array(box1, lengthbox1)
        h.setarrayitem(box1, index1, box2, descr1)
        h.new_array(box2, lengthbox1)
        # Just need the destination box for this call
        h.invalidate_caches(
            rop.CALL_N,
            arraycopydescr1,
            [None, box5, box2, index1, index1, index1]
        )
        assert h.getarrayitem(box1, index1, descr1) is box2
        h.invalidate_caches(
            rop.CALL_N,
            arraycopydescr1,
            [None, box5, box3, index1, index1, index1]
        )
        assert h.getarrayitem(box1, index1, descr1) is box2

        h.setarrayitem(box4, index1, box2, descr1)
        assert h.getarrayitem(box4, index1, descr1) is box2
        h.invalidate_caches(
            rop.CALL_N,
            arraycopydescr1,
            [None, box3, box5, index1, index1, index2]
        )
        assert h.getarrayitem(box4, index1, descr1) is None
示例#5
0
def test_register_virtual_fields():
    b1, b2 = IntFrontendOp(0), IntFrontendOp(1)
    vbox = RefFrontendOp(2)
    modifier = ResumeDataVirtualAdder(FakeOptimizer(), None, None, None, None)
    modifier.liveboxes_from_env = {}
    modifier.liveboxes = {}
    modifier.vfieldboxes = {}
    modifier.register_virtual_fields(vbox, [b1, b2])
    assert modifier.liveboxes == {
        vbox: UNASSIGNEDVIRTUAL,
        b1: UNASSIGNED,
        b2: UNASSIGNED
    }
    assert modifier.vfieldboxes == {vbox: [b1, b2]}

    modifier = ResumeDataVirtualAdder(FakeOptimizer(), None, None, None, None)
    modifier.liveboxes_from_env = {vbox: tag(0, TAGVIRTUAL)}
    modifier.liveboxes = {}
    modifier.vfieldboxes = {}
    modifier.register_virtual_fields(vbox, [b1, b2, vbox])
    assert modifier.liveboxes == {
        b1: UNASSIGNED,
        b2: UNASSIGNED,
        vbox: tag(0, TAGVIRTUAL)
    }
    assert modifier.vfieldboxes == {vbox: [b1, b2, vbox]}
示例#6
0
    def test_unescaped_array(self):
        h = HeapCache()
        box1 = RefFrontendOp(1)
        box2 = RefFrontendOp(2)
        lengthbox1 = IntFrontendOp(11)
        lengthbox2 = IntFrontendOp(12)
        h.new_array(box1, lengthbox1)
        assert h.is_unescaped(box1)
        h.invalidate_caches(rop.SETARRAYITEM_GC, None, [box1, index1, box2])
        assert h.is_unescaped(box1)
        h.invalidate_caches(rop.SETARRAYITEM_GC, None, [box2, index1, box1])
        assert not h.is_unescaped(box1)

        h = HeapCache()
        h.new_array(box1, lengthbox1)
        h.new(box2)
        assert h.is_unescaped(box1)
        assert h.is_unescaped(box2)
        h.invalidate_caches(rop.SETARRAYITEM_GC, None, [box1, lengthbox2, box2])
        assert h.is_unescaped(box1)
        assert h.is_unescaped(box2)
        h.invalidate_caches(
            rop.CALL_N, FakeCallDescr(FakeEffectinfo.EF_RANDOM_EFFECTS), [box1]
        )
        assert not h.is_unescaped(box1)
        assert not h.is_unescaped(box2)
示例#7
0
 def test_virtualizable_virtualref(self):
     i0, i1, i2 = IntFrontendOp(0), IntFrontendOp(0), IntFrontendOp(0)
     t = Trace([i0, i1, i2], metainterp_sd)
     p0 = FakeOp(t.record_op(rop.NEW_WITH_VTABLE, [], descr=SomeDescr()))
     t.record_op(rop.GUARD_TRUE, [i0])
     resume.capture_resumedata([], [i1, i2, p0], [p0, i1], t)
     (i0, i1, i2), l, iter = self.unpack(t)
     assert not l[1].framestack
     assert l[1].virtualizables == [l[0], i1, i2]
     assert l[1].vref_boxes == [l[0], i1]
示例#8
0
def test_virtual_adder_make_varray():
    b2s, b4s = [RefFrontendOp(0), IntFrontendOp(0)]
    b4s.setint(4)
    c1s = ConstInt(111)
    storage = Storage()
    memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
    modifier = ResumeDataVirtualAdder(FakeOptimizer(), storage, storage, None,
                                      memo)
    modifier.liveboxes_from_env = {}
    modifier.liveboxes = {}
    modifier.vfieldboxes = {}

    v2 = info.ArrayPtrInfo(LLtypeMixin.arraydescr, size=2, is_virtual=True)
    b2s.set_forwarded(v2)
    v2._items = [b4s, c1s]
    modifier.register_virtual_fields(b2s, [b4s, c1s])
    liveboxes = []
    modifier._number_virtuals(liveboxes, 0)
    dump_storage(storage, liveboxes)
    storage.rd_consts = memo.consts[:]
    storage.rd_numb = Numbering([0])
    # resume
    b1t, b3t, b4t = [IntFrontendOp(0), IntFrontendOp(0), IntFrontendOp(0)]
    b1t.setint(11)
    b3t.setint(33)
    b4t.setint(44)
    newboxes = _resume_remap(
        liveboxes,
        [  #b2s -- virtual
            b4s
        ],
        b4t)
    # resume
    metainterp = MyMetaInterp()
    reader = ResumeDataFakeReader(storage, newboxes, metainterp)
    assert len(reader.virtuals_cache.virtuals_ptr_cache) == 1
    b2t = reader.decode_ref(tag(0, TAGVIRTUAL))
    trace = metainterp.trace
    expected = [
        (rop.NEW_ARRAY, [ConstInt(2)], b2t.getref_base(),
         LLtypeMixin.arraydescr),
        (rop.SETARRAYITEM_GC, [b2t, ConstInt(0),
                               b4t], None, LLtypeMixin.arraydescr),
        (rop.SETARRAYITEM_GC, [b2t, ConstInt(1),
                               c1s], None, LLtypeMixin.arraydescr),
    ]
    with CompareableConsts():
        for x, y in zip(expected, trace):
            assert x == y
    #
    ptr = b2t.getref_base()._obj.container._as_ptr()
    assert lltype.typeOf(ptr) == lltype.Ptr(lltype.GcArray(lltype.Signed))
    assert len(ptr) == 2
    assert ptr[0] == 44
    assert ptr[1] == 111
示例#9
0
    def test_length_cache(self):
        h = HeapCache()
        box1 = RefFrontendOp(1)
        box2 = RefFrontendOp(2)
        lengthbox1 = IntFrontendOp(11)
        lengthbox2 = IntFrontendOp(12)
        h.new_array(box1, lengthbox1)
        assert h.arraylen(box1) is lengthbox1

        assert h.arraylen(box2) is None
        h.arraylen_now_known(box2, lengthbox2)
        assert h.arraylen(box2) is lengthbox2
示例#10
0
 def test_simple_iterator(self):
     i0, i1 = IntFrontendOp(0), IntFrontendOp(0)
     t = Trace([i0, i1], metainterp_sd)
     add = FakeOp(t.record_op(rop.INT_ADD, [i0, i1]))
     t.record_op(rop.INT_ADD, [add, ConstInt(1)])
     (i0, i1), l, _ = self.unpack(t)
     assert len(l) == 2
     assert l[0].opnum == rop.INT_ADD
     assert l[1].opnum == rop.INT_ADD
     assert l[1].getarg(1).getint() == 1
     assert l[1].getarg(0) is l[0]
     assert l[0].getarg(0) is i0
     assert l[0].getarg(1) is i1
示例#11
0
 def test_cut_trace_from(self):
     i0, i1, i2 = IntFrontendOp(0), IntFrontendOp(0), IntFrontendOp(0)
     t = Trace([i0, i1, i2], metainterp_sd)
     add1 = FakeOp(t.record_op(rop.INT_ADD, [i0, i1]))
     cut_point = t.cut_point()
     add2 = FakeOp(t.record_op(rop.INT_ADD, [add1, i1]))
     t.record_op(rop.GUARD_TRUE, [add2])
     resume.capture_resumedata([FakeFrame(3, JitCode(4), [add2, add1, i1])],
                               None, [], t)
     t.record_op(rop.INT_SUB, [add2, add1])
     t2 = t.cut_trace_from(cut_point, [add1, i1])
     (i0, i1), l, iter = self.unpack(t2)
     assert len(l) == 3
     assert l[0].getarglist() == [i0, i1]
示例#12
0
def test_remove_consts_and_duplicates():
    class FakeStaticData:
        cpu = None
        all_descrs = []
        warmrunnerdesc = None

    def is_another_box_like(box, referencebox):
        assert box is not referencebox
        assert box.type == referencebox.type
        assert box.getint() == referencebox.getint()
        return True

    metainterp = pyjitpl.MetaInterp(FakeStaticData(), None)
    metainterp.history = History()
    b1 = IntFrontendOp(1)
    b1.setint(1)
    b2 = IntFrontendOp(2)
    b2.setint(2)
    c3 = ConstInt(3)
    boxes = [b1, b2, b1, c3]
    dup = {}
    metainterp.history.set_inputargs([b1, b2], FakeStaticData())
    metainterp.remove_consts_and_duplicates(boxes, 4, dup)
    assert boxes[0] is b1
    assert boxes[1] is b2
    assert is_another_box_like(boxes[2], b1)
    assert is_another_box_like(boxes[3], c3)
    inp, operations = metainterp.history.trace.unpack()
    remap = dict(zip([b1, b2], inp))
    assert equaloplists(operations, [
        ResOperation(rop.SAME_AS_I, [b1]),
        ResOperation(rop.SAME_AS_I, [c3]),
    ],
                        remap=remap)
    assert dup == {b1: None, b2: None}
示例#13
0
 def test_deadranges(self):
     i0, i1, i2 = IntFrontendOp(0), IntFrontendOp(0), IntFrontendOp(0)
     t = Trace([i0, i1, i2], metainterp_sd)
     p0 = FakeOp(t.record_op(rop.NEW_WITH_VTABLE, [], descr=SomeDescr()))
     t.record_op(rop.GUARD_TRUE, [i0])
     resume.capture_resumedata([], [i1, i2, p0], [p0, i1], t)
     i3 = FakeOp(t.record_op(rop.INT_ADD, [i1, ConstInt(1)]))
     i4 = FakeOp(t.record_op(rop.INT_ADD, [i3, ConstInt(1)]))
     t.record_op(rop.ESCAPE_N, [ConstInt(3)])
     t.record_op(rop.ESCAPE_N, [ConstInt(3)])
     t.record_op(rop.ESCAPE_N, [ConstInt(3)])
     t.record_op(rop.ESCAPE_N, [ConstInt(3)])
     t.record_op(rop.ESCAPE_N, [ConstInt(3)])
     t.record_op(rop.FINISH, [i4])
     assert t.get_dead_ranges() == [0, 0, 0, 0, 0, 3, 4, 5]
示例#14
0
 def test_ll_arraycopy_doesnt_escape_arrays(self):
     h = HeapCache()
     box1 = RefFrontendOp(1)
     box2 = RefFrontendOp(2)
     lengthbox1 = IntFrontendOp(11)
     lengthbox2 = IntFrontendOp(12)
     h.new_array(box1, lengthbox1)
     h.new_array(box2, lengthbox2)
     h.invalidate_caches(rop.CALL_N, arraycopydescr1,
                         [None, box2, box1, index1, index1, index2])
     assert h.is_unescaped(box1)
     assert h.is_unescaped(box2)
     h.invalidate_caches(rop.CALL_N, arraycopydescr1,
                         [None, box2, box1, index1, index1,
                          InputArgInt()])
     assert not h.is_unescaped(box1)
     assert not h.is_unescaped(box2)
示例#15
0
 def execute_and_record(self, opnum, descr, *argboxes):
     resvalue = executor.execute(self.cpu, None, opnum, descr, *argboxes)
     if isinstance(resvalue, int):
         op = IntFrontendOp(0)
     else:
         op = RefFrontendOp(0)
     setvalue(op, resvalue)
     self.trace.append((opnum, list(argboxes), resvalue, descr))
     return op
示例#16
0
def test_ResumeDataLoopMemo_number_virtuals():
    memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
    b1, b2 = [IntFrontendOp(0), IntFrontendOp(0)]
    assert memo.num_cached_virtuals() == 0
    num = memo.assign_number_to_virtual(b1)
    assert num == -1
    assert memo.num_cached_virtuals() == 1
    num = memo.assign_number_to_virtual(b1)
    assert num == -1
    num = memo.assign_number_to_virtual(b2)
    assert num == -2

    assert memo.num_cached_virtuals() == 2
    num = memo.assign_number_to_virtual(b2)
    assert num == -2
    num = memo.assign_number_to_virtual(b1)
    assert num == -1

    memo.clear_box_virtual_numbers()
    assert memo.num_cached_virtuals() == 0
示例#17
0
 def test_call_doesnt_invalidate_unescaped_array_boxes(self):
     h = HeapCache()
     box1 = RefFrontendOp(1)
     box3 = RefFrontendOp(3)
     lengthbox1 = IntFrontendOp(11)
     h.new_array(box1, lengthbox1)
     assert h.is_unescaped(box1)
     h.setarrayitem(box1, index1, box3, descr1)
     h.invalidate_caches(rop.CALL_N,
                         FakeCallDescr(FakeEffectinfo.EF_CAN_RAISE), [])
     assert h.getarrayitem(box1, index1, descr1) is box3
示例#18
0
 def test_ll_arraycopy_dest_new(self):
     h = HeapCache()
     box1 = RefFrontendOp(1)
     box2 = RefFrontendOp(2)
     box3 = RefFrontendOp(3)
     box4 = RefFrontendOp(4)
     lengthbox1 = IntFrontendOp(11)
     h.new_array(box1, lengthbox1)
     h.setarrayitem(box3, index1, box4, descr1)
     h.invalidate_caches(rop.CALL_N, arraycopydescr1,
                         [None, box2, box1, index1, index1, index2])
示例#19
0
 def test_ll_arraycopy_differing_descrs(self):
     h = HeapCache()
     box1 = RefFrontendOp(1)
     box2 = RefFrontendOp(2)
     box3 = RefFrontendOp(3)
     lengthbox2 = IntFrontendOp(12)
     h.setarrayitem(box1, index1, box2, descr2)
     assert h.getarrayitem(box1, index1, descr2) is box2
     h.new_array(box2, lengthbox2)
     h.invalidate_caches(rop.CALL_N, arraycopydescr1,
                         [None, box3, box2, index1, index1, index2])
     assert h.getarrayitem(box1, index1, descr2) is box2
示例#20
0
def test_remove_consts_and_duplicates():
    class FakeStaticData:
        cpu = None
        all_descrs = []
        warmrunnerdesc = None
    def is_another_box_like(box, referencebox):
        assert box is not referencebox
        assert box.type == referencebox.type
        assert box.getint() == referencebox.getint()
        return True
    metainterp = pyjitpl.MetaInterp(FakeStaticData(), None)
    metainterp.history = History()
    b1 = IntFrontendOp(1)
    b1.setint(1)
    b2 = IntFrontendOp(2)
    b2.setint(2)
    c3 = ConstInt(3)
    boxes = [b1, b2, b1, c3]
    dup = {}
    metainterp.history.set_inputargs([b1, b2], FakeStaticData())
    metainterp.remove_consts_and_duplicates(boxes, 4, dup)
    assert boxes[0] is b1
    assert boxes[1] is b2
    assert is_another_box_like(boxes[2], b1)
    assert is_another_box_like(boxes[3], c3)
    inp, operations = metainterp.history.trace.unpack()
    remap = dict(zip([b1, b2], inp))
    assert equaloplists(operations, [
        ResOperation(rop.SAME_AS_I, [b1]),
        ResOperation(rop.SAME_AS_I, [c3]),
        ], remap=remap)
    assert dup == {b1: None, b2: None}
示例#21
0
 def test_rd_snapshot(self):
     i0, i1 = IntFrontendOp(0), IntFrontendOp(0)
     t = Trace([i0, i1], metainterp_sd)
     add = FakeOp(t.record_op(rop.INT_ADD, [i0, i1]))
     t.record_op(rop.GUARD_FALSE, [add])
     # now we write rd_snapshot and friends
     frame0 = FakeFrame(1, JitCode(2), [i0, i1])
     frame1 = FakeFrame(3, JitCode(4), [i0, i0, add])
     framestack = [frame0]
     resume.capture_resumedata(framestack, None, [], t)
     (i0, i1), l, iter = self.unpack(t)
     assert l[1].opnum == rop.GUARD_FALSE
     assert l[1].framestack[0].boxes == [i0, i1]
     t.record_op(rop.GUARD_FALSE, [add])
     resume.capture_resumedata([frame0, frame1], None, [], t)
     t.record_op(rop.INT_ADD, [add, add])
     (i0, i1), l, iter = self.unpack(t)
     assert l[1].opnum == rop.GUARD_FALSE
     assert l[1].framestack[0].boxes == [i0, i1]
     assert l[2].opnum == rop.GUARD_FALSE
     fstack = l[2].framestack
     assert fstack[0].boxes == [i0, i1]
     assert fstack[1].boxes == [i0, i0, l[0]]
示例#22
0
    def test_replace_box_with_const_in_array(self):
        h = HeapCache()
        box1 = RefFrontendOp(1)
        lengthbox2 = IntFrontendOp(2)
        lengthbox2.setint(10)
        h.arraylen_now_known(box1, lengthbox2)
        assert h.arraylen(box1) is lengthbox2
        c10 = ConstInt(10)
        h.replace_box(lengthbox2, c10)
        assert c10.same_constant(h.arraylen(box1))

        box2 = IntFrontendOp(2)
        box2.setint(12)
        h.setarrayitem(box1, index2, box2, descr1)
        assert h.getarrayitem(box1, index2, descr1) is box2
        c12 = ConstInt(12)
        h.replace_box(box2, c12)
        assert c12.same_constant(h.getarrayitem(box1, index2, descr1))
示例#23
0
 def convert_values(self, inpargs, values):
     if values:
         r = []
         for arg, v in zip(inpargs, values):
             if arg.type == 'i':
                 n = IntFrontendOp(0)
                 if v is not None:
                     n.setint(v)
             else:
                 n = RefFrontendOp(0)
                 if v is not None:
                     n.setref_base(v)
                 assert arg.type == 'r'
             r.append(n)
         return r
     return inpargs
示例#24
0
文件: test_util.py 项目: fhalde/pypy
 def convert_values(self, inpargs, values):
     from rpython.jit.metainterp.history import IntFrontendOp, RefFrontendOp
     if values:
         r = []
         for arg, v in zip(inpargs, values):
             if arg.type == 'i':
                 n = IntFrontendOp(0)
                 if v is not None:
                     n.setint(v)
             else:
                 n = RefFrontendOp(0)
                 if v is not None:
                     n.setref_base(v)
                 assert arg.type == 'r'
             r.append(n)
         return r
     return inpargs
示例#25
0
 def convert_values(self, inpargs, values):
     from rpython.jit.metainterp.history import IntFrontendOp, RefFrontendOp
     if values:
         r = []
         for arg, v in zip(inpargs, values):
             if arg.type == 'i':
                 n = IntFrontendOp(0)
                 if v is not None:
                     n.setint(v)
             else:
                 n = RefFrontendOp(0)
                 if v is not None:
                     n.setref_base(v)
                 assert arg.type == 'r'
             r.append(n)
         return r
     return inpargs
示例#26
0
    def test_replace_box_with_const_in_array(self):
        h = HeapCache()
        box1 = RefFrontendOp(1)
        lengthbox2 = IntFrontendOp(2)
        lengthbox2.setint(10)
        h.arraylen_now_known(box1, lengthbox2)
        assert h.arraylen(box1) is lengthbox2
        c10 = ConstInt(10)
        h.replace_box(lengthbox2, c10)
        assert c10.same_constant(h.arraylen(box1))

        box2 = IntFrontendOp(2)
        box2.setint(12)
        h.setarrayitem(box1, index2, box2, descr1)
        assert h.getarrayitem(box1, index2, descr1) is box2
        c12 = ConstInt(12)
        h.replace_box(box2, c12)
        assert c12.same_constant(h.getarrayitem(box1, index2, descr1))
示例#27
0
def test_virtual_adder_pending_fields_and_arrayitems():
    class Storage(object):
        pass
    storage = Storage()
    modifier = ResumeDataVirtualAdder(None, storage, storage, None, None)
    modifier._add_pending_fields([])
    assert not storage.rd_pendingfields
    #
    class FieldDescr(AbstractDescr):
        def is_array_of_primitives(self):
            return False
    field_a = FieldDescr()
    storage = Storage()
    modifier = ResumeDataVirtualAdder(None, storage, storage, None, None)
    a = IntFrontendOp(0)
    b = IntFrontendOp(0)
    modifier.liveboxes_from_env = {a: rffi.cast(rffi.SHORT, 1042),
                                   b: rffi.cast(rffi.SHORT, 1061)}
    modifier._add_pending_fields(
        [ResOperation(rop.SETFIELD_GC, [a, b], descr=field_a)])
    pf = storage.rd_pendingfields
    assert len(pf) == 1
    assert (annlowlevel.cast_base_ptr_to_instance(FieldDescr, pf[0].lldescr)
            is field_a)
    assert rffi.cast(lltype.Signed, pf[0].num) == 1042
    assert rffi.cast(lltype.Signed, pf[0].fieldnum) == 1061
    assert rffi.cast(lltype.Signed, pf[0].itemindex) == -1
    #
    array_a = FieldDescr()
    storage = Storage()
    modifier = ResumeDataVirtualAdder(None, storage, storage, None, None)
    a42 = IntFrontendOp(0)
    a61 = IntFrontendOp(0)
    a62 = IntFrontendOp(0)
    a63 = IntFrontendOp(0)
    modifier.liveboxes_from_env = {a42: rffi.cast(rffi.SHORT, 1042),
                                   a61: rffi.cast(rffi.SHORT, 1061),
                                   a62: rffi.cast(rffi.SHORT, 1062),
                                   a63: rffi.cast(rffi.SHORT, 1063)}
    modifier._add_pending_fields([
        ResOperation(rop.SETARRAYITEM_GC, [a42, ConstInt(0), a61],
                     descr=array_a),
        ResOperation(rop.SETARRAYITEM_GC, [a42, ConstInt(2147483647), a62],
                     descr=array_a)])
    pf = storage.rd_pendingfields
    assert len(pf) == 2
    assert (annlowlevel.cast_base_ptr_to_instance(FieldDescr, pf[0].lldescr)
            is array_a)
    assert rffi.cast(lltype.Signed, pf[0].num) == 1042
    assert rffi.cast(lltype.Signed, pf[0].fieldnum) == 1061
    assert rffi.cast(lltype.Signed, pf[0].itemindex) == 0
    assert (annlowlevel.cast_base_ptr_to_instance(FieldDescr, pf[1].lldescr)
            is array_a)
    assert rffi.cast(lltype.Signed, pf[1].num) == 1042
    assert rffi.cast(lltype.Signed, pf[1].fieldnum) == 1062
    assert rffi.cast(lltype.Signed, pf[1].itemindex) == 2147483647
    #
    if sys.maxint >= 2147483648:
        with py.test.raises(TagOverflow):
            modifier._add_pending_fields(
                [ResOperation(rop.SETARRAYITEM_GC,
                    [a42, ConstInt(2147483648), a63], descr=array_a)])
示例#28
0
def test_ResumeDataLoopMemo_number():
    b1, b2, b3, b4, b5 = [IntFrontendOp(0), IntFrontendOp(1), IntFrontendOp(2),
                          RefFrontendOp(3), RefFrontendOp(4)]
    c1, c2, c3, c4 = [ConstInt(1), ConstInt(2), ConstInt(3), ConstInt(4)]

    env = [b1, c1, b2, b1, c2]
    metainterp_sd = FakeMetaInterpStaticData()
    t = Trace([b1, b2, b3, b4, b5], metainterp_sd)
    snap = t.create_snapshot(FakeJitCode("jitcode", 0), 0, Frame(env), False)
    env1 = [c3, b3, b1, c1]
    t.append(0) # descr index
    snap1 = t.create_top_snapshot(FakeJitCode("jitcode", 0), 2, Frame(env1), False,
        [], [])
    snap1.prev = snap

    env2 = [c3, b3, b1, c3]
    env3 = [c3, b3, b1, c3]
    env4 = [c3, b4, b1, c3]
    env5 = [b1, b4, b5]

    memo = ResumeDataLoopMemo(metainterp_sd)

    iter = t.get_iter()
    b1, b2, b3, b4, b5 = iter.inputargs
    numb_state = memo.number(0, iter)
    numb = numb_state.create_numbering()
    assert numb_state.num_virtuals == 0

    assert numb_state.liveboxes == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX),
                                    b3: tag(2, TAGBOX)}
    base = [0, 0, tag(0, TAGBOX), tag(1, TAGINT),
            tag(1, TAGBOX), tag(0, TAGBOX), tag(2, TAGINT)]

    assert unpack_numbering(numb) == [17, 0, 0, 0] + base + [0, 2, tag(3, TAGINT), tag(2, TAGBOX),
                                      tag(0, TAGBOX), tag(1, TAGINT)]
    t.append(0)
    snap2 = t.create_top_snapshot(FakeJitCode("jitcode", 0), 2, Frame(env2),
                                  False, [], [])
    snap2.prev = snap

    numb_state2 = memo.number(1, iter)
    numb2 = numb_state2.create_numbering()
    assert numb_state2.num_virtuals == 0

    assert numb_state2.liveboxes == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX),
                                     b3: tag(2, TAGBOX)}
    assert numb_state2.liveboxes is not numb_state.liveboxes
    assert unpack_numbering(numb2) == [17, 0, 0, 0] + base + [0, 2, tag(3, TAGINT), tag(2, TAGBOX),
                                       tag(0, TAGBOX), tag(3, TAGINT)]

    t.append(0)
    snap3 = t.create_top_snapshot(FakeJitCode("jitcode", 0), 2, Frame([]),
                                  False, [], env3)
    snap3.prev = snap

    class FakeVirtualInfo(info.AbstractVirtualPtrInfo):
        def __init__(self, virt):
            self._is_virtual = virt

        def is_virtual(self):
            return self._is_virtual

    # renamed
    b3.set_forwarded(c4)
    numb_state3 = memo.number(2, iter)
    numb3 = numb_state3.create_numbering()
    assert numb_state3.num_virtuals == 0

    assert numb_state3.liveboxes == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX)}
    assert unpack_numbering(numb3) == ([17, 0, 0, 2, tag(3, TAGINT), tag(4, TAGINT),
                                       tag(0, TAGBOX), tag(3, TAGINT)] +
                                       base + [0, 2])

    # virtual
    t.append(0)
    snap4 = t.create_top_snapshot(FakeJitCode("jitcode", 0), 2, Frame([]),
                                  False, [], env4)
    snap4.prev = snap

    b4.set_forwarded(FakeVirtualInfo(True))
    numb_state4 = memo.number(3, iter)
    numb4 = numb_state4.create_numbering()
    assert numb_state4.num_virtuals == 1

    assert numb_state4.liveboxes == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX),
                                     b4: tag(0, TAGVIRTUAL)}
    assert unpack_numbering(numb4) == [17, 0, 0, 2, tag(3, TAGINT), tag(0, TAGVIRTUAL),
                                       tag(0, TAGBOX), tag(3, TAGINT)] + base + [0, 2]

    t.append(0)
    snap4 = t.create_snapshot(FakeJitCode("jitcode", 2), 1, Frame(env4), False)
    t.append(0)
    snap4.prev = snap
    snap5 = t.create_top_snapshot(FakeJitCode("jitcode", 0), 0, Frame([]), False,
                                  env5, [])
    snap5.prev = snap4

    b4.set_forwarded(FakeVirtualInfo(True))
    b5.set_forwarded(FakeVirtualInfo(True))
    numb_state5 = memo.number(4, iter)
    numb5 = numb_state5.create_numbering()
    assert numb_state5.num_virtuals == 2

    assert numb_state5.liveboxes == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX),
                                     b4: tag(0, TAGVIRTUAL), b5: tag(1, TAGVIRTUAL)}
    assert unpack_numbering(numb5) == [22, 0,
        3, tag(0, TAGBOX), tag(0, TAGVIRTUAL), tag(1, TAGVIRTUAL),
        0] + base + [
        2, 1, tag(3, TAGINT), tag(0, TAGVIRTUAL), tag(0, TAGBOX), tag(3, TAGINT)
        ] + [0, 0]
示例#29
0
def test_virtual_adder_make_virtual():
    b2s, b3s, b4s, b5s = [RefFrontendOp(0), IntFrontendOp(0), RefFrontendOp(0),
                          RefFrontendOp(0)]
    c1s = ConstInt(111)
    storage = Storage()
    memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
    modifier = ResumeDataVirtualAdder(FakeOptimizer(), storage, storage, None, memo)
    modifier.liveboxes_from_env = {}
    modifier.liveboxes = {}
    modifier.vfieldboxes = {}

    vdescr = LLtypeMixin.nodesize2
    ca = ConstInt(ptr2int(LLtypeMixin.node_vtable2))
    v4 = info.InstancePtrInfo(vdescr, ca, True)
    b4s.set_forwarded(v4)
    v4.setfield(LLtypeMixin.nextdescr, ca, b2s)
    v4.setfield(LLtypeMixin.valuedescr, ca, b3s)
    v4.setfield(LLtypeMixin.otherdescr, ca, b5s)
    ca = ConstInt(ptr2int(LLtypeMixin.node_vtable))
    v2 = info.InstancePtrInfo(LLtypeMixin.nodesize, ca, True)
    v2.setfield(LLtypeMixin.nextdescr, b4s, ca)
    v2.setfield(LLtypeMixin.valuedescr, c1s, ca)
    b2s.set_forwarded(v2)

    modifier.register_virtual_fields(b2s, [c1s, None, None, None, b4s])
    modifier.register_virtual_fields(b4s, [b3s, None, None, None, b2s, b5s])

    liveboxes = []
    modifier._number_virtuals(liveboxes, 0)
    storage.rd_consts = memo.consts[:]
    storage.rd_numb = Numbering([0])
    # resume
    b3t, b5t = [IntFrontendOp(0), RefFrontendOp(0)]
    b5t.setref_base(demo55o)
    b3t.setint(33)
    newboxes = _resume_remap(liveboxes, [#b2s -- virtual
                                         b3s,
                                         #b4s -- virtual
                                         #b2s -- again, shared
                                         #b3s -- again, shared
                                         b5s], b3t, b5t)

    metainterp = MyMetaInterp()
    reader = ResumeDataFakeReader(storage, newboxes, metainterp)
    assert len(reader.virtuals_cache.virtuals_ptr_cache) == 2
    b2t = reader.decode_ref(modifier._gettagged(b2s))
    b4t = reader.decode_ref(modifier._gettagged(b4s))
    trace = metainterp.trace
    b2new = (rop.NEW_WITH_VTABLE, [], b2t.getref_base(), LLtypeMixin.nodesize)
    b4new = (rop.NEW_WITH_VTABLE, [], b4t.getref_base(), LLtypeMixin.nodesize2)
    b2set = [(rop.SETFIELD_GC, [b2t, b4t],      None, LLtypeMixin.nextdescr),
             (rop.SETFIELD_GC, [b2t, c1s],      None, LLtypeMixin.valuedescr)]
    b4set = [(rop.SETFIELD_GC, [b4t, b2t],     None, LLtypeMixin.nextdescr),
             (rop.SETFIELD_GC, [b4t, b3t],     None, LLtypeMixin.valuedescr),
             (rop.SETFIELD_GC, [b4t, b5t],     None, LLtypeMixin.otherdescr)]
    expected = [b2new, b4new] + b4set + b2set

    # check that we get the operations in 'expected', in a possibly different
    # order.
    assert len(trace) == len(expected)
    orig = trace[:]
    with CompareableConsts():
        for x in trace:
            assert x in expected
            expected.remove(x)

    ptr = b2t.getref_base()._obj.container._as_ptr()
    assert lltype.typeOf(ptr) == lltype.Ptr(LLtypeMixin.NODE)
    assert ptr.value == 111
    ptr2 = ptr.next
    ptr2 = lltype.cast_pointer(lltype.Ptr(LLtypeMixin.NODE2), ptr2)
    assert ptr2.other == demo55
    assert ptr2.parent.value == 33
    assert ptr2.parent.next == ptr
示例#30
0
 def InputArgInt(a):
     i = IntFrontendOp(0)
     i.setint(a)
     return i