platform-admin/boc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
bd28b6033870793e3d5bf75b1e9832952257df57
boc/rust-service/target/debug/deps/libcrossbeam_utils-66e145216f0a822f.rmeta
T

781 lines
289 KiB
Plaintext
Raw Normal View History

BOC v1.0: RS256 auth, Ledger integration, Prometheus metrics, CI/CD, backup
2026-07-28 23:08:32 +00:00
rust
c€#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁÀ뉊]!ÜÛê(¹Þ—šên-5be7b69c3ff7b5b8Á¤²XctÔ'ÐÓ©z¨ɽÓ-a4945860e1c53b00Á¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁ–�òÖÀH•‘PIÓHã#£-055f30b747f859b6Árustc_std_workspace_coreÁ­Cçß^ò½èÝ$­Çÿ+Cé-c4878ee60b2242c9ÁŸÃï+Ñ]ŠqB<ÏïW#-8dd1dd90e70d0b6aÁ miniz_oxideÁ€š»J(P>àö÷g\K-1eb618da2918ab7fÁadler2ÁÆ;+Þ®5¥ÌýÝ°¦ÛLˆ-f7919172d268e069Á hashbrownÁPäV9ÒÆèÜ�"ÊÖVŽ\-0fc2184a5da6723aÁrustc_std_workspace_allocÁs&ØòØy¯s•bæ!‰ýŠ-97e4bf30be240674Á
std_detectÁhŠBîÙºÌI®Ë�Å�š-9dbbf8346ba7ac8bÁrustc_demangleÁûë9´Ç×@Œ�’ùXFº-f33013f239bf9f14Ácfg_ifÁÜLh�ž§Œaã¯>­�-0a71c8f33a838301Á addr2lineÁ׎Þ!]8V$É@@T·-e618e6be60e87ba2ÁgimliÁ¸
°µ~Î1‹Ñt ðÁ€w-1f7768a68858f670ÁobjectÁ
áPÃ?­À¶¼QHJ¥�-914cd6a4dbe590d1ÁmemchrÁ›º«8Ór­2Ù $¨ûib‚-cf21ca6f2bb15dcdÁë
‹ás«LÖ€îâƒ×ɯŒ-ee6f3747e38367f0Á primitiveÁL¥
crossbeam_loomÁt÷ testsÁ,³‚$¨š impl_consumeÁd•ìÂœ•ì€¼ªü”.µ $ÐÖtÖcrossbeam_sanitize_threadÁÌæüÏ1üË6ü‹yü‡~¸â<é�â<Û�íÀÅhintÁçatomicÁ 
  
