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]}
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
def test_virtual_adder_make_vstruct():
b2s, b4s = [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 = {}
v2 = info.StructPtrInfo(LLtypeMixin.ssize, is_virtual=True)
b2s.set_forwarded(v2)
v2.setfield(LLtypeMixin.adescr, b2s, c1s)
v2.setfield(LLtypeMixin.abisdescr, b2s, c1s)
v2.setfield(LLtypeMixin.bdescr, b2s, b4s)
modifier.register_virtual_fields(b2s, [c1s, c1s, b4s])
liveboxes = []
modifier._number_virtuals(liveboxes, 0)
dump_storage(storage, liveboxes)
storage.rd_consts = memo.consts[:]
storage.rd_numb = Numbering([0])
b4t = RefFrontendOp(0)
newboxes = _resume_remap(
liveboxes,
[ #b2s -- virtual
b4s
],
b4t)
#
NULL = ConstPtr.value
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, [], b2t.getref_base(), LLtypeMixin.ssize),
(rop.SETFIELD_GC, [b2t, c1s], None, LLtypeMixin.adescr),
(rop.SETFIELD_GC, [b2t, c1s], None, LLtypeMixin.abisdescr),
(rop.SETFIELD_GC, [b2t, b4t], None, LLtypeMixin.bdescr),
]
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(LLtypeMixin.S)
assert ptr.a == 111
assert ptr.b == lltype.nullptr(LLtypeMixin.NODE)
def test_virtual_adder_pending_fields():
b2s, b4s = [RefFrontendOp(0), RefFrontendOp(0)]
storage = Storage()
memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
modifier = ResumeDataVirtualAdder(None, storage, storage, None, memo)
modifier.liveboxes_from_env = {}
modifier.liveboxes = {}
modifier.vfieldboxes = {}
modifier.register_box(b2s)
modifier.register_box(b4s)
liveboxes = []
modifier._number_virtuals(liveboxes, 0)
assert liveboxes == [b2s, b4s] or liveboxes == [b4s, b2s]
modifier._add_pending_fields([
ResOperation(rop.SETFIELD_GC, [b2s, b4s], descr=LLtypeMixin.nextdescr)
])
storage.rd_consts = memo.consts[:]
storage.rd_numb = Numbering([0])
# resume
demo55.next = lltype.nullptr(LLtypeMixin.NODE)
b2t = RefFrontendOp(0)
b2t.setref_base(demo55o)
b4t = RefFrontendOp(0)
b4t.setref_base(demo66o)
newboxes = _resume_remap(liveboxes, [b2s, b4s], b2t, b4t)
metainterp = MyMetaInterp()
reader = ResumeDataFakeReader(storage, newboxes, metainterp)
assert reader.virtuals_cache is None
trace = metainterp.trace
b2set = (rop.SETFIELD_GC, [b2t, b4t], None, LLtypeMixin.nextdescr)
expected = [b2set]
for x, y in zip(expected, trace):
assert x == y
assert len(expected) == len(trace)
assert demo55.next == demo66
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
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)])