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

numba_cuda/numba/cuda/nvvmutils.py

@@ -0,0 +1,235 @@
+import itertools
+from llvmlite import ir
+from numba.core import cgutils, targetconfig
+from .cudadrv import nvvm
+
+
+def declare_atomic_cas_int(lmod, isize):
+    fname = '___numba_atomic_i' + str(isize) + '_cas_hack'
+    fnty = ir.FunctionType(ir.IntType(isize),
+                           (ir.PointerType(ir.IntType(isize)),
+                            ir.IntType(isize),
+                            ir.IntType(isize)))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def atomic_cmpxchg(builder, lmod, isize, ptr, cmp, val):
+    out = builder.cmpxchg(ptr, cmp, val, 'monotonic', 'monotonic')
+    return builder.extract_value(out, 0)
+
+
+def declare_atomic_add_float32(lmod):
+    fname = 'llvm.nvvm.atomic.load.add.f32.p0f32'
+    fnty = ir.FunctionType(ir.FloatType(),
+                           (ir.PointerType(ir.FloatType(), 0), ir.FloatType()))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_add_float64(lmod):
+    flags = targetconfig.ConfigStack().top()
+    if flags.compute_capability >= (6, 0):
+        fname = 'llvm.nvvm.atomic.load.add.f64.p0f64'
+    else:
+        fname = '___numba_atomic_double_add'
+    fnty = ir.FunctionType(ir.DoubleType(),
+                           (ir.PointerType(ir.DoubleType()), ir.DoubleType()))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_sub_float32(lmod):
+    fname = '___numba_atomic_float_sub'
+    fnty = ir.FunctionType(ir.FloatType(),
+                           (ir.PointerType(ir.FloatType()), ir.FloatType()))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_sub_float64(lmod):
+    fname = '___numba_atomic_double_sub'
+    fnty = ir.FunctionType(ir.DoubleType(),
+                           (ir.PointerType(ir.DoubleType()), ir.DoubleType()))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_inc_int32(lmod):
+    fname = 'llvm.nvvm.atomic.load.inc.32.p0i32'
+    fnty = ir.FunctionType(ir.IntType(32),
+                           (ir.PointerType(ir.IntType(32)), ir.IntType(32)))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_inc_int64(lmod):
+    fname = '___numba_atomic_u64_inc'
+    fnty = ir.FunctionType(ir.IntType(64),
+                           (ir.PointerType(ir.IntType(64)), ir.IntType(64)))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_dec_int32(lmod):
+    fname = 'llvm.nvvm.atomic.load.dec.32.p0i32'
+    fnty = ir.FunctionType(ir.IntType(32),
+                           (ir.PointerType(ir.IntType(32)), ir.IntType(32)))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_dec_int64(lmod):
+    fname = '___numba_atomic_u64_dec'
+    fnty = ir.FunctionType(ir.IntType(64),
+                           (ir.PointerType(ir.IntType(64)), ir.IntType(64)))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_max_float32(lmod):
+    fname = '___numba_atomic_float_max'
+    fnty = ir.FunctionType(ir.FloatType(),
+                           (ir.PointerType(ir.FloatType()), ir.FloatType()))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_max_float64(lmod):
+    fname = '___numba_atomic_double_max'
+    fnty = ir.FunctionType(ir.DoubleType(),
+                           (ir.PointerType(ir.DoubleType()), ir.DoubleType()))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_min_float32(lmod):
+    fname = '___numba_atomic_float_min'
+    fnty = ir.FunctionType(ir.FloatType(),
+                           (ir.PointerType(ir.FloatType()), ir.FloatType()))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_min_float64(lmod):
+    fname = '___numba_atomic_double_min'
+    fnty = ir.FunctionType(ir.DoubleType(),
+                           (ir.PointerType(ir.DoubleType()), ir.DoubleType()))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_nanmax_float32(lmod):
+    fname = '___numba_atomic_float_nanmax'
+    fnty = ir.FunctionType(ir.FloatType(),
+                           (ir.PointerType(ir.FloatType()), ir.FloatType()))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_nanmax_float64(lmod):
+    fname = '___numba_atomic_double_nanmax'
+    fnty = ir.FunctionType(ir.DoubleType(),
+                           (ir.PointerType(ir.DoubleType()), ir.DoubleType()))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_nanmin_float32(lmod):
+    fname = '___numba_atomic_float_nanmin'
+    fnty = ir.FunctionType(ir.FloatType(),
+                           (ir.PointerType(ir.FloatType()), ir.FloatType()))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_atomic_nanmin_float64(lmod):
+    fname = '___numba_atomic_double_nanmin'
+    fnty = ir.FunctionType(ir.DoubleType(),
+                           (ir.PointerType(ir.DoubleType()), ir.DoubleType()))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_cudaCGGetIntrinsicHandle(lmod):
+    fname = 'cudaCGGetIntrinsicHandle'
+    fnty = ir.FunctionType(ir.IntType(64),
+                           (ir.IntType(32),))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_cudaCGSynchronize(lmod):
+    fname = 'cudaCGSynchronize'
+    fnty = ir.FunctionType(ir.IntType(32),
+                           (ir.IntType(64), ir.IntType(32)))
+    return cgutils.get_or_insert_function(lmod, fnty, fname)
+
+
+def declare_string(builder, value):
+    lmod = builder.basic_block.function.module
+    cval = cgutils.make_bytearray(value.encode("utf-8") + b"\x00")
+    gl = cgutils.add_global_variable(lmod, cval.type, name="_str",
+                                     addrspace=nvvm.ADDRSPACE_CONSTANT)
+    gl.linkage = 'internal'
+    gl.global_constant = True
+    gl.initializer = cval
+
+    return builder.addrspacecast(gl, ir.PointerType(ir.IntType(8)), 'generic')
+
+
+def declare_vprint(lmod):
+    voidptrty = ir.PointerType(ir.IntType(8))
+    # NOTE: the second argument to vprintf() points to the variable-length
+    # array of arguments (after the format)
+    vprintfty = ir.FunctionType(ir.IntType(32), [voidptrty, voidptrty])
+    vprintf = cgutils.get_or_insert_function(lmod, vprintfty, "vprintf")
+    return vprintf
+
+
+# -----------------------------------------------------------------------------
+
+SREG_MAPPING = {
+    'tid.x': 'llvm.nvvm.read.ptx.sreg.tid.x',
+    'tid.y': 'llvm.nvvm.read.ptx.sreg.tid.y',
+    'tid.z': 'llvm.nvvm.read.ptx.sreg.tid.z',
+
+    'ntid.x': 'llvm.nvvm.read.ptx.sreg.ntid.x',
+    'ntid.y': 'llvm.nvvm.read.ptx.sreg.ntid.y',
+    'ntid.z': 'llvm.nvvm.read.ptx.sreg.ntid.z',
+
+    'ctaid.x': 'llvm.nvvm.read.ptx.sreg.ctaid.x',
+    'ctaid.y': 'llvm.nvvm.read.ptx.sreg.ctaid.y',
+    'ctaid.z': 'llvm.nvvm.read.ptx.sreg.ctaid.z',
+
+    'nctaid.x': 'llvm.nvvm.read.ptx.sreg.nctaid.x',
+    'nctaid.y': 'llvm.nvvm.read.ptx.sreg.nctaid.y',
+    'nctaid.z': 'llvm.nvvm.read.ptx.sreg.nctaid.z',
+
+    'warpsize': 'llvm.nvvm.read.ptx.sreg.warpsize',
+    'laneid': 'llvm.nvvm.read.ptx.sreg.laneid',
+}
+
+
+def call_sreg(builder, name):
+    module = builder.module
+    fnty = ir.FunctionType(ir.IntType(32), ())
+    fn = cgutils.get_or_insert_function(module, fnty, SREG_MAPPING[name])
+    return builder.call(fn, ())
+
+
+class SRegBuilder(object):
+    def __init__(self, builder):
+        self.builder = builder
+
+    def tid(self, xyz):
+        return call_sreg(self.builder, 'tid.%s' % xyz)
+
+    def ctaid(self, xyz):
+        return call_sreg(self.builder, 'ctaid.%s' % xyz)
+
+    def ntid(self, xyz):
+        return call_sreg(self.builder, 'ntid.%s' % xyz)
+
+    def nctaid(self, xyz):
+        return call_sreg(self.builder, 'nctaid.%s' % xyz)
+
+    def getdim(self, xyz):
+        i64 = ir.IntType(64)
+        tid = self.builder.sext(self.tid(xyz), i64)
+        ntid = self.builder.sext(self.ntid(xyz), i64)
+        nctaid = self.builder.sext(self.ctaid(xyz), i64)
+        res = self.builder.add(self.builder.mul(ntid, nctaid), tid)
+        return res
+
+
+def get_global_id(builder, dim):
+    sreg = SRegBuilder(builder)
+    it = (sreg.getdim(xyz) for xyz in 'xyz')
+    seq = list(itertools.islice(it, None, dim))
+    if dim == 1:
+        return seq[0]
+    else:
+        return seq

