def compile(self, sig, locals={}, **targetoptions):
locs = self.locals.copy()
locs.update(locals)
topt = self.targetoptions.copy()
topt.update(targetoptions)
flags = compiler.Flags()
self.targetdescr.options.parse_as_flags(flags, topt)
flags.set("no_compile")
flags.set("no_cpython_wrapper")
# Disable loop lifting
# The feature requires a real python function
flags.unset("enable_looplift")
typingctx = self.targetdescr.typing_context
targetctx = self.targetdescr.target_context
args, return_type = sigutils.normalize_signature(sig)
cres = compiler.compile_extra(typingctx,
targetctx,
self.py_func,
args=args,
return_type=return_type,
flags=flags,
locals=locals)
self.overloads[cres.signature] = cres
return cres
def _compile_subroutine_no_cache(self, builder, impl, sig, locals={},
flags=None):
"""
Invoke the compiler to compile a function to be used inside a
nopython function, but without generating code to call that
function.
Note this context's flags are not inherited.
"""
# Compile
from numba import compiler
with global_compiler_lock:
codegen = self.codegen()
library = codegen.create_library(impl.__name__)
if flags is None:
flags = compiler.Flags()
flags.set('no_compile')
flags.set('no_cpython_wrapper')
cres = compiler.compile_internal(self.typing_context, self,
library,
impl, sig.args,
sig.return_type, flags,
locals=locals)
# Allow inlining the function inside callers.
codegen.add_linking_library(cres.library)
return cres
def compile_cuda(pyfunc, return_type, args, debug):
# First compilation will trigger the initialization of the CUDA backend.
from .descriptor import CUDATargetDesc
typingctx = CUDATargetDesc.typingctx
targetctx = CUDATargetDesc.targetctx
# TODO handle debug flag
flags = compiler.Flags()
# Do not compile (generate native code), just lower (to LLVM)
flags.set('no_compile')
# Run compilation pipeline
cres = compiler.compile_extra(typingctx=typingctx,
targetctx=targetctx,
func=pyfunc,
args=args,
return_type=return_type,
flags=flags,
locals={})
# Linking depending libraries
targetctx.link_dependencies(cres.llvm_module, cres.target_context.linking)
# Fix global naming
for gv in cres.llvm_module.global_variables:
if '.' in gv.name:
gv.name = gv.name.replace('.', '_')
return cres
def compile_cuda(pyfunc, return_type, args, debug, inline):
# First compilation will trigger the initialization of the CUDA backend.
from .descriptor import CUDATargetDesc
typingctx = CUDATargetDesc.typingctx
targetctx = CUDATargetDesc.targetctx
# TODO handle debug flag
flags = compiler.Flags()
# Do not compile (generate native code), just lower (to LLVM)
flags.set('no_compile')
flags.set('no_cpython_wrapper')
if debug:
flags.set('boundcheck')
if inline:
flags.set('forceinline')
# Run compilation pipeline
cres = compiler.compile_extra(typingctx=typingctx,
targetctx=targetctx,
func=pyfunc,
args=args,
return_type=return_type,
flags=flags,
locals={})
library = cres.library
library.finalize()
return cres
def test_use_car_move(self):
tyctx = typing.Context()
tyctx.insert_class(Car, self.carattrs)
cgctx = CPUContext(tyctx)
cgctx.insert_class(Car, self.carattrs)
car_object = types.Object(Car)
argtys = (car_object, types.int32)
flags = compiler.Flags()
cr = compiler.compile_extra(tyctx, cgctx, use_car_move, args=argtys,
return_type=None, flags=flags, locals={})
func = cr.entry_point
if cr.typing_error:
raise cr.typing_error
car1 = Car(value=123)
car2 = Car(value=123)
self.assertEqual(use_car_move(car1, 321), func(car2, 321))
def bm_python():
use_car_move(car1, 321)
def bm_numba():
func(car2, 321)
python = utils.benchmark(bm_python, maxsec=.1)
numba = utils.benchmark(bm_numba, maxsec=.1)
print(python)
print(numba)
def compile(self, sig, locals={}, **targetoptions):
with self._compile_lock():
locs = self.locals.copy()
locs.update(locals)
topt = self.targetoptions.copy()
topt.update(targetoptions)
flags = compiler.Flags()
self.targetdescr.options.parse_as_flags(flags, topt)
args, return_type = sigutils.normalize_signature(sig)
# Don't recompile if signature already exist.
existing = self.overloads.get(tuple(args))
if existing is not None:
return existing
cres = compiler.compile_extra(self.typingctx,
self.targetctx,
self.py_func,
args=args,
return_type=return_type,
flags=flags,
locals=locs)
# Check typing error if object mode is used
if cres.typing_error is not None and not flags.enable_pyobject:
raise cres.typing_error
self.add_overload(cres)
return cres.entry_point
def compile_only_no_cache(self, builder, impl, sig, locals={}):
"""Invoke the compiler to compile a function to be used inside a
nopython function, but without generating code to call that
function.
"""
# Compile
from numba import compiler
codegen = self.codegen()
library = codegen.create_library(impl.__name__)
flags = compiler.Flags()
flags.set('no_compile')
flags.set('no_cpython_wrapper')
cres = compiler.compile_internal(self.typing_context,
self,
library,
impl,
sig.args,
sig.return_type,
flags,
locals=locals)
# Allow inlining the function inside callers.
codegen.add_linking_library(cres.library)
return cres
def compile_hsa(pyfunc, return_type, args, debug):
# First compilation will trigger the initialization of the HSA backend.
from .descriptor import HSATargetDesc
typingctx = HSATargetDesc.typingctx
targetctx = HSATargetDesc.targetctx
# TODO handle debug flag
flags = compiler.Flags()
# Do not compile (generate native code), just lower (to LLVM)
flags.set('no_compile')
flags.set('no_cpython_wrapper')
flags.unset('nrt')
# Run compilation pipeline
cres = compiler.compile_extra(typingctx=typingctx,
targetctx=targetctx,
func=pyfunc,
args=args,
return_type=return_type,
flags=flags,
locals={})
# Linking depending libraries
# targetctx.link_dependencies(cres.llvm_module, cres.target_context.linking)
library = cres.library
library.finalize()
return cres
def compile(self, sig, locals={}, **targetoptions):
locs = self.locals.copy()
locs.update(locals)
topt = self.targetoptions.copy()
topt.update(targetoptions)
if topt.get('nopython', True) == False:
raise TypeError("nopython option must be False")
topt['nopython'] = True
flags = compiler.Flags()
flags.set("no_compile")
self.targetdescr.options.parse_as_flags(flags, topt)
typingctx = self.targetdescr.typing_context
targetctx = self.targetdescr.target_context
args, return_type = sigutils.normalize_signature(sig)
cres = compiler.compile_extra(typingctx, targetctx, self.py_func,
args=args, return_type=return_type,
flags=flags, locals=locals)
self.overloads[cres.signature] = cres
return cres
def compile(self, sig):
with self._compile_lock:
args, return_type = sigutils.normalize_signature(sig)
# Don't recompile if signature already exists
# (e.g. if another thread compiled it before we got the lock)
existing = self.overloads.get(tuple(args))
if existing is not None:
return existing
flags = compiler.Flags()
self.targetdescr.options.parse_as_flags(flags, self.targetoptions)
cres = compiler.compile_extra(self.typingctx,
self.targetctx,
self.py_func,
args=args,
return_type=return_type,
flags=flags,
locals=self.locals)
# Check typing error if object mode is used
if cres.typing_error is not None and not flags.enable_pyobject:
raise cres.typing_error
self.add_overload(cres)
return cres.entry_point
def compile(self, args, return_type):
flags = compiler.Flags()
self.targetdescr.options.parse_as_flags(flags, self.targetoptions)
impl = self._get_implementation(args, {})
cres = compiler.compile_extra(self.targetdescr.typing_context,
self.targetdescr.target_context,
impl,
args=args, return_type=return_type,
flags=flags, locals=self.locals)
# Check typing error if object mode is used
if cres.typing_error is not None and not flags.enable_pyobject:
raise cres.typing_error
return cres
def compile(self, sig, locals={}, **targetoptions):
locs = self.locals.copy()
locs.update(locals)
topt = self.targetoptions.copy()
topt.update(targetoptions)
flags = compiler.Flags()
self.targetdescr.options.parse_as_flags(flags, topt)
flags.set("no_cpython_wrapper")
flags.set("error_model", "numpy")
# Disable loop lifting
# The feature requires a real python function
flags.unset("enable_looplift")
return self._compile_core(sig, flags, locals)
def compile_internal(self, builder, impl, sig, args, locals={}):
"""Invoke compiler to implement a function for a nopython function
"""
cache_key = (impl.__code__, sig)
if impl.__closure__:
# XXX This obviously won't work if a cell's value is
# unhashable.
cache_key += tuple(c.cell_contents for c in impl.__closure__)
fndesc = self.cached_internal_func.get(cache_key)
if fndesc is None:
# Compile
from numba import compiler
codegen = self.jit_codegen()
library = codegen.create_library(impl.__name__)
flags = compiler.Flags()
flags.set('no_compile')
flags.set('no_cpython_wrapper')
cres = compiler.compile_internal(self.typing_context,
self,
library,
impl,
sig.args,
sig.return_type,
flags,
locals=locals)
# Allow inlining the function inside callers.
codegen.add_linking_library(cres.library)
fndesc = cres.fndesc
self.cached_internal_func[cache_key] = fndesc
# Add call to the generated function
llvm_mod = cgutils.get_module(builder)
fn = self.declare_function(llvm_mod, fndesc)
status, res = self.call_conv.call_function(builder, fn,
sig.return_type, sig.args,
args)
with cgutils.if_unlikely(builder, status.is_error):
self.call_conv.return_status_propagate(builder, status)
return res
def compile_internal(self, builder, impl, sig, args, locals={}):
"""Invoke compiler to implement a function for a nopython function
"""
cache_key = (impl.__code__, sig)
fndesc = self.cached_internal_func.get(cache_key)
if fndesc is None:
# Compile
from numba import compiler
codegen = self.jit_codegen()
library = codegen.create_library(impl.__name__)
flags = compiler.Flags()
flags.set('no_compile')
flags.set('no_cpython_wrapper')
cres = compiler.compile_internal(self.typing_context,
self,
library,
impl,
sig.args,
sig.return_type,
flags,
locals=locals)
# Allow inlining the function inside callers.
codegen.add_linking_library(cres.library)
fndesc = cres.fndesc
self.cached_internal_func[cache_key] = fndesc
# Add call to the generated function
llvm_mod = cgutils.get_module(builder)
fn = self.declare_function(llvm_mod, fndesc)
status, res = self.call_function(builder, fn, sig.return_type,
sig.args, args)
return res
def compile(self, sig):
with self._compile_lock:
args, return_type = sigutils.normalize_signature(sig)
# Don't recompile if signature already exists
existing = self.overloads.get(tuple(args))
if existing is not None:
return existing
# Try to load from disk cache
cres = self._cache.load_overload(sig, self.targetctx)
if cres is not None:
# XXX fold this in add_overload()? (also see compiler.py)
if not cres.objectmode and not cres.interpmode:
self.targetctx.insert_user_function(
cres.entry_point, cres.fndesc, [cres.library])
self.add_overload(cres)
return cres.entry_point
flags = compiler.Flags()
self.targetdescr.options.parse_as_flags(flags, self.targetoptions)
cres = compiler.compile_extra(self.typingctx,
self.targetctx,
self.py_func,
args=args,
return_type=return_type,
flags=flags,
locals=self.locals)
# Check typing error if object mode is used
if cres.typing_error is not None and not flags.enable_pyobject:
raise cres.typing_error
self.add_overload(cres)
self._cache.save_overload(sig, cres)
return cres.entry_point