[pypy-commit] pypy arm-backend-2: update some more tests
bivab
noreply at buildbot.pypy.org
Mon Jan 9 11:56:36 CET 2012
Author: David Schneider <david.schneider at picle.org>
Branch: arm-backend-2
Changeset: r51154:9688a1080b2b
Date: 2011-12-30 20:28 +0100
http://bitbucket.org/pypy/pypy/changeset/9688a1080b2b/
Log: update some more tests
diff --git a/pypy/jit/backend/arm/test/test_gc_integration.py b/pypy/jit/backend/arm/test/test_gc_integration.py
--- a/pypy/jit/backend/arm/test/test_gc_integration.py
+++ b/pypy/jit/backend/arm/test/test_gc_integration.py
@@ -46,82 +46,19 @@
return ['compressed'] + shape[1:]
-class MockGcRootMap2(object):
- is_shadow_stack = False
-
- def get_basic_shape(self, is_64_bit):
- return ['shape']
-
- def add_frame_offset(self, shape, offset):
- shape.append(offset)
-
- def add_callee_save_reg(self, shape, reg_index):
- index_to_name = {1: 'ebx', 2: 'esi', 3: 'edi'}
- shape.append(index_to_name[reg_index])
-
- def compress_callshape(self, shape, datablockwrapper):
- assert datablockwrapper == 'fakedatablockwrapper'
- assert shape[0] == 'shape'
- return ['compressed'] + shape[1:]
-
-
class MockGcDescr(GcCache):
- is_shadow_stack = False
-
- def get_funcptr_for_new(self):
- return 123
-
- get_funcptr_for_newarray = get_funcptr_for_new
- get_funcptr_for_newstr = get_funcptr_for_new
- get_funcptr_for_newunicode = get_funcptr_for_new
get_malloc_slowpath_addr = None
-
+ write_barrier_descr = None
moving_gc = True
gcrootmap = MockGcRootMap()
def initialize(self):
pass
- record_constptrs = GcLLDescr_framework.record_constptrs.im_func
+ _record_constptrs = GcLLDescr_framework._record_constptrs.im_func
rewrite_assembler = GcLLDescr_framework.rewrite_assembler.im_func
-class TestRegallocDirectGcIntegration(object):
-
- def test_mark_gc_roots(self):
- py.test.skip('roots')
- cpu = CPU(None, None)
- cpu.setup_once()
- regalloc = Regalloc(MockAssembler(cpu, MockGcDescr(False)))
- regalloc.assembler.datablockwrapper = 'fakedatablockwrapper'
- boxes = [BoxPtr() for i in range(len(ARMv7RegisterManager.all_regs))]
- longevity = {}
- for box in boxes:
- longevity[box] = (0, 1)
- regalloc.fm = ARMFrameManager()
- regalloc.rm = ARMv7RegisterManager(longevity, regalloc.fm,
- assembler=regalloc.assembler)
- regalloc.xrm = VFPRegisterManager(longevity, regalloc.fm,
- assembler=regalloc.assembler)
- cpu = regalloc.assembler.cpu
- for box in boxes:
- regalloc.rm.try_allocate_reg(box)
- TP = lltype.FuncType([], lltype.Signed)
- calldescr = cpu.calldescrof(TP, TP.ARGS, TP.RESULT,
- EffectInfo.MOST_GENERAL)
- regalloc.rm._check_invariants()
- box = boxes[0]
- regalloc.position = 0
- regalloc.consider_call(ResOperation(rop.CALL, [box], BoxInt(),
- calldescr))
- assert len(regalloc.assembler.movs) == 3
- #
- mark = regalloc.get_mark_gc_roots(cpu.gc_ll_descr.gcrootmap)
- assert mark[0] == 'compressed'
- base = -WORD * FRAME_FIXED_SIZE
- expected = ['ebx', 'esi', 'edi', base, base-WORD, base-WORD*2]
- assert dict.fromkeys(mark[1:]) == dict.fromkeys(expected)
-
class TestRegallocGcIntegration(BaseTestRegalloc):
cpu = CPU(None, None)
@@ -199,42 +136,32 @@
'''
self.interpret(ops, [0, 0, 0, 0, 0, 0, 0, 0, 0], run=False)
+NOT_INITIALIZED = chr(0xdd)
+
class GCDescrFastpathMalloc(GcLLDescription):
gcrootmap = None
- expected_malloc_slowpath_size = WORD*2
+ write_barrier_descr = None
def __init__(self):
- GcCache.__init__(self, False)
+ GcLLDescription.__init__(self, None)
# create a nursery
- NTP = rffi.CArray(lltype.Signed)
- self.nursery = lltype.malloc(NTP, 16, flavor='raw')
- self.addrs = lltype.malloc(rffi.CArray(lltype.Signed), 3,
+ NTP = rffi.CArray(lltype.Char)
+ self.nursery = lltype.malloc(NTP, 64, flavor='raw')
+ for i in range(64):
+ self.nursery[i] = NOT_INITIALIZED
+ self.addrs = lltype.malloc(rffi.CArray(lltype.Signed), 2,
flavor='raw')
self.addrs[0] = rffi.cast(lltype.Signed, self.nursery)
- self.addrs[1] = self.addrs[0] + 16*WORD
- self.addrs[2] = 0
- # 16 WORDs
+ self.addrs[1] = self.addrs[0] + 64
+ self.calls = []
def malloc_slowpath(size):
- assert size == self.expected_malloc_slowpath_size
+ self.calls.append(size)
+ # reset the nursery
nadr = rffi.cast(lltype.Signed, self.nursery)
self.addrs[0] = nadr + size
- self.addrs[2] += 1
return nadr
- self.malloc_slowpath = malloc_slowpath
- self.MALLOC_SLOWPATH = lltype.FuncType([lltype.Signed],
- lltype.Signed)
- self._counter = 123000
-
- def can_inline_malloc(self, descr):
- return True
-
- def get_funcptr_for_new(self):
- return 42
-# return llhelper(lltype.Ptr(self.NEW_TP), self.new)
-
- def init_size_descr(self, S, descr):
- descr.tid = self._counter
- self._counter += 1
+ self.generate_function('malloc_nursery', malloc_slowpath,
+ [lltype.Signed], lltype.Signed)
def get_nursery_free_addr(self):
return rffi.cast(lltype.Signed, self.addrs)
@@ -243,209 +170,61 @@
return rffi.cast(lltype.Signed, self.addrs) + WORD
def get_malloc_slowpath_addr(self):
- fptr = llhelper(lltype.Ptr(self.MALLOC_SLOWPATH), self.malloc_slowpath)
- return rffi.cast(lltype.Signed, fptr)
+ return self.get_malloc_fn_addr('malloc_nursery')
- get_funcptr_for_newarray = None
- get_funcptr_for_newstr = None
- get_funcptr_for_newunicode = None
+ def check_nothing_in_nursery(self):
+ # CALL_MALLOC_NURSERY should not write anything in the nursery
+ for i in range(64):
+ assert self.nursery[i] == NOT_INITIALIZED
class TestMallocFastpath(BaseTestRegalloc):
def setup_method(self, method):
cpu = CPU(None, None)
- cpu.vtable_offset = WORD
cpu.gc_ll_descr = GCDescrFastpathMalloc()
cpu.setup_once()
+ self.cpu = cpu
- # hack: specify 'tid' explicitly, because this test is not running
- # with the gc transformer
- NODE = lltype.GcStruct('node', ('tid', lltype.Signed),
- ('value', lltype.Signed))
- nodedescr = cpu.sizeof(NODE)
- valuedescr = cpu.fielddescrof(NODE, 'value')
-
- self.cpu = cpu
- self.nodedescr = nodedescr
- vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
- vtable_int = cpu.cast_adr_to_int(llmemory.cast_ptr_to_adr(vtable))
- NODE2 = lltype.GcStruct('node2',
- ('parent', rclass.OBJECT),
- ('tid', lltype.Signed),
- ('vtable', lltype.Ptr(rclass.OBJECT_VTABLE)))
- descrsize = cpu.sizeof(NODE2)
- heaptracker.register_known_gctype(cpu, vtable, NODE2)
- self.descrsize = descrsize
- self.vtable_int = vtable_int
-
- self.namespace = locals().copy()
-
def test_malloc_fastpath(self):
ops = '''
- [i0]
- p0 = new(descr=nodedescr)
- setfield_gc(p0, i0, descr=valuedescr)
- finish(p0)
+ []
+ p0 = call_malloc_nursery(16)
+ p1 = call_malloc_nursery(32)
+ p2 = call_malloc_nursery(16)
+ finish(p0, p1, p2)
'''
- self.interpret(ops, [42])
- # check the nursery
+ self.interpret(ops, [])
+ # check the returned pointers
gc_ll_descr = self.cpu.gc_ll_descr
- assert gc_ll_descr.nursery[0] == self.nodedescr.tid
- assert gc_ll_descr.nursery[1] == 42
nurs_adr = rffi.cast(lltype.Signed, gc_ll_descr.nursery)
- assert gc_ll_descr.addrs[0] == nurs_adr + (WORD*2)
- assert gc_ll_descr.addrs[2] == 0 # slowpath never called
+ ref = self.cpu.get_latest_value_ref
+ assert rffi.cast(lltype.Signed, ref(0)) == nurs_adr + 0
+ assert rffi.cast(lltype.Signed, ref(1)) == nurs_adr + 16
+ assert rffi.cast(lltype.Signed, ref(2)) == nurs_adr + 48
+ # check the nursery content and state
+ gc_ll_descr.check_nothing_in_nursery()
+ assert gc_ll_descr.addrs[0] == nurs_adr + 64
+ # slowpath never called
+ assert gc_ll_descr.calls == []
def test_malloc_slowpath(self):
ops = '''
[]
- p0 = new(descr=nodedescr)
- p1 = new(descr=nodedescr)
- p2 = new(descr=nodedescr)
- p3 = new(descr=nodedescr)
- p4 = new(descr=nodedescr)
- p5 = new(descr=nodedescr)
- p6 = new(descr=nodedescr)
- p7 = new(descr=nodedescr)
- p8 = new(descr=nodedescr)
- finish(p0, p1, p2, p3, p4, p5, p6, p7, p8)
+ p0 = call_malloc_nursery(16)
+ p1 = call_malloc_nursery(32)
+ p2 = call_malloc_nursery(24) # overflow
+ finish(p0, p1, p2)
'''
self.interpret(ops, [])
+ # check the returned pointers
+ gc_ll_descr = self.cpu.gc_ll_descr
+ nurs_adr = rffi.cast(lltype.Signed, gc_ll_descr.nursery)
+ ref = self.cpu.get_latest_value_ref
+ assert rffi.cast(lltype.Signed, ref(0)) == nurs_adr + 0
+ assert rffi.cast(lltype.Signed, ref(1)) == nurs_adr + 16
+ assert rffi.cast(lltype.Signed, ref(2)) == nurs_adr + 0
+ # check the nursery content and state
+ gc_ll_descr.check_nothing_in_nursery()
+ assert gc_ll_descr.addrs[0] == nurs_adr + 24
# this should call slow path once
- gc_ll_descr = self.cpu.gc_ll_descr
- nadr = rffi.cast(lltype.Signed, gc_ll_descr.nursery)
- assert gc_ll_descr.addrs[0] == nadr + (WORD*2)
- assert gc_ll_descr.addrs[2] == 1 # slowpath called once
-
- def test_new_with_vtable(self):
- ops = '''
- [i0, i1]
- p0 = new_with_vtable(ConstClass(vtable))
- guard_class(p0, ConstClass(vtable)) [i0]
- finish(i1)
- '''
- self.interpret(ops, [0, 1])
- assert self.getint(0) == 1
- gc_ll_descr = self.cpu.gc_ll_descr
- assert gc_ll_descr.nursery[0] == self.descrsize.tid
- assert gc_ll_descr.nursery[1] == self.vtable_int
- nurs_adr = rffi.cast(lltype.Signed, gc_ll_descr.nursery)
- assert gc_ll_descr.addrs[0] == nurs_adr + (WORD*3)
- assert gc_ll_descr.addrs[2] == 0 # slowpath never called
-
-
-class Seen(Exception):
- pass
-
-
-class GCDescrFastpathMallocVarsize(GCDescrFastpathMalloc):
- def can_inline_malloc_varsize(self, arraydescr, num_elem):
- return num_elem < 5
-
- def get_funcptr_for_newarray(self):
- return 52
-
- def init_array_descr(self, A, descr):
- descr.tid = self._counter
- self._counter += 1
-
- def args_for_new_array(self, descr):
- raise Seen("args_for_new_array")
-
-
-class TestMallocVarsizeFastpath(BaseTestRegalloc):
- def setup_method(self, method):
- cpu = CPU(None, None)
- cpu.vtable_offset = WORD
- cpu.gc_ll_descr = GCDescrFastpathMallocVarsize()
- cpu.setup_once()
- self.cpu = cpu
-
- ARRAY = lltype.GcArray(lltype.Signed)
- arraydescr = cpu.arraydescrof(ARRAY)
- self.arraydescr = arraydescr
- ARRAYCHAR = lltype.GcArray(lltype.Char)
- arraychardescr = cpu.arraydescrof(ARRAYCHAR)
-
- self.namespace = locals().copy()
-
- def test_malloc_varsize_fastpath(self):
- # Hack. Running the GcLLDescr_framework without really having
- # a complete GC means that we end up with both the tid and the
- # length being at offset 0. In this case, so the length overwrites
- # the tid. This is of course only the case in this test class.
- ops = '''
- []
- p0 = new_array(4, descr=arraydescr)
- setarrayitem_gc(p0, 0, 142, descr=arraydescr)
- setarrayitem_gc(p0, 3, 143, descr=arraydescr)
- finish(p0)
- '''
- self.interpret(ops, [])
- # check the nursery
- gc_ll_descr = self.cpu.gc_ll_descr
- assert gc_ll_descr.nursery[0] == 4
- assert gc_ll_descr.nursery[1] == 142
- assert gc_ll_descr.nursery[4] == 143
- nurs_adr = rffi.cast(lltype.Signed, gc_ll_descr.nursery)
- assert gc_ll_descr.addrs[0] == nurs_adr + (WORD*5)
- assert gc_ll_descr.addrs[2] == 0 # slowpath never called
-
- def test_malloc_varsize_slowpath(self):
- ops = '''
- []
- p0 = new_array(4, descr=arraydescr)
- setarrayitem_gc(p0, 0, 420, descr=arraydescr)
- setarrayitem_gc(p0, 3, 430, descr=arraydescr)
- p1 = new_array(4, descr=arraydescr)
- setarrayitem_gc(p1, 0, 421, descr=arraydescr)
- setarrayitem_gc(p1, 3, 431, descr=arraydescr)
- p2 = new_array(4, descr=arraydescr)
- setarrayitem_gc(p2, 0, 422, descr=arraydescr)
- setarrayitem_gc(p2, 3, 432, descr=arraydescr)
- p3 = new_array(4, descr=arraydescr)
- setarrayitem_gc(p3, 0, 423, descr=arraydescr)
- setarrayitem_gc(p3, 3, 433, descr=arraydescr)
- finish(p0, p1, p2, p3)
- '''
- gc_ll_descr = self.cpu.gc_ll_descr
- gc_ll_descr.expected_malloc_slowpath_size = 5*WORD
- self.interpret(ops, [])
- assert gc_ll_descr.addrs[2] == 1 # slowpath called once
-
- def test_malloc_varsize_too_big(self):
- ops = '''
- []
- p0 = new_array(5, descr=arraydescr)
- finish(p0)
- '''
- py.test.raises(Seen, self.interpret, ops, [])
-
- def test_malloc_varsize_variable(self):
- ops = '''
- [i0]
- p0 = new_array(i0, descr=arraydescr)
- finish(p0)
- '''
- py.test.raises(Seen, self.interpret, ops, [])
-
- def test_malloc_array_of_char(self):
- # check that fastpath_malloc_varsize() respects the alignment
- # of the pointer in the nursery
- ops = '''
- []
- p1 = new_array(1, descr=arraychardescr)
- p2 = new_array(2, descr=arraychardescr)
- p3 = new_array(3, descr=arraychardescr)
- p4 = new_array(4, descr=arraychardescr)
- finish(p1, p2, p3, p4)
- '''
- self.interpret(ops, [])
- p1 = self.getptr(0, llmemory.GCREF)
- p2 = self.getptr(1, llmemory.GCREF)
- p3 = self.getptr(2, llmemory.GCREF)
- p4 = self.getptr(3, llmemory.GCREF)
- assert p1._obj.intval & (WORD-1) == 0 # aligned
- assert p2._obj.intval & (WORD-1) == 0 # aligned
- assert p3._obj.intval & (WORD-1) == 0 # aligned
- assert p4._obj.intval & (WORD-1) == 0 # aligned
+ assert gc_ll_descr.calls == [24]
diff --git a/pypy/jit/backend/arm/test/test_generated.py b/pypy/jit/backend/arm/test/test_generated.py
--- a/pypy/jit/backend/arm/test/test_generated.py
+++ b/pypy/jit/backend/arm/test/test_generated.py
@@ -137,7 +137,7 @@
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
args = [-5 , 24 , 46 , -15 , 13 , -8 , 0 , -6 , 6 , 6]
- op = cpu.execute_token(looptoken)
+ op = cpu.execute_token(looptoken, *args)
assert op.identifier == 2
assert cpu.get_latest_value_int(0) == 24
assert cpu.get_latest_value_int(1) == -32
diff --git a/pypy/jit/backend/arm/test/test_regalloc.py b/pypy/jit/backend/arm/test/test_regalloc.py
--- a/pypy/jit/backend/arm/test/test_regalloc.py
+++ b/pypy/jit/backend/arm/test/test_regalloc.py
@@ -151,20 +151,20 @@
loop = self.parse(ops)
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
- args = []
+ arguments = []
for arg in args:
if isinstance(arg, int):
- args.append(arg)
+ arguments.append(arg)
elif isinstance(arg, float):
arg = longlong.getfloatstorage(arg)
- args.append(arg)
+ arguments.append(arg)
else:
assert isinstance(lltype.typeOf(arg), lltype.Ptr)
llgcref = lltype.cast_opaque_ptr(llmemory.GCREF, arg)
- args.append(llgcref)
+ arguments.append(llgcref)
loop._jitcelltoken = looptoken
if run:
- self.cpu.execute_token(looptoken, *args)
+ self.cpu.execute_token(looptoken, *arguments)
return loop
def prepare_loop(self, ops):
More information about the pypy-commit
mailing list