def box_lsttype(typ, val, c):
context = c.context
builder = c.builder
# XXX deduplicate
ctor = cgutils.create_struct_proxy(typ)
lstruct = ctor(context, builder, value=val)
# Returns the plain MemInfo
boxed_meminfo = c.box(
types.MemInfoPointer(types.voidptr),
lstruct.meminfo,
)
modname = c.context.insert_const_string(
c.builder.module, 'numba.typed.typedlist',
)
typedlist_mod = c.pyapi.import_module_noblock(modname)
fmp_fn = c.pyapi.object_getattr_string(typedlist_mod, '_from_meminfo_ptr')
lsttype_obj = c.pyapi.unserialize(c.pyapi.serialize_object(typ))
result_var = builder.alloca(c.pyapi.pyobj)
builder.store(cgutils.get_null_value(c.pyapi.pyobj), result_var)
with builder.if_then(cgutils.is_not_null(builder, lsttype_obj)):
res = c.pyapi.call_function_objargs(
fmp_fn, (boxed_meminfo, lsttype_obj),
)
c.pyapi.decref(fmp_fn)
c.pyapi.decref(typedlist_mod)
c.pyapi.decref(boxed_meminfo)
builder.store(res, result_var)
return builder.load(result_var)
def __init__(self, dmm, fe_type):
# ndim = fe_type.ndim
members = [
("data", types.CPointer(fe_type.dtype)),
("meminfo", types.MemInfoPointer(fe_type.dtype)),
]
super(ArrayCTypesModel, self).__init__(dmm, fe_type, members)
def allocator_MyArray(typingctx, allocsize, align):
def impl(context, builder, sig, args):
context.nrt._require_nrt()
size, align = args
mod = builder.module
u32 = ir.IntType(32)
voidptr = cgutils.voidptr_t
get_alloc_fnty = ir.FunctionType(voidptr, ())
get_alloc_fn = cgutils.get_or_insert_function(
mod, get_alloc_fnty, name="_nrt_get_sample_external_allocator")
ext_alloc = builder.call(get_alloc_fn, ())
fnty = ir.FunctionType(voidptr, [cgutils.intp_t, u32, voidptr])
fn = cgutils.get_or_insert_function(
mod, fnty, name="NRT_MemInfo_alloc_safe_aligned_external")
fn.return_value.add_attribute("noalias")
if isinstance(align, builtins.int):
align = context.get_constant(types.uint32, align)
else:
assert align.type == u32, "align must be a uint32"
call = builder.call(fn, [size, align, ext_alloc])
call.name = "allocate_MyArray"
return call
mip = types.MemInfoPointer(types.voidptr) # return untyped pointer
sig = typing.signature(mip, allocsize, align)
return sig, impl
def unbox_listtype(typ, val, c):
context = c.context
builder = c.builder
miptr = c.pyapi.object_getattr_string(val, '_opaque')
native = c.unbox(types.MemInfoPointer(types.voidptr), miptr)
mi = native.value
ctor = cgutils.create_struct_proxy(typ)
lstruct = ctor(context, builder)
data_pointer = context.nrt.meminfo_data(builder, mi)
data_pointer = builder.bitcast(
data_pointer,
listobject.ll_list_type.as_pointer(),
)
lstruct.data = builder.load(data_pointer)
lstruct.meminfo = mi
lstobj = lstruct._getvalue()
c.pyapi.decref(miptr)
return NativeValue(lstobj)
def box_dicttype(typ, val, c):
context = c.context
builder = c.builder
# XXX deduplicate
ctor = cgutils.create_struct_proxy(typ)
dstruct = ctor(context, builder, value=val)
# Returns the plain MemInfo
boxed_meminfo = c.box(
types.MemInfoPointer(types.voidptr),
dstruct.meminfo,
)
modname = c.context.insert_const_string(
c.builder.module,
'numba.typed.typeddict',
)
typeddict_mod = c.pyapi.import_module_noblock(modname)
fmp_fn = c.pyapi.object_getattr_string(typeddict_mod, '_from_meminfo_ptr')
dicttype_obj = c.pyapi.unserialize(c.pyapi.serialize_object(typ))
res = c.pyapi.call_function_objargs(fmp_fn, (boxed_meminfo, dicttype_obj))
c.pyapi.decref(fmp_fn)
c.pyapi.decref(typeddict_mod)
c.pyapi.decref(boxed_meminfo)
return res
def unbox_listtype(typ, val, c):
context = c.context
builder = c.builder
# Check that `type(val) is Dict`
list_type = c.pyapi.unserialize(c.pyapi.serialize_object(List))
valtype = c.pyapi.object_type(val)
same_type = builder.icmp_unsigned("==", valtype, list_type)
with c.builder.if_else(same_type) as (then, orelse):
with then:
miptr = c.pyapi.object_getattr_string(val, '_opaque')
native = c.unbox(types.MemInfoPointer(types.voidptr), miptr)
mi = native.value
ctor = cgutils.create_struct_proxy(typ)
lstruct = ctor(context, builder)
data_pointer = context.nrt.meminfo_data(builder, mi)
data_pointer = builder.bitcast(
data_pointer,
listobject.ll_list_type.as_pointer(),
)
lstruct.data = builder.load(data_pointer)
lstruct.meminfo = mi
lstobj = lstruct._getvalue()
c.pyapi.decref(miptr)
bb_unboxed = c.builder.basic_block
with orelse:
# Raise error on incorrect type
c.pyapi.err_format(
"PyExc_TypeError",
"can't unbox a %S as a %S",
valtype,
list_type,
)
bb_else = c.builder.basic_block
# Phi nodes to gather the output
lstobj_res = c.builder.phi(lstobj.type)
is_error_res = c.builder.phi(cgutils.bool_t)
lstobj_res.add_incoming(lstobj, bb_unboxed)
lstobj_res.add_incoming(lstobj.type(None), bb_else)
is_error_res.add_incoming(cgutils.false_bit, bb_unboxed)
is_error_res.add_incoming(cgutils.true_bit, bb_else)
# cleanup
c.pyapi.decref(list_type)
c.pyapi.decref(valtype)
return NativeValue(lstobj_res, is_error=is_error_res)
def unbox_dicttype(typ, val, c):
context = c.context
# Check that `type(val) is Dict`
dict_type = c.pyapi.unserialize(c.pyapi.serialize_object(Dict))
valtype = c.pyapi.object_type(val)
same_type = c.builder.icmp_unsigned("==", valtype, dict_type)
with c.builder.if_else(same_type) as (then, orelse):
with then:
miptr = c.pyapi.object_getattr_string(val, '_opaque')
mip_type = types.MemInfoPointer(types.voidptr)
native = c.unbox(mip_type, miptr)
mi = native.value
argtypes = mip_type, typeof(typ)
def convert(mi, typ):
return dictobject._from_meminfo(mi, typ)
sig = signature(typ, *argtypes)
nil_typeref = context.get_constant_null(argtypes[1])
args = (mi, nil_typeref)
is_error, dctobj = c.pyapi.call_jit_code(convert, sig, args)
# decref here because we are stealing a reference.
c.context.nrt.decref(c.builder, typ, dctobj)
c.pyapi.decref(miptr)
bb_unboxed = c.builder.basic_block
with orelse:
# Raise error on incorrect type
c.pyapi.err_format(
"PyExc_TypeError",
"can't unbox a %S as a %S",
valtype,
dict_type,
)
bb_else = c.builder.basic_block
# Phi nodes to gather the output
dctobj_res = c.builder.phi(dctobj.type)
is_error_res = c.builder.phi(is_error.type)
dctobj_res.add_incoming(dctobj, bb_unboxed)
dctobj_res.add_incoming(dctobj.type(None), bb_else)
is_error_res.add_incoming(is_error, bb_unboxed)
is_error_res.add_incoming(cgutils.true_bit, bb_else)
# cleanup
c.pyapi.decref(dict_type)
c.pyapi.decref(valtype)
return NativeValue(dctobj_res, is_error=is_error_res)
def __init__(self, dmm, fe_type):
payload_type = types.ListPayload(fe_type.container)
members = [
# The meminfo data points to a ListPayload (shared with the
# original list object)
('meminfo', types.MemInfoPointer(payload_type)),
('index', types.EphemeralPointer(types.intp)),
]
super(ListIterModel, self).__init__(dmm, fe_type, members)
def __init__(self, dmm, fe_type):
payload_type = types.SetPayload(fe_type)
members = [
# The meminfo data points to a SetPayload
('meminfo', types.MemInfoPointer(payload_type)),
# This member is only used only for reflected sets
('parent', types.pyobject),
]
super(SetModel, self).__init__(dmm, fe_type, members)
def __init__(self, dmm, fe_type):
payload_type = types.ListPayload(fe_type)
members = [
# The meminfo data points to a ListPayload
("meminfo", types.MemInfoPointer(payload_type)),
# This member is only used only for reflected lists
("parent", types.pyobject),
]
super(ListModel, self).__init__(dmm, fe_type, members)
def __init__(self, dmm, fe_type):
payload_type = types.SetPayload(fe_type.container)
members = [
# The meminfo data points to a SetPayload (shared with the
# original set object)
('meminfo', types.MemInfoPointer(payload_type)),
# The index into the entries table
('index', types.EphemeralPointer(types.intp)),
]
super(SetIterModel, self).__init__(dmm, fe_type, members)
def codegen(context, builder, signature, args):
_, meminfo = args
st = cgutils.create_struct_proxy(inst_type)(context, builder)
st.meminfo = meminfo
#NOTE: Fixes sefault but not sure about it's lifecycle (i.e. watch out for memleaks)
context.nrt.incref(builder, types.MemInfoPointer(types.voidptr),
meminfo)
return st._getvalue()
def __init__(self, dmm, fe_type):
ndim = fe_type.ndim
members = [
("meminfo", types.MemInfoPointer(fe_type.dtype)),
("parent", types.pyobject),
("nitems", types.intp),
("itemsize", types.intp),
("data", types.CPointer(fe_type.dtype)),
("shape", types.UniTuple(types.intp, ndim)),
("strides", types.UniTuple(types.intp, ndim)),
]
super(ArrayModel, self).__init__(dmm, fe_type, members)
def __init__(self, dmm, fe_typ):
cls_data_ty = types.ClassDataType(fe_typ)
# MemInfoPointer uses the `dtype` attribute to traverse for nested
# NRT MemInfo. Since we handle nested NRT MemInfo ourselves,
# we will replace provide MemInfoPointer with an opaque type
# so that it does not raise exception for nested meminfo.
dtype = types.Opaque('Opaque.' + str(cls_data_ty))
members = [
('meminfo', types.MemInfoPointer(dtype)),
('data', types.CPointer(cls_data_ty)),
]
super(InstanceModel, self).__init__(dmm, fe_typ, members)
def __init__(self, dmm, fe_type):
ndim = fe_type.ndim
members = [
('meminfo', types.MemInfoPointer(fe_type.dtype)),
('parent', types.pyobject),
('nitems', types.intp),
('itemsize', types.intp),
('data', types.CPointer(fe_type.dtype)),
('shape', types.UniTuple(types.intp, ndim)),
('strides', types.UniTuple(types.intp, ndim)),
]
super(ArrayModel, self).__init__(dmm, fe_type, members)
def unbox_struct_ref(typ, obj, c):
mi_obj = c.pyapi.object_getattr_string(obj, "_meminfo")
mip_type = types.MemInfoPointer(types.voidptr)
mi = c.unbox(mip_type, mi_obj).value
utils = _Utils(c.context, c.builder, typ)
struct_ref = utils.new_struct_ref(mi)
out = struct_ref._getvalue()
c.pyapi.decref(mi_obj)
return NativeValue(out)
def box_struct_ref(typ, val, c):
"""
Convert a raw pointer to a Python int.
"""
utils = _Utils(c.context, c.builder, typ)
struct_ref = utils.get_struct_ref(val)
meminfo = struct_ref.meminfo
mip_type = types.MemInfoPointer(types.voidptr)
boxed_meminfo = c.box(mip_type, meminfo)
ctor_pyfunc = c.pyapi.unserialize(c.pyapi.serialize_object(obj_ctor))
ty_pyobj = c.pyapi.unserialize(c.pyapi.serialize_object(typ))
res = c.pyapi.call_function_objargs(
ctor_pyfunc,
[ty_pyobj, boxed_meminfo],
)
c.pyapi.decref(ctor_pyfunc)
c.pyapi.decref(ty_pyobj)
c.pyapi.decref(boxed_meminfo)
return res
def box_untyped_structref(typ, val, c):
print("HERE", typ)
meminfo = val.meminfo
typ = val.dtype
# utils = _Utils(c.context, c.builder, typ)
# struct_ref = utils.get_struct_ref(val)
# meminfo = struct_ref.meminfo
mip_type = types.MemInfoPointer(types.voidptr)
boxed_meminfo = c.box(mip_type, meminfo)
ctor_pyfunc = c.pyapi.unserialize(c.pyapi.serialize_object(obj_ctor))
ty_pyobj = c.pyapi.unserialize(c.pyapi.serialize_object(typ))
res = c.pyapi.call_function_objargs(
ctor_pyfunc,
[ty_pyobj, boxed_meminfo],
)
c.pyapi.decref(ctor_pyfunc)
c.pyapi.decref(ty_pyobj)
c.pyapi.decref(boxed_meminfo)
return res
def unbox_dicttype(typ, val, c):
context = c.context
miptr = c.pyapi.object_getattr_string(val, '_opaque')
mip_type = types.MemInfoPointer(types.voidptr)
native = c.unbox(mip_type, miptr)
mi = native.value
argtypes = mip_type, typeof(typ)
def convert(mi, typ):
return dictobject._from_meminfo(mi, typ)
sig = signature(typ, *argtypes)
nil_typeref = context.get_constant_null(argtypes[1])
args = (mi, nil_typeref)
is_error, dctobj = c.pyapi.call_jit_code(convert, sig, args)
# decref here because we are stealing a reference.
c.context.nrt.decref(c.builder, typ, dctobj)
c.pyapi.decref(miptr)
return NativeValue(dctobj, is_error=is_error)
def __init__(self, dmm, fe_type):
members = [('bit_generator', _bit_gen_type),
('meminfo', types.MemInfoPointer(types.voidptr)),
('parent', types.pyobject)]
super(NumPyRandomGeneratorTypeModel,
self).__init__(dmm, fe_type, members)
def __init__(self, dmm, fe_typ):
dtype = fe_typ.get_data_type()
members = [
("meminfo", types.MemInfoPointer(dtype)),
]
super().__init__(dmm, fe_typ, members)
def typeof_meminfo(val, c):
return types.MemInfoPointer(types.voidptr)
_cast,
_nonoptional,
_get_incref_decref,
_container_get_data,
_container_get_meminfo,
)
from numba.cpython import listobj
ll_list_type = cgutils.voidptr_t
ll_listiter_type = cgutils.voidptr_t
ll_voidptr_type = cgutils.voidptr_t
ll_status = cgutils.int32_t
ll_ssize_t = cgutils.intp_t
ll_bytes = cgutils.voidptr_t
_meminfo_listptr = types.MemInfoPointer(types.voidptr)
INDEXTY = types.intp
index_types = types.integer_domain
DEFAULT_ALLOCATED = 0
@register_model(ListType)
class ListModel(models.StructModel):
def __init__(self, dmm, fe_type):
members = [
('meminfo', _meminfo_listptr),
('data', types.voidptr), # ptr to the C list
]
_sentry_safe_cast_default,
_get_incref_decref,
_get_equal,
_container_get_data,
)
from numba.cpython.unicode import make_string_from_constant
ll_dict_type = cgutils.voidptr_t
ll_dictiter_type = cgutils.voidptr_t
ll_voidptr_type = cgutils.voidptr_t
ll_status = cgutils.int32_t
ll_ssize_t = cgutils.intp_t
ll_hash = ll_ssize_t
ll_bytes = cgutils.voidptr_t
_meminfo_dictptr = types.MemInfoPointer(types.voidptr)
# The following enums must match _dictobject.c
class DKIX(IntEnum):
"""Special return value of dict lookup.
"""
EMPTY = -1
class Status(IntEnum):
"""Status code for other dict operations.
"""
OK = 0
OK_REPLACED = 1
