def test_patch(l):
for middle in range(len(l)):
l1 = l[:middle]
l2 = l[middle:]
w = Writer(len(l))
w.append_int(0)
for num in l1:
w.append_int(num)
w.patch_current_size(0)
for num in l2:
w.append_int(num)
n = w.create_numbering()
assert unpack_numbering(n)[1:] == l
assert unpack_numbering(n)[0] == middle + 1
def test_known_classes():
cls = FakeClass()
box1 = InputArgRef()
box1.set_forwarded(InstancePtrInfo(known_class=cls))
box2 = InputArgRef()
box3 = InputArgRef()
optimizer = FakeOptimizer()
numb_state = NumberingState(4)
numb_state.append_int(1) # size of resume block
liveboxes = [InputArgInt(), box2, box1, box3]
serialize_optimizer_knowledge(optimizer, numb_state, liveboxes, {}, None)
assert unpack_numbering(
numb_state.create_numbering()) == [1, 0b010000, 0, 0, 0]
rbox1 = InputArgRef()
rbox2 = InputArgRef()
rbox3 = InputArgRef()
after_optimizer = FakeOptimizer(cpu=FakeCPU({rbox1: cls}))
deserialize_optimizer_knowledge(after_optimizer,
FakeStorage(numb_state.create_numbering()),
[InputArgInt(), rbox2, rbox1, rbox3],
liveboxes)
assert box1 in after_optimizer.constant_classes
assert box2 not in after_optimizer.constant_classes
assert box3 not in after_optimizer.constant_classes
def test_ResumeDataLoopMemo_random(lst):
inpargs = [box for box in lst if not isinstance(box, Const)]
metainterp_sd = FakeMetaInterpStaticData()
t = Trace(inpargs, metainterp_sd)
t.append(0)
i = t.get_iter()
t.create_top_snapshot(FakeJitCode("", 0), 0, Frame(lst), False, [], [])
memo = ResumeDataLoopMemo(metainterp_sd)
numb_state = memo.number(0, i)
numb = numb_state.create_numbering()
l = unpack_numbering(numb)
assert l[0] == len(l)
assert l[1] == 0
assert l[1] == 0
assert l[2] == 0
assert l[3] == 0
assert l[4] == 0
mapping = dict(zip(inpargs, i.inputargs))
for i, item in enumerate(lst):
v, tag = untag(l[i + 6])
if tag == TAGBOX:
assert l[i + 6] == numb_state.liveboxes[mapping[item]]
elif tag == TAGCONST:
assert memo.consts[v].getint() == item.getint()
elif tag == TAGINT:
assert v == item.getint()
def test_writer(l):
for size in [len(l), 0]:
w = Writer(len(l))
for num in l:
w.append_int(num)
n = w.create_numbering()
assert unpack_numbering(n) == l
def test_pack_unpack():
examples = [
[1, 2, 3, 4, 257, 10000, 13, 15],
[1, 2, 3, 4],
range(1, 10, 2),
[13000, 12000, 10000, 256, 255, 254, 257, -3, -1000]
]
for l in examples:
n = create_numbering(l)
assert unpack_numbering(n) == l
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 test_roundtrip(l):
n = create_numbering(l)
assert unpack_numbering(n) == l
def test_roundtrip(l):
n = create_numbering(l)
assert unpack_numbering(n) == l
