[pypy-svn] r74734 - in pypy/branch/blackhole-improvement/pypy/jit: codewriter codewriter/test metainterp metainterp/test
arigo at codespeak.net
arigo at codespeak.net
Tue May 25 16:00:23 CEST 2010
Author: arigo
Date: Tue May 25 16:00:22 2010
New Revision: 74734
Modified:
pypy/branch/blackhole-improvement/pypy/jit/codewriter/assembler.py
pypy/branch/blackhole-improvement/pypy/jit/codewriter/jitcode.py
pypy/branch/blackhole-improvement/pypy/jit/codewriter/test/test_jitcode.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/resume.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_loop.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_resume.py
Log:
Fix a subtle bug, involving a mismatch between reality and expectation
in the order of boxes.
Modified: pypy/branch/blackhole-improvement/pypy/jit/codewriter/assembler.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/codewriter/assembler.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/codewriter/assembler.py Tue May 25 16:00:22 2010
@@ -165,16 +165,16 @@
self.code[startposition] = chr(num)
self.startpoints.add(startposition)
- def get_liveness_info(self, prevstring, args, kind):
+ def get_liveness_info(self, prevlives, args, kind):
"""Return a string whose characters are register numbers.
We sort the numbers, too, to increase the chances of duplicate
strings (which are collapsed into a single string during translation).
"""
- lives = set(prevstring) # set of characters
+ lives = set(prevlives) # set of characters
for reg in args:
if isinstance(reg, Register) and reg.kind == kind:
lives.add(chr(reg.index))
- return ''.join(sorted(lives))
+ return lives
def fix_labels(self):
for name, pos in self.tlabel_positions:
Modified: pypy/branch/blackhole-improvement/pypy/jit/codewriter/jitcode.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/codewriter/jitcode.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/codewriter/jitcode.py Tue May 25 16:00:22 2010
@@ -28,7 +28,7 @@
self.num_regs_encoded = ((num_regs_i << 16) |
(num_regs_f << 8) |
(num_regs_r << 0))
- self.liveness = liveness
+ self.liveness = make_liveness_cache(liveness)
self._startpoints = startpoints # debugging
self._alllabels = alllabels # debugging
@@ -49,9 +49,8 @@
def get_live_vars_info(self, pc):
# 'pc' gives a position in this bytecode. This returns an object
- # that describes all variables that are live across the instruction
- # boundary at 'pc'. To decode the object, use the global functions
- # 'get_register_{count,index}_{i,r,f}()'.
+ # of class LiveVarsInfo that describes all variables that are live
+ # across the instruction boundary at 'pc'.
if not we_are_translated() and pc not in self.liveness:
self._missing_liveness(pc)
return self.liveness[pc] # XXX compactify!!
@@ -59,12 +58,12 @@
def _live_vars(self, pc):
# for testing only
info = self.get_live_vars_info(pc)
- lst_i = ['%%i%d' % get_register_index_i(info, index)
- for index in range(get_register_count_i(info))]
- lst_r = ['%%r%d' % get_register_index_r(info, index)
- for index in range(get_register_count_r(info))]
- lst_f = ['%%f%d' % get_register_index_f(info, index)
- for index in range(get_register_count_f(info))]
+ lst_i = ['%%i%d' % info.get_register_index_i(index)
+ for index in range(info.get_register_count_i())]
+ lst_r = ['%%r%d' % info.get_register_index_r(index)
+ for index in range(info.get_register_count_r())]
+ lst_f = ['%%f%d' % info.get_register_index_f(index)
+ for index in range(info.get_register_count_f())]
return ' '.join(lst_i + lst_r + lst_f)
def _missing_liveness(self, pc):
@@ -104,16 +103,54 @@
return '<SwitchDictDescr %s>' % (dict,)
-def get_register_count_i((live_i, live_r, live_f)):
- return len(live_i)
-def get_register_count_r((live_i, live_r, live_f)):
- return len(live_r)
-def get_register_count_f((live_i, live_r, live_f)):
- return len(live_f)
-
-def get_register_index_i((live_i, live_r, live_f), index):
- return ord(live_i[index])
-def get_register_index_r((live_i, live_r, live_f), index):
- return ord(live_r[index])
-def get_register_index_f((live_i, live_r, live_f), index):
- return ord(live_f[index])
+class LiveVarsInfo(object):
+ def __init__(self, live_i, live_r, live_f):
+ self.live_i = live_i
+ self.live_r = live_r
+ self.live_f = live_f
+
+ def get_register_count_i(self):
+ return len(self.live_i)
+ def get_register_count_r(self):
+ return len(self.live_r)
+ def get_register_count_f(self):
+ return len(self.live_f)
+
+ def get_register_index_i(self, index):
+ return ord(self.live_i[index])
+ def get_register_index_r(self, index):
+ return ord(self.live_r[index])
+ def get_register_index_f(self, index):
+ return ord(self.live_f[index])
+
+ def enumerate_vars(self, callback_i, callback_r, callback_f):
+ index = 0
+ for i in range(self.get_register_count_i()):
+ callback_i(index, self.get_register_index_i(i))
+ index += 1
+ for i in range(self.get_register_count_r()):
+ callback_r(index, self.get_register_index_r(i))
+ index += 1
+ for i in range(self.get_register_count_f()):
+ callback_f(index, self.get_register_index_f(i))
+ index += 1
+
+_liveness_cache = {}
+
+def make_liveness_cache(liveness):
+ if liveness is None:
+ return None
+ result = {}
+ for key, (value_i, value_r, value_f) in liveness.items():
+ # Sort the lists to increase the chances of sharing between unrelated
+ # strings that happen to contain the same characters. We sort in the
+ # reversed order just to reduce the risks of tests passing by chance.
+ value = (''.join(sorted(value_i, reverse=True)),
+ ''.join(sorted(value_r, reverse=True)),
+ ''.join(sorted(value_f, reverse=True)))
+ try:
+ info = _liveness_cache[value]
+ except KeyError:
+ info = _liveness_cache[value] = LiveVarsInfo(*value)
+ result[key] = info
+ return result
Modified: pypy/branch/blackhole-improvement/pypy/jit/codewriter/test/test_jitcode.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/codewriter/test/test_jitcode.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/codewriter/test/test_jitcode.py Tue May 25 16:00:22 2010
@@ -21,4 +21,4 @@
j.setup(liveness={5: (" A", "b", "CD")})
assert j.has_liveness_info(5)
assert not j.has_liveness_info(4)
- assert j._live_vars(5) == "%i32 %i65 %r98 %f67 %f68"
+ assert j._live_vars(5) == "%i65 %i32 %r98 %f68 %f67"
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py Tue May 25 16:00:22 2010
@@ -353,6 +353,9 @@
self.registers_r[i] = NULL
self.exception_last_value = None
+ def get_current_position_info(self):
+ return self.jitcode.get_live_vars_info(self.position)
+
def handle_exception_in_frame(self, e):
# This frame raises an exception. First try to see if
# the exception is handled in the frame itself.
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py Tue May 25 16:00:22 2010
@@ -101,6 +101,9 @@
outvalue[startindex+i] = reg
prepare_list_of_boxes._annspecialcase_ = 'specialize:arg(4)'
+ def get_current_position_info(self):
+ return self.jitcode.get_live_vars_info(self.pc)
+
def get_list_of_active_boxes(self, in_a_call):
if in_a_call:
# If we are not the topmost frame, self._result_argcode contains
@@ -114,37 +117,24 @@
elif argcode == 'f': self.registers_f[index] = history.CONST_FZERO
self._result_argcode = '?' # done
#
- from pypy.jit.codewriter.jitcode import get_register_count_i
- from pypy.jit.codewriter.jitcode import get_register_count_r
- from pypy.jit.codewriter.jitcode import get_register_count_f
- from pypy.jit.codewriter.jitcode import get_register_index_i
- from pypy.jit.codewriter.jitcode import get_register_index_r
- from pypy.jit.codewriter.jitcode import get_register_index_f
- info = self.jitcode.get_live_vars_info(self.pc)
- total = (get_register_count_i(info) +
- get_register_count_r(info) +
- get_register_count_f(info))
+ info = self.get_current_position_info()
+ start_i = 0
+ start_r = start_i + info.get_register_count_i()
+ start_f = start_r + info.get_register_count_r()
+ total = start_f + info.get_register_count_f()
# allocate a list of the correct size
env = [None] * total
make_sure_not_resized(env)
# fill it now
- count = 0
- for index in range(get_register_count_i(info)):
- box = self.registers_i[get_register_index_i(info, index)]
- assert box is not None
- env[count] = box
- count += 1
- for index in range(get_register_count_r(info)):
- box = self.registers_r[get_register_index_r(info, index)]
- assert box is not None
- env[count] = box
- count += 1
- for index in range(get_register_count_f(info)):
- box = self.registers_f[get_register_index_f(info, index)]
- assert box is not None
- env[count] = box
- count += 1
- assert count == total
+ for i in range(info.get_register_count_i()):
+ index = info.get_register_index_i(i)
+ env[start_i + i] = self.registers_i[index]
+ for i in range(info.get_register_count_r()):
+ index = info.get_register_index_r(i)
+ env[start_r + i] = self.registers_r[index]
+ for i in range(info.get_register_count_f()):
+ index = info.get_register_index_f(i)
+ env[start_f + i] = self.registers_f[index]
return env
def replace_active_box_in_frame(self, oldbox, newbox):
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/resume.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/resume.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/resume.py Tue May 25 16:00:22 2010
@@ -19,7 +19,6 @@
__slots__ = ('prev', 'boxes')
def __init__(self, prev, boxes):
- _assert_order(boxes)
self.prev = prev
self.boxes = boxes
@@ -58,7 +57,7 @@
storage.rd_frame_info_list = frame_info_list
snapshot = Snapshot(top.parent_resumedata_snapshot,
top.get_list_of_active_boxes(False))
- snapshot = Snapshot(snapshot, virtualref_boxes[:]) # xxx for now
+ #snapshot = Snapshot(snapshot, virtualref_boxes[:]) # xxx for now
if virtualizable_boxes is not None:
snapshot = Snapshot(snapshot, virtualizable_boxes[:]) # xxx for now
storage.rd_snapshot = snapshot
@@ -105,9 +104,6 @@
UNASSIGNED = tag(-1<<13, TAGBOX)
UNASSIGNEDVIRTUAL = tag(-1<<13, TAGVIRTUAL)
NULLREF = tag(-1, TAGCONST)
-TYPEBARRIER = tag(-2, TAGCONST)
- # nums = [..BoxInts.., TYPEBARRIER, ..BoxPtrs..]
- # and optionally an extra [TYPEBARRIER, ..BoxFloats..]
class ResumeDataLoopMemo(object):
@@ -171,12 +167,8 @@
numb1, liveboxes, v = self.number(values, snapshot.prev)
n = len(liveboxes)-v
boxes = snapshot.boxes
- _assert_order(boxes)
length = len(boxes)
- numslength = length + 1 + (length > 0 and boxes[-1].type == FLOAT)
- nums = [UNASSIGNED] * numslength
- prevkind = INT
- j = 0
+ nums = [UNASSIGNED] * length
for i in range(length):
box = boxes[i]
value = values.get(box, None)
@@ -195,22 +187,7 @@
tagged = tag(n, TAGBOX)
n += 1
liveboxes[box] = tagged
- #
- if box.type != prevkind:
- nums[j] = TYPEBARRIER
- j += 1
- if prevkind == INT and box.type == FLOAT:
- nums[j] = TYPEBARRIER
- j += 1
- prevkind = box.type
- #
- nums[j] = tagged
- j += 1
- #
- if j == length:
- nums[j] = TYPEBARRIER
- j += 1
- assert j == numslength
+ nums[i] = tagged
#
numb = Numbering(numb1, nums)
self.numberings[snapshot] = numb, liveboxes, v
@@ -416,14 +393,6 @@
return self.liveboxes_from_env[box]
return self.liveboxes[box]
-def _assert_order(boxes):
- if not we_are_translated():
- # verifies that 'boxes' are in order: all INTs, then all REFs,
- # and finally all FLOATs.
- _kind2count = {INT: 1, REF: 2, FLOAT: 3}
- kinds = [_kind2count[box.type] for box in boxes]
- assert kinds == sorted(kinds)
-
class AbstractVirtualInfo(object):
#def allocate(self, metainterp):
@@ -552,33 +521,25 @@
struct = self.decode_ref(num)
self.setfield(descr, struct, fieldnum)
- def _prepare_next_section(self):
- numb = self.cur_numb
- self.cur_numb = numb.prev
- nums = numb.nums
- length = len(nums)
- count_i = count_r = count_f = 0
- i = 0
- while True:
- num = nums[i]
- i += 1
- if tagged_eq(num, TYPEBARRIER):
- break
- self.write_an_int(count_i, self.decode_int(num))
- count_i += 1
- while i < length:
- num = nums[i]
- i += 1
- if tagged_eq(num, TYPEBARRIER):
- break
- self.write_a_ref(count_r, self.decode_ref(num))
- count_r += 1
- while i < length:
- num = nums[i]
- i += 1
- assert not tagged_eq(num, TYPEBARRIER)
- self.write_a_float(count_f, self.decode_float(num))
- count_f += 1
+ def _prepare_next_section(self, info):
+ # Use info.enumerate_vars(), normally dispatching to
+ # pypy.jit.codewriter.jitcode. Some tests give a different 'info'.
+ info.enumerate_vars(self._callback_i,
+ self._callback_r,
+ self._callback_f)
+ self.cur_numb = self.cur_numb.prev
+
+ def _callback_i(self, index, register_index):
+ value = self.decode_int(self.cur_numb.nums[index])
+ self.write_an_int(register_index, value)
+
+ def _callback_r(self, index, register_index):
+ value = self.decode_ref(self.cur_numb.nums[index])
+ self.write_a_ref(register_index, value)
+
+ def _callback_f(self, index, register_index):
+ value = self.decode_float(self.cur_numb.nums[index])
+ self.write_a_float(register_index, value)
def done(self):
self.cpu.clear_latest_values()
@@ -591,12 +552,13 @@
virtualizable_boxes = None
if expects_virtualizables:
XXX # virtualizable_boxes = resumereader.consume_boxes()
- resumereader.consume_boxes([], [], []) # XXX virtualref
+ #resumereader.consume_boxes([], [], []) # XXX virtualref
frameinfo = storage.rd_frame_info_list
while True:
f = metainterp.newframe(frameinfo.jitcode)
f.setup_resume_at_op(frameinfo.pc)
- resumereader.consume_boxes(f.registers_i, f.registers_r, f.registers_f)
+ resumereader.consume_boxes(f.get_current_position_info(),
+ f.registers_i, f.registers_r, f.registers_f)
frameinfo = frameinfo.prev
if frameinfo is None:
break
@@ -610,7 +572,8 @@
virtualizable_boxes = None
if expects_virtualizables:
virtualizable_boxes = resumereader.consume_boxes()
- virtualref_boxes = resumereader.consume_boxes()
+ #virtualref_boxes = resumereader.consume_boxes()
+ virtualref_boxes = [] # XXX virtualrefs
return virtualizable_boxes, virtualref_boxes, resumereader.virtuals
class ResumeDataBoxReader(AbstractResumeDataReader):
@@ -620,11 +583,11 @@
self.liveboxes = [None] * metainterp.cpu.get_latest_value_count()
self._prepare(metainterp.cpu, storage)
- def consume_boxes(self, boxes_i, boxes_r, boxes_f):
+ def consume_boxes(self, info, boxes_i, boxes_r, boxes_f):
self.boxes_i = boxes_i
self.boxes_r = boxes_r
self.boxes_f = boxes_f
- self._prepare_next_section()
+ self._prepare_next_section(info)
def allocate_with_vtable(self, known_class):
return self.metainterp.execute_and_record(rop.NEW_WITH_VTABLE,
@@ -720,8 +683,7 @@
resumereader = ResumeDataDirectReader(blackholeinterpbuilder.cpu, storage)
if expects_virtualizables:
XXX
- #virtualref_boxes = resumereader.consume_boxes()
- resumereader.consume_one_section(None) # virtualref XXX
+ #virtualref_boxes = resumereader.consume_boxes() # virtualref XXX
#
# First get a chain of blackhole interpreters whose length is given
# by the depth of rd_frame_info_list. The first one we get must be
@@ -758,7 +720,8 @@
def consume_one_section(self, blackholeinterp):
self.blackholeinterp = blackholeinterp
- self._prepare_next_section()
+ info = blackholeinterp.get_current_position_info()
+ self._prepare_next_section(info)
def allocate_with_vtable(self, known_class):
from pypy.jit.metainterp.executor import exec_new_with_vtable
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_loop.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_loop.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_loop.py Tue May 25 16:00:22 2010
@@ -4,7 +4,7 @@
from pypy.jit.metainterp.warmspot import ll_meta_interp, get_stats
from pypy.rpython.lltypesystem import lltype
from pypy.jit.metainterp.test.test_basic import LLJitMixin, OOJitMixin
-from pypy.jit.metainterp.policy import StopAtXPolicy
+from pypy.jit.codewriter.policy import StopAtXPolicy
from pypy.jit.metainterp.resoperation import rop
from pypy.jit.metainterp import history
@@ -342,7 +342,7 @@
assert res == expected
def test_loop_unicode(self):
- myjitdriver = JitDriver(greens = [], reds = ['x', 'n'])
+ myjitdriver = JitDriver(greens = [], reds = ['n', 'x'])
def f(n):
x = u''
while n > 13:
@@ -356,7 +356,7 @@
assert res == expected
def test_loop_string(self):
- myjitdriver = JitDriver(greens = [], reds = ['x', 'n'])
+ myjitdriver = JitDriver(greens = [], reds = ['n', 'x'])
def f(n):
x = ''
while n > 13:
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_resume.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_resume.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_resume.py Tue May 25 16:00:22 2010
@@ -95,10 +95,26 @@
return self.values[index]
class MyBlackholeInterp:
- def __init__(self):
+ def __init__(self, ARGS):
self.written_i = []
self.written_r = []
self.written_f = []
+ self.ARGS = ARGS
+
+ def get_current_position_info(self):
+ class MyInfo:
+ def enumerate_vars(_, callback_i, callback_r, callback_f):
+ count_i = count_r = count_f = 0
+ for index, ARG in enumerate(self.ARGS):
+ if ARG == lltype.Signed:
+ callback_i(index, count_i); count_i += 1
+ elif ARG == llmemory.GCREF:
+ callback_r(index, count_r); count_r += 1
+ elif ARG == lltype.Float:
+ callback_f(index, count_f); count_f += 1
+ else:
+ assert 0
+ return MyInfo()
def setarg_i(self, index, value):
assert index == len(self.written_i)
@@ -113,12 +129,14 @@
self.written_f.append(value)
def _next_section(reader, *expected):
- bh = MyBlackholeInterp()
+ bh = MyBlackholeInterp(map(lltype.typeOf, expected))
reader.consume_one_section(bh)
- lst_i = bh.written_i
- lst_r = bh.written_r
- lst_f = bh.written_f
- assert lst_i + lst_r + lst_f == list(expected)
+ expected_i = [x for x in expected if lltype.typeOf(x) == lltype.Signed]
+ expected_r = [x for x in expected if lltype.typeOf(x) == llmemory.GCREF]
+ expected_f = [x for x in expected if lltype.typeOf(x) == lltype.Float]
+ assert bh.written_i == expected_i
+ assert bh.written_r == expected_r
+ assert bh.written_f == expected_f
def test_simple_read():
@@ -126,36 +144,41 @@
c1, c2, c3 = [ConstInt(111), ConstInt(222), ConstInt(333)]
storage = Storage()
storage.rd_consts = [c1, c2, c3]
- numb = Numbering(None, [tag(0, TAGBOX), tag(2, TAGBOX), TYPEBARRIER,
- tag(1, TAGBOX)])
- numb = Numbering(numb, [tag(1, TAGCONST), tag(2, TAGCONST), TYPEBARRIER])
+ numb = Numbering(None, [tag(0, TAGBOX), tag(1, TAGBOX), tag(2, TAGBOX)])
+ numb = Numbering(numb, [tag(1, TAGCONST), tag(2, TAGCONST)])
numb = Numbering(numb, [tag(0, TAGBOX),
tag(0, TAGCONST),
- tag(0, TAGBOX),
- TYPEBARRIER,
NULLREF,
+ tag(0, TAGBOX),
tag(1, TAGBOX)])
storage.rd_numb = numb
#
cpu = MyCPU([42, gcref1, -66])
reader = ResumeDataDirectReader(cpu, storage)
- _next_section(reader, 42, 111, 42, gcrefnull, gcref1)
+ _next_section(reader, 42, 111, gcrefnull, 42, gcref1)
_next_section(reader, 222, 333)
- _next_section(reader, 42, -66, gcref1)
+ _next_section(reader, 42, gcref1, -66)
#
metainterp = MyMetaInterp(cpu)
reader = ResumeDataBoxReader(storage, metainterp)
bi, br, bf = [None]*3, [None]*2, [None]*0
- reader.consume_boxes(bi, br, bf)
+ info = MyBlackholeInterp([lltype.Signed, lltype.Signed,
+ llmemory.GCREF, lltype.Signed,
+ llmemory.GCREF]).get_current_position_info()
+ reader.consume_boxes(info, bi, br, bf)
b1s = reader.liveboxes[0]
b2s = reader.liveboxes[1]
assert bi == [b1s, ConstInt(111), b1s]
assert br == [ConstPtr(gcrefnull), b2s]
bi, br, bf = [None]*2, [None]*0, [None]*0
- reader.consume_boxes(bi, br, bf)
+ info = MyBlackholeInterp([lltype.Signed,
+ lltype.Signed]).get_current_position_info()
+ reader.consume_boxes(info, bi, br, bf)
assert bi == [ConstInt(222), ConstInt(333)]
bi, br, bf = [None]*2, [None]*1, [None]*0
- reader.consume_boxes(bi, br, bf)
+ info = MyBlackholeInterp([lltype.Signed, llmemory.GCREF,
+ lltype.Signed]).get_current_position_info()
+ reader.consume_boxes(info, bi, br, bf)
b3s = reader.liveboxes[2]
assert bi == [b1s, b3s]
assert br == [b2s]
@@ -164,7 +187,7 @@
def test_simple_read_tagged_ints():
storage = Storage()
storage.rd_consts = []
- numb = Numbering(None, [tag(100, TAGINT), TYPEBARRIER])
+ numb = Numbering(None, [tag(100, TAGINT)])
storage.rd_numb = numb
#
cpu = MyCPU([])
@@ -216,12 +239,12 @@
return "<FF %s %s %s>" % (self.jitcode, self.pc, self._env)
def test_Snapshot_create():
- l = [BoxInt(), BoxPtr()]
+ l = ['b0', 'b1']
snap = Snapshot(None, l)
assert snap.prev is None
assert snap.boxes is l
- l1 = [BoxInt()]
+ l1 = ['b3']
snap1 = Snapshot(snap, l1)
assert snap1.prev is snap
assert snap1.boxes is l1
@@ -620,9 +643,9 @@
assert liveboxes == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX),
b3: tag(2, TAGBOX)}
assert numb.nums == [tag(3, TAGINT), tag(2, TAGBOX), tag(0, TAGBOX),
- tag(1, TAGINT), TYPEBARRIER]
+ tag(1, TAGINT)]
assert numb.prev.nums == [tag(0, TAGBOX), tag(1, TAGINT), tag(1, TAGBOX),
- tag(0, TAGBOX), tag(2, TAGINT), TYPEBARRIER]
+ tag(0, TAGBOX), tag(2, TAGINT)]
assert numb.prev.prev is None
numb2, liveboxes2, v = memo.number({}, snap2)
@@ -632,7 +655,7 @@
b3: tag(2, TAGBOX)}
assert liveboxes2 is not liveboxes
assert numb2.nums == [tag(3, TAGINT), tag(2, TAGBOX), tag(0, TAGBOX),
- tag(3, TAGINT), TYPEBARRIER]
+ tag(3, TAGINT)]
assert numb2.prev is numb.prev
env3 = [c3, b3, b1, c3]
@@ -655,11 +678,11 @@
assert liveboxes3 == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX)}
assert numb3.nums == [tag(3, TAGINT), tag(4, TAGINT), tag(0, TAGBOX),
- tag(3, TAGINT), TYPEBARRIER]
+ tag(3, TAGINT)]
assert numb3.prev is numb.prev
# virtual
- env4 = [c3, b1, c3, b4]
+ env4 = [c3, b4, b1, c3]
snap4 = Snapshot(snap, env4)
numb4, liveboxes4, v = memo.number({b4: FakeValue(True, b4)}, snap4)
@@ -667,8 +690,8 @@
assert liveboxes4 == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX),
b4: tag(0, TAGVIRTUAL)}
- assert numb4.nums == [tag(3, TAGINT), tag(0, TAGBOX),
- tag(3, TAGINT), TYPEBARRIER, tag(0, TAGVIRTUAL)]
+ assert numb4.nums == [tag(3, TAGINT), tag(0, TAGVIRTUAL), tag(0, TAGBOX),
+ tag(3, TAGINT)]
assert numb4.prev is numb.prev
env5 = [b1, b4, b5]
@@ -680,8 +703,8 @@
assert liveboxes5 == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX),
b4: tag(0, TAGVIRTUAL), b5: tag(1, TAGVIRTUAL)}
- assert numb5.nums == [tag(0, TAGBOX), TYPEBARRIER,
- tag(0, TAGVIRTUAL), tag(1, TAGVIRTUAL)]
+ assert numb5.nums == [tag(0, TAGBOX), tag(0, TAGVIRTUAL),
+ tag(1, TAGVIRTUAL)]
assert numb5.prev is numb4
def test_ResumeDataLoopMemo_number_boxes():
@@ -767,7 +790,7 @@
storage = Storage()
snapshot = Snapshot(None, [b1, ConstInt(1), b1, b2])
snapshot = Snapshot(snapshot, [ConstInt(2), ConstInt(3)])
- snapshot = Snapshot(snapshot, [b1, b3, b2])
+ snapshot = Snapshot(snapshot, [b1, b2, b3])
storage.rd_snapshot = snapshot
storage.rd_frame_info_list = None
return storage
@@ -781,7 +804,7 @@
assert storage.rd_snapshot is None
cpu = MyCPU([])
reader = ResumeDataDirectReader(cpu, storage)
- _next_section(reader, sys.maxint, -65, 2**16)
+ _next_section(reader, sys.maxint, 2**16, -65)
_next_section(reader, 2, 3)
_next_section(reader, sys.maxint, 1, sys.maxint, 2**16)
@@ -812,7 +835,22 @@
def consume_boxes(self):
self.lst = []
- self._prepare_next_section()
+ class Whatever:
+ def __eq__(self, other):
+ return True
+ class MyInfo:
+ def enumerate_vars(_, callback_i, callback_r, callback_f):
+ for index, tagged in enumerate(self.cur_numb.nums):
+ box = self.decode_box(tagged, Whatever())
+ if box.type == INT:
+ callback_i(index, index)
+ elif box.type == REF:
+ callback_r(index, index)
+ elif box.type == FLOAT:
+ callback_f(index, index)
+ else:
+ assert 0
+ self._prepare_next_section(MyInfo())
return self.lst
def write_an_int(self, count_i, box):
@@ -849,7 +887,7 @@
metainterp = MyMetaInterp()
reader = ResumeDataFakeReader(storage, newboxes, metainterp)
lst = reader.consume_boxes()
- assert lst == [b1t, b3t, b1t]
+ assert lst == [b1t, b1t, b3t]
lst = reader.consume_boxes()
assert lst == [ConstInt(2), ConstInt(3)]
lst = reader.consume_boxes()
@@ -870,7 +908,7 @@
reader = ResumeDataFakeReader(storage, newboxes, metainterp)
lst = reader.consume_boxes()
c1t = ConstInt(111)
- assert lst == [c1t, b3t, b2t]
+ assert lst == [c1t, b2t, b3t]
lst = reader.consume_boxes()
assert lst == [ConstInt(2), ConstInt(3)]
lst = reader.consume_boxes()
More information about the Pypy-commit
mailing list