""" Test return values """ import math import unittest from numba.core.compiler import compile_isolated, Flags from numba.core import types from numba.core.errors import TypingError enable_pyobj_flags = Flags() enable_pyobj_flags.set("enable_pyobject") no_pyobj_flags = Flags() def get_nopython_func(): return abs def get_pyobj_func(): return open def get_module_func(): return math.floor class TestReturnValues(unittest.TestCase): def test_nopython_func(self, flags=enable_pyobj_flags): # Test returning func that is supported in nopython mode
import itertools import unittest from numba.core.controlflow import CFGraph, ControlFlowAnalysis from numba.core.compiler import compile_isolated, Flags from numba.core import types from numba.core.bytecode import FunctionIdentity, ByteCode from numba.tests.support import TestCase enable_pyobj_flags = Flags() enable_pyobj_flags.set("enable_pyobject") forceobj_flags = Flags() forceobj_flags.set("force_pyobject") no_pyobj_flags = Flags() no_pyobj_flags.set("nrt") def for_loop_usecase1(x, y): result = 0 for i in range(x): result += i return result def for_loop_usecase2(x, y): result = 0 for i, j in enumerate(range(x, y, -1)): result += i * j return result
import decimal import itertools 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.set("enable_pyobject") Noflags = Flags() Noflags.set("nrt") 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 compile_parallel(self, func, arg_types): fast_pflags = Flags() fast_pflags.set('auto_parallel', cpu.ParallelOptions(True)) fast_pflags.set('nrt') fast_pflags.set('fastmath', cpu.FastMathOptions(True)) return compile_isolated(func, arg_types, flags=fast_pflags).entry_point
""" Test generic manipulation of objects. """ import unittest from numba import njit from numba.core.compiler import compile_isolated, Flags from numba.core import types from numba.tests.support import TestCase enable_pyobj_flags = Flags() enable_pyobj_flags.set("enable_pyobject") force_pyobj_flags = Flags() force_pyobj_flags.set("force_pyobject") no_pyobj_flags = Flags() class C(object): pass def setattr_usecase(o, v): o.x = v def delattr_usecase(o): del o.x
import heapq as hq import itertools import numpy as np from numba import jit from numba.core.compiler import Flags from numba.tests.support import TestCase, CompilationCache, MemoryLeakMixin no_pyobj_flags = Flags() no_pyobj_flags.set("nrt") 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): return hq.heapreplace(heap, item)
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.set("no_compile") if not self.export_python_wrap: flags.set("no_cpython_wrapper") flags.set("no_cfunc_wrapper") if self.use_nrt: flags.set("nrt") # 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 = lc.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 = lc.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
) 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 import cpu import unittest enable_nrt_flags = Flags() enable_nrt_flags.set("nrt") 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
def complex_constant(n): tmp = n + 4 return tmp + 3j def long_constant(n): return n + 100000000000000000000000000000000000000000000000 def delitem_usecase(x): del x[:] forceobj = Flags() forceobj.set("force_pyobject") def loop_nest_3(x, y): n = 0 for i in range(x): for j in range(y): for k in range(x + y): n += i * j return n def array_of_object(x): return x
import unittest from numba.core.compiler import compile_isolated, Flags from numba.core import types force_pyobj_flags = Flags() force_pyobj_flags.set("force_pyobject") no_pyobj_flags = Flags() def return_int(a, b): return a + b class TestPythonInt(unittest.TestCase): # Issue #474: ints should be returned rather than longs under Python 2, # as much as possible. def test_int_return_type(self, flags=force_pyobj_flags, int_type=types.int64, operands=(3, 4)): pyfunc = return_int cr = compile_isolated(pyfunc, (int_type, int_type), flags=flags) cfunc = cr.entry_point expected = pyfunc(*operands) got = cfunc(*operands) self.assertIs(type(got), type(expected)) self.assertEqual(got, expected)
class TestSVML(TestCase): """ Tests SVML behaves as expected """ # env mutating, must not run in parallel _numba_parallel_test_ = False def __init__(self, *args): self.flags = Flags() self.flags.set('nrt') # flags for njit(fastmath=True) self.fastflags = Flags() self.fastflags.set('nrt') self.fastflags.set('fastmath', cpu.FastMathOptions(True)) super(TestSVML, self).__init__(*args) def compile(self, func, *args, **kwargs): assert not kwargs sig = tuple([numba.typeof(x) for x in args]) std = compile_isolated(func, sig, flags=self.flags) fast = compile_isolated(func, sig, flags=self.fastflags) return std, fast def copy_args(self, *args): if not args: return tuple() new_args = [] for x in args: if isinstance(x, np.ndarray): new_args.append(x.copy('k')) elif isinstance(x, np.number): new_args.append(x.copy()) elif isinstance(x, numbers.Number): new_args.append(x) else: raise ValueError('Unsupported argument type encountered') return tuple(new_args) def check(self, pyfunc, *args, **kwargs): jitstd, jitfast = self.compile(pyfunc, *args) std_pattern = kwargs.pop('std_pattern', None) fast_pattern = kwargs.pop('fast_pattern', None) cpu_name = kwargs.pop('cpu_name', 'skylake-avx512') # python result py_expected = pyfunc(*self.copy_args(*args)) # jit result jitstd_result = jitstd.entry_point(*self.copy_args(*args)) # fastmath result jitfast_result = jitfast.entry_point(*self.copy_args(*args)) # assert numerical equality np.testing.assert_almost_equal(jitstd_result, py_expected, **kwargs) np.testing.assert_almost_equal(jitfast_result, py_expected, **kwargs) # look for specific patters in the asm for a given target with override_env_config('NUMBA_CPU_NAME', cpu_name), \ override_env_config('NUMBA_CPU_FEATURES', ''): # recompile for overridden CPU jitstd, jitfast = self.compile(pyfunc, *args) if std_pattern: self.check_svml_presence(jitstd, std_pattern) if fast_pattern: self.check_svml_presence(jitfast, fast_pattern) def check_svml_presence(self, func, pattern): asm = func.library.get_asm_str() self.assertIn(pattern, asm) def test_scalar_context(self): # SVML will not be used. pat = '$_sin' if config.IS_OSX else '$sin' self.check(math_sin_scalar, 7., std_pattern=pat) self.check(math_sin_scalar, 7., fast_pattern=pat) def test_svml(self): # loops both with and without fastmath should use SVML. # The high accuracy routines are dropped if `fastmath` is set std = "__svml_sin8_ha," fast = "__svml_sin8," # No `_ha`! self.check(math_sin_loop, 10, std_pattern=std, fast_pattern=fast) def test_svml_disabled(self): code = """if 1: import os import numpy as np import math def math_sin_loop(n): ret = np.empty(n, dtype=np.float64) for x in range(n): ret[x] = math.sin(np.float64(x)) return ret def check_no_svml(): try: # ban the use of SVML os.environ['NUMBA_DISABLE_INTEL_SVML'] = '1' # delay numba imports to account for env change as # numba.__init__ picks up SVML and it is too late by # then to override using `numba.config` import numba from numba import config from numba.core import cpu from numba.tests.support import override_env_config from numba.core.compiler import compile_isolated, Flags # compile for overridden CPU, with and without fastmath with override_env_config('NUMBA_CPU_NAME', 'skylake-avx512'), \ override_env_config('NUMBA_CPU_FEATURES', ''): sig = (numba.int32,) f = Flags() f.set('nrt') std = compile_isolated(math_sin_loop, sig, flags=f) f.set('fastmath', cpu.FastMathOptions(True)) fast = compile_isolated(math_sin_loop, sig, flags=f) fns = std, fast # assert no SVML call is present in the asm for fn in fns: asm = fn.library.get_asm_str() assert '__svml_sin' not in asm finally: # not really needed as process is separate os.environ['NUMBA_DISABLE_INTEL_SVML'] = '0' config.reload_config() check_no_svml() """ popen = subprocess.Popen([sys.executable, "-c", code], stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, err = popen.communicate() if popen.returncode != 0: raise AssertionError( "process failed with code %s: stderr follows\n%s\n" % (popen.returncode, err.decode())) def test_svml_working_in_non_isolated_context(self): @njit(fastmath={'fast'}, error_model="numpy") def impl(n): x = np.empty(n * 8, dtype=np.float64) ret = np.empty_like(x) for i in range(ret.size): ret[i] += math.cosh(x[i]) return ret impl(1) self.assertTrue( 'intel_svmlcc' in impl.inspect_llvm(impl.signatures[0]))
from io import StringIO import numpy as np from numba.core import types from numba.core.compiler import compile_isolated, Flags from numba.tests.support import TestCase, tag, MemoryLeakMixin import unittest looplift_flags = Flags() looplift_flags.set("enable_pyobject") looplift_flags.set("enable_looplift") pyobject_looplift_flags = looplift_flags.copy() pyobject_looplift_flags.set("enable_pyobject_looplift") def lift1(x): # Outer needs object mode because of np.empty() a = np.empty(3) for i in range(a.size): # Inner is nopython-compliant a[i] = x return a def lift2(x): # Outer needs object mode because of np.empty() a = np.empty((3, 4)) for i in range(a.shape[0]): for j in range(a.shape[1]): # Inner is nopython-compliant
return obj.h 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.set("auto_parallel", ParallelOptions(True)) force_parallel_flags.set("nrt") class DebugTestBase(TestCase): all_dumps = set([ "bytecode", "cfg", "ir", "typeinfer", "llvm", "func_opt_llvm", "optimized_llvm", "assembly", ])