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