a ”$a@ã @sädZddlZddlZzddlmZmZWnReyzddlmZzddlmZWn"eytGdd„deƒZYn0Yn0ddlmZm Z m Z m Z d Z Gd d „d e ƒZGd d „d ejjƒZGdd„dejjƒZGdd„de ƒZdS)z* Runner.py: Task scheduling and execution éN)ÚQueueÚ PriorityQueue)r)rc@s$eZdZdd„Zdd„Zdd„ZdS)rcCs||_g|_dS©N)ÚmaxsizeÚqueue)Úselfr©rúh/home/jack/SDK/ZBT-AX3000-OpenWrt-21.02/build_dir/hostpkg/samba-4.14.12/third_party/waf/waflib/Runner.pyÚ_initszPriorityQueue._initcCst |j|¡dSr)ÚheapqÚheappushr)rÚitemrrr Ú_putszPriorityQueue._putcCs t |j¡Sr)r Úheappopr©rrrr Ú_getszPriorityQueue._getN)Ú__name__Ú __module__Ú __qualname__r rrrrrr rsr)ÚUtilsÚTaskÚErrorsÚLogséc@sTeZdZdd„Zdd„Zdd„Zdd„Zd d „Zd d „Zd d„Z dd„Z dd„Z dS)Ú PriorityTaskscCs g|_dSr©Úlstrrrr Ú__init__"szPriorityTasks.__init__cCs t|jƒSr)Úlenrrrrr Ú__len__$szPriorityTasks.__len__cCs t|jƒSr)Úiterrrrrr Ú__iter__&szPriorityTasks.__iter__cCsdd dd„|jDƒ¡S)NzPriorityTasks: [%s]z css|]}t|ƒVqdSr)Ústr©Ú.0Úxrrr Ú )óz(PriorityTasks.__str__..)Újoinrrrrr Ú__str__(szPriorityTasks.__str__cCs g|_dSrrrrrr Úclear*szPriorityTasks.clearcCst |j|¡dSr©r r r©rÚtaskrrr Úappend,szPriorityTasks.appendcCst |j|¡dS)zDeprecated, do not useNr+r,rrr Ú appendleft.szPriorityTasks.appendleftcCs t |j¡Sr)r rrrrrr Úpop1szPriorityTasks.popcCsD|jr|D]}| |¡q n$t|tƒr8||_t |¡n|j|_dSr)rr.Ú isinstanceÚlistr Úheapify)rrr%rrr Úextend3s  zPriorityTasks.extendN) rrrrrr!r)r*r.r/r0r4rrrr r!src@s eZdZdZdd„Zdd„ZdS)ÚConsumerz© Daemon thread object that executes a task. It shares a semaphore with the coordinator :py:class:`waflib.Runner.Spawner`. There is one instance per task to consume. cCs0tjj |¡||_||_| d¡| ¡dS©Né)rÚ threadingÚThreadrr-ÚspawnerÚ setDaemonÚstart)rr:r-rrr rDs  zConsumer.__init__c CszzH|jjjs|jj |j¡W|jj ¡|jjj |j¡d|_d|_n,|jj ¡|jjj |j¡d|_d|_0dS)z Processes a single task N) r:ÚmasterÚstopÚ process_taskr-ÚsemÚreleaseÚoutÚputrrrr ÚrunLs  ý z Consumer.runN)rrrÚ__doc__rrDrrrr r5>sr5c@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚSpawnerzÉ Daemon thread that consumes tasks from :py:class:`waflib.Runner.Parallel` producer and spawns a consuming thread :py:class:`waflib.Runner.Consumer` for each :py:class:`waflib.Task.Task` instance. cCs:tjj |¡||_tj |j¡|_| d¡|  ¡dSr6) rr8r9rr=Ú SemaphoreÚnumjobsr@r;r<)rr=rrr r_s  zSpawner.__init__cCs$z | ¡WntyYn0dS)zb Spawns new consumers to execute tasks by delegating to :py:meth:`waflib.Runner.Spawner.loop` N)ÚloopÚ Exceptionrrrr rDgs  z Spawner.runcCs>|j}|j ¡}|j ¡|js.| |jj¡t ||ƒqdS)zd Consumes task objects from the producer; ends when the producer has no more task to provide. N) r=ÚreadyÚgetr@Úacquirer>Ú log_displayÚ generatorÚbldr5)rr=r-rrr rIqs   z Spawner.loopN)rrrrErrDrIrrrr rFYs rFc@sšeZdZdZd&dd„Zdd„Zdd„Zd d „Zd d „Zd d„Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd „Zd!d"„Zd#d$„Zd%S)'ÚParallelzE Schedule the tasks obtained from the build context for execution. écCs†||_||_tƒ|_tƒ|_tƒ|_tdƒ|_t dƒ|_ d|_ d|_ d|_ g|_d|_d|_t t¡|_d|_|jdkr‚t|ƒ|_dS)ze The initialization requires a build context reference for computing the total number of jobs. rFNr7)rHrPrÚ outstandingÚ postponedÚsetÚ incompleterrKrrBÚcountÚ processedr>ÚerrorÚbiterÚdirtyrÚ defaultdictÚrevdepsr:rF)rrPÚjrrr r‚s"    zParallel.__init__cCs|js dS|j ¡S)zS Obtains the next Task instance to run :rtype: :py:class:`waflib.Task.Task` N)rSr0rrrr Ú get_next_taskÁszParallel.get_next_taskcCs|j |¡dS)zä Adds the task to the list :py:attr:`waflib.Runner.Parallel.postponed`. The order is scrambled so as to consume as many tasks in parallel as possible. :param tsk: task instance :type tsk: :py:class:`waflib.Task.Task` N)rTr.©rÚtskrrr ÚpostponeËszParallel.postponec Cs´|j|jtkr| ¡q|js°|jr<| ¡|jrÒq°n–|jrÒz|j|jk}WntydYnf0|rÊg}|jD]@}dd„|j Dƒ}|  dt |ƒ|f¡|st|  dt |ƒ¡qtt  dd |¡¡‚|j|_|jrò|j |j¡|j ¡q|js|jrn|jD]@}|j D]}|jsqq|j |¡|j  |¡q®q|js°|jr\q°t  d|j¡‚qt|jƒ}| |¡\}} |j |¡|j | ¡|j ¡|_q°qdS) z¿ Pulls a next group of tasks to execute in :py:attr:`waflib.Runner.Parallel.outstanding`. Ensures that all tasks in the current build group are complete before processing the next one. cSsg|]}|jst|ƒ‘qSr)ÚhasrunÚidr#rrr Ú ïr'z-Parallel.refill_task_list..z%s -> %rz> task %r dependencies are done, check its *runnable_status*?z/Deadlock detected: check the task build order%sÚzBroken revdeps detected on %rN)rWrHÚGAPÚget_outrSrTZdeadlockrXÚAttributeErrorÚ run_afterr.ÚreprrdrÚWafErrorr(r4r*rVrcÚremover>rYÚnextrZÚprio_and_splitÚupdaterPÚtotal) rZcondrraÚdepsr%ÚkÚtasksrKÚwaitingrrr Úrefill_task_listÕsT              zParallel.refill_task_listc CsÜt|ddƒrØt|jƒ}tƒ}dd„}||j|jƒD]h}|jD]\}t|tjƒr€||vr˜|  |¡|j |@D]}|j |  |¡qhq<||vr<|j |  |¡q.iteri)ÚgetattrrUrwrSrVrjr1rÚ TaskGroupÚaddÚprevr]ror4rprqr) rraZmoreÚ groups_donerzr%rsr^rKrurrr Úadd_more_taskss"       zParallel.add_more_taskscsÖ‡fdd„}|ˆjvr|ˆj|D]R}t|tjƒrj|j |¡|jsr|jD]}|j |¡||ƒqHg|_q ||ƒq ˆj|=t|dƒrÒ|j }z|  |¡Wnt y¬Yn&0|j rÒ|  ¡sÒ|j  ¡}ˆ |¡q®dS)Ncs<|ˆjvr8|jD]}|jsq8qˆj |¡ˆj |¡dSr)rVrjrcrmrSr.)r%rsrrr Ú try_unfreeze5s    z,Parallel.mark_finished..try_unfreezeÚ semaphore)r]r1rr|r~rmrnrjÚhasattrr‚rAÚKeyErrorruÚ is_lockedr0Ú _add_task)rrarr%rsr@rrr Ú mark_finished4s*           zParallel.mark_finishedcCs<|j ¡}|js| |¡| |¡|jd8_d|_|S)zè Waits for a Task that task consumers add to :py:attr:`waflib.Runner.Parallel.out` after execution. Adds more Tasks if necessary through :py:attr:`waflib.Runner.Parallel.add_more_tasks`. :rtype: :py:attr:`waflib.Task.Task` r7T)rBrLr>r€r‡rWr[r`rrr rh_s   zParallel.get_outcCs|j |¡dS)z¥ Enqueue a Task to :py:attr:`waflib.Runner.Parallel.ready` so that consumers can run them. :param tsk: task instance :type tsk: :py:attr:`waflib.Task.Task` N)rKrCr`rrr Úadd_taskoszParallel.add_taskc Cs®t|dƒr@|j}z| |¡Wn ty>|j |¡YdS0|jd7_|jd7_|jdkr |  |j j ¡z|  |¡W|j  |¡qª|j  |¡0n | |¡dS)Nr‚r7)rƒr‚rMÚ IndexErrorrur}rWrXrHrNrOrPr?rBrCrˆ)rrar@rrr r†ys     zParallel._add_taskcCs"| ¡|jtjkr| |¡dS)zG Processes a task and attempts to stop the build in case of errors N)ÚprocessrcrÚSUCCESSÚ error_handlerr`rrr r?s zParallel.process_taskcCstj|_| |¡dS)z' Mark a task as skipped/up-to-date N)rÚSKIPPEDrcr‡r`rrr Úskip•sz Parallel.skipcCstj|_| |¡dS)zA Mark a task as failed because of unsatisfiable dependencies N)rÚCANCELEDrcr‡r`rrr ÚcancelœszParallel.cancelcCs|jjsd|_|j |¡dS)zã Called when a task cannot be executed. The flag :py:attr:`waflib.Runner.Parallel.stop` is set, unless the build is executed with:: $ waf build -k :param tsk: task instance :type tsk: :py:attr:`waflib.Task.Task` TN)rPÚkeepr>rYr.r`rrr rŒ£s zParallel.error_handlercCsºz | ¡WSty´|jd7_t ¡|_|js˜|jjr˜|  |¡|jjdkrxt j dksd|j sp|j   |¡d|_nt j dkrŽ|j   |¡tjYStj|_| |¡tjYS0dS)z© Obtains the task status to decide whether to run it immediately or not. :return: the exit status, for example :py:attr:`waflib.Task.ASK_LATER` :rtype: integer r7TN)Úrunnable_statusrJrXÚ tracebackÚ format_excÚerr_msgr>rPr‘rŽrÚverboserYr.rÚ EXCEPTIONrcrŒr`rrr Ú task_status±s"          zParallel.task_statuscCsD|j ¡|_|jsî| ¡| ¡}|s2|jrîq nqî|jrH|jd7_q |jrPqî| |¡}|t j krp|  |¡q |t j kr†|  |¡q |t jkr´|jd7_| |¡| |¡q |t jkr tjdkrÔ|j |¡|jd7_| |¡q |jr|jr| ¡qî|j d¡|js@|jr(J‚|jr4J‚|jr@J‚dS)aà Obtains Task instances from the BuildContext instance and adds the ones that need to be executed to :py:class:`waflib.Runner.Parallel.ready` so that the :py:class:`waflib.Runner.Spawner` consumer thread has them executed. Obtains the executed Tasks back from :py:class:`waflib.Runner.Parallel.out` and marks the build as failed by setting the ``stop`` flag. If only one job is used, then executes the tasks one by one, without consumers. r7N)rPrqr>rvr_rWrcrXr˜rÚRUN_MEr†Ú ASK_LATERrbÚSKIP_MErŽr€Ú CANCEL_MErr–rYr.rrhrKrCrTrV)rraÚstrrr r<ÎsD                 zParallel.startc s|D] }d|_q|j‰tƒ}|D]X}|jD]L}t|tjƒrh||vrv| |¡|jD]}ˆ| |¡qRq*ˆ| |¡q*q ‡‡fdd„‰|D]>}|jdkrœqŒz ˆ|ƒWqŒt j yÈ|  |ˆ¡YqŒ0qŒg}g}|D].}|jD]}|j sâ|  |¡qØqâ|  |¡qØ||fS)a< Label input tasks with priority values, and return a pair containing the tasks that are ready to run and the tasks that are necessarily waiting for other tasks to complete. The priority system is really meant as an optional layer for optimization: dependency cycles are found quickly, and builds should be more efficient. A high priority number means that a task is processed first. This method can be overridden to disable the priority system:: def prio_and_split(self, tasks): return tasks, [] :return: A pair of task lists :rtype: tuple rcs–t|tjƒr$t‡fdd„|jDƒƒS|jdkr|d|_|ˆvrlˆ|}|jt|ƒt‡fdd„|Dƒƒ|_n|j|_d|_n|jdkrt   d¡‚|jS)Nc3s|]}ˆ|ƒVqdSrr©r$rs©Úvisitrr r&1r'z9Parallel.prio_and_split..visit..rr7c3s|]}ˆ|ƒVqdSrrržrŸrr r&8r'rRzDependency cycle found!) r1rr|ÚsumrnÚvisitedÚ tree_weightrÚ prio_orderrrl)ÚnZrev©Úreverser rr r /s  (  z&Parallel.prio_and_split..visit)r¢r]rUrjr1rr|r}r~rrlÚ debug_cyclesrcr.)rrtr%rrsr^rKrurr¦r ro s:         zParallel.prio_and_splitcs>i‰|D] }dˆ|<q‡‡‡fdd„‰|D]}ˆ|gƒq*dS)Nrcs²t|tjƒr&|jD]}ˆ||ƒqdSˆ|dkrfdˆ|<ˆ |g¡D]}ˆ||g|ƒqFdˆ|<nHˆ|dkr®g}|D]}| t|ƒ¡||urzqšqzt dd  |¡¡‚dS)Nrr7rRz4Task dependency cycle in "run_after" constraints: %srf) r1rr|rnrLr.rkrrlr()r¥Úaccrsrra©r§Útmpr rr r Zs       z$Parallel.debug_cycles..visitr)rrtr§r%rrªr r¨Us  zParallel.debug_cyclesN)rR)rrrrErr_rbrvr€r‡rhrˆr†r?rŽrrŒr˜r<ror¨rrrr rQ~s$ ?  ;$+ <KrQ)rEr r“rrrÚ ImportErrorÚwaflibrrrrrgÚobjectrr8r9r5rFrQrrrr Ús    %