[Thr% d%SSKrSSKrSSKrSSKrSSKJr SSKJrJr SSK J r J r /SQr \R"\5r"SS5r"SS \R"5r"S S \R"5r"S S \R"5rSq\ \\S'S\4Sjr\SS\S\ \S\ \4Sjj5rg)N)contextmanager) getframeinfostack)AnyOptional) TimerRequest TimerClient RequestQueue TimerServer configureexpiresc<\rSrSrSr/SQrS\S\S\4Sjr Sr S r g ) ra Data object representing a countdown timer acquisition and release that is used between the ``TimerClient`` and ``TimerServer``. A negative ``expiration_time`` should be interpreted as a "release" request. .. note:: the type of ``worker_id`` is implementation specific. It is whatever the TimerServer and TimerClient implementations have on to uniquely identify a worker.  worker_idscope_idexpiration_timerrrc(XlX lX0lgNr)selfrrrs [/var/www/auris/envauris/lib/python3.13/site-packages/torch/distributed/elastic/timer/api.py__init__TimerRequest.__init__*s" .c[U[5(aYURUR:H=(a9 URUR:H=(a URUR:H$g)NF) isinstancerrrr)rothers r__eq__TimerRequest.__eq__/sY e\ * *%//1BMMU^^3B((E,A,AA  r)rrrN) __name__ __module__ __qualname____firstlineno____doc__ __slots__rstrfloatrr__static_attributes__rrrrs- =I/#//u/ rrcx\rSrSrSr\R S\S\SS4Sj5r \R S\4Sj5r S r g) r 9z_ Client library to acquire and release countdown timers by communicating with the TimerServer. rrreturnNcg)z Acquires a timer for the worker that holds this client object given the scope_id and expiration_time. Typically registers the timer with the TimerServer. Nr))rrrs racquireTimerClient.acquire?rcg)z Releases the timer for the ``scope_id`` on the worker this client represents. After this method is called, the countdown timer on the scope is no longer in effect. Nr))rrs rreleaseTimerClient.releaseGr0rr)) r r!r"r#r$abcabstractmethodr&r'r.r2r(r)rrr r 9sW    e       rr c~\rSrSrSr\R S\4Sj5r\R S\S\ S\ \ 4Sj5r Sr g ) r Pz; Consumer queue holding timer acquisition/release requests r,cg)a Returns the size of the queue at the time this method is called. Note that by the time ``get`` is called the size of the queue may have increased. The size of the queue should not decrease until the ``get`` method is called. That is, the following assertion should hold: size = q.size() res = q.get(size, timeout=0) assert size == len(res) -- or -- size = q.size() res = q.get(size * 2, timeout=1) assert size <= len(res) <= size * 2 Nr)rs rsizeRequestQueue.sizeUr0rr:timeoutcg)zh Gets up to ``size`` number of timer requests in a blocking fashion (no more than ``timeout`` seconds). Nr))rr:r<s rgetRequestQueue.getir0rr)N)r r!r"r#r$r4r5intr:r'listrr>r(r)rrr r Ps\  c  &   e \0B  rr cV^\rSrSrSrSS\S\S\4U4Sjjjr\ RS\ \ SS 4S j5r \ RS \\SS 4S j5r\ RS \S\\\ \ 44Sj5r\ RS\S\4Sj5rS\S\4SjrSrSrSrSSjrSSjrSrU=r$)r qz Entity that monitors active timers and expires them in a timely fashion. This server is responsible for reaping workers that have expired timers. request_queue max_intervaldaemoncb>[TU]5 XlX lX0lSUlSUlg)z :param request_queue: Consumer ``RequestQueue`` :param max_interval: max time (in seconds) to wait for an item in the request_queue :param daemon: whether to run the watchdog thread as a daemon NF)superr_request_queue _max_interval_daemon_watchdog_thread_stop_signaled)rrDrErF __class__s rrTimerServer.__init__xs1 +) <@#rtimer_requestsr,Ncg)z Processes the incoming timer requests and registers them with the server. The timer request can either be a acquire-timer or release-timer request. Timer requests with a negative expiration_time should be interpreted as a release-timer request. Nr))rrPs rregister_timersTimerServer.register_timersr0r worker_idscg)z1 Clears all timers for the given ``worker_ids``. Nr))rrTs r clear_timersTimerServer.clear_timersr0rdeadlinecg)z Returns all expired timers for each worker_id. An expired timer is a timer for which the expiration_time is less than or equal to the provided deadline. Nr))rrXs rget_expired_timersTimerServer.get_expired_timersr0rrcg)z Reaps the given worker. Returns True if the worker has been successfully reaped, False otherwise. If any uncaught exception is thrown from this method, the worker is considered reaped and all associated timers will be removed. Nr)rrs r _reap_workerTimerServer._reap_workerr0rcpURU5$![a [RS5 gf=f)zp Wraps ``_reap_worker(worker_id)``, if an uncaught exception is thrown, then it considers the worker as reaped. ziUncaught exception thrown from _reap_worker(), check that the implementation correctly catches exceptionsT)r^ Exceptionlogger exceptionr]s r_reap_worker_no_throw!TimerServer._reap_worker_no_throws@  $$Y/ /    M   s 55cUR(d%UR5 UR(dM$gg![a [R S5 N6f=f)NzError running watchdog)rM _run_watchdograrbrcr9s r_watchdog_loopTimerServer._watchdog_loopsJ%% ;""$%%% ;  !9: ;s8AAc^[SURR55nURRXR5nUR U5 [ R "5n[5nURU5R5HupV[RSUURU55 URU5(a)[RSU5 URU5 Mj[RSU5 M UR!U5 g)Nz*Reaping worker_id=[%s]. Expired timers: %szSuccessfully reaped worker=[%s]z7Error reaping worker=[%s]. Will retry on next watchdog.)maxrIr:r>rJrRtimesetrZitemsrbinfo _get_scopesrdadderrorrV)r batch_sizerPnowreaped_worker_idsrexpired_timerss rrgTimerServer._run_watchdogsD//4467 ,,00=O=OP ^,iikE)-)@)@)E)K)K)M %I KK<  0  )))44 =yI!%%i0 My*N +,rcDUVs/sHo"RPM sn$s snfr)r)rrPrs rrqTimerServer._get_scopess$23Nq N333sc<[RS[U5RURUR 5 [ R"URUR S9Ul [RS5 URR5 g)Nz)Starting %s... max_interval=%s, daemon=%s)targetrFzStarting watchdog thread...) rbrptyper rJrK threadingThreadrhrLstartr9s rrTimerServer.startss 7 J      LL  !* 0 0&&t||!   12 ##%rc4[RS[U5R5 SUlUR (aB[RS5 UR R UR5 SUlg[RS5 g)Nz Stopping %sTzStopping watchdog thread...z)No watchdog thread running, doing nothing)rbrpr~r rMrLjoinrJr9s rstopTimerServer.stopsg M4:#6#67"  KK5 6  ! ! & &t'9'9 :$(D ! KKC Dr)rKrJrIrMrL)T)r,N)r r!r"r#r$r r'boolrr4r5rArrRrnrrVdictr&rZr^rdrhrgrqrrr( __classcell__)rNs@rr r qsPT$)$9>$HL$$   d<.@ T    s3x D    5 T#tL?Q:Q5R    c d   s t ;-*4 &EErr _timer_client timer_clientcbUq[RS[[5R5 g)zE Configures a timer client. Must be called before using ``expires``. zTimer client configured to: %sN)rrbrpr~r )rs rr r s# !M KK0$}2E2N2NOrafterscopeclientc#Z# Uc[c [S5e[nUc4[[5SS5nURSUR 3n[ R "5U-nURX5 Sv URU5 g!URU5 f=f7f)a Acquires a countdown timer that expires in ``after`` seconds from now, unless the code-block that it wraps is finished within the timeframe. When the timer expires, this worker is eligible to be reaped. The exact meaning of "reaped" depends on the client implementation. In most cases, reaping means to terminate the worker process. Note that the worker is NOT guaranteed to be reaped at exactly ``time.now() + after``, but rather the worker is "eligible" for being reaped and the ``TimerServer`` that the client talks to will ultimately make the decision when and how to reap the workers with expired timers. Usage:: torch.distributed.elastic.timer.configure(LocalTimerClient()) with expires(after=10): torch.distributed.all_reduce(...) Nz5Configure timer client before using countdown timers.rkr#) r RuntimeErrorrrfilenamelinenormr.r2)rrrcaller expirations rr r s*~  VW W }egajm,??#1V]]O4u$J NN5% uusArs  %'     8 $: #'' . 377 ByE#''yEx(, x $+PKPOS! !!#!7? 7L!!r