numba_cuda/numba/cuda/printimpl.py

@@ -0,0 +1,86 @@
+from functools import singledispatch
+from llvmlite import ir
+from numba.core import types, cgutils
+from numba.core.errors import NumbaWarning
+from numba.core.imputils import Registry
+from numba.cuda import nvvmutils
+from warnings import warn
+
+registry = Registry()
+lower = registry.lower
+
+voidptr = ir.PointerType(ir.IntType(8))
+
+
+# NOTE: we don't use @lower here since print_item() doesn't return a LLVM value
+
+@singledispatch
+def print_item(ty, context, builder, val):
+    """
+    Handle printing of a single value of the given Numba type.
+    A (format string, [list of arguments]) is returned that will allow
+    forming the final printf()-like call.
+    """
+    raise NotImplementedError("printing unimplemented for values of type %s"
+                              % (ty,))
+
+
+@print_item.register(types.Integer)
+@print_item.register(types.IntegerLiteral)
+def int_print_impl(ty, context, builder, val):
+    if ty in types.unsigned_domain:
+        rawfmt = "%llu"
+        dsttype = types.uint64
+    else:
+        rawfmt = "%lld"
+        dsttype = types.int64
+    lld = context.cast(builder, val, ty, dsttype)
+    return rawfmt, [lld]
+
+
+@print_item.register(types.Float)
+def real_print_impl(ty, context, builder, val):
+    lld = context.cast(builder, val, ty, types.float64)
+    return "%f", [lld]
+
+
+@print_item.register(types.StringLiteral)
+def const_print_impl(ty, context, builder, sigval):
+    pyval = ty.literal_value
+    assert isinstance(pyval, str)  # Ensured by lowering
+    rawfmt = "%s"
+    val = context.insert_string_const_addrspace(builder, pyval)
+    return rawfmt, [val]
+
+
+@lower(print, types.VarArg(types.Any))
+def print_varargs(context, builder, sig, args):
+    """This function is a generic 'print' wrapper for arbitrary types.
+    It dispatches to the appropriate 'print' implementations above
+    depending on the detected real types in the signature."""
+
+    vprint = nvvmutils.declare_vprint(builder.module)
+
+    formats = []
+    values = []
+
+    for i, (argtype, argval) in enumerate(zip(sig.args, args)):
+        argfmt, argvals = print_item(argtype, context, builder, argval)
+        formats.append(argfmt)
+        values.extend(argvals)
+
+    rawfmt = " ".join(formats) + "\n"
+    if len(args) > 32:
+        msg = ('CUDA print() cannot print more than 32 items. '
+               'The raw format string will be emitted by the kernel instead.')
+        warn(msg, NumbaWarning)
+
+        rawfmt = rawfmt.replace('%', '%%')
+    fmt = context.insert_string_const_addrspace(builder, rawfmt)
+    array = cgutils.make_anonymous_struct(builder, values)
+    arrayptr = cgutils.alloca_once_value(builder, array)
+
+    vprint = nvvmutils.declare_vprint(builder.module)
+    builder.call(vprint, (fmt, builder.bitcast(arrayptr, voidptr)))
+
+    return context.get_dummy_value()

