o Ggg@svdZddlZddlZddlZddlZddlZddlZddlmZddl Z ddl m Z ddl m Z mZddlmZddlmZdZgd Zejd d ejd krSejnejZejd kr^ejnejZGd ddejZzejZ Wn e!y{ej"Z YnwGddde Z#Gddde#Z$Gddde#Z%Gddde#Z&Gddde#Z'Gddde#Z(e$e%e'e(e&gZ)e*e+dde)DZ,dde)DZ-e*e+dde)DZ.d de)DZ/e(j0Z1d!d"Z2d#d$Z3ed%d&d'd(Z4e3e*e,e-d)d*d+Z5Gd,d-d-Z6Gd.d/d/e6eZ7e3d08d1de,Dd08e/d08e1d2Gd3d4d4e6Z9Gd5d6d6Z:d7d8Z;e~sz&LibController.info..)r1r2r3varsitemsr.rr7rinfowszLibController.infocCdS)z>Set additional attributes meant to be exposed in the info dictNrr<rrrr-z'LibController.set_additional_attributescC|S)zExposes the current thread limit as a dynamic property This is not meant to be used or overriden by subclasses. )get_num_threadsr<rrrr3szLibController.num_threadscCr>)z5Return the maximum number of threads available to useNrr<rrrrAr?zLibController.get_num_threadscCr>)z(Set the maximum number of threads to useNr)r.r3rrrset_num_threadsr?zLibController.set_num_threadscCr>)z(Return the version of the shared libraryNrr<rrrr+r?zLibController.get_versioncCr>)z8Return the affixes for the symbols of the shared library)rCrr<rrrr(zLibController._find_affixescCst|j|j||jdS)zBReturn the symbol of the shared library accounding for the affixesN)getattrr'r)r*)r.namerrr _get_symbolszLibController._get_symbol)rrr__doc__rr/r=r-propertyr3rrArBr+r(rGrrrrr Hs #       r c@sveZdZdZdZdZdZdZdZe dde eeDZ d d Z d d Zd dZddZddZddZddZdS)OpenBLASControllerzController class for OpenBLASblasopenblas) libopenblaslibblaslibscipy_openblas)rCscipy_)rC64__64ccs"|] \}}|d|VqdS)openblas_get_num_threadsNr)r4r!suffixrrr s  zOpenBLASController.cCs@t|j|jD]\}}t|j|d|r||fSqdSNrS) itertoolsproduct_symbol_prefixes_symbol_suffixeshasattrr')r.r!rTrrrr(s  z OpenBLASController._find_affixescC||_||_dSN_get_threading_layerthreading_layer_get_architecture architecturer<rrrr- z,OpenBLASController.set_additional_attributescCs|d}|dur |SdSrVrG)r.get_num_threads_funcrrrrAs z"OpenBLASController.get_num_threadscCs|d}|dur ||SdS)Nopenblas_set_num_threadsrd)r.r3set_num_threads_funcrrrrBs z"OpenBLASController.set_num_threadscCsF|d}|dur!tj|_|}|ddkr|ddSdSdS)Nopenblas_get_configrsOpenBLASutf-8)rGrrrestypesplitdecode)r.get_version_funcconfigrrrr+s   zOpenBLASController.get_versioncCs8|d}|dur|}|dkrdS|dkrdSdSdS) z&Return the threading layer of OpenBLASopenblas_get_parallelNopenmpripthreadsdisabledunknownrd)r.get_threading_layer_funcr`rrrr_s z'OpenBLASController._get_threading_layercCs*|d}|durtj|_|dSdS)z,Return the architecture detected by OpenBLASopenblas_get_corenameNrj)rGrrrkrm)r.get_architecture_funcrrrras  z$OpenBLASController._get_architectureN)rrrrHr1r2filename_prefixesrYrZtuplerWrX check_symbolsr(r-rArBr+r_rarrrrrJs"  rJc@sPeZdZdZdZdZdZdZddZdd Z d d Z d d Z ddZ ddZ dS)BLISControllerzController class for BLISrKblis)libblisrN)bli_thread_get_num_threadsbli_thread_set_num_threadsbli_info_get_version_strbli_info_get_enable_openmpbli_info_get_enable_pthreadsbli_arch_query_idbli_arch_stringcCr\r]r^r<rrrr-rcz(BLISController.set_additional_attributescC(t|jddd}|}|dkrdS|S)NrcSdSr]rrrrrr?z0BLISController.get_num_threads..rirEr'r.get_funcr3rrrrAzBLISController.get_num_threadscCt|jddd}||S)NrcSrr]rr3rrrrr?z0BLISController.set_num_threads..rr.r3set_funcrrrrB zBLISController.set_num_threadscCs.t|jdd}|dur dStj|_|dS)Nrrj)rEr'rrrkrm)r. get_version_rrrr+ s  zBLISController.get_versioncCs4t|jdddr dSt|jdddrdSdS) z"Return the threading layer of BLISrcSr>NFrrrrrrr?z5BLISController._get_threading_layer..rrrcSr>rrrrrrrr?rsrtrr<rrrr_s z#BLISController._get_threading_layercCsPt|jdd}t|jdd}|dus|durdStj|_tj|_||dS)z(Return the architecture detected by BLISrNrrj)rEr'rc_intrkrrm)r.rrrrrrasz BLISController._get_architectureN)rrrrHr1r2ryr{r-rArBr+r_rarrrrr|s  r|cseZdZdZdZdZdZdZeddZ edd Z fd d Z d d Z ddZ ddZddZdddZddZddZZS)FlexiBLASControllerzController class for FlexiBLASrK flexiblas) libflexiblas)flexiblas_get_num_threadsflexiblas_set_num_threadsflexiblas_get_versionflexiblas_listflexiblas_list_loadedflexiblas_current_backendcCs |jddS)NTloaded)_get_backend_listr<rrrloaded_backends9s z#FlexiBLASController.loaded_backendscCr@r])_get_current_backendr<rrrcurrent_backend=sz#FlexiBLASController.current_backendcs"t}|j|d<|j|d<|S)r0rr)superr=rr)r. exposed_attrs __class__rrr=As   zFlexiBLASController.infocCs|jdd|_dS)NFr)ravailable_backendsr<rrrr-Ksz-FlexiBLASController.set_additional_attributescCr)NrcSrr]rrrrrrOr?z5FlexiBLASController.get_num_threads..rrirrrrrrANrz#FlexiBLASController.get_num_threadscCr)NrcSrr]rrrrrrWr?z5FlexiBLASController.set_num_threads..rrrrrrBUrz#FlexiBLASController.set_num_threadscCsjt|jdd}|dur dSt}t}t}|t|t|t||jd|jd|jS)Nr.)rEr'rrbyrefvalue)r.rmajorminorpatchrrrr+[szFlexiBLASController.get_versionFcCsd|rdnd}t|j|d}|durdS|ddd}g}t|D]}td}||d||jddkr@||jdq"|S) zReturn the list of available backends for FlexiBLAS. If loaded is False, return the list of available backends from the FlexiBLAS configuration. If loaded is True, return the list of actually loaded backends. r_loadedrCNrrj __FALLBACK__)rEr'rangercreate_string_bufferrrmappend)r.r func_nameget_backend_list_ n_backendsbackendsi backend_namerrrrfs    z%FlexiBLASController._get_backend_listcCs@t|jdd}|dur dStd}||t||jdS)zReturn the backend of FlexiBLASrNrrj)rEr'rrsizeofrrm)r. get_backend_backendrrrr}s   z(FlexiBLASController._get_current_backendcCs||jvr;||jvrt|jddd}n t|jddd}|t|d}|dkr6td|d |jd |jt|jd d d}|j |}||}|dkrZtd |ddS)aSwitch the backend of FlexiBLAS Parameters ---------- backend : str The name or the path to the shared library of the backend to switch to. If the backend is not already loaded, it will be loaded first. flexiblas_load_backendcSr>Nrr_rrrrr?z4FlexiBLASController.switch_backend..flexiblas_load_backend_librarycSr>rrrrrrrr?rjrzFailed to load backend zS. It must either be the name of a backend available in the FlexiBLAS configuration z' or the path to a valid shared library.flexiblas_switchcSr>rrrrrrrr?zFailed to switch to backend rN) rrrEr'strencode RuntimeErrorr"_load_librariesindex)r.r load_funcres switch_funcidxrrrswitch_backends(    z"FlexiBLASController.switch_backend)F)rrrrHr1r2ryr{rIrrr=r-rArBr+rrr __classcell__rrrrr*s$      rc@sHeZdZdZdZdZdZdZddZdd Z d d Z d d Z ddZ dS) MKLControllerzController class for MKLrKmkl) libmkl_rtmkl_rtrN)MKL_Get_Max_ThreadsMKL_Set_Num_ThreadsMKL_Get_Version_StringMKL_Set_Threading_LayercCs||_dSr])r_r`r<rrrr-sz'MKLController.set_additional_attributescCt|jddd}|S)NrcSrr]rrrrrrr?z/MKLController.get_num_threads..rr.rrrrrAzMKLController.get_num_threadscCr)NrcSrr]rrrrrrr?z/MKLController.set_num_threads..rrrrrrBzMKLController.set_num_threadscCs\t|jdsdStd}|j|d|jd}td|}|dur*| d}| S)NrrjzVersion ([^ ]+) r) r[r'rrrrrmresearchgroupsstrip)r.rr,grouprrrr+s     zMKLController.get_versioncCs0t|jddd}dddddd d }||d S) z!Return the threading layer of MKLrcSr>rr)layerrrrrr?z4MKLController._get_threading_layer..intel sequentialpgignutbbz not specified)rrirqrrr)r.set_threading_layer layer_maprrrr_s  z"MKLController._get_threading_layerN) rrrrHr1r2ryr{r-rArBr+r_rrrrrs rc@s8eZdZdZdZdZdZdZddZddZ d d Z d S) OpenMPControllerzController class for OpenMPrr)libiomplibgomplibompvcomp)omp_get_max_threadsomp_get_num_threadscCr)NrcSrr]rrrrrrr?z2OpenMPController.get_num_threads..rrrrrrArz OpenMPController.get_num_threadscCr)Nomp_set_num_threadscSrr]rrrrrrr?z2OpenMPController.set_num_threads..rrrrrrBrz OpenMPController.set_num_threadscCrr]rr<rrrr+rDzOpenMPController.get_versionN) rrrrHr1r2ryr{rArBr+rrrrrs rcc|]}|jVqdSr]r1r4librrrrUrUcCg|]}|jqSr)r2rrrr rccs |] }|jD]}|VqqdSr])ry)r4rr!rrrrUscCsg|] }|jdkr|jqS)rK)r1r2rrrrr scCs2t|t|jt|jt|jdS)zRegister a new controllerN) _ALL_CONTROLLERSr_ALL_USER_APISr1_ALL_INTERNAL_APISr2 _ALL_PREFIXESextendry) controllerrrrr s   r csfdd}|S)Ncs"|jdur|jji|_|Sr])rHformat)oargskwargsrr decorators z$_format_docstring..decoratorr)rrrrrr_format_docstringsri')maxsizecCs tj|S)zCSmall caching wrapper around os.path.realpath to limit system calls)ospathrealpathr rrr _realpath!s r) USER_APIS 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 r=rrrrr 's r c@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. Nlimitsr1cCs6||_|||\|_|_|_|j|_|dSr]) _controller _check_params_limits _user_api _prefixesr=_original_info_set_threadpool_limitsr.rrr1rrrr/Es   z_ThreadpoolLimiter.__init__cCs|Sr]rr<rrr __enter__Msz_ThreadpoolLimiter.__enter__cCs |dSr])restore_original_limits)r.typer tracebackrrr__exit__Ps z_ThreadpoolLimiter.__exit__cCst|||dS)z@Return an instance of this class that can be used as a decorator)rrr1)_ThreadpoolLimiterDecorator)clsrrr1rrrwrapSsz_ThreadpoolLimiter.wrapcCs,t|jj|jD] \}}||dqdS)z,Set the limits back to their original valuesr3N)ziprlib_controllersrrB)r.lib_controller original_inforrrrZs   z*_ThreadpoolLimiter.restore_original_limitscsi}g}|jD]1fdd|jD}t|}t|}|dkr$|}n|dkr+d}n t|}|||<q|rGtdd |d|S) zuOriginal num_threads from before calling threadpool_limits Return a dict `{user_api: num_threads}`. cs g|] }|dkr|dqS)r1r3rr4lib_inforrrrms  z?_ThreadpoolLimiter.get_original_num_threads..rirNz1Multiple value possible for following user apis: , z. Returning the minimum.) rrsetlenpopminrwarningswarnjoin)r.r3 warning_apisrn_limitslimitrrrget_original_num_threadsds0     z+_ThreadpoolLimiter.get_original_num_threadscsttrdkr|j\}dusttrE|dur"t}n|tvr*|g}n tdtd|ddurBfdd|Dg}n7ttrRddDn tt r_d dj Dtt snt d t d d d D}dd D}||fS)zCSuitable values for the _limits, _user_api and _prefixes attributessequential_blas_under_openmpNzuser_api must be either in z or None. Got z instead.csi|]}|qSrrr4apirrrr9rz4_ThreadpoolLimiter._check_params..cSsi|] }|d|dqSr!r3rr(rrrr9scSsi|]}|j|jqSrr:r4r&rrrr9szUlimits must either be an int, a list, a dict, or 'sequential_blas_under_openmp'. Got z insteadcSg|]}|tvr|qSr)r)r4r!rrrrz4_ThreadpoolLimiter._check_params..cSr<r)rr7rrrrr=) isinstancerr,_get_params_for_sequential_blas_under_openmpvaluesintr ValueErrorlistr r%dict TypeErrorr)r.rr1prefixesrr9rrsF     z _ThreadpoolLimiter._check_paramscCsh|jdurdS|jjD]&}|j|jvr|j|j}n|j|jvr'|j|j}nq |dur1||q dS)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)rrr%r!r1rB)r.r&r3rrrrs     z)_ThreadpoolLimiter._set_threadpool_limits)rrrrHr/rr  classmethodr#r unregisterr5rrrrrrr:s $ 3rc@s(eZdZdZdddddZddZdS)r!z8Same as _ThreadpoolLimiter but to be used as a decoratorNrcCs"|||\|_|_|_||_dSr])rrrrrrrrrr/s z$_ThreadpoolLimiterDecorator.__init__cCs|j|_||Sr])rr=rrr<rrrrs z%_ThreadpoolLimiterDecorator.__enter__)rrrrHr/rrrrrr!s r!r*ccs|] }d|dVqdS)"Nrr7rrrrUsr 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||ddSNr)rr/r r.rr1rrrr/szthreadpool_limits.__init__cstjt||dSrM)rr#r )r"rr1rrrr#szthreadpool_limits.wrap)NN)rrrrHr/rGr#rrrrrrs .rc@seZdZdZeZddZeddZddZ dd Z d d Z e d d deDd ed eddddddZe d ddeDd ed eddddddZddZddZddZddZdd Zd!d"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|_||dSr])r%r_warn_if_incompatible_openmpr<rrrr/0s zThreadpoolController.__init__cCs||}||_|Sr])__new__r%)r"r%new_controllerrrr_from_controllers5s z&ThreadpoolController._from_controllerscCsdd|jDS)z.Return lib_controllers info as a list of dictscSsg|]}|qSr)r=r;rrrr=sz-ThreadpoolController.info..)r%r<rrrr=;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|vVqdSr])rE)r4keyvalsr&rrrURs  z9ThreadpoolController.select...)anyr;)r4rrUrrOs z/ThreadpoolController.select..)r;r>rCr%r rR)r.rrSrTr%rrWrselect?s    zThreadpoolController.selectcCs$|jdddjr dddSdddS)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. rLrr)r2r`NrrirK)rXr%r<rrrr?Zs  zAThreadpoolController._get_params_for_sequential_blas_under_openmpr*cc|]}d|VqdSz"{}"Nrr7rrrrUgzThreadpoolController.rJNrcCst|||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. r)rrNrrrr4fs3zThreadpoolController.limitccrYrZr[r7rrrrUr\cCstj|||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. r)rr#rNrrrr#s'zThreadpoolController.wrapcCs t|jSr])r,r%r<rrr__len__s zThreadpoolController.__len__cCsNtjdkr |dStjdkr|dSdtjvr!|dS|dS)zALoop through loaded shared libraries and store the supported onesdarwinwin32pyodideN)sysplatform_find_libraries_with_dyld+_find_libraries_with_enum_process_module_exmodules_find_libraries_pyodide$_find_libraries_with_dl_iterate_phdrr<rrrrs       z$ThreadpoolController._load_librariescsl}t|dstdtgSfdd}ttjtt tj tj }||}t d}| ||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_phdrz9Could not find dl_iterate_phdr in the C standard library.cs$|jj}|r|d}|dS)Nrjr)contentsrrm_make_controller_from_path)r=sizedatar r<rrmatch_library_callbacks   zYThreadpoolController._find_libraries_with_dl_iterate_phdr..match_library_callbackN) _get_libcr[r/r0RuntimeWarningr CFUNCTYPErPOINTERrc_size_trrh)r.libcrmc_func_signaturec_match_library_callbackrlrr<rrgs"    z9ThreadpoolController._find_libraries_with_dl_iterate_phdrcCsj|}t|dstdtgS|}tj|j_ t |D]}t ||}| d}| |qdS)zLoop through loaded libraries and return binders on supported ones This function is expected to work on OSX system only _dyld_image_countz;Could not find _dyld_image_count in the C standard library.rjN)ror[r/r0rprwrr_dyld_get_image_namerkr string_atrmrj)r.rtn_dyldrr rrrrcs     z.ThreadpoolController._find_libraries_with_dyldc CsNddlm}m}m}d}d}d}|d}|d}|||Bdt} | s0td tzpd } |} || } t | } | | t | | t | |sTtd | | j krZn| j | | } q7| j | | }t|| d |}t |} |}|D]}|| |t | t |std| j }||q|W|| d S|| w)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_PATHrrPsapikernel32FzCould not open PID TzEnumProcessModulesEx failedNzGetModuleFileNameEx failed)ctypes.wintypesr{r|r} _get_windll OpenProcessr getpidOSErrorrrEnumProcessModulesExrrmapcreate_unicode_bufferGetModuleFileNameExWrj CloseHandle)r.r{r|r}PROCESS_QUERY_INFORMATIONPROCESS_VM_READLIST_LIBRARIES_ALLps_api kernel_32 h_process buf_countneededbufbuf_sizecount h_modulesn_sizeh_moduler rrrrdsT        z@ThreadpoolController._find_libraries_with_enum_process_module_excCsZzddlm}WntytdYdSw|jD] }tj |r*| |qdS)aPyodide specific implementation for finding loaded libraries. Adapted from suggestion in https://github.com/joblib/threadpoolctl/pull/169#issuecomment-1946696449. One day, we may have a simpler solution. libc dl_iterate_phdr needs to be implemented in Emscripten and exposed in Pyodide, see https://github.com/emscripten-core/emscripten/issues/21354 for more details. r)LDSOzHUnable to import LDSO from pyodide_js._module. This should never happen.N) pyodide_js._moduler ImportErrorr/r0loadedLibsByName as_object_mapr r existsrj)r.rr rrrrfPs    z,ThreadpoolController._find_libraries_pyodidecst|}tj|}tD]U}|||j}|durq|dkr:|dr9t |t t fdd|j Ds8qnq||||d|dd|jDvrLqt|dr]t fd d|j Drc|jqdS) z:Store a library controller if it is supported and selectedNrN.dllc3s|]}t|VqdSr])r[r4func)rNrrrUs  zBThreadpoolController._make_controller_from_path..rcsrr]r rrrrrUrr{c3s|] }tj|VqdSr])r[r'rrUrrrUs  )rr r basenamelowerr _check_prefixryendswithrr%r&rVr{r%r[r)r.r filenamecontroller_classr!r)r&rNrrjks4     z/ThreadpoolController._make_controller_from_pathcCs |D] }||r |SqdS)z]Return the prefix library_basename starts with Return None if none matches. N) startswith)r.library_basenameryr!rrrrs  z"ThreadpoolController._check_prefixcCsBdd|jD}td}d|vrd|vrt|tdSdSdS)z?Raise a warning if llvm-OpenMP and intel-OpenMP are both loadedcSrr)r!r;rrrrrzEThreadpoolController._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 rrN)r%textwrapdedentr/r0rp)r.rFmsgrrrrOs z1ThreadpoolController._warn_if_incompatible_openmpcCs4|jd}|durtjtdtd}||jd<|S)z Load the lib-C for unix systems.rtNcr#)_system_librariesgetrr%rr&)r"rtrrrros  zThreadpoolController._get_libccCs2|j|}|durt|d}||j|<|S)zLoad a windows DLLNr)rrrWinDLL)r"dll_namedllrrrrs  z ThreadpoolController._get_windll)rrrrHrDrr/rGrRr=rXr?rr1r_ALL_BLAS_LIBRARIES_ALL_OPENMP_LIBRARIESr4r#r]rrgrcrdrfrjrrOrorrrrrr !sD   0$ )>:  r c Csddl}ddl}ddl}ddl}|jddd}|jdddd d d d |jd ddd||jdd}|jD]}z |j |ddWq7t ySt d||j dYq7w|j r\t|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--importre*rz;Python modules to import before introspecting thread-pools.)destnargsdefaulthelpz-cz --commandz@a Python statement to execute before introspecting thread-pools.)rri)packagezWARNING: could not import)filerq)indent)argparse importlibjsonraArgumentParser add_argument parse_argsargvre import_modulerprintstderrcommandexecdumpsr )rrrraparseroptionsmodulerrr_mains>   r__main__)=rHr rrarrWrtypingrr/ ctypes.utilrabcrr functoolsr contextlibr __version____all__environ setdefaultr c_uint64c_uint32rc_uint16r Structurer RTLD_NOLOADr&AttributeError DEFAULT_MODEr rJr|rrrrrCr+rrrrryrr rrr rr!r1rr rrrrrrs        [H?8   7; &