Ejemplo n.º 1
0
 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)
Ejemplo n.º 2
0
    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
Ejemplo n.º 3
0
    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])
Ejemplo n.º 4
0
    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])
Ejemplo n.º 5
0
    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
Ejemplo n.º 6
0
    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])
Ejemplo n.º 7
0
 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)
Ejemplo n.º 8
0
    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())
Ejemplo n.º 9
0
    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)
Ejemplo n.º 10
0
    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)
Ejemplo n.º 11
0
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))
Ejemplo n.º 12
0
 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)
Ejemplo n.º 13
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
Ejemplo n.º 14
0
    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])
Ejemplo n.º 15
0
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
Ejemplo n.º 16
0
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
Ejemplo n.º 17
0
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
Ejemplo n.º 18
0
    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
Ejemplo n.º 19
0
    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
Ejemplo n.º 20
0
    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
Ejemplo n.º 21
0
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
Ejemplo n.º 22
0
Archivo: nrt.py Proyecto: gyenney/Tools
    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
Ejemplo n.º 23
0
Archivo: nrt.py Proyecto: jriehl/numba
    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
Ejemplo n.º 24
0
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))
Ejemplo n.º 25
0
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))
Ejemplo n.º 26
0
Archivo: base.py Proyecto: yuguen/numba
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))
Ejemplo n.º 27
0
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))
Ejemplo n.º 28
0
    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
Ejemplo n.º 29
0
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))
Ejemplo n.º 30
0
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))
Ejemplo n.º 31
0
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)
Ejemplo n.º 32
0
Archivo: base.py Proyecto: meego/numba
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))
Ejemplo n.º 33
0
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))
Ejemplo n.º 34
0
def dylib_add_symbol(name, addr):
    llvm.add_symbol(name, addr)
Ejemplo n.º 35
0
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)
Ejemplo n.º 36
0

@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)
Ejemplo n.º 37
0
        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)
Ejemplo n.º 38
0
        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)

Ejemplo n.º 39
0
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)
Ejemplo n.º 40
0
 def dynamic_map_function(self, func):
     name, ptr = self.native_funcs[func]
     ll.add_symbol(name, ptr)
Ejemplo n.º 41
0
    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(),
Ejemplo n.º 42
0
Archivo: str_ext.py Proyecto: W3SS/hpat
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)
Ejemplo n.º 43
0
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)
Ejemplo n.º 44
0
                                            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)
Ejemplo n.º 45
0
    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


Ejemplo n.º 46
0
 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)