numba_cuda/numba/cuda/random.py

@@ -0,0 +1,292 @@
+import math
+
+from numba import (config, cuda, float32, float64, uint32, int64, uint64,
+                   from_dtype, jit)
+
+import numpy as np
+
+# This implementation is based upon the xoroshiro128+ and splitmix64 algorithms
+# described at:
+#
+#     http://xoroshiro.di.unimi.it/
+#
+# and originally implemented by David Blackman and Sebastiano Vigna.
+#
+# The implementations below are based on the C source code:
+#
+#  * http://xoroshiro.di.unimi.it/xoroshiro128plus.c
+#  * http://xoroshiro.di.unimi.it/splitmix64.c
+#
+# Splitmix64 is used to generate the initial state of the xoroshiro128+
+# generator to ensure that small seeds don't result in predictable output.
+
+# **WARNING**: There is a lot of verbose casting in this file to ensure that
+# NumPy casting conventions (which cast uint64 [op] int32 to float64) don't
+# turn integers into floats when using these functions in the CUDA simulator.
+#
+# There are also no function type signatures to ensure that compilation is
+# deferred so that import is quick, and Sphinx autodoc works.  We are also
+# using the CPU @jit decorator everywhere to create functions that work as
+# both CPU and CUDA device functions.
+
+xoroshiro128p_dtype = np.dtype([('s0', np.uint64), ('s1', np.uint64)],
+                               align=True)
+xoroshiro128p_type = from_dtype(xoroshiro128p_dtype)
+
+# When cudasim is enabled, Fake CUDA arrays are passed to some of the
+# @jit-decorated functions. This required fallback to object mode. With
+# Numba 0.59.0 object mode must be explicitly enabled.
+# https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit
+# In order to avoid the warning / future error, we explicitly specify that
+# object mode with loop lifting is acceptable when using the simulator.
+_forceobj = _looplift = config.ENABLE_CUDASIM
+_nopython = not config.ENABLE_CUDASIM
+
+
+@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython)
+def init_xoroshiro128p_state(states, index, seed):
+    '''Use SplitMix64 to generate an xoroshiro128p state from 64-bit seed.
+
+    This ensures that manually set small seeds don't result in a predictable
+    initial sequence from the random number generator.
+
+    :type states: 1D array, dtype=xoroshiro128p_dtype
+    :param states: array of RNG states
+    :type index: uint64
+    :param index: offset in states to update
+    :type seed: int64
+    :param seed: seed value to use when initializing state
+    '''
+    index = int64(index)
+    seed = uint64(seed)
+
+    z = seed + uint64(0x9E3779B97F4A7C15)
+    z = (z ^ (z >> uint32(30))) * uint64(0xBF58476D1CE4E5B9)
+    z = (z ^ (z >> uint32(27))) * uint64(0x94D049BB133111EB)
+    z = z ^ (z >> uint32(31))
+
+    states[index]['s0'] = z
+    states[index]['s1'] = z
+
+
+@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython)
+def rotl(x, k):
+    '''Left rotate x by k bits.'''
+    x = uint64(x)
+    k = uint32(k)
+    return (x << k) | (x >> uint32(64 - k))
+
+
+@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython)
+def xoroshiro128p_next(states, index):
+    '''Return the next random uint64 and advance the RNG in states[index].
+
+    :type states: 1D array, dtype=xoroshiro128p_dtype
+    :param states: array of RNG states
+    :type index: int64
+    :param index: offset in states to update
+    :rtype: uint64
+    '''
+    index = int64(index)
+    s0 = states[index]['s0']
+    s1 = states[index]['s1']
+    result = s0 + s1
+
+    s1 ^= s0
+    states[index]['s0'] = uint64(rotl(s0, uint32(55))) ^ s1 ^ (s1 << uint32(14))
+    states[index]['s1'] = uint64(rotl(s1, uint32(36)))
+
+    return result
+
+
+@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython)
+def xoroshiro128p_jump(states, index):
+    '''Advance the RNG in ``states[index]`` by 2**64 steps.
+
+    :type states: 1D array, dtype=xoroshiro128p_dtype
+    :param states: array of RNG states
+    :type index: int64
+    :param index: offset in states to update
+    '''
+    index = int64(index)
+
+    jump = (uint64(0xbeac0467eba5facb), uint64(0xd86b048b86aa9922))
+
+    s0 = uint64(0)
+    s1 = uint64(0)
+
+    for i in range(2):
+        for b in range(64):
+            if jump[i] & (uint64(1) << uint32(b)):
+                s0 ^= states[index]['s0']
+                s1 ^= states[index]['s1']
+            xoroshiro128p_next(states, index)
+
+    states[index]['s0'] = s0
+    states[index]['s1'] = s1
+
+
+@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython)
+def uint64_to_unit_float64(x):
+    '''Convert uint64 to float64 value in the range [0.0, 1.0)'''
+    x = uint64(x)
+    return (x >> uint32(11)) * (float64(1) / (uint64(1) << uint32(53)))
+
+
+@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython)
+def uint64_to_unit_float32(x):
+    '''Convert uint64 to float32 value in the range [0.0, 1.0)'''
+    x = uint64(x)
+    return float32(uint64_to_unit_float64(x))
+
+
+@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython)
+def xoroshiro128p_uniform_float32(states, index):
+    '''Return a float32 in range [0.0, 1.0) and advance ``states[index]``.
+
+    :type states: 1D array, dtype=xoroshiro128p_dtype
+    :param states: array of RNG states
+    :type index: int64
+    :param index: offset in states to update
+    :rtype: float32
+    '''
+    index = int64(index)
+    return uint64_to_unit_float32(xoroshiro128p_next(states, index))
+
+
+@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython)
+def xoroshiro128p_uniform_float64(states, index):
+    '''Return a float64 in range [0.0, 1.0) and advance ``states[index]``.
+
+    :type states: 1D array, dtype=xoroshiro128p_dtype
+    :param states: array of RNG states
+    :type index: int64
+    :param index: offset in states to update
+    :rtype: float64
+    '''
+    index = int64(index)
+    return uint64_to_unit_float64(xoroshiro128p_next(states, index))
+
+
+TWO_PI_FLOAT32 = np.float32(2 * math.pi)
+TWO_PI_FLOAT64 = np.float64(2 * math.pi)
+
+
+@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython)
+def xoroshiro128p_normal_float32(states, index):
+    '''Return a normally distributed float32 and advance ``states[index]``.
+
+    The return value is drawn from a Gaussian of mean=0 and sigma=1 using the
+    Box-Muller transform.  This advances the RNG sequence by two steps.
+
+    :type states: 1D array, dtype=xoroshiro128p_dtype
+    :param states: array of RNG states
+    :type index: int64
+    :param index: offset in states to update
+    :rtype: float32
+    '''
+    index = int64(index)
+
+    u1 = xoroshiro128p_uniform_float32(states, index)
+    u2 = xoroshiro128p_uniform_float32(states, index)
+
+    z0 = math.sqrt(-float32(2.0) * math.log(u1)) * math.cos(TWO_PI_FLOAT32 * u2)
+    # discarding second normal value
+    # z1 = math.sqrt(-float32(2.0) * math.log(u1))
+    #                * math.sin(TWO_PI_FLOAT32 * u2)
+    return z0
+
+
+@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython)
+def xoroshiro128p_normal_float64(states, index):
+    '''Return a normally distributed float32 and advance ``states[index]``.
+
+    The return value is drawn from a Gaussian of mean=0 and sigma=1 using the
+    Box-Muller transform.  This advances the RNG sequence by two steps.
+
+    :type states: 1D array, dtype=xoroshiro128p_dtype
+    :param states: array of RNG states
+    :type index: int64
+    :param index: offset in states to update
+    :rtype: float64
+    '''
+    index = int64(index)
+
+    u1 = xoroshiro128p_uniform_float32(states, index)
+    u2 = xoroshiro128p_uniform_float32(states, index)
+
+    z0 = math.sqrt(-float64(2.0) * math.log(u1)) * math.cos(TWO_PI_FLOAT64 * u2)
+    # discarding second normal value
+    # z1 = math.sqrt(-float64(2.0) * math.log(u1))
+    #                * math.sin(TWO_PI_FLOAT64 * u2)
+    return z0
+
+
+@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython)
+def init_xoroshiro128p_states_cpu(states, seed, subsequence_start):
+    n = states.shape[0]
+    seed = uint64(seed)
+    subsequence_start = uint64(subsequence_start)
+
+    if n >= 1:
+        init_xoroshiro128p_state(states, 0, seed)
+
+        # advance to starting subsequence number
+        for _ in range(subsequence_start):
+            xoroshiro128p_jump(states, 0)
+
+        # populate the rest of the array
+        for i in range(1, n):
+            states[i] = states[i - 1]  # take state of previous generator
+            xoroshiro128p_jump(states, i)  # and jump forward 2**64 steps
+
+
+def init_xoroshiro128p_states(states, seed, subsequence_start=0, stream=0):
+    '''Initialize RNG states on the GPU for parallel generators.
+
+    This initializes the RNG states so that each state in the array corresponds
+    subsequences in the separated by 2**64 steps from each other in the main
+    sequence.  Therefore, as long no CUDA thread requests more than 2**64
+    random numbers, all of the RNG states produced by this function are
+    guaranteed to be independent.
+
+    The subsequence_start parameter can be used to advance the first RNG state
+    by a multiple of 2**64 steps.
+
+    :type states: 1D DeviceNDArray, dtype=xoroshiro128p_dtype
+    :param states: array of RNG states
+    :type seed: uint64
+    :param seed: starting seed for list of generators
+    '''
+
+    # Initialization on CPU is much faster than the GPU
+    states_cpu = np.empty(shape=states.shape, dtype=xoroshiro128p_dtype)
+    init_xoroshiro128p_states_cpu(states_cpu, seed, subsequence_start)
+
+    states.copy_to_device(states_cpu, stream=stream)
+
+
+def create_xoroshiro128p_states(n, seed, subsequence_start=0, stream=0):
+    '''Returns a new device array initialized for n random number generators.
+
+    This initializes the RNG states so that each state in the array corresponds
+    subsequences in the separated by 2**64 steps from each other in the main
+    sequence.  Therefore, as long no CUDA thread requests more than 2**64
+    random numbers, all of the RNG states produced by this function are
+    guaranteed to be independent.
+
+    The subsequence_start parameter can be used to advance the first RNG state
+    by a multiple of 2**64 steps.
+
+    :type n: int
+    :param n: number of RNG states to create
+    :type seed: uint64
+    :param seed: starting seed for list of generators
+    :type subsequence_start: uint64
+    :param subsequence_start:
+    :type stream: CUDA stream
+    :param stream: stream to run initialization kernel on
+    '''
+    states = cuda.device_array(n, dtype=xoroshiro128p_dtype, stream=stream)
+    init_xoroshiro128p_states(states, seed, subsequence_start, stream)
+    return states

