def test_dylib_symbols(self): llvm.add_symbol("__xyzzy", 1234) llvm.add_symbol("__xyzzy", 5678) addr = llvm.address_of_symbol("__xyzzy") self.assertEqual(addr, 5678) addr = llvm.address_of_symbol("__foobar") self.assertIs(addr, None)
def initialize(self, ctx): """Initializes the NRT Must be called before any actual call to the NRT API. Safe to be called multiple times. """ if self._init: # Already initialized return # Register globals into the system for py_name in _nrt.c_helpers: c_name = "NRT_" + py_name c_address = _nrt.c_helpers[py_name] ll.add_symbol(c_name, c_address) # Compile atomic operations self._library = nrtdynmod.compile_nrt_functions(ctx) self._ptr_inc = self._library.get_pointer_to_function("nrt_atomic_add") self._ptr_dec = self._library.get_pointer_to_function("nrt_atomic_sub") self._ptr_cas = self._library.get_pointer_to_function("nrt_atomic_cas") # Install atomic ops to NRT _nrt.memsys_set_atomic_inc_dec(self._ptr_inc, self._ptr_dec) _nrt.memsys_set_atomic_cas(self._ptr_cas) self._init = True
def _do_install(self, context): is32bit = utils.MACHINE_BITS == 32 c_helpers = _helperlib.c_helpers for name in ['cpow', 'sdiv', 'srem', 'udiv', 'urem']: ll.add_symbol("numba.math.%s" % name, c_helpers[name]) if sys.platform.startswith('win32') and is32bit: # For Windows XP _ftol2 is not defined, we will just use # _ftol as a replacement. # On Windows 7, this is not necessary but will work anyway. ftol = _get_msvcrt_symbol("_ftol") _add_missing_symbol("_ftol2", ftol) elif sys.platform.startswith('linux') and is32bit: _add_missing_symbol("__fixunsdfdi", c_helpers["fptoui"]) _add_missing_symbol("__fixunssfdi", c_helpers["fptouif"]) if is32bit: # Make the library immortal self._multi3_lib = compile_multi3(context) ptr = self._multi3_lib.get_pointer_to_function("multi3") assert ptr _add_missing_symbol("__multi3", ptr) # List available C-math for fname in intrinsics.INTR_MATH: # Force binding from CPython's C runtime library. # (under Windows, different versions of the C runtime can # be loaded at the same time, for example msvcrt100 by # CPython and msvcrt120 by LLVM) ll.add_symbol(fname, c_helpers[fname])
def _do_install(self): is32bit = utils.MACHINE_BITS == 32 c_helpers = _helperlib.c_helpers for name in ['cpow', 'sdiv', 'srem', 'udiv', 'urem']: ll.add_symbol("numba.math.%s" % name, c_helpers[name]) if sys.platform.startswith('win32') and is32bit: # For Windows XP _ftol2 is not defined, we will just use # _ftol as a replacement. # On Windows 7, this is not necessary but will work anyway. ftol = _get_msvcrt_symbol("_ftol") _add_missing_symbol("_ftol2", ftol) elif sys.platform.startswith('linux') and is32bit: _add_missing_symbol("__fixunsdfdi", c_helpers["fptoui"]) _add_missing_symbol("__fixunssfdi", c_helpers["fptouif"]) if is32bit: _add_missing_symbol("__multi3", c_helpers["multi3"]) # List available C-math for fname in intrinsics.INTR_MATH: # Force binding from CPython's C runtime library. # (under Windows, different versions of the C runtime can # be loaded at the same time, for example msvcrt100 by # CPython and msvcrt120 by LLVM) ll.add_symbol(fname, c_helpers[fname])
def _do_install(self, context): is32bit = utils.MACHINE_BITS == 32 c_helpers = _helperlib.c_helpers if sys.platform.startswith("win32") and is32bit: # For Windows XP _ftol2 is not defined, we will just use # _ftol as a replacement. # On Windows 7, this is not necessary but will work anyway. ftol = _get_msvcrt_symbol("_ftol") _add_missing_symbol("_ftol2", ftol) elif sys.platform.startswith("linux") and is32bit: _add_missing_symbol("__fixunsdfdi", c_helpers["fptoui"]) _add_missing_symbol("__fixunssfdi", c_helpers["fptouif"]) if is32bit: # Make the library immortal self._multi3_lib = compile_multi3(context) ptr = self._multi3_lib.get_pointer_to_function("multi3") assert ptr _add_missing_symbol("__multi3", ptr) # List available C-math for fname in intrinsics.INTR_MATH: # Force binding from CPython's C runtime library. # (under Windows, different versions of the C runtime can # be loaded at the same time, for example msvcrt100 by # CPython and msvcrt120 by LLVM) ll.add_symbol(fname, c_helpers[fname])
def mk_boxing(self): '''provide boxing and unboxing''' if not self.spec or self.spec.input_types: # we only support models/results at this point return ll.add_symbol('unbox_'+self.spec.c_name, self.cy_unboxer()) @box(self.NbType) def box_me(typ, val, c): 'Call Cythons contructor with the C++ pointer and return Python object.' ll_intp = c.context.get_value_type(types.uintp) addr = c.builder.ptrtoint(val, ll_intp) v = c.box(types.uintp, addr) py_obj = c.pyapi.unserialize(c.pyapi.serialize_object(self.spec.pyclass)) res = c.pyapi.call_function_objargs(py_obj, (v,)) return res @unbox(self.NbType) def unbox_me(typ, obj, c): 'Call C++ unboxing function and return as NativeValue' # Define the signature fnty = lir.FunctionType(lir.IntType(8).as_pointer(), [lir.IntType(8).as_pointer(),]) # Get function fn = c.builder.module.get_or_insert_function(fnty, name='unbox_'+self.spec.c_name) # finally generate the call ptr = c.builder.call(fn, [obj]) return NativeValue(ptr, is_error=c.pyapi.c_api_error())
def translate(self, clib, module): logging.debug("Adding external function {0}".format(self.name)) f = getattr(clib, self.name) llvm.add_symbol(self.name, ctypes.cast(f, ctypes.c_void_p).value) llvm_arg_types = [arg.llvmType(module) for arg in self.type_.arg_types] func_tp = ll.FunctionType(self.type_.return_type.llvmType(module), llvm_arg_types) self.llvm = ll.Function(module, func_tp, self.name)
def load_native_func(fname, module, suffixes=None, skip_check=None): suffixes = suffixes or [ '', ] for s in suffixes: if skip_check and skip_check(s): continue fsuffix = f'_{s}' if s else '' full_func_name = f'{fname}{fsuffix}' ll.add_symbol(full_func_name, getattr(module, full_func_name))
def remove_native_function(self, func): """ Remove internal references to nonpython mode function *func*. KeyError is raised if the function isn't known to us. """ name, ptr = self.native_funcs.pop(func) # If the symbol wasn't redefined, NULL it out. # (otherwise, it means the corresponding Python function was # re-compiled, and the new target is still alive) if ll.address_of_symbol(name) == ptr: ll.add_symbol(name, 0)
def tofile_overload(arr_ty, fname_ty): # FIXME: import here since hio has hdf5 which might not be available import hio import llvmlite.binding as ll ll.add_symbol('file_write', hio.file_write) ll.add_symbol('file_write_parallel', hio.file_write_parallel) if fname_ty == string_type: def tofile_impl(arr, fname): A = np.ascontiguousarray(arr) dtype_size = get_dtype_size(A.dtype) file_write(fname, A.ctypes, dtype_size * A.size) return tofile_impl
def _do_install(self): is32bit = utils.MACHINE_BITS == 32 c_helpers = _helperlib.c_helpers for name in ['cpow', 'sdiv', 'srem', 'udiv', 'urem']: ll.add_symbol("numba.math.%s" % name, c_helpers[name]) if sys.platform.startswith('win32') and is32bit: # For Windows XP _ftol2 is not defined, we will just use # _ftol as a replacement. # On Windows 7, this is not necessary but will work anyway. ftol = _get_msvcrt_symbol("_ftol") _add_missing_symbol("_ftol2", ftol) elif sys.platform.startswith('linux') and is32bit: _add_missing_symbol("__fixunsdfdi", c_helpers["fptoui"]) _add_missing_symbol("__fixunssfdi", c_helpers["fptouif"]) # Necessary for Python3 ll.add_symbol("numba.round", c_helpers["round_even"]) ll.add_symbol("numba.roundf", c_helpers["roundf_even"]) # List available C-math for fname in intrinsics.INTR_MATH: # Force binding from CPython's C runtime library. # (under Windows, different versions of the C runtime can # be loaded at the same time, for example msvcrt100 by # CPython and msvcrt120 by LLVM) ll.add_symbol(fname, c_helpers[fname])
def tofile_overload(arr_ty, fname_ty): # FIXME: import here since hio has hdf5 which might not be available from .. import hio import llvmlite.binding as ll ll.add_symbol('file_write', hio.file_write) ll.add_symbol('file_write_parallel', hio.file_write_parallel) # TODO: fix Numba to convert literal if fname_ty == string_type or isinstance(fname_ty, types.StringLiteral): def tofile_impl(arr, fname): A = np.ascontiguousarray(arr) dtype_size = get_dtype_size(A.dtype) file_write(fname._data, A.ctypes, dtype_size * A.size) return tofile_impl
def _init(): from . import workqueue as lib from ctypes import CFUNCTYPE, c_void_p global _is_initialized if _is_initialized: return ll.add_symbol('numba_add_task', lib.add_task) ll.add_symbol('numba_synchronize', lib.synchronize) ll.add_symbol('numba_ready', lib.ready) ll.add_symbol('do_scheduling_signed', lib.do_scheduling_signed) ll.add_symbol('do_scheduling_unsigned', lib.do_scheduling_unsigned) _is_initialized = True
def run(self, stats): logging.debug("Preparing execution...") import ctypes import llvmlite import os _lib_dir = os.path.dirname(llvm.ffi.__file__) clib = ctypes.CDLL( os.path.join(_lib_dir, llvmlite.utils.get_library_name())) # Direct access as below mangles the name # f = clib.__powidf2 f = getattr(clib, '__powidf2') llvm.add_symbol('__powidf2', ctypes.cast(f, ctypes.c_void_p).value) with llvm.create_mcjit_compiler(self.llmod(), self.target_machine) as ee: ee.finalize_object() entry = self.module.entry ret_type = entry.result.type logging.info("running {0}{1}".format( entry, list(zip(entry.type_.arg_types, self.module.entry_args)))) entry_ptr = ee.get_pointer_to_global(self.llmod().get_function( self.llvm.name)) ret_ctype = entry.result.type.Ctype() if ret_type.on_heap: ret_ctype = ctypes.POINTER(ret_ctype) cfunc = ctypes.CFUNCTYPE(ret_ctype)(entry_ptr) time_start = time.time() retval = cfunc() stats['elapsed'] = time.time() - time_start for arg in self.module.entry_args: arg.ctype2Python(self.cge) # may be a no-op if not necessary retval = ret_type.unpack(retval) logging.debug("Returning...") self.destruct() return retval
def run(self, stats): logging.debug("Preparing execution...") import ctypes import llvmlite import os _lib_dir = os.path.dirname(llvm.ffi.__file__) clib = ctypes.CDLL(os.path.join(_lib_dir, llvmlite.utils.get_library_name())) # Direct access as below mangles the name # f = clib.__powidf2 f = getattr(clib, '__powidf2') llvm.add_symbol('__powidf2', ctypes.cast(f, ctypes.c_void_p).value) with llvm.create_mcjit_compiler(self.llmod(), self.target_machine) as ee: ee.finalize_object() entry = self.module.entry ret_type = entry.result.type logging.info("running {0}{1}".format(entry, list(zip(entry.type_.arg_types, self.module.entry_args)))) entry_ptr = ee.get_pointer_to_global(self.llmod().get_function(self.llvm.name)) ret_ctype = entry.result.type.Ctype() if ret_type.on_heap: ret_ctype = ctypes.POINTER(ret_ctype) cfunc = ctypes.CFUNCTYPE(ret_ctype)(entry_ptr) time_start = time.time() retval = cfunc() stats['elapsed'] = time.time() - time_start for arg in self.module.entry_args: arg.ctype2Python(self.cge) # may be a no-op if not necessary retval = ret_type.unpack(retval) logging.debug("Returning...") self.destruct() return retval
def __init__(self): self.module = ir.Module(name='Kaleidoscope') target = llvm.Target.from_default_triple() target_machine = target.create_target_machine() backing_mod = llvm.parse_assembly('') self.engine = llvm.create_mcjit_compiler(backing_mod, target_machine) self._prototypes = { 'sin': prototype('sin', 'x'), 'cos': prototype('cos', 'x'), 'sqrt': prototype('sqrt', 'x'), } self._runtime = [] for func in runtime.__all__: wrap = runtime.Wrap(getattr(runtime, func)) self._runtime.append(wrap) llvm.add_symbol(str(wrap), wrap.addr) self._prototypes[str(wrap)] = wrap.prototype
def _handle_np_fromfile(assign, lhs, rhs): """translate np.fromfile() to native """ # TODO: dtype in kws if len(rhs.args) != 2: # pragma: no cover raise ValueError("np.fromfile(): file name and dtype expected") # FIXME: import here since hio has hdf5 which might not be available from .. import hio import llvmlite.binding as ll ll.add_symbol('get_file_size', hio.get_file_size) ll.add_symbol('file_read', hio.file_read) ll.add_symbol('file_read_parallel', hio.file_read_parallel) _fname = rhs.args[0] _dtype = rhs.args[1] def fromfile_impl(fname, dtype): size = get_file_size(fname) dtype_size = get_dtype_size(dtype) A = np.empty(size // dtype_size, dtype=dtype) file_read(fname, A, size) read_arr = A f_block = compile_to_numba_ir( fromfile_impl, { 'np': np, 'get_file_size': get_file_size, 'file_read': file_read, 'get_dtype_size': get_dtype_size }).blocks.popitem()[1] replace_arg_nodes(f_block, [_fname, _dtype]) nodes = f_block.body[:-3] # remove none return nodes[-1].target = lhs return nodes
def initialize(self, ctx): """Initializes the NRT Must be called before any actual call to the NRT API. Safe to be called multiple times. """ if self._init: # Already initialized return # Compile atomic operations compiled = atomicops.compile_atomic_ops(ctx) self._library, self._ptr_inc, self._ptr_dec, self._ptr_cas = compiled # Install atomic ops to NRT _nrt.memsys_set_atomic_inc_dec(self._ptr_inc, self._ptr_dec) _nrt.memsys_set_atomic_cas(self._ptr_cas) # Register globals into the system for py_name in _nrt.c_helpers: c_name = "NRT_" + py_name c_address = _nrt.c_helpers[py_name] ll.add_symbol(c_name, c_address) self._init = True
def fix_python_api(): """ Execute once to install special symbols into the LLVM symbol table """ ll.add_symbol("Py_None", ctypes.addressof(_PyNone)) ll.add_symbol("numba_native_error", id(NativeError)) # Add C helper functions c_helpers = _helperlib.c_helpers for py_name in c_helpers: c_name = "numba_" + py_name c_address = c_helpers[py_name] ll.add_symbol(c_name, c_address) # Add all built-in exception classes for obj in utils.builtins.__dict__.values(): if isinstance(obj, type) and issubclass(obj, BaseException): ll.add_symbol("PyExc_%s" % (obj.__name__), id(obj))
def _load_global_helpers(): """ Execute once to install special symbols into the LLVM symbol table. """ # This is Py_None's real C name ll.add_symbol("_Py_NoneStruct", id(None)) # Add Numba C helper functions for c_helpers in (_helperlib.c_helpers, _dynfunc.c_helpers): for py_name, c_address in c_helpers.items(): c_name = "numba_" + py_name ll.add_symbol(c_name, c_address) # Add Numpy C helpers (npy_XXX) for c_name, c_address in _helperlib.npymath_exports.items(): ll.add_symbol(c_name, c_address) # Add all built-in exception classes for obj in utils.builtins.__dict__.values(): if isinstance(obj, type) and issubclass(obj, BaseException): ll.add_symbol("PyExc_%s" % (obj.__name__), id(obj))
def add_external_function(self, function, signature, number_of_args, target_ids): """ Wrap the function and make it available in the LLVM module """ f_c = cfunc(sig=signature)(function) name = function.__qualname__ f_c_sym = llvm.add_symbol(name, f_c.address) llvm_signature = np.tile(ll.DoubleType(), number_of_args).tolist() for i in target_ids: llvm_signature[i] = ll.DoubleType().as_pointer() fnty_c_func = ll.FunctionType(ll.VoidType(), llvm_signature) fnty_c_func.as_pointer(f_c_sym) f_llvm = ll.Function(self.module, fnty_c_func, name=name) self.ext_funcs[name] = f_llvm
def _init(): from . import workqueue as lib from ctypes import CFUNCTYPE, c_void_p ll.add_symbol('numba_add_task', lib.add_task) ll.add_symbol('numba_synchronize', lib.synchronize) ll.add_symbol('numba_ready', lib.ready) set_cas = CFUNCTYPE(None, c_void_p)(lib.set_cas) engine, cas_ptr = _make_cas_function() set_cas(c_void_p(cas_ptr)) _keepalive.append(_ProtectEngineDestroy(set_cas, engine))
def _load_num_threads_funcs(lib): ll.add_symbol('get_num_threads', lib.get_num_threads) ll.add_symbol('set_num_threads', lib.set_num_threads) ll.add_symbol('get_thread_id', lib.get_thread_id) global _set_num_threads _set_num_threads = CFUNCTYPE(None, c_int)(lib.set_num_threads) _set_num_threads(NUM_THREADS) global _get_num_threads _get_num_threads = CFUNCTYPE(c_int)(lib.get_num_threads) global _get_thread_id _get_thread_id = CFUNCTYPE(c_int)(lib.get_thread_id)
def _load_global_helpers(): """ Execute once to install special symbols into the LLVM symbol table. """ ll.add_symbol("Py_None", id(None)) # Add C helper functions for c_helpers in (_helperlib.c_helpers, _dynfunc.c_helpers): for py_name in c_helpers: c_name = "numba_" + py_name c_address = c_helpers[py_name] ll.add_symbol(c_name, c_address) # Add all built-in exception classes for obj in utils.builtins.__dict__.values(): if isinstance(obj, type) and issubclass(obj, BaseException): ll.add_symbol("PyExc_%s" % (obj.__name__), id(obj))
def _load_global_helpers(): """ Execute once to install special symbols into the LLVM symbol table. """ ll.add_symbol("Py_None", id(None)) # Add C helper functions c_helpers = _helperlib.c_helpers for py_name in c_helpers: c_name = "numba_" + py_name c_address = c_helpers[py_name] ll.add_symbol(c_name, c_address) # Add all built-in exception classes for obj in utils.builtins.__dict__.values(): if isinstance(obj, type) and issubclass(obj, BaseException): ll.add_symbol("PyExc_%s" % (obj.__name__), id(obj))
def dylib_add_symbol(name, addr): llvm.add_symbol(name, addr)
from numba import types, cgutils from numba.targets.imputils import lower_builtin from numba.targets.arrayobj import make_array from numba.extending import overload import numba.targets.arrayobj from numba.targets.imputils import impl_ret_new_ref, impl_ret_borrowed from numba.typing.builtins import IndexValueType import numpy as np import hpat from hpat import distributed_api from hpat.distributed_api import mpi_req_numba_type, ReqArrayType, req_array_type, _h5_typ_table import time from llvmlite import ir as lir import hdist import llvmlite.binding as ll ll.add_symbol('hpat_dist_get_rank', hdist.hpat_dist_get_rank) ll.add_symbol('hpat_dist_get_size', hdist.hpat_dist_get_size) ll.add_symbol('hpat_dist_get_start', hdist.hpat_dist_get_start) ll.add_symbol('hpat_dist_get_end', hdist.hpat_dist_get_end) ll.add_symbol('hpat_dist_get_node_portion', hdist.hpat_dist_get_node_portion) ll.add_symbol('hpat_dist_get_time', hdist.hpat_dist_get_time) ll.add_symbol('hpat_get_time', hdist.hpat_get_time) ll.add_symbol('hpat_barrier', hdist.hpat_barrier) ll.add_symbol('hpat_dist_reduce', hdist.hpat_dist_reduce) ll.add_symbol('hpat_dist_arr_reduce', hdist.hpat_dist_arr_reduce) ll.add_symbol('hpat_dist_exscan_i4', hdist.hpat_dist_exscan_i4) ll.add_symbol('hpat_dist_exscan_i8', hdist.hpat_dist_exscan_i8) ll.add_symbol('hpat_dist_exscan_f4', hdist.hpat_dist_exscan_f4) ll.add_symbol('hpat_dist_exscan_f8', hdist.hpat_dist_exscan_f8) ll.add_symbol('hpat_dist_irecv', hdist.hpat_dist_irecv) ll.add_symbol('hpat_dist_isend', hdist.hpat_dist_isend)
@infer_global(read_ros_images_inner_parallel) class ReadInnerParallelTyper(AbstractTemplate): def generic(self, args, kws): assert not kws assert len(args) == 4 return signature(types.int32, *args) from numba import cgutils from numba.targets.arrayobj import make_array from llvmlite import ir as lir import ros_cpp import llvmlite.binding as ll ll.add_symbol('open_bag', ros_cpp.open_bag) ll.add_symbol('get_msg_count', ros_cpp.get_msg_count) ll.add_symbol('get_image_dims', ros_cpp.get_image_dims) ll.add_symbol('read_images', ros_cpp.read_images) ll.add_symbol('read_images_parallel', ros_cpp.read_images_parallel) @lower_builtin(open_bag, hpat.string_type) def lower_open_bag(context, builder, sig, args): fnty = lir.FunctionType( lir.IntType(8).as_pointer(), [lir.IntType(8).as_pointer()]) fn = builder.module.get_or_insert_function(fnty, name="open_bag") return builder.call(fn, args) @lower_builtin(get_msg_count, bag_file_type)
assert len(args) == 4 return signature(string_array_type, *unliteral_all(args)) @infer_global(read_parquet_parallel) class ReadParallelParquetInfer(AbstractTemplate): def generic(self, args, kws): assert not kws assert len(args) == 6 # array_ty = types.Array(ndim=1, layout='C', dtype=args[2]) return signature(types.int32, *unliteral_all(args)) if _has_pyarrow: from .. import parquet_cpp ll.add_symbol('get_arrow_readers', parquet_cpp.get_arrow_readers) ll.add_symbol('del_arrow_readers', parquet_cpp.del_arrow_readers) ll.add_symbol('pq_read', parquet_cpp.read) ll.add_symbol('pq_read_parallel', parquet_cpp.read_parallel) ll.add_symbol('pq_get_size', parquet_cpp.get_size) ll.add_symbol('pq_read_string', parquet_cpp.read_string) ll.add_symbol('pq_read_string_parallel', parquet_cpp.read_string_parallel) @lower_builtin(get_column_size_parquet, types.Opaque('arrow_reader'), types.intp) def pq_size_lower(context, builder, sig, args): fnty = lir.FunctionType(lir.IntType(64), [lir.IntType(8).as_pointer(), lir.IntType(64)]) fn = builder.module.get_or_insert_function(fnty, name="pq_get_size") return builder.call(fn, args)
assert not kws assert len(args) == 5 # array_ty = types.Array(ndim=1, layout='C', dtype=args[2]) return signature(types.int32, *args) from numba import cgutils from numba.targets.imputils import lower_builtin from numba.targets.arrayobj import make_array from llvmlite import ir as lir import llvmlite.binding as ll from hpat.config import _has_pyarrow if _has_pyarrow: import parquet_cpp ll.add_symbol('pq_read', parquet_cpp.read) ll.add_symbol('pq_read_parallel', parquet_cpp.read_parallel) ll.add_symbol('pq_get_size', parquet_cpp.get_size) ll.add_symbol('pq_read_string', parquet_cpp.read_string) ll.add_symbol('pq_read_string_parallel', parquet_cpp.read_string_parallel) @lower_builtin(get_column_size_parquet, StringType, types.intp) def pq_size_lower(context, builder, sig, args): fnty = lir.FunctionType(lir.IntType(64), [lir.IntType(8).as_pointer(), lir.IntType(64)]) fn = builder.module.get_or_insert_function(fnty, name="pq_get_size") return builder.call(fn, args)
from numba import types, cgutils from numba.targets.imputils import lower_builtin from numba.targets.arrayobj import make_array import numba.targets.arrayobj import numpy as np import hpat from hpat import distributed_api import time from llvmlite import ir as lir import hdist import llvmlite.binding as ll ll.add_symbol('hpat_dist_get_rank', hdist.hpat_dist_get_rank) ll.add_symbol('hpat_dist_get_size', hdist.hpat_dist_get_size) ll.add_symbol('hpat_dist_get_end', hdist.hpat_dist_get_end) ll.add_symbol('hpat_dist_get_node_portion', hdist.hpat_dist_get_node_portion) ll.add_symbol('hpat_dist_get_time', hdist.hpat_dist_get_time) ll.add_symbol('hpat_dist_reduce_i4', hdist.hpat_dist_reduce_i4) ll.add_symbol('hpat_dist_reduce_i8', hdist.hpat_dist_reduce_i8) ll.add_symbol('hpat_dist_reduce_f4', hdist.hpat_dist_reduce_f4) ll.add_symbol('hpat_dist_reduce_f8', hdist.hpat_dist_reduce_f8) ll.add_symbol('hpat_dist_arr_reduce', hdist.hpat_dist_arr_reduce) ll.add_symbol('hpat_dist_exscan_i4', hdist.hpat_dist_exscan_i4) ll.add_symbol('hpat_dist_exscan_i8', hdist.hpat_dist_exscan_i8) ll.add_symbol('hpat_dist_exscan_f4', hdist.hpat_dist_exscan_f4) ll.add_symbol('hpat_dist_exscan_f8', hdist.hpat_dist_exscan_f8) ll.add_symbol('hpat_dist_irecv', hdist.hpat_dist_irecv) ll.add_symbol('hpat_dist_isend', hdist.hpat_dist_isend) ll.add_symbol('hpat_dist_wait', hdist.hpat_dist_wait) ll.add_symbol('hpat_dist_get_item_pointer', hdist.hpat_dist_get_item_pointer) ll.add_symbol('hpat_get_dummy_ptr', hdist.hpat_get_dummy_ptr)
def dynamic_map_function(self, func): name, ptr = self.native_funcs[func] ll.add_symbol(name, ptr)
def resolve_train(self, dict, args, kws): assert not kws assert len(args) == 2 return signature(types.none, *args) @bound_function("svc.predict") def resolve_predict(self, dict, args, kws): assert not kws assert len(args) == 1 return signature(types.Array(types.float64, 1, 'C'), *args) from llvmlite import ir as lir import llvmlite.binding as ll try: import daal_wrapper ll.add_symbol('svc_train', daal_wrapper.svc_train) ll.add_symbol('svc_predict', daal_wrapper.svc_predict) ll.add_symbol('dtor_svc', daal_wrapper.dtor_svc) except ImportError: print("daal import error") @lower_builtin(SVC, types.intp) def impl_svc_constructor(context, builder, sig, args): dtype = SVCPayloadType() alloc_type = context.get_data_type(dtype) alloc_size = context.get_abi_sizeof(alloc_type) llvoidptr = context.get_value_type(types.voidptr) llsize = context.get_value_type(types.uintp) dtor_ftype = lir.FunctionType(lir.VoidType(),
def contains_noregex(str, pat): return False @infer_global(contains_regex) @infer_global(contains_noregex) class ContainsInfer(AbstractTemplate): def generic(self, args, kws): assert not kws assert len(args) == 2 return signature(types.boolean, *args) import hstr_ext ll.add_symbol('init_string', hstr_ext.init_string) ll.add_symbol('init_string_const', hstr_ext.init_string_const) ll.add_symbol('get_c_str', hstr_ext.get_c_str) ll.add_symbol('str_concat', hstr_ext.str_concat) ll.add_symbol('str_equal', hstr_ext.str_equal) ll.add_symbol('str_split', hstr_ext.str_split) ll.add_symbol('str_substr_int', hstr_ext.str_substr_int) ll.add_symbol('str_to_int64', hstr_ext.str_to_int64) ll.add_symbol('str_to_float64', hstr_ext.str_to_float64) ll.add_symbol('get_str_len', hstr_ext.get_str_len) ll.add_symbol('str_contains_regex', hstr_ext.str_contains_regex) ll.add_symbol('str_contains_noregex', hstr_ext.str_contains_noregex) ll.add_symbol('str_from_int32', hstr_ext.str_from_int32) ll.add_symbol('str_from_int64', hstr_ext.str_from_int64) ll.add_symbol('str_from_float32', hstr_ext.str_from_float32) ll.add_symbol('str_from_float64', hstr_ext.str_from_float64)
def _add_missing_symbol(symbol, addr): """Add missing symbol into LLVM internal symtab """ if not ll.address_of_symbol(symbol): ll.add_symbol(symbol, addr)
unbox_datetime_date_array, box_datetime_date_array) from hpat.str_ext import string_type, list_string_array_type from hpat.str_arr_ext import (string_array_type, unbox_str_series, box_str_arr) from hpat.hiframes.pd_categorical_ext import (PDCategoricalDtype, box_categorical_array, unbox_categorical_array) from hpat.hiframes.pd_series_ext import (SeriesType, arr_to_series_type, _get_series_array_type) from hpat.hiframes.split_impl import (string_array_split_view_type, box_str_arr_split_view) from .. import hstr_ext import llvmlite.binding as ll from llvmlite import ir as lir import llvmlite.llvmpy.core as lc from llvmlite.llvmpy.core import Type as LLType ll.add_symbol('array_size', hstr_ext.array_size) ll.add_symbol('array_getptr1', hstr_ext.array_getptr1) @typeof_impl.register(pd.DataFrame) def typeof_pd_dataframe(val, c): col_names = tuple(val.columns.tolist()) # TODO: support other types like string and timestamp col_types = get_hiframes_dtypes(val) return DataFrameType(col_types, None, col_names, True) # register series types for import @typeof_impl.register(pd.Series) def typeof_pd_str_series(val, c): index_type = _infer_index_type(val.index)
write_impl = loc_vars['f'] return write_impl from numba.typing.templates import ( signature, AbstractTemplate, infer_global, infer) from numba.extending import (register_model, models, lower_builtin) from numba import cgutils from llvmlite import ir as lir import llvmlite.binding as ll from numba.targets.arrayobj import make_array from hpat.utils import _numba_to_c_type_map from .. import chiframes ll.add_symbol('get_join_sendrecv_counts', chiframes.get_join_sendrecv_counts) ll.add_symbol('timsort', chiframes.timsort) from .. import hdist ll.add_symbol('c_alltoallv', hdist.c_alltoallv) @numba.njit def calc_disp(arr): disp = np.empty_like(arr) disp[0] = 0 for i in range(1, len(arr)): disp[i] = disp[i-1] + arr[i-1] return disp
def _do_install(self, context): # add the symbols for numpy math to the execution environment. for sym in _npymath_exports.symbols: ll.add_symbol(*sym)