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

numba_cuda/numba/cuda/tests/doc_examples/test_montecarlo.py

@@ -0,0 +1,109 @@
+import unittest
+
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
+from numba.tests.support import captured_stdout
+
+
+@skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
+class TestMonteCarlo(CUDATestCase):
+    """
+    Test monte-carlo integration
+    """
+
+    def setUp(self):
+        # Prevent output from this test showing up when running the test suite
+        self._captured_stdout = captured_stdout()
+        self._captured_stdout.__enter__()
+        super().setUp()
+
+    def tearDown(self):
+        # No exception type, value, or traceback
+        self._captured_stdout.__exit__(None, None, None)
+        super().tearDown()
+
+    def test_ex_montecarlo(self):
+        # ex_montecarlo.import.begin
+        import numba
+        import numpy as np
+        from numba import cuda
+        from numba.cuda.random import (
+            create_xoroshiro128p_states,
+            xoroshiro128p_uniform_float32,
+        )
+        # ex_montecarlo.import.end
+
+        # ex_montecarlo.define.begin
+        # number of samples, higher will lead to a more accurate answer
+        nsamps = 1000000
+        # ex_montecarlo.define.end
+
+        # ex_montecarlo.kernel.begin
+        @cuda.jit
+        def mc_integrator_kernel(out, rng_states, lower_lim, upper_lim):
+            """
+            kernel to draw random samples and evaluate the function to
+            be integrated at those sample values
+            """
+            size = len(out)
+
+            gid = cuda.grid(1)
+            if gid < size:
+                # draw a sample between 0 and 1 on this thread
+                samp = xoroshiro128p_uniform_float32(rng_states, gid)
+
+                # normalize this sample to the limit range
+                samp = samp * (upper_lim - lower_lim) + lower_lim
+
+                # evaluate the function to be
+                # integrated at the normalized
+                # value of the sample
+                y = func(samp)
+                out[gid] = y
+        # ex_montecarlo.kernel.end
+
+        # ex_montecarlo.callfunc.begin
+        @cuda.reduce
+        def sum_reduce(a, b):
+            return a + b
+
+        def mc_integrate(lower_lim, upper_lim, nsamps):
+            """
+            approximate the definite integral of `func` from
+            `lower_lim` to `upper_lim`
+            """
+            out = cuda.to_device(np.zeros(nsamps, dtype="float32"))
+            rng_states = create_xoroshiro128p_states(nsamps, seed=42)
+
+            # jit the function for use in CUDA kernels
+
+            mc_integrator_kernel.forall(nsamps)(
+                out, rng_states, lower_lim, upper_lim
+            )
+            # normalization factor to convert
+            # to the average: (b - a)/(N - 1)
+            factor = (upper_lim - lower_lim) / (nsamps - 1)
+
+            return sum_reduce(out) * factor
+        # ex_montecarlo.callfunc.end
+
+        # ex_montecarlo.launch.begin
+        # define a function to integrate
+        @numba.jit
+        def func(x):
+            return 1.0 / x
+
+        mc_integrate(1, 2, nsamps)  # array(0.6929643, dtype=float32)
+        mc_integrate(2, 3, nsamps)  # array(0.4054021, dtype=float32)
+        # ex_montecarlo.launch.end
+
+        # values computed independently using maple
+        np.testing.assert_allclose(
+            mc_integrate(1, 2, nsamps), 0.69315, atol=0.001
+        )
+        np.testing.assert_allclose(
+            mc_integrate(2, 3, nsamps), 0.4055, atol=0.001
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

numba_cuda/numba/cuda/tests/doc_examples/test_random.py

@@ -0,0 +1,59 @@
+# Contents in this file are referenced from the sphinx-generated docs.
+# "magictoken" is used for markers as beginning and ending of example text.
+
+import unittest
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
+
+
+@skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
+class TestRandom(CUDATestCase):
+    def test_ex_3d_grid(self):
+        # magictoken.ex_3d_grid.begin
+        from numba import cuda
+        from numba.cuda.random import (create_xoroshiro128p_states,
+                                       xoroshiro128p_uniform_float32)
+        import numpy as np
+
+        @cuda.jit
+        def random_3d(arr, rng_states):
+            # Per-dimension thread indices and strides
+            startx, starty, startz = cuda.grid(3)
+            stridex, stridey, stridez = cuda.gridsize(3)
+
+            # Linearized thread index
+            tid = (startz * stridey * stridex) + (starty * stridex) + startx
+
+            # Use strided loops over the array to assign a random value to each entry
+            for i in range(startz, arr.shape[0], stridez):
+                for j in range(starty, arr.shape[1], stridey):
+                    for k in range(startx, arr.shape[2], stridex):
+                        arr[i, j, k] = xoroshiro128p_uniform_float32(rng_states, tid)
+
+        # Array dimensions
+        X, Y, Z = 701, 900, 719
+
+        # Block and grid dimensions
+        bx, by, bz = 8, 8, 8
+        gx, gy, gz = 16, 16, 16
+
+        # Total number of threads
+        nthreads = bx * by * bz * gx * gy * gz
+
+        # Initialize a state for each thread
+        rng_states = create_xoroshiro128p_states(nthreads, seed=1)
+
+        # Generate random numbers
+        arr = cuda.device_array((X, Y, Z), dtype=np.float32)
+        random_3d[(gx, gy, gz), (bx, by, bz)](arr, rng_states)
+        # magictoken.ex_3d_grid.end
+
+        # Some basic tests of the randomly-generated numbers
+        host_arr = arr.copy_to_host()
+        self.assertGreater(np.mean(host_arr), 0.49)
+        self.assertLess(np.mean(host_arr), 0.51)
+        self.assertTrue(np.all(host_arr <= 1.0))
+        self.assertTrue(np.all(host_arr >= 0.0))
+
+
+if __name__ == '__main__':
+    unittest.main()

numba_cuda/numba/cuda/tests/doc_examples/test_reduction.py

@@ -0,0 +1,76 @@
+import unittest
+
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
+from numba.tests.support import captured_stdout
+
+
+@skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
+class TestReduction(CUDATestCase):
+    """
+    Test shared memory reduction
+    """
+
+    def setUp(self):
+        # Prevent output from this test showing up when running the test suite
+        self._captured_stdout = captured_stdout()
+        self._captured_stdout.__enter__()
+        super().setUp()
+
+    def tearDown(self):
+        # No exception type, value, or traceback
+        self._captured_stdout.__exit__(None, None, None)
+        super().tearDown()
+
+    def test_ex_reduction(self):
+        # ex_reduction.import.begin
+        import numpy as np
+        from numba import cuda
+        from numba.types import int32
+        # ex_reduction.import.end
+
+        # ex_reduction.allocate.begin
+        # generate data
+        a = cuda.to_device(np.arange(1024))
+        nelem = len(a)
+        # ex_reduction.allocate.end
+
+        # ex_reduction.kernel.begin
+        @cuda.jit
+        def array_sum(data):
+            tid = cuda.threadIdx.x
+            size = len(data)
+            if tid < size:
+                i = cuda.grid(1)
+
+                # Declare an array in shared memory
+                shr = cuda.shared.array(nelem, int32)
+                shr[tid] = data[i]
+
+                # Ensure writes to shared memory are visible
+                # to all threads before reducing
+                cuda.syncthreads()
+
+                s = 1
+                while s < cuda.blockDim.x:
+                    if tid % (2 * s) == 0:
+                        # Stride by `s` and add
+                        shr[tid] += shr[tid + s]
+                    s *= 2
+                    cuda.syncthreads()
+
+                # After the loop, the zeroth  element contains the sum
+                if tid == 0:
+                    data[tid] = shr[tid]
+        # ex_reduction.kernel.end
+
+        # ex_reduction.launch.begin
+        array_sum[1, nelem](a)
+        print(a[0])                  # 523776
+        print(sum(np.arange(1024)))  # 523776
+        # ex_reduction.launch.end
+
+        np.testing.assert_equal(a[0], sum(np.arange(1024)))
+
+
+if __name__ == "__main__":
+    unittest.main()

numba_cuda/numba/cuda/tests/doc_examples/test_sessionize.py

@@ -0,0 +1,130 @@
+import unittest
+
+from numba.cuda.testing import (CUDATestCase, skip_if_cudadevrt_missing,
+                                skip_on_cudasim, skip_unless_cc_60,
+                                skip_if_mvc_enabled)
+from numba.tests.support import captured_stdout
+
+
+@skip_if_cudadevrt_missing
+@skip_unless_cc_60
+@skip_if_mvc_enabled('CG not supported with MVC')
+@skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
+class TestSessionization(CUDATestCase):
+    """
+    Test click stream sessionization
+    """
+
+    def setUp(self):
+        # Prevent output from this test showing up when running the test suite
+        self._captured_stdout = captured_stdout()
+        self._captured_stdout.__enter__()
+        super().setUp()
+
+    def tearDown(self):
+        # No exception type, value, or traceback
+        self._captured_stdout.__exit__(None, None, None)
+        super().tearDown()
+
+    def test_ex_sessionize(self):
+        # ex_sessionize.import.begin
+        import numpy as np
+        from numba import cuda
+
+        # Set the timeout to one hour
+        session_timeout = np.int64(np.timedelta64("3600", "s"))
+        # ex_sessionize.import.end
+
+        # ex_sessionize.allocate.begin
+        # Generate data
+        ids = cuda.to_device(
+            np.array(
+                [
+                    1, 1, 1, 1, 1, 1,
+                    2, 2, 2,
+                    3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+                    4, 4, 4, 4, 4, 4, 4, 4, 4,
+                ]
+            )
+        )
+        sec = cuda.to_device(
+            np.array(
+                [
+                    1, 2, 3, 5000, 5001, 5002, 1,
+                    2, 3, 1, 2, 5000, 5001, 10000,
+                    10001, 10002, 10003, 15000, 150001,
+                    1, 5000, 50001, 15000, 20000,
+                    25000, 25001, 25002, 25003,
+                ],
+                dtype="datetime64[ns]",
+            ).astype(
+                "int64"
+            )  # Cast to int64 for compatibility
+        )
+        # Create a vector to hold the results
+        results = cuda.to_device(np.zeros(len(ids)))
+        # ex_sessionize.allocate.end
+
+        # ex_sessionize.kernel.begin
+        @cuda.jit
+        def sessionize(user_id, timestamp, results):
+            gid = cuda.grid(1)
+            size = len(user_id)
+
+            if gid >= size:
+                return
+
+            # Determine session boundaries
+            is_first_datapoint = gid == 0
+            if not is_first_datapoint:
+                new_user = user_id[gid] != user_id[gid - 1]
+                timed_out = (
+                    timestamp[gid] - timestamp[gid - 1] > session_timeout
+                )
+                is_sess_boundary = new_user or timed_out
+            else:
+                is_sess_boundary = True
+
+            # Determine session labels
+            if is_sess_boundary:
+                # This thread marks the start of a session
+                results[gid] = gid
+
+                # Make sure all session boundaries are written
+                # before populating the session id
+                grid = cuda.cg.this_grid()
+                grid.sync()
+
+                look_ahead = 1
+                # Check elements 'forward' of this one
+                # until a new session boundary is found
+                while results[gid + look_ahead] == 0:
+                    results[gid + look_ahead] = gid
+                    look_ahead += 1
+                    # Avoid out-of-bounds accesses by the last thread
+                    if gid + look_ahead == size - 1:
+                        results[gid + look_ahead] = gid
+                        break
+        # ex_sessionize.kernel.end
+
+        # ex_sessionize.launch.begin
+        sessionize.forall(len(ids))(ids, sec, results)
+
+        print(results.copy_to_host())
+        # array([ 0.,  0.,  0.,  3.,  3.,  3.,
+        #         6.,  6.,  6.,  9.,  9., 11.,
+        #         11., 13., 13., 13., 13., 17.,
+        #         18., 19., 20., 21., 21., 23.,
+        #         24., 24., 24., 24.])
+        # ex_sessionize.launch.end
+
+        expect = [
+            0, 0, 0, 3, 3, 3, 6, 6, 6, 9, 9,
+            11, 11, 13, 13, 13, 13, 17, 18, 19, 20, 21,
+            21, 23, 24, 24, 24, 24
+        ]
+        np.testing.assert_equal(expect, results.copy_to_host())
+
+
+if __name__ == "__main__":
+    unittest.main()

numba_cuda/numba/cuda/tests/doc_examples/test_ufunc.py

@@ -0,0 +1,50 @@
+import unittest
+
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
+from numba.tests.support import captured_stdout
+
+
+@skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
+class TestUFunc(CUDATestCase):
+    """
+    Test calling a UFunc
+    """
+
+    def setUp(self):
+        # Prevent output from this test showing
+        # up when running the test suite
+        self._captured_stdout = captured_stdout()
+        self._captured_stdout.__enter__()
+        super().setUp()
+
+    def tearDown(self):
+        # No exception type, value, or traceback
+        self._captured_stdout.__exit__(None, None, None)
+        super().tearDown()
+
+    def test_ex_cuda_ufunc_call(self):
+        # ex_cuda_ufunc.begin
+        import numpy as np
+        from numba import cuda
+
+        # A kernel calling a ufunc (sin, in this case)
+        @cuda.jit
+        def f(r, x):
+            # Compute sin(x) with result written to r
+            np.sin(x, r)
+
+        # Declare input and output arrays
+        x = np.arange(10, dtype=np.float32) - 5
+        r = np.zeros_like(x)
+
+        # Launch kernel that calls the ufunc
+        f[1, 1](r, x)
+
+        # A quick sanity check demonstrating equality of the sine computed by
+        # the sin ufunc inside the kernel, and NumPy's sin ufunc
+        np.testing.assert_allclose(r, np.sin(x))
+        # ex_cuda_ufunc.end
+
+
+if __name__ == "__main__":
+    unittest.main()

numba_cuda/numba/cuda/tests/doc_examples/test_vecadd.py

@@ -0,0 +1,73 @@
+import unittest
+
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
+from numba.tests.support import captured_stdout
+
+
+@skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
+class TestVecAdd(CUDATestCase):
+    """
+    Test simple vector addition
+    """
+
+    def setUp(self):
+        # Prevent output from this test showing
+        # up when running the test suite
+        self._captured_stdout = captured_stdout()
+        self._captured_stdout.__enter__()
+        super().setUp()
+
+    def tearDown(self):
+        # No exception type, value, or traceback
+        self._captured_stdout.__exit__(None, None, None)
+        super().tearDown()
+
+    def test_ex_vecadd(self):
+        # ex_vecadd.import.begin
+        import numpy as np
+        from numba import cuda
+        # ex_vecadd.import.end
+
+        # ex_vecadd.kernel.begin
+        @cuda.jit
+        def f(a, b, c):
+            # like threadIdx.x + (blockIdx.x * blockDim.x)
+            tid = cuda.grid(1)
+            size = len(c)
+
+            if tid < size:
+                c[tid] = a[tid] + b[tid]
+        # ex_vecadd.kernel.end
+
+        # Seed RNG for test repeatability
+        np.random.seed(1)
+
+        # ex_vecadd.allocate.begin
+        N = 100000
+        a = cuda.to_device(np.random.random(N))
+        b = cuda.to_device(np.random.random(N))
+        c = cuda.device_array_like(a)
+        # ex_vecadd.allocate.end
+
+        # ex_vecadd.forall.begin
+        f.forall(len(a))(a, b, c)
+        print(c.copy_to_host())
+        # ex_vecadd.forall.end
+
+        # ex_vecadd.launch.begin
+        # Enough threads per block for several warps per block
+        nthreads = 256
+        # Enough blocks to cover the entire vector depending on its length
+        nblocks = (len(a) // nthreads) + 1
+        f[nblocks, nthreads](a, b, c)
+        print(c.copy_to_host())
+        # ex_vecadd.launch.end
+
+        np.testing.assert_equal(
+            c.copy_to_host(),
+            a.copy_to_host() + b.copy_to_host()
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

numba_cuda/numba/cuda/tests/nocuda/__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__))