Õ seq_lockÁSeqLockÁ&º(æ (optimistic_readÁ(
validate_readÁ(writeÁSeqLockWriteGuardÁ-lockÁ-º0”2ã atomic_cellÁ4444444444 4
4 4 4
444
AtomicCellÁE¥E»4H¥4J¥4L¥4N¥4P¥Pæ P
into_innerÁStransmute_copy_by_valÁTSrcÁTDstÁT ConstHackÁWÖ
Wà
WsrcÁWdstÁP is_lock_freeÁPÈPswapÁPas_ptrÁ4`¥`takeÁ4c¥c¬4f¥fcompare_and_swapÁf f¾j—4l¥lã4Õ 4impl_arithmeticÁ4 q fetch_andÁq
fetch_nandÁqfetch_orÁq fetch_xorÁ4
v¥v>4 y¥y÷4 |¥|×4
can_transmuteÁ’“4Ò ‚LENÁ‚�‚LOCKSÁ… … 4
AtomicUnitÁˆ
4
Š¬ŠÈŠŠ¡4atomic_is_lock_freeÁ�¥4€‘¥4†“¥4 atomic_swapÁ•¥4atomic_compare_exchange_weakÁ—¥consumeÁšš
AtomicConsumeÁœValÁœ load_consumeÁšˆš impl_atomicÁš¡¥¡” cache_paddedÁ¥¥¥¥¥ª¥¥¬¥¥®¥®æ ®©
¥²¥²å²´¥¥¥¹¥¹×¥¼¥¼÷¥¿¥¿×backoffÁÃÃÃÃ
SPIN_LIMITÁà YIELD_LIMITÁÃBackoffÁÉstepÁÃËæ ËresetÁËspinÁËsnoozeÁË is_completedÁÃÑ×ÃÓ>çÖ once_lockÁ××××OnceLockÁÛ¥ÛonceÁÛ»×ߥ×á¥×ã¥ãæ ã get_or_initÁæ—ã
initializeÁè—è ã
get_uncheckedÁ×ì¥ìãÖparkerÁïïïïïïïïïï ï
ï ïParkerÁüunparkerÁü_markerÁïï€>ï‚æ ‚parkÁ‚ park_timeoutÁ‚
park_deadlineÁ‚º‚into_rawÁ‚from_rawÁïŠ×ïUnparkerÁŒinnerÁïïï�unparkÁ�´�Äï”×ï–ƒïEMPTYÁïPARKEDÁïNOTIFIEDÁïInnerÁ›º›Ò ›cvarÁï Ÿ÷Ÿ�Ö sharded_lockÁ¢¢¢¢¢¢¢¢¢¢ ¢
¢ ¢ ¢
¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢
NUM_SHARDSÁ¢ShardÁÀÒ À write_guardÁ¢ ShardedLockÁÃ¥ÃshardsÁû¢Ç¥¢É¥¢Ë¥¢Í¥¢Ï¥Ïæ Ñ Ï©
¢Ô¥Ô is_poisonedÁÔget_mutÁÔtry_readÁÔreadÁÔ try_writeÁÔ® ¢Ü¥Ü×ÞLockedPlaceholderÁß
Þá×¢ã¥ã>¢æ¥æ÷¢ 饢
ë¥ëåë´¢ ï¥ï×¢ ò¥ò×¢
õ¥¢÷¥÷ã¢ú¥ú×¢ý¥ý×¢€¥€å€´¢„¥„¢
current_indexÁ‡ ¢
ThreadIndicesÁ‰mappingÁ‰ free_listÁ‰
next_indexÁ¢thread_indicesÁ�THREAD_INDICESÁ�initÁ¢ RegistrationÁ�Ö� thread_idÁ¢“ãÖ
wait_groupÁ•••••••••• WaitGroupÁŸñ•ð¡�¡Ò ¡ü•¥>•§æ §waitÁ•ªã•¬ƒ•®×ÖÖÖÖÖÖÖÖŠ¸¸¸¸¸¸¸¸¸¸ ¸
¸ ¸ ¸ SharedVecÁÆ¥¸ SharedOptionÁÈ¥¸scopeÁÊ'envÁÊ—Ê£Ê AbortOnPanicÁÎ
ÊÐãÊ Ê Ê ¸ScopeÁÕ÷&ÕhandlesÁÕ�$Õʸ¸Û÷&ÛspawnÁÝ'scopeÁÝ—Ý¥ÛbuilderÁá›(¸ã׸å›(å÷&åÐ å
stack_sizeÁåŽ(ê—ê¥ê ¸î¥¸ð¥¸ScopedJoinHandleÁò›(ò¥òhandleÁò� òŠòʸù¥ùjoinÁû ùŠ¸úþþþþþƒ¥ƒ as_pthread_tÁƒinto_pthread_tÁ¸‡¥‡×4Š fetch_addÁŠ fetch_subÁŠàŠðŠ�Š�Š fetch_maxÁŠ fetch_minÁ4“£+“´+“à“ð“�“�“å+“ö+4œ£+œ´+œàœðœ�œ�œå+œö+4¥£+¥´+¥à¥ð¥�¥�¥å+¥ö+4®£+®´+®à®ð®�®�®å+®ö+4·£+·´+·à·ð·�·�·å+·ö+4À£+À´+ÀàÀðÀ�À�Àå+Àö+4É£+É´+ÉàÉðÉ�É�Éå+Éö+4Ò£+Ò´+ÒàÒðÒ�Ò�Òå+Òö+4Û£+Û´+ÛàÛðÛ�Û�Ûå+Ûö+4ä£+ä´+äàäðä�ä�äå+äö+4í£+í´+íàíðí�í�íå+íö+šö”öŸøšú”úŸüšþ”þŸ€š‚”‚Ÿ„š†”†ŸˆšŠ”ŠŸŒšŽ”ŽŸ�š’”’Ÿ”š –”–Ÿ˜š
š”šŸœš ž”žŸ ¡Ÿ¢¥ CachePaddedÁ¤¥¤»¥§¥§ƒ¥ ª¥¥
¬¥¬>¥ ¯¥¯§±ù¥ ³¥¥
µ¥µ�¥¸¥¸Ö¢ShardedLockReadGuardÁ»'aÁ»¥»Ò »_guardÁ»Ê¢ShardedLockWriteGuardÁÁç5Á¥ÁÒ ÁÊ¢ REGISTRATIONÁÆ__rust_std_internal_init_fnÁÆ È É__RUST_STD_INTERNAL_VALÁÈ Ë•7¸ScopedThreadBuilderÁÍ›(Í÷&Íê&͹(¸Ò›(Ò÷&Ò×*
+
3
]
^
_
b
e
h
i
j
n
r
s
t
u
~
~
~
‹
Œ
�
Ž
ž
µ
¸
»
»
»
Á
Á
Á
Í
Î
Ï
Ð
Ò
Ò
Ò
æ
è
ë
î
„
…
†
‡
‹
‹
‹
‘
•
•
•
—
 
¡
Ö
×
Ø
Ù
Ú
Û
Þ
Þ
Þ
â
â
â
é
ë
î
ï
ñ
ñ
ñ
ò
ô
ô
ô
õ
÷
ù
ú
ü
ü
ü
ý
ÿ
ÿ
ÿ
€
ƒ
„
†
”
«
­
¯
¯
¯
Ê
Ñ
Ú
Ý
ã
ä
ä
ä
ê
î
ð
ù
ý
ƒ
…
‡
‰
‰
‰
‹
Œ
�
Ž
�
�
‘
’
”
•
–
—
˜
™
š
›
�
ž
Ÿ
 
¡
¢
£
¤
¦
§
¨
©
ª
«
¬
­
¯
°
±
²
³
´
µ

¸
¹
º
»
¼
½
¾
¿
Á
Â
Ã
Ä
Å
Æ
Ç
È
Ê
Ë
Ì
Í
Î
Ï
Ð
Ñ
Ó
Ô
Õ
Ö
×
Ø
Ù
Ú
Ü
Ý
Þ
ß
à
á
â
ã
å
æ
ç
è
é
ê
ë
ì
î
ï
ð
ñ
ò
ó
ô
õ
ø
ü
€
„
ˆ
Œ
�
”
˜
œ
 
¢
©
±
±
·
·
º
Õ
Õ
Õ
œŒ"--º .Ò /ºÕvÕz‹Ô_ÌìEEÌ G»4ãÄÔ–»=Rj¥� åB«½åB¬½åBŒ"åB³åBéåB�C¿cåBœ¤]¤]V¦]Á‚]üß3ø¤”&œ¤]¤]V¦]Á‚]üß3ø¤”&œ¤]¤]V¦]Á‚]üß3ø¤”&œ¤]¤]V¦]Á‚]üß3ø¤”&œ¤]¤]V¦]Á‚]üß3ø¤”&œ¤]¤]V¦]Á‚]üß3ø¤”&œ¤]¤]V¦]Á‚]üß3ø¤”&œ¤]¤]V¦]Á‚]üß3ø¤”&œ¤]¤]V¦]Á‚]üß3ø¤”&œ¤]¤]V¦]Á‚]üß3ø¤”&œ¤]¤]V¦]Á‚]üß3ø¤”&œ¤]¤]V¦]Á‚]üß3ø¤”& �Cؤ¤ž4¦»¥¡¼»×ͬä�CŠ üH³üHšeüHÐìüHµßüHüH™üHÌìüH� üHé!üHö!üH¿cüHéüH�CÄcüH¿cÉÉüÊ‹ÃuV(4;G³ÀJ� Ûۣݻ×Þ»×$"zM'ø�CÌìÿJŒ"ÿJÌìüü¬ýºïþÊï¾
ðá¿Š<¿³ÙK¿cÙKÌ쌌á�ñïv˜¼weŠw� ¯L¿c¯LدLÌìÃÈţ¢Æ»¢¬3Jd½U+b�C� ƒM«½ƒM¬½ƒM¿cƒM¿cßßàˆ  Æ…Hã „¡³ƒMéƒM�C� »»Ë5¾Ò ¢¿�6¢ÀÊ¢BFVÚcž^8¥é!µN¿cµNÄcµN� ÁÁ—6ÄÒ ¢ÅÊ¢[²Åw·Ž8€OŒ"«O¿c«OÄc«Oé!«Oö!«OŒ"��Ç#‘Ö¢’ã#¢²i4R­¢³ŸŸÀ$ ñ•Æ�Ôgf¾Œ"çPØçP¿cçPŒ"ÎÎÏ“' WËÆG©!�w� ÕÕÈ'×Ý'¸Ø�$¸Ùʸî)àZym¬8¿cçQ¿cÍÍÁ7Ðê&¸Ñ¹(¸ÿ;x]^²›(÷&ÌìòòÃ)õë)¸ö� ¸÷Š¸øʸå Q¥ãL8€O� ‘SŠ*‘S¿c‘S2-lEìÛ÷Á“�ªŸÐÎHEª¤áÛÿüŽŒÇÃîòJE¬¤ßÛ�ŒÉÃé»õÁÚÕðòLEËÃNEÍÃvE¬¤ÓÉ€üãÃ¥ŸyE¼¤æÃ|E¹¤ÑÉŠü”ŒÜÃáßï»úÁ®ŸãÕÒ͇òö¤]ú¤]þ¤]‚¤]†¤]Š¤]Ž¤]’¤]–¤]š¤]ž¤]¡¤]§¤–Œ¬Ÿª¤¯¤³¤µ¤¸¤²¤ë»€Á¤„Á¿¤ò»ýÁƒòŒ"�Ìì-� /«½=¬½ ³ é(¿c
œ YØTŠ šeÐìµß™é!ö!ÄcŠ*œË
„Ë
ŒÄ ÜÊD>ü±8 & èï)ü…j&&ä
'º„7½4ϱš$¢�D¯Eüž&¬®¿
"„®
ñ�C3D ÂY
`|ž
õ0ÑÛÑÛ MaybeUninitÁÓÛuninitÁÝÔÛ»ÝÍõƒ«%9�C¿Ñ ÃüþQ E�C ÎÕüÊ‹RåBlæ�CÛî0î0
UnsafeCellÁð0»Ì-·}—KEüC£¸[p¸[o�Co¹\‹$„&Üî%
 ”%
TåB�C6, ˆ&‘&ü„�S�C ¥åB$œåB…A
ø¹7   (üÁ.¬Á
œÁ
ÀÖ
 /¬Ú
œÚ
Àà
 /o€ îð ï üØ!oüØ!Z´‰" ›"
 
-
4Œ‰"
¼å_
E  VϢdk
sy
àW@ 
 ˜ ž"
° Wå_˜` ±" ÜÃÛÃÛ ManuallyDropÁÅÛ»¬„µÜÀ,�%*˜`ü®!¨
 Ä®!
½˜`L . Õ" ß"à"üÍ“ 0 T1 ˜`Šå_ýæ`°‰ÊDˆÊD]ÎàbêWWê
Zˆ4[’4 YB¹D‡Rxå_˜` ÃÛÃÛìaÅÛ»¬„µÜÀ,�%*å_På_PˆÁÔ€0
 Ā0
��C% 0\üÒ/N$ñ/„™:T™:ú\!
(¤:
û0¸[8,¤: ¨:ä™:
 $ª:
¸[�C{\ª: ´:»:_üê9QðH4ˆ: åB,þ9 ¸[Ç ú\ÉBü­‡,œ®‡
Œ®‡
À’0œÅ‡
ŒÅ‡
À“0r ؇ ü܇.¤Ý‡
”݇
ʈi-¤õ‡
”õ‡
ʼi-l ‰ˆ ü­‡] "(Œˆü¤†è$ƆcÊDaÊD5êÊDçÊD½DCÊD67ÁtÙ”
dÙ”
)(üÈ” 
 „È”
°þYQ- ç”ü¨”A„¤¤ž4¦»¥¡¼»×ͬäþY¤±”þY¾]_ÁCÊDLENÁCÊDLENÁø˜Î^ið˜Ñ^
à˜Ñ^
�Cˆˆ‰¨ —ñ˜2zÁÅ¿TZ˜‚_$ê› ˜¶_
¨˜·_ æ`4:ø™Î^ið™Ñ^
à™Ñ^
�C‹E17™‚_ ¯·™¶_ 
T™·_ æ`4:øšÎ^i
ðšÑ^ 
àšÑ^
�CùE 17  š‚_
[dš¶_

 
š·_
 æ`4 :
ø›Î^ið›Ñ^
à›Ñ^
�CçF
17 ›‚_ ›¶_
°›·_ æ`4:øœÎ^iðœÑ^
àœÑ^
�CÕG
17œ‚_·Àœ¶_
^ œ·_ æ`4:,ð› �—×eù›�ü©›Pø˜þ^9ø™þ^9øšþ^9ø›þ^9øœþ^9$Λæ`Oæ`ø˜ð^G Ãn½æ`fbø™ð^G ‹E3æ`ßÛøšð^G ùE¬æ`VRø›ð^G çF#æ`ÍÉøœð^G ÕGš_aÁ^Ýv» Ýv
ÝvyÝv×M ·4ì�4 ¤�C ¹4À4°üê3VüHt„4�C û3�Cg¿4”G6Á
”G10Á\³
L³
þ8'üÓ&¬ã
ϋ
ò�C+8
?|Ó²[IZ øüšj Û�C ƒŠåüîœÿJ$‹ï8ï8OnceÁð8ñé8ãTPàVçaú\ó¸[ñ]ÊD0ÁÊD1ÁÊD2ÁÊD8Áùê·™e
éê·e
¾¦PùêÕúeÈÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¦P ¦P’}²âùé�f�aÆ®®£°ñ¨it§ÅLS¶¦Páé¢faZÈ’}’}_Áùêðe
éêðe
ЦP17ùꦮe
 ÉïE—}ª~æ`0’} ê¿eùêíÔeùê‚!­e
 ËïE¡€æ`%’} ê›!eQ êÀ$eùêÛôeÈ’} ÉïE¡€æ`îËïE¡€æ`¦V_Á¥ÃÖ¸íÀë ž4\‘¤Âü<ÄÉÕü¸ü30 Miscellaneous tools for concurrent programming.Á4út8 ## AtomicsÁGúüK<9 * [`AtomicCell`], a thread-safe mutable memory location.ÁüˆYV * [`AtomicConsume`], for reading from primitive atomic types with "consume" ordering.Áâúìæ ## Thread synchronizationÁ„úüˆ-* * [`Parker`], a thread parking primitive.Áü¶OL * [`ShardedLock`], a sharded reader-writer lock with fast concurrent reads.Áü†PM * [`WaitGroup`], for synchronizing the beginning or end of some computation.Á×ú„Û
