numba-cuda 0.0.0__py3-none-any.whl → 0.0.12__py3-none-any.whl

numba_cuda/numba/cuda/tests/cudapy/__init__.py

@@ -0,0 +1,8 @@
+from numba.cuda.testing import ensure_supported_ccs_initialized
+from numba.cuda.tests import load_testsuite
+import os
+
+
+def load_tests(loader, tests, pattern):
+    ensure_supported_ccs_initialized()
+    return load_testsuite(loader, os.path.dirname(__file__))

numba_cuda/numba/cuda/tests/cudapy/cache_usecases.py

@@ -0,0 +1,234 @@
+from numba import cuda
+from numba.cuda.testing import CUDATestCase
+import numpy as np
+import sys
+
+
+class UseCase:
+    """
+    Provide a way to call a kernel as if it were a function.
+
+    This allows the CUDA cache tests to closely match the CPU cache tests, and
+    also to support calling cache use cases as njitted functions. The class
+    wraps a function that takes an array for the return value and arguments,
+    and provides an interface that accepts arguments, launches the kernel
+    appropriately, and returns the stored return value.
+
+    The return type is inferred from the type of the first argument, unless it
+    is explicitly overridden by the ``retty`` kwarg.
+    """
+    def __init__(self, func, retty=None):
+        self._func = func
+        self._retty = retty
+
+    def __call__(self, *args):
+        array_args = [np.asarray(arg) for arg in args]
+        if self._retty:
+            array_return = np.ndarray((), dtype=self._retty)
+        else:
+            array_return = np.zeros_like(array_args[0])
+
+        self._call(array_return, *array_args)
+        return array_return[()]
+
+    @property
+    def func(self):
+        return self._func
+
+
+class CUDAUseCase(UseCase):
+    def _call(self, ret, *args):
+        self._func[1, 1](ret, *args)
+
+
+@cuda.jit(cache=True)
+def add_usecase_kernel(r, x, y):
+    r[()] = x[()] + y[()] + Z
+
+
+@cuda.jit(cache=False)
+def add_nocache_usecase_kernel(r, x, y):
+    r[()] = x[()] + y[()] + Z
+
+
+add_usecase = CUDAUseCase(add_usecase_kernel)
+add_nocache_usecase = CUDAUseCase(add_nocache_usecase_kernel)
+
+Z = 1
+
+
+# Inner / outer cached / uncached cases
+
+@cuda.jit(cache=True)
+def inner(x, y):
+    return x + y + Z
+
+
+@cuda.jit(cache=True)
+def outer_kernel(r, x, y):
+    r[()] = inner(-y[()], x[()])
+
+
+@cuda.jit(cache=False)
+def outer_uncached_kernel(r, x, y):
+    r[()] = inner(-y[()], x[()])
+
+
+outer = CUDAUseCase(outer_kernel)
+outer_uncached = CUDAUseCase(outer_uncached_kernel)
+
+
+# Exercise returning a record instance.  This used to hardcode the dtype
+# pointer's value in the bitcode.
+
+packed_record_type = np.dtype([('a', np.int8), ('b', np.float64)])
+aligned_record_type = np.dtype([('a', np.int8), ('b', np.float64)], align=True)
+
+packed_arr = np.empty(2, dtype=packed_record_type)
+for i in range(packed_arr.size):
+    packed_arr[i]['a'] = i + 1
+    packed_arr[i]['b'] = i + 42.5
+
+aligned_arr = np.array(packed_arr, dtype=aligned_record_type)
+
+
+@cuda.jit(cache=True)
+def record_return(r, ary, i):
+    r[()] = ary[i]
+
+
+record_return_packed = CUDAUseCase(record_return, retty=packed_record_type)
+record_return_aligned = CUDAUseCase(record_return, retty=aligned_record_type)
+
+
+# Closure test cases
+
+def make_closure(x):
+    @cuda.jit(cache=True)
+    def closure(r, y):
+        r[()] = x + y[()]
+
+    return CUDAUseCase(closure)
+
+
+closure1 = make_closure(3)
+closure2 = make_closure(5)
+closure3 = make_closure(7)
+closure4 = make_closure(9)
+
+
+# Ambiguous / renamed functions
+
+@cuda.jit(cache=True)
+def ambiguous_function(r, x):
+    r[()] = x[()] + 2
+
+
+renamed_function1 = CUDAUseCase(ambiguous_function)
+
+
+@cuda.jit(cache=True)
+def ambiguous_function(r, x):
+    r[()] = x[()] + 6
+
+
+renamed_function2 = CUDAUseCase(ambiguous_function)
+
+
+@cuda.jit(cache=True)
+def many_locals():
+    aa = cuda.local.array((1, 1), np.float64)
+    ab = cuda.local.array((1, 1), np.float64)
+    ac = cuda.local.array((1, 1), np.float64)
+    ad = cuda.local.array((1, 1), np.float64)
+    ae = cuda.local.array((1, 1), np.float64)
+    af = cuda.local.array((1, 1), np.float64)
+    ag = cuda.local.array((1, 1), np.float64)
+    ah = cuda.local.array((1, 1), np.float64)
+    ai = cuda.local.array((1, 1), np.float64)
+    aj = cuda.local.array((1, 1), np.float64)
+    ak = cuda.local.array((1, 1), np.float64)
+    al = cuda.local.array((1, 1), np.float64)
+    am = cuda.local.array((1, 1), np.float64)
+    an = cuda.local.array((1, 1), np.float64)
+    ao = cuda.local.array((1, 1), np.float64)
+    ap = cuda.local.array((1, 1), np.float64)
+    ar = cuda.local.array((1, 1), np.float64)
+    at = cuda.local.array((1, 1), np.float64)
+    au = cuda.local.array((1, 1), np.float64)
+    av = cuda.local.array((1, 1), np.float64)
+    aw = cuda.local.array((1, 1), np.float64)
+    ax = cuda.local.array((1, 1), np.float64)
+    ay = cuda.local.array((1, 1), np.float64)
+    az = cuda.local.array((1, 1), np.float64)
+
+    aa[:] = 0
+    ab[:] = 0
+    ac[:] = 0
+    ad[:] = 0
+    ae[:] = 0
+    af[:] = 0
+    ag[:] = 0
+    ah[:] = 0
+    ai[:] = 0
+    aj[:] = 0
+    ak[:] = 0
+    al[:] = 0
+    am[:] = 0
+    an[:] = 0
+    ao[:] = 0
+    ap[:] = 0
+    ar[:] = 0
+    at[:] = 0
+    au[:] = 0
+    av[:] = 0
+    aw[:] = 0
+    ax[:] = 0
+    ay[:] = 0
+    az[:] = 0
+
+
+# Simple use case for multiprocessing test
+
+@cuda.jit(cache=True)
+def simple_usecase_kernel(r, x):
+    r[()] = x[()]
+
+
+simple_usecase_caller = CUDAUseCase(simple_usecase_kernel)
+
+
+# Usecase with cooperative groups
+
+@cuda.jit(cache=True)
+def cg_usecase_kernel(r, x):
+    grid = cuda.cg.this_grid()
+    grid.sync()
+
+
+cg_usecase = CUDAUseCase(cg_usecase_kernel)
+
+
+class _TestModule(CUDATestCase):
+    """
+    Tests for functionality of this module's functions.
+    Note this does not define any "test_*" method, instead check_module()
+    should be called by hand.
+    """
+
+    def check_module(self, mod):
+        self.assertPreciseEqual(mod.add_usecase(2, 3), 6)
+        self.assertPreciseEqual(mod.outer_uncached(3, 2), 2)
+        self.assertPreciseEqual(mod.outer(3, 2), 2)
+
+        packed_rec = mod.record_return_packed(mod.packed_arr, 1)
+        self.assertPreciseEqual(tuple(packed_rec), (2, 43.5))
+        aligned_rec = mod.record_return_aligned(mod.aligned_arr, 1)
+        self.assertPreciseEqual(tuple(aligned_rec), (2, 43.5))
+
+        mod.simple_usecase_caller(2)
+
+
+def self_test():
+    mod = sys.modules[__name__]
+    _TestModule().check_module(mod)

