o 8ήc@sdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl mZmZmZmZddlmZmZmZmZmZmZmZddlZddlmZddlm Z edZ!zddl"m#Z#e#dd l$m%Z%d Z&Wn e'y~d Z&Ynwz dd l$m(Z(d Z)Wn e'yd Z)Ynwzddl*Z+d Z,Wn e'yd Z,Ynwe -e)d Z.e -e&dZ/e)oe(j0dkZ1e -e1dZ2ej34dZ5ej34dZ6ej7dkZ8e8Z9e5 Z:ddZ;e,rddZGddde?Z@Gdd d e@ZAGd!d"d"e?ZBGd#d$d$e@ZCGd%d&d&e@ZDGd'd(d(e@ZEd)d*ZFd+d,ZGe jHZIGd-d.d.e?ZJd/d0ZKeGeIejLZMeGeKd1ZNe5sQeGeKd2ZOeGeKd3ZPeGeKd4ZQGd5d6d6eZRe jSd7vZTe -eTd8Gd9d:d:eRZUeUVGd;d<dd>eWeRZXeXVGd?d@d@eZYeGdAdBdBeYZZeZVeGdCdDdDeYZ[eGdEdFdFeYZ\ee2GdGdHdHeYZ]ee/GdIdJdJeYZ^eGdKdLdLeZ_ee.GdMdNdNeZ`eadOkre bdSdS)Pz Tests the parallel backend N)jit vectorize guvectorizeset_num_threads)temp_directoryoverride_configTestCasetagskip_parfors_unsupported linux_onlyneeds_external_compilers)_TIMEOUT)configgN@)_check_tbb_version_compatible)tbbpoolTF)omppoolzOpenMP threadpool requiredzTBB threadpool requiredGNUzGNU OpenMP only testswindarwinlcCt||SN)nponesnvrH/tmp/pip-target-vg8gfxp4/lib/python/numba/tests/test_parallel_backend.pyfooHsrcCs2tt||ft||f}|t||Sr)rdotrarange)rrxrrrlinalgMs r"cCrr)rr rrrrr"QscCs||Srr)abrrr ufunc_fooVsr%cCs|||d<dS)Nrr)r#r$outrrr gufunc_fooZsr'c@eZdZddZdS)runnablecK ||_dSr)_options)selfoptionsrrr__init___ zrunnable.__init__N)__name__ __module__ __qualname__r.rrrrr)^s r)c@r() jit_runnercCBtdi|jt}d}d}t||}|||}tj||dSN r)rr+rrtestingassert_allcloser,cfuncr#r$expectedgotrrr__call__e   zjit_runner.__call__Nr0r1r2r>rrrrr3c r3c@eZdZddZddZdS) mask_runnercKs||_||_dSr)runnermask)r,rDrEr-rrrr.os zmask_runner.__init__cCs|jrt|j|dSr)rErrD)r,rrrr>ss  zmask_runner.__call__Nr0r1r2r.r>rrrrrCns rCc@r() linalg_runnercCr4r5)rr+r"rr8r9r:rrrr>}r?zlinalg_runner.__call__Nr@rrrrrG{rArGc@r()vectorize_runnercCsVtdgfi|jt}tjdtj}}t||}|||}tj||dS)Nz(f4, f4)r7) rr+r%rrandomastypefloat32r8r9r:rrrr>s   zvectorize_runner.__call__Nr@rrrrrHrArHc@r()guvectorize_runnercCs\dg}t|dfi|jt}tjdtj}}t||}|||}tj ||dS)Nz(f4, f4, f4[:])z (),()->()r7) rr+r'rrIrJrKr%r8r9)r,sigr;r#r$r<r=rrrr>s   zguvectorize_runner.__call__Nr@rrrrrLrArLc Kst|d}ztttt|dD] }t|}|qWdSty9}z | |WYd}~dSd}~ww)Nqueueg?) get faulthandlerenablerangeintlenrIchoice Exceptionput)fnlistkwargsq_fnerrrchoosers  r^cfdd}|S)Ncs}d|ifddtdD}|D]}|q|D]}|q|sLg}|s<||d|r0d}t|ddd|DdS) NrNcsg|] }tfdqS))targetargsrY)r^).0i)rXkwsparallel_classrr sz8compile_factory..run_compile..r6Fz)Error(s) occurred in delegated runner: %s cSsg|]}t|qSr)repr)rbr!rrrrfs)rRstartjoinemptyappendrO RuntimeError)rXrZthstherrors_msgre queue_impl)rXrdr run_compiles"  z$compile_factory..run_compiler)rersrtrrrrcompile_factorysruc@rB)_proc_class_implcCr*r)_method)r,methodrrrr.r/z_proc_class_impl.__init__cOst|j}|j|i|Sr)multiprocessing get_contextrwProcess)r,rarYctxrrrr>s z_proc_class_impl.__call__NrFrrrrrvs rvcCs,|dkrd}t|}t|}|j}||fS)Ndefault)ryrzrvQueue)rxr|procrNrrr_get_mp_classess  rspawnfork forkserverr}c@sheZdZdZeddedddedddeddedddeddedddeddddeddedddeddddg Ze s\eddd edddd eddd edddd gZ e e e j d krdgZnd d gZgZeD]ZeD] Zeeeeqpqld dgZederededede d gedddgedddgeedZddhZdddZdS)TestParallelBackendBasez6 Base class for testing the parallel backends T)nopython)rcache)rnogilparallel)rr`)rr`r)rr)rrr threadingrImultiprocessing_spawnmultiprocessing_forkmultiprocessing_forkserver)concurrent_jitconcurrent_vectorizeconcurrent_guvectorizeconcurrent_mix_useconcurrent_mix_use_masksomptbbcCs<t|jj|_td|j|dkrt|nM|dkr t|nL|dkr)t|nK|dkr2t|nJ|dkr;t |nI|dkr^ttg}t rO| t| tt ||D]}||qVn.td|WddSWddSWddSWddSWddSWddS1swYdS) N CACHE_DIRrrrrmultiprocessing_defaultrIzUnknown parallelism supplied %s)r __class__r0 _cache_dirr thread_implfork_proc_implforkserver_proc_implspawn_proc_impldefault_proc_impl _HAVE_OS_FORKrlrIshuffle ValueError)r,rX parallelismpsimplrrrrtsH          "z#TestParallelBackendBase.run_compileN)r)r0r1r2__doc__r3rGrHrL all_impls_parfors_unsupported parfor_implsextendrNUMBA_NUM_THREADSmasks mask_implsrrErlrCrrrunners safe_backendsrtrrrrrsZ                   r)rr workqueuezThreading layer not explicitc@seZdZdZeddZdS)TestParallelBackendav These are like the numba.tests.test_threadsafety tests but designed instead to torture the parallel backend. If a suitable backend is supplied via NUMBA_THREADING_LAYER these tests can be run directly. This test class cannot be run using the multiprocessing option to the test runner (i.e. `./runtests -m`) as daemon processes cannot have children. cCsX|jD]&}|jD]\}}d|d|}dd}|||}||_t|||q qdS)Ntest_r[cr_)Ncs2t}|jrd}||dS|jddS)Nz)daemonized processes cannot have children)r)rycurrent_processdaemonskipTestrt)r,selfprocrqrprr test_methodJs zBTestParallelBackend.generate..methgen..test_methodr)rrrrrrmethgenIsz-TestParallelBackend.generate..methgen)rritemsr0setattr)clsrnamermethnamerr\rrrgenerateCs  zTestParallelBackend.generateN)r0r1r2r classmethodrrrrrr6s rc@s0eZdZeeedddZddZddZ dS) TestInSubprocessFrrrcCs~tj|tjtj|d}tt|j}z'||\}}|j dkr-t d|j | f| | fW| S| w)Nstdoutstderrenvr/process failed with code %s: stderr follows %s subprocessPopenPIPErTimer _TEST_TIMEOUTkillri communicate returncodeAssertionErrordecodecancelr,cmdlinerpopentimeoutr&errrrrrun_cmd`s"   zTestInSubprocess.run_cmdcCs0tj}t||d<tjdd|g}|||S)NNUMBA_THREADING_LAYERz-mznumba.runtests)osenvironcopystrsys executabler)r,testthreading_layerenv_copyrrrrrun_test_in_separate_processss   z-TestInSubprocess.run_test_in_separate_processN) r0r1r2 skip_no_tbb skip_no_ompunittestskipIfbackendsrrrrrrr[s  rc@s,eZdZdZdZeddZeddZdS)TestSpecificBackenda This is quite contrived, for each test in the TestParallelBackend tests it generates a test that will run the TestParallelBackend test in a new python process with an environment modified to ensure a specific threadsafe backend is used. This is with view of testing the backends independently and in an isolated manner such that if they hang/crash/have issues, it doesn't kill the test suite. Fc sb|j}tj}d|d|}d|||ffdd}d||f} t|| td||dS)Nrr[z%s.%s.%scsR|\}}|jrtd||f|d||d|v|d|vdS)Nzstdout: "%s" stderr: "%s"OKFAILERROR)r_DEBUGprintassertIn assertTrue)r,or]backendinjected_methodrr test_templates  z2TestSpecificBackend._inject..test_templatez test_%s_%s_%s long_running)r1rr0rr ) rrrr backend_guardthemodtheclsrr injected_testrrr_injectszTestSpecificBackend._injectc Cst|jD]2\}}|jD]*}|jD]"}|dvr$|dkr$tjdr$q|dvr-|dkr-q|||||qq qdS)N)rrIrlinux)rrIr) rrrrkeysrplatform startswithr)rrrrrrrrrs"  zTestSpecificBackend.generateN)r0r1r2rrrrrrrrrrzs rc@s6eZdZdZdejeZddeiZ dddZ dS) ThreadLayerTestHelperzP Helper class for running an isolated piece of code based on a template z%raif 1: import sys sys.path.insert(0, "%(here)r") import multiprocessing import numpy as np from numba import njit import numba try: import threading_backend_usecases except ImportError as e: print("DEBUG:", sys.path) raise e import os sigterm_handler = threading_backend_usecases.sigterm_handler busy_func = threading_backend_usecases.busy_func def the_test(): %%s if __name__ == "__main__": the_test() hereNcCs|durtj}td|d<tj|tjtj|d}tt |j }z | | \}}|j dkr.test_templatez test_threading_layer_selector_%s important)rr )rrrrrrrrrs z#TestThreadingLayerSelection._injectcCs$|jD] \}}|||qdSr)rrr)rrrrrrrsz$TestThreadingLayerSelection.generateN) r0r1r2rrrrrrrrrrrrrrr s  r c@sZeZdZdefddZeeddZeeddZedd Z ed d Z d d Z dS)TestThreadingLayerPriorityenv_varcCsJtj}d|d<||d<d|d}tjdt|g}|j||ddS) zJTest setting priority via env var NUMBA_THREADING_LAYER_PRIORITY. r}rNUMBA_THREADING_LAYER_PRIORITYa import numba # trigger threading layer decision # hence catching invalid THREADING_LAYER_PRIORITY @numba.jit( 'float64[::1](float64[::1], float64[::1])', nopython=True, parallel=True, ) def plus(x, y): return x + y captured_envvar = list("a ".split()) assert numba.config.THREADING_LAYER_PRIORITY == captured_envvar, "priority mismatch" assert numba.threading_layer() == captured_envvar[0], "selected backend mismatch" r r N)rrrrrtextwrapdedentr)r,rrcodecmdrrr each_env_vars  z'TestThreadingLayerPriority.each_env_varcCs0gd}t|D] }d|}||q dS)Nr ) itertools permutationsrjr)r,r}rrrrrtest_valid_env_var3s   z-TestThreadingLayerPriority.test_valid_env_varcCsZd}|t }||Wdn1swYdD] }||t|jqdS)Nztbb omp workqueue notvalidhere)z!THREADING_LAYER_PRIORITY invalid:zIt must be a permutation of) assertRaisesrrrr exception)r,rraisesmsgrrrtest_invalid_env_var;s  z/TestThreadingLayerPriority.test_invalid_env_varcCdD]}||qdS)N)zomp tbb workqueuezomp workqueue tbbrr,rrrrtest_ompG z#TestThreadingLayerPriority.test_ompcCr!)N)ztbb omp workqueueztbb workqueue ompr"r#rrrtest_tbbLr%z#TestThreadingLayerPriority.test_tbbcCr!)N)zworkqueue tbb ompzworkqueue omp tbbr"r#rrrtest_workqueueQs z)TestThreadingLayerPriority.test_workqueueN) r0r1r2rrrrrr r$r&r'rrrrrs!     rc@sHeZdZdZdZeddZeddZddZ e e d d d Z d S) TestMiscBackendIssueszL Checks fixes for the issues with threading backends implementation FcC<d}tjd|g}tj}d|d<d|d<|j||ddS) z8 Tests that OMP does not overflow stack aif 1: from numba import vectorize, threading_layer import numpy as np @vectorize(['f4(f4,f4,f4,f4,f4,f4,f4,f4)'], target='parallel') def foo(a, b, c, d, e, f, g, h): return a+b+c+d+e+f+g+h x = np.ones(2**20, np.float32) foo(*([x]*8)) assert threading_layer() == "omp", "omp not found" r rr100K OMP_STACKSIZEr Nrrrrrrr,r rrrrrtest_omp_stack_overflow]s  z-TestMiscBackendIssues.test_omp_stack_overflowcCr)) zq Tests that TBB works well with single thread https://github.com/numba/numba/issues/3440 aMif 1: from numba import njit, prange, threading_layer @njit(parallel=True) def foo(n): acc = 0 for i in prange(n): acc += i return acc foo(100) assert threading_layer() == "tbb", "tbb not found" r rr1rr Nr,r-rrrtest_single_thread_tbbts  z,TestMiscBackendIssues.test_single_thread_tbbc Csd}tjd|g}tj}d|d<d|d<z |j||d\}}Wd StyL}z|jr1t||t |}| d|| d |WYd }~d Sd }~ww) zW Tests workqueue raises sigabrt if a nested parallel call is performed aif 1: from numba import njit, prange import numpy as np @njit(parallel=True) def nested(x): for i in prange(len(x)): x[i] += 1 @njit(parallel=True) def main(): Z = np.zeros((5, 10)) for i in prange(Z.shape[0]): nested(Z[i]) return Z main() r rr4rr zfailed with codez3Terminating: Nested parallel kernel launch detectedN) rrrrrrrrrrr)r,r rrr&rr]e_msgrrr+test_workqueue_aborts_on_nested_parallelisms"    zATestMiscBackendIssues.test_workqueue_aborts_on_nested_parallelismzTest needs fork(2)cCs<d}tjd|g}tj}d|d<d|d<|j||ddS)Naif 1: from numba import njit, prange, threading_layer import numpy as np import multiprocessing if __name__ == "__main__": # Need for force fork context (OSX default is "spawn") multiprocessing.set_start_method('fork') @njit(parallel=True) def func(x): return 10. * x arr = np.arange(2.) # run in single process to start Numba's thread pool np.testing.assert_allclose(func(arr), func.py_func(arr)) # now run in a multiprocessing pool to get a fork from a # non-main thread with multiprocessing.Pool(10) as p: result = p.map(func, [arr]) np.testing.assert_allclose(result, func.py_func(np.expand_dims(arr, 0))) assert threading_layer() == "workqueue" r rrr1rr r,r-rrr0test_workqueue_handles_fork_from_non_main_threads   zFTestMiscBackendIssues.test_workqueue_handles_fork_from_non_main_threadN)r0r1r2rrrr.rr0r3r skipUnlessrr4rrrrr(Vs   (r(c@sTeZdZdZdZddZddZddZed d Z d d Z d dZ eddZ dS)TestForkSafetyIssueszV Checks Numba's behaviour in various situations involving GNU OpenMP and fork FcCs"d}tjd|g}||\}}dS)Nzsif 1: from numba.np.ufunc import omppool assert omppool.openmp_vendor == 'GNU' r )rrr)r,r rr&rrrr!test_check_threading_layer_is_gnus z6TestForkSafetyIssues.test_check_threading_layer_is_gnuc Csfd}|j|}tjd|g}z ||\}}WdSty2}z|dt|WYd}~dSd}~ww)z~ Whilst normally valid, this actually isn't for Numba invariant of OpenMP Checks SIGABRT is received. zif 1: X = np.arange(1000000.) Y = np.arange(1000000.) Z = busy_func(X, Y) pid = os.fork() if pid == 0: Z = busy_func(X, Y) else: os.wait() r zfailed with code -6N)rrrrrrr)r,r r rr&rr]rrr!test_par_parent_os_fork_par_childs z6TestForkSafetyIssues.test_par_parent_os_fork_par_childcC@d}|j|}tjd|g}||\}}|jrt||dSdS)au Implicit use of multiprocessing fork context. Does this: 1. Start with OpenMP 2. Fork to processes using OpenMP (this is invalid) 3. Joins fork 4. Check the exception pushed onto the queue that is a result of catching SIGTERM coming from the C++ aborting on illegal fork pattern for GNU OpenMP aif 1: mp = multiprocessing.get_context('fork') X = np.arange(1000000.) Y = np.arange(1000000.) q = mp.Queue() # Start OpenMP runtime on parent via parallel function Z = busy_func(X, Y, q) # fork() underneath with no exec, will abort proc = mp.Process(target = busy_func, args=(X, Y, q)) proc.start() err = q.get() assert "Caught SIGTERM" in str(err) r Nrrrrrrr,r r rr&rrrr*test_par_parent_implicit_mp_fork_par_childs  z?TestForkSafetyIssues.test_par_parent_implicit_mp_fork_par_childcCr9)au Explicit use of multiprocessing fork context. Does this: 1. Start with OpenMP 2. Fork to processes using OpenMP (this is invalid) 3. Joins fork 4. Check the exception pushed onto the queue that is a result of catching SIGTERM coming from the C++ aborting on illegal fork pattern for GNU OpenMP aif 1: X = np.arange(1000000.) Y = np.arange(1000000.) q = multiprocessing.Queue() # Start OpenMP runtime on parent via parallel function Z = busy_func(X, Y, q) # fork() underneath with no exec, will abort ctx = multiprocessing.get_context('fork') proc = ctx.Process(target = busy_func, args=(X, Y, q)) proc.start() proc.join() err = q.get() assert "Caught SIGTERM" in str(err) r Nr:r;rrr*test_par_parent_explicit_mp_fork_par_child's  z?TestForkSafetyIssues.test_par_parent_explicit_mp_fork_par_childcCr9)z Explicit use of multiprocessing spawn, this is safe. Does this: 1. Start with OpenMP 2. Spawn to processes using OpenMP 3. Join spawns 4. Run some more OpenMP aif 1: X = np.arange(1000000.) Y = np.arange(1000000.) q = multiprocessing.Queue() # Start OpenMP runtime and run on parent via parallel function Z = busy_func(X, Y, q) procs = [] ctx = multiprocessing.get_context('spawn') for x in range(20): # start a lot to try and get overlap ## fork() + exec() to run some OpenMP on children proc = ctx.Process(target = busy_func, args=(X, Y, q)) procs.append(proc) sys.stdout.flush() sys.stderr.flush() proc.start() [p.join() for p in procs] try: q.get(False) except multiprocessing.queues.Empty: pass else: raise RuntimeError("Queue was not empty") # Run some more OpenMP on parent Z = busy_func(X, Y, q) r Nr:r;rrr-test_par_parent_mp_spawn_par_child_par_parentJs  zBTestForkSafetyIssues.test_par_parent_mp_spawn_par_child_par_parentcCr9)a Implicit use of multiprocessing (will be fork, but cannot declare that in Py2.7 as there's no process launch context). Does this: 1. Start with no OpenMP 2. Fork to processes using OpenMP 3. Join forks 4. Run some OpenMP a,if 1: X = np.arange(1000000.) Y = np.arange(1000000.) q = multiprocessing.Queue() # this is ok procs = [] for x in range(10): # fork() underneath with but no OpenMP in parent, this is ok proc = multiprocessing.Process(target = busy_func, args=(X, Y, q)) procs.append(proc) proc.start() [p.join() for p in procs] # and this is still ok as the OpenMP happened in forks Z = busy_func(X, Y, q) try: q.get(False) except multiprocessing.queues.Empty: pass else: raise RuntimeError("Queue was not empty") r Nr:r;rrr=test_serial_parent_implicit_mp_fork_par_child_then_par_parentv  zRTestForkSafetyIssues.test_serial_parent_implicit_mp_fork_par_child_then_par_parentcCr9)z Explicit use of multiprocessing 'fork'. Does this: 1. Start with no OpenMP 2. Fork to processes using OpenMP 3. Join forks 4. Run some OpenMP a'if 1: X = np.arange(1000000.) Y = np.arange(1000000.) q = multiprocessing.Queue() # this is ok procs = [] ctx = multiprocessing.get_context('fork') for x in range(10): # fork() underneath with but no OpenMP in parent, this is ok proc = ctx.Process(target = busy_func, args=(X, Y, q)) procs.append(proc) proc.start() [p.join() for p in procs] # and this is still ok as the OpenMP happened in forks Z = busy_func(X, Y, q) try: q.get(False) except multiprocessing.queues.Empty: pass else: raise RuntimeError("Queue was not empty") r Nr:r;rrr=test_serial_parent_explicit_mp_fork_par_child_then_par_parentr@zRTestForkSafetyIssues.test_serial_parent_explicit_mp_fork_par_child_then_par_parentN) r0r1r2rrr7r8r<r r=r>r?rArrrrr6s! ",)r6c@s,eZdZdZeddZeeddZdS)TestTBBSpecificIssuesFcCsPd}tjd|g}||\}}d}||||jr&td|td|dSdS)Na%if 1: import threading import numba numba.config.THREADING_LAYER='tbb' from numba import njit, prange, objmode from numba.core.serialize import PickleCallableByPath import os e_running = threading.Event() e_proceed = threading.Event() def indirect_core(): e_running.set() # wait for forker() to have forked while not e_proceed.isSet(): pass indirect = PickleCallableByPath(indirect_core) @njit def obj_mode_func(): with objmode(): indirect() @njit(parallel=True, nogil=True) def work(): acc = 0 for x in prange(10): acc += x obj_mode_func() return acc def runner(): work() def forker(): # wait for the jit function to say it's running while not e_running.isSet(): pass # then fork os.fork() # now fork is done signal the runner to proceed to exit e_proceed.set() numba_runner = threading.Thread(target=runner,) fork_runner = threading.Thread(target=forker,) threads = (numba_runner, fork_runner) for t in threads: t.start() for t in threads: t.join() r z9Attempted to fork from a non-main thread, the TBB libraryOUT:ERR:)rrrrrr)r,r rr&rmsg_headrrrtest_fork_from_non_main_threads 6  z4TestTBBSpecificIssues.test_fork_from_non_main_threadcCsd}dd|}tjd|g}tj}d|d<|j||d\}}||vr*|dn|d ||j r?t d |t d |dSdS) NzSKIP: COMPILATION FAILEDar if 1: import ctypes import sys import multiprocessing as mp from tempfile import TemporaryDirectory, NamedTemporaryFile from numba.pycc.platform import Toolchain, _external_compiler_ok from numba import njit, prange, threading_layer import faulthandler faulthandler.enable() if not _external_compiler_ok: raise AssertionError('External compilers are not found.') with TemporaryDirectory() as tmpdir: with NamedTemporaryFile(dir=tmpdir) as tmpfile: try: src = """ #define TBB_PREVIEW_WAITING_FOR_WORKERS 1 #include static tbb::task_scheduler_handle tsh; extern "C" { void launch(void) { tsh = tbb::task_scheduler_handle::get(); } } """ cxxfile = f"{tmpfile.name}.cxx" with open(cxxfile, 'wt') as f: f.write(src) tc = Toolchain() object_files = tc.compile_objects([cxxfile,], output_dir=tmpdir) dso_name = f"{tmpfile.name}.so" tc.link_shared(dso_name, object_files, libraries=['tbb',], export_symbols=['launch']) # Load into the process, it doesn't matter whether the # DSO exists on disk once it's loaded in. DLL = ctypes.CDLL(dso_name) except Exception as e: # Something is broken in compilation, could be one of # many things including, but not limited to: missing tbb # headers, incorrect permissions, compilers that don't # work for the above print(e) print('BROKEN_COMPILERS') sys.exit(0) # Do the test, launch this library and also execute a # function with the TBB threading layer. DLL.launch() @njit(parallel=True) def foo(n): acc = 0 for i in prange(n): acc += i return acc foo(1) # Check the threading layer used was TBB assert threading_layer() == 'tbb' # Use mp context for a controlled version of fork, this triggers the # reported bug. ctx = mp.get_context('fork') def nowork(): pass p = ctx.Process(target=nowork) p.start() p.join(10) print("SUCCESS") BROKEN_COMPILERSr rrr z3Compilation of DSO failed. Check output for detailsSUCCESSrCrD) replacerrrrrrrrrr)r,rGr rrr&rrrr&test_lifetime_of_task_scheduler_handle*sK M    z Checks the OpenMP vendor strings are correct MSwin32IntelrrrN)dictrrrr assertEqualr openmp_vendor)r,r<krrr test_vendorss  zTestOpenMPVendors.test_vendorsN)r0r1r2rZrrrrrRs rR__main__)crrPrryrrIrrrrrnumpyrnumbarrrrnumba.tests.supportrrrr r r r rNt_queuenumba.testing.mainr _RUNNER_TIMEOUT numba.corerrnumba.np.ufunc.parallelrnumba.np.ufuncr_HAVE_TBB_POOL ImportErrorr_HAVE_OMP_POOLscipy.linalg.cython_lapackscipy _HAVE_LAPACKr5rrrX_gnuompskip_unless_gnu_omprr_windows_osxmaxsize_32bitrrrr"r%r'objectr)r3rCrGrHrLr^ruThread _thread_classrvrr~rrrrrrTHREADING_LAYER_specific_backendsrrrrrr rr(r6rBrKrRr0mainrrrrs$                          X !36%F hA<