U 9%e@s`dZddlZddlZddlZddlZddlZddlmZddlZddl m Z ddl m Z m Z ddlmZddlmZdZd d d d d gZejddejdkrejnejZejdkrejnejZGdddejZz ejZWne k rej!ZYnXGdd d e Z"Gddde"Z#Gddde"Z$Gddde"Z%Gddde"Z&e#e$e%e&gZ'e(e)dde'DZ*dde'DZ+e(e)d de'DZ,d!de'DZ-e&j.Z/d"d Z0d#d$Z1ed%d&d'd(Z2e1e(e*e+d)d*d Z3Gd+d,d,Z4Gd-d.d.e4eZ5e1d/6d0de*Dd/6e-d/6e/d1Gd2d d e4Z7Gd3d d Z8d4d5Z9e:d6kr\e9dS)7zthreadpoolctl 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)final) find_library)ABCabstractmethod) lru_cache)ContextDecoratorz3.2.0threadpool_limitsthreadpool_infoThreadpoolController LibControllerregisterZKMP_DUPLICATE_LIB_OKTruelc@s,eZdZdefdejfdejfdefgZdS) _dl_phdr_infoZ dlpi_addr dlpi_nameZ dlpi_phdrZ dlpi_phnumN) __name__ __module__ __qualname__ _SYSTEM_UINTctypesc_char_pZc_void_p_SYSTEM_UINT_HALFZ_fields_rrL/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/threadpoolctl.pyr6s rc@sheZdZdZedddddZeddZdd Zed d Z e d d Z e ddZ e ddZ dS)r a Abstract base class for the individual library controllers A library controller must expose the following class attributes: - user_api : str Usually the name of the library or generic specification the library implements, e.g. "blas" is a specification with different implementations. - internal_api : str Usually the name of the library or concrete implementation of some specification, e.g. "openblas" is an implementation of the "blas" specification. - filename_prefixes : tuple Possible prefixes of the shared library's filename that allow to identify the library. e.g. "libopenblas" for libopenblas.so. and implement the following methods: `get_num_threads`, `set_num_threads` and `get_version`. Threadpoolctl loops through all the loaded shared libraries and tries to match the filename of each library with the `filename_prefixes`. If a match is found, a controller is instantiated and a handler to the library is stored in the `dynlib` attribute as a `ctypes.CDLL` object. It can be used to access the necessary symbols of the shared library to implement the above methods. The following information will be exposed in the info dictionary: - user_api : standardized API, if any, or a copy of internal_api. - internal_api : implementation-specific API. - num_threads : the current thread limit. - prefix : prefix of the shared library's filename. - filepath : path to the loaded shared library. - version : version of the library (if available). In addition, each library controller may expose internal API specific entries. They must be set as attributes in the `set_additional_attributes` method. NfilepathprefixcCs2||_||_tj|td|_||_|dS)z0This is not meant to be overriden by subclasses.modeN) rrrCDLL _RTLD_NOLOADdynlib get_versionversionset_additional_attributes)selfrrrrr__init__js  zLibController.__init__cCs(|j|j|jdt|}|d|S)ziReturn relevant info wrapped in a dict This is not meant to be overriden by subclasses. )user_api internal_api num_threadsr )r&r'r(varspop)r$Z exposed_attrsrrrinfoss zLibController.infocCsdS)z>Set additional attributes meant to be exposed in the info dictNrr$rrrr#sz'LibController.set_additional_attributescCs|S)zExposes the current thread limit as a dynamic property This is not meant to be used or overriden by subclasses. )get_num_threadsr,rrrr(szLibController.num_threadscCsdS)z5Return the maximum number of threads available to useNrr,rrrr-szLibController.get_num_threadscCsdS)z(Set the maximum number of threads to useNr)r$r(rrrset_num_threadsszLibController.set_num_threadscCsdS)z(Return the version of the shared libraryNrr,rrrr!szLibController.get_version)rrr__doc__rr%r+r#propertyr(rr-r.r!rrrrr Fs#    c@sPeZdZdZdZdZdZdZddZdd Z d d Z d d Z ddZ ddZ dS)OpenBLASControllerzController class for OpenBLASblasopenblas)Z libopenblaslibblas)openblas_get_num_threadsopenblas_get_num_threads64_cCs||_||_dSN_get_threading_layerthreading_layer_get_architecture architecturer,rrrr#s z,OpenBLASController.set_additional_attributescCs"t|jdt|jddd}|S)Nr5r6cSsdSr7rrrrrz4OpenBLASController.get_num_threads..getattrr r$get_funcrrrr-s z"OpenBLASController.get_num_threadscCs$t|jdt|jddd}||S)NZopenblas_set_num_threadsZopenblas_set_num_threads64_cSsdSr7rr(rrrr=r>z4OpenBLASController.set_num_threads..r?r$r(Zset_funcrrrr.sz"OpenBLASController.set_num_threadscCsTt|jdt|jdd}|dkr$dStj|_|}|ddkrP|ddSdS)NZopenblas_get_configZopenblas_get_config64_rsOpenBLASutf-8)r@r rrrestypesplitdecode)r$Z get_configconfigrrrr!s   zOpenBLASController.get_versioncCsFt|jdt|jdd}|dkr$dS|}|dkr6dS|dkrBdSd S) z&Return the threading layer of OpenBLASopenblas_get_parallelZopenblas_get_parallel64_NunknownopenmprEpthreadsdisabledr?)r$rKr:rrrr9s z'OpenBLASController._get_threading_layercCs8t|jdt|jdd}|dkr$dStj|_|dS)z,Return the architecture detected by OpenBLASZopenblas_get_corenameZopenblas_get_corename64_NrFr@r rrrGrI)r$Z get_corenamerrrr;s z$OpenBLASController._get_architectureNrrrr/r&r'filename_prefixes check_symbolsr#r-r.r!r9r;rrrrr1s  r1c@sPeZdZdZdZdZdZdZddZdd Z d d Z d d Z ddZ ddZ dS)BLISControllerzController class for BLISr2Zblis)Zlibblisr4)bli_thread_get_num_threadscCs||_||_dSr7r8r,rrrr#s z(BLISController.set_additional_attributescCs(t|jddd}|}|dkr$dS|S)NrVcSsdSr7rrrrrr=r>z0BLISController.get_num_threads..rEr?)r$rBr(rrrr-szBLISController.get_num_threadscCst|jddd}||S)NZbli_thread_set_num_threadscSsdSr7rrCrrrr=r>z0BLISController.set_num_threads..r?rDrrrr.s zBLISController.set_num_threadscCs.t|jdd}|dkrdStj|_|dS)NZbli_info_get_version_strrFrQ)r$Z get_version_rrrr!s zBLISController.get_versioncCs |jrdS|jrdSdS)z"Return the threading layer of BLISrNrOrP)r Zbli_info_get_enable_openmpZbli_info_get_enable_pthreadsr,rrrr9 s   z#BLISController._get_threading_layercCsPt|jdd}t|jdd}|dks,|dkr0dStj|_tj|_||dS)z(Return the architecture detected by BLISbli_arch_query_idNbli_arch_stringrF)r@r rc_intrGrrI)r$rXrYrrrr;sz BLISController._get_architectureNrRrrrrrUsrUc@sHeZdZdZdZdZdZdZddZdd Z d d Z d d Z ddZ dS) MKLControllerzController class for MKLr2Zmkl)Z libmkl_rtZmkl_rtr4)MKL_Get_Max_ThreadscCs||_dSr7)r9r:r,rrrr#)sz'MKLController.set_additional_attributescCst|jddd}|S)Nr\cSsdSr7rrrrrr=-r>z/MKLController.get_num_threads..r?rArrrr-,szMKLController.get_num_threadscCst|jddd}||S)NZMKL_Set_Num_ThreadscSsdSr7rrCrrrr=1r>z/MKLController.set_num_threads..r?rDrrrr.0szMKLController.set_num_threadscCs\t|jdsdStd}|j|d|jd}td|}|dk rT| d}| S)NMKL_Get_Version_StringrFzVersion ([^ ]+) r) hasattrr rcreate_string_bufferr]valuerIresearchgroupsstrip)r$resr"grouprrrr!4s     zMKLController.get_versioncCs0t|jddd}dddddd d }||d S) z!Return the threading layer of MKLZMKL_Set_Threading_LayercSsdS)NrWr)layerrrrr=Gr>z4MKLController._get_threading_layer..intel sequentialZpgiZgnuZtbbz not specified)rrErMrWrWr?)r$Zset_threading_layerZ layer_maprrrr9Asz"MKLController._get_threading_layerN) rrrr/r&r'rSrTr#r-r.r!r9rrrrr[!s r[c@s4eZdZdZdZdZdZddZddZdd Z d S) OpenMPControllerzController class for OpenMPrN)libiompZlibgomplibompZvcompcCst|jddd}|S)NZomp_get_max_threadscSsdSr7rrrrrr=\r>z2OpenMPController.get_num_threads..r?rArrrr-[sz OpenMPController.get_num_threadscCst|jddd}||S)NZomp_set_num_threadscSsdSr7rrCrrrr=`r>z2OpenMPController.set_num_threads..r?rDrrrr._sz OpenMPController.set_num_threadscCsdSr7rr,rrrr!cszOpenMPController.get_versionN) rrrr/r&r'rSr-r.r!rrrrrmTsrmccs|] }|jVqdSr7r&.0librrr msrtcCsg|] }|jqSr)r'rqrrr nsruccs|]}|jD] }|Vq qdSr7)rS)rrrsrrrrrtpscCsg|]}|jdkr|jqS)r2)r&r'rqrrrrurs cCs2t|t|jt|jt|jdS)zRegister a new controllerN) _ALL_CONTROLLERSappend_ALL_USER_APISr&_ALL_INTERNAL_APISr' _ALL_PREFIXESextendrS) controllerrrrr xs   csfdd}|S)Ncs|jdk r|jj|_|Sr7)r/format)oargskwargsrr decorators z$_format_docstring..decoratorr)rrrrrr_format_docstringsri')maxsizecCs tj|S)zCSmall caching wrapper around os.path.realpath to limit system calls)ospathrealpath)rrrr _realpathsr) 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 r+rrrrr sc@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. Nlimitsr&cCs6||_|||\|_|_|_|j|_|dSr7) _controller _check_params_limits _user_api _prefixesr+_original_info_set_threadpool_limitsr$r|rr&rrrr%s z_ThreadpoolLimiter.__init__cCs|Sr7rr,rrr __enter__sz_ThreadpoolLimiter.__enter__cCs |dSr7)restore_original_limits)r$typera tracebackrrr__exit__sz_ThreadpoolLimiter.__exit__cCst|||dS)z@Return an instance of this class that can be used as a decorator)r|rr&)_ThreadpoolLimiterDecorator)clsr|rr&rrrwraps z_ThreadpoolLimiter.wrapcCs,t|jj|jD]\}}||dqdS)z,Set the limits back to their original valuesr(N)ziprlib_controllersrr.)r$lib_controllerZ original_inforrrrs  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)r&r(rrrZlib_inforprrrus z?_ThreadpoolLimiter.get_original_num_threads..rErNz1Multiple value possible for following user apis: , z. Returning the minimum.) rrsetlenr*minrwwarningswarnjoin)r$r(Z warning_apisrZn_limitslimitrrprget_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|] }|qSrrrrapirrr sz4_ThreadpoolLimiter._check_params..cSsi|]}|d|dqSrr(rrrrrr scSsi|]}|j|jqSrrrrrrrrrszUlimits must either be an int, a list, a dict, or 'sequential_blas_under_openmp'. Got z insteadcSsg|]}|tkr|qSr)rz)rrrrrrrusz4_ThreadpoolLimiter._check_params..cSsg|]}|tkr|qSr)rxrrrrrus) isinstancestrr,_get_params_for_sequential_blas_under_openmpvaluesintrx ValueErrorlistr rdict TypeErrorr)r$rr&prefixesrrrrs>    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)rrrrr&r.)r$rr(rrrr#s    z)_ThreadpoolLimiter._set_threadpool_limits)rrrr/r%rr classmethodrr unregisterrrrrrrrrs $3rc@s(eZdZdZdddddZddZdS)rz8Same as _ThreadpoolLimiter but to be used as a decoratorNrcCs"|||\|_|_|_||_dSr7)rrrrrrrrrr%>s z$_ThreadpoolLimiterDecorator.__init__cCs|j|_||Sr7)rr+rrr,rrrrDs z%_ThreadpoolLimiterDecorator.__enter__)rrrr/r%rrrrrr;srrccs|]}d|dVqdS)"NrrrrrrtNsrZ BLAS_LIBSZ 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)superr%r r$rr& __class__rrr%szthreadpool_limits.__init__cstjt||dSr)rrr )rrr&rrrrszthreadpool_limits.wrap)NN)NN)rrrr/r%rr __classcell__rrrrrMs.c@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|_||dSr7)r_load_libraries_warn_if_incompatible_openmpr,rrrr%szThreadpoolController.__init__cCs||}||_|Sr7)__new__r)rrZnew_controllerrrr_from_controllerss z&ThreadpoolController._from_controllerscCsdd|jDS)z.Return lib_controllers info as a list of dictscSsg|] }|qSr)r+rrrrrusz-ThreadpoolController.info..)rr,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|kVqdSr7)r@)rrkeyvalsrrrrtsz9ThreadpoolController.select...)anyitems)rrrrrrus  z/ThreadpoolController.select..)rrrrr r)r$rrrrrrrselects   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. r3rN)r'r:NrrEr2)rrr,rrrrs  zAThreadpoolController._get_params_for_sequential_blas_under_openmprccs|]}d|VqdSz"{}"Nr}rrrrrtszThreadpoolController.rNrcCst|||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)rrrrrrs3zThreadpoolController.limitccs|]}d|VqdSrrrrrrrtscCstj|||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)rrrrrrrs'zThreadpoolController.wrapcCs t|jSr7)rrr,rrr__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_phdrr,rrrr/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)NrFr)contentsrrI_make_controller_from_path)r+sizedatarr,rrmatch_library_callbackHs   zYThreadpoolController._find_libraries_with_dl_iterate_phdr..match_library_callbackr>N) _get_libcr_rZ CFUNCTYPErZZPOINTERrZc_size_trr)r$libcrZc_func_signatureZc_match_library_callbackrrr,rr8s    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_countrFN) rr_rrrZ_dyld_get_image_namerGrangeZ string_atrIr)r$rZn_dyldirrrrr]s    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_PATHirkZPsapikernel32FzCould not open PID zEnumProcessModulesEx failedNzGetModuleFileNameEx failed)Zctypes.wintypesrrr _get_windllZ OpenProcessrgetpidOSErrorZ CloseHandlerZsizeofZEnumProcessModulesExZbyreframapZcreate_unicode_bufferZGetModuleFileNameExWr)r$rrrZPROCESS_QUERY_INFORMATIONZPROCESS_VM_READZLIST_LIBRARIES_ALLZps_apiZ kernel_32Z h_processZ buf_countneededbufZbuf_sizecountZ h_modulesZn_sizeZh_modulerrrrrpsX      z@ThreadpoolController._find_libraries_with_enum_process_module_excst|}tj|}tD]p}|||j}|dkr8q|dkrt|drt |t t fdd|j Dstqnq|||d}|j|qdS)z:Store a library controller if it is supported and selectedNr4.dllc3s|]}t|VqdSr7)r_)rrfuncr4rrrtszBThreadpoolController._make_controller_from_path..r)rrrbasenamelowerrv _check_prefixrSendswithrrrrrTrrw)r$rfilenamecontroller_classrrrrrrs     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$Zlibrary_basenamerSrrrrrs  z"ThreadpoolController._check_prefixcCs:dd|jD}td}d|kr6d|kr6t|tdS)z?Raise a warning if llvm-OpenMP and intel-OpenMP are both loadedcSsg|] }|jqSr)rrrrrruszEThreadpoolController._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 rornN)rtextwrapdedentrrRuntimeWarning)r$rmsgrrrrs z1ThreadpoolController._warn_if_incompatible_openmpcCsf|jd}|dkrbtd}|dkrJtdtjjdtjjdt dSt j |t d}||jd<|S)z Load the lib-C for unix systems.rNcz,libc not found. The ctypes module in Python .z is maybe too old for this OS.r) _system_librariesgetrrrr version_infomajorminorrrrr)rrZ libc_namerrrrs  zThreadpoolController._get_libccCs2|j|}|dkr.t|d}||j|<|S)zLoad a windows DLLNr)rrrZWinDLL)rZdll_nameZdllrrrrs   z ThreadpoolController._get_windll)rrrr/rrr%rrr+rrrrrx_ALL_BLAS_LIBRARIES_ALL_OPENMP_LIBRARIESrrrrrrrrrrrrrrrrr s@   0$ %>-  c 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.)rrE)packagezWARNING: could not import)filerM)indent)argparse importlibjsonrArgumentParser add_argument parse_argsargvr  import_module ImportErrorprintstderrcommandexecdumpsr )rrrrparseroptionsmodulerrr_mains<  r$__main__);r/rrbrrrtypingrr ctypes.utilrabcrr functoolsr contextlibr __version____all__environ setdefaultrZc_uint64Zc_uint32rZc_uint16rZ Structurer RTLD_NOLOADrAttributeErrorZ DEFAULT_MODEr r1rUr[rmrvrrrxryrzrrSrr rrr rrrrr r$rrrrrs~        TP73    7 &