numba_cuda/numba/cuda/tests/cudapy/cache_with_cpu_usecases.py

@@ -0,0 +1,41 @@
+import sys
+
+from numba import cuda, njit
+from numba.cuda.testing import CUDATestCase
+from numba.cuda.tests.cudapy.cache_usecases import CUDAUseCase, UseCase
+
+
+class CPUUseCase(UseCase):
+    def _call(self, ret, *args):
+        self._func(ret, *args)
+
+
+# Using the same function as a cached CPU and CUDA-jitted function
+
+def target_shared_assign(r, x):
+    r[()] = x[()]
+
+
+assign_cuda_kernel = cuda.jit(cache=True)(target_shared_assign)
+assign_cuda = CUDAUseCase(assign_cuda_kernel)
+assign_cpu_jitted = njit(cache=True)(target_shared_assign)
+assign_cpu = CPUUseCase(assign_cpu_jitted)
+
+
+class _TestModule(CUDATestCase):
+    """
+    Tests for functionality of this module's functions.
+    Note this does not define any "test_*" method, instead check_module()
+    should be called by hand.
+    """
+
+    def check_module(self, mod):
+        self.assertPreciseEqual(mod.assign_cpu(5), 5)
+        self.assertPreciseEqual(mod.assign_cpu(5.5), 5.5)
+        self.assertPreciseEqual(mod.assign_cuda(5), 5)
+        self.assertPreciseEqual(mod.assign_cuda(5.5), 5.5)
+
+
+def self_test():
+    mod = sys.modules[__name__]
+    _TestModule().check_module(mod)

