jit/backend/aarch64/test/test_runner.py::TestARM64::()::test_call_release_gil_variable_function_and_arguments
self = <rpython.jit.backend.aarch64.test.test_runner.TestARM64 object at 0x000000098cb19868>
def test_call_release_gil_variable_function_and_arguments(self):
from rpython.translator.tool.cbuild import ExternalCompilationInfo
from rpython.rlib.libffi import types
from rpython.rlib.rarithmetic import r_uint, r_longlong, r_ulonglong
from rpython.rlib.rarithmetic import r_singlefloat
from rpython.translator.c import primitive
def same_as_for_box(b):
if b.type == 'i':
return rop.SAME_AS_I
elif b.type == 'f':
return rop.SAME_AS_F
else:
assert False
cpu = self.cpu
rnd = random.Random(525)
seed = py.test.config.option.randomseed
print("random seed %d" % seed)
ALL_TYPES = [
(types.unsigned, lltype.Unsigned),
(types.signed, lltype.Signed),
(types.uint8, rffi.UCHAR),
(types.sint8, rffi.SIGNEDCHAR),
(types.uint16, rffi.USHORT),
(types.sint16, rffi.SHORT),
(types.uint32, rffi.UINT),
(types.sint32, rffi.INT),
]
if IS_32_BIT and cpu.supports_longlong:
ALL_TYPES += [
(types.uint64, lltype.UnsignedLongLong),
(types.sint64, lltype.SignedLongLong),
] * 2
if cpu.supports_floats:
ALL_TYPES += [
(types.double, rffi.DOUBLE),
] * 4
if cpu.supports_singlefloats:
ALL_TYPES += [
(types.float, rffi.FLOAT),
] * 4
NB_TESTS = 100
c_source = []
all_tests = []
def prepare_c_source():
"""Pick a random choice of argument types and length,
and build a C function with these arguments. The C
function will simply copy them all into static global
variables. There are then additional functions to fetch
them, one per argument, with a signature 'void(ARG *)'.
"""
POSSIBLE_TYPES = [rnd.choice(ALL_TYPES)
for i in range(random.randrange(2, 5))]
load_factor = rnd.random()
keepalive_factor = rnd.random()
#
ffitypes = []
ARGTYPES = []
for i in range(rnd.randrange(4, 20)):
ffitype, TP = rnd.choice(POSSIBLE_TYPES)
ffitypes.append(ffitype)
ARGTYPES.append(TP)
fn_name = 'vartest%d' % k
all_tests.append((ARGTYPES, ffitypes, fn_name))
#
fn_args = []
for i, ARG in enumerate(ARGTYPES):
arg_decl = primitive.cdecl(primitive.PrimitiveType[ARG],
'x%d' % i)
fn_args.append(arg_decl)
var_name = 'argcopy_%s_x%d' % (fn_name, i)
var_decl = primitive.cdecl(primitive.PrimitiveType[ARG],
var_name)
c_source.append('static %s;' % var_decl)
getter_name = '%s_get%d' % (fn_name, i)
c_source.append('RPY_EXPORTED void %s(%s) { *p = %s; }' % (
getter_name,
primitive.cdecl(primitive.PrimitiveType[ARG], '*p'),
var_name))
c_source.append('#include <stdio.h>')
c_source.append('')
c_source.append('static void real%s(%s)' % (
fn_name, ', '.join(fn_args)))
c_source.append('{')
for i in range(len(ARGTYPES)):
if ARGTYPES[i] is lltype.Float:
c_source.append(' fprintf(stderr, "x%d = %%f\\n", x%d);' % (i, i))
elif ARGTYPES[i] is lltype.Signed:
c_source.append(' fprintf(stderr, "x%d = %%ld\\n", x%d);' % (i, i))
elif ARGTYPES[i] is rffi.UINT:
c_source.append(' fprintf(stderr, "x%d = %%u\\n", x%d);' % (i, i))
for i in range(len(ARGTYPES)):
c_source.append(' argcopy_%s_x%d = x%d;' % (fn_name, i, i))
c_source.append('}')
c_source.append('RPY_EXPORTED void *%s(void)' % fn_name)
c_source.append('{')
c_source.append(' return (void *)&real%s;' % fn_name)
c_source.append('}')
c_source.append('')
for k in range(NB_TESTS):
prepare_c_source()
eci = ExternalCompilationInfo(
separate_module_sources=['\n'.join(c_source)])
for k in range(NB_TESTS):
ARGTYPES, ffitypes, fn_name = all_tests[k]
func_getter_ptr = rffi.llexternal(fn_name, [], lltype.Signed,
compilation_info=eci, _nowrapper=True)
load_factor = rnd.random()
keepalive_factor = rnd.random()
#
func_raw = func_getter_ptr()
calldescr = cpu._calldescr_dynamic_for_tests(ffitypes, types.void)
faildescr = BasicFailDescr(1)
#
argboxes = [InputArgInt()] # for the function to call
codes = ['X']
for ffitype in ffitypes:
kind = types.getkind(ffitype)
codes.append(kind)
if kind in 'uis':
b1 = InputArgInt()
elif kind in 'fUI':
b1 = InputArgFloat()
else:
assert 0, kind
argboxes.append(b1)
codes = ''.join(codes) # useful for pdb
print()
print(codes)
#
argvalues = [func_raw]
for TP in ARGTYPES:
r = (rnd.random() - 0.5) * 999999999999.9
r = rffi.cast(TP, r)
argvalues.append(r)
#
argvalues_normal = argvalues[:1]
for ffitype, r in zip(ffitypes, argvalues[1:]):
kind = types.getkind(ffitype)
if kind in 'ui':
r = rffi.cast(lltype.Signed, r)
elif kind in 's':
r, = struct.unpack("i", struct.pack("f", float(r)))
elif kind in 'f':
r = longlong.getfloatstorage(r)
elif kind in 'UI': # 32-bit only
r = rffi.cast(lltype.SignedLongLong, r)
else:
assert 0
argvalues_normal.append(r)
#
ops = []
loadcodes = []
insideboxes = []
for b1 in argboxes:
load = rnd.random() < load_factor
loadcodes.append(' ^'[load])
if load:
b2 = ResOperation(same_as_for_box(b1), [b1])
ops.insert(rnd.randrange(0, len(ops)+1), b2)
b1 = b2
insideboxes.append(b1)
loadcodes = ''.join(loadcodes)
print(loadcodes)
ops += [
ResOperation(rop.CALL_RELEASE_GIL_N,
[ConstInt(0)] + insideboxes,
descr=calldescr),
ResOperation(rop.GUARD_NOT_FORCED, [], descr=faildescr),
ResOperation(rop.FINISH, [], descr=BasicFinalDescr(0))
]
ops[-2].setfailargs([])
# keep alive a random subset of the insideboxes
for b1 in insideboxes:
if rnd.random() < keepalive_factor:
ops.insert(-1, ResOperation(same_as_for_box(b1), [b1]))
looptoken = JitCellToken()
self.cpu.compile_loop(argboxes, ops, looptoken)
#
deadframe = self.cpu.execute_token(looptoken, *argvalues_normal)
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 0
expected = argvalues[1:]
got = []
for i, ARG in enumerate(ARGTYPES):
PARG = rffi.CArrayPtr(ARG)
getter_name = '%s_get%d' % (fn_name, i)
getter_ptr = rffi.llexternal(getter_name, [PARG], lltype.Void,
compilation_info=eci,
_nowrapper=True)
my_arg = lltype.malloc(PARG.TO, 1, zero=True, flavor='raw')
getter_ptr(my_arg)
got.append(my_arg[0])
lltype.free(my_arg, flavor='raw')
different_values = ['x%d: got %r, expected %r' % (i, a, b)
for i, (a, b) in enumerate(zip(got, expected))
if a != b]
assert got == expected, '\n'.join(
> ['bad args, signature %r' % codes[1:]] + different_values)
E AssertionError: bad args, signature 'uuuuuuuuuuuuuuuu'
E x9: got 0L, expected 1296614681L
E x10: got 50457L, expected 18168L
E x11: got 0L, expected 2915928126L
E x12: got 18168L, expected 4071145508L
E x13: got 0L, expected 3799767498L
E x14: got 34878L, expected 45869L
E x15: got 44493L, expected 55192L
jit/backend/test/runner_test.py:3125: AssertionError
---------- Captured stdout call ----------
random seed 2268
Xffffffffffffff
^^^^^^ ^ ^ ^^
Xuuuuu
^
Xfuuuufuu
^ ^ ^ ^^
Xfuufufuffffffffufff
^^^^^^^^^^^^^^^^ ^^^
Xufiii
^ ^^
Xuuuuuuuuuuuuuuuu
^^^^^^^^^^^^^^^^^
---------- Captured stderr call ----------
x0 = 30929122653.162849
x1 = -395497867215.309998
x2 = -62524093260.779312
x3 = -101973126768.347702
x4 = -45341041728.490089
x5 = 473184424185.093994
x6 = 127449029787.966705
x7 = -491300118726.029907
x8 = -13577252726.929310
x9 = 412396223530.263367
x10 = -311667007254.672913
x11 = 179811299166.832031
x12 = 106919162979.735992
x13 = 132755693854.574585
x0 = 903130545
x2 = 2109298301
x3 = 1170444473
x4 = 740884280
x0 = 107810367434.388641
x4 = 4243011841
x5 = 279827692997.644226
x7 = 2054308608
x0 = -253113409267.482513
x1 = 26689741
x2 = 3697082565
x3 = -498182871379.384705
x4 = 1208243857
x5 = 190998332517.451355
x6 = 1058551026
x7 = -161277281141.774841
x8 = 428120198784.631409
x9 = -109485210615.034515
x10 = -428202255718.504517
x11 = 310162262483.630493
x12 = -22988185520.200798
x13 = 154840712187.172272
x14 = 352178453371.731018
x15 = 1695659842
x16 = 128249381911.786530
x17 = -460367571933.266663
x18 = 38464979242.859451
x1 = -198882325888.710785
x0 = 2157614384
x1 = 2648187258
x3 = 244670483
x5 = 444713111
x8 = 2152077888
x9 = 0
x11 = 0
x12 = 18168
x13 = 0
builder: rpython-macos-arm64 build #730*
test: jit/backend/aarch64/test/test_runner.py::TestARM64::()::test_call_release_gil_variable_function_and_arguments