## UtilitiesÁìúüð96 * [`Backoff`], for exponential backoff in spin loops.ÁüªVS * [`CachePadded`], for padding and aligning a value to the length of a cache line.Áü�QN * [`scope`], for spawning threads that borrow local variables from the stack.ÁÓúü×&# [`AtomicCell`]: atomic::AtomicCellÁüþ,) [`AtomicConsume`]: atomic::AtomicConsumeÁä« [`Parker`]: sync::ParkerÁüÈ&# [`ShardedLock`]: sync::ShardedLockÁüï" [`WaitGroup`]: sync::WaitGroupÁä’ [`scope`]: thread::scopeÁüï ü™6|Ì¥ÃÖ¸íüÀýž4ü¤ÂüûÉÕ=@C„Þ :lÓÖt¨„§ÜžLלç$ö spin_loopÁL  “ ¬”œµ$ÄK²†JCondvarÁ<·‡>¤,Àµ>¬Ó4â¦t› ›_
®D«¼À
AtomicBoolÁT¤¬]
AtomicI16ÁL°£ÁAtomicI8ÁD»ÕÀ AtomicIsizeÁ\ÅÝà AtomicU16ÁLÒÊÁAtomicU8ÁDÝüÀ AtomicUsizeÁ\ç„Ä AtomicI32ÁL´ñÁ AtomicU32ÁL¿˜Â AtomicI64ÁLÍ¿Â AtomicU64ÁLØ攆il\_”þHK25ìîÔÖ¹»”Ÿ¤¦‹�”¸vx]_L¦ñôäçtÑŒ Atomic types.Áúü<æ‚üSY¬ƒ4Ù4šÌ Tá E™ÿlŒ
œ¤d½óµ Ì´ü®!ÖtÚ„ÙÜÐDÁ&-í
ë Õ $(‚]"øŽ\.„Ä#®D;¼À$ü<RÉ%ÕLa”T4FH79tK+Ìw<‰þY„7½4ϱš'”Û,Û&&�DdòþY)*+,ü…!™þY((¨lüû5|‰Ö ÖþYÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÊD( ™(
*$šüæ8lô× ×þYÊD( ‚ (
+$ƒ stampÁ,‰ ü¼
7,Ê
 þY©B((
,$Ù
üÓ#Œå©BÕvÕz‹Ô_./3´–$–--¶—dÕ,Õ--ÊD´æ©B1ÌË,Ù©Bæ`00
1$ßü³©B3�"3”ç$êØ Ø©Bæ`2 ï2
3$ô|ýóµ ÌÒüÌ!Ötë„êÜá\� E‚ˆ‰�‘“•—Õ $€46®D†¼À47 ž4\œ¤48„\T¹î049‹Ï‹4:×Þ `4;í$óë4=ìadùÃÛ4>ÄZ\‡ÑÛ4?
RefUnwindSafeÁl§¬½4A
UnwindSafeÁT¶«½4Bµ Í“4Cä
<è&4Dô_4w ”•ÿ´­îLÉáLØÔLçÇíº¼ª¬\™‘“wyLÇkÄ×^ĸüò*' A thread-safe mutable memory location.Á�úü¡]Z This type is equivalent to [`Cell`], except it can also be shared among multiple threads.Áÿúüƒ`] Operations on `AtomicCell`s use atomic instructions whenever possible, and synchronize usingÁüä]Z global locks otherwise. You can call [`AtomicCell::<T>::is_lock_free()`] to check whetherÁüÂ.+ atomic instructions or locks will be used.Áñúüõ]Z Atomic loads use the [`Acquire`] ordering and atomic stores use the [`Release`] ordering.ÁÓúì× [`Cell`]: std::cell::CellÁüõA> [`AtomicCell::<T>::is_lock_free()`]: AtomicCell::is_lock_freeÁü·52 [`Acquire`]: std::sync::atomic::Ordering::AcquireÁüí52 [`Release`]: std::sync::atomic::Ordering::ReleaseÁTÃ¥FFÍì�C ÎåBãÄÔ–»=RjGn üƒ!,ƒ4EEú\ü©+¥IIê£ µÌì�C$¸åBüØ+¥KKê£ äÞ¤$çåBüˆ$¥MMê£ �åB ü°'¥OOê£ µåB ¬Ü¥QQê£ áåBRS\]^_üÊ)üø52 Creates a new atomic cell initialized with `val`.Á²útº # ExamplesÁÍú<Õ ```Áüá,) use crossbeam_utils::atomic::AtomicCell;Á’úüš let a = AtomicCell::new(7);Á<¾ݦ×�CåBPP
R�C¹"&ü„"üÛ85 Consumes the atomic and returns the contained value.Á˜úü UR This is safe because passing `self` by value guarantees that no other threads areÁüú+( concurrently accessing the atomic data.Áªút²º¦Åú<ÍݦüÙ,úü’°§ܶ let v = a.into_inner();ÁÖú¬Þ assert_eq!(v, 7);Á<øݦT‘åB�CPP
S�C 'üÍ@.\¹¬Ý4å_˜`Ö
Uà
VVUÍìå_óÍì˜`ø
Tå_˜`ˆÁ$')$&̳L¹4Ö
Xà
YXYÅ­ÃÕ­Èçd YB¹D‡RxZ[%'*,´ßß4WW¦e´‡‡4WWàbüÒ/#ü—&FC Returns `true` if operations on values of this type are lock-free.Áâ&úüê&VS If the compiler or the platform doesn't support the necessary atomic instructions,ÁüÅ'\Y `AtomicCell<T>` will use global locks for every potentially concurrent atomic operation.Á¦(út®(º¦Á(ú<É(ݦüÕ(,)úüŽ)UR // This type is internally represented as `AtomicUsize` so we can just use atomicÁüè)! // operations provided by it.ÁüŽ*:7 assert_eq!(AtomicCell::<usize>::is_lock_free(), true);ÁÍ*úüÕ*'$ // A wrapper struct around `isize`.Á„�+
struct Foo {Áœ–+ bar: isize,Á,®+ }Áü¸+IF // `AtomicCell<Foo>` will be internally represented as `AtomicIsize`.Áü†,85 assert_eq!(AtomicCell::<Foo>::is_lock_free(), true);ÁÃ,úüË,;8 // Operations on zero-sized types are always lock-free.Áü‹-74 assert_eq!(AtomicCell::<()>::is_lock_free(), true);ÁÇ-úüÏ-\Y // Very large types cannot be represented as any of the standard atomic types, so atomicÁü°.LI // operations on them will have to use global locks for synchronization.Áü�/@= assert_eq!(AtomicCell::<[u8; 1000]>::is_lock_free(), false);Á<Æ/ݦdß/PP
\�CÜÇ2ü¦0&# Stores `val` into the atomic cell.ÁÑ0útÙ0º¦ì0ú<ô0ݦü€1,1úü¹1°§Ý1úäå1 assert_eq!(a.load(), 7);Á|†2 a.store(8);Áäš2 assert_eq!(a.load(), 8);Á<»2ݦ,Î2Ù ÙåB�Cæ`P Ô2P
8²š8¬ ¶š ¸š8"4ºš Áš ïš Ú
Äš Åš íš 8$Æš Êš8Á4Ëš Ñš Òš8Ôš
ך8,Øš8Õ 4Þš'äš, æš8Õ 4çš% ðš8¬ Š› ‹›8£+LŒ› •› «›8¹–›$ ™›8®D››'£›8F4¥›$ › Ø› ÿ�8ò›8�64ö› ý›8Ò $ÿ› ƒœ šœ8$„œ ˆœ8Á4‰œ �œ �œ8’œ8¬,•œ ›œ8® ,œœ ¡œ ¢œ% £œ8½œ8»,Áœ Çœ8"4Éœ Ðœ èœ Òœ8Óœ
ל Øœ æœ8$Ùœ Ýœ8Á4Þœ äœ åœ% éœ8ƒ�8­ò‡� ‹�
��8»,Ž�% “�
­�8»,®� ´�8»,¶� »�8æd¼� È� Ì�8¹É�% Í�8­òç�<¾óü®žI<ú„Ÿ<�ôü”Ÿ&<úÇŸ<º¦tן<úòŸ<ݦ<‚ <î¦ü– ,<úÏ + ß  à  ï 8Óá  å , ç 8Ýê<è <úý <Þõü�¡"<Šö伡<ݦ<å¡+ ù¡ ú¡ �¢8Ý4û¡8�¢8 “¢8´+L–¢ Ÿ¢ ®¢  ¢8$¡¢$ ¥¢8¹§¢& ª¢, ¬¢8¿ ­¢(°¢, ³¢8¿ ´¢ ¶¢ ‰§8Õ 4È¢ ΢ Т û¦, æ¢8¿ ç¢$ è¢8Ývê¢$ ì¢ ‚£ «¤
8œ£8¬  £ ¢£8"4¤£ «£ Ù£ ­£
®£ ¯£ ×£ 8$°£ ´£8Á4µ£ »£ ¼£8¾£
Á£8,£8Õ 4È£'Σ, У8Õ 4Ñ£% Ú£8¬ ô£ õ£8´+Lö£ ÿ£ •¤8¹€¤$ ƒ¤8®D…¤'�¤8F4�¤$ ¬¤ ¤ é¦8ܤ8�64ठç¤8Ò $é¤ í¤ „¥8$î¤ ò¤8Á4ó¤ ù¤ ú¤8ü¤8¬,ÿ¤ …¥8® ,†¥ ‹¥ Œ¥% �¥8§¥8»,«¥ ±¥8"4³¥ º¥ Ò¥ ¼¥8½¥
Á¥ Â¥ Ð¥8$Ã¥ Ç¥8Á4È¥ Î¥ Ï¥% Ó¥8í¥8­òñ¥ õ¥
÷¥8»,ø¥% ý¥
—¦8»,˜¦ ž¦8», ¦ ¥¦8ëd¦¦ ²¦ ¶¦8¹³¦% ·¦8­òѦ< ûü˜§N<úó§<º¦tƒ¨<úž¨<ݦ<®¨<î¦ü¨,<úû¨+ ‹© Œ© ›©8Ó�© ‘©, “©8Ýê<”©<ú©©<‰ýü¹©"<µýäè©<ݦ<‘ª+ ¥ª ¦ª ­ª8Ý4§ª8»ª8 ¿ª8àLª ˪ Úª ̪8$ͪ$ Ѫ8¹Óª& Öª, ت8¿ Ùª(ܪ, ߪ8¿ ઠ⪠¢¯8Õ 4ôª úª üª ”¯, ’«8¿ “«$ ”«8Ýv–«$ ˜« ®« ׬
8È«8¬ Ì« Ϋ8"4Ы ׫ …¬ Ù«
Ú« Û« ƒ¬ 8$Ü« à«8Á4á« ç« è«8ê«
í«8,î«8Õ 4ô«'ú«, ü«8Õ 4ý«% †¬8¬  ¬ ¡¬8àL¢¬ «¬ Á¬8¹¬¬$ ¯¬8®D±¬'¹¬8F4»¬$ ج î¬ ‚¯8ˆ­8�64Œ­ “­8Ò $•­ ™­ °­8$š­ ž­8Á4Ÿ­ ¥­ ¦­8¨­8¬,«­ ±­8® ,²­ ·­ ¸­% ¹­8Ó­8»,×­ Ý­8"4ß­ æ­ þ­ è­8é­
í­ î­ ü­8$ï­ ó­8Á4ô­ ú­ û­% ÿ­8™®8­ò�® ¡®
£®8»,¤®% ©®
î8»,Įʮ8¹Í®% Ю8­òê®<¡‚ü±¯O<ú�°<º¦t�°<ú¸°<ݦ<È°<î¦üÜ°,<ú•±+ ¥± ¦± µ±8Ó§± «±, ­±8Ýê<®±<úñ<‹„üÓ±#<¸„üƒ²#<ݦ<³²+ Dz Ȳ ϲ8Ý4ɲ8ݲ8 á²8ðTä² î² ý² ï²8$ð²$ ô²8¹ö²& ù², û²8¿ ü²(ÿ², ‚³8¿ ƒ³ …³ η8Õ 4—³ �³ Ÿ³ À·, µ³8¿ ¶³$ ·³8Ýv¹³$ »³ ѳ û´
8ë³8¬ ï³ ñ³8"4ó³ ú³ ¨´ ü³
ý³ þ³ ¦´ 8$ÿ³ ƒ´8Á4„´ Š´ ‹´8�´
�´8,‘´8Õ 4—´'�´, Ÿ´8Õ 4 ´% ©´8¬ ô Ä´8ðTÅ´ Ï´ å´8¹д$ Ó´8®DÕ´'Ý´8F4ß´$ ü´ ’µ ®·8¬µ8�64°µ ·µ8Ò $¹µ ½µ Ôµ8$¾µ µ8Á4õ ɵ ʵ8̵8¬,ϵ Õµ8® ,Öµ Ûµ ܵ% ݵ8÷µ8»,ûµ �8"4ƒ¶ Š¶ ¢¶ Œ¶8�
‘¶ ’¶  ¶8$“¶ —¶8Á4˜¶ ž¶ Ÿ¶% £¶8½¶8­òÁ¶ Ŷ
Ƕ8»,ȶ% Ͷ
ç¶8»,è¶ î¶ ð¶ ñ¶ û¶8­òò¶ ö¶8¹ø¶% ü¶8­ò–·<Ó‰üÝ·M<ú·¸<º¦tǸ<úâ¸<ݦ<ò¸<î¦ü†¹,<ú¿¹+ Ϲ й ß¹8Óѹ Õ¹, ×¹8Ýê<ع<úí¹<Ëüý¹"<ð‹쬺<ݦ<Öº+ êº ëº òº8Ý4ìº8€»8 „»8�D‡» �» ž» �»8$‘»$ •»8¹—»& š», œ»8¿ �»( », £»8¿ ¤» ¦» å¿8Õ 4¸» ¾» À» ׿, Ö»8¿ ×»$ Ø»8ÝvÚ»$ Ü» ò» š½
8Œ¼8¬ �¼ ’¼8"4”¼ ›¼ ɼ �¼
ž¼ Ÿ¼ Ǽ 8$ ¼ ¤¼8Á4¥¼ «¼ ¬¼8®¼
±¼8,²¼8Õ 4¸¼'¾¼, À¼8Õ 4Á¼% ʼ8¬ ä¼ å¼8�Dæ¼ î¼ „½8¹ï¼$ ò¼8®Dô¼'ü¼8F4þ¼$ ›½ ±½ Å¿8˽8�64Ͻ Ö½8Ò $ؽ ܽ ó½8$ݽ á½8Á4â½ è½ é½8ë½8¬,î½ ô½8® ,õ½ ú½ û½% ü½8–¾8»,š¾  ¾8"4¢¾ ©¾ Á¾ «¾8¬¾
°¾ ±¾ ¿¾8$²¾ ¶¾8Á4·¾ ½¾ ¾¾% ¾8ܾ8­òྠä¾
æ¾8»,ç¾% ì¾
†¿8»,‡¿�¿8¹�¿% “¿8­ò­¿<£‘üô¿N<úÏÀ<º¦tßÀ<úúÀ<ݦ<ŠÁ<î¦üžÁ,<ú×Á+ çÁ èÁ ÷Á8ÓéÁ íÁ, ïÁ8Ýê<ðÁ<ú…Â<›“ü•Â"<È“äÄÂ<ݦ<íÂ+ �à ‚à ‰Ã8Ý4ƒÃ8—Ã8 ›Ã8�LžÃ §Ã ¶Ã ¨Ã8$©Ã$ ­Ã8¹¯Ã& ²Ã, ´Ã8¿ µÃ(¸Ã, »Ã8¿ ¼Ã ¾Ã þÇ8Õ 4Ðà Öà Øà ðÇ, îÃ8¿ ïÃ$ ðÃ8ÝvòÃ$ ôà ŠÄ ³Å
8¤Ä8¬ ¨Ä ªÄ8"4¬Ä ³Ä áÄ µÄ
¶Ä ·Ä ßÄ 8$¸Ä ¼Ä8Á4½Ä ÃÄ ÄÄ8ÆÄ
ÉÄ8,ÊÄ8Õ 4ÐÄ'ÖÄ, ØÄ8Õ 4ÙÄ% âÄ8¬ üÄ ýÄ8�LþÄ ‡Å �Å8¹ˆÅ$ ‹Å8®D�Å'•Å8F4—Å$ ´Å ÊÅ ÞÇ8äÅ8�64èÅ ïÅ8Ò $ñÅ õÅ ŒÆ8$öÅ úÅ8Á4ûÅ �Æ ‚Æ8„Æ8¬,‡Æ �Æ8® ,ŽÆ “Æ ”Æ% •Æ8¯Æ8»,³Æ ¹Æ8"4»Æ ÂÆ ÚÆ ÄÆ8ÅÆ
ÉÆ ÊÆ ØÆ8$ËÆ ÏÆ8Á4ÐÆ ÖÆ ×Æ% ÛÆ8õÆ8­òùÆ ýÆ
ÿÆ8»,€Ç% …Ç
ŸÇ8», Ç¦Ç8¹©Ç% ¬Ç8­òÆÇ<ú˜ü�ÈA<Æ™üÛÈ#<ú‹É<º¦t›É<ú¶É<ݦ<ÆÉ<î¦üÚÉ,<ú“Ê+ £Ê ¤Ê ³Ê8Ó¥Ê ©Ê, «Ê8Ýê<¬Ê<úÁÊ< assert_eq!(a.fetch_max(9), 7);ÁüÑÊ"<ÃÙä€Ë<ݦ<©Ë+ ½Ë ¾Ë ÅË8Ý4¿Ë8ÓË8 ×Ë8å+LÚË ãË òË äË8$åË$ éË8¹ëË& îË, ðË8¿ ñË(ôË, ÷Ë8¿ øË úË ÈÐ8Õ 4ŒÌ ’Ì ”Ì ºÐ, ªÌ8¿ «Ì$ ¬Ì8Ýv®Ì$ °Ì ÆÌ ïÍ
8àÌ8¬ äÌ æÌ8"4èÌ ïÌ �Í ñÌ
òÌ óÌ ›Í 8$ôÌ øÌ8Á4ùÌ ÿÌ €Í8‚Í
…Í8,†Í8Õ 4ŒÍ'’Í, ”Í8Õ 4•Í% žÍ8¬ ¸Í ¹Í8å+LºÍ ÃÍ ÙÍ8¹ÄÍ$ ÇÍ8®DÉÍ'ÑÍ8F4ÓÍ$ ðÍ †Î ¨Ð8 Î8�64¤Î «Î8Ò $­Î ±Î ÈÎ8$²Î ¶Î8Á4·Î ½Î ¾Î8ÀÎ8¬,ÃÎ ÉÎ8® ,ÊÎ ÏÎ ÐÎ% ÑÎ8ëÎ8»,ïÎ õÎ8"4÷Î þÎ –Ï €Ï8�Ï
…Ï †Ï ”Ï8$‡Ï ‹Ï8Á4ŒÏ ’Ï “Ï% —Ï8±Ï8­òµÏ ¹Ï
»Ï8»,¼Ï% ÁÏ
ÛÏ8»,ÜÏ âÏ8‹äÏ'çÏ8Ë éÏ ìÏ õÏ8­òíÏ$ ðÏ8¹òÏ% öÏ8­ò�Ð<¡¡ü×ÐA<Æ™ü¥Ñ#<úÕÑ<º¦tåÑ<ú€Ò<ݦ<�Ò<î¦ü¤Ò,<úÝÒ+ íÒ îÒ ýÒ8ÓïÒ óÒ, õÒ8Ýê<öÒ<ú‹Ó<›£ü›Ó"<¨ÌäÊÓ<ݦ<óÓ+ ‡Ô ˆÔ �Ô8Ý4‰Ô8�Ô8 ¡Ô8ö+L¤Ô ­Ô ¼Ô ®Ô8$¯Ô$ ³Ô8¹µÔ& ¸Ô, ºÔ8¿ »Ô(¾Ô, ÁÔ8¿ ÂÔ ÄÔ ’Ù8Õ 4ÖÔ ÜÔ ÞÔ „Ù, ôÔ8¿ õÔ$ öÔ8ÝvøÔ$ úÔ �Õ ¹Ö
8ªÕ8¬ ®Õ °Õ8"4²Õ ¹Õ çÕ »Õ
¼Õ ½Õ åÕ 8$¾Õ ÂÕ8Á4ÃÕ ÉÕ ÊÕ8ÌÕ
ÏÕ8,ÐÕ8Õ 4ÖÕ'ÜÕ, ÞÕ8Õ 4ßÕ% èÕ8¬ ‚Ö ƒÖ8ö+L„Ö �Ö £Ö8¹ŽÖ$ ‘Ö8®D“Ö'›Ö8F4�Ö$ ºÖ ÐÖ òØ8êÖ8�64îÖ õÖ8Ò $÷Ö ûÖ ’×8$üÖ €×8Á4�× ‡× ˆ×8Š×8¬,�× “×8® ,”× ™× š×% ›×8µ×8»,¹× ¿×8"4Á× È× à× Ê×8Ë×
Ï× Ð× Þ×8$Ñ× Õ×8Á4Ö× Ü× Ý×% á×8û×8­òÿ× ƒØ
…Ø8»,†Ø% ‹Ø
¥Ø8»,¦Ø ¬Ø8‹®Ø'±Ø8Ó¨³Ø ¶Ø ¿Ø8­ò·Ø$ ºØ8¹¼Ø% ÀØ8­òÚØ% £Ù¬­ãEEÌ G»4ãÄÔ–»=Rjrstuüùæ*üÉãNK Applies logical "and" to the current value and returns the previous value.Áœäút¤äº¦·äú<¿äݦüËä,î¦üäúü„å" let a = AtomicCell::new(true);Á«åúü³å(% assert_eq!(a.fetch_and(true), true);Áüàå assert_eq!(a.load(), true);Á„æúüŒæ)& assert_eq!(a.fetch_and(false), true);Áüºæ  assert_eq!(a.load(), false);Á<ßæݦL€çâ âöÿq Šçq
r$‹ç¹‘çü‡ï+üøêOL Applies logical "nand" to the current value and returns the previous value.ÁÌëútÔ뺦çëú<ïëݦüûë,ìúü´ì"ç€Ûìúüãì*' assert_eq!(a.fetch_nand(false), true);Áü’íÔ�¶íúü¾í)& assert_eq!(a.fetch_nand(true), true);Áüìí ¿‚‘îúü™î+( assert_eq!(a.fetch_nand(false), false);ÁüÉîÔ�<íîݦTŽïã ãöÿq ™ïq
s$šï¹ ïüÀö)ü�óMJ Applies logical "or" to the current value and returns the previous value.Áâóútêóº¦ýóú<…ôݦü‘ô,î¦ÂôúüÊô# let a = AtomicCell::new(false);Áòôúüúô)& assert_eq!(a.fetch_or(false), false);Áü¨õ ¿‚ÍõúüÕõ(% assert_eq!(a.fetch_or(true), false);Áü‚öÔ�<¦öݦDÇöä äöÿq Ðöq
t$Ñö¹×öüíý*ü½úNK Applies logical "xor" to the current value and returns the previous value.Á�ûút˜ûº¦«ûú<³ûݦü¿û,î¦ðûúüøû"瀟üúü§ü)& assert_eq!(a.fetch_xor(false), true);ÁüÕüÔ�ùüúü�ý(% assert_eq!(a.fetch_xor(true), true);Áü®ý ¿‚<ÓýݦLôýå åöÿq þýq
u$ÿý¹…þüê�*¥wwê£ ï�ªÂ<ò�åBx´x웂<ž‚åBvv
x�Cüê‚!¥zzê£ ï‚åB{ë{ü ƒ $£ƒ�CåByy
{�C¹¨ƒüéƒ7¥}}ê£ îƒþÅ$ñƒ¿c�CTøƒåB~Àc~*,ü§„8ª„æçè æåB ç c cˆ¢cµ
 `£cbufÁ `àB¤GS
èÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
æ`ŸÈŸÈ ÈErrorÁ O˜éBL| ®„|
~�C$¯„± µ„ü¤†&l­†4’€“�€�Íìˆi »†Íì¼i ¾†
ˆi¼i"$ ü–Œ(.\ŠŒ$™Œ4ÊD¶—
‚addrÁ$žŒ„�”“”4ÊD쨔 ®”4�müî”),õ”4�m†Ç€C‡ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€C“•ÊDž•……ÊDŒ¹—TÀ—4Ãn—ñ˜2zÁÅ¿‰/*4ˆˆÃn|Í—Ãn‹Œ�Žüñ— $ô—4é éÃn¼À½À¾ÀË¿ÀÀÀÌÁÀÂÀGÃÀÄÀFÅÀÆÀ×`šÁ¬S øBæ`Š ù—Š
‹$ú—_orderÁ4€˜ü¨˜+,«˜4ê êÃnæ`ç¡æ`Š ±˜Š
Œ$²˜_valÁ$¸˜ü¡4˜üê˜*$í˜4ë ëÃnæ`ç¡æ`Š ò˜Š
�$ó˜è¢$ù˜ü¡4ƒ™ü«™ ¬®™4ì ìÃnæ`æ`ç¡ç¡Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
æ`æ`Š Í™Š
Ž$Ι_currentÁDÜ™_newÁ$ò™_successÁD„š_failureÁD šü©›)œ²›4¥��ê£ Æ›¢f  ü£�=\­�4ðH�C¥’’ê£ ¹�þÅ$Û�
‘�Cˆ¼�!ü�ª.d™ª4ðH�Cæ`¥””ê£ ¦ª
“�C’©ª¹¶ª!ü§®2\±®4ðH�C�C¥––ê£ ½®
•�C’À®¹Í®!ü°´v亴4ðH�C�C•Ó¥˜˜ê£ ×´þÅ$œµÏÈ£µ
—�C’Ú´ÞÍ<ë´æ ÷´;=¼Ô ÀH\î <ò œ®D9¼Àš›ä%¼˜üDSP Trait which allows reading from primitive atomic types with "consume" ordering.Ál¢œœÎìü˜¸œЬЬ �ž�žÍìج�L߉­žDßü¶$! Type returned by `load_consume`.Á䜜üª$üîDA Loads a value from the atomic using a "consume" memory ordering.Á·úü¿IF This is similar to the "acquire" ordering, except that an ordering isÁü�LI only guaranteed with operations that "depend on" the result of the load.ÁüÞGD However consume loads are usually much faster than acquire loads onÁüªJG architectures with a weak memory model since they don't require memoryÁ¼ù fence instructions.Á•úü�KH The exact definition of "depend on" is a bit vague, but it works as youÁüíJG would expect in practice since a lot of software, especially the LinuxÁü¼" kernel, rely on this behavior.ÁãúüëHE This
+ Ø
 Ù
 à
8Ý4Ú
8 ê
8Ÿdí
 ù
 ÿ
 ú
8$û
(�8$„'ˆ8”Š Ž Ñ8#œ8, '¥8ÅL§'°8ç$²'8Õ 4¸'¾8¦tÀ% Î8Ü8� 4à ç8$é í8¬$î ò „8®Dó'û8Ë<ý% …8¦t“ ¡ ³8®D¢'ª8G<¬% ´8� 4Â% ØÄ­\º Æ » Ì ã , Í8Õ 4Î& Ô8¼,Õ$ Ú, Ü8¹Ý& à8´á*å è ¸+ ò ó ‘8âô ÷ �8”
ø û �8×´œü8$›8ÿl 8
®8í$²'8ç$¸'¼8Õ 4¾'Ä, Æ8Õ 4Ç Î ’
8!$Ü8”á å, ç8¹è% ë8ˆdù … † ‡% ˆ+ œ � ±8âž ¡ °8Öt¢8$»8ÿlÀ8
Î8loomÁ$Ò'Ö8ç$Ø'Ü8Õ 4Þ'ä, æ8Õ 4ç î ²
8!$ü8”� …, ‡8¹ˆ% ‹8ˆd™ ¥ ¦ §% ¨% ¹üª:×´œ“¬’ü‰ ¥¢¢ê£ ¯ÃH£¢�ž¢Dëð¡¡ðH´ƒ
ÑH„âdæ¤×
 `¥¦r,é!¥¨DerefMutÁD&ö!¥©LCL57ü�1,¥««ê£ œ1Þ¤$Ÿ1üHüÀ1,¥­­ê£ Ì1� �C$Ï1üH´ñ1¥¯¯ê£ ö1üH°±
üê3(üŽ2:7 Pads and aligns a value to the length of a cache line.ÁÍ2útÕ2º¦è2ú<ð2ݦüü2%" use crossbeam_utils::CachePadded;Á¦3úü®3+( let padded_value = CachePadded::new(1);Á<Þ3ݦ÷3�CüH®®
°�C¿<äÑ6äÆ4 Returns the inner value.Áç4útï4º¦‚5ú<Š5ݦü–5%òÂÀ5úüÈ5+( let padded_value = CachePadded::new(7);Áüø5*' let value = padded_value.into_inner();Á̧6 assert_eq!(value, 7);Á<Å6ݦTØ6üH�C®®
±�C$ã6üŒ7 ¥³³ê£ ‘7üH´µê!ë!µ\³74¸7²²�C¬É7,Ì7î îüH î�C² Ò7²
µ�C$Ó7üþ7#¥··ê£ ƒ8üH¸÷!¸ü¨8!L«8ï ïüH ï�C µ8
¸�C$º8üí81¥ººê£ ò8»’Tõ8üH»Àc»ü¥98¨9ðñò ðüH ñ c cˆ¢cµ
 `£cÈ’ `àB¤GS
ò ¬9¹
»�C$­9± ³9üÎ:"¥½½ê£ Ó:üH¾ë¾¬÷:$ú:�CüH¼¼
¾�C¿ ÿ:ü´;5¥ÀÀê£ ¹;Äc�Cd¼;üHÁÅcÁ!#üð;8ó;óôõ óüH ô c cˆ¢cµ
 `£cÈ’ `àB¤GS
õï“¿ ÷;¿
Á�C$ø;± þ;üü Î@\Ÿ<£ÇÈÉ¿ $ÃÄa$,á.ÃÅ×< `ÃÆ´:„ -L6¬BTHÔG´]\cÔG”�ü{/, Performs exponential backoff in spin loops.Á«úü¯RO Backing off in spin loops reduces contention and improves overall performance.Á‚úü†c` This primitive can execute *YIELD* and *PAUSE* instructions, yield the current thread to the OSÁüêa^ scheduler, and tell when is a good time to block the thread using a different synchronizationÁüÌ^[ mechanism. Each step of the back off procedure takes roughly twice as long as the previousÁL« step.Áµút¹º¦ÈúüÌ$! Backing off in a lock-free loop:Áñú<õݦüý! use crossbeam_utils::Backoff;ÁüŸ'$ use std::sync::atomic::AtomicUsize;ÁüÇ,) use std::sync::atomic::Ordering::SeqCst;Áôúüø63 fn fetch_mul(a: &AtomicUsize, b: usize) -> usize {Áü¯%" let backoff = Backoff::new();ÁtÕ loop {Áüä%" let val = a.load(SeqCst);ÁüŠUR if a.compare_exchange(val, val.wrapping_mul(b), SeqCst, SeqCst).is_ok() {ÁÜà return val;Álü
}ÁÜŠ backoff.spin();ÁL¦ }Á,°ñ³<¶ݦ¾úüÂ30 Waiting for an [`AtomicBool`] to become `true`:Áöú<úݦü‚ !âÔü¤ &# use std::sync::atomic::AtomicBool;ÁüË ,¾Õø úüü &# fn spin_wait(ready: &AtomicBool) {Áü£
%ÀÖüÉ
# while !ready.load(SeqCst) {Áìí
 backoff.snooze();ÁL‹ ñØ,• ñ³<› ݦ£ úü§ \Y Waiting for an [`AtomicBool`] to become `true` and parking the thread after a long wait.Áü„ a^ Note that whoever sets the atomic variable to `true` must notify the parked thread by callingÁŒæ  [`unpark()`]:Áø ú<ü ݦü„
!âÔü¦
&ŽÚüÍ
,¾Õ¤ú
 use std::thread;Á�úü“*' fn blocking_wait(ready: &AtomicBool) {Áü¾%ÀÖüä#–Ûüˆ'$ if backoff.is_completed() {Áü° thread::park();Á¤Ð } else {Áüå! backoff.snooze();Ál‡·ØL•ñØ,Ÿñ³<¥ݦ­úü±+( [`is_completed`]: Backoff::is_completedÁüÝ.+ [`std::thread::park()`]: std::thread::parkÁüŒ# [`Condvar`]: std::sync::CondvarÁü°1. [`AtomicBool`]: std::sync::atomic::AtomicBoolÁüâ-* [`unpark()`]: std::thread::Thread::unparkÁ<›ÀJuV(4;GÊ|©$©ÃÉÉá.á.aã.»Ì-IÜž�B2®”Gd½ÀJÌÍÎÏФŽäÐ Creates a new `Backoff`.Áñútùº¦Œú<”ݦü !âÔÆúüÎ! let backoff = Backoff::new();Á<ôݦ•ÀJËË
Ìœ«Ì× Resets the `Backoff`.Áõútýº¦�ú<˜ݦü¤!âÔÊúüÒ!µå¤ø backoff.reset();Á<‘ݦ,²ö öÀJæ`Ë ¸Ë
Í$¹”Äüæ" Backs off in a lock-free loop.Á�úü•]Z This method should be used when we need to retry an operation because another thread madeÁl÷
progress.Á‰úü‘EB The processor may yield using the *YIELD* or *PAUSE* instruction.ÁÛút㺦öúüþ$›Ô§ú<¯ݦü»!âÔüá'�Õü�,¾Õ¾úüÆ6€Öü�%ÀÖt«îÖü¾%†×üèUµ×Ü“Ølâ·ØÜôÍØL”ñØ,¢ñ³¬úü´  let a = AtomicUsize::new(7);ÁüÙ$! assert_eq!(fetch_mul(&a, 8), 7);Áü‚# assert_eq!(a.load(SeqCst), 56);Á<ªݦ$Ë÷ ÷ÀJæ`Ë ÐË
Î$Ѥ¸.ü® ! Backs off in a blocking loop.ÁÔ úüÜ XU This method should be used when we need to wait for another thread to make progress.Á¹!úüÁ![X The processor may yield using the *YIELD* or *PAUSE* instruction and the current threadÁü¡";8 may yield by giving up a timeslice to the OS scheduler.Áá"úüé"GD In `#[no_std]` environments, this method is equivalent to [`spin`].Áµ#úü½#[X If possible, use [`is_completed`] to check when it is advised to stop using backoff andÁü�$QN block the current thread using a different synchronization mechanism instead.Áó$úÜû$ [`spin`]: Backoff::spinÁü›%+¥áË%útÓ%º¦æ%úüî%3ªÙ¦&ú<®&ݦüº&!âÔ¼à& use std::sync::Arc;Áüü&&ŽÚü§',¾Õ¤Ø'ÉÞäñ' use std::time::Duration;Á’(úüš(&ØÚüÅ(%ÀÖüï(#–Ûì—)ÂÛL¹)ñØ,Ç)ñ³Ñ)úüÙ)1. let ready = Arc::new(AtomicBool::new(false));Áü�* let ready2 = ready.clone();Á³*úÜ»* thread::spawn(move || {ÁüÛ*2/ thread::sleep(Duration::from_millis(100));Áü’+# ready2.store(true, SeqCst);Á<º+ });ÁÆ+úüÎ+*' assert_eq!(ready.load(SeqCst), false);Á´ý+ spin_wait(&ready);Áü˜,)& assert_eq!(ready.load(SeqCst), true);ÁüÆ,•’ # std::thread::sleep(std::time::Duration::from_millis(500)); // wait for background threads closed: https://github.com/rust-lang/miri/issues/1371Á<à-ݦì-úüô-1¿â4¿.ø øÀJæ`Ë Æ.Ë
Ï$Ç.üÿ="ü½2[X Returns `true` if exponential backoff has completed and blocking the thread is advised.Á�3út¥3º¦¸3úüÀ3\Y Waiting for an [`AtomicBool`] to become `true` and parking the thread after a long wait:Á¡4ú<©4ݦüµ4!âÔ¼Û4²ôü÷4&ŽÚü¢5,¾Õ¤Ó5ÉÞäì5ûô�6úü•6*óÞüÄ6%ÀÖüî6#–Ûü–7'ÃßüÂ7ôߤæ7œàüÿ7!ºàl¥8·ØL·8ñØ,Å8ñ³Ï8úü×81Šöü�9Åöü±9# let waiter = thread::current();ÁÙ9úÜá9ùöü�:2ž÷ü¸:#Ú÷Äà: waiter.unpark();Á<ý:†ø‰;úü‘;*£øÔÀ; blocking_wait(&ready);Áüß;)öøü�<•ªù<§=ݦ³=úü»=1¿âd†>ù ùÀJË “>Ë
Ð$”>ÜÓ>ÀJÒÀcÒüõ>8ø>úûü úÀJ û c cˆ¢cµ
 `£cÈ’ `àB¤GS
üï“Ñ ü>Ñ
Ò$ý>± ƒ?ÄÑ@ÀJÔ´Ô¼ð@<ó@ÀJÓÓ
Ô¼´à@dæü& # Thread synchronization primitives.Á' úü+- Í„üYO „…ü©P Ý…»À|Ô¼Î$î×¬4ˆ ü±áD� Œ²ˆ\Ô Ã´Ë5¤á »µ—6¬÷ ÁÀ$L© Ÿ·l— Öt… „„ Üû L› ÖÛ„\T»î0×ØÄZ\ÖÑÛ×Ù¿z$òï8×Ú´¯A´Ë2|ç"ìùD‹¥ÜÜê£ ”ÿJ$"zM'øÝÞî"$T�$�×ÛÛµ{ü­!,­×ÛÛú\üÀ0¥ààê£ Ì“Â$ÏÞ¤$ÖÿJüô)¥ââê£ €Þ¤$ƒÿJœ¢¥ääê£ §ÿJåæèëüî!.\Þ‚ÿJãã
å�Cü‚ S\� ý ýÿJ˜Û ý�Cã—çç Ÿ ãÁÛ œ –"˜Ûæ`lÇ ˜Ûæ`˜"�C Ó 
æ�C˜Û$  ± ¦ GIü«AT®×þ þÿJ˜Ûæ`ã—éé ¼ãÁÛ ¹ÆŒlÞÙŒ ê
è�C˜Û$½± Ã/1µè<closure_kind>Áê<closure_signature>Áê<upvars>Áêêèê�C˜ÛËGæ`æ`˜Û «hüè$lò×ÿ ÿÿJ ÿ�Cã €ã
ë�C$�äð¥ííê£ õÿJî�"$–€ €ÿJæ`ì ›ì
î�C$ T¦ 4ª ÖüŒ˜™š›øŽ\%
„Äïñ×4<
ÅÀïò×ÆÀïòKb
†JïôêŒ<g
‡>ïõ¤,p
µ>ïö×�
¤,ï÷ PhantomDataÁ\—
• ïøû‘– ïøDurationÁD´
­ÖïúInstantÁ<¾
óTïûô

„2
þ´I
ÙÛÅDz´D|
¢ÄŠ
ˆL¨
[]BDΐ
üÉ
 A thread parking primitive.Áé
úüíW
T Conceptually, each `Parker` has an associated token which is initially not present:ÁÅ
úüÉ^
[ * The [`park`] method blocks the current thread unless or until the token is available, at矬6
3 which point it automatically consumes the token.Áß
úüãa
^ * The [`park_timeout`] and [`park_deadline`] methods work the same as [`park`], but block for矁
 a specified maximum time.Áå
úüéb
_ * The [`unpark`] method atomically makes the token available if it wasn't already. Because theÁüÌ_
\ token is initially absent, [`unpark`] followed by [`park`] will result in the second callÁä¬
 returning immediately.ÁÉ
úüÍb
_ In other words, each `Parker` acts a bit like a spinlock that can be locked and unlocked usingÁä°
 [`park`] and [`unpark`].ÁÍ
útÑ
º¦à
ú<ä
ݦ¤ì
ÉÞä�
ûôüž&
# use crossbeam_utils::sync::Parker;ÁÅ
úÔÉ
 let p = Parker::new();Áüä!
 let u = p.unparker().clone();Á†
úüŠ
 // Make the token available.Á|«
u.unpark();Áü» 3
0 // Wakes up immediately and consumes the token.Álï
p.park();Áý
úÜ�
ùöü�
2
/ thread::sleep(Duration::from_millis(500));ÁœÐ
 u.unpark();Á<ä
†øì
úüð
5
2 // Wakes up when `u.unpark()` provides the token.Ál¦
š�ü´ •
ªù<Ê
ݦÒ
úÔÖ
 [`park`]: Parker::parkÁüñ *
' [`park_timeout`]: Parker::park_timeoutÁüœ
,
) [`park_deadline`]: Parker::park_deadline矃
 [`unpark`]: Unparker::unparkÁ4õ
ÙK¾
ðá¿Š<¿ýþ”‚
D‚
ïüü¯Lüš
<š
ïüü• • – û‘Fu\»Ÿ æ`ܾ
ÙK¼Þ
ÙK�´�¤ü
<ÿ
ÙK€€
�\Ë
ÙKƒ„…†‡ˆ‰´’
ÜÝ
 Creates a new `Parker`.Áý
út…
º¦˜
ú< 
ݦü¬&
†›×
úÔß
Á›<þ
ݦŠ
ú™
ÙK‚‚
ƒ”Ù
üÎ@
= Blocks the current thread until the token is made available.Á“
út›
º¦®
ú<¶
ݦüÂ&
†›í
úÔõ
Á›ü”!
固
úüÂ
œœ|ç
Åœû
úüƒ3
Þœl»
š�<Í
ݦ$à
� �ÙKæ`‚ å
‚
„$æ
üÇ-
ü¡]
Z Blocks the current thread until the token is made available, but only for a limited time.Áƒ
út‹
º¦ž
ú<¦
ݦä²
ûôüÓ&
†›þ
úÔ†
Á›¥
úü­U
R // Waits for the token to become available, but will not wait longer than 500 ms.Áü‡/
, p.park_timeout(Duration::from_millis(500));Á<»
ݦdÎ
‚ ‚ÙK­Ö­Ö±’®ÖsecsÁâ}¯ÖnanosÁâ}:²Zµ–²ªæ`‚ Û
‚
…$Ü
timeoutÁ<â
ü� .
ü�]
Z Blocks the current thread until the token is made available, or until a certain deadline.Áÿ
út‡
º¦š
ú<¢
ݦü®'
$ use std::time::{Duration, Instant};ÁüÚ&
†›…
úÔ�
Á›ü¬?
< let deadline = Instant::now() + Duration::from_millis(500);Áð
úüøU
€©ôÒ
 p.park_deadline(deadline);Á<õ
ݦlˆ
ƒ ƒÙKóTóTôTÏ’õTˆ�A t( ¼Í¥Šæ`‚ –
‚
†$—
deadlineÁD�
ü¥%#
üî 6
3 Returns a reference to an associated [`Unparker`].Á©!
úü±![
X The returned [`Unparker`] doesn't have to be used by reference - it can also be cloned.Á‘"
út™"
º¦¬"
ú<´"
ݦüÀ"&
†›ë"
úÔó"
Á›ü’#!
囸#
úüÀ#
œœ|å#
Åœüù#3
Þœl±$
š�<Ã$
ݦÏ$
úÔ×$
®Ÿüö$*
ÒŸD¬%
„ „ÙK „¯L‚ µ%
‚
‡$¶%
ü…(*
üí%+
( Converts a `Parker` into a raw pointer.Á�&
út¥&
º¦¸&
ú<À&
ݦüÌ&&
†›÷&
úÔÿ&
Á›üž'"
 let raw = Parker::into_raw(p);矁'/
, # let _ = unsafe { Parker::from_raw(raw) };Á<ù'
ݦDŒ(
ÙKࢂ‚
ˆthisÁ$•(
üö+0
üç(+
( Converts a raw pointer into a `Parker`.Á—)
údŸ)
# SafetyÁ°)
úü¸)S
P This method is safe to use only with pointers returned by [`Parker::into_raw`].Á�*
út˜*
º¦«*
ú<³*
ݦü¿*&
†›ê*
úÔò*
Á›ü‘+"
ä´ü¸+-
* let p = unsafe { Parker::from_raw(raw) };Á<ê+
ݦD„,
à¢ÙK‚‚
‰µ �,
Ôž-
ÙK‹Àc‹ü¿-8
Â-
…†‡ …ÙK † c cˆ¢cµ
 `£cÈ’ `àB¤GS
‡ï“Š Æ-
Š
‹$Ç-
± Í-
φ.
ü¢.9
6 Unparks a thread parked by the associated [`Parker`].ÁDç.
¯Lv˜¼weŠw�Œö.
,ö.
†J†JK‰Jµ �7ŠJphantomÁ�7‹J¤�7·0ØQd�è››ðœºï�Ò ïž�ïü躷 ÓuçEçEèEGlobalÁ ¿±‡§í#ìŒ/
¯Lì­/
¯LlÏ/
¯L‘’“¤Ð6
üã/>
; Atomically makes the token available if it is not already.Á¦0
úü®0\
Y This method will wake up the thread blocked on [`park`] or [`park_timeout`], if there isÁD�1
 any.Áœ1
út¤1
º¦·1
ú<¿1
ݦ¤Ë1
ÉÞää1
ûôü…2&
†›°2
úÔ¸2
Á›ü×2!
å›ý2
úÜ…3
ùöü¥32
Ê�œÜ3
…ž<ô3
†ø€4
úüˆ45
»žlÂ4
š�üÔ4•
ªù<î5
ݦú5
úÔ‚6
Reference in New Issue Copy Permalink