def pack_array(builder, values):
n = len(values)
ty = values[0].type
ary = Constant.undef(Type.array(ty, n))
for i, v in enumerate(values):
ary = builder.insert_value(ary, v, i)
return ary
def _generic_array(context, builder, shape, dtype, symbol_name, addrspace):
elemcount = reduce(operator.mul, shape, 1)
lldtype = context.get_data_type(dtype)
laryty = Type.array(lldtype, elemcount)
if addrspace == target.SPIR_LOCAL_ADDRSPACE:
lmod = builder.module
# Create global variable in the requested address-space
gvmem = lmod.add_global_variable(laryty, symbol_name, addrspace)
if elemcount <= 0:
raise ValueError("array length <= 0")
else:
gvmem.linkage = lc.LINKAGE_INTERNAL
if dtype not in types.number_domain:
raise TypeError("unsupported type: %s" % dtype)
# Convert to generic address-space
dataptr = context.addrspacecast(builder, gvmem,
target.SPIR_GENERIC_ADDRSPACE)
else:
raise NotImplementedError("addrspace {addrspace}".format(**locals()))
return _make_array(context, builder, dataptr, dtype, shape)
def pack_array(builder, values):
n = len(values)
ty = values[0].type
ary = Constant.undef(Type.array(ty, n))
for i, v in enumerate(values):
ary = builder.insert_value(ary, v, i)
return ary
def _generic_array(context, builder, shape, dtype, symbol_name, addrspace):
elemcount = reduce(operator.mul, shape)
lldtype = context.get_data_type(dtype)
laryty = Type.array(lldtype, elemcount)
if addrspace == target.SPIR_LOCAL_ADDRSPACE:
lmod = builder.module
# Create global variable in the requested address-space
gvmem = lmod.add_global_variable(laryty, symbol_name, addrspace)
if elemcount <= 0:
raise ValueError("array length <= 0")
else:
gvmem.linkage = lc.LINKAGE_INTERNAL
if dtype not in types.number_domain:
raise TypeError("unsupported type: %s" % dtype)
# Convert to generic address-space
dataptr = context.addrspacecast(builder, gvmem,
target.SPIR_GENERIC_ADDRSPACE)
else:
raise NotImplementedError("addrspace {addrspace}".format(**locals()))
return _make_array(context, builder, dataptr, dtype, shape)
def pack_array(builder, values, ty=None):
"""
Pack an array of values. *ty* should be given if the array may be empty,
in which case the type can't be inferred from the values.
"""
n = len(values)
if ty is None:
ty = values[0].type
ary = Constant.undef(Type.array(ty, n))
for i, v in enumerate(values):
ary = builder.insert_value(ary, v, i)
return ary
def pack_array(builder, values, ty=None):
"""
Pack an array of values. *ty* should be given if the array may be empty,
in which case the type can't be inferred from the values.
"""
n = len(values)
if ty is None:
ty = values[0].type
ary = Constant.undef(Type.array(ty, n))
for i, v in enumerate(values):
ary = builder.insert_value(ary, v, i)
return ary
def _generic_array(context,
builder,
shape,
dtype,
symbol_name,
addrspace,
can_dynsized=False):
elemcount = reduce(operator.mul, shape)
lldtype = context.get_data_type(dtype)
laryty = Type.array(lldtype, elemcount)
if addrspace == nvvm.ADDRSPACE_LOCAL:
# Special case local addrespace allocation to use alloca
# NVVM is smart enough to only use local memory if no register is
# available
dataptr = cgutils.alloca_once(builder, laryty, name=symbol_name)
else:
lmod = builder.module
# Create global variable in the requested address-space
gvmem = lmod.add_global_variable(laryty, symbol_name, addrspace)
# Specify alignment to avoid misalignment bug
align = context.get_abi_sizeof(lldtype)
# Alignment is required to be a power of 2 for shared memory. If it is
# not a power of 2 (e.g. for a Record array) then round up accordingly.
gvmem.align = 1 << (align - 1).bit_length()
if elemcount <= 0:
if can_dynsized: # dynamic shared memory
gvmem.linkage = lc.LINKAGE_EXTERNAL
else:
raise ValueError("array length <= 0")
else:
## Comment out the following line to workaround a NVVM bug
## which generates a invalid symbol name when the linkage
## is internal and in some situation.
## See _get_unique_smem_id()
# gvmem.linkage = lc.LINKAGE_INTERNAL
gvmem.initializer = lc.Constant.undef(laryty)
other_supported_type = isinstance(dtype, (types.Record, types.Boolean))
if dtype not in types.number_domain and not other_supported_type:
raise TypeError("unsupported type: %s" % dtype)
# Convert to generic address-space
conv = nvvmutils.insert_addrspace_conv(lmod, Type.int(8), addrspace)
addrspaceptr = gvmem.bitcast(Type.pointer(Type.int(8), addrspace))
dataptr = builder.call(conv, [addrspaceptr])
return _make_array(context, builder, dataptr, dtype, shape)
def _generic_array(context,
builder,
shape,
dtype,
symbol_name,
addrspace,
can_dynsized=False):
elemcount = reduce(operator.mul, shape)
lldtype = context.get_data_type(dtype)
laryty = Type.array(lldtype, elemcount)
if addrspace == nvvm.ADDRSPACE_LOCAL:
# Special case local addrespace allocation to use alloca
# NVVM is smart enough to only use local memory if no register is
# available
dataptr = builder.alloca(laryty, name=symbol_name)
else:
lmod = cgutils.get_module(builder)
# Create global variable in the requested address-space
gvmem = lmod.add_global_variable(laryty, symbol_name, addrspace)
if elemcount <= 0:
if can_dynsized: # dynamic shared memory
gvmem.linkage = lc.LINKAGE_EXTERNAL
else:
raise ValueError("array length <= 0")
else:
## Comment out the following line to workaround a NVVM bug
## which generates a invalid symbol name when the linkage
## is internal and in some situation.
# gvmem.linkage = lc.LINKAGE_INTERNAL
gvmem.initializer = lc.Constant.undef(laryty)
if dtype not in types.number_domain:
raise TypeError("unsupported type: %s" % dtype)
# Convert to generic address-space
conv = nvvmutils.insert_addrspace_conv(lmod, Type.int(8), addrspace)
addrspaceptr = gvmem.bitcast(Type.pointer(Type.int(8), addrspace))
dataptr = builder.call(conv, [addrspaceptr])
return _make_array(context, builder, dataptr, dtype, shape)
def _generic_array(context, builder, shape, dtype, symbol_name, addrspace,
can_dynsized=False):
elemcount = reduce(operator.mul, shape)
lldtype = context.get_data_type(dtype)
laryty = Type.array(lldtype, elemcount)
if addrspace == nvvm.ADDRSPACE_LOCAL:
# Special case local addrespace allocation to use alloca
# NVVM is smart enough to only use local memory if no register is
# available
dataptr = cgutils.alloca_once(builder, laryty, name=symbol_name)
else:
lmod = builder.module
# Create global variable in the requested address-space
gvmem = lmod.add_global_variable(laryty, symbol_name, addrspace)
# Specify alignment to avoid misalignment bug
gvmem.align = context.get_abi_sizeof(lldtype)
if elemcount <= 0:
if can_dynsized: # dynamic shared memory
gvmem.linkage = lc.LINKAGE_EXTERNAL
else:
raise ValueError("array length <= 0")
else:
## Comment out the following line to workaround a NVVM bug
## which generates a invalid symbol name when the linkage
## is internal and in some situation.
## See _get_unique_smem_id()
# gvmem.linkage = lc.LINKAGE_INTERNAL
gvmem.initializer = lc.Constant.undef(laryty)
if dtype not in types.number_domain:
raise TypeError("unsupported type: %s" % dtype)
# Convert to generic address-space
conv = nvvmutils.insert_addrspace_conv(lmod, Type.int(8), addrspace)
addrspaceptr = gvmem.bitcast(Type.pointer(Type.int(8), addrspace))
dataptr = builder.call(conv, [addrspaceptr])
return _make_array(context, builder, dataptr, dtype, shape)
def _generic_array(context, builder, shape, dtype, symbol_name, addrspace):
"""
This function allows us to create generic arrays in different
address spaces.
"""
elemcount = reduce(operator.mul, shape)
lldtype = context.get_data_type(dtype)
laryty = Type.array(lldtype, elemcount)
if addrspace == address_space.LOCAL:
lmod = builder.module
# Create global variable in the requested address-space
gvmem = lmod.add_global_variable(laryty, symbol_name, addrspace)
if elemcount <= 0:
raise ValueError("array length <= 0")
else:
gvmem.linkage = lc.LINKAGE_INTERNAL
if dtype not in types.number_domain:
raise TypeError("unsupported type: %s" % dtype)
elif addrspace == address_space.PRIVATE:
gvmem = cgutils.alloca_once(builder, laryty, name=symbol_name)
else:
raise NotImplementedError("addrspace {addrspace}".format(**locals()))
# We need to add the addrspace to _make_array() function call as we want
# the variable containing the reference of the memory to retain the
# original address space of that memory. Before, we were casting the
# memories allocated in local address space to global address space. This
# approach does not let us identify the original address space of a memory
# down the line.
return _make_array(context,
builder,
gvmem,
dtype,
shape,
addrspace=addrspace)
def get_data_type(self, ty):
"""
Get a LLVM data representation of the Numba type *ty* that is safe
for storage. Record data are stored as byte array.
The return value is a llvmlite.ir.Type object, or None if the type
is an opaque pointer (???).
"""
try:
fac = type_registry.match(ty)
except KeyError:
pass
else:
return fac(self, ty)
if (isinstance(ty, types.Dummy) or isinstance(ty, types.Module)
or isinstance(ty, types.Function)
or isinstance(ty, types.Dispatcher)
or isinstance(ty, types.Object)
or isinstance(ty, types.Macro)):
return PYOBJECT
elif isinstance(ty, types.CPointer):
dty = self.get_data_type(ty.dtype)
return Type.pointer(dty)
elif isinstance(ty, types.Optional):
return self.get_struct_type(self.make_optional(ty))
elif isinstance(ty, types.Array):
return self.get_struct_type(self.make_array(ty))
elif isinstance(ty, types.UniTuple):
dty = self.get_value_type(ty.dtype)
return Type.array(dty, ty.count)
elif isinstance(ty, types.Tuple):
dtys = [self.get_value_type(t) for t in ty]
return Type.struct(dtys)
elif isinstance(ty, types.Record):
# Record are represented as byte array
return Type.struct([Type.array(Type.int(8), ty.size)])
elif isinstance(ty, types.UnicodeCharSeq):
charty = Type.int(numpy_support.sizeof_unicode_char * 8)
return Type.struct([Type.array(charty, ty.count)])
elif isinstance(ty, types.CharSeq):
charty = Type.int(8)
return Type.struct([Type.array(charty, ty.count)])
elif ty in STRUCT_TYPES:
return self.get_struct_type(STRUCT_TYPES[ty])
else:
try:
impl = struct_registry.match(ty)
except KeyError:
pass
else:
return self.get_struct_type(impl(ty))
if isinstance(ty, types.Pair):
pairty = self.make_pair(ty.first_type, ty.second_type)
return self.get_struct_type(pairty)
else:
return LTYPEMAP[ty]
def get_data_type(self, ty):
"""
Get a LLVM data representation of the Numba type *ty* that is safe
for storage. Record data are stored as byte array.
The return value is a llvmlite.ir.Type object, or None if the type
is an opaque pointer (???).
"""
try:
fac = type_registry.match(ty)
except KeyError:
pass
else:
return fac(self, ty)
if (
isinstance(ty, types.Dummy)
or isinstance(ty, types.Module)
or isinstance(ty, types.Function)
or isinstance(ty, types.Dispatcher)
or isinstance(ty, types.Object)
or isinstance(ty, types.Macro)
):
return PYOBJECT
elif isinstance(ty, types.CPointer):
dty = self.get_data_type(ty.dtype)
return Type.pointer(dty)
elif isinstance(ty, types.Optional):
return self.get_struct_type(self.make_optional(ty))
elif isinstance(ty, types.Array):
return self.get_struct_type(self.make_array(ty))
elif isinstance(ty, types.UniTuple):
dty = self.get_value_type(ty.dtype)
return Type.array(dty, ty.count)
elif isinstance(ty, types.Tuple):
dtys = [self.get_value_type(t) for t in ty]
return Type.struct(dtys)
elif isinstance(ty, types.Record):
# Record are represented as byte array
return Type.struct([Type.array(Type.int(8), ty.size)])
elif isinstance(ty, types.UnicodeCharSeq):
charty = Type.int(numpy_support.sizeof_unicode_char * 8)
return Type.struct([Type.array(charty, ty.count)])
elif isinstance(ty, types.CharSeq):
charty = Type.int(8)
return Type.struct([Type.array(charty, ty.count)])
elif ty in STRUCT_TYPES:
return self.get_struct_type(STRUCT_TYPES[ty])
else:
try:
impl = struct_registry.match(ty)
except KeyError:
pass
else:
return self.get_struct_type(impl(ty))
if isinstance(ty, types.Pair):
pairty = self.make_pair(ty.first_type, ty.second_type)
return self.get_struct_type(pairty)
else:
return LTYPEMAP[ty]
def _generic_array(context,
builder,
shape,
dtype,
symbol_name,
addrspace,
can_dynsized=False):
elemcount = reduce(operator.mul, shape, 1)
# Check for valid shape for this type of allocation.
# Only 1d arrays can be dynamic.
dynamic_smem = elemcount <= 0 and can_dynsized and len(shape) == 1
if elemcount <= 0 and not dynamic_smem:
raise ValueError("array length <= 0")
# Check that we support the requested dtype
other_supported_type = isinstance(dtype, (types.Record, types.Boolean))
if dtype not in types.number_domain and not other_supported_type:
raise TypeError("unsupported type: %s" % dtype)
lldtype = context.get_data_type(dtype)
laryty = Type.array(lldtype, elemcount)
if addrspace == nvvm.ADDRSPACE_LOCAL:
# Special case local address space allocation to use alloca
# NVVM is smart enough to only use local memory if no register is
# available
dataptr = cgutils.alloca_once(builder, laryty, name=symbol_name)
else:
lmod = builder.module
# Create global variable in the requested address space
gvmem = lmod.add_global_variable(laryty, symbol_name, addrspace)
# Specify alignment to avoid misalignment bug
align = context.get_abi_sizeof(lldtype)
# Alignment is required to be a power of 2 for shared memory. If it is
# not a power of 2 (e.g. for a Record array) then round up accordingly.
gvmem.align = 1 << (align - 1).bit_length()
if dynamic_smem:
gvmem.linkage = lc.LINKAGE_EXTERNAL
else:
## Comment out the following line to workaround a NVVM bug
## which generates a invalid symbol name when the linkage
## is internal and in some situation.
## See _get_unique_smem_id()
# gvmem.linkage = lc.LINKAGE_INTERNAL
gvmem.initializer = lc.Constant.undef(laryty)
# Convert to generic address-space
conv = nvvmutils.insert_addrspace_conv(lmod, Type.int(8), addrspace)
addrspaceptr = gvmem.bitcast(Type.pointer(Type.int(8), addrspace))
dataptr = builder.call(conv, [addrspaceptr])
targetdata = _get_target_data(context)
lldtype = context.get_data_type(dtype)
itemsize = lldtype.get_abi_size(targetdata)
# Compute strides
laststride = itemsize
rstrides = []
for i, lastsize in enumerate(reversed(shape)):
rstrides.append(laststride)
laststride *= lastsize
strides = [s for s in reversed(rstrides)]
kstrides = [context.get_constant(types.intp, s) for s in strides]
# Compute shape
if dynamic_smem:
# Compute the shape based on the dynamic shared memory configuration.
# Unfortunately NVVM does not provide an intrinsic for the
# %dynamic_smem_size register, so we must read it using inline
# assembly.
get_dynshared_size = InlineAsm.get(Type.function(Type.int(), []),
"mov.u32 $0, %dynamic_smem_size;",
'=r',
side_effect=True)
dynsmem_size = builder.zext(builder.call(get_dynshared_size, []),
Type.int(width=64))
# Only 1-D dynamic shared memory is supported so the following is a
# sufficient construction of the shape
kitemsize = context.get_constant(types.intp, itemsize)
kshape = [builder.udiv(dynsmem_size, kitemsize)]
else:
kshape = [context.get_constant(types.intp, s) for s in shape]
# Create array object
ndim = len(shape)
aryty = types.Array(dtype=dtype, ndim=ndim, layout='C')
ary = context.make_array(aryty)(context, builder)
context.populate_array(ary,
data=builder.bitcast(dataptr, ary.data.type),
shape=kshape,
strides=kstrides,
itemsize=context.get_constant(types.intp, itemsize),
meminfo=None)
return ary._getvalue()
def __init__(self, _type, size):
"""Initialize the instance."""
super(MiddleIrTypeArray, self).__init__(
Type.array(_type._ptr, size))
self.type = _type
