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

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

@@ -0,0 +1,36 @@
+from numba import vectorize
+from numba import cuda, float32
+import numpy as np
+from numba.cuda.testing import skip_on_cudasim, CUDATestCase
+import unittest
+
+
+@skip_on_cudasim('ufunc API unsupported in the simulator')
+class TestCudaVectorizeDeviceCall(CUDATestCase):
+    def test_cuda_vectorize_device_call(self):
+
+        @cuda.jit(float32(float32, float32, float32), device=True)
+        def cu_device_fn(x, y, z):
+            return x ** y / z
+
+        def cu_ufunc(x, y, z):
+            return cu_device_fn(x, y, z)
+
+        ufunc = vectorize([float32(float32, float32, float32)], target='cuda')(
+            cu_ufunc)
+
+        N = 100
+
+        X = np.array(np.random.sample(N), dtype=np.float32)
+        Y = np.array(np.random.sample(N), dtype=np.float32)
+        Z = np.array(np.random.sample(N), dtype=np.float32) + 0.1
+
+        out = ufunc(X, Y, Z)
+
+        gold = (X ** Y) / Z
+
+        self.assertTrue(np.allclose(out, gold))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,37 @@
+import numpy as np
+from numba import vectorize
+from numba import cuda, float64
+from numba.cuda.testing import skip_on_cudasim, CUDATestCase
+import unittest
+
+sig = [float64(float64, float64)]
+
+
+@skip_on_cudasim('ufunc API unsupported in the simulator')
+class TestCUDAVectorizeScalarArg(CUDATestCase):
+
+    def test_vectorize_scalar_arg(self):
+        @vectorize(sig, target='cuda')
+        def vector_add(a, b):
+            return a + b
+
+        A = np.arange(10, dtype=np.float64)
+        dA = cuda.to_device(A)
+        v = vector_add(1.0, dA)
+
+        np.testing.assert_array_almost_equal(
+            v.copy_to_host(),
+            np.arange(1, 11, dtype=np.float64))
+
+    def test_vectorize_all_scalars(self):
+        @vectorize(sig, target='cuda')
+        def vector_add(a, b):
+            return a + b
+
+        v = vector_add(1.0, 1.0)
+
+        np.testing.assert_almost_equal(2.0, v)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,139 @@
+import numpy as np
+from numba import cuda
+from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
+from numba.tests.support import linux_only, override_config
+from numba.core.errors import NumbaPerformanceWarning
+import warnings
+
+
+@skip_on_cudasim('cudasim does not raise performance warnings')
+class TestWarnings(CUDATestCase):
+    def test_inefficient_launch_configuration(self):
+        @cuda.jit
+        def kernel():
+            pass
+
+        with override_config('CUDA_LOW_OCCUPANCY_WARNINGS', 1):
+            with warnings.catch_warnings(record=True) as w:
+                kernel[1, 1]()
+
+        self.assertEqual(w[0].category, NumbaPerformanceWarning)
+        self.assertIn('Grid size', str(w[0].message))
+        self.assertIn('low occupancy', str(w[0].message))
+
+    def test_efficient_launch_configuration(self):
+        @cuda.jit
+        def kernel():
+            pass
+
+        with override_config('CUDA_LOW_OCCUPANCY_WARNINGS', 1):
+            with warnings.catch_warnings(record=True) as w:
+                kernel[256, 256]()
+
+        self.assertEqual(len(w), 0)
+
+    def test_warn_on_host_array(self):
+        @cuda.jit
+        def foo(r, x):
+            r[0] = x + 1
+
+        N = 10
+        arr_f32 = np.zeros(N, dtype=np.float32)
+        with override_config('CUDA_WARN_ON_IMPLICIT_COPY', 1):
+            with warnings.catch_warnings(record=True) as w:
+                foo[1, N](arr_f32, N)
+
+        self.assertEqual(w[0].category, NumbaPerformanceWarning)
+        self.assertIn('Host array used in CUDA kernel will incur',
+                      str(w[0].message))
+        self.assertIn('copy overhead', str(w[0].message))
+
+    def test_pinned_warn_on_host_array(self):
+        @cuda.jit
+        def foo(r, x):
+            r[0] = x + 1
+
+        N = 10
+        ary = cuda.pinned_array(N, dtype=np.float32)
+
+        with override_config('CUDA_WARN_ON_IMPLICIT_COPY', 1):
+            with warnings.catch_warnings(record=True) as w:
+                foo[1, N](ary, N)
+
+        self.assertEqual(w[0].category, NumbaPerformanceWarning)
+        self.assertIn('Host array used in CUDA kernel will incur',
+                      str(w[0].message))
+        self.assertIn('copy overhead', str(w[0].message))
+
+    def test_nowarn_on_mapped_array(self):
+        @cuda.jit
+        def foo(r, x):
+            r[0] = x + 1
+
+        N = 10
+        ary = cuda.mapped_array(N, dtype=np.float32)
+
+        with override_config('CUDA_WARN_ON_IMPLICIT_COPY', 1):
+            with warnings.catch_warnings(record=True) as w:
+                foo[1, N](ary, N)
+
+        self.assertEqual(len(w), 0)
+
+    @linux_only
+    def test_nowarn_on_managed_array(self):
+        @cuda.jit
+        def foo(r, x):
+            r[0] = x + 1
+
+        N = 10
+        ary = cuda.managed_array(N, dtype=np.float32)
+
+        with override_config('CUDA_WARN_ON_IMPLICIT_COPY', 1):
+            with warnings.catch_warnings(record=True) as w:
+                foo[1, N](ary, N)
+
+        self.assertEqual(len(w), 0)
+
+    def test_nowarn_on_device_array(self):
+        @cuda.jit
+        def foo(r, x):
+            r[0] = x + 1
+
+        N = 10
+        ary = cuda.device_array(N, dtype=np.float32)
+
+        with override_config('CUDA_WARN_ON_IMPLICIT_COPY', 1):
+            with warnings.catch_warnings(record=True) as w:
+                foo[1, N](ary, N)
+
+        self.assertEqual(len(w), 0)
+
+    def test_warn_on_debug_and_opt(self):
+        with warnings.catch_warnings(record=True) as w:
+            cuda.jit(debug=True, opt=True)
+
+        self.assertEqual(len(w), 1)
+        self.assertIn('not supported by CUDA', str(w[0].message))
+
+    def test_warn_on_debug_and_opt_default(self):
+        with warnings.catch_warnings(record=True) as w:
+            cuda.jit(debug=True)
+
+        self.assertEqual(len(w), 1)
+        self.assertIn('not supported by CUDA', str(w[0].message))
+
+    def test_no_warn_on_debug_and_no_opt(self):
+        with warnings.catch_warnings(record=True) as w:
+            cuda.jit(debug=True, opt=False)
+
+        self.assertEqual(len(w), 0)
+
+    def test_no_warn_with_no_debug_and_opt_kwargs(self):
+        with warnings.catch_warnings(record=True) as w:
+            cuda.jit()
+
+        self.assertEqual(len(w), 0)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,276 @@
+import numpy as np
+from numba import cuda, int32, int64, float32, float64
+from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
+from numba.core import config
+
+
+def useful_syncwarp(ary):
+    i = cuda.grid(1)
+    if i == 0:
+        ary[0] = 42
+    cuda.syncwarp(0xffffffff)
+    ary[i] = ary[0]
+
+
+def use_shfl_sync_idx(ary, idx):
+    i = cuda.grid(1)
+    val = cuda.shfl_sync(0xffffffff, i, idx)
+    ary[i] = val
+
+
+def use_shfl_sync_up(ary, delta):
+    i = cuda.grid(1)
+    val = cuda.shfl_up_sync(0xffffffff, i, delta)
+    ary[i] = val
+
+
+def use_shfl_sync_down(ary, delta):
+    i = cuda.grid(1)
+    val = cuda.shfl_down_sync(0xffffffff, i, delta)
+    ary[i] = val
+
+
+def use_shfl_sync_xor(ary, xor):
+    i = cuda.grid(1)
+    val = cuda.shfl_xor_sync(0xffffffff, i, xor)
+    ary[i] = val
+
+
+def use_shfl_sync_with_val(ary, into):
+    i = cuda.grid(1)
+    val = cuda.shfl_sync(0xffffffff, into, 0)
+    ary[i] = val
+
+
+def use_vote_sync_all(ary_in, ary_out):
+    i = cuda.grid(1)
+    pred = cuda.all_sync(0xffffffff, ary_in[i])
+    ary_out[i] = pred
+
+
+def use_vote_sync_any(ary_in, ary_out):
+    i = cuda.grid(1)
+    pred = cuda.any_sync(0xffffffff, ary_in[i])
+    ary_out[i] = pred
+
+
+def use_vote_sync_eq(ary_in, ary_out):
+    i = cuda.grid(1)
+    pred = cuda.eq_sync(0xffffffff, ary_in[i])
+    ary_out[i] = pred
+
+
+def use_vote_sync_ballot(ary):
+    i = cuda.threadIdx.x
+    ballot = cuda.ballot_sync(0xffffffff, True)
+    ary[i] = ballot
+
+
+def use_match_any_sync(ary_in, ary_out):
+    i = cuda.grid(1)
+    ballot = cuda.match_any_sync(0xffffffff, ary_in[i])
+    ary_out[i] = ballot
+
+
+def use_match_all_sync(ary_in, ary_out):
+    i = cuda.grid(1)
+    ballot, pred = cuda.match_all_sync(0xffffffff, ary_in[i])
+    ary_out[i] = ballot if pred else 0
+
+
+def use_independent_scheduling(arr):
+    i = cuda.threadIdx.x
+    if i % 4 == 0:
+        ballot = cuda.ballot_sync(0x11111111, True)
+    elif i % 4 == 1:
+        ballot = cuda.ballot_sync(0x22222222, True)
+    elif i % 4 == 2:
+        ballot = cuda.ballot_sync(0x44444444, True)
+    elif i % 4 == 3:
+        ballot = cuda.ballot_sync(0x88888888, True)
+    arr[i] = ballot
+
+
+def _safe_cc_check(cc):
+    if config.ENABLE_CUDASIM:
+        return True
+    else:
+        return cuda.get_current_device().compute_capability >= cc
+
+
+@skip_on_cudasim("Warp Operations are not yet implemented on cudasim")
+class TestCudaWarpOperations(CUDATestCase):
+    def test_useful_syncwarp(self):
+        compiled = cuda.jit("void(int32[:])")(useful_syncwarp)
+        nelem = 32
+        ary = np.empty(nelem, dtype=np.int32)
+        compiled[1, nelem](ary)
+        self.assertTrue(np.all(ary == 42))
+
+    def test_shfl_sync_idx(self):
+        compiled = cuda.jit("void(int32[:], int32)")(use_shfl_sync_idx)
+        nelem = 32
+        idx = 4
+        ary = np.empty(nelem, dtype=np.int32)
+        compiled[1, nelem](ary, idx)
+        self.assertTrue(np.all(ary == idx))
+
+    def test_shfl_sync_up(self):
+        compiled = cuda.jit("void(int32[:], int32)")(use_shfl_sync_up)
+        nelem = 32
+        delta = 4
+        ary = np.empty(nelem, dtype=np.int32)
+        exp = np.arange(nelem, dtype=np.int32)
+        exp[delta:] -= delta
+        compiled[1, nelem](ary, delta)
+        self.assertTrue(np.all(ary == exp))
+
+    def test_shfl_sync_down(self):
+        compiled = cuda.jit("void(int32[:], int32)")(use_shfl_sync_down)
+        nelem = 32
+        delta = 4
+        ary = np.empty(nelem, dtype=np.int32)
+        exp = np.arange(nelem, dtype=np.int32)
+        exp[:-delta] += delta
+        compiled[1, nelem](ary, delta)
+        self.assertTrue(np.all(ary == exp))
+
+    def test_shfl_sync_xor(self):
+        compiled = cuda.jit("void(int32[:], int32)")(use_shfl_sync_xor)
+        nelem = 32
+        xor = 16
+        ary = np.empty(nelem, dtype=np.int32)
+        exp = np.arange(nelem, dtype=np.int32) ^ xor
+        compiled[1, nelem](ary, xor)
+        self.assertTrue(np.all(ary == exp))
+
+    def test_shfl_sync_types(self):
+        types = int32, int64, float32, float64
+        values = (np.int32(-1), np.int64(1 << 42),
+                  np.float32(np.pi), np.float64(np.pi))
+        for typ, val in zip(types, values):
+            compiled = cuda.jit((typ[:], typ))(use_shfl_sync_with_val)
+            nelem = 32
+            ary = np.empty(nelem, dtype=val.dtype)
+            compiled[1, nelem](ary, val)
+            self.assertTrue(np.all(ary == val))
+
+    def test_vote_sync_all(self):
+        compiled = cuda.jit("void(int32[:], int32[:])")(use_vote_sync_all)
+        nelem = 32
+        ary_in = np.ones(nelem, dtype=np.int32)
+        ary_out = np.empty(nelem, dtype=np.int32)
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 1))
+        ary_in[-1] = 0
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 0))
+
+    def test_vote_sync_any(self):
+        compiled = cuda.jit("void(int32[:], int32[:])")(use_vote_sync_any)
+        nelem = 32
+        ary_in = np.zeros(nelem, dtype=np.int32)
+        ary_out = np.empty(nelem, dtype=np.int32)
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 0))
+        ary_in[2] = 1
+        ary_in[5] = 1
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 1))
+
+    def test_vote_sync_eq(self):
+        compiled = cuda.jit("void(int32[:], int32[:])")(use_vote_sync_eq)
+        nelem = 32
+        ary_in = np.zeros(nelem, dtype=np.int32)
+        ary_out = np.empty(nelem, dtype=np.int32)
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 1))
+        ary_in[1] = 1
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 0))
+        ary_in[:] = 1
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 1))
+
+    def test_vote_sync_ballot(self):
+        compiled = cuda.jit("void(uint32[:])")(use_vote_sync_ballot)
+        nelem = 32
+        ary = np.empty(nelem, dtype=np.uint32)
+        compiled[1, nelem](ary)
+        self.assertTrue(np.all(ary == np.uint32(0xffffffff)))
+
+    @unittest.skipUnless(_safe_cc_check((7, 0)),
+                         "Matching requires at least Volta Architecture")
+    def test_match_any_sync(self):
+        compiled = cuda.jit("void(int32[:], int32[:])")(use_match_any_sync)
+        nelem = 10
+        ary_in = np.arange(nelem, dtype=np.int32) % 2
+        ary_out = np.empty(nelem, dtype=np.int32)
+        exp = np.tile((0b0101010101, 0b1010101010), 5)
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == exp))
+
+    @unittest.skipUnless(_safe_cc_check((7, 0)),
+                         "Matching requires at least Volta Architecture")
+    def test_match_all_sync(self):
+        compiled = cuda.jit("void(int32[:], int32[:])")(use_match_all_sync)
+        nelem = 10
+        ary_in = np.zeros(nelem, dtype=np.int32)
+        ary_out = np.empty(nelem, dtype=np.int32)
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 0b1111111111))
+        ary_in[1] = 4
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 0))
+
+    @unittest.skipUnless(_safe_cc_check((7, 0)),
+                         "Independent scheduling requires at least Volta "
+                         "Architecture")
+    def test_independent_scheduling(self):
+        compiled = cuda.jit("void(uint32[:])")(use_independent_scheduling)
+        arr = np.empty(32, dtype=np.uint32)
+        exp = np.tile((0x11111111, 0x22222222, 0x44444444, 0x88888888), 8)
+        compiled[1, 32](arr)
+        self.assertTrue(np.all(arr == exp))
+
+    def test_activemask(self):
+        @cuda.jit
+        def use_activemask(x):
+            i = cuda.grid(1)
+            if (i % 2) == 0:
+                # Even numbered threads fill in even numbered array entries
+                # with binary "...01010101"
+                x[i] = cuda.activemask()
+            else:
+                # Odd numbered threads fill in odd numbered array entries
+                # with binary "...10101010"
+                x[i] = cuda.activemask()
+
+        out = np.zeros(32, dtype=np.uint32)
+        use_activemask[1, 32](out)
+
+        # 0x5 = 0101: The pattern from even-numbered threads
+        # 0xA = 1010: The pattern from odd-numbered threads
+        expected = np.tile((0x55555555, 0xAAAAAAAA), 16)
+        np.testing.assert_equal(expected, out)
+
+    def test_lanemask_lt(self):
+        @cuda.jit
+        def use_lanemask_lt(x):
+            i = cuda.grid(1)
+            x[i] = cuda.lanemask_lt()
+
+        out = np.zeros(32, dtype=np.uint32)
+        use_lanemask_lt[1, 32](out)
+
+        # A string of 1s that grows from the LSB for each entry:
+        # 0, 1, 3, 7, F, 1F, 3F, 7F, FF, 1FF, etc.
+        # or in binary:
+        # ...0001, ....0011, ...0111, etc.
+        expected = np.asarray([(2 ** i) - 1 for i in range(32)],
+                              dtype=np.uint32)
+        np.testing.assert_equal(expected, out)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

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

