From 02a901a0f068a31dbaa3f4d2966197313d444e58 Mon Sep 17 00:00:00 2001 From: Andreas Kloeckner Date: Mon, 19 Apr 2021 10:58:03 -0500 Subject: [PATCH] Drop test_preamble_with_separate_temporaries (we no longer support function manglers) --- test/test_loopy.py | 60 ----------------------- test/testlib.py | 117 --------------------------------------------- 2 files changed, 177 deletions(-) diff --git a/test/test_loopy.py b/test/test_loopy.py index 1e728eefb..1be7ba732 100644 --- a/test/test_loopy.py +++ b/test/test_loopy.py @@ -2520,66 +2520,6 @@ def test_wildcard_dep_matching(): {"insn1", "insn5"}) -def test_preamble_with_separate_temporaries(ctx_factory): - # create a function mangler - - # and finally create a test - n = 5 - # for each entry come up with a random number of data points - num_data = np.asarray(np.random.randint(2, 10, size=n), dtype=np.int32) - # turn into offsets - offsets = np.asarray(np.hstack(([0], np.cumsum(num_data))), dtype=np.int32) - # create lookup data - lookup = np.empty(0) - for i in num_data: - lookup = np.hstack((lookup, np.arange(i))) - lookup = np.asarray(lookup, dtype=np.int32) - # and create data array - data = np.random.rand(np.product(num_data)) - - # make kernel - kernel = lp.make_kernel("{[i]: 0 <= i < n}", - """ - for i - <>ind = indirect(offsets[i], offsets[i + 1], 1) - out[i] = data[ind] - end - """, - [lp.GlobalArg("out", shape=("n",)), - lp.TemporaryVariable( - "offsets", shape=(offsets.size,), initializer=offsets, - address_space=lp.AddressSpace.GLOBAL, - read_only=True), - lp.GlobalArg("data", shape=(data.size,), dtype=np.float64)], - ) - - # fixt params, and add manglers / preamble - from testlib import ( - SeparateTemporariesPreambleTestMangler, - SeparateTemporariesPreambleTestPreambleGenerator, - ) - func_info = dict( - func_name="indirect", - func_arg_dtypes=(np.int32, np.int32, np.int32), - func_result_dtypes=(np.int32,), - arr=lookup - ) - - kernel = lp.fix_parameters(kernel, **{"n": n}) - kernel = lp.register_preamble_generators( - kernel, [SeparateTemporariesPreambleTestPreambleGenerator(**func_info)]) - kernel = lp.register_function_manglers( - kernel, [SeparateTemporariesPreambleTestMangler(**func_info)]) - - print(lp.generate_code(kernel)[0]) - # and call (functionality unimportant, more that it compiles) - ctx = cl.create_some_context() - queue = cl.CommandQueue(ctx) - # check that it actually performs the lookup correctly - assert np.allclose(kernel( - queue, data=data.flatten("C"))[1][0], data[offsets[:-1] + 1]) - - def test_arg_inference_for_predicates(): prog = lp.make_kernel("{[i]: 0 <= i < 10}", """ diff --git a/test/testlib.py b/test/testlib.py index 7009e8f5a..847c7423a 100644 --- a/test/testlib.py +++ b/test/testlib.py @@ -17,123 +17,6 @@ class GridOverride: # }}} -# {{{ test_preamble_with_separate_temporaries - -class SeparateTemporariesPreambleTestDataHolder: - def __init__(self, func_name, func_arg_dtypes, func_result_dtypes, arr): - self.func_name = func_name - self.func_arg_dtypes = func_arg_dtypes - self.func_result_dtypes = func_result_dtypes - self.arr = arr - - def __eq__(self, other): - import numpy as np - return ( - isinstance(other, type(self)) - and self.func_name == other.func_name - and self.func_arg_dtypes == other.func_arg_dtypes - and self.func_result_dtypes == other.func_result_dtypes - and np.array_equal(self.arr, other.arr)) - - def __ne__(self, other): - return not self.__eq__(other) - - -class SeparateTemporariesPreambleTestMangler( - SeparateTemporariesPreambleTestDataHolder): - def __call__(self, kernel, name, arg_dtypes): - """ - A function that will return a :class:`loopy.kernel.data.CallMangleInfo` - to interface with the calling :class:`loopy.LoopKernel` - """ - if name != self.func_name: - return None - - from loopy.types import to_loopy_type - from loopy.kernel.data import CallMangleInfo - - def __compare(d1, d2): - # compare dtypes ignoring atomic - return to_loopy_type(d1, for_atomic=True) == \ - to_loopy_type(d2, for_atomic=True) - - # check types - if len(arg_dtypes) != len(arg_dtypes): - raise Exception("Unexpected number of arguments provided to mangler " - "{}, expected {}, got {}".format( - self.func_name, len(self.func_arg_dtypes), - len(arg_dtypes))) - - for i, (d1, d2) in enumerate(zip(self.func_arg_dtypes, arg_dtypes)): - if not __compare(d1, d2): - raise Exception("Argument at index {} for mangler {} does not " - "match expected dtype. Expected {}, got {}". - format(i, self.func_name, str(d1), str(d2))) - - # get target for creation - target = arg_dtypes[0].target - return CallMangleInfo( - target_name=self.func_name, - result_dtypes=tuple(to_loopy_type(x, target=target) for x in - self.func_result_dtypes), - arg_dtypes=arg_dtypes) - - -class SeparateTemporariesPreambleTestPreambleGenerator( - SeparateTemporariesPreambleTestDataHolder): - def __call__(self, preamble_info): - - # find a function matching our name - func_match = next( - (x for x in preamble_info.seen_functions - if x.name == self.func_name), None) - desc = "custom_funcs_indirect" - if func_match is not None: - from loopy.types import to_loopy_type - # check types - if tuple(to_loopy_type(x) for x in self.func_arg_dtypes) == \ - func_match.arg_dtypes: - # if match, create our temporary - var = lp.TemporaryVariable( - "lookup", initializer=self.arr, dtype=self.arr.dtype, - shape=self.arr.shape, - address_space=lp.AddressSpace.GLOBAL, read_only=True) - # and code - code = """ - int {name}(int start, int end, int match) - {{ - int result = start; - for (int i = start + 1; i < end; ++i) - {{ - if (lookup[i] == match) - result = i; - }} - return result; - }} - """.format(name=self.func_name) - - # generate temporary variable code - from cgen import Initializer - from loopy.target.c import generate_array_literal - codegen_state = preamble_info.codegen_state.copy( - is_generating_device_code=True) - kernel = preamble_info.kernel - ast_builder = codegen_state.ast_builder - target = kernel.target - decl_info, = var.decl_info(target, index_dtype=kernel.index_dtype) - decl = ast_builder.wrap_global_constant( - ast_builder.get_temporary_decl( - codegen_state, None, var, - decl_info)) - if var.initializer is not None: - decl = Initializer(decl, generate_array_literal( - codegen_state, var, var.initializer)) - # return generated code - yield (desc, "\n".join([str(decl), code])) - -# }}} - - # {{{ test_register_function_lookup class Log2Callable(lp.ScalarCallable): -- GitLab