U .d@sdZddlZddlZddlZddlZddlZddlZddlmZddl m Z m Z ddl m Z ddlmZdZdd d gZejd d ejd krejnejZejd krejnejZGdddejZz ejZWnek rejZYnXddddddddddddddddddddZ e!e"dd e #DZ$d!d"e #DZ%e!e"d#d e #DZ&d$d"e #DZ'e!e d%d&Z(d'd(Z)e d)d*d+d,Z*e)e!e$e%d-d.d Z+Gd/d0d0Z,Gd1d2d2e,eZ-e)d3.d4d e$Dd3.e'd3.e(d5Gd6dde,Z/e)d3.d7d e&Dd3.d8d e$Dd3.e'd3.e(d9Gd:d d Z0e)d3.d;d e$Dd3.dd>e Z1Gd?d@d@e1Z2GdAdBdBe1Z3GdCdDdDe1Z4GdEd%d%e1Z5dFdGZ6e7dHkre6dS)Izthreadpoolctl This module provides utilities to introspect native libraries that relies on thread pools (notably BLAS and OpenMP implementations) and dynamically set the maximal number of threads they can use. N) find_library)ABCabstractmethod) lru_cache)ContextDecoratorz3.1.0threadpool_limitsthreadpool_infoThreadpoolControllerZKMP_DUPLICATE_LIB_OKTruelc@s,eZdZdefdejfdejfdefgZdS) _dl_phdr_infoZ dlpi_addr dlpi_nameZ dlpi_phdrZ dlpi_phnumN) __name__ __module__ __qualname__ _SYSTEM_UINTctypesc_char_pc_void_p_SYSTEM_UINT_HALF_fields_rr1/tmp/pip-unpacked-wheel-hgipyrju/threadpoolctl.pyr /s r openmp)libiompZlibgomplibompZvcomp)user_api internal_apifilename_prefixesblasopenblas)Z libopenblaslibblas)openblas_get_num_threadsopenblas_get_num_threads64_)rrr check_symbolsZmkl)Z libmkl_rtZmkl_rtr )MKL_Get_Max_ThreadsZblis)Zlibblisr )bli_thread_get_num_threads)OpenMPControllerOpenBLASController MKLControllerBLISControllerccs|]}|dVqdS)rNr.0librrr `sr-cCsg|] }|dqS)rrr*rrr asr.ccs |]}|dD] }|VqqdS)rNr)r+r,prefixrrrr-cs cCs g|]}|ddkr|dqS)rrrrr*rrrr.is r&rcsfdd}|S)Ncs|jdk r|jj|_|SN)__doc__format)oargskwargsrr decoratorts z$_format_docstring..decoratorr)r5r6r7rr4r_format_docstringssr8i')maxsizecCs tj|S)zCSmall caching wrapper around os.path.realpath to limit system calls)ospathrealpath)filepathrrr _realpath|sr>) USER_APISZ INTERNAL_APIScCs tS)aReturn the maximal number of threads for each detected library. Return a list with all the supported libraries that have been found. Each library is represented by a dict with the following information: - "user_api" : user API. Possible values are {USER_APIS}. - "internal_api": internal API. Possible values are {INTERNAL_APIS}. - "prefix" : filename prefix of the specific implementation. - "filepath": path to the loaded library. - "version": version of the library (if available). - "num_threads": the current thread limit. In addition, each library may contain internal_api specific entries. )r inforrrrrsc@sheZdZdZdddddZddZdd Zedddd d Zd d Z e Z ddZ ddZ ddZ dS)_ThreadpoolLimiteraThe guts of ThreadpoolController.limit Refer to the docstring of ThreadpoolController.limit for more details. It will only act on the library controllers held by the provided `controller`. Using the default constructor sets the limits right away such that it can be used as a callable. Setting the limits can be delayed by using the `wrap` class method such that it can be used as a decorator. NlimitsrcCs6||_|||\|_|_|_|j|_|dSr0) _controller _check_params_limits _user_api _prefixesr@_original_info_set_threadpool_limitsself controllerrCrrrr__init__s z_ThreadpoolLimiter.__init__cCs|Sr0rrLrrr __enter__sz_ThreadpoolLimiter.__enter__cCs |dSr0)restore_original_limits)rLtypevalue tracebackrrr__exit__sz_ThreadpoolLimiter.__exit__cCst|||dS)z@Return an instance of this class that can be used as a decorator)rMrCr)_ThreadpoolLimiterDecorator)clsrMrCrrrrwraps z_ThreadpoolLimiter.wrapcCs,t|jj|jD]\}}||dqdS)z,Set the limits back to their original values num_threadsN)ziprDlib_controllersrIset_num_threads)rLlib_controllerZ original_inforrrrQs  z*_ThreadpoolLimiter.restore_original_limitscsi}g}|jD]bfdd|jD}t|}t|}|dkrH|}n |dkrVd}nt|}|||<q|rtdd |d|S) zuOriginal num_threads from before calling threadpool_limits Return a dict `{user_api: num_threads}`. cs g|]}|dkr|dqS)rrYrr+Zlib_inforrrr.s z?_ThreadpoolLimiter.get_original_num_threads..rNz1Multiple value possible for following user apis: , z. Returning the minimum.) rGrIsetlenpopminappendwarningswarnjoin)rLrYZ warning_apisrCZn_limitslimitrr_rget_original_num_threadss0     z+_ThreadpoolLimiter.get_original_num_threadscsttr$dkr$|j\}dks6ttr|dkrDt}n&|tkrT|g}ntdtd|ddk rfdd|Dg}nnttrddDntt rd dj Dtt st d t d d d D}dd D}||fS)zCSuitable values for the _limits, _user_api and _prefixes attributesZsequential_blas_under_openmpNzuser_api must be either in z or None. Got z instead.csi|] }|qSrrr+apirCrr sz4_ThreadpoolLimiter._check_params..cSsi|]}|d|dqSr/rYrr^rrrroscSsi|]}|j|jqSrrpr+r]rrrroszUlimits must either be an int, a list, a dict, or 'sequential_blas_under_openmp'. Got z insteadcSsg|]}|tkr|qSr) _ALL_PREFIXESr+r/rrrr.sz4_ThreadpoolLimiter._check_params..cSsg|]}|tkr|qSr)_ALL_USER_APISrlrrrr.s) isinstancestrrD,_get_params_for_sequential_blas_under_openmpvaluesintrt ValueErrorlistr r[dict TypeErrorrR)rLrCrprefixesrrnrrEs>    z _ThreadpoolLimiter._check_paramscCsh|jdkrdS|jjD]L}|j|jkr4|j|j}n|j|jkr|j|j}nq|dk r||qdS)zChange the maximal number of threads in selected thread pools. Return a list with all the supported libraries that have been found matching `self._prefixes` and `self._user_api`. N)rFrDr[r/rr\)rLr]rYrrrrJs    z)_ThreadpoolLimiter._set_threadpool_limits)r rrr1rNrPrU classmethodrXrQ unregisterrkrErJrrrrrAs $3rAc@s(eZdZdZdddddZddZdS)rVz8Same as _ThreadpoolLimiter but to be used as a decoratorNrBcCs"|||\|_|_|_||_dSr0)rErFrGrHrDrKrrrrN1s z$_ThreadpoolLimiterDecorator.__init__cCs|j|_||Sr0)rDr@rIrJrOrrrrP7s z%_ThreadpoolLimiterDecorator.__enter__)r rrr1rNrPrrrrrV.srVraccs|]}d|dVqdS"Nrrlrrrr-Asr? BLAS_LIBS OPENMP_LIBScs4eZdZdZdfdd Zedfdd ZZS) ragChange the maximal number of threads that can be used in thread pools. This object can be used either as a callable (the construction of this object limits the number of threads), as a context manager in a `with` block to automatically restore the original state of the controlled libraries when exiting the block, or as a decorator through its `wrap` method. Set the maximal number of threads that can be used in thread pools used in the supported libraries to `limit`. This function works for libraries that are already loaded in the interpreter and can be changed dynamically. This effect is global and impacts the whole Python process. There is no thread level isolation as these libraries do not offer thread-local APIs to configure the number of threads to use in nested parallel calls. Parameters ---------- limits : int, dict, 'sequential_blas_under_openmp' or None (default=None) The maximal number of threads that can be used in thread pools - If int, sets the maximum number of threads to `limits` for each library selected by `user_api`. - If it is a dictionary `{{key: max_threads}}`, this function sets a custom maximum number of threads for each `key` which can be either a `user_api` or a `prefix` for a specific library. - If 'sequential_blas_under_openmp', it will chose the appropriate `limits` and `user_api` parameters for the specific use case of sequential BLAS calls within an OpenMP parallel region. The `user_api` parameter is ignored. - If None, this function does not do anything. user_api : {USER_APIS} or None (default=None) APIs of libraries to limit. Used only if `limits` is an int. - If "blas", it will only limit BLAS supported libraries ({BLAS_LIBS}). - If "openmp", it will only limit OpenMP supported libraries ({OPENMP_LIBS}). Note that it can affect the number of threads used by the BLAS libraries if they rely on OpenMP. - If None, this function will apply to all supported libraries. Ncstjt||ddSNrB)superrNr rLrCr __class__rrrNtszthreadpool_limits.__init__cstjt||dSr)rrXr )rWrCrrrrrXwszthreadpool_limits.wrap)NN)NN)r rrr1rNrrX __classcell__rrrrr@s.ccs|]}d|dVqdSrrrsrrrr-}sccs|]}d|dVqdSrrrlrrrr-~s)PREFIXESr?rrc@seZdZdZeZddZeddZddZ dd Z d d Z e d d deDd ed eddddddZe d ddeDd ed eddddddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zed'd(Zed)d*ZdS)+r zCollection of LibController objects for all loaded supported libraries Attributes ---------- lib_controllers : list of `LibController` objects The list of library controllers of all loaded supported libraries. cCsg|_||dSr0)r[_load_libraries_warn_if_incompatible_openmprOrrrrNszThreadpoolController.__init__cCs||}||_|Sr0)__new__r[)rWr[Znew_controllerrrr_from_controllerss z&ThreadpoolController._from_controllerscCsdd|jDS)z.Return lib_controllers info as a list of dictscSsg|] }|qSr)r@rqrrrr.sz-ThreadpoolController.info..)r[rOrrrr@szThreadpoolController.infoc sHD] \}}t|ts |gn||<qfdd|jD}t|S)a>Return a ThreadpoolController containing a subset of its current library controllers It will select all libraries matching at least one pair (key, value) from kwargs where key is an entry of the library info dict (like "user_api", "internal_api", "prefix", ...) and value is the value or a list of acceptable values for that entry. For instance, `ThreadpoolController().select(internal_api=["blis", "openblas"])` will select all library controllers whose internal_api is either "blis" or "openblas". cs*g|]"tfddDrqS)c3s"|]\}}t|d|kVqdSr0)getattr)r+keyvalsr]rrr-sz9ThreadpoolController.select...)anyitems)r+r6rrr.s  z/ThreadpoolController.select..)rrur{r[r r)rLr6rrr[rrrselects   zThreadpoolController.selectcCs$|jdddjrdddSdddS)zReturn appropriate params to use for a sequential BLAS call in an OpenMP loop This function takes into account the unexpected behavior of OpenBLAS with the OpenMP threading layer. rr)rthreading_layerNrBr`r)rr[rOrrrrws  zAThreadpoolController._get_params_for_sequential_blas_under_openmpraccs|]}d|VqdSz"{}"Nr2rlrrrr-szThreadpoolController.rNrBcCst|||dS)aChange the maximal number of threads that can be used in thread pools. This function returns an object that can be used either as a callable (the construction of this object limits the number of threads) or as a context manager, in a `with` block to automatically restore the original state of the controlled libraries when exiting the block. Set the maximal number of threads that can be used in thread pools used in the supported libraries to `limits`. This function works for libraries that are already loaded in the interpreter and can be changed dynamically. This effect is global and impacts the whole Python process. There is no thread level isolation as these libraries do not offer thread-local APIs to configure the number of threads to use in nested parallel calls. Parameters ---------- limits : int, dict, 'sequential_blas_under_openmp' or None (default=None) The maximal number of threads that can be used in thread pools - If int, sets the maximum number of threads to `limits` for each library selected by `user_api`. - If it is a dictionary `{{key: max_threads}}`, this function sets a custom maximum number of threads for each `key` which can be either a `user_api` or a `prefix` for a specific library. - If 'sequential_blas_under_openmp', it will chose the appropriate `limits` and `user_api` parameters for the specific use case of sequential BLAS calls within an OpenMP parallel region. The `user_api` parameter is ignored. - If None, this function does not do anything. user_api : {USER_APIS} or None (default=None) APIs of libraries to limit. Used only if `limits` is an int. - If "blas", it will only limit BLAS supported libraries ({BLAS_LIBS}). - If "openmp", it will only limit OpenMP supported libraries ({OPENMP_LIBS}). Note that it can affect the number of threads used by the BLAS libraries if they rely on OpenMP. - If None, this function will apply to all supported libraries. rB)rArrrrrjs3zThreadpoolController.limitccs|]}d|VqdSrrrlrrrr-scCstj|||dS)aChange the maximal number of threads that can be used in thread pools. This function returns an object that can be used as a decorator. Set the maximal number of threads that can be used in thread pools used in the supported libraries to `limits`. This function works for libraries that are already loaded in the interpreter and can be changed dynamically. Parameters ---------- limits : int, dict or None (default=None) The maximal number of threads that can be used in thread pools - If int, sets the maximum number of threads to `limits` for each library selected by `user_api`. - If it is a dictionary `{{key: max_threads}}`, this function sets a custom maximum number of threads for each `key` which can be either a `user_api` or a `prefix` for a specific library. - If None, this function does not do anything. user_api : {USER_APIS} or None (default=None) APIs of libraries to limit. Used only if `limits` is an int. - If "blas", it will only limit BLAS supported libraries ({BLAS_LIBS}). - If "openmp", it will only limit OpenMP supported libraries ({OPENMP_LIBS}). Note that it can affect the number of threads used by the BLAS libraries if they rely on OpenMP. - If None, this function will apply to all supported libraries. rB)rArXrrrrrXs'zThreadpoolController.wrapcCs t|jSr0)rcr[rOrrr__len__%szThreadpoolController.__len__cCs4tjdkr|ntjdkr(|n|dS)zALoop through loaded shared libraries and store the supported onesdarwinwin32N)sysplatform_find_libraries_with_dyld+_find_libraries_with_enum_process_module_ex$_find_libraries_with_dl_iterate_phdrrOrrrr(s     z$ThreadpoolController._load_librariescs`}t|dsgSfdd}ttjtttjtj}||}td}| ||dS)anLoop through loaded libraries and return binders on supported ones This function is expected to work on POSIX system only. This code is adapted from code by Intel developer @anton-malakhov available at https://github.com/IntelPython/smp Copyright (c) 2017, Intel Corporation published under the BSD 3-Clause license dl_iterate_phdrcs$|jj}|r |d}|dS)Nutf-8r)contentsr decode_make_controller_from_path)r@sizedatar=rOrrmatch_library_callbackAs   zYThreadpoolController._find_libraries_with_dl_iterate_phdr..match_library_callbackN) _get_libchasattrr CFUNCTYPEc_intPOINTERr c_size_trr)rLlibcrZc_func_signatureZc_match_library_callbackrrrOrr1s    z9ThreadpoolController._find_libraries_with_dl_iterate_phdrcCs^|}t|dsgS|}tj|j_t|D](}t||}| d}| |q0dS)zLoop through loaded libraries and return binders on supported ones This function is expected to work on OSX system only _dyld_image_countrN) rrrrrZ_dyld_get_image_namerestyperange string_atrr)rLrZn_dyldir=rrrrVs    z.ThreadpoolController._find_libraries_with_dyldc CsFddlm}m}m}d}d}d}|d}|d}|||Bdt} | s`td tzd } |} || } t | } | | t | | t | |std | | jkrq| j| | } ql| j| | }t|| d |}t |} |}|D]:}|| |t | t |s td | j}||qW5| | Xd S)aLoop through loaded libraries and return binders on supported ones This function is expected to work on windows system only. This code is adapted from code by Philipp Hagemeister @phihag available at https://stackoverflow.com/questions/17474574 r)DWORDHMODULEMAX_PATHiZPsapikernel32FzCould not open PID zEnumProcessModulesEx failedNzGetModuleFileNameEx failed)Zctypes.wintypesrrr _get_windllZ OpenProcessr:getpidOSErrorZ CloseHandlersizeofZEnumProcessModulesExbyrefrSmapcreate_unicode_bufferZGetModuleFileNameExWr)rLrrrZPROCESS_QUERY_INFORMATIONZPROCESS_VM_READZLIST_LIBRARIES_ALLZps_apiZ kernel_32Z h_processZ buf_countneededbufbuf_sizecountZ h_modulesZn_sizeZh_moduler=rrrrisX      z@ThreadpoolController._find_libraries_with_enum_process_module_exc st|}tj|}tD]\}}|||d}|dkrBq |dkr|dr t |t t fdd|dDsq nq |d}|d }t |}|||||d } |j| q dS) z:Store a library controller if it is supported and selectedrNr .dllc3s|]}t|VqdSr0)r)r+funcr rrr-szBThreadpoolController._make_controller_from_path..r#rrr=r/rr)r>r:r;basenamelower_SUPPORTED_LIBRARIESr _check_prefixendswithrCDLL _RTLD_NOLOADrglobalsr[rf) rLr=filenamecontroller_classZ candidate_libr/rrZlib_controller_classr]rrrrs0    z/ThreadpoolController._make_controller_from_pathcCs |D]}||r|SqdS)z]Return the prefix library_basename starts with Return None if none matches. N startswith)rLZlibrary_basenamerr/rrrrs  z"ThreadpoolController._check_prefixcCsHtjdkrdSdd|jD}td}d|krDd|krDt|tdS)z?Raise a warning if llvm-OpenMP and intel-OpenMP are both loadedlinuxNcSsg|] }|jqSr)r/rqrrrr.szEThreadpoolController._warn_if_incompatible_openmp..a Found Intel OpenMP ('libiomp') and LLVM OpenMP ('libomp') loaded at the same time. Both libraries are known to be incompatible and this can cause random crashes or deadlocks on Linux when loaded in the same Python program. Using threadpoolctl may cause crashes or deadlocks. For more information and possible workarounds, please see https://github.com/joblib/threadpoolctl/blob/master/multiple_openmp.md rr)rrr[textwrapdedentrgrhRuntimeWarning)rLr~msgrrrrs  z1ThreadpoolController._warn_if_incompatible_openmpcCsD|jd}|dkr@td}|dkr(dStj|td}||jd<|S)z Load the lib-C for unix systems.rNcmode)_system_librariesgetrrrr)rWrZ libc_namerrrrs  zThreadpoolController._get_libccCs2|j|}|dkr.t|d}||j|<|S)zLoad a windows DLLNr)rrrZWinDLL)rWZdll_namedllrrrrs   z ThreadpoolController._get_windll)r rrr1r|rrNrrr@rrwr8rirt_ALL_BLAS_LIBRARIES_ALL_OPENMP_LIBRARIESrjrXrrrrrrrrrrrrrrr |s@   0$ %?5  ccs|]}d|VqdSrrrlrrrr-sccs|]}d|VqdSrrrlrrrr-sc@s\eZdZdZdddddddZddZedd Zed d Z ed d Z eddZ dS) LibControlleraAAbstract base class for the individual library controllers A library controller is represented by the following information: - "user_api" : user API. Possible values are {USER_APIS}. - "internal_api" : internal API. Possible values are {INTERNAL_APIS}. - "prefix" : prefix of the shared library's name. - "filepath" : path to the loaded library. - "version" : version of the library (if available). - "num_threads" : the current thread limit. In addition, each library controller may contain internal_api specific entries. NrcCs6||_||_||_||_tj|td|_||_ dS)Nr) rrr/r=rrr_dynlib get_versionversion)rLr=r/rrrrrrN%s zLibController.__init__cCs(tt|fd|ji}dd|DS)z&Return relevant info wrapped in a dictrYcSs i|]\}}|ds||qS)_r)r+kvrrrro0s z&LibController.info..)r|varsrYr)rLZ all_attrsrrrr@-szLibController.infocCs|Sr0)get_num_threadsrOrrrrY2szLibController.num_threadscCsdS)z5Return the maximum number of threads available to useNrrOrrrr6szLibController.get_num_threadscCsdS)z(Set the maximum number of threads to useNr)rLrYrrrr\;szLibController.set_num_threadscCsdS)z(Return the version of the shared libraryNrrOrrrr@szLibController.get_version) r rrr1rNr@propertyrYrrr\rrrrrrs   rcsHeZdZdZfddZddZddZdd Zd d Zd d Z Z S)r'zController class for OpenBLASc s&tjf|||_||_dSr0rrN_get_threading_layerr_get_architecture architecturerLr6rrrrNIs zOpenBLASController.__init__cCs"t|jdt|jddd}|S)Nr!r"cSsdSr0rrrrrSrz4OpenBLASController.get_num_threads..rrrLget_funcrrrrNs z"OpenBLASController.get_num_threadscCs$t|jdt|jddd}||S)NZopenblas_set_num_threadsZopenblas_set_num_threads64_cSsdSr0rrYrrrr^rz4OpenBLASController.set_num_threads..rrLrYZset_funcrrrr\Xsz"OpenBLASController.set_num_threadscCsTt|jdt|jdd}|dkr$dStj|_|}|ddkrP|ddSdS)NZopenblas_get_configZopenblas_get_config64_rsOpenBLASr`r)rrrrrsplitr)rLZ get_configconfigrrrrcs   zOpenBLASController.get_versioncCsFt|jdt|jdd}|dkr$dS|}|dkr6dS|dkrBdSd S) z&Return the threading layer of OpenBLASopenblas_get_parallelZopenblas_get_parallel64_Nunknownrr`pthreadsdisabledr)rLrrrrrrts z'OpenBLASController._get_threading_layercCs8t|jdt|jdd}|dkr$dStj|_|dS)z,Return the architecture detected by OpenBLASZopenblas_get_corenameZopenblas_get_corename64_Nrrrrrrr)rLZ get_corenamerrrrs z$OpenBLASController._get_architecture r rrr1rNrr\rrrrrrrrr'Fs   r'csHeZdZdZfddZddZddZdd Zd d Zd d Z Z S)r)zController class for BLISc s&tjf|||_||_dSr0rrrrrrNs zBLISController.__init__cCs(t|jddd}|}|dkr$dS|S)Nr%cSsdSr0rrrrrrrz0BLISController.get_num_threads..r`r)rLrrYrrrrszBLISController.get_num_threadscCst|jddd}||S)NZbli_thread_set_num_threadscSsdSr0rrrrrrrz0BLISController.set_num_threads..rrrrrr\s zBLISController.set_num_threadscCs.t|jdd}|dkrdStj|_|dS)NZbli_info_get_version_strrr)rLZ get_version_rrrrs zBLISController.get_versioncCs |jrdS|jrdSdS)z"Return the threading layer of BLISrrr)rZbli_info_get_enable_openmpZbli_info_get_enable_pthreadsrOrrrrs   z#BLISController._get_threading_layercCsPt|jdd}t|jdd}|dks,|dkr0dStj|_tj|_||dS)z(Return the architecture detected by BLISbli_arch_query_idNbli_arch_stringr)rrrrrrr)rLrrrrrrsz BLISController._get_architecturerrrrrr)s r)cs@eZdZdZfddZddZddZdd Zd d ZZ S) r(zController class for MKLc stjf|||_dSr0)rrNrrrrrrrNszMKLController.__init__cCst|jddd}|S)Nr$cSsdSr0rrrrrrrz/MKLController.get_num_threads..rrrrrrszMKLController.get_num_threadscCst|jddd}||S)NZMKL_Set_Num_ThreadscSsdSr0rrrrrrrz/MKLController.set_num_threads..rrrrrr\s zMKLController.set_num_threadscCs\t|jdsdStd}|j|d|jd}td|}|dk rT| d}| S)NMKL_Get_Version_StringrzVersion ([^ ]+) r) rrrcreate_string_bufferr rSrresearchgroupsstrip)rLresrgrouprrrrs     zMKLController.get_versioncCs0t|jddd}dddddd d }||d S) z!Return the threading layer of MKLZMKL_Set_Threading_LayercSsdS)Nrr)Zlayerrrrrrz4MKLController._get_threading_layer..intel sequentialZpgiZgnuZtbbz not specified)rr`rrrrr)rLZset_threading_layerZ layer_maprrrrsz"MKLController._get_threading_layer) r rrr1rNrr\rrrrrrrr(s   r(c@s(eZdZdZddZddZddZdS) r&zController class for OpenMPcCst|jddd}|S)NZomp_get_max_threadscSsdSr0rrrrrrrz2OpenMPController.get_num_threads..rrrrrrsz OpenMPController.get_num_threadscCst|jddd}||S)NZomp_set_num_threadscSsdSr0rrrrrrrz2OpenMPController.set_num_threads..rrrrrr\s z OpenMPController.set_num_threadscCsdSr0rrOrrrrszOpenMPController.get_versionN)r rrr1rr\rrrrrr&sc Csddl}ddl}ddl}ddl}|jddd}|jdddd d d d |jd ddd||jdd}|jD]<}z|j |ddWqnt k rt d||j dYqnXqn|j rt|j t |jtdddS)zBCommandline interface to display thread-pool information and exit.rNz5python -m threadpoolctl -i numpy scipy.linalg xgboostz)Display thread-pool information and exit.)usage descriptionz-iz--importmodules*rz;Python modules to import before introspecting thread-pools.)destnargsdefaulthelpz-cz --commandz@a Python statement to execute before introspecting thread-pools.)rr`)packagezWARNING: could not import)filer)indent)argparse importlibjsonrArgumentParser add_argument parse_argsargvr import_module ImportErrorprintstderrcommandexecdumpsr)r r!r"rparseroptionsmodulerrr_mains<  r1__main__)8r1r:r rrrrgZ ctypes.utilrabcrr functoolsr contextlibr __version____all__environ setdefaultr9c_uint64c_uint32rc_uint16r Structurer RTLD_NOLOADrAttributeError DEFAULT_MODErr{rbrxrtZ_ALL_INTERNAL_APISrrrrr8r>rrArVrirr rr'r)r(r&r1r rrrrs            70L31&