numba_cuda/numba/cuda/tests/cudasim/support.py

@@ -0,0 +1,6 @@
+from numba import cuda
+
+
+@cuda.jit(device=True)
+def cuda_module_in_device_function():
+    return cuda.threadIdx.x

numba_cuda/numba/cuda/tests/cudasim/test_cudasim_issues.py

@@ -0,0 +1,102 @@
+import threading
+
+import numpy as np
+
+from numba import cuda
+from numba.cuda.testing import CUDATestCase, skip_unless_cudasim
+import numba.cuda.simulator as simulator
+import unittest
+
+
+class TestCudaSimIssues(CUDATestCase):
+    def test_record_access(self):
+        backyard_type = [('statue', np.float64),
+                         ('newspaper', np.float64, (6,))]
+
+        goose_type = [('garden', np.float64, (12,)),
+                      ('town', np.float64, (42,)),
+                      ('backyard', backyard_type)]
+
+        goose_np_type = np.dtype(goose_type, align=True)
+
+        @cuda.jit
+        def simple_kernel(f):
+            f.garden[0] = 45.0
+            f.backyard.newspaper[3] = 2.0
+            f.backyard.newspaper[3] = f.backyard.newspaper[3] + 3.0
+
+        item = np.recarray(1, dtype=goose_np_type)
+        simple_kernel[1, 1](item[0])
+        np.testing.assert_equal(item[0]['garden'][0], 45)
+        np.testing.assert_equal(item[0]['backyard']['newspaper'][3], 5)
+
+    def test_recarray_setting(self):
+        recordwith2darray = np.dtype([('i', np.int32),
+                                      ('j', np.float32, (3, 2))])
+        rec = np.recarray(2, dtype=recordwith2darray)
+        rec[0]['i'] = 45
+
+        @cuda.jit
+        def simple_kernel(f):
+            f[1] = f[0]
+        simple_kernel[1, 1](rec)
+        np.testing.assert_equal(rec[0]['i'], rec[1]['i'])
+
+    def test_cuda_module_in_device_function(self):
+        """
+        Discovered in https://github.com/numba/numba/issues/1837.
+        When the `cuda` module is referenced in a device function,
+        it does not have the kernel API (e.g. cuda.threadIdx, cuda.shared)
+        """
+        from numba.cuda.tests.cudasim import support
+
+        inner = support.cuda_module_in_device_function
+
+        @cuda.jit
+        def outer(out):
+            tid = inner()
+            if tid < out.size:
+                out[tid] = tid
+
+        arr = np.zeros(10, dtype=np.int32)
+        outer[1, 11](arr)
+        expected = np.arange(arr.size, dtype=np.int32)
+        np.testing.assert_equal(expected, arr)
+
+    @skip_unless_cudasim('Only works on CUDASIM')
+    def test_deadlock_on_exception(self):
+        def assert_no_blockthreads():
+            blockthreads = []
+            for t in threading.enumerate():
+                if not isinstance(t, simulator.kernel.BlockThread):
+                    continue
+
+                # join blockthreads with a short timeout to allow aborted
+                # threads to exit
+                t.join(1)
+                if t.is_alive():
+                    self.fail("Blocked kernel thread: %s" % t)
+
+            self.assertListEqual(blockthreads, [])
+
+        @simulator.jit
+        def assign_with_sync(x, y):
+            i = cuda.grid(1)
+            y[i] = x[i]
+
+            cuda.syncthreads()
+            cuda.syncthreads()
+
+        x = np.arange(3)
+        y = np.empty(3)
+        assign_with_sync[1, 3](x, y)
+        np.testing.assert_array_equal(x, y)
+        assert_no_blockthreads()
+
+        with self.assertRaises(IndexError):
+            assign_with_sync[1, 6](x, y)
+        assert_no_blockthreads()
+
+
+if __name__ == '__main__':
+    unittest.main()