numba_cuda/numba/cuda/simulator/__init__.py

@@ -0,0 +1,38 @@
+import sys
+
+from .api import *
+from .vector_types import vector_types
+from .reduction import Reduce
+from .cudadrv.devicearray import (device_array, device_array_like, pinned,
+                                  pinned_array, pinned_array_like,
+                                  mapped_array, to_device, auto_device)
+from .cudadrv import devicearray
+from .cudadrv.devices import require_context, gpus
+from .cudadrv.devices import get_context as current_context
+from .cudadrv.runtime import runtime
+from numba.core import config
+reduce = Reduce
+
+# Register simulated vector types as module level variables
+for name, svty in vector_types.items():
+    setattr(sys.modules[__name__], name, svty)
+    for alias in svty.aliases:
+        setattr(sys.modules[__name__], alias, svty)
+del vector_types, name, svty, alias
+
+# Ensure that any user code attempting to import cudadrv etc. gets the
+# simulator's version and not the real version if the simulator is enabled.
+if config.ENABLE_CUDASIM:
+    import sys
+    from numba.cuda.simulator import cudadrv
+    sys.modules['numba.cuda.cudadrv'] = cudadrv
+    sys.modules['numba.cuda.cudadrv.devicearray'] = cudadrv.devicearray
+    sys.modules['numba.cuda.cudadrv.devices'] = cudadrv.devices
+    sys.modules['numba.cuda.cudadrv.driver'] = cudadrv.driver
+    sys.modules['numba.cuda.cudadrv.runtime'] = cudadrv.runtime
+    sys.modules['numba.cuda.cudadrv.drvapi'] = cudadrv.drvapi
+    sys.modules['numba.cuda.cudadrv.error'] = cudadrv.error
+    sys.modules['numba.cuda.cudadrv.nvvm'] = cudadrv.nvvm
+
+    from . import compiler
+    sys.modules['numba.cuda.compiler'] = compiler