rust U?#rustc 1.98.1 (48a229cea 2026-09-01)ÁûÊÆÍRLñ.åSÛAúwjL-df1bddb45adbe94bÁ±ò‰<å%Z‰>¸64‡ËV`-2d2ab9fb0fe1def5ÁŠ AtomicUsizeÁ\§Óportable-atomicÁÜôû AtomicWakerÁ ƒ wakerÁWAITINGÁ REGISTERINGÁWAKINGÁ˜  AssertSyncÁregisterÁ wakeÁtakeÁ>ñ8888888´…´…WakerÁµ…ƒ‰…­3‹e]éö  ê ƒ ƒÕžSƒ‡2Ÿg‹ýÆ‹ÿ ‹´…    öŸgýÆÿ 0ÁŸ0b01ÁŸ0b10ÁÌàFa „Ú Ÿÿ`ÿ`V�a¬â`½68ŸœRtŸü¿Fo  V“2“2 UnsafeCellÁ•2�ñ.ç–\*=°"�řǙș­É™Ê™àË™óG*¤�R{9 Í ­G´Gü«E‰ù רÉ• (ýð”PÏš2ƒ¬ŽG‹$ÁEþSN<ñFŸu| „„àF • :ŸD«r$žG ř͕ œ|ŽG š2ƒ=¾ ¢G´  .54.=‹ þ^Ë'ƒ·hŸüœ„#i ¨áA ­á%�¯Ïþ“2“2Õ•2�ñ.ç–\*=°"�ø`ø`ù`Align8Áû`óë` x:B’‚£+}ŸM‡Œ ŸŸýΖ 7î ©ŸŸÔ«Õ«Ö«Ï׫ث٫ÐÚ«Û«Ü«Gݫޫ߫Fà«á«â«Üã« šÃíc1Œ¤ü– îŸ�— Î$ÑŠîƒ âŠ å�¯ÏžËý�¯2Ï ƒ À¯Ïý�–&• è–• îƒü‰†&i §Æ A ¬Æ   þœ ² • /  ý±Š 9î ¡ŸŸ¿ ¿አîýÿÿÿÿÿÿÿŸæŠ S òŠóŠ Ááü–„) ÀÆ  ¯† Ô†ü–‚Ýü¡…´üâ†�ù ôßÞ© ħ„ù öå `³ Rýè¬ßÏ 2Ê ) ¼æ ýØ>ŒçÊ Ÿ1 Âæ ý‡“ âÅbŸŸù žá$[ 2ƒ,Ã…ýâ�´n«XÍ4Ê…ýï�•• ôƒÅø‘n ýƒ–•  ù ñÄà§ Ü”†Þ ³   Ø  2Ê Ñ Ì çÊ ŸÇ ý´‡ é µbŸŸù œÆ% ƒl¬‚ ‹,¢‚Ÿ¦Æ„¸…Ÿ›• ¶ œ  Ë!• µ «1Rƒ,¥…ƒ,â†ö4°„Ÿ4Ÿ†Ÿ\\†ŠŸ4”ŠŸ4§ŠŸ ¸[ɇT]ƒl ©ŸŸ¿ ¿ýž— 8² ä ©ŸŸ¿ ¿ýþ• 8 ©ŸŸ¿ ¿ý­• 8 ©ŸŸ¿ ¿ýÝ” 7 ¡ŸŸ¿ ¿ýÒ‹ 8 ¡ŸŸ¿ ¿ý‚‹ 8ßç ¡ŸŸ¿ ¿ý߉ 9 ¡ŸŸ¿ ¿ý�‰ 9Øà îŸþ.  îËËÑ‹üš‹7唹‹î• Øš2ƒ‹$ª‹þØU7Ÿ ûÕT¯“2ñÅûcF4íš�F›�G<õ˜�G™�Ð<þ–�З�Ù,˜´… Š\á�  ü§�ü>; `futures::task::AtomicWaker` extracted into its own crate.Á?�tC # FeaturesÁR�üVGD This crate adds a feature, `portable-atomic`, which uses a polyfillÁüžHE from the [`portable-atomic`] crate in order to provide functionalityÁüçNK to targets without atomics. See the [`README`] for the [`portable-atomic`]Áü¶0- crate for more information on how to use it.Áç�üëA> [`portable-atomic`]: https://crates.io/crates/portable-atomicÁü­[X [`README`]: https://github.com/taiki-e/portable-atomic/blob/main/README.md#optional-cfgÁü•…ahttps://raw.githubusercontent.com/smol-rs/smol/master/assets/images/logo_fullsize_transparent.pngÁ„¡³ l§ ûÎÕÏ“2ñÎûcFÍš�Fß›�G͘�Gß™�ÐÍ–�Ðà—�ÙÍ´… ŠÌ�  š� ´£—L¿‹ä΀ƒ`c?BŒŒ!üÍÓ¡ܪì©ü (.´Ùüµ0- A synchronization primitive for task wakeup.Áæ�üêIF Sometimes the task interested in a given event will change over time.Áü´ NK An `AtomicWaker` can coordinate concurrent notifications with the consumerÁüƒ LI potentially "updating" the underlying task to wake up. This is useful inÁüÐ JG scenarios where a computation completes in another thread and wants toÁü› PM notify the consumer, but the consumer is in the process of being migrated toÁ¼ì  a new logical task.Á„ �üˆ PM Consumers should call `register` before checking the result of a computationÁüÙ JG and producers should call `wake` after producing the computation (thisÁü¤ LI differs from the usual `thread::park` pattern). It is also permitted forÁüñ GD `wake` to be called **before** `register`. This results in a no-op.Á¹�ü½QN A single `AtomicWaker` may be reused for any number of calls to `register` orÁ\� `wake`.Á›�¬Ÿ # Memory orderingÁµ�ü¹JG Calling `register` "acquires" all memory "released" by calls to `wake`Áü„GD before the call to `register`. Later calls to `wake` will wake theÁüÌPM registered waker (on contention this wake might be triggered in `register`).Á��ü¡OL For concurrent calls to `register` (should be avoided) the ordering is onlyÁüñ$! guaranteed for the winning call.Á–�tš # ExamplesÁ©�ü­NK Here is a simple example providing a `Flag` that can be signalled manuallyÁ¬ü when it is ready.Á’�<– ```Áüž  use futures::future::Future;Áü¿41 use futures::task::{Context, Poll, AtomicWaker};Á¼ô use std::sync::Arc;ÁüŒ&# use std::sync::atomic::AtomicBool;Áü³-* use std::sync::atomic::Ordering::Relaxed;Á´á use std::pin::Pin;Áø�”ü struct Inner {ÁÜ� waker: AtomicWaker,ÁÄ« set: AtomicBool,Á,Ä }ÁÊ�¤Î #[derive(Clone)]Áäã struct Flag(Arc);Á€�|„ impl Flag {Áô” pub fn new() -> Self {Áü³! Flag(Arc::new(Inner {ÁüÕ*' waker: AtomicWaker::new(),Áü€,) set: AtomicBool::new(false),Á|­ }))ÁL½ }ÁÇ�ôË pub fn signal(&self) {Áüê,) self.0.set.store(true, Relaxed);Áü—  self.0.waker.wake();ÁL¸ª6,ÂÖ3È�ÔÌ impl Future for Flag {ÁÌç type Output = ();Á��ü…IF fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {ÁüÏA> // quick check to avoid registration if already done.Áü‘)& if self.0.set.load(Relaxed) {Áü»'$ return Poll::Ready(());Álã }Áñ�üõ.+ self.0.waker.register(cx.waker());Á¤�ü¨KH // Need to check condition **after** `register` to avoid a raceÁüôA> // condition that would result in lost notifications.Áü¶)ã9üà Poll::Ready(())Á¤€ } else {Áì• Poll::PendingÁl³Æ:LÁª6,ËÖ3<ÑÌ0\ä‹ÕžSƒ‡2 ”ö,ö  þüŽ ,Ž  ˤƒC<‰CŸÄåC\ëCŸœÖD4ÜDŸ„óD‹Ô«EäŠE Create an `AtomicWaker`.Á¸E‹Bÿ ´÷ETýEÿÆÌ÷Eÿ ›A$‰F“A'¥A“A1¥A'Ì™FÍü©W%üºG:7 Registers the waker to be notified on calls to `wake`.ÁùG�ü�HKH The new task will take place of any previous tasks that were registeredÁüÑHJG by previous calls to `register`. Any calls to `wake` that happen afterÁü IHE a call to `register` (as defined by the memory ordering rules), willÁüíILI notify the `register` caller's task and deregister the waker from futureÁü¾JIF notifications. Because of this, callers should ensure `register` getsÁüŒKC@ invoked with a new `Waker` **each** time they require a wakeup.ÁÔK�üÜKJG It is safe to call `register` with multiple other threads concurrentlyÁü«LGD calling `wake`. This will result in the `register` caller's currentÁì÷L task being notified once.Á™M�ü¡MKH This function is safe to call concurrently, but this is generally a badÁüñMKH idea. Concurrent calls to `register` will attempt to register differentÁüÁNLI tasks to be notified. One of the callers will win and have its task set,Áü’O>; but there is no guarantee as to which caller will succeed.ÁÕO�tÝO§/ðO�üøO<9 Here is how `register` is used when implementing a flag.Á¹P�<ÁPÌ0üÍP Ý0üòP4‡1ü«Q&å1üÖQ-•2´ˆRË2£R�Œ«R struct Flag {ÁÜÁR‘3ÄáRµ3,þRÖ3ˆS�Ô�Só7̯S–8ÍS�üÕSIÅ8ü£TKH // Register **before** checking `set` to avoid a race conditionÁüóT74 // that would result in lost notifications.Áü¯U,) self.waker.register(cx.waker());ÁàU�üèU'$ if self.set.load(Relaxed) {Áü”VÚ<¤¸V‚=ìÑVŸ=lóVÆ:L…Wª6,“WÖ3<�WÌ0D°W  ‹  ÍBÿ ¹W $ºWƒ,ÀWÙX���ŸŸUÿ»P”¢~ü”}:7 Calls `wake` on the last `Waker` passed to `register`.ÁÓ}�üÛ}B? If `register` has not been called yet, then this does nothing.Á$©~! !‹»PBÿ ®~ $¯~ü–‚#ü‘PM Returns the last `Waker` passed to `register`, so that the user can wake it.Áæ�î�üö[X Sometimes, just waking the AtomicWaker is not fine grained enough. This allows the userÁüÖ€[X to take the waker and then wake it separately, rather than performing both steps in oneÁ”¶� atomic action.ÁÍ��üÕ�<9 If a waker has not been registered, this returns `None`.Á$�‚" "‹ƒBÿ ¢‚ $£‚ä÷Š‹÷¤š‹<�‹‹Bÿ üÕ‹‹ güû‹8þ‹#$% #‹ $€g€gŠ‚gê ûcƒgbufÁûcØ«q¢1È¡%ÀœÜÄœ¯ÅœóƜǜ€Èœó‘¥_¿´Òw»PĤĤŤErrorÁ Ñâó:½ÖàMBÿ ‚Œ $ƒŒœ ‰ŒüàŒ ‹ü„� ‹î ÇWîÞîçî]î ŒŒî Œî (https://crates.io/crates/portable-atomicÁ>https://github.com/taiki-e/portable-atomic/blob/main/README.mdÁREADMEÁÂZ¡•Z…[ÂZ¡•Z…[¡ƒÿÿÿÿÿÿÿƒÿ¼[Ë[Ø4u‚á˜x`9d7S54”ÞN!éÍâÛdË4ÈåBàG�Õ• AhÄä2¦|+×�z‡²WUàNLô¿³�jÞA“rëöнšõÛ±€îöÑsù}b‡ª#My>ÌÞ¼ÈòÀd¦ã÷ÏÆXs‰ C':ÒáÝìÕL4]j@È(½Ñ·‡®Ý%É#wúÛø;ÈÊ-÷EøâÜOa«÷1�3ž;£�µeø+m¢:"²¥ beûx¿KèRD N -° º ˆŒ“š�£©°¸ØR/G[oƒœö] o2 æ'A(,)*+E+{+—+Ä,×,¬X �X i 6+‡+Ð,ã,«ñ3K_sÙüš'õ(ò*^+°+´ …ˆ�–𠦬³Ô*CWk˜òY j â'=(&)%+@+u+‘+¾,Ñ,ä,ê,ñ,÷,ý,- -‚Œ“�£©°Ñí/G[oÁø‚'Ý(Ù*E+—+ç,î,ô,ú,ÿ,--ø$=Sg{‹è e Ë'#()+2+m+ƒ+¥,Ì,ß,ò5Mau…àþ_ ¿'ú' )+,+e+}+˜,Æ,Ù,ú(AUi}�îg Ï''()+4+q+…+©,Î,á,òÚ›'ö(ó*_+±+Ú›'ö(ó*_+±+ņ'æ'á(Þ*J+œ+ÉAKV3 Öd K”¨¿J Ð c Ñ ì¡µÌ¥¹ÐòÓ')+u+­,4 ©ëƒö] *+{+Ä,×, ü¸»ÂÆÊÎÒÖÚÞâæøÿ +8<CTXgkv�…‹�–šž¤ª°¶¼Â “”•–7+ˆ+Ò Ó Ö Ø Ú Û -—X i <+�+Ð,ã, ¨Øîî$crate::assertÁɇT]�±ù]core_intrinsicsÁpanic_internalsÁƒgeneric_assert_internalsÁ±œØ4u‚á˜xà7PØl1áîîÜ Ø4u‚á˜xšøZÃ`*” debug_assertÁü‰}ÍœS]ƒ‘‹Ø4u‚á˜xšZIè�®r 78[7_738W7e7 8;8‰7y7#8l8ü7ðODHT &@·ÞšõÛ±€îöÑ ŠôE¤5 &iÓCð~©�;;oÅþòËsù}b‡ª# ø ÀSÈã>3”D ÉšÞ‹‡®Ý%É#wúx¿KèR%Rvæ/?Ÿb`9d7S54”ÏG/딜9…àG�Õ• A C':ÒáÝ×�z‡²WU�»È¯ã›KÛø;ÈÊ- My>ÌÞ¼Èò ÷EøâÜOa«!÷1�3ž;£�"Ø4u‚á˜x�2¾¶aß),²¥ beû$Àd¦ã÷Ï ÞN!éÍÞA“rëöнÜÝý©+<çµeø+m¢:"#ßcÍ÷oá賫Qžqî»hÄä2¦|+ÆXs‰ …—ï4 ÌªâÛdË4ÈåBìÕL4]j@È(½Ñ·)%$"1JOMKQQKMHR KHQP%O!5'."+- -! JB*(/LB*  &NO:ICMKNQPL8QP*MQP4OQMON7PNOJQJG# MNQMP-PLMCKQPL+$8LMQOOQ9O5NO9G!O!!'"%.* ?POMQNHOL"PPQCA %9+2  NP<1,$" ,F# >[/MFNO1QQPOS##R #ONCM?)OHI)LT*MVRTT>NNN7RS*FLBBB+@C!%DLPQBP'V ?G+ U``A*OK846C$8G$KQ] "?!$ZÞœQ÷ëJ¶éÁÿý´N<x86_64-unknown-linux-gnuÁî·D,dñÍ2Ò,¿8Ê atomic_wakerÁ-169f766165a8585dÁØ4u‚á˜x ~RÀ³ßV&°<< $]<&]&&:&LL>>>W::>(6&"66&""W(>  &L :W>º 0 ñ rust-end-file