numba_cuda/numba/cuda/tests/data/cuda_include.cu

@@ -0,0 +1,5 @@
+// Not all CUDA includes are safe to include in device code compiled by NVRTC,
+// because it does not have paths to all system include directories. Headers
+// such as cuda_device_runtime_api.h are safe to use in NVRTC without adding
+// additional includes.
+#include <cuda_device_runtime_api.h>

numba_cuda/numba/cuda/tests/data/error.cu

@@ -0,0 +1,7 @@
+extern "C" __device__
+int bar(int* out, int a) {
+  // Explicitly placed to generate an error
+  SYNTAX ERROR
+  *out = a * 2;
+  return 0;
+}

numba_cuda/numba/cuda/tests/data/jitlink.cu

@@ -0,0 +1,23 @@
+// Compile with:
+//
+//   nvcc -gencode arch=compute_50,code=compute_50 -rdc true -ptx jitlink.cu
+//
+// using the oldest supported toolkit version (10.2 at the time of writing).
+
+extern "C" __device__
+int bar(int *out, int a)
+{
+  *out = a * 2;
+  return 0;
+}
+
+
+// The out argument is necessary due to Numba's CUDA calling convention, which
+// always reserves the first parameter for a pointer to a returned value, even
+// if there is no return value.
+extern "C" __device__
+int array_mutator(void *out, int *a)
+{
+  a[0] = a[1];
+  return 0;
+}  

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

@@ -0,0 +1,51 @@
+//
+// Generated by NVIDIA NVVM Compiler
+//
+// Compiler Build ID: CL-27506705
+// Cuda compilation tools, release 10.2, V10.2.89
+// Based on LLVM 3.4svn
+//
+
+.version 6.5
+.target sm_50
+.address_size 64
+
+	// .globl	bar
+
+.visible .func  (.param .b32 func_retval0) bar(
+	.param .b64 bar_param_0,
+	.param .b32 bar_param_1
+)
+{
+	.reg .b32 	%r<4>;
+	.reg .b64 	%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;
+}
+
+	// .globl	array_mutator
+.visible .func  (.param .b32 func_retval0) array_mutator(
+	.param .b64 array_mutator_param_0,
+	.param .b64 array_mutator_param_1
+)
+{
+	.reg .b32 	%r<3>;
+	.reg .b64 	%rd<2>;
+
+
+	ld.param.u64 	%rd1, [array_mutator_param_1];
+	ld.u32 	%r1, [%rd1+4];
+	st.u32 	[%rd1], %r1;
+	mov.u32 	%r2, 0;
+	st.param.b32	[func_retval0+0], %r2;
+	ret;
+}
+
+