def test_get_split_shape():
# create opts
opts = dummy_loopy_opts(depth=8, order='F')
# create array split
asplit = array_splitter(opts)
def __test(splitter, shape):
arr = np.zeros(shape)
if splitter.data_order == 'F':
grow = 1
split = 0
else:
grow = 0
split = -1
sh, gr, sp = asplit.split_shape(arr)
assert gr == grow
assert sp == split
assert sh == asplit.split_numpy_arrays(arr)[0].shape
# test with small square
__test(asplit, (10, 10))
# now test with evenly sized
__test(asplit, (16, 16))
# finally, try with 3d arrays
__test(asplit, (10, 10, 10))
__test(asplit, (16, 16, 16))
# and finally test with some randomly sized arrays
for i in range(50):
shape = np.random.randint(1, 12, size=np.random.randint(2, 5))
__test(asplit, shape)
# now repeat with C split
# create opts
opts = dummy_loopy_opts(width=8, order='C')
# create array split
asplit = array_splitter(opts)
# test with small square
__test(asplit, (10, 10))
# now test with evenly sized
__test(asplit, (16, 16))
# finally, try with 3d arrays
__test(asplit, (10, 10, 10))
__test(asplit, (16, 16, 16))
# and finally test with some randomly sized arrays
for i in range(50):
shape = np.random.randint(1, 12, size=np.random.randint(2, 5))
__test(asplit, shape)
def test_indexer(opts):
asplit = array_splitter(opts)
def __test(splitter, shape):
# make a dummy array
arr = np.arange(np.prod(shape)).reshape(shape)
index = indexer(splitter, shape)
# split
split_arr = splitter.split_numpy_arrays(arr)[0]
# loop over every index in the array
check_axes = tuple(range(len(shape)))
it = np.nditer(arr, flags=['multi_index'], order=opts.order)
while not it.finished:
# get indicies
check_inds = tuple((x, ) for x in it.multi_index)
new_indicies = index(check_inds, check_axes)
# check that it matches the old array value
assert split_arr[new_indicies] == arr[it.multi_index]
it.iternext()
# test with small square
__test(asplit, (10, 10))
# now test with evenly sized
__test(asplit, (16, 16))
# finally, try with 3d arrays
__test(asplit, (10, 10, 10))
__test(asplit, (16, 16, 16))
def test_lpy_array_splitter_f_deep():
from pymbolic.primitives import Subscript, Variable
# create opts
opts = dummy_loopy_opts(depth=8, order='F')
# create array split
asplit = array_splitter(opts)
k = lp.split_iname(_create('F'), 'i', 8)
k = asplit.split_loopy_arrays(k)
# test that it runs
k()
# check dim
a1 = next(x for x in k.args if x.name == 'a1')
assert a1.shape == (8, 10, 2)
# and indexing
assign = next(insn.assignee for insn in k.instructions if insn.id == 'a1')
assert isinstance(assign,
Subscript) and assign.index == (Variable('i_inner'), 0,
Variable('i_outer'))
# now test with evenly sized
a2 = next(x for x in k.args if x.name == 'a2')
assert a2.shape == (8, 16, 2)
assign = next(insn.assignee for insn in k.instructions if insn.id == 'a2')
assert isinstance(assign,
Subscript) and assign.index == (Variable('i_inner'), 0,
Variable('i_outer'))
def test_lpy_wide_array_splitter(opts):
from pymbolic.primitives import Subscript, Variable
# create array split
asplit = array_splitter(opts)
# create a test kernel
arg1 = lp.GlobalArg('a1', shape=(10, 10), order=opts.order)
arg2 = lp.GlobalArg('a2', shape=(16, 16), order=opts.order)
k = lp.make_kernel([
'{[i]: 0 <= i < 10}', '{{[j_outer]: 0 <= j_outer < {}}}'.format(
int(np.ceil(10 / VECTOR_WIDTH))),
'{{[j_inner]: 0 <= j_inner < {}}}'.format(VECTOR_WIDTH)
],
"""
for i, j_outer, j_inner
a1[j_outer, i] = 1 {id=a1}
a2[j_outer, i] = 1 {id=a2}
end
""", [arg1, arg2],
silenced_warnings=['no_device_in_pre_codegen_checks'],
target=lp.OpenCLTarget())
a1_hold = k.arg_dict['a1'].copy()
a2_hold = k.arg_dict['a2'].copy()
k = asplit.split_loopy_arrays(k)
k = lp.tag_inames(k, {'j_inner': 'l.0' if not opts.is_simd else 'vec'})
# ensure there's no loopy errors
lp.generate_code_v2(k).device_code()
def __indexer():
if opts.order == 'C':
return (Variable('j_outer'), Variable('i'), Variable('j_inner'))
else:
return (Variable('j_inner'), Variable('j_outer'), Variable('i'))
# check dim
a1 = k.arg_dict['a1']
assert a1.shape == asplit.split_shape(a1_hold)[0]
# and indexing
assign = next(insn.assignee for insn in k.instructions if insn.id == 'a1')
# construct index
assert isinstance(assign, Subscript) and assign.index == __indexer()
# now test with evenly sized
a2 = k.arg_dict['a2']
assert a2.shape == asplit.split_shape(a2_hold)[0]
assign = next(insn.assignee for insn in k.instructions if insn.id == 'a2')
assert isinstance(assign, Subscript) and assign.index == __indexer()
def test_lpy_deep_array_splitter(opts):
from pymbolic.primitives import Subscript, Variable
# create array split
asplit = array_splitter(opts)
# create a test kernel
size = VECTOR_WIDTH * 3
loop_bound = VECTOR_WIDTH * 2
arg1 = lp.GlobalArg('a1', shape=(size, size), order=opts.order)
arg2 = lp.GlobalArg('a2', shape=(16, 16), order=opts.order)
k = lp.make_kernel('{{[i]: 0 <= i < {}}}'.format(loop_bound),
"""
a1[0, i] = 1 {id=a1}
a2[0, i] = 1 {id=a2}
""", [arg1, arg2],
silenced_warnings=['no_device_in_pre_codegen_checks'],
target=lp.OpenCLTarget())
k = lp.split_iname(k,
'i',
VECTOR_WIDTH,
inner_tag='l.0' if not opts.is_simd else 'vec')
a1_hold = k.arg_dict['a1'].copy()
a2_hold = k.arg_dict['a2'].copy()
k = asplit.split_loopy_arrays(k)
# ensure there's no loopy errors
lp.generate_code_v2(k).device_code()
def __indexer():
if opts.order == 'C':
return (0, Variable('i_outer'), Variable('i_inner'))
else:
return (Variable('i_inner'), 0, Variable('i_outer'))
# check dim
a1 = k.arg_dict['a1']
assert a1.shape == asplit.split_shape(a1_hold)[0]
# and indexing
assign = next(insn.assignee for insn in k.instructions if insn.id == 'a1')
# construct index
assert isinstance(assign, Subscript) and assign.index == __indexer()
# now test with evenly sized
a2 = k.arg_dict['a2']
assert a2.shape == asplit.split_shape(a2_hold)[0]
assign = next(insn.assignee for insn in k.instructions if insn.id == 'a2')
assert isinstance(assign, Subscript) and assign.index == __indexer()
def test_select_elements(shape, mask, axes, tiling=True):
# create array
arr = np.arange(1, np.prod(shape) + 1).reshape(shape)
for opts in opts_loop(width=[None], depth=[None], simd=False):
asplit = array_splitter(opts)
assert np.array_equal(
select_elements(arr, mask, axes,
tiling=tiling).flatten(order=opts.order),
# despite the name, this can actually be used for both split & non-split
# elements and forms a nice test-case answer here
get_split_elements(arr,
asplit,
arr.shape,
mask,
axes,
tiling=tiling))
def test_npy_array_splitter_f_deep():
# create opts
opts = dummy_loopy_opts(depth=8, order='F')
# create array split
asplit = array_splitter(opts)
def _test(shape):
__internal(asplit, shape, order='F', wide=opts.depth)
# test with small square
_test((10, 10))
# now test with evenly sized
_test((16, 16))
# finally, try with 3d arrays
_test((10, 10, 10))
_test((16, 16, 16))
def test_lpy_iname_presplit(opts):
"""
Tests that inames access to pre-split inames in non-split loopy arrays are
correctly handled
"""
from pymbolic.primitives import Subscript, Variable
# create array split
asplit = array_splitter(opts)
# create a test kernel
arg1 = lp.GlobalArg('a1', shape=(20, 10), order=opts.order)
arg2 = lp.GlobalArg('a2', shape=(16, 16), order=opts.order)
k = lp.make_kernel([
'{[i]: 0 <= i < 10}', '{{[j_outer]: 0 <= j_outer < {}}}'.format(
int(np.ceil(10 / VECTOR_WIDTH))),
'{{[j_inner]: 0 <= j_inner < {}}}'.format(VECTOR_WIDTH)
],
"""
a1[j_outer, i] = 1 {id=a1}
a2[j_outer, i] = 1 {id=a2}
""", [arg1, arg2],
silenced_warnings=['no_device_in_pre_codegen_checks'],
target=lp.OpenCLTarget())
k = asplit.split_loopy_arrays(k, dont_split=['a1', 'a2'])
# ensure there's no loopy errors
lp.generate_code_v2(k).device_code()
def __indexer():
return (Variable('j_outer') * VECTOR_WIDTH + Variable('j_inner'),
Variable('i'))
# check indexing
assign = next(insn.assignee for insn in k.instructions if insn.id == 'a1')
# construct index
assert isinstance(assign, Subscript) and assign.index == __indexer()
# now test with evenly sized
assign = next(insn.assignee for insn in k.instructions if insn.id == 'a2')
assert isinstance(assign, Subscript) and assign.index == __indexer()
def test_npy_array_splitter(opts):
# create array split
asplit = array_splitter(opts)
def _test(shape):
__internal(asplit,
shape,
order=opts.order,
width=opts.width,
depth=opts.depth)
# test with small square
_test((10, 10))
# now test with evenly sized
_test((16, 16))
# finally, try with 3d arrays
_test((10, 10, 10))
_test((16, 16, 16))
def test_get_split_shape(opts):
# create array split
asplit = array_splitter(opts)
def __test(splitter, shape):
# make a dummy array
arr = np.zeros(shape)
# get the split shape
sh, gr, vec, spl = asplit.split_shape(arr)
# first -- test against numpy splitter to ensure we get the right shape
assert sh == asplit.split_numpy_arrays(arr)[0].shape
# next, the "grow" axis is either the first axis ("C") or the second axis
# for "F"
grow = opts.order == 'F'
assert gr == grow
# and the vec_axis is in front if 'F' else in back
vec_axis = len(shape) if opts.order == 'C' else 0
assert vec == vec_axis
# and finally, the split axis
split_axis = 0 if opts.width else len(shape) - 1
assert spl == split_axis
# test with small square
__test(asplit, (10, 10))
# now test with evenly sized
__test(asplit, (16, 16))
# finally, try with 3d arrays
__test(asplit, (10, 10, 10))
__test(asplit, (16, 16, 16))
# and finally test with some randomly sized arrays
for i in range(50):
shape = np.random.randint(1, 12, size=np.random.randint(2, 5))
__test(asplit, shape)
def test_stride_limiter(dtype):
# tests an issue, particularly for the Intel OpenCL runtime where integers in
# array indexing that overflow the int32 max result in segfaults in kernel
# The long term fix is probably to allow the user to specify the dtype via
# command line or platform file, but for now we simply limit the maximum # of
# conditions per run
from pymbolic import parse
arry_name = 'a'
extractor = re.compile(r'{}\[(.+)\] = i'.format(arry_name))
dim_size = 1000000
for opt in loopy_opts():
split = array_splitter(opt)
# create a really big loopy array
ary = lp.GlobalArg(arry_name,
shape=(problem_size.name, dim_size),
dtype=dtype)
# make a dummy kernel with this argument to populate dim tags
knl = lp.make_kernel([
'{{[i]: 0 <= i < {}}}'.format(dim_size),
'{{[j]: 0 <= j < {}}}'.format(problem_size.name)
], '{}[j, i] = i'.format(arry_name), [ary, problem_size])
# split said array
knl = split.split_loopy_arrays(knl)
ary = knl.args[0]
# get limits object
limits = None
with NamedTemporaryFile(suffix='.yaml', mode='w') as temp:
temp.write("""
alloc:
# some huge number such that this isn't the limiting factor
{0}
global:
{0}
""".format(str(np.iinfo(dtype).max * 10),
str(np.iinfo(dtype).max * 10)))
temp.seek(0)
limits = memory_limits.get_limits(
opt, {memory_type.m_global: [ary]},
temp.name,
memory_manager.get_string_strides()[0],
dtype=dtype,
limit_int_overflow=True)
# and feed through stride limiter
limit = limits.integer_limited_problem_size(ary, dtype=dtype)
# get the intruction from the kernel
knl = lp.generate_code_v2(knl).device_code()
# regex the array indexing out
index = extractor.search(knl).group(1)
# sub out 'i', 'j' and 'problem_size'
repl = {
'i': str(dim_size - 1),
'j': str(limit - 1),
'problem_size': str(limit)
}
pattern = re.compile(r'\b(' + '|'.join(repl.keys()) + r')\b')
index = pattern.sub(lambda x: repl[x.group()], index)
index = re.sub('/', '//', index)
max_index = parse(index)
assert isinstance(max_index, (int, float))
assert max_index < np.iinfo(dtype).max
# finally, test that we get the same limit from can_fit
assert limit == limits.can_fit(mtype=memory_type.m_global)
def test_get_comparable_nosplit(ndim, sparse):
axis_size = 10
# create array
arr = np.arange(axis_size**ndim)
arr = arr.reshape((axis_size, ) * ndim)
if sparse:
# set some array elements to zero to sparsify it
choice = np.sort(np.random.choice(axis_size, 3, replace=False))
choice1 = np.sort(np.random.choice(axis_size, 3, replace=False))
for x1 in choice:
for x2 in choice1:
arr[:, x1, x2] = 0
# create comparable object
for i1, (masks, axes, tiling) in enumerate(compare_patterns(arr.shape)):
comparable = get_comparable([masks], [arr],
compare_axis=axes,
tiling=tiling)
namestore = None
for i2, opts in enumerate(opts_loop(sparse=sparse)):
kc = kernel_call('', arr, axes, masks)
outv = arr.copy()
if sparse and opts.jac_format == JacobianFormat.sparse:
if csc_matrix is None:
raise SkipTest(
'Scipy required for sparse Jacobian testing')
# get the appropriate matrix type
matrix = csr_matrix if opts.order == 'C' else csc_matrix
# get the sparse indicies
matrix = matrix(arr[0, :, :])
row, col = (matrix.indptr, matrix.indices) if opts.order == 'C' \
else (matrix.indices, matrix.indptr)
# and get the sparse indicies in flat form
matrix = coo_matrix(arr[0, :, :])
flat_row, flat_col = matrix.row, matrix.col
kc.input_args = {}
kc.input_args['jac'] = arr.copy()
namestore = type(
'', (object, ), {
'jac_row_inds': dummy_init(row),
'jac_col_inds': dummy_init(col),
'flat_jac_row_inds': dummy_init(flat_row),
'flat_jac_col_inds': dummy_init(flat_col)
})
# and finally, sparsify array
outv = sparsify(outv, col, row, opts.order)
asplit = array_splitter(opts)
kc.set_state(asplit,
order=opts.order,
namestore=namestore,
jac_format=opts.jac_format)
outv = asplit.split_numpy_arrays(outv.copy())[0]
outv = comparable(kc, outv, 0, False)
ansv = comparable(kc, kc.transformed_ref_ans[0].copy(), 0, True)
assert np.array_equal(outv, ansv)
def test_get_split_elements(opts):
# create opts
asplit = array_splitter(opts)
def __test(shape, check_inds=None, check_axes=None, tiling=True):
# make a dummy array
arr = np.arange(1, np.prod(shape) + 1).reshape(shape)
# split
split_arr = asplit.split_numpy_arrays(arr)[0]
if check_inds is None:
assert tiling
# create the indicies to check
check_inds = tuple(np.arange(x) for x in shape)
check_axes = tuple(range(len(shape)))
ans = arr.flatten(opts.order)
elif tiling:
assert check_axes is not None
assert check_inds is not None
ans = kernel_call('', arr,
check_axes, [check_inds])._get_comparable(
arr, 0, True).flatten(opts.order)
else:
slicer = [slice(None)] * arr.ndim
assert all(check_inds[0].size == ci.size for ci in check_inds[1:])
for i, ax in enumerate(check_axes):
slicer[ax] = check_inds[i]
ans = arr[tuple(slicer)].flatten(opts.order)
# and compare to the old (unsplit) matrix
assert np.allclose(
get_split_elements(split_arr,
asplit,
arr.shape,
check_inds,
check_axes,
tiling=tiling), ans)
# test with small square
__test((10, 10))
# now test with evenly sized
__test((16, 16))
# finally, try with 3d arrays
__test((10, 10, 10))
# and some non-full check-inds / axes
__test((10, 10, 10), [np.arange(3, 7), np.arange(2, 4)], (0, 1))
__test((10, 10, 10), [np.arange(3, 7), np.arange(2, 4)], (1, 2))
__test((10, 10, 10), [np.arange(3, 7), np.arange(2, 4)], (0, 2))
__test((10, 10, 10), [np.arange(3, 7), np.arange(2, 4)], (0, 1))
__test((16, 16, 16))
__test((16, 16, 16), [np.arange(3, 7), np.arange(2, 4)], (1, 2))
__test((16, 16, 16), [np.arange(3, 7), np.arange(2, 4)], (0, 2))
__test((16, 16, 16), [np.arange(3, 7), np.arange(2, 4)], (0, 1))
# and some non-tiled axes
__test((10, 10, 10),
[np.arange(0, 4), np.arange(3, 7),
np.arange(2, 6)], (0, 1, 2),
tiling=False)
__test((16, 16, 16),
[np.arange(0, 4), np.arange(3, 7),
np.arange(2, 6)], (0, 1, 2),
tiling=False)
__test((16, 16, 16),
[np.arange(0, 4), np.arange(3, 7),
np.arange(2, 6)], (0, 1, 2),
tiling=False)
# try with a really large array
__test((100000, 16, 16),
[np.arange(3, 50000),
np.arange(2, 10),
np.array([7])], (0, 1, 2))
__test((100000, 16, 16),
[np.arange(0, 4), np.arange(3, 7),
np.arange(2, 6)], (0, 1, 2),
tiling=False)
def test_strided_copy(state):
lang = state['lang']
order = state['order']
depth = state['depth']
width = state['width']
# cleanup
clean_dir(build_dir)
clean_dir(obj_dir)
clean_dir(lib_dir)
# create
utils.create_dir(build_dir)
utils.create_dir(obj_dir)
utils.create_dir(lib_dir)
vec_size = depth if depth else (width if width else 0)
# set max per run such that we will have a non-full run (1024 - 1008)
# this should also be evenly divisible by depth and width
# (as should the non full run)
max_per_run = 16
# number of ics should be divisibly by depth and width
ics = max_per_run * 8 + vec_size
if vec_size:
assert ics % vec_size == 0
assert max_per_run % vec_size == 0
assert int(np.floor(ics / max_per_run) * max_per_run) % vec_size == 0
dtype = np.dtype('float64')
# create test arrays
def __create(shape):
if not isinstance(shape, tuple):
shape = (shape, )
shape = (ics, ) + shape
arr = np.zeros(shape, dtype=dtype, order=order)
arr.flat[:] = np.arange(np.prod(shape))
return arr
arrays = [
__create(16),
__create(10),
__create(20),
__create((20, 20)),
__create(())
]
const = [np.arange(10, dtype=dtype)]
lp_arrays = [lp.GlobalArg('a{}'.format(i), shape=('problem_size',) + a.shape[1:],
order=order, dtype=(arrays + const)[i].dtype)
for i, a in enumerate(arrays)] + \
[lp.TemporaryVariable('a{}'.format(i + len(arrays)), dtype=dtype,
order=order, initializer=const[i], read_only=True,
shape=const[i].shape) for i in range(len(const))]
const = lp_arrays[len(arrays):]
dtype = 'double'
# create array splitter
opts = type('', (object, ), {
'width': width,
'depth': depth,
'order': order,
'lang': lang
})
asplit = array_splitter(opts)
# split numpy
arrays = asplit.split_numpy_arrays(arrays)
# make dummy knl
knl = lp.make_kernel(
'{[i]: 0 <= i <= 1}', """
if i > 1
a0[i, i] = 0
a1[i, i] = 0
a2[i, i] = 0
a3[i, i, i] = 0
a4[i] = 0
<> k = a5[i]
end
""", lp_arrays)
# split loopy
lp_arrays = asplit.split_loopy_arrays(knl).args
# now create a simple library
mem = memory_manager(opts.lang,
opts.order,
asplit._have_split(),
dev_type=state['device_type'],
strided_c_copy=lang == 'c')
mem.add_arrays([x for x in lp_arrays],
in_arrays=[x.name for x in lp_arrays if x not in const],
out_arrays=[x.name for x in lp_arrays if x not in const],
host_constants=const)
# create "kernel"
size_type = 'int'
lang_headers = []
if lang == 'opencl':
lang_headers.extend([
'#include "memcpy_2d.oclh"', '#include "vectorization.oclh"',
'#include <CL/cl.h>', '#include "ocl_errorcheck.oclh"'
])
size_type = 'cl_uint'
elif lang == 'c':
lang_headers.extend(
['#include "memcpy_2d.h"', '#include "error_check.h"'])
# kernel must copy in and out, using the mem_manager's format
knl = Template("""
for (size_t offset = 0; offset < problem_size; offset += per_run)
{
${type} this_run = problem_size - offset < per_run ? \
problem_size - offset : per_run;
/* Memory Transfers into the kernel, if any */
${mem_transfers_in}
/* Memory Transfers out */
${mem_transfers_out}
}
""").safe_substitute(type=size_type,
mem_transfers_in=mem._mem_transfers(
to_device=True, host_postfix='_save'),
mem_transfers_out=mem.get_mem_transfers_out(),
problem_size=ics)
# create the host memory allocations
host_names = ['h_' + arr.name for arr in lp_arrays]
host_allocs = mem.get_mem_allocs(True, host_postfix='')
# device memory allocations
device_allocs = mem.get_mem_allocs(False)
# copy to save for test
host_name_saves = ['h_' + a.name + '_save' for a in lp_arrays]
host_const_allocs = mem.get_host_constants()
host_copies = [
Template("""
${type} ${save} [${size}] = {${vals}};
memset(${host}, 0, ${size} * sizeof(${type}));
""").safe_substitute(save='h_' + lp_arrays[i].name + '_save',
host='h_' + lp_arrays[i].name,
size=arrays[i].size,
vals=', '.join(
[str(x) for x in arrays[i].flatten()]),
type=dtype) for i in range(len(arrays))
]
# and finally checks
check_template = Template("""
for(int i = 0; i < ${size}; ++i)
{
assert(${host}[i] == ${save}[i]);
}
""")
checks = [
check_template.safe_substitute(host=host_names[i],
save=host_name_saves[i],
size=arrays[i].size)
for i in range(len(arrays))
]
# and preambles
ocl_preamble = """
double* temp_d;
int* temp_i;
// create a context / queue
int lim = 10;
cl_uint num_platforms;
cl_uint num_devices;
cl_platform_id platform [lim];
cl_device_id device [lim];
cl_int return_code;
cl_context context;
cl_command_queue queue;
check_err(clGetPlatformIDs(lim, platform, &num_platforms));
for (int i = 0; i < num_platforms; ++i)
{
check_err(clGetDeviceIDs(platform[i], CL_DEVICE_TYPE_ALL, lim, device,
&num_devices));
if(num_devices > 0)
break;
}
context = clCreateContext(NULL, 1, &device[0], NULL, NULL, &return_code);
check_err(return_code);
//create queue
queue = clCreateCommandQueue(context, device[0], 0, &return_code);
check_err(return_code);
"""
preamble = ''
if lang == 'opencl':
preamble = ocl_preamble
end = ''
if lang == 'opencl':
end = """
check_err(clFlush(queue));
check_err(clReleaseCommandQueue(queue));
check_err(clReleaseContext(context));
"""
file_src = Template("""
${lang_headers}
#include <stdlib.h>
#include <string.h>
#include <assert.h>
void main()
{
${preamble}
double zero [${max_dim}] = {0};
${size_type} problem_size = ${problem_size};
${size_type} per_run = ${max_per_run};
${host_allocs}
${host_const_allocs}
${mem_declares}
${device_allocs}
${mem_saves}
${host_constant_copy}
${knl}
${checks}
${end}
exit(0);
}
""").safe_substitute(lang_headers='\n'.join(lang_headers),
mem_declares=mem.get_defns(),
host_allocs=host_allocs,
host_const_allocs=host_const_allocs,
device_allocs=device_allocs,
mem_saves='\n'.join(host_copies),
host_constant_copy=mem.get_host_constants_in(),
checks='\n'.join(checks),
knl=knl,
preamble=preamble,
end=end,
size_type=size_type,
max_per_run=max_per_run,
problem_size=ics,
max_dim=max([x.size for x in arrays]))
# write file
fname = os.path.join(build_dir, 'test' + utils.file_ext[lang])
with open(fname, 'w') as file:
file.write(file_src)
files = [fname]
# write aux
write_aux(build_dir, opts, [], [])
# copy any deps
def __copy_deps(lang,
scan_path,
out_path,
change_extension=True,
ffilt=None):
deps = [
x for x in os.listdir(scan_path)
if os.path.isfile(os.path.join(scan_path, x))
and not x.endswith('.in')
]
if ffilt is not None:
deps = [x for x in deps if ffilt in x]
files = []
for dep in deps:
dep_dest = dep
dep_is_header = dep.endswith(utils.header_ext[lang])
ext = (utils.file_ext[lang]
if not dep_is_header else utils.header_ext[lang])
if change_extension and not dep.endswith(ext):
dep_dest = dep[:dep.rfind('.')] + ext
shutil.copyfile(os.path.join(scan_path, dep),
os.path.join(out_path, dep_dest))
if not dep_is_header:
files.append(os.path.join(out_path, dep_dest))
return files
scan = os.path.join(script_dir, os.pardir, 'kernel_utils', lang)
files += __copy_deps(lang, scan, build_dir)
scan = os.path.join(script_dir, os.pardir, 'kernel_utils', 'common')
files += __copy_deps(host_langs[lang],
scan,
build_dir,
change_extension=False,
ffilt='memcpy_2d')
# build
files = [
file_struct(lang, lang, f[:f.rindex('.')], [build_dir], [], build_dir,
obj_dir, True, True) for f in files
]
assert not any(compiler(x) for x in files)
lib = libgen(lang, obj_dir, lib_dir, [x.filename for x in files], True,
False, True)
lib = os.path.join(lib_dir, lib)
# and run
subprocess.check_call(lib)
def test_read_initial_conditions(self):
build_dir = self.store.build_dir
obj_dir = self.store.obj_dir
lib_dir = self.store.lib_dir
setup = test_utils.get_read_ics_source()
utils.create_dir(build_dir)
utils.create_dir(obj_dir)
utils.create_dir(lib_dir)
oploop = OptionLoop(
OrderedDict([
# no need to test conv
('conp', [True]),
('order', ['C', 'F']),
('depth', [4, None]),
('width', [4, None]),
('lang', ['c'])
]))
for state in oploop:
if state['depth'] and state['width']:
continue
self.__cleanup(False)
# create dummy loopy opts
opts = type('', (object, ), state)()
asplit = array_splitter(opts)
# get source
path = os.path.realpath(
os.path.join(self.store.script_dir, os.pardir, 'kernel_utils',
'common', 'read_initial_conditions.c.in'))
with open(path, 'r') as file:
ric = Template(file.read())
# subs
ric = ric.safe_substitute(mechanism='mechanism.h',
vectorization='vectorization.h')
# write
with open(os.path.join(build_dir, 'read_initial_conditions.c'),
'w') as file:
file.write(ric)
# write header
write_aux(build_dir, opts, self.store.specs, self.store.reacs)
# write setup
with open(os.path.join(build_dir, 'setup.py'), 'w') as file:
file.write(setup.safe_substitute(buildpath=build_dir))
# copy read ics header to final dest
shutil.copyfile(
os.path.join(self.store.script_dir, os.pardir, 'kernel_utils',
'common', 'read_initial_conditions.h'),
os.path.join(build_dir, 'read_initial_conditions.h'))
# copy wrapper
shutil.copyfile(
os.path.join(self.store.script_dir, 'test_utils',
'read_ic_wrapper.pyx'),
os.path.join(build_dir, 'read_ic_wrapper.pyx'))
# setup
python_str = 'python{}.{}'.format(sys.version_info[0],
sys.version_info[1])
call = [
python_str,
os.path.join(build_dir, 'setup.py'), 'build_ext',
'--build-lib', lib_dir
]
subprocess.check_call(call)
# copy in tester
shutil.copyfile(
os.path.join(self.store.script_dir, 'test_utils',
'ric_tester.py'),
os.path.join(lib_dir, 'ric_tester.py'))
# For simplicity (and really, lack of need) we test CONP only
# hence, the extra variable is the volume, while the fixed parameter
# is the pressure
# save phi, param in correct order
phi = (self.store.phi_cp if opts.conp else self.store.phi_cv)
save_phi, = asplit.split_numpy_arrays(phi)
save_phi = save_phi.flatten(opts.order)
param = self.store.P if opts.conp else self.store.V
save_phi.tofile(os.path.join(lib_dir, 'phi_test.npy'))
param.tofile(os.path.join(lib_dir, 'param_test.npy'))
# save bin file
out_file = np.concatenate(
(
np.reshape(phi[:, 0], (-1, 1)), # temperature
np.reshape(param, (-1, 1)), # param
phi[:, 1:]),
axis=1 # species
)
out_file = out_file.flatten('K')
with open(os.path.join(lib_dir, 'data.bin'), 'wb') as file:
out_file.tofile(file)
# and run
subprocess.check_call([
python_str,
os.path.join(lib_dir, 'ric_tester.py'), opts.order,
str(self.store.test_size)
])
