z i{4~SrSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK J r SSK J r \ R"5rSrSrSr\R&SS j5rS rSS jrSqS qS rSr\R&SSSjj5r\R8S5r\R8SSj5r\\l\\l SSjr!g)zi Routines for running Python functions in parallel using process pools from the multiprocessing library. ) annotationsN)ProcessPoolExecutor) user_configc$Uupp4U"U/UQ70UD6$N)paramtaskvalue task_args task_kwargss O/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/utils/parallel.py _task_wrapperrHs!,1)T)  1 1[ 11c[[SS5=nb[U"S55nO[R"5=(d SnUS-=(d S$)Nsched_getaffinityr)getattroslen cpu_count)rnum_cpuss r#_physical_cpus_assuming_twofold_smtrMsI$R)&Q M arc`[R"SS9=nc[RS;$US;$)NT) allow_none)darwinwin32)fork forkserver)multiprocessingget_start_methodsysplatform)set_start_methods r_parallel_defaultr&Xs7+<<MMV||#666 5 55rc[R"S5=n(a[U5nUS:aU$S$[ RSS5=nb US:aU$S$[5$![a [R "SUS35 NSf=f)aEGet the number of processes that a multiprocessing parallel call will use by default. Such functions typically also accept a ``num_processes`` keyword argument that will supersede the value returned from this function. In order of priority (highest to lowest), the return value will be: 1. The ``QISKIT_NUM_PROCS`` environment variable, if set. 2. The ``num_processes`` key of the Qiskit user configuration file, if set. 3. Half of the logical CPUs available to this process, if this can be determined. This is a proxy for the number of physical CPUs, assuming two-fold simultaneous multithreading (SMT); empirically, multiprocessing performance of Qiskit seems to be worse when attempting to use SMT cores. 4. 1, if all else fails. If a user-configured value is set to a number less than 1, it is treated as if it were 1. QISKIT_NUM_PROCSrrzAfailed to interpret environment 'QISKIT_NUM_PROCS' as a number: '' num_processesN) rgetenvint ValueErrorwarningswarnCONFIGgetr)env_num_processesuser_num_processess rdefault_num_processesr4as(II&8999 E #$5 6 ):A(=$ D1 D$jj$??L%7!%;!BB . 00  MM&'q*  s A!!$BBc[R"5SR[R"55[R"5[R "5[ 5S.$)aBasic hardware information about the local machine. Attempts to estimate the number of physical CPUs in the machine, even when hyperthreading is turned on. CPU count defaults to 1 when true count can't be determined. Returns: dict: The hardware information. z, )python_compiler python_buildpython_versionrcpus)r$r6joinr7r8systemrrrrlocal_hardware_infor<sK$335 ("7"7"9:"113oo35  rc0[R"5SL$)aUChecks whether the current process is the main one. Since Python 3.8, this is identical to the standard Python way of calculating this:: >>> import multiprocessing >>> multiprocessing.parent_process() is None This function is left for backwards compatibility, but there is little reason not to use the built-in tooling of Python. N)r!parent_processrrris_main_processr?s  ) ) +t 33rFFALSETRUEc\Uc [5OUnUS:ag[R"S[5[:wag[b[$[ (a [ 5$[R"S5=nbUR5S:H$[RSS5=nbU$[ 5$)aDecide whether a multiprocessing function should spawn subprocesses for parallelization. In particular, this is how :func:`parallel_map` decides whether to use multiprocessing or not. The ``num_processes`` argument alone does not enforce parallelism; by default, Qiskit will only use process-based parallelism when a ``fork``-like process spawning start method is in effect. You can override this decision either by setting the :mod:`multiprocessing` start method you use, setting the ``QISKIT_PARALLEL`` environment variable to ``"TRUE"``, or setting ``parallel = true`` in your user settings file. This function includes two context managers that can be used to temporarily modify the return value of this function: .. autofunction:: qiskit.utils::should_run_in_parallel.override .. autofunction:: qiskit.utils::should_run_in_parallel.ignore_user_settings Args: num_processes: the maximum number of processes requested for use (``None`` implies the default). Examples: Temporarily override the configured settings to disable parallelism:: >>> with should_run_in_parallel.override(True): ... assert should_run_in_parallel(8) >>> with should_run_in_parallel.override(False): ... assert not should_run_in_parallel(8) NrFQISKIT_IN_PARALLELQISKIT_PARALLELtrueparallel_enabled) r4rr+_IN_PARALLEL_ALLOW_PARALLELISM_PARALLEL_OVERRIDE_PARALLEL_IGNORE_USER_SETTINGSr&lowerr0r1)r*env_qiskit_paralleluser_qiskit_parallels rshould_run_in_parallelrMs>0=/D)+-Mq &(FG ) *%!!%% ""!yy):;;H"((*f44 & +=t DDQ##  rc## [R5 [SsnqSv Uq[R5 g!Uq[R5 f=f7f)zA context manager within which :func:`should_run_in_parallel` will ignore environmental configuration variables. In particular, the ``QISKIT_PARALLEL`` environment variable and the user-configuration file are ignored within this context.TN)rM cache_clearrI)previouss r_parallel_ignore_user_settingsrQsO&&(/Mt,H,- )1&**,*2&**,A<AAAc## [R5 [UsnqSv Uq[R5 g!Uq[R5 f=f7f)aA context manager within which :func:`should_run_in_parallel` will return the given ``value``. This is not a *complete* override; Qiskit will never attempt to parallelize if only a single process is available, and will not allow process-based parallelism at a depth greater than 1.N)rMrOrH)r rPs r_parallel_overriderTsO&&(#5u H - %**,&**,rRc:^^^Tc0OTmUc [5n[U5S:d[U5(dUVs/sHnT"U/TQ70TD6PM sn$UUU4SjU5n[R"S[ 5n[ [RS'[US9n[UR[U55sSSS5 U[RS'$s snf!,(df  O=fU[RS'g!U[RS'f=f)a Parallel execution of a mapping of `values` to the function `task`. This is functionally equivalent to:: result = [task(value, *task_args, **task_kwargs) for value in values] This will parallelise the results if the number of ``values`` is greater than one and :func:`should_run_in_parallel` returns ``True``. If not, it will run in serial. Args: task (func): Function that is to be called for each value in ``values``. values (array_like): List or array of values for which the ``task`` function is to be evaluated. task_args (list): Optional additional arguments to the ``task`` function. task_kwargs (dict): Optional additional keyword argument to the ``task`` function. num_processes (int): Number of processes to spawn. If not given, the return value of :func:`default_num_processes` is used. Returns: result: The result list contains the value of ``task(value, *task_args, **task_kwargs)`` for each value in ``values``. Examples: .. plot:: :include-source: :nofigs: import time from qiskit.utils import parallel_map def func(_): time.sleep(0.1) return 0 parallel_map(func, list(range(10))); Nrc30># UH nTUTT4v M g7frr).0r r r r s r parallel_map..5sLVE4 ;7VsrC) max_workers) r4rrMrr+rG_IN_PARALLEL_FORBID_PARALLELISMenvironrlistmapr) r valuesr r r*r work_itemsprevious_in_parallelexecutors ` `` r parallel_maprc sH$+"K-/  6{Q4]CCDJKF5U6Y6+6FKKLVLJ99%9;YZ'FBJJ#$@ ] ;x ]J?@< ;,@ '(L< ; ;,@ '(+? '(s)C DC= D C-)DD)returnr,)rdboolr)r*z int | Nonerdre)r re)rNN)"__doc__ __future__r contextlib functoolsr!rr$r#r.concurrent.futuresrqiskitr get_configr0rrr&cacher4r<r?rHrIrGr[rMcontextmanagerrQrTignore_user_settingsoverridercrrrrqsd #  2    !2  6  1 1F$ 4!&!("( 11h --& --&/M+"42@r