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