numba_cuda/numba/cuda/tests/cudapy/extensions_usecases.py

@@ -0,0 +1,58 @@
+from numba import types
+from numba.core import config
+
+
+class TestStruct:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+
+class TestStructModelType(types.Type):
+    def __init__(self):
+        super().__init__(name="TestStructModelType")
+
+
+test_struct_model_type = TestStructModelType()
+
+
+if not config.ENABLE_CUDASIM:
+    from numba import int32
+    from numba.core.extending import (
+        models,
+        register_model,
+        make_attribute_wrapper,
+        typeof_impl,
+        type_callable
+    )
+    from numba.cuda.cudaimpl import lower
+    from numba.core import cgutils
+
+    @typeof_impl.register(TestStruct)
+    def typeof_teststruct(val, c):
+        return test_struct_model_type
+
+    @register_model(TestStructModelType)
+    class TestStructModel(models.StructModel):
+        def __init__(self, dmm, fe_type):
+            members = [("x", int32), ("y", int32)]
+            super().__init__(dmm, fe_type, members)
+
+    make_attribute_wrapper(TestStructModelType, 'x', 'x')
+    make_attribute_wrapper(TestStructModelType, 'y', 'y')
+
+    @type_callable(TestStruct)
+    def type_test_struct(context):
+        def typer(x, y):
+            if isinstance(x, types.Integer) and isinstance(y, types.Integer):
+                return test_struct_model_type
+        return typer
+
+    @lower(TestStruct, types.Integer, types.Integer)
+    def lower_test_type_ctor(context, builder, sig, args):
+        obj = cgutils.create_struct_proxy(
+            test_struct_model_type
+        )(context, builder)
+        obj.x = args[0]
+        obj.y = args[1]
+        return obj._getvalue()

numba_cuda/numba/cuda/tests/cudapy/jitlink.ptx

@@ -0,0 +1,30 @@
+//
+// Generated by NVIDIA NVVM Compiler
+// Compiler built on Tue Apr  1 03:34:02 2014 (1396341242)
+// Cuda compilation tools, release 6.0, V6.0.1
+//
+
+.version 4.0
+.target sm_20
+.address_size 64
+
+
+.visible .func  (.param .b32 func_retval0) bar(
+	.param .b64 bar_param_0,
+	.param .b32 bar_param_1
+)
+{
+	.reg .s32 	%r<4>;
+	.reg .s64 	%rd<2>;
+
+
+	ld.param.u64 	%rd1, [bar_param_0];
+	ld.param.u32 	%r1, [bar_param_1];
+	shl.b32 	%r2, %r1, 1;
+	st.u32 	[%rd1], %r2;
+	mov.u32 	%r3, 0;
+	st.param.b32	[func_retval0+0], %r3;
+	ret;
+}
+
+

