def test_unsupport_bitsize(self): ffi = self.get_ffi() with self.assertRaises(ValueError) as raises: cffi_support.map_type( ffi.typeof('error'), use_record_dtype=True, ) # When bitsize is provided, bitshift defaults to 0. self.assertEqual("field 'bits' has bitshift, this is not supported", str(raises.exception))
def __new__(meta, type_name, bases, attrs): if attrs.get('base', False): cls = super().__new__(meta, type_name, bases, attrs) return cls if 'members' in attrs: m = attrs['members'] cls_ffi = FFI() cls_ffi.cdef(build_udt_def(type_name, m)) t = core_ffi.new('GrB_Type*') _check(lib.GrB_Type_new(t, cls_ffi.sizeof(type_name))) cffi_support.map_type(cls_ffi.typeof(type_name), use_record_dtype=True) attrs['ffi'] = cls_ffi attrs['gb_type'] = t[0] attrs['C'] = type_name attrs['member_def'] = list(map(methodcaller('split'), m)) attrs['base_name'] = 'UDT' else: attrs['ffi'] = core_ffi gb_type_name = type_name cls = super().__new__(meta, type_name, bases, attrs) meta._gb_type_map[cls.gb_type] = cls cls.ptr = cls.C + '*' cls.zero = getattr(cls, 'zero', core_ffi.NULL) cls.one = getattr(cls, 'one', core_ffi.NULL) get = partial(getattr, lib) cls.base_name = base_name = getattr(cls, 'base_name', cls.__name__) cls.Monoid_new = get('GrB_Monoid_new_{}'.format(base_name)) cls.Matrix_setElement = get( 'GrB_Matrix_setElement_{}'.format(base_name)) cls.Matrix_extractElement = get( 'GrB_Matrix_extractElement_{}'.format(base_name)) cls.Matrix_extractTuples = get( 'GrB_Matrix_extractTuples_{}'.format(base_name)) cls.Matrix_assignScalar = get('GrB_Matrix_assign_{}'.format(base_name)) cls.Vector_setElement = get( 'GrB_Vector_setElement_{}'.format(base_name)) cls.Vector_extractElement = get( 'GrB_Vector_extractElement_{}'.format(base_name)) cls.Vector_extractTuples = get( 'GrB_Vector_extractTuples_{}'.format(base_name)) cls.Vector_assignScalar = get('GrB_Vector_assign_{}'.format(base_name)) cls.Scalar_setElement = get( 'GxB_Scalar_setElement_{}'.format(base_name)) cls.Scalar_extractElement = get( 'GxB_Scalar_extractElement_{}'.format(base_name)) return cls
def test_cfunc_callback(self): ffi = self.get_ffi() big_struct = ffi.typeof('big_struct') nb_big_struct = cffi_support.map_type(big_struct, use_record_dtype=True) sig = cffi_support.map_type(ffi.typeof('myfunc'), use_record_dtype=True) @njit def calc(base): tmp = 0 for i in range(base.size): elem = base[i] tmp += elem.i1 * elem.f2 / elem.d3 tmp += base[i].af4.sum() return tmp @cfunc(sig) def foo(ptr, n): base = carray(ptr, n) return calc(base) # Make data mydata = ffi.new('big_struct[3]') ptr = ffi.cast('big_struct*', mydata) for i in range(3): ptr[i].i1 = i * 123 ptr[i].f2 = i * 213 ptr[i].d3 = (1 + i) * 213 for j in range(9): ptr[i].af4[j] = i * 10 + j # Address of my data addr = int(ffi.cast('size_t', ptr)) got = foo.ctypes(addr, 3) # Make numpy array from the cffi buffer array = np.ndarray( buffer=ffi.buffer(mydata), dtype=numpy_support.as_dtype(nb_big_struct), shape=3, ) expect = calc(array) self.assertEqual(got, expect)
def test_type_parsing(self): ffi = self.get_ffi() # Check struct typedef big_struct = ffi.typeof('big_struct') nbtype = cffi_support.map_type(big_struct, use_record_dtype=True) self.assertIsInstance(nbtype, types.Record) self.assertEqual(len(nbtype), 4) self.assertEqual(nbtype.typeof('i1'), types.int32) self.assertEqual(nbtype.typeof('f2'), types.float32) self.assertEqual(nbtype.typeof('d3'), types.float64) self.assertEqual( nbtype.typeof('af4'), types.NestedArray(dtype=types.float32, shape=(9, )), ) # Check function typedef myfunc = ffi.typeof('myfunc') sig = cffi_support.map_type(myfunc, use_record_dtype=True) self.assertIsInstance(sig, typing.Signature) self.assertEqual(sig.args[0], types.CPointer(nbtype)) self.assertEqual(sig.args[1], types.uintp) self.assertEqual(sig.return_type, types.float64)
def __set_name__(self, cls, name): func_name = self.func.__name__ cls_name = cls.__name__ if cls.base_name == 'UDT': cls.ffi.cdef(build_binop_def(cls_name, func_name, boolean)) sig = cffi_support.map_type(cls.ffi.typeof( binop_name(cls_name, func_name)), use_record_dtype=True) else: sig = numba.void(cls.numba_t, cls.numba_t, cls.numba_t) jitfunc = jit(self.func, nopython=True) @cfunc(sig) def wrapper(z_, x_, y_): z = carray(z_, 1)[0] x = carray(x_, 1)[0] y = carray(y_, 1)[0] jitfunc(z, x, y) self.op = BinaryOp(func_name, cls_name, wrapper, cls, boolean) setattr(cls, func_name, self.op)
def test_type_map(self): signature = cffi_support.map_type(mod.ffi.typeof(mod.cffi_sin)) self.assertEqual(len(signature.args), 1) self.assertEqual(signature.args[0], types.double)
def __new__(meta, type_name, bases, attrs): if attrs.get("base", False): cls = super().__new__(meta, type_name, bases, attrs) return cls if "members" in attrs: m = attrs["members"] cls_ffi = FFI() cls_ffi.cdef(build_udt_def(type_name, m)) t = core_ffi.new("GrB_Type*") _check(lib.GrB_Type_new(t, cls_ffi.sizeof(type_name))) cffi_support.map_type(cls_ffi.typeof(type_name), use_record_dtype=True) attrs["ffi"] = cls_ffi attrs["gb_type"] = t[0] attrs["C"] = type_name attrs["member_def"] = list(map(methodcaller("split"), m)) attrs["base_name"] = "UDT" else: attrs["ffi"] = core_ffi gb_type_name = type_name cls = super().__new__(meta, type_name, bases, attrs) meta._gb_type_map[cls.gb_type] = cls meta._type_gb_map[cls] = cls.gb_type meta._gb_name_type_map[type_name] = cls meta._gb_name_type_map[cls.C] = cls cls.ptr = cls.C + "*" cls.zero = getattr(cls, "zero", core_ffi.NULL) cls.one = getattr(cls, "one", core_ffi.NULL) get = partial(getattr, lib) cls.base_name = base_name = getattr(cls, "base_name", cls.__name__) cls.prefix = prefix = getattr(cls, "prefix", "GrB") cls.Monoid_new = get("{}_Monoid_new_{}".format(prefix, base_name)) cls.Matrix_setElement = get("{}_Matrix_setElement_{}".format( prefix, base_name)) cls.Matrix_extractElement = get("{}_Matrix_extractElement_{}".format( prefix, base_name)) cls.Matrix_extractTuples = get("{}_Matrix_extractTuples_{}".format( prefix, base_name)) cls.Matrix_assignScalar = get("{}_Matrix_assign_{}".format( prefix, base_name)) cls.Matrix_apply_BinaryOp1st = get( "{}_Matrix_apply_BinaryOp1st_{}".format(prefix, base_name)) cls.Matrix_apply_BinaryOp2nd = get( "{}_Matrix_apply_BinaryOp2nd_{}".format(prefix, base_name)) cls.Vector_setElement = get("{}_Vector_setElement_{}".format( prefix, base_name)) cls.Vector_extractElement = get("{}_Vector_extractElement_{}".format( prefix, base_name)) cls.Vector_extractTuples = get("{}_Vector_extractTuples_{}".format( prefix, base_name)) cls.Vector_assignScalar = get("{}_Vector_assign_{}".format( prefix, base_name)) cls.Vector_apply_BinaryOp1st = get( "{}_Vector_apply_BinaryOp1st_{}".format(prefix, base_name)) cls.Vector_apply_BinaryOp2nd = get( "{}_Vector_apply_BinaryOp2nd_{}".format(prefix, base_name)) cls.Scalar_setElement = get( "GxB_Scalar_setElement_{}".format(base_name)) cls.Scalar_extractElement = get( "GxB_Scalar_extractElement_{}".format(base_name)) return cls
logger = logging.getLogger("sunode.basic") lib: Any = _cvodes.lib ffi: Any = _cvodes.ffi cffi_utils.register_module(_cvodes) cffi_utils.register_type( ffi.typeof("N_Vector").item, numba.types.Opaque("N_Vector") ) cffi_utils.register_type( ffi.typeof("SUNMatrix").item, numba.types.Opaque("SUNMatrix") ) _data_dtype = cffi_utils.map_type(ffi.typeof("realtype")) _index_dtype = cffi_utils.map_type(ffi.typeof("sunindextype")) data_dtype: Any = np.dtype(_data_dtype.name) index_dtype: Any = np.dtype(_index_dtype.name) CPointer = NewType("CPointer", int) ERRORS = {} for name in dir(lib): item = getattr(lib, name) if not isinstance(item, int): continue if name.startswith('CV_') or name.startswith('CVLS_') or name.startswith('SUN_NLS_'): ERRORS[item] = name
def __new__(meta, type_name, bases, attrs): if attrs.get("base", False): cls = super().__new__(meta, type_name, bases, attrs) return cls if "members" in attrs: # pragma: nocover m = attrs["members"] cls_ffi = FFI() cls_ffi.cdef(build_udt_def(type_name, m)) t = core_ffi.new("GrB_Type*") _check(lib.GrB_Type_new(t, cls_ffi.sizeof(type_name))) cffi_support.map_type(cls_ffi.typeof(type_name), use_record_dtype=True) attrs["_ffi"] = cls_ffi attrs["_gb_type"] = t[0] attrs["_c_type"] = type_name attrs["member_def"] = list(map(methodcaller("split"), m)) attrs["base_name"] = "UDT" else: attrs["_ffi"] = core_ffi _gb_type_name = type_name cls = super().__new__(meta, type_name, bases, attrs) meta._gb_type_map[cls._gb_type] = cls meta._type_gb_map[cls] = cls._gb_type meta._dtype_gb_map[cls._numpy_t] = cls meta._gb_name_type_map[type_name] = cls meta._gb_name_type_map[cls._c_type] = cls cls._ptr = cls._c_type + "*" cls.default_zero = getattr(cls, "default_zero", core_ffi.NULL) cls.default_one = getattr(cls, "default_one", core_ffi.NULL) def get(n): try: return getattr(lib, "GrB_" + n) except AttributeError: return getattr(lib, "GxB_" + n) cls._base_name = base_name = getattr(cls, "_base_name", cls.__name__) cls._Monoid_new = get(f"Monoid_new_{base_name}") cls._Matrix_setElement = get(f"Matrix_setElement_{base_name}") cls._Matrix_extractElement = get(f"Matrix_extractElement_{base_name}") cls._Matrix_extractTuples = get(f"Matrix_extractTuples_{base_name}") cls._Matrix_assignScalar = get(f"Matrix_assign_{base_name}") cls._Matrix_apply_BinaryOp1st = get( f"Matrix_apply_BinaryOp1st_{base_name}") cls._Matrix_apply_BinaryOp2nd = get( f"Matrix_apply_BinaryOp2nd_{base_name}") cls._Vector_setElement = get(f"Vector_setElement_{base_name}") cls._Vector_extractElement = get(f"Vector_extractElement_{base_name}") cls._Vector_extractTuples = get(f"Vector_extractTuples_{base_name}") cls._Vector_assignScalar = get(f"Vector_assign_{base_name}") cls._Vector_apply_BinaryOp1st = get( f"Vector_apply_BinaryOp1st_{base_name}") cls._Vector_apply_BinaryOp2nd = get( f"Vector_apply_BinaryOp2nd_{base_name}") cls._Scalar_setElement = get(f"Scalar_setElement_{base_name}") cls._Scalar_extractElement = get(f"Scalar_extractElement_{base_name}") cls._Vector_reduce = get(f"Vector_reduce_{base_name}") cls._Matrix_reduce = get(f"Matrix_reduce_{base_name}") return cls