def mk_pipeline(
cls,
args,
return_type=None,
flags=None,
locals={},
library=None,
typing_context=None,
target_context=None,
):
if not flags:
flags = Flags()
flags.nrt = True
if typing_context is None:
typing_context = registry.cpu_target.typing_context
if target_context is None:
target_context = registry.cpu_target.target_context
return cls(
typing_context,
target_context,
library,
args,
return_type,
flags,
locals,
)
def autogenerate(cls):
test_flags = ['fastmath', ] # TODO: add 'auto_parallel' ?
# generate all the combinations of the flags
test_flags = sum([list(combinations(test_flags, x)) for x in range( \
len(test_flags)+1)], [])
flag_list = [] # create Flag class instances
for ft in test_flags:
flags = Flags()
flags.nrt = True
flags.error_model = 'numpy'
flags.__name__ = '_'.join(ft+('usecase',))
for f in ft:
setattr(flags, f, {
'fastmath': cpu.FastMathOptions(True)
}.get(f, True))
flag_list.append(flags)
# main loop covering all the modes and use-cases
for dtype in ('complex64', 'float64', 'float32', 'int32', ):
for vlen in vlen2cpu:
for flags in flag_list:
for mode in "scalar", "range", "prange", "numpy":
cls._inject_test(dtype, mode, vlen, flags)
# mark important
for n in ( "test_int32_range4_usecase", # issue #3016
):
setattr(cls, n, tag("important")(getattr(cls, n)))
def gen_ir(self, func, args_tuple, fastmath=False):
with override_env_config("NUMBA_CPU_NAME",
"skylake-avx512"), override_env_config(
"NUMBA_CPU_FEATURES", ""):
_flags = Flags()
_flags.fastmath = FastMathOptions(fastmath)
_flags.nrt = True
jitted = compile_isolated(func, args_tuple, flags=_flags)
return jitted.library.get_llvm_str()
def test_mangled_flags_with_fastmath_parfors_inline(self):
# at least for these control cases
flags = Flags()
flags.nrt = True
flags.auto_parallel = True
flags.fastmath = True
flags.inline = "always"
self.assertLess(len(flags.get_mangle_string()), len(flags.summary()))
demangled = flags.demangle(flags.get_mangle_string())
# There should be no pointer value in the demangled string.
self.assertNotIn("0x", demangled)
def mk_pipeline(cls, args, return_type=None, flags=None, locals={},
library=None, typing_context=None, target_context=None):
if not flags:
flags = Flags()
flags.nrt = True
if typing_context is None:
typing_context = typing.Context()
if target_context is None:
target_context = cpu.CPUContext(typing_context)
return cls(typing_context, target_context, library, args, return_type,
flags, locals)
def test_usecase(self):
n = 10
obs_got = np.zeros(n)
obs_expected = obs_got.copy()
flags = Flags()
flags.nrt = True
cres = compile_isolated(usecase, (types.float64[:], types.intp),
flags=flags)
cres.entry_point(obs_got, n)
usecase(obs_expected, n)
self.assertPreciseEqual(obs_got, obs_expected)
def test_demangle(self):
def check(flags):
mangled = flags.get_mangle_string()
out = flags.demangle(mangled)
# Demangle result MUST match summary()
self.assertEqual(out, flags.summary())
# test empty flags
flags = Flags()
check(flags)
# test default
check(DEFAULT_FLAGS)
# test other
flags = Flags()
flags.no_cpython_wrapper = True
flags.nrt = True
flags.fastmath = True
check(flags)
def test_demangling_from_mangled_symbols(self):
"""Test demangling of flags from mangled symbol"""
# Use default mangler to mangle the string
fname = 'foo'
argtypes = types.int32,
flags = Flags()
flags.nrt = True
flags.target_backend = "myhardware"
name = default_mangler(
fname,
argtypes,
abi_tags=[flags.get_mangle_string()],
)
# Find the ABI-tag. Starts with "B"
prefix = "_Z3fooB"
# Find the length of the ABI-tag
m = re.match("[0-9]+", name[len(prefix):])
size = m.group(0)
# Extract the ABI tag
base = len(prefix) + len(size)
abi_mangled = name[base:base + int(size)]
# Demangle and check
demangled = Flags.demangle(abi_mangled)
self.assertEqual(demangled, flags.summary())
import heapq as hq
import itertools
import numpy as np
from numba import jit, typed
from numba.core.compiler import Flags
from numba.core.config import IS_WIN32
from numba.tests.support import TestCase, CompilationCache, MemoryLeakMixin
no_pyobj_flags = Flags()
no_pyobj_flags.nrt = True
def heapify(x):
return hq.heapify(x)
def heappop(heap):
return hq.heappop(heap)
def heappush(heap, item):
return hq.heappush(heap, item)
def heappushpop(heap, item):
return hq.heappushpop(heap, item)
def heapreplace(heap, item):
try:
import scipy
except ImportError:
scipy = None
enable_pyobj_flags = Flags()
enable_pyobj_flags.enable_pyobject = True
force_pyobj_flags = Flags()
force_pyobj_flags.force_pyobject = True
no_pyobj_flags = Flags()
nrt_flags = Flags()
nrt_flags.nrt = True
tag = testing.make_tag_decorator(['important', 'long_running'])
_32bit = sys.maxsize <= 2**32
is_parfors_unsupported = _32bit
skip_parfors_unsupported = unittest.skipIf(
is_parfors_unsupported,
'parfors not supported',
)
skip_py38_or_later = unittest.skipIf(utils.PYVERSION >= (3, 8),
"unsupported on py3.8 or later")
skip_unless_py10_or_later = unittest.skipUnless(utils.PYVERSION >= (3, 10),
"needs Python 3.10 or later")
def test_mangled_flags_is_shorter(self):
# at least for these control cases
flags = Flags()
flags.nrt = True
flags.auto_parallel = True
self.assertLess(len(flags.get_mangle_string()), len(flags.summary()))
def _cull_exports(self):
"""Read all the exported functions/modules in the translator
environment, and join them into a single LLVM module.
"""
self.exported_function_types = {}
self.function_environments = {}
self.environment_gvs = {}
codegen = self.context.codegen()
library = codegen.create_library(self.module_name)
# Generate IR for all exported functions
flags = Flags()
flags.no_compile = True
if not self.export_python_wrap:
flags.no_cpython_wrapper = True
flags.no_cfunc_wrapper = True
if self.use_nrt:
flags.nrt = True
# Compile NRT helpers
nrt_module, _ = nrtdynmod.create_nrt_module(self.context)
library.add_ir_module(nrt_module)
for entry in self.export_entries:
cres = compile_extra(self.typing_context,
self.context,
entry.function,
entry.signature.args,
entry.signature.return_type,
flags,
locals={},
library=library)
func_name = cres.fndesc.llvm_func_name
llvm_func = cres.library.get_function(func_name)
if self.export_python_wrap:
llvm_func.linkage = 'internal'
wrappername = cres.fndesc.llvm_cpython_wrapper_name
wrapper = cres.library.get_function(wrappername)
wrapper.name = self._mangle_method_symbol(entry.symbol)
wrapper.linkage = 'external'
fnty = cres.target_context.call_conv.get_function_type(
cres.fndesc.restype, cres.fndesc.argtypes)
self.exported_function_types[entry] = fnty
self.function_environments[entry] = cres.environment
self.environment_gvs[entry] = cres.fndesc.env_name
else:
llvm_func.name = entry.symbol
self.dll_exports.append(entry.symbol)
if self.export_python_wrap:
wrapper_module = library.create_ir_module("wrapper")
self._emit_python_wrapper(wrapper_module)
library.add_ir_module(wrapper_module)
# Hide all functions in the DLL except those explicitly exported
library.finalize()
for fn in library.get_defined_functions():
if fn.name not in self.dll_exports:
if fn.linkage in {Linkage.private, Linkage.internal}:
# Private/Internal linkage must have "default" visibility
fn.visibility = "default"
else:
fn.visibility = 'hidden'
return library
import numpy as np
import unittest
from numba.core.compiler import compile_isolated, Flags
from numba import njit, typeof
from numba.core import utils, types, errors
from numba.tests.support import TestCase, tag
from numba.core.typing import arraydecl
from numba.core.types import intp, ellipsis, slice2_type, slice3_type
enable_pyobj_flags = Flags()
enable_pyobj_flags.enable_pyobject = True
Noflags = Flags()
Noflags.nrt = True
def slicing_1d_usecase(a, start, stop, step):
return a[start:stop:step]
def slicing_1d_usecase2(a, start, stop, step):
b = a[start:stop:step]
total = 0
for i in range(b.shape[0]):
total += b[i] * (i + 1)
return total
def slicing_1d_usecase3(a, start, stop):
def compile_parallel(self, func, arg_types):
fast_pflags = Flags()
fast_pflags.auto_parallel = cpu.ParallelOptions(True)
fast_pflags.nrt = True
fast_pflags.fastmath = cpu.FastMathOptions(True)
return compile_isolated(func, arg_types, flags=fast_pflags).entry_point
def unsupported_parfor(a, b):
return np.dot(a, b) # dot as gemm unsupported
def supported_parfor(n):
a = np.ones(n)
for i in prange(n):
a[i] = a[i] + np.sin(i)
return a
force_parallel_flags = Flags()
force_parallel_flags.auto_parallel = ParallelOptions(True)
force_parallel_flags.nrt = True
class DebugTestBase(TestCase):
all_dumps = set([
'bytecode', 'cfg', 'ir', 'typeinfer', 'llvm', 'func_opt_llvm',
'optimized_llvm', 'assembly'
])
def assert_fails(self, *args, **kwargs):
self.assertRaises(AssertionError, *args, **kwargs)
def check_debug_output(self, out, dump_names):
enabled_dumps = dict.fromkeys(self.all_dumps, False)
for name in dump_names:
)
from numba.core.extending import intrinsic, include_path
from numba.core.typing import signature
from numba.core.imputils import impl_ret_untracked
from llvmlite import ir
import llvmlite.binding as llvm
import numba.core.typing.cffi_utils as cffi_support
from numba.core.unsafe.nrt import NRT_get_api
from numba.tests.support import (MemoryLeakMixin, TestCase, temp_directory,
import_dynamic)
from numba.core.registry import cpu_target
import unittest
enable_nrt_flags = Flags()
enable_nrt_flags.nrt = True
linux_only = unittest.skipIf(not sys.platform.startswith('linux'),
'linux only test')
x86_only = unittest.skipIf(platform.machine() not in ('i386', 'x86_64'),
'x86 only test')
class Dummy(object):
alive = 0
def __init__(self):
type(self).alive += 1
def __del__(self):
type(self).alive -= 1