numba_cuda/numba/cuda/tests/cudapy/recursion_usecases.py

@@ -0,0 +1,100 @@
+"""
+Usecases of recursive functions in the CUDA target, many derived from
+numba/tests/recursion_usecases.py.
+
+Some functions are compiled at import time, hence a separate module.
+"""
+
+from numba import cuda
+
+
+@cuda.jit("i8(i8)", device=True)
+def fib1(n):
+    if n < 2:
+        return n
+    # Note the second call does not use a named argument, unlike the CPU target
+    # usecase
+    return fib1(n - 1) + fib1(n - 2)
+
+
+def make_fib2():
+    @cuda.jit("i8(i8)", device=True)
+    def fib2(n):
+        if n < 2:
+            return n
+        return fib2(n - 1) + fib2(n - 2)
+
+    return fib2
+
+
+fib2 = make_fib2()
+
+
+@cuda.jit
+def type_change_self(x, y):
+    if x > 1 and y > 0:
+        return x + type_change_self(x - y, y)
+    else:
+        return y
+
+
+# Implicit signature
+@cuda.jit(device=True)
+def fib3(n):
+    if n < 2:
+        return n
+
+    return fib3(n - 1) + fib3(n - 2)
+
+
+# Run-away self recursion
+@cuda.jit(device=True)
+def runaway_self(x):
+    return runaway_self(x)
+
+
+@cuda.jit(device=True)
+def raise_self(x):
+    if x == 1:
+        raise ValueError("raise_self")
+    elif x > 0:
+        return raise_self(x - 1)
+    else:
+        return 1
+
+
+@cuda.jit(debug=True, opt=False)
+def raise_self_kernel(x):
+    raise_self(x)
+
+
+def make_optional_return_case(jit=lambda x: x):
+    @jit
+    def foo(x):
+        if x > 5:
+            return x - 1
+        else:
+            return
+
+    @jit
+    def bar(x):
+        out = foo(x)
+        if out is None:
+            return out
+        elif out < 8:
+            return out
+        else:
+            return x * bar(out)
+
+    return bar
+
+
+def make_growing_tuple_case(jit=lambda x: x):
+    # From issue #4387
+    @jit
+    def make_list(n):
+        if n <= 0:
+            return None
+
+        return (n, make_list(n - 1))
+    return make_list

numba_cuda/numba/cuda/tests/cudapy/test_alignment.py

@@ -0,0 +1,42 @@
+import numpy as np
+from numba import from_dtype, cuda
+from numba.cuda.testing import skip_on_cudasim, CUDATestCase
+import unittest
+
+
+class TestAlignment(CUDATestCase):
+    def test_record_alignment(self):
+        rec_dtype = np.dtype([('a', 'int32'), ('b', 'float64')], align=True)
+        rec = from_dtype(rec_dtype)
+
+        @cuda.jit((rec[:],))
+        def foo(a):
+            i = cuda.grid(1)
+            a[i].a = a[i].b
+
+        a_recarray = np.recarray(3, dtype=rec_dtype)
+        for i in range(a_recarray.size):
+            a_rec = a_recarray[i]
+            a_rec.a = 0
+            a_rec.b = (i + 1) * 123
+
+        foo[1, 3](a_recarray)
+
+        self.assertTrue(np.all(a_recarray.a == a_recarray.b))
+
+    @skip_on_cudasim('Simulator does not check alignment')
+    def test_record_alignment_error(self):
+        rec_dtype = np.dtype([('a', 'int32'), ('b', 'float64')])
+        rec = from_dtype(rec_dtype)
+
+        with self.assertRaises(Exception) as raises:
+            @cuda.jit((rec[:],))
+            def foo(a):
+                i = cuda.grid(1)
+                a[i].a = a[i].b
+
+        self.assertTrue('type float64 is not aligned' in str(raises.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()