def test_repr_of_descr():
c0 = GcCache(False)
T = lltype.GcStruct('T')
S = lltype.GcStruct('S', ('x', lltype.Char), ('y', lltype.Ptr(T)),
('z', lltype.Ptr(T)))
descr1 = get_size_descr(c0, S)
s = symbolic.get_size(S, False)
assert descr1.repr_of_descr() == '<SizeDescr %d>' % s
#
descr2 = get_field_descr(c0, S, 'y')
o, _ = symbolic.get_field_token(S, 'y', False)
assert descr2.repr_of_descr() == '<GcPtrFieldDescr %d>' % o
#
descr2i = get_field_descr(c0, S, 'x')
o, _ = symbolic.get_field_token(S, 'x', False)
assert descr2i.repr_of_descr() == '<CharFieldDescr %d>' % o
#
descr3 = get_array_descr(c0, lltype.GcArray(lltype.Ptr(S)))
assert descr3.repr_of_descr() == '<GcPtrArrayDescr>'
#
descr3i = get_array_descr(c0, lltype.GcArray(lltype.Char))
assert descr3i.repr_of_descr() == '<CharArrayDescr>'
#
cache = {}
descr4 = get_call_descr(c0, [lltype.Char, lltype.Ptr(S)], lltype.Ptr(S))
assert 'GcPtrCallDescr' in descr4.repr_of_descr()
#
descr4i = get_call_descr(c0, [lltype.Char, lltype.Ptr(S)], lltype.Char)
assert 'CharCallDescr' in descr4i.repr_of_descr()
#
descr4f = get_call_descr(c0, [lltype.Char, lltype.Ptr(S)], lltype.Float)
assert 'FloatCallDescr' in descr4f.repr_of_descr()
def __init__(self, rtyper, stats=None, translate_support_code=False,
annmixlevel=None, gcdescr=None):
self.rtyper = rtyper
self.translate_support_code = translate_support_code
self.compiled_functions = []
self.fail_ops = []
self.in_out_args = []
if translate_support_code:
get_size = llmemory.sizeof
else:
get_size = rffi.sizeof
self._arraydescrs = [
ArrayDescr(get_size(llmemory.GCREF), self.SIZE_GCPTR), # 0
ArrayDescr(get_size(lltype.Signed), self.SIZE_INT), # 1
ArrayDescr(get_size(lltype.Char), self.SIZE_CHAR), # 2
ArrayDescr(get_size(lltype.UniChar), self.SIZE_UNICHAR), # 3
]
self._descr_caches = {}
self.fielddescr_vtable = self.fielddescrof(rclass.OBJECT, 'typeptr')
if sys.maxint == 2147483647:
self.size_of_int = 4
else:
self.size_of_int = 8
if runicode.MAXUNICODE > 0xffff:
self.size_of_unicode = 4
else:
self.size_of_unicode = 2
self.gcarray_gcref = lltype.GcArray(llmemory.GCREF)
self.gcarray_signed = lltype.GcArray(lltype.Signed)
self.gcarray_char = lltype.GcArray(lltype.Char)
self.gcarray_unichar = lltype.GcArray(lltype.UniChar)
basesize, _, ofs_length = symbolic.get_array_token(
self.gcarray_signed, self.translate_support_code)
self.array_index_array = basesize
self.array_index_length = ofs_length
basesize, _, ofs_length = symbolic.get_array_token(
rstr.STR, self.translate_support_code)
self.string_index_array = basesize
self.string_index_length = ofs_length
basesize, _, ofs_length = symbolic.get_array_token(
rstr.UNICODE, self.translate_support_code)
self.unicode_index_array = basesize
self.unicode_index_length = ofs_length
self.vtable_descr = self.fielddescrof(rclass.OBJECT, 'typeptr')
self._ovf_error_instance = self._get_prebuilt_error(OverflowError)
self._zer_error_instance = self._get_prebuilt_error(ZeroDivisionError)
#
# temporary (Boehm only)
from pypy.translator.tool.cbuild import ExternalCompilationInfo
compilation_info = ExternalCompilationInfo(libraries=['gc'])
self.malloc_fn_ptr = rffi.llexternal("GC_malloc",
[rffi.SIZE_T],
llmemory.GCREF,
compilation_info=compilation_info,
sandboxsafe=True,
_nowrapper=True)
assert rffi.sizeof(rffi.SIZE_T) == self.size_of_int
def test_array_token():
A = lltype.GcArray(lltype.Char)
basesize, itemsize, ofs_length = get_array_token(A, False)
assert basesize >= WORD # at least the 'length', maybe some gc headers
assert itemsize == 1
assert ofs_length == basesize - WORD
A = lltype.GcArray(lltype.Signed)
basesize, itemsize, ofs_length = get_array_token(A, False)
assert basesize >= WORD # at least the 'length', maybe some gc headers
assert itemsize == WORD
assert ofs_length == basesize - WORD
def test_array_token():
for translate_support_code in (True, False):
A = lltype.GcArray(lltype.Char)
arraytok = get_array_token(A, translate_support_code)
basesize, itemsize, ofs_length = convert(arraytok)
assert basesize >= WORD # at least the 'length', maybe some gc headers
assert itemsize == 1
assert ofs_length == basesize - WORD
A = lltype.GcArray(lltype.Signed)
arraytok = get_array_token(A, translate_support_code)
basesize, itemsize, ofs_length = convert(arraytok)
assert basesize >= WORD # at least the 'length', maybe some gc headers
assert itemsize == WORD
assert ofs_length == basesize - WORD
def define_arraycopy_writebarrier_ptr(cls):
TP = lltype.GcArray(lltype.Ptr(lltype.GcArray(lltype.Signed)))
def fn():
l = lltype.malloc(TP, 100)
for i in range(100):
l[i] = lltype.malloc(TP.OF.TO, i)
l2 = lltype.malloc(TP, 50)
rgc.ll_arraycopy(l, l2, 40, 0, 50)
rgc.collect()
for i in range(50):
assert l2[i] == l[40 + i]
return 0
return fn
def test_is_pure():
from pypy.objspace.flow.model import Variable, Constant
from pypy.rpython import rclass
assert llop.bool_not.is_pure([Variable()])
assert llop.debug_assert.is_pure([Variable()])
assert not llop.int_add_ovf.is_pure([Variable(), Variable()])
#
S1 = lltype.GcStruct('S', ('x', lltype.Signed), ('y', lltype.Signed))
v_s1 = Variable()
v_s1.concretetype = lltype.Ptr(S1)
assert not llop.setfield.is_pure([v_s1, Constant('x'), Variable()])
assert not llop.getfield.is_pure([v_s1, Constant('y')])
#
A1 = lltype.GcArray(lltype.Signed)
v_a1 = Variable()
v_a1.concretetype = lltype.Ptr(A1)
assert not llop.setarrayitem.is_pure([v_a1, Variable(), Variable()])
assert not llop.getarrayitem.is_pure([v_a1, Variable()])
assert llop.getarraysize.is_pure([v_a1])
#
S2 = lltype.GcStruct('S', ('x', lltype.Signed), ('y', lltype.Signed),
hints={'immutable': True})
v_s2 = Variable()
v_s2.concretetype = lltype.Ptr(S2)
assert not llop.setfield.is_pure([v_s2, Constant('x'), Variable()])
assert llop.getfield.is_pure([v_s2, Constant('y')])
#
A2 = lltype.GcArray(lltype.Signed, hints={'immutable': True})
v_a2 = Variable()
v_a2.concretetype = lltype.Ptr(A2)
assert not llop.setarrayitem.is_pure([v_a2, Variable(), Variable()])
assert llop.getarrayitem.is_pure([v_a2, Variable()])
assert llop.getarraysize.is_pure([v_a2])
#
for kind in [
rclass.IR_MUTABLE, rclass.IR_IMMUTABLE, rclass.IR_IMMUTABLE_ARRAY,
rclass.IR_QUASIIMMUTABLE, rclass.IR_QUASIIMMUTABLE_ARRAY
]:
accessor = rclass.FieldListAccessor()
S3 = lltype.GcStruct('S', ('x', lltype.Signed), ('y', lltype.Signed),
hints={'immutable_fields': accessor})
accessor.initialize(S3, {'x': kind})
v_s3 = Variable()
v_s3.concretetype = lltype.Ptr(S3)
assert not llop.setfield.is_pure([v_s3, Constant('x'), Variable()])
assert not llop.setfield.is_pure([v_s3, Constant('y'), Variable()])
assert llop.getfield.is_pure([v_s3, Constant('x')]) is kind
assert not llop.getfield.is_pure([v_s3, Constant('y')])
def test_decode_builtin_call_method():
A = lltype.GcArray(lltype.Signed)
def myfoobar(a, i, marker, c):
assert marker == 'mymarker'
return a[i] * ord(c)
myfoobar.oopspec = 'spam.foobar(a, 2, c, i)'
TYPE = lltype.FuncType([lltype.Ptr(A), lltype.Signed,
lltype.Void, lltype.Char],
lltype.Signed)
fnobj = lltype.functionptr(TYPE, 'foobar', _callable=myfoobar)
vi = Variable('i')
vi.concretetype = lltype.Signed
vc = Variable('c')
vc.concretetype = lltype.Char
v_result = Variable('result')
v_result.concretetype = lltype.Signed
myarray = lltype.malloc(A, 10)
myarray[5] = 42
op = SpaceOperation('direct_call', [newconst(fnobj),
newconst(myarray),
vi,
voidconst('mymarker'),
vc],
v_result)
oopspec, opargs = decode_builtin_call(op)
assert oopspec == 'spam.foobar'
assert opargs == [newconst(myarray), newconst(2), vc, vi]
def test_arrayitems(self):
TP = lltype.GcArray(lltype.Signed)
ofs = symbolic.get_field_token(TP, 'length', False)[0]
itemsofs = symbolic.get_field_token(TP, 'items', False)[0]
descr = self.cpu.arraydescrof(TP)
res = self.execute_operation(rop.NEW_ARRAY, [ConstInt(10)], 'ref',
descr)
resbuf = self._resbuf(res)
assert resbuf[ofs / WORD] == 10
self.execute_operation(rop.SETARRAYITEM_GC,
[res, ConstInt(2), BoxInt(38)], 'void', descr)
assert resbuf[itemsofs / WORD + 2] == 38
self.execute_operation(rop.SETARRAYITEM_GC,
[res, BoxInt(3), BoxInt(42)], 'void', descr)
assert resbuf[itemsofs / WORD + 3] == 42
r = self.execute_operation(rop.GETARRAYITEM_GC, [res, ConstInt(2)],
'int', descr)
assert r.value == 38
r = self.execute_operation(rop.GETARRAYITEM_GC,
[res.constbox(), BoxInt(2)], 'int', descr)
assert r.value == 38
r = self.execute_operation(
rop.GETARRAYITEM_GC, [res.constbox(), ConstInt(2)], 'int', descr)
assert r.value == 38
r = self.execute_operation(rop.GETARRAYITEM_GC, [res, BoxInt(2)],
'int', descr)
assert r.value == 38
r = self.execute_operation(rop.GETARRAYITEM_GC, [res, BoxInt(3)],
'int', descr)
assert r.value == 42
def test_subclass(self):
myjitdriver = JitDriver(greens = [], reds = ['n', 'xy2'],
virtualizables = ['xy2'])
ARRAY = lltype.GcArray(lltype.Signed)
def g(xy2, n):
while n > 0:
myjitdriver.can_enter_jit(xy2=xy2, n=n)
myjitdriver.jit_merge_point(xy2=xy2, n=n)
parent = xy2.parent
promote_virtualizable(parent, 'inst_x')
promote_virtualizable(parent, 'inst_l2')
parent.inst_l2[0] += parent.inst_x
n -= 1
def f(n):
xy2 = self.setup2sub()
xy2.parent.inst_x = 2
xy2.parent.inst_l1 = lltype.malloc(ARRAY, 2)
xy2.parent.inst_l1[0] = 1941309
xy2.parent.inst_l1[1] = 2941309
xy2.parent.inst_l2 = lltype.malloc(ARRAY, 1)
xy2.parent.inst_l2[0] = 10000
m = 10
while m > 0:
g(xy2, n)
m -= 1
return xy2.parent.inst_l2[0]
assert f(18) == 10360
res = self.meta_interp(f, [18])
assert res == 10360
self.check_simple_loop(getfield_gc=0, getarrayitem_gc=0,
setfield_gc=0, setarrayitem_gc=0)
def define_write_typeids_z(self):
U = lltype.GcForwardReference()
U.become(lltype.GcStruct('U', ('next', lltype.Ptr(U)),
('x', lltype.Signed)))
S = lltype.GcStruct('S', ('u', lltype.Ptr(U)))
A = lltype.GcArray(lltype.Ptr(S))
filename = self.filename_dump_typeids_z
open_flags = os.O_WRONLY | os.O_CREAT | getattr(os, 'O_BINARY', 0)
def fn():
s = lltype.malloc(S)
s.u = lltype.malloc(U)
s.u.next = lltype.malloc(U)
s.u.next.next = lltype.malloc(U)
a = lltype.malloc(A, 1000)
s2 = lltype.malloc(S)
#
p = rgc.get_typeids_z()
s = ''.join([p[i] for i in range(len(p))])
fd = os.open(filename, open_flags, 0666)
os.write(fd, s)
os.close(fd)
return 0
return fn
def define_get_rpy_type_index(self):
U = lltype.GcStruct('U', ('x', lltype.Signed))
S = lltype.GcStruct('S', ('u', lltype.Ptr(U)))
A = lltype.GcArray(lltype.Ptr(S))
def fn():
s = lltype.malloc(S)
s.u = lltype.malloc(U)
a = lltype.malloc(A, 1000)
s2 = lltype.malloc(S)
gcref1 = lltype.cast_opaque_ptr(llmemory.GCREF, s)
int1 = rgc.get_rpy_type_index(gcref1)
gcref2 = lltype.cast_opaque_ptr(llmemory.GCREF, s.u)
int2 = rgc.get_rpy_type_index(gcref2)
gcref3 = lltype.cast_opaque_ptr(llmemory.GCREF, a)
int3 = rgc.get_rpy_type_index(gcref3)
gcref4 = lltype.cast_opaque_ptr(llmemory.GCREF, s2)
int4 = rgc.get_rpy_type_index(gcref4)
assert int1 != int2
assert int1 != int3
assert int2 != int3
assert int1 == int4
return 0
return fn
def define_can_move(cls):
TP = lltype.GcArray(lltype.Float)
def func():
return rgc.can_move(lltype.malloc(TP, 1))
return func
def test_keepalive_const_arrayitems():
A1 = lltype.GcArray(lltype.Signed)
a1 = lltype.malloc(A1, 10)
a1[6] = 1234
def fn():
p1 = lltype.direct_arrayitems(a1)
p2 = lltype.direct_ptradd(p1, 6)
return p2[0]
graph, t = get_graph(fn, [])
assert summary(graph) == {
'direct_arrayitems': 1,
'direct_ptradd': 1,
'getarrayitem': 1
}
constant_fold_graph(graph)
# kill all references to 'a1'
a1 = fn = None
del graph.func
import gc
gc.collect()
assert summary(graph) == {'getarrayitem': 1}
check_graph(graph, [], 1234, t)
def test_immutable_to_old_promotion(self):
T_CHILD = lltype.Ptr(lltype.GcStruct('Child', ('field', lltype.Signed)))
T_PARENT = lltype.Ptr(lltype.GcStruct('Parent', ('sub', T_CHILD)))
child = lltype.malloc(T_CHILD.TO)
child2 = lltype.malloc(T_CHILD.TO)
parent = lltype.malloc(T_PARENT.TO)
parent2 = lltype.malloc(T_PARENT.TO)
parent.sub = child
child.field = 3
parent2.sub = child2
child2.field = 8
T_ALL = lltype.Ptr(lltype.GcArray(T_PARENT))
all = lltype.malloc(T_ALL.TO, 2)
all[0] = parent
all[1] = parent2
def f(x, y):
res = all[x]
#all[x] = lltype.nullptr(T_PARENT.TO)
return res.sub.field
run, transformer = self.runner(f, nbargs=2, transformer=True)
run([1, 4])
if not transformer.GCClass.prebuilt_gc_objects_are_static_roots:
assert len(transformer.layoutbuilder.addresses_of_static_ptrs) == 0
else:
assert len(transformer.layoutbuilder.addresses_of_static_ptrs) >= 4
def test_specific_bug(self):
rgenop = self.RGenOp()
FUNC0 = lltype.FuncType([], lltype.Signed)
A = lltype.GcArray(lltype.Signed)
a = lltype.malloc(A, 2, immortal=True)
gv_a = rgenop.genconst(a)
signed_kind = rgenop.kindToken(lltype.Signed)
arraytoken = rgenop.arrayToken(A)
builder0, gv_callable, _ = rgenop.newgraph(rgenop.sigToken(FUNC0),
'generated')
builder0.start_writing()
builder0.genop_setarrayitem(arraytoken, gv_a, rgenop.genconst(0),
rgenop.genconst(1))
builder0.genop_setarrayitem(arraytoken, gv_a, rgenop.genconst(1),
rgenop.genconst(2))
v0 = builder0.genop_getarrayitem(arraytoken, gv_a, rgenop.genconst(0))
v1 = builder0.genop_getarrayitem(arraytoken, gv_a, rgenop.genconst(1))
v2 = builder0.genop2('int_add', v0, v1)
builder1 = builder0.pause_writing([v2])
builder1.start_writing()
args_gv = [v2]
label0 = builder1.enter_next_block([signed_kind], args_gv)
[v3] = args_gv
args_gv = [v3]
label1 = builder1.enter_next_block([signed_kind], args_gv)
[v4] = args_gv
builder1.finish_and_return(rgenop.sigToken(FUNC0), v4)
builder0.end()
def test_access_list_fields(self):
myjitdriver = JitDriver(greens = [], reds = ['n', 'xy2'],
virtualizables = ['xy2'])
ARRAY = lltype.GcArray(lltype.Signed)
def f(n):
xy2 = self.setup2()
xy2.inst_x = 100
xy2.inst_l1 = lltype.malloc(ARRAY, 3)
xy2.inst_l1[0] = -9999999
xy2.inst_l1[1] = -9999999
xy2.inst_l1[2] = 3001
xy2.inst_l2 = lltype.malloc(ARRAY, 2)
xy2.inst_l2[0] = 80
xy2.inst_l2[1] = -9999999
while n > 0:
myjitdriver.can_enter_jit(xy2=xy2, n=n)
myjitdriver.jit_merge_point(xy2=xy2, n=n)
promote_virtualizable(xy2, 'inst_l1')
promote_virtualizable(xy2, 'inst_l2')
xy2.inst_l1[2] += xy2.inst_l2[0]
n -= 1
promote_virtualizable(xy2, 'inst_l1')
return xy2.inst_l1[2]
res = self.meta_interp(f, [16])
assert res == 3001 + 16 * 80
self.check_simple_loop(setarrayitem_gc=0, setfield_gc=0,
getarrayitem_gc=0, getfield_gc=0)
def test_simple_all_removed(self):
myjitdriver = JitDriver(greens = [], reds = ['n'])
#
A = lltype.GcArray(lltype.Signed)
class XY:
pass
class ExCtx:
pass
exctx = ExCtx()
#
@dont_look_inside
def externalfn(n):
return 1
#
def f(n):
while n > 0:
myjitdriver.can_enter_jit(n=n)
myjitdriver.jit_merge_point(n=n)
xy = XY()
xy.next1 = lltype.malloc(A, 0)
xy.next2 = lltype.malloc(A, 0)
xy.next3 = lltype.malloc(A, 0)
exctx.topframeref = virtual_ref(xy)
n -= externalfn(n)
exctx.topframeref = vref_None
xy.next1 = lltype.nullptr(A)
xy.next2 = lltype.nullptr(A)
xy.next3 = lltype.nullptr(A)
virtual_ref_finish(xy)
#
self.meta_interp(f, [15])
self.check_loops(new_with_vtable=0, # all virtualized
new_array=0)
self.check_aborted_count(0)
def test_array_length(self):
myjitdriver = JitDriver(greens = [], reds = ['n', 'xy2'],
virtualizables = ['xy2'])
ARRAY = lltype.GcArray(lltype.Signed)
def g(xy2, n):
while n > 0:
myjitdriver.can_enter_jit(xy2=xy2, n=n)
myjitdriver.jit_merge_point(xy2=xy2, n=n)
promote_virtualizable(xy2, 'inst_l1')
promote_virtualizable(xy2, 'inst_l2')
xy2.inst_l1[1] += len(xy2.inst_l2)
n -= 1
def f(n):
xy2 = self.setup2()
xy2.inst_x = 2
xy2.inst_l1 = lltype.malloc(ARRAY, 2)
xy2.inst_l1[0] = 1941309
xy2.inst_l1[1] = 2941309
xy2.inst_l2 = lltype.malloc(ARRAY, 1)
xy2.inst_l2[0] = 10000
g(xy2, n)
return xy2.inst_l1[1]
res = self.meta_interp(f, [18])
assert res == 2941309 + 18
self.check_simple_loop(setfield_gc=0, getarrayitem_gc=0,
arraylen_gc=0, getfield_gc=0)
def define_get_rpy_memory_usage(self):
U = lltype.GcStruct('U', ('x1', lltype.Signed),
('x2', lltype.Signed),
('x3', lltype.Signed),
('x4', lltype.Signed),
('x5', lltype.Signed),
('x6', lltype.Signed),
('x7', lltype.Signed),
('x8', lltype.Signed))
S = lltype.GcStruct('S', ('u', lltype.Ptr(U)))
A = lltype.GcArray(lltype.Ptr(S))
def fn():
s = lltype.malloc(S)
s.u = lltype.malloc(U)
a = lltype.malloc(A, 1000)
gcref1 = lltype.cast_opaque_ptr(llmemory.GCREF, s)
int1 = rgc.get_rpy_memory_usage(gcref1)
assert 8 <= int1 <= 32
gcref2 = lltype.cast_opaque_ptr(llmemory.GCREF, s.u)
int2 = rgc.get_rpy_memory_usage(gcref2)
assert 4*9 <= int2 <= 8*12
gcref3 = lltype.cast_opaque_ptr(llmemory.GCREF, a)
int3 = rgc.get_rpy_memory_usage(gcref3)
assert 4*1001 <= int3 <= 8*1010
return 0
return fn
def test_residual_function(self):
myjitdriver = JitDriver(greens = [], reds = ['n', 'xy2'],
virtualizables = ['xy2'])
ARRAY = lltype.GcArray(lltype.Signed)
#
@dont_look_inside
def h(xy2):
# this function is marked for residual calls because
# it does something with a virtualizable's array that is not
# just accessing an item
return xy2.inst_l2
#
def g(xy2, n):
while n > 0:
myjitdriver.can_enter_jit(xy2=xy2, n=n)
myjitdriver.jit_merge_point(xy2=xy2, n=n)
promote_virtualizable(xy2, 'inst_l1')
xy2.inst_l1[1] = xy2.inst_l1[1] + len(h(xy2))
n -= 1
def f(n):
xy2 = self.setup2()
xy2.inst_x = 2
xy2.inst_l1 = lltype.malloc(ARRAY, 2)
xy2.inst_l1[0] = 1941309
xy2.inst_l1[1] = 2941309
xy2.inst_l2 = lltype.malloc(ARRAY, 1)
xy2.inst_l2[0] = 10000
g(xy2, n)
return xy2.inst_l1[1]
res = self.meta_interp(f, [18])
assert res == 2941309 + 18
self.check_simple_loop(call=1, setfield_gc=0, getarrayitem_gc=0,
arraylen_gc=1, getfield_gc=0)
def define_dump_rpy_heap(self):
U = lltype.GcForwardReference()
U.become(lltype.GcStruct('U', ('next', lltype.Ptr(U)),
('x', lltype.Signed)))
S = lltype.GcStruct('S', ('u', lltype.Ptr(U)))
A = lltype.GcArray(lltype.Ptr(S))
filename1 = self.filename1_dump
filename2 = self.filename2_dump
def fn():
s = lltype.malloc(S)
s.u = lltype.malloc(U)
s.u.next = lltype.malloc(U)
s.u.next.next = lltype.malloc(U)
a = lltype.malloc(A, 1000)
s2 = lltype.malloc(S)
#
fd1 = os.open(filename1, os.O_WRONLY | os.O_CREAT, 0666)
fd2 = os.open(filename2, os.O_WRONLY | os.O_CREAT, 0666)
rgc.dump_rpy_heap(fd1)
rgc.dump_rpy_heap(fd2) # try twice in a row
keepalive_until_here(s2)
keepalive_until_here(s)
keepalive_until_here(a)
os.close(fd1)
os.close(fd2)
return 0
return fn
def test_framework_varsized(self):
S = lltype.GcStruct("S", ('x', lltype.Signed))
T = lltype.GcStruct("T", ('y', lltype.Signed), ('s', lltype.Ptr(S)))
ARRAY_Ts = lltype.GcArray(lltype.Ptr(T))
def f():
r = 0
for i in range(30):
a = lltype.malloc(ARRAY_Ts, i)
for j in range(i):
a[j] = lltype.malloc(T)
a[j].y = i
a[j].s = lltype.malloc(S)
a[j].s.x = 2 * i
r += a[j].y + a[j].s.x
a[j].s = lltype.malloc(S)
a[j].s.x = 3 * i
r -= a[j].s.x
for j in range(i):
r += a[j].y
return r
fn = self.getcompiled(f)
res = fn()
assert res == f()
def test_unerased_pointers_in_short_preamble(self):
from pypy.rlib.rerased import new_erasing_pair
from pypy.rpython.lltypesystem import lltype
class A(object):
def __init__(self, val):
self.val = val
erase_A, unerase_A = new_erasing_pair('A')
erase_TP, unerase_TP = new_erasing_pair('TP')
TP = lltype.GcArray(lltype.Signed)
myjitdriver = JitDriver(greens=[],
reds=['n', 'm', 'i', 'j', 'sa', 'p'])
def f(n, m, j):
i = sa = 0
p = erase_A(A(7))
while i < n:
myjitdriver.jit_merge_point(n=n, m=m, i=i, j=j, sa=sa, p=p)
if i < m:
sa += unerase_A(p).val
elif i == m:
a = lltype.malloc(TP, 5)
a[0] = 42
p = erase_TP(a)
else:
sa += unerase_TP(p)[0]
sa += A(i).val
assert n > 0 and m > 0
i += j
return sa
res = self.meta_interp(f, [20, 10, 1])
assert res == f(20, 10, 1)
def test_can_move(self):
TP = lltype.GcArray(lltype.Float)
def func():
return rgc.can_move(lltype.malloc(TP, 1))
assert self.interpret(func, []) == self.GC_CAN_MOVE
def test_boehm():
gc_ll_descr = GcLLDescr_boehm(None, None)
#
record = []
prev_funcptr_for_new = gc_ll_descr.funcptr_for_new
def my_funcptr_for_new(size):
p = prev_funcptr_for_new(size)
record.append((size, p))
return p
gc_ll_descr.funcptr_for_new = my_funcptr_for_new
#
# ---------- gc_malloc ----------
S = lltype.GcStruct('S', ('x', lltype.Signed))
sizedescr = get_size_descr(gc_ll_descr, S)
p = gc_ll_descr.gc_malloc(sizedescr)
assert record == [(sizedescr.size, p)]
del record[:]
# ---------- gc_malloc_array ----------
A = lltype.GcArray(lltype.Signed)
arraydescr = get_array_descr(gc_ll_descr, A)
p = gc_ll_descr.gc_malloc_array(arraydescr, 10)
assert record == [(arraydescr.get_base_size(False) +
10 * arraydescr.get_item_size(False), p)]
del record[:]
# ---------- gc_malloc_str ----------
p = gc_ll_descr.gc_malloc_str(10)
basesize, itemsize, ofs_length = symbolic.get_array_token(rstr.STR, False)
assert record == [(basesize + 10 * itemsize, p)]
del record[:]
# ---------- gc_malloc_unicode ----------
p = gc_ll_descr.gc_malloc_unicode(10)
basesize, itemsize, ofs_length = symbolic.get_array_token(rstr.UNICODE,
False)
assert record == [(basesize + 10 * itemsize, p)]
del record[:]
def test_jit_force_virtual_seen(self):
myjitdriver = JitDriver(greens=[], reds=['n'])
#
A = lltype.GcArray(lltype.Signed)
class XY:
pass
class ExCtx:
pass
exctx = ExCtx()
#
def f(n):
while n > 0:
myjitdriver.can_enter_jit(n=n)
myjitdriver.jit_merge_point(n=n)
xy = XY()
xy.n = n
exctx.topframeref = vref = virtual_ref(xy)
xy.next1 = lltype.malloc(A, 0)
n = exctx.topframeref().n - 1
xy.next1 = lltype.nullptr(A)
exctx.topframeref = vref_None
virtual_ref_finish(vref, xy)
return 1
#
res = self.meta_interp(f, [15])
assert res == 1
self.check_resops(
new_with_vtable=4, # vref, xy
new_array=2) # next1
self.check_aborted_count(0)
def test_fakeadr_eq():
S = lltype.GcStruct("S", ("x", lltype.Signed), ("y", lltype.Signed))
s = lltype.malloc(S)
assert cast_ptr_to_adr(s) == cast_ptr_to_adr(s)
adr1 = cast_ptr_to_adr(s) + FieldOffset(S, "x")
adr2 = cast_ptr_to_adr(s) + FieldOffset(S, "y")
adr3 = cast_ptr_to_adr(s) + FieldOffset(S, "y")
assert adr1 != adr2
assert adr2 == adr3
A = lltype.GcArray(lltype.Char)
a = lltype.malloc(A, 5)
adr1 = cast_ptr_to_adr(a) + ArrayLengthOffset(A)
adr2 = cast_ptr_to_adr(a) + ArrayLengthOffset(A)
assert adr1 == adr2
adr1 = cast_ptr_to_adr(a) + ArrayItemsOffset(A)
adr2 = cast_ptr_to_adr(a) + ArrayItemsOffset(A)
assert adr1 == adr2
adr2 += ItemOffset(lltype.Char, 0)
assert adr1 == adr2
adr1 += ItemOffset(lltype.Char, 2)
adr2 += ItemOffset(lltype.Char, 3)
assert adr1 != adr2
adr2 += ItemOffset(lltype.Char, -1)
assert adr1 == adr2
def test_gc_offsets():
STRUCT = lltype.GcStruct('S1', ('x', lltype.Signed), ('y', lltype.Char))
ARRAY = lltype.GcArray(lltype.Signed)
s1 = llarena.round_up_for_allocation(llmemory.sizeof(STRUCT))
s2 = llmemory.offsetof(STRUCT, 'x')
s3 = llmemory.ArrayLengthOffset(ARRAY)
s4 = llmemory.sizeof(ARRAY, 0)
s5 = llmemory.ArrayItemsOffset(ARRAY)
def fn():
return (s1 * 100000000 + s2 * 1000000 + s3 * 10000 + s4 * 100 + s5)
mod, f = compile_test(fn, [], gcpolicy="semispace")
res = f()
i1 = (res // 100000000) % 100
i2 = (res // 1000000) % 100
i3 = (res // 10000) % 100
i4 = (res // 100) % 100
i5 = (res // 1) % 100
assert i1 % 4 == 0
assert 12 <= i1 <= 24
assert 4 <= i2 <= i1 - 8
assert 4 <= i3 <= 12
assert i4 == i5
assert i3 + 4 <= i5
def test_include_write_array():
A = lltype.GcArray(lltype.Signed)
effects = frozenset([("array", lltype.Ptr(A))])
effectinfo = effectinfo_from_writeanalyze(effects, FakeCPU())
assert not effectinfo.readonly_descrs_fields
assert not effectinfo.write_descrs_fields
assert list(effectinfo.write_descrs_arrays) == [('arraydescr', A)]
def test_gc_malloc_array(self):
A = lltype.GcArray(lltype.Signed)
arraydescr = get_array_descr(self.gc_ll_descr, A)
p = self.gc_ll_descr.gc_malloc_array(arraydescr, 10)
assert self.llop1.record == [
("varsize", arraydescr.tid, 10, repr(arraydescr.basesize),
repr(arraydescr.itemsize), repr(arraydescr.lendescr.offset), p)
]
