def test_floats(self):
inp = '''
[f0]
f1 = float_add(3.5, f0)
'''
_, loop, oloop = self.reparse(inp)
equaloplists(loop.operations, oloop.operations)
def test_floats(self):
inp = '''
[f0]
f1 = float_add(3.5, f0)
'''
_, loop, oloop = self.reparse(inp)
equaloplists(loop.operations, oloop.operations)
def test_equaloplists_fail_args():
ops = """
[i0]
i1 = int_add(i0, 1)
i2 = int_add(i1, 1)
guard_true(i1) [i2, i1]
jump(i1)
"""
namespace = {}
loop1 = pure_parse(ops, namespace=namespace)
loop2 = pure_parse(ops.replace("[i2, i1]", "[i1, i2]"),
namespace=namespace)
with pytest.raises(AssertionError):
equaloplists(loop1.operations,
loop2.operations,
remap=make_remap(loop1.inputargs, loop2.inputargs))
assert equaloplists(loop1.operations,
loop2.operations,
remap=make_remap(loop1.inputargs, loop2.inputargs),
strict_fail_args=False)
loop3 = pure_parse(ops.replace("[i2, i1]", "[i2, i0]"),
namespace=namespace)
with pytest.raises(AssertionError):
equaloplists(loop1.operations,
loop3.operations,
remap=make_remap(loop1.inputargs, loop3.inputargs))
def compare_short(self, short, expected_short):
expected_short = self.parse(expected_short)
remap = {}
exp = ([ResOperation(rop.LABEL, expected_short.inputargs)] +
expected_short.operations)
for k, v in zip(short[0].getarglist(), expected_short.inputargs):
remap[v] = k
equaloplists(short, exp, remap=remap)
def compare_short(self, short, expected_short):
expected_short = self.parse(expected_short)
remap = {}
exp = ([ResOperation(rop.LABEL, expected_short.inputargs)] +
expected_short.operations)
for k, v in zip(short[0].getarglist(), expected_short.inputargs):
remap[v] = k
equaloplists(short, exp, remap=remap)
def test_floats(self):
inp = '''
[f0]
f1 = float_add(3.5, f0)
'''
_, loop, oloop = self.reparse(inp)
remap = {}
for box1, box2 in zip(loop.inputargs, oloop.inputargs):
assert box1.__class__ == box2.__class__
remap[box2] = box1
equaloplists(loop.operations, oloop.operations, remap=remap)
def test_floats(self):
inp = '''
[f0]
f1 = float_add(3.5, f0)
'''
_, loop, oloop = self.reparse(inp)
remap = {}
for box1, box2 in zip(loop.inputargs, oloop.inputargs):
assert box1.__class__ == box2.__class__
remap[box2] = box1
equaloplists(loop.operations, oloop.operations, remap=remap)
def reparse(self, inp, namespace=None, check_equal=True):
""" parse loop once, then log it and parse again.
Checks that we get the same thing.
"""
if namespace is None:
namespace = {}
loop = pure_parse(inp, namespace=namespace)
logger = Logger(self.make_metainterp_sd())
output = logger.log_loop(loop, namespace)
oloop = pure_parse(output, namespace=namespace)
if check_equal:
equaloplists(loop.operations, oloop.operations)
assert oloop.inputargs == loop.inputargs
return logger, loop, oloop
def reparse(self, inp, namespace=None, check_equal=True):
""" parse loop once, then log it and parse again.
Checks that we get the same thing.
"""
if namespace is None:
namespace = {}
loop = pure_parse(inp, namespace=namespace)
logger = Logger(self.make_metainterp_sd())
output = logger.log_loop(loop, namespace)
oloop = pure_parse(output, namespace=namespace)
if check_equal:
equaloplists(loop.operations, oloop.operations)
assert oloop.inputargs == loop.inputargs
return logger, loop, oloop
def test_remove_consts_and_duplicates():
class FakeStaticData:
cpu = None
all_descrs = []
warmrunnerdesc = None
def is_another_box_like(box, referencebox):
assert box is not referencebox
assert box.type == referencebox.type
assert box.getint() == referencebox.getint()
return True
metainterp = pyjitpl.MetaInterp(FakeStaticData(), None)
metainterp.history = History()
b1 = IntFrontendOp(1)
b1.setint(1)
b2 = IntFrontendOp(2)
b2.setint(2)
c3 = ConstInt(3)
boxes = [b1, b2, b1, c3]
dup = {}
metainterp.history.set_inputargs([b1, b2], FakeStaticData())
metainterp.remove_consts_and_duplicates(boxes, 4, dup)
assert boxes[0] is b1
assert boxes[1] is b2
assert is_another_box_like(boxes[2], b1)
assert is_another_box_like(boxes[3], c3)
inp, operations = metainterp.history.trace.unpack()
remap = dict(zip([b1, b2], inp))
assert equaloplists(operations, [
ResOperation(rop.SAME_AS_I, [b1]),
ResOperation(rop.SAME_AS_I, [c3]),
], remap=remap)
assert dup == {b1: None, b2: None}
def test_remove_consts_and_duplicates():
class FakeStaticData:
cpu = None
all_descrs = []
warmrunnerdesc = None
def is_another_box_like(box, referencebox):
assert box is not referencebox
assert box.type == referencebox.type
assert box.getint() == referencebox.getint()
return True
metainterp = pyjitpl.MetaInterp(FakeStaticData(), None)
metainterp.history = History()
b1 = IntFrontendOp(1)
b1.setint(1)
b2 = IntFrontendOp(2)
b2.setint(2)
c3 = ConstInt(3)
boxes = [b1, b2, b1, c3]
dup = {}
metainterp.history.set_inputargs([b1, b2], FakeStaticData())
metainterp.remove_consts_and_duplicates(boxes, 4, dup)
assert boxes[0] is b1
assert boxes[1] is b2
assert is_another_box_like(boxes[2], b1)
assert is_another_box_like(boxes[3], c3)
inp, operations = metainterp.history.trace.unpack()
remap = dict(zip([b1, b2], inp))
assert equaloplists(operations, [
ResOperation(rop.SAME_AS_I, [b1]),
ResOperation(rop.SAME_AS_I, [c3]),
],
remap=remap)
assert dup == {b1: None, b2: None}
def reparse(self, inp, namespace=None, check_equal=True):
""" parse loop once, then log it and parse again.
Checks that we get the same thing.
"""
if namespace is None:
namespace = {}
loop = pure_parse(inp, namespace=namespace)
logger = Logger(self.make_metainterp_sd())
output = logger.log_loop(loop, namespace)
oloop = pure_parse(output, namespace=namespace)
if check_equal:
remap = {}
for box1, box2 in zip(loop.inputargs, oloop.inputargs):
assert box1.__class__ == box2.__class__
remap[box2] = box1
equaloplists(loop.operations, oloop.operations, remap=remap)
return logger, loop, oloop
def assert_equal(optimized, expected, text_right=None):
assert len(optimized.inputargs) == len(expected.inputargs)
remap = {}
for box1, box2 in zip(optimized.inputargs, expected.inputargs):
assert box1.type == box2.type
remap[box2] = box1
assert equaloplists(optimized.operations, expected.operations, False,
remap, text_right)
def reparse(self, inp, namespace=None, check_equal=True):
""" parse loop once, then log it and parse again.
Checks that we get the same thing.
"""
if namespace is None:
namespace = {}
loop = pure_parse(inp, namespace=namespace)
logger = Logger(self.make_metainterp_sd())
output = logger.log_loop(loop, namespace)
oloop = pure_parse(output, namespace=namespace)
if check_equal:
remap = {}
for box1, box2 in zip(loop.inputargs, oloop.inputargs):
assert box1.__class__ == box2.__class__
remap[box2] = box1
equaloplists(loop.operations, oloop.operations, remap=remap)
return logger, loop, oloop
def assert_equal(self, optimized, expected, text_right=None):
from rpython.jit.metainterp.optimizeopt.util import equaloplists
assert len(optimized.inputargs) == len(expected.inputargs)
remap = {}
for box1, box2 in zip(optimized.inputargs, expected.inputargs):
assert box1.type == box2.type
remap[box2] = box1
assert equaloplists(optimized.operations,
expected.operations, False, remap, text_right)
def assert_equal(optimized, expected, text_right=None):
from rpython.jit.metainterp.optimizeopt.util import equaloplists
assert len(optimized.inputargs) == len(expected.inputargs)
remap = {}
for box1, box2 in zip(optimized.inputargs, expected.inputargs):
assert box1.type == box2.type
remap[box2] = box1
assert equaloplists(optimized.operations, expected.operations, False,
remap, text_right)
def test_equaloplists():
ops = """
[i0]
i1 = int_add(i0, 1)
i2 = int_add(i1, 1)
guard_true(i1) [i2]
jump(i1)
"""
namespace = {}
loop1 = pure_parse(ops, namespace=namespace)
loop2 = pure_parse(ops, namespace=namespace)
loop3 = pure_parse(ops.replace("i2 = int_add", "i2 = int_sub"),
namespace=namespace)
assert equaloplists(loop1.operations,
loop2.operations,
remap=make_remap(loop1.inputargs, loop2.inputargs))
with pytest.raises(AssertionError):
equaloplists(loop1.operations,
loop3.operations,
remap=make_remap(loop1.inputargs, loop3.inputargs))
def test_remove_consts_and_duplicates():
class FakeStaticData:
cpu = None
warmrunnerdesc = None
def is_another_box_like(box, referencebox):
assert box is not referencebox
assert isinstance(box, referencebox.clonebox().__class__)
assert box.value == referencebox.value
return True
metainterp = pyjitpl.MetaInterp(FakeStaticData(), None)
metainterp.history = History()
b1 = BoxInt(1)
b2 = BoxInt(2)
c3 = ConstInt(3)
boxes = [b1, b2, b1, c3]
dup = {}
metainterp.remove_consts_and_duplicates(boxes, 4, dup)
assert boxes[0] is b1
assert boxes[1] is b2
assert is_another_box_like(boxes[2], b1)
assert is_another_box_like(boxes[3], c3)
assert equaloplists(metainterp.history.operations, [
ResOperation(rop.SAME_AS, [b1], boxes[2]),
ResOperation(rop.SAME_AS, [c3], boxes[3]),
])
assert dup == {b1: None, b2: None}
#
del metainterp.history.operations[:]
b4 = BoxInt(4)
boxes = [b2, b4, "something random"]
metainterp.remove_consts_and_duplicates(boxes, 2, dup)
assert is_another_box_like(boxes[0], b2)
assert boxes[1] is b4
assert equaloplists(metainterp.history.operations, [
ResOperation(rop.SAME_AS, [b2], boxes[0]),
])
def test_equaloplists():
ops = """
[i0]
i1 = int_add(i0, 1)
i2 = int_add(i1, 1)
guard_true(i1) [i2]
jump(i1)
"""
namespace = {}
loop1 = pure_parse(ops, namespace=namespace)
loop2 = pure_parse(ops, namespace=namespace)
loop3 = pure_parse(ops.replace("i2 = int_add", "i2 = int_sub"),
namespace=namespace)
assert equaloplists(loop1.operations, loop2.operations)
py.test.raises(AssertionError,
"equaloplists(loop1.operations, loop3.operations)")
def test_equaloplists():
ops = """
[i0]
i1 = int_add(i0, 1)
i2 = int_add(i1, 1)
guard_true(i1) [i2]
jump(i1)
"""
namespace = {}
loop1 = pure_parse(ops, namespace=namespace)
loop2 = pure_parse(ops, namespace=namespace)
loop3 = pure_parse(ops.replace("i2 = int_add", "i2 = int_sub"),
namespace=namespace)
assert equaloplists(loop1.operations, loop2.operations)
py.test.raises(AssertionError,
"equaloplists(loop1.operations, loop3.operations)")
def test_equaloplists_fail_args():
ops = """
[i0]
i1 = int_add(i0, 1)
i2 = int_add(i1, 1)
guard_true(i1) [i2, i1]
jump(i1)
"""
namespace = {}
loop1 = pure_parse(ops, namespace=namespace)
loop2 = pure_parse(ops.replace("[i2, i1]", "[i1, i2]"),
namespace=namespace)
py.test.raises(AssertionError,
"equaloplists(loop1.operations, loop2.operations)")
assert equaloplists(loop1.operations, loop2.operations,
strict_fail_args=False)
loop3 = pure_parse(ops.replace("[i2, i1]", "[i2, i0]"),
namespace=namespace)
py.test.raises(AssertionError,
"equaloplists(loop1.operations, loop3.operations)")
def test_equaloplists_fail_args():
ops = """
[i0]
i1 = int_add(i0, 1)
i2 = int_add(i1, 1)
guard_true(i1) [i2, i1]
jump(i1)
"""
namespace = {}
loop1 = pure_parse(ops, namespace=namespace)
loop2 = pure_parse(ops.replace("[i2, i1]", "[i1, i2]"),
namespace=namespace)
py.test.raises(AssertionError,
"equaloplists(loop1.operations, loop2.operations)")
assert equaloplists(loop1.operations, loop2.operations,
strict_fail_args=False)
loop3 = pure_parse(ops.replace("[i2, i1]", "[i2, i0]"),
namespace=namespace)
py.test.raises(AssertionError,
"equaloplists(loop1.operations, loop3.operations)")
def assert_operations_match(self, loop_a, loop_b):
assert equaloplists(loop_a.operations, loop_b.operations)
def check_rewrite(self, frm_operations, to_operations, **namespace):
# objects to use inside the test
A = lltype.GcArray(lltype.Signed)
adescr = get_array_descr(self.gc_ll_descr, A)
adescr.tid = 4321
alendescr = adescr.lendescr
#
pinned_obj_type = lltype.GcStruct('PINNED_STRUCT', ('my_int', lltype.Signed))
pinned_obj_my_int_descr = get_field_descr(self.gc_ll_descr, pinned_obj_type, 'my_int')
pinned_obj_ptr = lltype.malloc(pinned_obj_type)
pinned_obj_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, pinned_obj_ptr)
assert rgc.pin(pinned_obj_gcref)
#
notpinned_obj_type = lltype.GcStruct('NOT_PINNED_STRUCT', ('my_int', lltype.Signed))
notpinned_obj_my_int_descr = get_field_descr(self.gc_ll_descr, notpinned_obj_type, 'my_int')
notpinned_obj_ptr = lltype.malloc(notpinned_obj_type)
notpinned_obj_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, notpinned_obj_ptr)
#
ptr_array_descr = self.cpu.arraydescrof(MovableObjectTracker.ptr_array_type)
#
vtable_descr = self.gc_ll_descr.fielddescr_vtable
O = lltype.GcStruct('O', ('parent', rclass.OBJECT),
('x', lltype.Signed))
o_vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
#
tiddescr = self.gc_ll_descr.fielddescr_tid
wbdescr = self.gc_ll_descr.write_barrier_descr
WORD = globals()['WORD']
#
strdescr = self.gc_ll_descr.str_descr
unicodedescr = self.gc_ll_descr.unicode_descr
strlendescr = strdescr.lendescr
unicodelendescr = unicodedescr.lendescr
casmdescr = JitCellToken()
clt = FakeLoopToken()
clt._ll_initial_locs = [0, 8]
frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw')
clt.frame_info = frame_info
frame_info.jfi_frame_depth = 13
frame_info.jfi_frame_size = 255
framedescrs = self.gc_ll_descr.getframedescrs(self.cpu)
framelendescr = framedescrs.arraydescr.lendescr
jfi_frame_depth = framedescrs.jfi_frame_depth
jfi_frame_size = framedescrs.jfi_frame_size
jf_frame_info = framedescrs.jf_frame_info
signedframedescr = self.cpu.signedframedescr
floatframedescr = self.cpu.floatframedescr
casmdescr.compiled_loop_token = clt
tzdescr = None # noone cares
#
namespace.update(locals())
#
for funcname in self.gc_ll_descr._generated_functions:
namespace[funcname] = self.gc_ll_descr.get_malloc_fn(funcname)
namespace[funcname + '_descr'] = getattr(self.gc_ll_descr,
'%s_descr' % funcname)
#
ops = parse(frm_operations, namespace=namespace)
operations = self.gc_ll_descr.rewrite_assembler(self.cpu,
ops.operations,
[])
# make the array containing the GCREF's accessible inside the tests.
# This must be done after we call 'rewrite_assembler'. Before that
# call 'last_moving_obj_tracker' is None or filled with some old
# value.
namespace['ptr_array_gcref'] = self.gc_ll_descr.last_moving_obj_tracker.ptr_array_gcref
expected = parse(to_operations % Evaluator(namespace),
namespace=namespace)
equaloplists(operations, expected.operations)
lltype.free(frame_info, flavor='raw')
def check_rewrite(self, frm_operations, to_operations, **namespace):
S = lltype.GcStruct('S', ('x', lltype.Signed),
('y', lltype.Signed))
sdescr = get_size_descr(self.gc_ll_descr, S)
sdescr.tid = 1234
#
T = lltype.GcStruct('T', ('y', lltype.Signed),
('z', lltype.Ptr(S)),
('t', lltype.Signed))
tdescr = get_size_descr(self.gc_ll_descr, T)
tdescr.tid = 5678
tzdescr = get_field_descr(self.gc_ll_descr, T, 'z')
#
A = lltype.GcArray(lltype.Signed)
adescr = get_array_descr(self.gc_ll_descr, A)
adescr.tid = 4321
alendescr = adescr.lendescr
#
B = lltype.GcArray(lltype.Char)
bdescr = get_array_descr(self.gc_ll_descr, B)
bdescr.tid = 8765
blendescr = bdescr.lendescr
#
C = lltype.GcArray(lltype.Ptr(S))
cdescr = get_array_descr(self.gc_ll_descr, C)
cdescr.tid = 8111
clendescr = cdescr.lendescr
#
E = lltype.GcStruct('Empty')
edescr = get_size_descr(self.gc_ll_descr, E)
edescr.tid = 9000
#
vtable_descr = self.gc_ll_descr.fielddescr_vtable
O = lltype.GcStruct('O', ('parent', rclass.OBJECT),
('x', lltype.Signed))
o_descr = self.cpu.sizeof(O, True)
o_vtable = globals()['o_vtable']
#
tiddescr = self.gc_ll_descr.fielddescr_tid
wbdescr = self.gc_ll_descr.write_barrier_descr
WORD = globals()['WORD']
#
strdescr = self.gc_ll_descr.str_descr
unicodedescr = self.gc_ll_descr.unicode_descr
strlendescr = strdescr.lendescr
unicodelendescr = unicodedescr.lendescr
strhashdescr = self.gc_ll_descr.str_hash_descr
unicodehashdescr = self.gc_ll_descr.unicode_hash_descr
casmdescr = JitCellToken()
clt = FakeLoopToken()
clt._ll_initial_locs = [0, 8]
frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw')
clt.frame_info = frame_info
frame_info.jfi_frame_depth = 13
frame_info.jfi_frame_size = 255
framedescrs = self.gc_ll_descr.getframedescrs(self.cpu)
framelendescr = framedescrs.arraydescr.lendescr
jfi_frame_depth = framedescrs.jfi_frame_depth
jfi_frame_size = framedescrs.jfi_frame_size
jf_frame_info = framedescrs.jf_frame_info
jf_savedata = framedescrs.jf_savedata
jf_force_descr = framedescrs.jf_force_descr
jf_descr = framedescrs.jf_descr
jf_guard_exc = framedescrs.jf_guard_exc
jf_forward = framedescrs.jf_forward
jf_extra_stack_depth = framedescrs.jf_extra_stack_depth
signedframedescr = self.cpu.signedframedescr
floatframedescr = self.cpu.floatframedescr
casmdescr.compiled_loop_token = clt
#
guarddescr = AbstractFailDescr()
#
namespace.update(locals())
#
for funcname in self.gc_ll_descr._generated_functions:
namespace[funcname] = self.gc_ll_descr.get_malloc_fn(funcname)
namespace[funcname + '_descr'] = getattr(self.gc_ll_descr,
'%s_descr' % funcname)
#
ops = parse(frm_operations, namespace=namespace)
expected = parse(to_operations % Evaluator(namespace),
namespace=namespace)
operations = self.gc_ll_descr.rewrite_assembler(self.cpu,
ops.operations,
[])
remap = {}
for a, b in zip(ops.inputargs, expected.inputargs):
remap[b] = a
equaloplists(operations, expected.operations, remap=remap)
lltype.free(frame_info, flavor='raw')
def check_rewrite(self, frm_operations, to_operations, **namespace):
S = lltype.GcStruct('S', ('x', lltype.Signed), ('y', lltype.Signed))
sdescr = get_size_descr(self.gc_ll_descr, S)
sdescr.tid = 1234
#
T = lltype.GcStruct('T', ('y', lltype.Signed), ('z', lltype.Ptr(S)),
('t', lltype.Signed))
tdescr = get_size_descr(self.gc_ll_descr, T)
tdescr.tid = 5678
tzdescr = get_field_descr(self.gc_ll_descr, T, 'z')
#
A = lltype.GcArray(lltype.Signed)
adescr = get_array_descr(self.gc_ll_descr, A)
adescr.tid = 4321
alendescr = adescr.lendescr
#
B = lltype.GcArray(lltype.Char)
bdescr = get_array_descr(self.gc_ll_descr, B)
bdescr.tid = 8765
blendescr = bdescr.lendescr
#
C = lltype.GcArray(lltype.Ptr(S))
cdescr = get_array_descr(self.gc_ll_descr, C)
cdescr.tid = 8111
clendescr = cdescr.lendescr
#
E = lltype.GcStruct('Empty')
edescr = get_size_descr(self.gc_ll_descr, E)
edescr.tid = 9000
#
vtable_descr = self.gc_ll_descr.fielddescr_vtable
O = lltype.GcStruct('O', ('parent', rclass.OBJECT),
('x', lltype.Signed))
o_vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
register_known_gctype(self.cpu, o_vtable, O)
#
tiddescr = self.gc_ll_descr.fielddescr_tid
wbdescr = self.gc_ll_descr.write_barrier_descr
WORD = globals()['WORD']
#
strdescr = self.gc_ll_descr.str_descr
unicodedescr = self.gc_ll_descr.unicode_descr
strlendescr = strdescr.lendescr
unicodelendescr = unicodedescr.lendescr
strhashdescr = self.gc_ll_descr.str_hash_descr
unicodehashdescr = self.gc_ll_descr.unicode_hash_descr
casmdescr = JitCellToken()
clt = FakeLoopToken()
clt._ll_initial_locs = [0, 8]
frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw')
clt.frame_info = frame_info
frame_info.jfi_frame_depth = 13
frame_info.jfi_frame_size = 255
framedescrs = self.gc_ll_descr.getframedescrs(self.cpu)
framelendescr = framedescrs.arraydescr.lendescr
jfi_frame_depth = framedescrs.jfi_frame_depth
jfi_frame_size = framedescrs.jfi_frame_size
jf_frame_info = framedescrs.jf_frame_info
jf_savedata = framedescrs.jf_savedata
jf_force_descr = framedescrs.jf_force_descr
jf_descr = framedescrs.jf_descr
jf_guard_exc = framedescrs.jf_guard_exc
jf_forward = framedescrs.jf_forward
jf_extra_stack_depth = framedescrs.jf_extra_stack_depth
signedframedescr = self.cpu.signedframedescr
floatframedescr = self.cpu.floatframedescr
casmdescr.compiled_loop_token = clt
#
guarddescr = AbstractFailDescr()
#
namespace.update(locals())
#
for funcname in self.gc_ll_descr._generated_functions:
namespace[funcname] = self.gc_ll_descr.get_malloc_fn(funcname)
namespace[funcname + '_descr'] = getattr(self.gc_ll_descr,
'%s_descr' % funcname)
#
ops = parse(frm_operations, namespace=namespace)
expected = parse(to_operations % Evaluator(namespace),
namespace=namespace)
operations = self.gc_ll_descr.rewrite_assembler(
self.cpu, ops.operations, [])
equaloplists(operations, expected.operations)
lltype.free(frame_info, flavor='raw')
def check_rewrite(self, frm_operations, to_operations, **namespace):
# objects to use inside the test
A = lltype.GcArray(lltype.Signed)
adescr = get_array_descr(self.gc_ll_descr, A)
adescr.tid = 4321
alendescr = adescr.lendescr
#
pinned_obj_type = lltype.GcStruct('PINNED_STRUCT', ('my_int', lltype.Signed))
pinned_obj_my_int_descr = get_field_descr(self.gc_ll_descr, pinned_obj_type, 'my_int')
pinned_obj_ptr = lltype.malloc(pinned_obj_type)
pinned_obj_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, pinned_obj_ptr)
assert rgc.pin(pinned_obj_gcref)
#
notpinned_obj_type = lltype.GcStruct('NOT_PINNED_STRUCT', ('my_int', lltype.Signed))
notpinned_obj_my_int_descr = get_field_descr(self.gc_ll_descr, notpinned_obj_type, 'my_int')
notpinned_obj_ptr = lltype.malloc(notpinned_obj_type)
notpinned_obj_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, notpinned_obj_ptr)
#
ptr_array_descr = self.cpu.arraydescrof(MovableObjectTracker.ptr_array_type)
#
vtable_descr = self.gc_ll_descr.fielddescr_vtable
O = lltype.GcStruct('O', ('parent', rclass.OBJECT),
('x', lltype.Signed))
o_vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
register_known_gctype(self.cpu, o_vtable, O)
#
tiddescr = self.gc_ll_descr.fielddescr_tid
wbdescr = self.gc_ll_descr.write_barrier_descr
WORD = globals()['WORD']
#
strdescr = self.gc_ll_descr.str_descr
unicodedescr = self.gc_ll_descr.unicode_descr
strlendescr = strdescr.lendescr
unicodelendescr = unicodedescr.lendescr
casmdescr = JitCellToken()
clt = FakeLoopToken()
clt._ll_initial_locs = [0, 8]
frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw')
clt.frame_info = frame_info
frame_info.jfi_frame_depth = 13
frame_info.jfi_frame_size = 255
framedescrs = self.gc_ll_descr.getframedescrs(self.cpu)
framelendescr = framedescrs.arraydescr.lendescr
jfi_frame_depth = framedescrs.jfi_frame_depth
jfi_frame_size = framedescrs.jfi_frame_size
jf_frame_info = framedescrs.jf_frame_info
signedframedescr = self.cpu.signedframedescr
floatframedescr = self.cpu.floatframedescr
casmdescr.compiled_loop_token = clt
tzdescr = None # noone cares
#
namespace.update(locals())
#
for funcname in self.gc_ll_descr._generated_functions:
namespace[funcname] = self.gc_ll_descr.get_malloc_fn(funcname)
namespace[funcname + '_descr'] = getattr(self.gc_ll_descr,
'%s_descr' % funcname)
#
ops = parse(frm_operations, namespace=namespace)
operations = self.gc_ll_descr.rewrite_assembler(self.cpu,
ops.operations,
[])
# make the array containing the GCREF's accessible inside the tests.
# This must be done after we call 'rewrite_assembler'. Before that
# call 'last_moving_obj_tracker' is None or filled with some old
# value.
namespace['ptr_array_gcref'] = self.gc_ll_descr.last_moving_obj_tracker.ptr_array_gcref
expected = parse(to_operations % Evaluator(namespace),
namespace=namespace)
equaloplists(operations, expected.operations)
lltype.free(frame_info, flavor='raw')
def assert_operations_match(self, loop_a, loop_b):
assert equaloplists(loop_a.operations, loop_b.operations)
def check_rewrite(self, frm_operations, to_operations, **namespace):
S = lltype.GcStruct('S', ('x', lltype.Signed),
('y', lltype.Signed))
sdescr = get_size_descr(self.gc_ll_descr, S)
sdescr.tid = 1234
#
T = lltype.GcStruct('T', ('y', lltype.Signed),
('z', lltype.Ptr(S)),
('t', lltype.Signed))
tdescr = get_size_descr(self.gc_ll_descr, T)
tdescr.tid = 5678
tzdescr = get_field_descr(self.gc_ll_descr, T, 'z')
#
A = lltype.GcArray(lltype.Signed)
adescr = get_array_descr(self.gc_ll_descr, A)
adescr.tid = 4321
alendescr = adescr.lendescr
#
B = lltype.GcArray(lltype.Char)
bdescr = get_array_descr(self.gc_ll_descr, B)
bdescr.tid = 8765
blendescr = bdescr.lendescr
#
C = lltype.GcArray(lltype.Ptr(S))
cdescr = get_array_descr(self.gc_ll_descr, C)
cdescr.tid = 8111
clendescr = cdescr.lendescr
#
E = lltype.GcStruct('Empty')
edescr = get_size_descr(self.gc_ll_descr, E)
edescr.tid = 9000
#
vtable_descr = self.gc_ll_descr.fielddescr_vtable
O = lltype.GcStruct('O', ('parent', rclass.OBJECT),
('x', lltype.Signed))
o_vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
register_known_gctype(self.cpu, o_vtable, O)
#
tiddescr = self.gc_ll_descr.fielddescr_tid
wbdescr = self.gc_ll_descr.write_barrier_descr
WORD = globals()['WORD']
#
strdescr = self.gc_ll_descr.str_descr
unicodedescr = self.gc_ll_descr.unicode_descr
strlendescr = strdescr.lendescr
unicodelendescr = unicodedescr.lendescr
casmdescr = JitCellToken()
clt = FakeLoopToken()
clt._ll_initial_locs = [0, 8]
frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw')
clt.frame_info = frame_info
frame_info.jfi_frame_depth = 13
frame_info.jfi_frame_size = 255
framedescrs = self.gc_ll_descr.getframedescrs(self.cpu)
framelendescr = framedescrs.arraydescr.lendescr
jfi_frame_depth = framedescrs.jfi_frame_depth
jfi_frame_size = framedescrs.jfi_frame_size
jf_frame_info = framedescrs.jf_frame_info
signedframedescr = self.cpu.signedframedescr
floatframedescr = self.cpu.floatframedescr
casmdescr.compiled_loop_token = clt
tzdescr = None # noone cares
#
namespace.update(locals())
#
for funcname in self.gc_ll_descr._generated_functions:
namespace[funcname] = self.gc_ll_descr.get_malloc_fn(funcname)
namespace[funcname + '_descr'] = getattr(self.gc_ll_descr,
'%s_descr' % funcname)
#
ops = parse(frm_operations, namespace=namespace)
expected = parse(to_operations % Evaluator(namespace),
namespace=namespace)
operations = self.gc_ll_descr.rewrite_assembler(self.cpu,
ops.operations,
[])
equaloplists(operations, expected.operations)
lltype.free(frame_info, flavor='raw')
