numba-cuda 0.0.1__py3-none-any.whl → 0.0.13__py3-none-any.whl

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

@@ -0,0 +1,244 @@
+from typing import List
+from dataclasses import dataclass, field
+from numba import cuda, float32
+from numba.cuda.compiler import compile_ptx_for_current_device, compile_ptx
+from math import cos, sin, tan, exp, log, log10, log2, pow, tanh
+from operator import truediv
+import numpy as np
+from numba.cuda.testing import (CUDATestCase, skip_on_cudasim,
+                                skip_unless_cc_75)
+import unittest
+
+
+@dataclass
+class FastMathCriterion:
+    fast_expected: List[str] = field(default_factory=list)
+    fast_unexpected: List[str] = field(default_factory=list)
+    prec_expected: List[str] = field(default_factory=list)
+    prec_unexpected: List[str] = field(default_factory=list)
+
+    def check(self, test: CUDATestCase, fast: str, prec: str):
+        test.assertTrue(all(i in fast for i in self.fast_expected))
+        test.assertTrue(all(i not in fast for i in self.fast_unexpected))
+        test.assertTrue(all(i in prec for i in self.prec_expected))
+        test.assertTrue(all(i not in prec for i in self.prec_unexpected))
+
+
+@skip_on_cudasim('Fastmath and PTX inspection not available on cudasim')
+class TestFastMathOption(CUDATestCase):
+    def _test_fast_math_common(self, pyfunc, sig, device, criterion):
+
+        # Test jit code path
+        fastver = cuda.jit(sig, device=device, fastmath=True)(pyfunc)
+        precver = cuda.jit(sig, device=device)(pyfunc)
+
+        criterion.check(
+            self, fastver.inspect_asm(sig), precver.inspect_asm(sig)
+        )
+
+        # Test compile_ptx code path
+        fastptx, _ = compile_ptx_for_current_device(
+            pyfunc, sig, device=device, fastmath=True
+        )
+        precptx, _ = compile_ptx_for_current_device(
+            pyfunc, sig, device=device
+        )
+
+        criterion.check(self, fastptx, precptx)
+
+    def _test_fast_math_unary(self, op, criterion: FastMathCriterion):
+        def kernel(r, x):
+            r[0] = op(x)
+
+        def device_function(x):
+            return op(x)
+
+        self._test_fast_math_common(
+            kernel, (float32[::1], float32), device=False, criterion=criterion
+        )
+        self._test_fast_math_common(
+            device_function, (float32,), device=True, criterion=criterion
+        )
+
+    def _test_fast_math_binary(self, op, criterion: FastMathCriterion):
+        def kernel(r, x, y):
+            r[0] = op(x, y)
+
+        def device(x, y):
+            return op(x, y)
+
+        self._test_fast_math_common(
+            kernel,
+            (float32[::1], float32, float32), device=False, criterion=criterion
+        )
+        self._test_fast_math_common(
+            device, (float32, float32), device=True, criterion=criterion
+        )
+
+    def test_cosf(self):
+        self._test_fast_math_unary(
+            cos,
+            FastMathCriterion(
+                fast_expected=['cos.approx.ftz.f32 '],
+                prec_unexpected=['cos.approx.ftz.f32 ']
+            )
+        )
+
+    def test_sinf(self):
+        self._test_fast_math_unary(
+            sin,
+            FastMathCriterion(
+                fast_expected=['sin.approx.ftz.f32 '],
+                prec_unexpected=['sin.approx.ftz.f32 ']
+            )
+        )
+
+    def test_tanf(self):
+        self._test_fast_math_unary(
+            tan,
+            FastMathCriterion(fast_expected=[
+                'sin.approx.ftz.f32 ',
+                'cos.approx.ftz.f32 ',
+                'div.approx.ftz.f32 '
+            ], prec_unexpected=['sin.approx.ftz.f32 '])
+        )
+
+    @skip_unless_cc_75
+    def test_tanhf(self):
+
+        self._test_fast_math_unary(
+            tanh,
+            FastMathCriterion(
+                fast_expected=['tanh.approx.f32 '],
+                prec_unexpected=['tanh.approx.f32 ']
+            )
+        )
+
+    def test_tanhf_compile_ptx(self):
+        def tanh_kernel(r, x):
+            r[0] = tanh(x)
+
+        def tanh_common_test(cc, criterion):
+            fastptx, _ = compile_ptx(tanh_kernel, (float32[::1], float32),
+                                     fastmath=True, cc=cc)
+            precptx, _ = compile_ptx(tanh_kernel, (float32[::1], float32),
+                                     cc=cc)
+            criterion.check(self, fastptx, precptx)
+
+        tanh_common_test(cc=(7, 5), criterion=FastMathCriterion(
+            fast_expected=['tanh.approx.f32 '],
+            prec_unexpected=['tanh.approx.f32 ']
+        ))
+
+        tanh_common_test(cc=(7, 0),
+                         criterion=FastMathCriterion(
+            fast_expected=['ex2.approx.ftz.f32 ',
+                           'rcp.approx.ftz.f32 '],
+            prec_unexpected=['tanh.approx.f32 ']))
+
+    def test_expf(self):
+        self._test_fast_math_unary(
+            exp,
+            FastMathCriterion(
+                fast_unexpected=['fma.rn.f32 '],
+                prec_expected=['fma.rn.f32 ']
+            )
+        )
+
+    def test_logf(self):
+        # Look for constant used to convert from log base 2 to log base e
+        self._test_fast_math_unary(
+            log, FastMathCriterion(
+                fast_expected=['lg2.approx.ftz.f32 ', '0f3F317218'],
+                prec_unexpected=['lg2.approx.ftz.f32 '],
+            )
+        )
+
+    def test_log10f(self):
+        # Look for constant used to convert from log base 2 to log base 10
+        self._test_fast_math_unary(
+            log10, FastMathCriterion(
+                fast_expected=['lg2.approx.ftz.f32 ', '0f3E9A209B'],
+                prec_unexpected=['lg2.approx.ftz.f32 ']
+            )
+        )
+
+    def test_log2f(self):
+        self._test_fast_math_unary(
+            log2, FastMathCriterion(
+                fast_expected=['lg2.approx.ftz.f32 '],
+                prec_unexpected=['lg2.approx.ftz.f32 ']
+            )
+        )
+
+    def test_powf(self):
+        self._test_fast_math_binary(
+            pow, FastMathCriterion(
+                fast_expected=['lg2.approx.ftz.f32 '],
+                prec_unexpected=['lg2.approx.ftz.f32 '],
+            )
+        )
+
+    def test_divf(self):
+        self._test_fast_math_binary(
+            truediv, FastMathCriterion(
+                fast_expected=['div.approx.ftz.f32 '],
+                fast_unexpected=['div.rn.f32'],
+                prec_expected=['div.rn.f32'],
+                prec_unexpected=['div.approx.ftz.f32 '],
+            )
+        )
+
+    def test_divf_exception(self):
+        # LTO optimizes away the exception status due to an oversight
+        # in the way we generate it (it is not added to the used list).
+        self.skip_if_lto("Exceptions not supported with LTO")
+
+        def f10(r, x, y):
+            r[0] = x / y
+
+        sig = (float32[::1], float32, float32)
+        fastver = cuda.jit(sig, fastmath=True, debug=True)(f10)
+        precver = cuda.jit(sig, debug=True)(f10)
+        nelem = 10
+        ary = np.empty(nelem, dtype=np.float32)
+        with self.assertRaises(ZeroDivisionError):
+            precver[1, nelem](ary, 10.0, 0.0)
+
+        try:
+            fastver[1, nelem](ary, 10.0, 0.0)
+        except ZeroDivisionError:
+            self.fail("Divide in fastmath should not throw ZeroDivisionError")
+
+    @unittest.expectedFailure
+    def test_device_fastmath_propagation(self):
+        # The fastmath option doesn't presently propagate to device functions
+        # from their callees - arguably it should do, so this test is presently
+        # an xfail.
+        @cuda.jit("float32(float32, float32)", device=True)
+        def foo(a, b):
+            return a / b
+
+        def bar(arr, val):
+            i = cuda.grid(1)
+            if i < arr.size:
+                arr[i] = foo(i, val)
+
+        sig = (float32[::1], float32)
+        fastver = cuda.jit(sig, fastmath=True)(bar)
+        precver = cuda.jit(sig)(bar)
+
+        # Variants of the div instruction are further documented at:
+        # https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-div
+
+        # The fast version should use the "fast, approximate divide" variant
+        self.assertIn('div.approx.f32', fastver.inspect_asm(sig))
+        # The precise version should use the "IEEE 754 compliant rounding"
+        # variant, and neither of the "approximate divide" variants.
+        self.assertIn('div.rn.f32', precver.inspect_asm(sig))
+        self.assertNotIn('div.approx.f32', precver.inspect_asm(sig))
+        self.assertNotIn('div.full.f32', precver.inspect_asm(sig))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,52 @@
+import numpy as np
+
+from numba import cuda
+import unittest
+from numba.cuda.testing import CUDATestCase
+
+
+@cuda.jit
+def foo(x):
+    i = cuda.grid(1)
+    if i < x.size:
+        x[i] += 1
+
+
+class TestForAll(CUDATestCase):
+    def test_forall_1(self):
+        arr = np.arange(11)
+        orig = arr.copy()
+        foo.forall(arr.size)(arr)
+        np.testing.assert_array_almost_equal(arr, orig + 1)
+
+    def test_forall_2(self):
+        @cuda.jit("void(float32, float32[:], float32[:])")
+        def bar(a, x, y):
+            i = cuda.grid(1)
+            if i < x.size:
+                y[i] = a * x[i] + y[i]
+
+        x = np.arange(13, dtype=np.float32)
+        y = np.arange(13, dtype=np.float32)
+        oldy = y.copy()
+        a = 1.234
+        bar.forall(y.size)(a, x, y)
+        np.testing.assert_array_almost_equal(y, a * x + oldy, decimal=3)
+
+    def test_forall_no_work(self):
+        # Ensure that forall doesn't launch a kernel with no blocks when called
+        # with 0 elements. See Issue #5017.
+        arr = np.arange(11)
+        foo.forall(0)(arr)
+
+    def test_forall_negative_work(self):
+        # Ensure that forall doesn't allow the creation of a forall with a
+        # negative element count.
+        with self.assertRaises(ValueError) as raises:
+            foo.forall(-1)
+        self.assertIn("Can't create ForAll with negative task count",
+                      str(raises.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,29 @@
+import numpy as np
+
+from numba import cuda
+from numba.cuda.testing import unittest, CUDATestCase
+
+
+class TestFreeVar(CUDATestCase):
+    def test_freevar(self):
+        """Make sure we can compile the following kernel with freevar reference
+        in arguments to shared.array
+        """
+        from numba import float32
+
+        size = 1024
+        nbtype = float32
+
+        @cuda.jit("(float32[::1], intp)")
+        def foo(A, i):
+            "Dummy function"
+            sdata = cuda.shared.array(size,   # size is freevar
+                                      dtype=nbtype)  # nbtype is freevar
+            A[i] = sdata[i]
+
+        A = np.arange(2, dtype="float32")
+        foo[1, 1](A, 0)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,66 @@
+import numpy as np
+import math
+from numba import cuda
+from numba.types import float32, float64, int32, void
+from numba.cuda.testing import unittest, CUDATestCase
+
+
+def simple_frexp(aryx, aryexp, arg):
+    aryx[0], aryexp[0] = math.frexp(arg)
+
+
+def simple_ldexp(aryx, arg, exp):
+    aryx[0] = math.ldexp(arg, exp)
+
+
+class TestCudaFrexpLdexp(CUDATestCase):
+    def template_test_frexp(self, nptype, nbtype):
+        compiled = cuda.jit(void(nbtype[:], int32[:], nbtype))(simple_frexp)
+        arg = 3.1415
+        aryx = np.zeros(1, dtype=nptype)
+        aryexp = np.zeros(1, dtype=np.int32)
+        compiled[1, 1](aryx, aryexp, arg)
+        np.testing.assert_array_equal(aryx, nptype(0.785375))
+        self.assertEqual(aryexp, 2)
+
+        arg = np.inf
+        compiled[1, 1](aryx, aryexp, arg)
+        np.testing.assert_array_equal(aryx, nptype(np.inf))
+        self.assertEqual(aryexp, 0)  # np.frexp gives -1
+
+        arg = np.nan
+        compiled[1, 1](aryx, aryexp, arg)
+        np.testing.assert_array_equal(aryx, nptype(np.nan))
+        self.assertEqual(aryexp, 0)  # np.frexp gives -1
+
+    def template_test_ldexp(self, nptype, nbtype):
+        compiled = cuda.jit(void(nbtype[:], nbtype, int32))(simple_ldexp)
+        arg = 0.785375
+        exp = 2
+        aryx = np.zeros(1, dtype=nptype)
+        compiled[1, 1](aryx, arg, exp)
+        np.testing.assert_array_equal(aryx, nptype(3.1415))
+
+        arg = np.inf
+        compiled[1, 1](aryx, arg, exp)
+        np.testing.assert_array_equal(aryx, nptype(np.inf))
+
+        arg = np.nan
+        compiled[1, 1](aryx, arg, exp)
+        np.testing.assert_array_equal(aryx, nptype(np.nan))
+
+    def test_frexp_f4(self):
+        self.template_test_frexp(np.float32, float32)
+
+    def test_ldexp_f4(self):
+        self.template_test_ldexp(np.float32, float32)
+
+    def test_frexp_f8(self):
+        self.template_test_frexp(np.float64, float64)
+
+    def test_ldexp_f8(self):
+        self.template_test_ldexp(np.float64, float64)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,60 @@
+import numpy as np
+from numba import cuda, int32, float32
+from numba.cuda.testing import unittest, CUDATestCase
+
+N = 100
+
+
+def simple_smem(ary):
+    sm = cuda.shared.array(N, int32)
+    i = cuda.grid(1)
+    if i == 0:
+        for j in range(N):
+            sm[j] = j
+    cuda.syncthreads()
+    ary[i] = sm[i]
+
+
+S0 = 10
+S1 = 20
+
+
+def coop_smem2d(ary):
+    i, j = cuda.grid(2)
+    sm = cuda.shared.array((S0, S1), float32)
+    sm[i, j] = (i + 1) / (j + 1)
+    cuda.syncthreads()
+    ary[i, j] = sm[i, j]
+
+
+class TestCudaTestGlobal(CUDATestCase):
+    def test_global_int_const(self):
+        """Test simple_smem
+        """
+        compiled = cuda.jit("void(int32[:])")(simple_smem)
+
+        nelem = 100
+        ary = np.empty(nelem, dtype=np.int32)
+        compiled[1, nelem](ary)
+
+        self.assertTrue(np.all(ary == np.arange(nelem, dtype=np.int32)))
+
+    @unittest.SkipTest
+    def test_global_tuple_const(self):
+        """Test coop_smem2d
+        """
+        compiled = cuda.jit("void(float32[:,:])")(coop_smem2d)
+
+        shape = 10, 20
+        ary = np.empty(shape, dtype=np.float32)
+        compiled[1, shape](ary)
+
+        exp = np.empty_like(ary)
+        for i in range(ary.shape[0]):
+            for j in range(ary.shape[1]):
+                exp[i, j] = float(i + 1) / (j + 1)
+        self.assertTrue(np.allclose(ary, exp))
+
+
+if __name__ == '__main__':
+    unittest.main()