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_vunisliceinfo():
info = VUniSliceInfo()
info.fieldnums = [tag(10, TAGBOX), tag(20, TAGBOX), tag(30, TAGBOX)]
reader = FakeResumeDataReader()
reader._prepare_virtuals([info])
assert reader.force_all_virtuals().virtuals_ptr_cache == [
FakeBuiltObject(unislice=info.fieldnums)]
def test_vstrconcatinfo():
info = VStrConcatInfo()
info.fieldnums = [tag(10, TAGBOX), tag(20, TAGBOX)]
reader = FakeResumeDataReader()
reader._prepare_virtuals([info])
assert reader.force_all_virtuals().virtuals_ptr_cache == [
FakeBuiltObject(strconcat=info.fieldnums)]
def test_varrayinfo():
arraydescr = FakeArrayDescr()
info = VArrayInfoNotClear(arraydescr)
info.fieldnums = [tag(456, TAGINT)]
reader = FakeResumeDataReader()
reader._prepare_virtuals([info])
assert reader.force_all_virtuals().virtuals_ptr_cache == [
FakeBuiltObject(arraydescr=arraydescr, items=[tag(456, TAGINT)])]
def test_vstructinfo():
info = VStructInfo(124, ["fielddescr1"])
info.fieldnums = [tag(456, TAGINT)]
reader = FakeResumeDataReader()
reader._prepare_virtuals([info])
cache = reader.force_all_virtuals()
assert cache.virtuals_ptr_cache == [
FakeBuiltObject(typedescr=124, fielddescr1=tag(456, TAGINT))]
def test_tag():
assert tag(3, 1) == rffi.r_short(3<<2|1)
assert tag(-3, 2) == rffi.r_short(-3<<2|2)
assert tag((1<<13)-1, 3) == rffi.r_short(((1<<15)-1)|3)
assert tag(-1<<13, 3) == rffi.r_short((-1<<15)|3)
py.test.raises(AssertionError, tag, 3, 5)
py.test.raises(TagOverflow, tag, 1<<13, 0)
py.test.raises(TagOverflow, tag, (1<<13)+1, 0)
py.test.raises(TagOverflow, tag, (-1<<13)-1, 0)
py.test.raises(TagOverflow, tag, (-1<<13)-5, 0)
def test_tagged_list_eq():
assert tagged_list_eq(
[UNASSIGNED, tag(1, TAGBOX),
tag(-2, TAGVIRTUAL)],
[UNASSIGNED, tag(1, TAGBOX),
tag(-2, TAGVIRTUAL)])
assert not tagged_list_eq([tag(1, TAGBOX)], [tag(-2, TAGBOX)])
assert not tagged_list_eq([tag(1, TAGBOX), tag(-2, TAGBOX)],
[tag(1, TAGBOX)])
def test_vuniplaininfo():
info = VUniPlainInfo()
info.fieldnums = [tag(60, TAGINT)]
reader = FakeResumeDataReader()
reader._prepare_virtuals([info])
assert reader.force_all_virtuals().virtuals_ptr_cache == [
FakeBuiltObject(unistring=[60])]
def test_simple_read_tagged_ints():
storage = Storage()
storage.rd_consts = []
numb = Numbering([1, tag(100, TAGINT)])
storage.rd_numb = numb
#
cpu = MyCPU([])
reader = ResumeDataDirectReader(MyMetaInterp(cpu), storage, "deadframe")
_next_section(reader, 100)
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_simple_read():
#b1, b2, b3 = [BoxInt(), InputArgRef(), BoxInt()]
c1, c2, c3 = [ConstInt(111), ConstInt(222), ConstInt(333)]
storage = Storage()
storage.rd_consts = [c1, c2, c3]
numb = Numbering(
[
3,
tag(0, TAGBOX),
tagconst(0), NULLREF,
tag(0, TAGBOX),
tag(1, TAGBOX)
] + [tagconst(1), tagconst(2)] +
[tag(0, TAGBOX), tag(1, TAGBOX),
tag(2, TAGBOX)])
storage.rd_numb = numb
#
cpu = MyCPU([42, gcref1, -66])
metainterp = MyMetaInterp(cpu)
reader = ResumeDataDirectReader(metainterp, storage, "deadframe")
_next_section(reader, 42, 111, gcrefnull, 42, gcref1)
_next_section(reader, 222, 333)
_next_section(reader, 42, gcref1, -66)
#
reader = ResumeDataBoxReader(storage, "deadframe", metainterp)
bi, br, bf = [None] * 3, [None] * 2, [None] * 0
bh = MyBlackholeInterp([
lltype.Signed, lltype.Signed, llmemory.GCREF, lltype.Signed,
llmemory.GCREF
])
bh.fake_consume_boxes(reader, bi, br, bf)
b1s = reader.liveboxes[0]
b2s = reader.liveboxes[1]
assert_same(bi, [b1s, ConstInt(111), b1s])
assert_same(br, [ConstPtr(gcrefnull), b2s])
bi, br, bf = [None] * 2, [None] * 0, [None] * 0
bh = MyBlackholeInterp([lltype.Signed, lltype.Signed])
bh.fake_consume_boxes(reader, bi, br, bf)
assert_same(bi, [ConstInt(222), ConstInt(333)])
bi, br, bf = [None] * 2, [None] * 1, [None] * 0
bh = MyBlackholeInterp([lltype.Signed, llmemory.GCREF, lltype.Signed])
bh.fake_consume_boxes(reader, bi, br, bf)
b3s = reader.liveboxes[2]
assert_same(bi, [b1s, b3s])
assert_same(br, [b2s])
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]
def tagconst(i):
return tag(i + TAG_CONST_OFFSET, TAGCONST)
def test_tagged_eq():
assert tagged_eq(UNASSIGNED, UNASSIGNED)
assert not tagged_eq(tag(1, TAGBOX), UNASSIGNED)
def test_untag():
assert untag(tag(3, 1)) == (3, 1)
assert untag(tag(-3, 2)) == (-3, 2)
assert untag(tag((1<<13)-1, 3)) == ((1<<13)-1, 3)
assert untag(tag(-1<<13, 3)) == (-1<<13, 3)
