967 lines
246 KiB
Plaintext
967 lines
246 KiB
Plaintext
|
rust
|
|||
|
|
«× #rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥! -3d1337db07d0b3aeÁ À뉊 ]!ÜÛê(¹Þ—šên -5be7b69c3ff7b5b8Á ¤²XctÔ'ÐÓ©z¨É½Ó -a4945860e1c53b00Á ¤°ð ¾ä-±($²ï=©Ã -7e98a21bfd32b0edÁ–�òÖÀH•‘P IÓ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Ór2Ù $¨ûib‚ -cf21ca6f2bb15dcdÁë
|
|||
|
|
‹ás «LÖ€îâƒ×ɯŒ -ee6f3747e38367f0Á crossbeam_utilsÁ z“ÚLå<ýÓ;ã¡ÒFÕ -66e145216f0a822fÁ loomÁ$Ð crossbeam_loomÁ t¤ primitiveÁLÀ ‰ t‡ testsÁ,𤂠$Ϥ³¾,ë‚ $ÊÔ¾,›‚ $úï AtomicEpochReprÁ|¤ó 64ÁăԂï EpochReprÁLÅó� Ĥԣï EpochReprSignedÁ|À ó� ÄŸ Ôž ¬ MAX_OBJECTSÁ\� crossbeam_sanitizeÁ ”ëµ $ÿÔꬾ,˜¤‚ $÷£�¾,¸P‚ $—PÔ‚$þ=‚ $Ý=Œ¾,š‚ $ù
|
|||
|
|
í À ¢ cellÁ ¥ æ withÁ £ impl FnOnce(*const T) -> RÁ with_mutÁ £ impl FnOnce(*mut T) -> RÁ ç ¤ atomicÁ
|
|||
|
|
|
|||
|
|
strongest_failure_orderingÁ * CompareAndSetErrorÁ , 'gÁ ,¥ ,¡ CompareExchangeErrorÁ 0ë
|
|||
|
|
0¥ 0¡ 0 currentÁ 0æ 6¥ 6¡ 6× CompareAndSetOrderingÁ : successÁ : failureÁ =ü =Š @ü @Š low_bitsÁ C¥ ensure_alignedÁ E¥ compose_tagÁ G¥
|
|||
|
|
decompose_tagÁ I¥ PointableÁ K ALIGNÁ K InitÁ K initÁ K´ O 'aÁ K¶ QÛ Kã T¥ T² T¾ TÉ T´ YÛ T¶ [Û Tã M ^¥ ^‘ ^ elementsÁ a c¥ c layoutÁ f¥ f² f¾ fÉ f´ kÛ f¶ mÛ fã V p¥ p dataÁ p _markerÁ t¥ v¥ x¥ xæ {¥ {É {€ {—
|
|||
|
|
{ ۑ
|
|||
|
|
{ load_consumeÁ ‚ë
|
|||
|
|
{È „¡ { swapÁ †ë
|
|||
|
|
†¡ { ‰ë
|
|||
|
|
‰¡ ‰ ‰ {¡ Žë
|
|||
|
|
Ž¡ Ž Ž {¾ “ë
|
|||
|
|
“— { compare_and_setÁ –ë
|
|||
|
|
– –¡ { compare_and_set_weakÁ šë
|
|||
|
|
š š¡ { fetch_andÁ žë
|
|||
|
|
{ fetch_orÁ ë
|
|||
|
|
{ fetch_xorÁ ¢ë
|
|||
|
|
{
|
|||
|
|
into_ownedÁ { try_into_ownedÁ
|
|||
|
|
¦¥ ¦× ©¥ ©× ¬¥ ¬ƒ
|
|||
|
|
¯¥ ¯> ²¥ ²÷ µ¥ µ÷ ¸¥ ¸÷ »ë
|
|||
|
|
»¥ »÷ ¿¥ ¿÷ ¶ Â¥ Â
|
|||
|
|
into_usizeÁ € OwnedÁ Æ¥ ÆË ÆÖ Ê¥ Êò Ê€ Î¥ Î from_rawÁ Î into_boxÁ Îæ Ó¥ ÓÉ Ó into_sharedÁ Öë
|
|||
|
|
Ó tagÁ Ó with_tagÁ Ú¥ Úã Ý¥ Ý× à¥ àƒ ã¥ ãå ã´ ç¥ ç¶ ê¥ ê÷ í¥ í÷ ð¥ ð borrowÁ ó¥ ó
|
|||
|
|
borrow_mutÁ ö¥ öÉ ù¥ ù as_mutÁ SharedÁ üë
|
|||
|
|
ü¥ üË üÖ !�¥ �ƒ "„¥ #†¥ †ò †€ $Šë
|
|||
|
|
Š¥ Š as_rawÁ %Žë
|
|||
|
|
Ž¥ Ž—
|
|||
|
|
Ž is_nullÁ Ž´ Ž¶ ŽÉ Ž� Ž’ Ž¯ Žº &š¥ š÷ '�ë
|
|||
|
|
�¥ �� (¡¥ )£ë
|
|||
|
|
£¥ £ï
|
|||
|
|
*§¥ §‹ +ª¥ ª× ,¥ × -°¥ °> collectorÁ ³ ³³³³³³ CollectorÁ º globalÁ ³ ³³¾> ³Àæ À registerÁ ³Ãƒ ³Å× ³Ç� ³³ LocalHandleÁ Ê® ³Ìÿ
|
|||
|
|
Ì is_pinnedÁ ÌØ ³ Ðã ³
|
|||
|
|
Ò× deferredÁ Ô ÔÔÔÔÔÔÔ
|
|||
|
|
DATA_WORDSÁ Ô DataÁ Ý Ô DeferredÁ ßÑ ßË ßÖ Ô ã× Ôå NO_OPÁ æ
|
|||
|
|
no_op_callÁ åæ è— èÑ ê— èÑì— åÑ epochÁ ï ï� ï® ïÓ ï ô startingÁ ôë ô ô pinnedÁ ô unpinnedÁ ô successorÁ ïûæ û¬ ûÈ û £ € €€€€€€€€ GuardÁ ‰® € ‹ deferÁ Œ— Œ£ ‹ defer_uncheckedÁ �— �£ � ‹
|
|||
|
|
defer_destroyÁ “¥ “ ‹ flushÁ ‹ repinÁ ‹ repin_afterÁ ˜— ˜£ ˜
|
|||
|
|
ScopeGuardÁ ›
|
|||
|
|
›ˆ ˜ žã ‹Ø €¢ã €¤× € unprotectedÁ ¦ GuardWrapperÁ §
|
|||
|
|
§ˆ ¦ ¦ UNPROTECTEDÁ å ¬ ¬¬¬¬¬¬¬¬¬ ¬
|
|||
|
|
¬ ¬ ¬
|
|||
|
|
¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬ ¬ ¬ ¬ ¬þ ¬ BagÁ Î deferredsÁ Ï Î‘ ¬ ¬Óæ Ó is_emptyÁ Ó try_pushÁ Ó sealÁ ¬Ø> Ù ¬Ûã ¬Ý× ¬¬à
|
|||
|
|
is_expiredÁ ¬ GlobalÁ â localsÁ â queueÁ âÅ" ¬æ
|
|||
|
|
COLLECT_STEPSÁ ææ æ push_bagÁ æ collectÁ ê æ try_advanceÁ ¬ LocalÁ í entryÁ íØ í bagÁ í guard_countÁ í handle_countÁ í pin_countÁ íÅ" ¬õ PINNINGS_BETWEEN_COLLECTÁ õÉ õ˜ õØ ù õ õ±$ ü õœ% þ õÿ
|
|||
|
|
õþ õ©% õ acquire_handleÁ õ release_handleÁ õ finalizeÁ … … ¬ ˆ entry_ofÁ ˆ
|
|||
|
|
element_ofÁ ˆô, ç Œ listÁ � ��������� � IsElementÁ ˜¥ ˜“- ˜£- ˜ô, � IterÁ �ë
|
|||
|
|
�¥ �” �£ � predÁ � currÁ � headÁ �Ö � ¦> �¨ deleteÁ �ª¥ ª” ªæ ª insertÁ ®ë
|
|||
|
|
ªù °ë
|
|||
|
|
�²¥ ²” ²ã �¶ë
|
|||
|
|
¶¥ ¶” ¶› ¶ó Œ once_lockÁ ¼ ¼¼¼ OnceLockÁ À¥ À onceÁ À» ¼ Ä¥ ¼Æ¥ ¼È¥ Èæ È get_or_initÁ Ë— È
|
|||
|
|
initializeÁ Í— Í È
|
|||
|
|
get_uncheckedÁ ¼Ñ¥ Ñã Œñ) Ô ÔÔÔÔÔÔÔÔÔ Ô
|
|||
|
|
Ô Ô NodeÁ ᥠáË áó Ô å¥ Ôç¥ Ôé¥ éæ é
|
|||
|
|
push_internalÁ é pushÁ é pop_internalÁ î î é pop_if_internalÁ ñ— ñ ñ é try_popÁ é
|
|||
|
|
try_pop_ifÁ ö— Ôø¥ øã
|
|||
|
|
|
|||
|
|
> Œ ŒŒŒŒŒŒØ “ COLLECTORÁ Œÿ
|
|||
|
|
• Œ — Œ default_collectorÁ Œ with_handleÁ š— š£ š š
|
|||
|
|
UnsafeCellÁ £
|
|||
|
|
£¥ £ˆ §¥ §× ï EpochÁ ªË ïïﮃ ï°> ï²× ï´Ö ïï ·� ï AtomicEpochÁ ¹Ë ï
|
|||
|
|
»> ï ½× ¬ SealedBagÁ ¿Å" ¿ _bagÁ ¬
|
|||
|
|
Â> ¬ Ä× � EntryÁ Æó �È× � ListÁ Ê¥ Ê” Ê÷. ÊÖ �Ï¥ Ï” Ï× � IterErrorÁ Ó StalledÁ Ô
|
|||
|
|
��×� � Ù× Ô QueueÁ Û¥ Û÷. Û tailÁ Ôߥ ß× Œ HANDLEÁ â __rust_std_internal_init_fnÁ â ä å __RUST_STD_INTERNAL_VALÁ ä çü:
|
|||
|
|
|
|||
|
|
6
|
|||
|
|
9
|
|||
|
|
9
|
|||
|
|
9
|
|||
|
|
;
|
|||
|
|
<
|
|||
|
|
>
|
|||
|
|
?
|
|||
|
|
A
|
|||
|
|
B
|
|||
|
|
€
|
|||
|
|
‚
|
|||
|
|
„
|
|||
|
|
†
|
|||
|
|
‰
|
|||
|
|
‰
|
|||
|
|
Ž
|
|||
|
|
Ž
|
|||
|
|
“
|
|||
|
|
–
|
|||
|
|
–
|
|||
|
|
š
|
|||
|
|
š
|
|||
|
|
ž
|
|||
|
|
|
|||
|
|
¢
|
|||
|
|
¨
|
|||
|
|
¨
|
|||
|
|
¨
|
|||
|
|
«
|
|||
|
|
«
|
|||
|
|
«
|
|||
|
|
®
|
|||
|
|
Ø
|
|||
|
|
Ü
|
|||
|
|
ß
|
|||
|
|
ß
|
|||
|
|
ß
|
|||
|
|
â
|
|||
|
|
æ
|
|||
|
|
é
|
|||
|
|
ò
|
|||
|
|
õ
|
|||
|
|
ø
|
|||
|
|
û
|
|||
|
|
�
|
|||
|
|
ƒ
|
|||
|
|
„
|
|||
|
|
†
|
|||
|
|
�
|
|||
|
|
’
|
|||
|
|
“
|
|||
|
|
”
|
|||
|
|
•
|
|||
|
|
˜
|
|||
|
|
™
|
|||
|
|
š
|
|||
|
|
|
|||
|
|
|
|||
|
|
¡
|
|||
|
|
¦
|
|||
|
|
¦
|
|||
|
|
§
|
|||
|
|
©
|
|||
|
|
©
|
|||
|
|
ª
|
|||
|
|
¬
|
|||
|
|
¬
|
|||
|
|
¬
|
|||
|
|
|
|||
|
|
¯
|
|||
|
|
¯
|
|||
|
|
¯
|
|||
|
|
°
|
|||
|
|
Â
|
|||
|
|
Ä
|
|||
|
|
Æ
|
|||
|
|
Æ
|
|||
|
|
Æ
|
|||
|
|
È
|
|||
|
|
È
|
|||
|
|
Í
|
|||
|
|
Î
|
|||
|
|
Ï
|
|||
|
|
Ñ
|
|||
|
|
Ó
|
|||
|
|
Ó
|
|||
|
|
Ó
|
|||
|
|
ä
|
|||
|
|
ä
|
|||
|
|
ä
|
|||
|
|
ý
|
|||
|
|
þ
|
|||
|
|
ÿ
|
|||
|
|
Œ
|
|||
|
|
�
|
|||
|
|
“
|
|||
|
|
“
|
|||
|
|
–
|
|||
|
|
—
|
|||
|
|
˜
|
|||
|
|
Ÿ
|
|||
|
|
|
|||
|
|
£
|
|||
|
|
¥
|
|||
|
|
¥
|
|||
|
|
¥
|
|||
|
|
Õ
|
|||
|
|
Ö
|
|||
|
|
Ü
|
|||
|
|
Þ
|
|||
|
|
Þ
|
|||
|
|
Þ
|
|||
|
|
á
|
|||
|
|
é
|
|||
|
|
é
|
|||
|
|
é
|
|||
|
|
ê
|
|||
|
|
ê
|
|||
|
|
ê
|
|||
|
|
ì
|
|||
|
|
ì
|
|||
|
|
÷
|
|||
|
|
ø
|
|||
|
|
ù
|
|||
|
|
û
|
|||
|
|
ü
|
|||
|
|
ü
|
|||
|
|
þ
|
|||
|
|
þ
|
|||
|
|
€
|
|||
|
|
�
|
|||
|
|
‚
|
|||
|
|
ƒ
|
|||
|
|
„
|
|||
|
|
…
|
|||
|
|
‰
|
|||
|
|
Š
|
|||
|
|
‹
|
|||
|
|
‹
|
|||
|
|
š
|
|||
|
|
›
|
|||
|
|
œ
|
|||
|
|
œ
|
|||
|
|
©
|
|||
|
|
©
|
|||
|
|
µ
|
|||
|
|
»
|
|||
|
|
Ë
|
|||
|
|
Í
|
|||
|
|
Ð
|
|||
|
|
Ó
|
|||
|
|
ì
|
|||
|
|
ì
|
|||
|
|
ì
|
|||
|
|
ì
|
|||
|
|
í
|
|||
|
|
í
|
|||
|
|
î
|
|||
|
|
î
|
|||
|
|
ñ
|
|||
|
|
ñ
|
|||
|
|
ñ
|
|||
|
|
õ
|
|||
|
|
õ
|
|||
|
|
ö
|
|||
|
|
ö
|
|||
|
|
ö
|
|||
|
|
ú
|
|||
|
|
š
|
|||
|
|
©
|
|||
|
|
©
|
|||
|
|
©
|
|||
|
|
¯
|
|||
|
|
³
|
|||
|
|
³
|
|||
|
|
³
|
|||
|
|
µ
|
|||
|
|
¸
|
|||
|
|
¸
|
|||
|
|
¾
|
|||
|
|
¾
|
|||
|
|
¾
|
|||
|
|
Å
|
|||
|
|
Å
|
|||
|
|
Å
|
|||
|
|
É
|
|||
|
|
É
|
|||
|
|
É
|
|||
|
|
Ò
|
|||
|
|
Ò
|
|||
|
|
Ò
|
|||
|
|
Ø
|
|||
|
|
Ø
|
|||
|
|
Ú
|
|||
|
|
Ú
|
|||
|
|
Ú
|
|||
|
|
á
|
|||
|
|
á
|
|||
|
|
á
|
|||
|
|
:K˜¿c £ £ ¤Ã6 ¦ˆ
|
|||
|
|
2šÁ]îC4 ¥ ¿c 0 0 ‚ 4² 5æ `::+d¼þ 8¥¡ :¼À½À¾ÀË ¿ÀÀÀÌ ÁÀÂÀG ÃÀÄÀF ÅÀÆÀ× `šÁ¬S øB :™E™E KÅD K
|
|||
|
|
ÑÛÑÛ MaybeUninitÁ ÓÛ uninitÁÝ ÔÛ»Ý Íõƒ«%9ÅD Ìì p p V rË sÖ �»(xÑÑÄÅD � ÿF ¿cÿF ÎcÿF ØÿF ³ ÿF é ÿF Æ Æ ‹ ÈË ÉÖ $zF–Е5ÉÅD é ÿF�� ž BoxÁ ¡ˆˆ ¢‰ˆ l }.xÏÅDçEçEèEÕ) ¿±‡§í# é ÿFÅD é p p V rË sÖ �»(xÑÑćE ü ü à ÿË €Ö De—�è× ë
|
|||
|
|
‡E é ÿF ÅD ÂñGÅD Œ"ñG ¿cñG ØñG é!ñG ö!ñG é ñGÅD é ñG¶H ñGÅD £ñGÅD à ñGÅD ã ñGÅD Ø ü ü à ÿË €Ö De—�è× 8‡E Š ÎK ÂÎK‡E é ÎK ‡E µßêIêI ™ÎK íßêIêI ºÎK ¿cÎK ÎcÎK ³ ÎK Ìì º º ‡ »˜ ÉÈ\Ácä � ŠM ³ ŠM ØŠM ¿cŠM µßŠMŠM ™ŠM Œ" Ê Ê … Ë® D_ú6xƒgt ¿cþM ¿c ß ß µ! àÑ Ô áË Ô âÖ Ô Ì�¡÷—ì= Š ª ª þ6 «Ë ï ì·>ƒ‡am Û‰O ؉O ³ ‰O ¿c‰O ™‰O Ðì‰O µß‰O‰O ³ ¹ ¹ â7 ºË ï :ºm¨©V¬G ¿c‰P Œ" › › œÙ% �ˆ € Ê=*‘K”© Œ" ‰ ‰ —$ Š® þšl{ÈÅ0 ¿c�Q � § § ¨¿& ©ˆ € fZ�R{˜ýL Ìì Î Î §( ϲ( ¬ Ñ‘ ¬ 87úÆ]T§œ ³ ùQ Œ"ùQ ¿cùQ ³ ¿ ¿ –8 ÀÅ" ¬ Á¯8 ¬ ÒÊè¨‰Ü ¿cØR � ØR ˜ í í ß* îì* ¬ ïØ ¬ ð�+ ñŒ+ ¬ òŸ+ ¬ ó³+ ¬ ôÅ" ¬ :ÁÁ£ÏFV$ S ¿c Æ Æ Ô8 Çó � ç¾3èlD9… ¿c Ê Ê ö8 Í÷. � ÎÖ � ñ$ƒ[ë΂çÅD” Ðì Ó Ô ÕÐ9 w¨�ì�G µß¬U¬U ¿c¬U ³ ¬T Œ"áT ùM � � ³. ¡£ � ¢ß. � £ë. � ¤÷. � ¥Ö � ¥ªç�\¨ŒW ë
|
|||
|
|
‡E” � À À ×0 Âï0 ¼ û ¼ Mɾ š5½žÅD ÌìùV Œ"ùV ¿c Û Û ƒ: Ý÷. Ô Þ : Ô P Ãnƒ•zÅD � ÒW ÌìÒW Œ"ÒW § £6 0¦ pÝ Æª üÅ ºÒ Êã ß² ª½ ¹¤ ‰Ý ÎÄ ¿È ÆÏ ÊÙ Óß Û=¼À@
|
|||
|
|
T f t p¼ ºÒ ÎÆ Àç Ûv p½ ºª §ß ¿Ä Àå Û© p ü¬ pà Æ� üà º® ª¯ p° ü¾ º° ª» ¹Ø Π¿¦ Ʋ pµ p¸ p» p¿ pê Æí Æš üÊ Æ† üÚ ÆÐ Êž ›¢ ‰Û β ÊÑ Àø Ûã Æç Æð Æó Æö Æù Æ„ ü¬ ª� üÇ º· ª× Ó¡ üÉ º´ ª£ ü§ ü ª¶ ªÖ Óˆ í¶ �¿cÆ :t K Ìì� !Îc(Ø
|
|||
|
|
³ "é 7 Â3Œ"é!8ö! £à ã Š µß™ íߺÛÐì ˜ùMüù%# $—&
|
|||
|
|
# ìù%
|
|||
|
|
õ0ÅD 3 E ›& üî%/ £ ÅD œ& «& üª%� ”D lÎ% ÅD $Â% î0î0 Ã6 ð0»Ì- ·}—KEüC£ÅD Û ÅD Ù ËH w ¤Ó3
|
|||
|
|
”Ó3
|
|||
|
|
ÊÅD % ü¾3* V ,Ë3 $ _Á Ã` 0ÁÜ©>
|
|||
|
|
Ì©>
|
|||
|
|
Ê ^ ^ M `‘ aÐ &°Ô{-i–‚ÅD X ü”>1 h Ã` ,¡> $ _Á œïU
|
|||
|
|
„ïU
|
|||
|
|
ŒÄ €V Ã` > \™V • ÅD üÖUY p ÅD ®V µV ü«UŠ ÿF LÂU ¤]¤] V ¦]Á‚] üß3ø¤”&Ã` á • • – PhantomDataÁ Fu\»Ÿåb × „ Ã` 3Á Ã`
|
|||
|
|
DATA_WORDSÁTµ
|
|||
|
|
ç ¬Ó
|
|||
|
|
œÓ
|
|||
|
|
òÃ`Ã` 9 \ÿ • �e üœy ß ” üËÑ æ ¼N $ã ‰e ß ÑÛÑÛ ±E ÓÛÆEÝ ÔÛ»Ý Íõƒ«%9¸e ù • • – €c Fu\»Ÿée é Ÿ _Á @ Ã` 64Á @ Ã` MAX_OBJECTSÁ @ Ã` MAX_OBJECTSÁ Ã` 8Á € Ã` 128Á\³
|
|||
|
|
L³
|
|||
|
|
þ8 ' üÓ& ¬ã
|
|||
|
|
ϋ
|
|||
|
|
òÅD + 8
|
|||
|
|
? |Ó
|
|||
|
|
õ0¥F O ` ø üšj À ÅD ƒ Š Ê üîœ ùV $‹ ï8ï8 OnceÁ ð8 innerÁé8 ãTPàVça ! î0î0 Ã6 ð0»Ì- ·}—KEüC£¥F , ¥F + ’ ùW· ™e
|
|||
|
|
|
|||
|
|
éW· e
|
|||
|
|
¾þMùWÕ úe ä ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡z٠ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙþM þM ûk± ß ùV�f�a â ®® £ °Ói¨ it§ÅLS¶þM áV¢fa X äûk ûk _Á ùWð e
|
|||
|
|
éWð e
|
|||
|
|
ÐþM / 5 ùW¦ ®e å €l“m �e / ûk W¿ e ùWí Ôe ùW‚!e ç‚o…o�e # ûk W›!e M WÀ$e ùWÛ ôe ä ûk å‚o…o�e å ç‚o…o�e Ÿ S _Á üæ £ ÅD ¤ ) ”D 4 §_ ; B Œ�r
|
|||
|
|
› œ % ÈP 0 S 9 @ œ——
|
|||
|
|
§ ¨ & ¿Q 1 �Q 8 ? ³ÔŒŒí À û ¤,‰+ Ò
|
|||
|
|
”æ/ , üà¬ú/ : ýV4ê0 p €‚¤ò0 0 �‹,ˆ1 Æ ‚¢L�1 K ƒ¶<š1  „Ã4£1 ü …‡ L¼1 º ‡… \Ç1 Ê ˆ¬&\á1 ¦ Š—$,î1 ‰ ‹î5ŒÐ2 ™ Lã2 — ¡ÿ
|
|||
|
|
î2 • ¢ü ó2 ü # Epoch-based memory reclamation.Á $ ú ü(\ Y An interesting problem concurrent collections deal with comes from the remove operation.Á ü…b _ Suppose that a thread removes an element from a lock-free map, while another thread is readingÁ üè` ] that same element at the same time. The first thread must wait until the second thread stopsÁ üÉ= : reading the element. Only then it is safe to destruct it.Á ‡ ú ü‹] Z Programming languages that come with garbage collectors solve this problem trivially. TheÁ üéa ^ garbage collector will destruct the removed element when no thread can hold a reference to itÁ dË anymore.Á Ø ú üÜa ^ This crate implements a basic memory reclamation mechanism, which is based on epochs. When anÁ ü¾` ] element gets removed from a concurrent collection, it is inserted into a pile of garbage andÁ üŸc ` marked with the current epoch. Every time a thread accesses a collection, it checks the currentÁ üƒa ^ epoch, attempts to increment it, and destructs some garbage that became so old that no threadÁ üå" can be referencing it anymore.Á ˆ ú üŒb _ That is the general mechanism behind epoch-based memory reclamation, but the details are a bitÁ üï` ] more complicated. Anyhow, memory reclamation is designed to be fully automatic and somethingÁ üÐ C @ users of concurrent collections don't have to worry much about.Á ”
|
|||
|
|
ú t˜
|
|||
|
|
# PointersÁ §
|
|||
|
|
ú ü«
|
|||
|
|
b _ Concurrent collections are built using atomic pointers. This module provides [`Atomic`], whichÁ üŽ ^ [ is just a shared atomic pointer to a heap-allocated object. Loading an [`Atomic`] yields aÁ üí a ^ [`Shared`], which is an epoch-protected pointer through which the loaded object can be safelyÁ LÏ read.Á Ù ú lÝ
|
|||
|
|
# PinningÁ ë ú üï b _ Before an [`Atomic`] can be loaded, a participant must be [`pin`]ned. By pinning a participantÁ üÒ
|
|||
|
|
X U we declare that any object that gets removed from now on must not be destructed justÁ ü«\ Y yet. Garbage collection of newly removed objects is suspended until the participant getsÁ lˆ
|
|||
|
|
unpinned.Á – ú lš
|
|||
|
|
# GarbageÁ ¨ ú ü¬a ^ Objects that get removed from concurrent collections must be stashed away until all currentlyÁ üŽ^ [ pinned participants get unpinned. Such objects can be stored into a thread-local or globalÁ üíR O storage, where they are kept until the right time for their destruction comes.Á À ú üÄk h There is a global shared instance of garbage queue. You can [`defer`](Guard::defer) the execution of anÁ ü°_ \ arbitrary function until the global epoch is advanced enough. Most notably, concurrent dataÁ ü�7 4 structures may defer the deallocation of an object.Á È ú TÌ # APIsÁ × ú üÛa ^ For majority of use cases, just use the default garbage collector by invoking [`pin`]. If youÁ ü½I F want to create your own garbage collector, use the [`Collector`] API.Á üÇ üñ6 |¤ ³ÔŒŒí¢
|
|||
|
|
À£
|
|||
|
|
¤¢
|
|||
|
|
Ò
|
|||
|
|
¡
|
|||
|
|
, üà
|
|||
|
|
: ýVŸ
|
|||
|
|
p €‚ž
|
|||
|
|
0 �‹�
|
|||
|
|
Æ ‚¢œ
|
|||
|
|
K ƒ¶›
|
|||
|
|
 „Ú
|
|||
|
|
ü …‡ ™
|
|||
|
|
º ‡… ˜
|
|||
|
|
Ê ˆ¬&—
|
|||
|
|
¦ Š—$–
|
|||
|
|
‰ ‹î5•
|
|||
|
|
™ ”
|
|||
|
|
— ¡ÿ
|
|||
|
|
“
|
|||
|
|
• ¢ËÎÑ„î Èlþ óµ Ì¢ üœ ! ‰ tÈ „Ç Ü¾ L‚ ‹d±* µ œ’ $¡ £¤¬ð$ ¥ ÍìÅD õ$ ”D
|
|||
|
|
üª%1 ¾% ÅD”D
|
|||
|
|
ÅDËŒüÏ&@ $Ý& é é”D Ü £ £
|
|||
|
|
Ü
|
|||
|
|
å& Íìé’ â& Íìä’ Ôï& –"ä’µJ ¬ô& ä’É“˜" é’ ˆ'
|
|||
|
|
ÅDé’ä’$æ& ± ì& _a [] üã'B Dñ' ê ê”D “ é’ £
|
|||
|
|
“
|
|||
|
|
ý' œ“ ú' ÍìÕ” ć( –"Õ”åb œŒ( Õ”¯•˜" é’ ž(
|
|||
|
|
ÅDé’Õ”$þ' ± „( _a [] œê( $ù( K Æ) †J Ì 4î) ‚] „¹) '”â) Œ¬* ¾”ü* µTË+ »¤Œ›+ óµ Ì®+ üš+. ü‘+9 4Ï+ *,0:CEGIK^pÂÆüÄG � 4( èØ Y4C ZLK £ ‹ a ‹ × p ` €c\‡ • €c – í$¤ ë ±E\ª ÑÛ r,È é! ! DerefMutÁDÏ ö! "µ ä “ #ž,ó ‰f $—$,� ‰ % AtomicUsizeÁ\¹ „Ä '®DÆ ¼À (
|
|||
|
|
AtomicConsumeÁlî œ )Œqœed4Y\NQL[ELj9Ìy-L˜ žL¼ùûâäLÞ×\íÊœÿ½ô˜¥§•—üÕ&}ü–8Ô™ ™E™E
|
|||
|
|
* ordÁ ´tÙü‡% üå; 8 The error returned on failed compare-and-set operation.Á "Use `CompareExchangeError` insteadÁüà$ üÌ:”� ‡› ë
|
|||
|
|
- ¥ . ¡ / - . / Íì‡E § Íì�E ª 0 0 ‚ 4² 5æ `::+d¼þ ë
|
|||
|
|
‡E�E£UW RT ü�I üÐ< 9 The error returned on failed compare-and-swap operation.Á ¤˜ ë
|
|||
|
|
1 ¥ 2 ¡ 3 3 2 1 Îì‡E ± ‚� È K‡E L½ Â�E‡E TË ‡E ë
|
|||
|
|
žÍ‘� `::+d¼þ 45[] `b Ôª üÝH E The value in the atomic pointer at the time of the failed operation.Á<® 0 0 êIT‡
|
|||
|
|
üË 7 4 The new value, which the operation failed to store.Á ‹
|
|||
|
|
0 0 �Eü–
|
|||
|
|
Q 8 ë ¥ 7 ¡ 8 8 ë 7 òœ ›
|
|||
|
|
‚� ž
|
|||
|
|
•ŸT¡
|
|||
|
|
¿c�E T®
|
|||
|
|
ÒD9 Àc 9 /1 46 üî
|
|||
|
|
8 ñ
|
|||
|
|
ì í î ìÒD í c c ˆ ¢cµ
|
|||
|
|
` £c bufÁ ` àB¤GS
|
|||
|
|
îÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
�eŸÈŸÈ È ErrorÁ O˜éBL 6 õ
|
|||
|
|
6
|
|||
|
|
9 8‡E�E$ö
|
|||
|
|
± ü
|
|||
|
|
üÛ üÉ 4 1 Memory orderings for compare-and-set operations.Á þ ú ü‚
|
|||
|
|
[ X A compare-and-set operation can have different memory orderings depending on whether itÁ üÞ
|
|||
|
|
\ Y succeeds or fails. This trait generalizes different ways of specifying memory orderings.Á »ú ü¿A > The two ways of specifying orderings for compare-and-set are:Á �ú ü…^ [ 1. Just one `Ordering` for the success case. In case of failure, the strongest appropriateÁ Ôä ordering is chosen.Á üÿ\ Y 2. A pair of `Ordering`s. The first one is for the success case, while the second one isÁ äÜ for the failure case.Á Š`compare_and_set` and `compare_and_set_weak` that use this trait are deprecated, use `compare_exchange` or `compare_exchange_weak instead`Áü½š ü¤¶ ¬å …© : : Îì üÛß : Ä« Ä« ;<;< < ; ô¹ ü�3 0 The ordering of the operation when it succeeds.Á<¼ …©Ì ï ïÌ« ™E : Ä :
|
|||
|
|
;Ì«$Åôš üÝ0 - The ordering of the operation when it fails.Á ’ú üš] Z The failure ordering can't be `Release` or `AcqRel` and must be equivalent or weaker thanÁ Ìü the success ordering.Á<� …©ù ð ðÌ« ™E : ¥ :
|
|||
|
|
<Ì«$¦üÑ' ™E>? ; < > ? ì�<� ñ ñ™E ™E = ˜ =
|
|||
|
|
> $™ìÔ<× ò ò™E ™E = ß =
|
|||
|
|
? $àü¼3 ŽFAB ; < A B ì„<‡ ó óŽF ™E @ � @
|
|||
|
|
A $�ìÌ<Ï ô ôŽF ™E @ × @
|
|||
|
|
B $Øüï-Dò Ã` ¥ D D ÎìÅD û KÅD L‡
|
|||
|
|
CÅD üŠ4t� Ã`�e ¥ F F „³ œ ”³L¨
|
|||
|
|
EÅD@ ³ ü¯ G\² Ã`Ã`Ã` ¥ H H „³ ¾ ”³LÊ
|
|||
|
|
GÅDË$Õ ¯ â #% üƒ Fl† Ã`Ã`Ã` ¥ J J „³ ” ”³L
|
|||
|
|
IÅDË$« œÈ' ü… / , Types that are pointed to by a single word.Á µ ú ü¹ b _ In concurrent programming, it is necessary to represent an object within a word because atomicÁ üœ!_ \ operations (e.g., reads, writes, read-modify-writes) support only single words. This traitÁ üü!> ; qualifies such types that are pointed to by a single word.Á »"ú ü¿"\ Y The trait generalizes `Box<T>` for a sized type `T`. In a box, an object of type `T` isÁ üœ#c ` allocated in heap and it is owned by a single-word pointer. This trait is also implemented forÁ ü€$d a `[MaybeUninit<T>]` by storing its size along with its elements and pointing to the pair of arrayÁ ´å$ size and elements.Á ü$ú ü€%] Z Pointers to `Pointable` types can be stored in [`Atomic`], [`Owned`], and [`Shared`]. InÁ üÞ%G D particular, Crossbeam supports dynamically sized slices as follows.Á ¦&ú <ª& ```Á ô²& use std::mem::MaybeUninit;Á üÑ& use crossbeam_epoch::Owned;Á ñ&ú üõ&J G let o = Owned::<[MaybeUninit<i32>]>::init(10); // allocating [i32; 10]Á <À'©¼ LÒ' K K Ä«üÈ'Ö K Ä« Ä« LMNOQSLMNOQS ÍìÌ« M TÀ( »¿ Q O N S ”„( ìâ' The alignment of pointer.Á,Š( K K Ã`LÀ( ô�( The type for initializers.Á$Å( K K ü×)* üÐ(- * Initializes a with the given initializer.Á ‚)ú dŠ) # SafetyÁ ›)ú ü£)/ , The result should be a multiple of `ALIGN`.Á$á) ÿÃ` K K
|
|||
|
|
NÌ«É$æ)üÇ,, ü‡*# Dereferences the given pointer.Á ¯*ú d·*³À È*ú üÐ*L I - The given `ptr` should have been initialized with [`Pointable::init`].Á ü¡+D A - `ptr` should not have yet been dropped by [`Pointable::drop`].Á üê+X U - `ptr` should not be mutably der
|
|||
|
|
`Shared`.Á œlú ü¤lZÏã tƒm²ä –mú tžmÖÛ ±mú <¹m©¼ üÅm9 6 use crossbeam_epoch::{self as epoch, Atomic, Shared};Á üƒn,·å ´nú ô¼n¼Ü ôßn…æ ü‚o2 / let p = a.swap(Shared::null(), SeqCst, guard);Á ü¹o4 1 # unsafe { drop(p.into_owned()); } // avoid leakÁ <òo©¼$…p ‡ ø øÿF Éõ™E ‡�Q ü ü à ÿË €Ö De—�è× ‡ÅD {¡ ˆ ˆ Šp { õõ Žp †öT‘p
|
|||
|
|
†ÅDÉõ$žpæ ¤p«š ¬p »pCE;= üê~Š ü´q` ] Stores the pointer `new` (either `Shared` or `Owned`) into the atomic pointer if the currentÁ ü™r^ [ value is the same as `current`. The tag is also taken into account, so two pointers to theÁ üürG D same object, but with different tags, will not be considered equal.Á Èsú üÐs_ \ The return value is a result indicating whether the new pointer was written. On success theÁ ü´t[ X pointer that was written is returned. On failure the actual current value and `new` areÁ l”u
|
|||
|
|
returned.Á ¦uú ü®uE B This method takes two `Ordering` arguments to describe the memoryÁ üøuQ N ordering of this operation. `success` describes the required ordering for theÁ üÎv[ X read-modify-write operation that takes place if the comparison with `current` succeeds.Á ü®wZ W `failure` describes the required ordering for the load operation that takes place whenÁ ü�xR O the comparison fails. Using `Acquire` as success ordering makes the store partÁ üäxN K of this operation `Relaxed`, and using `Release` makes the successful loadÁ ü·yP M `Relaxed`. The failure ordering can only be `SeqCst`, `Acquire` or `Relaxed`Á üŒzB ? and must be equivalent to or weaker than the success ordering.Á Ózú tÛzÖÛ îzú <öz©¼ ü‚{@ = use crossbeam_epoch::{self as epoch, Atomic, Owned, Shared};Á üÇ{,·å ø{ú ô€|¼Ü £|ú ô«|…æ üÎ|% " let curr = a.load(SeqCst, guard);Á üø|O L let res1 = a.compare_exchange(curr, Shared::null(), SeqCst, SeqCst, guard);Á üÌ}Q N let res2 = a.compare_exchange(curr, Owned::new(5678), SeqCst, SeqCst, guard);Á ü¢~7 4 # unsafe { drop(curr.into_owned()); } // avoid leakÁ <Þ~©¼„ñ~ Š ù ú ùÿF ü ü à ÿË €Ö De—�è× úÅDÉõ™E™E Š�Q Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ü ü à ÿË €Ö De—�è× ŠÅD 0 0 ‚ 4² 5æ `::+d¼þ ŠÅDÉõ {¡ ‹ ‹ ‚ { õõ † †öTé€
|
|||
|
|
‰ÅDÉõ$“²<¡æ Áü<ÑŠ<ì ‡€TVLN �‚ ‰ <closure_kind>Á Œ <closure_signature>Á Œ <upvars>Á Œ Œ ‰ ŒÅDÉõ Ã` ü ü à ÿË €Ö De—�è× ÅD Ã` LÊ‚ ‰ìŒ � …� � £� � � ‰ �ÅDÉõ ÔŽ 0 0 ‚ 4² 5æ `::+d¼þ ÅDÉõ ˜�üÝ—� ü—„`¢û üü„^Œü üß…Gôü «†ú ü³†_ \ Unlike [`compare_exchange`], this method is allowed to spuriously fail even when comparisonÁ ü—‡_ \ succeeds, which can result in more efficient code on some platforms. The return value is aÁ üû‡Z W result indicating whether the new pointer was written. On success the pointer that wasÁ üÚˆT Q written is returned. On failure the actual current value and `new` are returned.Á ³‰ú ü»‰EÁÿ ü…ŠQ�€ üÛŠ[ë€ ü»‹ZÐ� üšŒR´‚ üñŒN�ƒ üÄ�Pèƒ ü™ŽB„ àŽú üèŽ2 / [`compare_exchange`]: Atomic::compare_exchangeÁ Ÿ�ú t§�ÖÛ º�ú <Â�©¼ üÎ�@À… ü“�,·å Ä�ú ôÌ�¼Ü ôï�…æ ’‘ú üš‘# let mut new = Owned::new(5678);Á ü‘( % let mut ptr = a.load(SeqCst, guard);Á üï‘H E # unsafe { drop(a.load(SeqCst, guard).into_owned()); } // avoid leakÁ T¼’ loop {Á üË’H E match a.compare_exchange_weak(ptr, new, SeqCst, SeqCst, guard) {Á ´˜“ Ok(p) => {Á ij“ ptr = p;Á ´Ð“ break;Á lë“
|
|||
|
|
}Á Ìý“ Err(err) => {Á ü›”" ptr = err.current;Á ô” new = err.new;Á lå”ü˜ L÷” }Á ,…• }Á �•ú ü—•) & let mut curr = a.load(SeqCst, guard);Á TÅ•³— üÔ•T Q match a.compare_exchange_weak(curr, Shared::null(), SeqCst, SeqCst, guard) {Á Ü– Ok(_) => break,Á üÍ–+ ( Err(err) => curr = err.current,Á Lý–™š ,‹—¬š ü•—7ˆ <Ñ—©¼¬ä— � û ü ûÿF ü ü à ÿË €Ö De—�è× üÅDÉõ™E™E ��Q Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ü ü à ÿË €Ö De—�è× �ÅD 0 0 ‚ 4² 5æ `::+d¼þ �ÅDÉõ {¡ � � ú— { õõ þ— †öTá™
|
|||
|
|
ŽÅDÉõ$‹˜²<™˜æ ¹˜ü<ɘŠ<ä˜ ÿ˜[]RT Š› ŽìŒ ‘ …� ‘ £� ‘ ‘ Ž ‘ÅDÉõÑŽ˜�LÇ› ŽìŒ ’ …� ’ £� ’ ’ Ž ’ÅDÉõý�˜�ü쫆 ü”�T Q Fetches the pointer, and then applies a function to it that returns a new value.Á üí�^ [ Returns a `Result` of `Ok(previous_value)` if the function returned `Some`, else `Err(_)`.Á Оú üØž^ [ Note that the given function may be called multiple times if the value has been changed byÁ ü»Ÿ^ [ other threads in the meantime, as long as the function returns `Some(_)`, but the functionÁ üž 9 6 will have been applied only once to the stored value.Á Ü ú üä J G `fetch_update` takes two [`Ordering`] arguments to describe the memoryÁ ü³¡M J ordering of this operation. The first describes the required ordering forÁ ü…¢F C when the operation finally succeeds while the second describes theÁ üТL I required ordering for loads. These correspond to the success and failureÁ ü¡£; 8 orderings of [`Atomic::compare_exchange`] respectively.Á á£ú üé£F C Using [`Acquire`] as success ordering makes the store part of thisÁ ü´¤K H operation [`Relaxed`], and using [`Release`] makes the final successfulÁ ü„¥H E load [`Relaxed`]. The (failed) load ordering can only be [`SeqCst`],Á üÑ¥K H [`Acquire`] or [`Relaxed`] and must be equivalent to or weaker than theÁ ¬¡¦ success ordering.Á »¦ú üæ" [`Relaxed`]: Ordering::RelaxedÁ üê¦" [`Acquire`]: Ordering::AcquireÁ ü‘§" [`Release`]: Ordering::ReleaseÁ ü¸§ [`SeqCst`]: Ordering::SeqCstÁ ݧú tå§ÖÛ ø§ú <€¨©¼ üŒ¨1üä ü¨,·å ó¨ú ôû¨¼Ü ôž©…æ Á©ú üÉ©N K let res1 = a.fetch_update(SeqCst, SeqCst, guard, |x| Some(x.with_tag(1)));Á Ôœª assert!(res1.is_ok());Á »ªú üê? < let res2 = a.fetch_update(SeqCst, SeqCst, guard, |x| None);Á ܇« assert!(res2.is_err());Á ü§«4äÜ <à«©¼dó« ý ýÿF ™E™E ë
|
|||
|
|
�Q —Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ü ü à ÿË €Ö De—�è× ë
|
|||
|
|
ÅD¥³ {ë
|
|||
|
|
” — • ” • �¬ { ÍìÒ² „¬ “"Ò²¥³ üÄ- Ò²·´˜" ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ¥³¬Ü
|
|||
|
|
“ÅD ë
|
|||
|
|
Ò²$‘¬ set_orderÁLŸ¬
|
|||
|
|
fail_orderÁT¼¬£,Ú¬ funcÁ$ø¬€¬ÖØ ü¯¾Š üÔ°`¢û ü¹±^Œü üœ²Gôü è²ú üð²_Ñý üÔ³[ºþ l´´žÿ Æ´ú üδU R This method takes a [`CompareAndSetOrdering`] argument which describes the memoryÁ ü¨µ ordering of this operation.Á ̵ú üÔµ% " # Migrating to `compare_exchange`Á þµú ü†¶X U `compare_and_set` is equivalent to `compare_exchange` with the following mapping forÁ ¬ã¶ memory orderings:Á ý¶ú ü…· Original | Success | FailureÁ üª· -------- | ------- | -------Á üÏ· Relaxed | Relaxed | RelaxedÁ üô· Acquire | Acquire | AcquireÁ ü™¸ Release | Release | RelaxedÁ ü¾¸ AcqRel | AcqRel | AcquireÁ ü㸠SeqCst | SeqCst | SeqCstÁ ‡¹ú t�¹ÖÛ ¢¹ú <ª¹©¼ ܶ¹ # #![allow(deprecated)]Á üÖ¹@À… ü›º,·å ̺ú ôÔº¼Ü ÷ºú ôÿº…æ ü¢»%ʆ üÌ»F C let res1 = a.compare_and_set(curr, Shared::null(), SeqCst, guard);Á ü—¼H E let res2 = a.compare_and_set(curr, Owned::new(5678), SeqCst, guard);Á üä¼7ˆ < ½©¼ Use `compare_exchange` insteadÁüˆ¾ üô½6|¶¾ –¾, — þ ÿ þÿF ü ü à ÿË €Ö De—�è× ÿÅD�E —�Q Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ü ü à ÿË €Ö De—�è× —ÅD 0 0 ‚ 4² 5æ `::+d¼þ —ÅD�E { ˜ ¡ ™ ˜ ™ ƾ { ÍìÊÀ ʾ ‚� ; :ÊÀ ¬ŒÀ Â�EÅD T®À
|
|||
|
|
–ÅDÊÀ�E$Ú¾²<è¾æ ˆ¿«š ˜¿£,¨¿ƒ…qs uw ü˜Õ� üœÁ`¢û ü�Â^Œü üäÂGôü °Ãú ü¸Ã^ [ Unlike [`compare_and_set`], this method is allowed to spuriously fail even when comparisonÁ ü›Ä_ù� üÿÄZã‘ üÞÅTÈ’ ·Æú ü¿ÆU�¶ ü™Ç ï¶ ½Çú üÅÇ0 - [`compare_and_set`]: Atomic::compare_and_setÁ úÇú ü‚È* ' # Migrating to `compare_exchange_weak`Á ±Èú ü¹Èb _ `compare_and_set_weak` is equivalent to `compare_exchange_weak` with the following mapping forÁ ¬ ÉŸ ºÉú üÂÉ ò¸ üçÉ �¹ üŒÊ ȹ ü±Ê ó¹ üÖÊ žº üûÊ Éº ü Ë ôº ÄËú tÌËÖÛ ßËú <çË©¼ ÜóËÓ» ü“Ì@À… üØÌ,·å ‰Íú ô‘Í¼Ü ô´Í…æ ×Íú üßÍ#€– ü‡Î(®– ü´ÎHá– T�ϳ— ü�Ï? < match a.compare_and_set_weak(ptr, new, SeqCst, guard) {Á ´ÔÏš˜ ÄïϺ˜ ´ŒÐܘ l§Ðü˜ ̹Г™ ü×Ð"·™ ôþÐã™ l¡Ñü˜ L³Ñ™š ,ÁѬš ËÑú üÓÑ)Éš T�Ò³— ü�ÒK H match a.compare_and_set_weak(curr, Shared::null(), SeqCst, guard) {Á ÜàÒé› ü€Ó+�œ L°Ó™š ,¾Ó¬š üÈÓ7ˆ <„Ô©¼ #Use `compare_exchange_weak` insteadÁüìÔ% üØÔ;¤ŸÕ „Í, › € � €ÿF ü ü à ÿË €Ö De—�è× �ÅD�EÊÀ ›�Q Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ü ü à ÿË €Ö De—�è× ›ÅD 0 0 ‚ 4² 5æ `::+d¼þ ›ÅD�E { œ ¡ � œ � ´Õ { Þ ¸Õ ‚� »Õ ù¬úÖ ‰ÃTœ×
|
|||
|
|
šÅDÊÀ�E$ÈÕ²<ÖÕæ öÕ«š †Ö£,–Öik`b df üãÝU ü�Ø' $ Bitwise "and" with the current tag.Á »Øú üÃØ^ [ Performs a bitwise "and" operation on the current tag and the argument `val`, and sets theÁ ü¦Ù8 5 new tag to the result. Returns the previous pointer.Á ãÙú üëÙZÏã tÊÚ²ä ÝÚú tåÚÖÛ øÚú <€Û©¼ üŒÛ9ª÷ üÊÛ,·å ûÛú ü
|
|||
|
|
` £c—¢ ` àB¤GS
|
|||
|
|
‡¾£ ¦ ß‚ ¦
|
|||
|
|
¨ÅD$à‚± æ‚üü„6 ¥ ª ª „³ �… ”³L�…ÿF« Ïc « ü¹…8 ¼… ˆ ‰ Š ˆÿF ‰ c c ˆ ¢cµ
|
|||
|
|
` £c—¢ ` àB¤GS
|
|||
|
|
Š¾£ © À… ©
|
|||
|
|
«ÅD$Á…± Ç…ü•‡/ ¥ „³ š‡ ”³L¦‡ÿF® Ù ® ¼úˆ üˇ' $ Returns a copy of the atomic value.Á ÷‡ú üÿ‡[ X Note that a `Relaxed` load is used here. If you need synchronization, use it with otherÁ ´ßˆ atomics or fences.Á,ýˆ ‹ ‹ÿF ÿF ¬ ƒ‰ ¬
|
|||
|
|
®ÅD$„‰üô‰1 ¥ ° ° „³ ù‰ ”³L…ŠÿF± ´ ± ¤¬Š<¯Š ÿF ¯ ¯
|
|||
|
|
±ÅDüãŠ8 ¥ ³ ³ „³ èŠ ”³LôŠÿF´ ë ´ ü½� ü¢‹5 2 Returns a new atomic pointer pointing to `owned`.Á Ü‹ú tä‹ÖÛ ÷‹ú <ÿ‹©¼ ü‹Œ) & use crossbeam_epoch::{Atomic, Owned};Á ¹Œú üÁŒ2 / let a = Atomic::<i32>::from(Owned::new(1234));Á üøŒ4äÜ <±�©¼$À� ñGÿF ² ²
|
|||
|
|
´ÅD ownedÁ,Å�üÃŽ" ¥ ¶ ¶ Ç‘ ÈŽÿF· ë · ÔìŽ$ïŽ ¶HÿF µ µ
|
|||
|
|
·ÅD ôŽìµ� ¥ ¹ ¹ Ç‘ º�ÿFº ë º ¬Ù�$Ü� ÅDÿF ¸ ¸
|
|||
|
|
ºÅD¿ á�ü��A ë
|
|||
|
|
¼ ¥ ½ ½ ¼ ïž ˜� ‡ŸL¤�´I¾ ë ¾ ”�#% ü½’# ü×�3 0 Returns a new atomic pointer pointing to `ptr`.Á �‘ú t—‘ÖÛ ª‘ú <²‘©¼ ü¾‘* ' use crossbeam_epoch::{Atomic, Shared};Á í‘ú üõ‘7 4 let a = Atomic::<i32>::from(Shared::<i32>::null());Á <±’©¼$À’ êI´I » »
|
|||
|
|
¾ ë
|
|||
|
|
‡Eµ Å’ü�“$ ¥ À À Ç‘ ”“ÿFÁ ë Á ô©• üº“3 0 Returns a new atomic pointer pointing to `raw`.Á ò“ú tú“ÖÛ �”ú <•”©¼ Œ¡” use std::ptr;Á ü·” ‡Ü Ü”ú üä”4 1 let a = Atomic::<i32>::from(ptr::null::<i32>());Á <�•©¼$¬• µJÿF ¿ ¿
|
|||
|
|
ÁÅD@ ±•ü¯–( üú•4 1 A trait for either `Owned` or `Shared` pointers.Á <¹–  ¥ à  à īü¯–Ì ïž Á– ‡ŸLÍ–  ī- Ä«3ÄÅÄÅ Å Ä =? ì™— üÞ–6 3 Returns the machine representation of the pointer.ÁTœ— Ì«Ã`  Â
|
|||
|
|
ÄÌ«‡E$§—üÏ™* ü¼—@ = Returns a new pointer pointing to the tagged pointer `data`.Á �˜ú d‰˜³À š˜ú ü¢˜_ \ The given `data` should have been created by `Pointer::into_usize()`, and one `data` shouldÁ ü†™D A not be converted back by `Pointer::from_usize()` multiple times.ÁTÙ™ Ã`Ì«  Â
|
|||
|
|
ÅÌ«‡EË$ä™üâ›' üý™# An owned heap-allocated object.Á ¡šú ü¥š* ' This type is very similar to `Box<T>`.Á Кú üÔšb˜Ô ü·›* ' least significant bits of the address.Á ,í› ¥ Ç Ç „³ ó› ”³Lÿ›ñG $zF–Е5É ÈÉ Ü,. \�œ$�œ Æ Æ Ã`ä¡œ<¡œ Æ Æ • • – €c Fu\»Ÿ¶HüÂœ3 ¥ Ë Ë „³ Çœ ”³LÓœñGÌÍ Ä Å Ì Í ') äŠ�T�� ñGÃ` Ê Ê
|
|||
|
|
ÌÅD$˜�ü Ÿ) üú�@¨‹ ¿žú dÇž³å Øžú üàž- * Panics if the data is zero in debug mode.ÁTªŸ Ã`ñG Ê Ê
|
|||
|
|
ÍÅDË$µŸ„å ¥ Ï Ï Ç‘ ê ñGÐÑÒ üÚ¦/ üü 2 / Returns a new owned pointer pointing to `raw`.Á ³¡ú ü»¡\ Y This function is unsafe because improper use may lead to memory problems. Argument `raw`Á üœ¢] Z must be a valid pointer. Also, a double-free may occur if the function is called twice onÁ Ìþ¢ the same raw pointer.Á œ£ú d¤£³å µ£ú ü½£, ) Panics if `raw` is not properly aligned.Á î£ú dö£³À ‡¤ú ü�
|
|||
|
|
` £c—¢ ` àB¤GS
|
|||
|
|
�¾£ Ý �½ Ý
|
|||
|
|
ßÅD$‚½± ˆ½üí¾! ¥ á á Ç‘ ò¾ ØÅD ,õ¾ñGâ Ù â #% ¼•¿,˜¿ ‘ ‘ñG ñG à ž¿ à
|
|||
|
|
âÅD$Ÿ¿üò¿. ¥ ä ä „³ ÷¿ ”³LƒÀñGåæ ê! ë! æ #% \§À4¬À ã ã ÅD¬½À,ÀÀ ’ ’ñG ’ÅD ã ÆÀ ã
|
|||
|
|
æÅD$ÇÀüµÁ1 ¥ è è „³ ºÁ ”³LÆÁñGé ÷! é üíÁ!LðÁ “ “ñG “ÅD ç úÁ ç
|
|||
|
|
éÅD$ÿÁäõ ¥ ë ë Ç‘ úÂñGì ë ì ¬˜Ã$›Ã ÅDñG ê ê
|
|||
|
|
ìÅD¿ ÃüÏÃ! ¥ î î Ç‘ ÔÃñGï ë ï ÔÂÆ ü÷Ã0 - Returns a new owned pointer pointing to `b`.Á ¬Äú d´Ä³å ÅÄú üÍÄ> ; Panics if the pointer (the `Box`) is not properly aligned.Á �Åú t˜ÅÖÛ «Åú <³Å©¼ ü¿Å á¼ ãÅú üëÅFò™ <¶Æ©¼$ÅÆ ¶HñG í í
|
|||
|
|
ïÅD ÊÆüœÇ2 ¥ ñ ñ „³ ¡Ç ”³LÇñGò ¢ ò ´ÕÇ4ØÇ ” ”ñG ”ÅD ð ßÇ ð
|
|||
|
|
òÅD$àÇüŒÈ5 ¥ ô ô „³ ‘È ”³L�ÈñGõ ¥ õ üÈÈ"TËÈ • •ñG •ÅD ó ÖÈ ó
|
|||
|
|
õÅD$ÛÈü�É1 ¥ ÷ ÷ „³ ”É ”³L ÉñGø â ø ´ÇÉ4ÊÉ – –ñG –ÅD ö ÑÉ ö
|
|||
|
|
øÅD$ÒÉüþÉ1 ¥ ú ú „³ ƒÊ ”³L�ÊñGû å û ô¶Ê4¹Ê — —ñG —ÅD ù ÀÊ ù
|
|||
|
|
ûÅD$ÅÊü…Í1 üùÊ5 2 A pointer to an object protected by the epoch GC.Á ¯Ëú ü³Ë? < The pointer is valid for use only during the lifetime `'g`.Á óËú ü÷Ëb˜Ô üÚÌ*®� 4�Í ë
|
|||
|
|
ý ¥ þ ý þ ïž ›Í §Ÿ0O ‡ŸL¬ÍêI De—�è× ÿ€—Í79 ý\½Í$½Í ü ü Ã`üÎÍ(<ÎÍ ü ü • • – €c Fu\»Ÿ ë
|
|||
|
|
�e ¯LüûÍ3 8 ˜ ¥ ‚ ‚ ˜ ïž €Î ‡ŸLŒÎÎKƒ Ù ƒ ¼µÎ,¸Î ™ ™ÎK ÎK � ¾Î �
|
|||
|
|
ƒ 8‡E$¿ÎüæÎ2 8 š ¥ … š … ïž ëÎ ‡ŸL÷ÎÎK ü�Ï8 8 › ¥ ‡ › ‡ ïž ¢Ï ‡ŸL®ÏÎKˆ‰ Ä Å ˆ ‰ ') äêÏTíÏ ÎKÃ` † †
|
|||
|
|
ˆ 8‡E$øÏü´Ð)T¾Ð Ã`ÎK † †
|
|||
|
|
‰ 8‡EË$ÉÐÌ¸Ñ ë
|
|||
|
|
‹ ¥ Œ ‹ Œ òœ ÁÑêI� ½Ñ üàÕ üØÑ< 9 Converts the pointer to a raw pointer (without the tag).Á ™Òú t¡ÒÖÛ ´Òú <¼Ò©¼ üÈÒ8 5 use crossbeam_epoch::{self as epoch, Atomic, Owned};Á ü…Ó,·å ¶Óú ì¾Ó œ ôàÓ let raw = &*o as *const _;Á äƒÔ let a = Atomic::from(o);Á ¤Ôú ô¬Ô…æ üÏÔ"æ üöÔ assert_eq!(p.as_raw(), raw);Á ü›Õ4äÜ <ÔÕ©¼4çÕ œ œêI ¯L Š îÕ Š
|
|||
|
|
� ë
|
|||
|
|
‡E$ïÕüÚÖ- ë
|
|||
|
|
� ¥ � � � ïž ãÖ ‡ŸLïÖêI‘’“”•–—˜™ ßÖ35 ôßØ üŽ× Returns a new null pointer.Á ²×ú tº×ÖÛ Í×ú <Õש¼ üá× use crossbeam_epoch::Shared;Á †Øú üŽØ" let p = Shared::<i32>::null();Á ÌµØ assert!(p.is_null());Á <ÓØ©¼$æØ êI Ž Ž
|
|||
|
|
‘ ë
|
|||
|
|
‡EìÉÝ üÝÙ* ' Returns `true` if the pointer is null.Á ŒÚú t”ÚÖÛ §Úú <¯Ú©¼ ü»Ú8ÈÆ üøÚ,·å ©Ûú Ü±Û let a = Atomic::null();Á ôÑÛ…æ
|
|||
|
|
,ä›ü¥œ0 8 ¦ ¥ ¢ ¦ ¢ ïž ªœ ‡ŸL¶œÎK üÚœK ë
|
|||
|
|
¤ ¥ ¥ ¤ ¥ ïž ãœ ‡ŸLïœêI¦ ïß ¦ ßœ$& ü¬�<\¯� § ¨ §êI ¨êI ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ¿ßÀßÁß LessÁ Âß ÃßÄß~ Åß ÆßÇß GreaterÁ Èß åºÝÈnûê7 £ »� £
|
|||
|
|
¦ ë
|
|||
|
|
‡E$¼�¹
|
|||
|
|
,Â�üŸž1 8 © ¥ ¨ © ¨ ïž ¤ž ‡ŸL°žÎK© » © üמ, Úž ª « ªÎK «ÎK ׃ § Þž §
|
|||
|
|
© 8‡E$ßž¹
|
|||
|
|
,åžü²Ÿ8 8 ¬ ¥ « « ¬ ïž ·Ÿ ‡ŸLßÎK¬ Àc ¬ üñŸ8 ôŸ ® ¯ ÎK ® c c ˆ ¢cµ
|
|||
|
|
` £c—¢ ` àB¤GS
|
|||
|
|
¯¾£ ª øŸ ª
|
|||
|
|
¬ 8‡E$ùŸ± ÿŸüå¡: 8 ° ¥ ® ° ® ïž ê¡ ‡ŸLö¡ÎK¯ Ïc ¯ ü¦¢8 ©¢ ± ² ³ ±ÎK ² c c ˆ ¢cµ
|
|||
|
|
` £c—¢ ` àB¤GS
|
|||
|
|
³¾£ ¢
|
|||
|
|
¯ 8‡E$®¢± ´¢üÒ£5 8 ´ ¥ ± ´ ± ïž ×£ ‡ŸLã£ÎK² ´ ² ¤Ž¤<‘¤ ÎK ° °
|
|||
|
|
² 8‡El‘, »¤Œá+ óµ Ìô+ üà+. ü×+9 L•, ºÊ× ³ ` ³ ´—$,Ë ‰ ³ µÕ)4è â ³ ·ß*,ð í ³ ¸K ” †J ³ ¹ Llœ½]|ÖNP=?Üü1¤À üš% " An epoch-based garbage collector.Á LË ŠM ÉÈ\Ácä »ôÛ4æ º º †J†J K ‰Jµ �7 ŠJ phantomÁ�7 ‹J¤�7 ·0ØQd�è â â Õ) ãã) ¬ äñ) ¬ åÅ" Ï�ÝJv »& úHôþ ŠM ô ŠM Ôà ŠM¿ ´ ¿ ¤ä<ç ŠM ¾ ¾
|
|||
|
|
¿ tÊ ŠMÁ ¤€ äß Creates a new collector.Á ‡ ŠM À À
|
|||
|
|
Á üì% üº- * Registers a new handle for the collector.ÁDó µ µŠM þM À ü À
|
|||
|
|
 $ýÄ» ŠMÄ Ù Ä ¼› üÚ< 9 Creates another reference to the same garbage collector.Á,ž ¶ ¶ŠM ŠM à ¤ Ã
|
|||
|
|
Ä $¥ì… ŠMÆ Àc Æ ü© 8 ¬ · ¸ ¹ ·ŠM ¸ c c ˆ ¢cµ
|
|||
|
|
` £c—¢ ` àB¤GS
|
|||
|
|
¹¾£ Å ° Å
|
|||
|
|
Æ $± ± · ä�
|
|||
|
|
ŠMÈ ·ß È üî
|
|||
|
|
% ü²
|
|||
|
|
7 4 Checks if both handles point to the same collector.Áñ
|
|||
|
|
º » ºŠM »ŠM Ç ô
|
|||
|
|
Ç
|
|||
|
|
È $õ
|
|||
|
|
rhsÁ û
|
|||
|
|
¬Í ŠM ´Œ üç $ ! A handle to a garbage collector.Á \— þM D_ú6xƒgt Ë Ñô© ,´ Ê Ê €r„Ì þMÍÎÏ ÔŠ
|
|||
|
|
¤ã Pins the handle.Á ‘
|
|||
|
|
¼ ¼þM �Q Ì •
|
|||
|
|
Ì
|
|||
|
|
Í $–
|
|||
|
|
ü— üÙ
|
|||
|
|
+ ( Returns `true` if the handle is pinned.ÁLž ½ ½þM Ì ¨ Ì
|
|||
|
|
Î $©ü¼% üñ8 5 Returns the `Collector` associated with this handle.ÁLà ¾ ¾þM ¾ŠM Ì Í Ì
|
|||
|
|
Ï $ÎÌš þMÑ �" Ñ ”È$Ë ¿ ¿þM�e Ð Ð Ð
|
|||
|
|
Ñ $Õü² þMÓ Àc Ó üØ8 Û À Á  ÀþM Á c c ˆ ¢cµ
|
|||
|
|
` £c—¢ ` àB¤GS
|
|||
|
|
¾£ Ò ß Ò
|
|||
|
|
Ó $à± ædÚ, »¤Œª, óµ ̽, ü©,. ü ,9 DÞ, ÜÝßÄG � Ô Õ× ! ` Ô Ö€c\8 • Ô ×€c – Ô ×í$U ë Ô Ù±E\[ ÑÛ Ô Úµ s “ Ô ÛŒŽLÌ*pLIL O=?Lm/¼ôTúÔ Ã`LË$ÐÔ Ã` Þ Tß Ã`Ô• D§ ¼N Ì�¡÷—ì= àáâĶ$¶Ô ß ß ‰e¼Ô$ÔÔ ß ß ÑÛÑÛ ±E ÓÛÆEÝ ÔÛ»Ý Íõƒ«%9— ìñ<ñÔ ß ß “gä¤ ¼Nä Àc ä üÇC Ê Ã Ä Å Ã¼N Ä c c ˆ ¢cµ
|
|||
|
|
` £c—¢ ` àB¤GS
|
|||
|
|
ž£ ã Î ã
|
|||
|
|
ä $ϱ Õl· ¼Næèî äË,Ü å å ¼NäôT÷ Ô Œe�e „e _rawÁ$‚üÙ , ç —¼N å — é é å ÍìϤ ë –"Ϥ�e Dî Ϥ�e˜" �e
|
|||
|
|
èϤ± ø ;= üÍ )$× Ô Œe�e — ë ë ÷¤ Ü ˆ¥Dß ›¥
|
|||
|
|
êϤ@ é "$ üÊ)$Ô Ô Œe�e — í í ÷¤ Ù ˆ¥DÜ ›¥
|
|||
|
|
ìϤ@ æ"$ äì$ú ¼N�e å å
|
|||
|
|
î $ƒL¢- »¤Œò, óµ Ì…- üñ,. üè,9 ,¦- ñò󹪮D’ ¼À ï ðüò(¤· ó� Äœü– |¼ï ¤]¤] V ¦]Á‚] üß3ø¤”&t„ ó� Äéüã L‰ï ¤ù ó� ÄÞüØ |þï Tú ‰Oõö÷øùú üÏ
|
|||
|
|
DÝ
|
|||
|
|
‰O ô ô
|
|||
|
|
õ ü†>d” ‰O‰O ô ô
|
|||
|
|
ö $¡‹– §üÛ%Lé ‰O ô ô
|
|||
|
|
÷ $óüï#4ý ‰O‰O ô ô
|
|||
|
|
ø $„ü¡%D¯ ‰O‰O ô ô
|
|||
|
|
ù $¸ü¥&L³ ‰O‰O ô ô
|
|||
|
|
ú $½„£ ‰Püýþÿ üì' ú ‰O‰P û û
|
|||
|
|
ü Å",þü§ 1$µ Æ Æ‰P ™E‰O û º û
|
|||
|
|
ý $» «š Á üã 7,ñ Ç Ç‰P ‰O™E�e û ÷ û
|
|||
|
|
þ $ø Å",þ «š Œ ü¬'®„º' È È‰P ‰O‰O™E™EÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
‰O‰O û Ô' û
|
|||
|
|
ÿ $Õ'²<ã'æ û'ü<�(Š<ª(Lç- »¤Œ·- óµ ÌÊ- ü¶-. ü-9 ,ë- ‰¦×
|
|||
|
|
|
|||
|
|
` € �í
|
|||
|
|
ë € ‚¢L3
|
|||
|
|
K € „Ã4>
|
|||
|
|
ü € …‡ L]
|
|||
|
|
º € †µ!D}
|
|||
|
|
ß € ‡ß*,œ
|
|||
|
|
í € ˆL
|
|||
|
|
ŒL
|
|||
|
|
}l#
|
|||
|
|
np_aÜK
|
|||
|
|
RÌl
|
|||
|
|
C´‹
|
|||
|
|
5„‚
|
|||
|
|
ü¤1
|
|||
|
|
. A guard that keeps the current thread pinned.Á Ö
|
|||
|
|
ú lÚ
|
|||
|
|
Œƒ è
|
|||
|
|
ú üìO
|
|||
|
|
L The current thread is pinned by calling [`pin`], which returns a new guard:Á ¼
|
|||
|
|
ú <À
|
|||
|
|
©¼ üÈ!
|
|||
|
|
use crossbeam_epoch as epoch;Á ê
|
|||
|
|
ú üîb
|
|||
|
|
_ // It is often convenient to prefix a call to `pin` with a `&` in order to create a reference.Á üÑ\
|
|||
|
|
Y // This is not really necessary, but makes passing references to the guard a bit easier.Á ô®
|
|||
|
|
…æ <Í
|
|||
|
|
©¼ Õ
|
|||
|
|
ú üÙL
|
|||
|
|
I When a guard gets dropped, the current thread is automatically unpinned.Á ¦
|
|||
|
|
ú ܪ
|
|||
|
|
# Pointers on the stackÁ Æ
|
|||
|
|
ú üÊW
|
|||
|
|
T Having a guard allows us to create pointers on the stack to heap-allocated objects.Á „¢
|
|||
|
|
|
|||
|
|
For example:Á ³
|
|||
|
|
ú <·
|
|||
|
|
©¼ ü¿1
|
|||
|
|
üä üñ,
|
|||
|
|
·å ž
|
|||
|
|
ú ü¢&
|
|||
|
|
# // Create a heap-allocated number.Á ìÉ
|
|||
|
|
let a = Atomic::new(777);Á ç
|
|||
|
|
ú ôë
|
|||
|
|
// Pin the current thread.Á ôŠ
|
|||
|
|
…æ ©
|
|||
|
|
ú üJ
|
|||
|
|
G // Load the heap-allocated object and create pointer `p` on the stack.Á üø"
|
|||
|
|
æ ›
|
|||
|
|
ú üŸ 3
|
|||
|
|
0 // Dereference the pointer and print the value:Á üÓ .
|
|||
|
|
+ if let Some(num) = unsafe { p.as_ref() } {Á ü‚
|
|||
|
|
+
|
|||
|
|
( println!("The number is {}.", num);Á ,®
|
|||
|
|
|
|||
|
|
¬š ü´
|
|||
|
|
4
|
|||
|
|
äÜ <é
|
|||
|
|
|
|||
|
|
©¼ ñ
|
|||
|
|
|
|||
|
|
ú ¬õ
|
|||
|
|
|
|||
|
|
# Multiple guardsÁ ‹
|
|||
|
|
ú ü� _
|
|||
|
|
\ Pinning is reentrant and it is perfectly legal to create multiple guards. In that case, theÁ üï b
|
|||
|
|
_ thread will actually be pinned only when the first guard is created and unpinned when the lastÁ œÒ
|
|||
|
|
one is dropped:Á æ
|
|||
|
|
ú <ê
|
|||
|
|
©¼ üò !
|
|||
|
|
Û³ ”
|
|||
|
|
ú ô˜
|
|||
|
|
let guard1 = epoch::pin();Á ô·
|
|||
|
|
let guard2 = epoch::pin();Á üÖ
|
|||
|
|
|
|||
|
|
assert!(epoch::is_pinned());Á Œ÷
|
|||
|
|
drop(guard1);Á ü‰
|
|||
|
|
á¿ Œª
|
|||
|
|
drop(guard2);Á ü¼!
|
|||
|
|
assert!(!epoch::is_pinned());Á <Þ
|
|||
|
|
©¼ æ
|
|||
|
|
ú ¼ê
|
|||
|
|
[`pin`]: super::pinÁ ,�
|
|||
|
|
�Q þšl{ÈÅ0 Š £ô™
|
|||
|
|
,¤
|
|||
|
|
‰ ‰ €rT¼
|
|||
|
|
�QŒ�“–—˜ üÚ^
|
|||
|
|
üÍY
|
|||
|
|
V Stores a function so that it can be executed at some point after all currently pinnedÁ Ì«
|
|||
|
|
threads get unpinned.Á É
|
|||
|
|
ú üÑ]
|
|||
|
|
Z This method first stores `f` into the thread-local (or handle-local) cache. If this cacheÁ ü³X
|
|||
|
|
U becomes full, some functions are moved into the global cache. At the same time, someÁ ü�Z
|
|||
|
|
W functions from both local and global caches may get executed in order to incrementallyÁ üï(
|
|||
|
|
% clean up the caches as they fill up.Á œ
|
|||
|
|
ú ü¤Z
|
|||
|
|
W There is no guarantee when exactly `f` will be executed. The only guarantee is that itÁ üƒ[
|
|||
|
|
X won't be executed until all currently pinned threads get unpinned. In theory, `f` mightÁ üãW
|
|||
|
|
T never run, but the epoch-based garbage collection will make an effort to execute itÁ ¤¿
|
|||
|
|
reasonably soon.Á Ø
|
|||
|
|
ú üàW
|
|||
|
|
T If this method is called from an [`unprotected`] guard, the function will simply beÁ ̼
|
|||
|
|
executed immediately.Á,á
|
|||
|
|
É É�Q Ϥ�e ‹ — � £ Ž � Ž í
|
|||
|
|
‹ ÷¤ ç
|
|||
|
|
œ“ ê
|
|||
|
|
ˆ¥l�
|
|||
|
|
Ϥ�e˜" é’ ›
|
|||
|
|
ÌìϤ $©
|
|||
|
|
Ϥ<°
|
|||
|
|
|
|||
|
|
ŒÏ¤é’$î
|
|||
|
|
± ô
|
|||
|
|
bd gi üÝ8T
|
|||
|
|
üŠY
|
|||
|
|
 Ìè
|
|||
|
|
‚Ã †
|
|||
|
|
ú üŽ]
|
|||
|
|
±Ã üðX
|
|||
|
|
˜Ä üÍZ
|
|||
|
|
úÄ ü¬(
|
|||
|
|
ÞÅ Ù
|
|||
|
|
ú üáZ
|
|||
|
|
œÆ üÀ [
|
|||
|
|
€Ç ü W
|
|||
|
|
åÇ ¤ü
|
|||
|
|
ÅÈ •
|
|||
|
|
ú ü� W
|
|||
|
|
ïÈ Ìù
|
|||
|
|
ÏÉ —
|
|||
|
|
ú dŸ
|
|||
|
|
³À °
|
|||
|
|
ú ü¸ \
|
|||
|
|
Y The given function must not hold reference onto the stack. It is highly recommended thatÁ ü™ W
|
|||
|
|
T the passed function is **always** marked with `move` in order to prevent accidentalÁ dõ
|
|||
|
|
borrows.Á †!
|
|||
|
|
ú <Ž!
|
|||
|
|
©¼ üš!!
|
|||
|
|
Û³ À!
|
|||
|
|
ú ôÈ!
|
|||
|
|
…æ Üë!
|
|||
|
|
let message = "Hello!";Á d‹"
|
|||
|
|
ÙØ üœ"K
|
|||
|
|
H // ALWAYS use `move` when sending a closure into `defer_unchecked`.Á üì"'
|
|||
|
|
$ guard.defer_unchecked(move || {Á ü˜#$
|
|||
|
|
! println!("{}", message);Á \Á#
|
|||
|
|
});Á ,Ñ#
|
|||
|
|
¬š <Û#
|
|||
|
|
©¼ ç#
|
|||
|
|
ú üï#^
|
|||
|
|
[ Apart from that, keep in mind that another thread may execute `f`, so anything accessed byÁ üÒ$
|
|||
|
|
the closure must be `Send`.Á ö$
|
|||
|
|
ú üþ$_
|
|||
|
|
\ We intentionally didn't require `F: Send`, because Rust's type systems usually cannot proveÁ üâ%\
|
|||
|
|
Y `F: Send` for typical use cases. For example, consider the following code snippet, whichÁ üÃ&Y
|
|||
|
|
V exemplifies the typical use case of deferring the deallocation of a shared reference:Á ¡'
|
|||
|
|
ú l©'
|
|||
|
|
|
|||
|
|
```ignoreÁ ü»'5
|
|||
|
|
2 let shared = Owned::new(7i32).into_shared(guard);Á üõ'R
|
|||
|
|
O guard.defer_unchecked(move || shared.into_owned()); // `Shared` is not `Send`!Á <Ì(
|
|||
|
|
©¼ Ø(
|
|||
|
|
ú üà(]
|
|||
|
|
Z While `Shared` is not `Send`, it's safe for another thread to call the deferred function,Á üÂ)_
|
|||
|
|
\ because it's called only after the grace period and `shared` is no longer shared with otherÁ ü¦*<
|
|||
|
|
9 threads. But we don't expect type systems to prove this.Á ç*
|
|||
|
|
ú tï*
|
|||
|
|
ÖÛ ‚+
|
|||
|
|
ú üŠ+V
|
|||
|
|
S When a heap-allocated object in a data structure becomes unreachable, it has to beÁ üå+^
|
|||
|
|
[ deallocated. However, the current thread and other threads may be still holding referencesÁ üÈ,`
|
|||
|
|
] on the stack to that same object. Therefore it cannot be deallocated before those referencesÁ ü-\
|
|||
|
|
Y get dropped. This method can defer deallocation until all those threads get unpinned andÁ üŽ.8
|
|||
|
|
5 consequently drop all their references on the stack.Á Ë.
|
|||
|
|
ú <Ó.
|
|||
|
|
©¼ üß.8
|
|||
|
|
ÈÆ üœ/,
|
|||
|
|
·å Í/
|
|||
|
|
ú üÕ/
|
|||
|
|
let a = Atomic::new("foo");Á ù/
|
|||
|
|
ú ü�0M
|
|||
|
|
J // Now suppose that `a` is shared among multiple threads and concurrentlyÁ üÓ0
|
|||
|
|
// accessed and modified...Á ÷0
|
|||
|
|
ú ôÿ0
|
|||
|
|
¸¹ ô¢1
|
|||
|
|
…æ Å1
|
|||
|
|
ú üÍ1M
|
|||
|
|
J // Steal the object currently stored in `a` and swap it with another one.Á üŸ2H
|
|||
|
|
E let p = a.swap(Owned::new("bar").into_shared(guard), SeqCst, guard);Á ì2
|
|||
|
|
ú ¬ô2
|
|||
|
|
if !p.is_null() {Á üŽ3<
|
|||
|
|
9 // The object `p` is pointing to is now unreachable.Á üÏ3R
|
|||
|
|
O // Defer its deallocation until all currently pinned threads get unpinned.Á „¦4
|
|||
|
|
|
|||
|
|
unsafe {Á ü»4O
|
|||
|
|
L // ALWAYS use `move` when sending a closure into `defer_unchecked`.Á ü�5+
|
|||
|
|
( guard.defer_unchecked(move || {Á ü¿5D
|
|||
|
|
A println!("{} is now being deallocated.", p.deref());Á üˆ6\
|
|||
|
|
Y // Now we have unique access to the object pointed to by `p` and can turn itÁ üé6T
|
|||
|
|
Q // into an `Owned`. Dropping the `Owned` will deallocate the object.Á üÂ7%
|
|||
|
|
" drop(p.into_owned());Á |ì7
|
|||
|
|
});Á L€8
|
|||
|
|
™š ,Ž8
|
|||
|
|
¬š ü˜84
|
|||
|
|
äÜ <Ñ8
|
|||
|
|
©¼|ë8
|
|||
|
|
Ê Ê�Q Ϥ�e ‹ — � £ ‘ ‘ � �9
|
|||
|
|
‹ ÷¤ û8
|
|||
|
|
œ“ þ8
|
|||
|
|
ˆ¥l£9
|
|||
|
|
åË ¯9
|
|||
|
|
|
|||
|
|
�Ϥé’$‚9
|
|||
|
|
± ˆ9
|
|||
|
|
8: =? <‘:
|
|||
|
|
�ìŒ ’ …� ’ £� ’ ’ � ’Ï¤é’ �e�e Ϥü¨UM
|
|||
|
|
üé:]
|
|||
|
|
Z Stores a destructor for an object so that it can be deallocated and dropped at some pointÁ üË;4
|
|||
|
|
1 after all currently pinned threads get unpinned.Á „<
|
|||
|
|
ú üŒ<]
|
|||
|
|
Z This method first stores the destructor into the thread-local (or handle-local) cache. IfÁ üî<Z
|
|||
|
|
W this cache becomes full, some destructors are moved into the global cache. At the sameÁ üÍ=Y
|
|||
|
|
V time, some destructors from both local and global caches may get executed in order toÁ ü«>6
|
|||
|
|
3 incrementally clean up the caches as they fill up.Á æ>
|
|||
|
|
ú üî>]
|
|||
|
|
Z There is no guarantee when exactly the destructor will be executed. The only guarantee isÁ üÐ?]
|
|||
|
|
Z that it won't be executed until all currently pinned threads get unpinned. In theory, theÁ ü²@]
|
|||
|
|
Z destructor might never run, but the epoch-based garbage collection will make an effort toÁ ü”A
|
|||
|
|
execute it reasonably soon.Á ¸A
|
|||
|
|
ú üÀAY
|
|||
|
|
V If this method is called from an [`unprotected`] guard, the destructor will simply beÁ ÌžB
|
|||
|
|
ÏÉ ¼B
|
|||
|
|
ú dÄB
|
|||
|
|
³À ÕB
|
|||
|
|
ú üÝB]
|
|||
|
|
Z The object must not be reachable by other threads anymore, otherwise it might be still inÁ ü¿C!
|
|||
|
|
use when the destructor runs.Á åC
|
|||
|
|
ú üíC_
|
|||
|
|
\ Apart from that, keep in mind that another thread may execute the destructor, so the objectÁ üÑD&
|
|||
|
|
# must be sendable to other threads.Á üD
|
|||
|
|
ú ü„E_
|
|||
|
|
\ We intentionally didn't require `T: Send`, because Rust's type systems usually cannot proveÁ üèE\
|
|||
|
|
Y `T: Send` for typical use cases. For example, consider the following code snippet, whichÁ üÉFY
|
|||
|
|
ñÔ §G
|
|||
|
|
ú l¯G
|
|||
|
|
ßÕ üÁG5
|
|||
|
|
öÕ üûG;
|
|||
|
|
8 guard.defer_destroy(shared); // `Shared` is not `Send`!Á <»H
|
|||
|
|
©¼ ÇH
|
|||
|
|
ú üÏH^
|
|||
|
|
[ While `Shared` is not `Send`, it's safe for another thread to call the destructor, becauseÁ ü²IW
|
|||
|
|
T it's called only after the grace period and `shared` is no longer shared with otherÁ üŽJ<
|
|||
|
|
úØ ÏJ
|
|||
|
|
ú t×J
|
|||
|
|
ÖÛ êJ
|
|||
|
|
ú üòJV
|
|||
|
|
åÙ üÍK^
|
|||
|
|
ÅÚ ü°L`
|
|||
|
|
Û ü•M\
|
|||
|
|
—Ü üöM8
|
|||
|
|
ýÜ ³N
|
|||
|
|
ú <»N
|
|||
|
|
©¼ üÇN8
|
|||
|
|
ÈÆ ü„O,
|
|||
|
|
·å µO
|
|||
|
|
ú ü½O
|
|||
|
|
€Þ áO
|
|||
|
|
ú üéOM
|
|||
|
|
µÞ ü»P
|
|||
|
|
Œß ßP
|
|||
|
|
ú ôçP
|
|||
|
|
¸¹ ôŠQ
|
|||
|
|
…æ Q
|
|||
|
|
ú üµQM
|
|||
|
|
çß ü‡RH
|
|||
|
|
¾à ÔR
|
|||
|
|
ú ¬ÜR
|
|||
|
|
›á üöR<
|
|||
|
|
ºá ü·SR
|
|||
|
|
€â „ŽT
|
|||
|
|
Ûâ ü£T#
|
|||
|
|
guard.defer_destroy(p);Á LËT
|
|||
|
|
™š ,ÙT
|
|||
|
|
¬š üãT4
|
|||
|
|
äÜ <œU
|
|||
|
|
©¼l¶U
|
|||
|
|
Ë Ì Ë�Q ü ü à ÿË €Ö De—�è× ÌÅD�e ‹ ¥ ” ” ÛU
|
|||
|
|
‹ „³ ÄU
|
|||
|
|
”³LÐU
|
|||
|
|
|
|||
|
|
“ÅD$ÜU
|
|||
|
|
µ âU
|
|||
|
|
#% <•V
|
|||
|
|
“ìŒ • …� • £� • • “ •ÅD �eñG ØŽœÂ\
|
|||
|
|
ü»V_
|
|||
|
|
\ Clears up the thread-local cache of deferred functions by executing them or moving into theÁ ŒŸW
|
|||
|
|
global cache.Á µW
|
|||
|
|
ú ü½W^
|
|||
|
|
[ Call this method after deferring execution of a function if you want to get it executed asÁ ü XY
|
|||
|
|
V soon as possible. Flushing will make sure it is residing in the global cache, so thatÁ üþXD
|
|||
|
|
A any thread has a chance of taking the function and executing it.Á ÇY
|
|||
|
|
ú üÏY\
|
|||
|
|
Y If this method is called from an [`unprotected`] guard, it is a no-op (nothing happens).Á °Z
|
|||
|
|
ú t¸Z
|
|||
|
|
ÖÛ ËZ
|
|||
|
|
ú <ÓZ
|
|||
|
|
©¼ üßZ!
|
|||
|
|
Û³ …[
|
|||
|
|
ú ô�[
|
|||
|
|
…æ Ì°[
|
|||
|
|
guard.defer(move || {Á üÎ[@
|
|||
|
|
= println!("This better be printed as soon as possible!");Á <“\
|
|||
|
|
});Á ”Ÿ\
|
|||
|
|
guard.flush();Á <¶\
|
|||
|
|
©¼,É\
|
|||
|
|
Í Í�Q �e ‹ Ï\
|
|||
|
|
‹
|
|||
|
|
– $Ð\
|
|||
|
|
¼Šf
|
|||
|
|
üÊ]3
|
|||
|
|
0 Unpins and then immediately re-pins the thread.Á ‚^
|
|||
|
|
ú üŠ^Z
|
|||
|
|
W This method is useful when you don't want delay the advancement of the global epoch byÁ üé^^
|
|||
|
|
[ holding an old epoch. For safety, you should not maintain any guard-based reference acrossÁ üÌ_^
|
|||
|
|
[ the call (the latter is enforced by `&mut self`). The thread will only be repinned if thisÁ ü¯`4
|
|||
|
|
1 is the only active guard for the current thread.Á è`
|
|||
|
|
ú üð`]
|
|||
|
|
Z If this method is called from an [`unprotected`] guard, then the call will be just no-op.Á Òa
|
|||
|
|
ú tÚa
|
|||
|
|
ÖÛ ía
|
|||
|
|
ú <õa
|
|||
|
|
©¼ ü�b1
|
|||
|
|
üä ü·b,
|
|||
|
|
·å èb
|
|||
|
|
ú ìðb
|
|||
|
|
†¹ ü’c!
|
|||
|
|
let mut guard = epoch::pin();Á ,¸c
|
|||
|
|
{Á üÂc'
|
|||
|
|
$ let p = a.load(SeqCst, &guard);Á üîc6
|
|||
|
|
3 assert_eq!(unsafe { p.as_ref() }, Some(&777));Á ,©d
|
|||
|
|
¬š ”³d
|
|||
|
|
guard.repin();Á ,Êd
|
|||
|
|
œ‹ üÔd'
|
|||
|
|
«‹ ü€e6
|
|||
|
|
Ü‹ ,»e
|
|||
|
|
¬š üÅe4
|
|||
|
|
äÜ <þe
|
|||
|
|
©¼,‘f
|
|||
|
|
Î Î�Q�e ‹ —f
|
|||
|
|
‹
|
|||
|
|
— $œf
|
|||
|
|
ü÷pR
|
|||
|
|
ü’g[
|
|||
|
|
X Temporarily unpins the thread, executes the given function and then re-pins the thread.Á òg
|
|||
|
|
ú üúg[
|
|||
|
|
X This method is useful when you need to perform a long-running operation (e.g. sleeping)Á üÚh`
|
|||
|
|
] and don't need to maintain any guard-based reference across the call (the latter is enforcedÁ ü¿i^
|
|||
|
|
[ by `&mut self`). The thread will only be unpinned if this is the only active guard for theÁ œ¢j
|
|||
|
|
current thread.Á ºj
|
|||
|
|
ú üÂj^
|
|||
|
|
[ If this method is called from an [`unprotected`] guard, then the passed function is calledÁ ü¥k*
|
|||
|
|
' directly without unpinning the thread.Á Ôk
|
|||
|
|
ú tÜk
|
|||
|
|
ÖÛ ïk
|
|||
|
|
ú <÷k
|
|||
|
|
©¼ üƒl1
|
|||
|
|
üä ü¹l,
|
|||
|
|
·å ¤êl
|
|||
|
|
use std::thread;Á äƒm
|
|||
|
|
use std::time::Duration;Á ¤m
|
|||
|
|
ú ì¬m
|
|||
|
|
†¹ üÎm!
|
|||
|
|
òŠ ,ôm
|
|||
|
|
œ‹ üþm'
|
|||
|
|
«‹ üªn6
|
|||
|
|
Ü‹ ,ån
|
|||
|
|
¬š üïnC
|
|||
|
|
@ guard.repin_after(|| thread::sleep(Duration::from_millis(50)));Á ,·o
|
|||
|
|
œ‹ üÁo'
|
|||
|
|
«‹ üío6
|
|||
|
|
Ü‹ ,¨p
|
|||
|
|
¬š ü²p4
|
|||
|
|
äÜ <ëp
|
|||
|
|
©¼\þp
|
|||
|
|
Ï Ï�QÏ¤é’ ‹ — ™ £ š ™ š �q
|
|||
|
|
‹ ÷¤ Šq
|
|||
|
|
œ“ �q
|
|||
|
|
ˆ¥l»q
|
|||
|
|
åË Çq
|
|||
|
|
|
|||
|
|
˜Ï¤é’$•q
|
|||
|
|
± ›q
|
|||
|
|
8: =? L8 T¤r
|
|||
|
|
€ ÈP Ê=*‘K”© œ � €rÈP ŸL89 € €rÈP › ›
|
|||
|
|
œ d¯r
|
|||
|
|
€ › › €rÄÆr
|
|||
|
|
ÈPŸ �" Ÿ ”ír
|
|||
|
|
$ðr
|
|||
|
|
Ð ÐÈP�e ž õr
|
|||
|
|
ž
|
|||
|
|
Ÿ $úr
|
|||
|
|
ü {-
|
|||
|
|
üŠw7
|
|||
|
|
4 Returns the `Collector` associated with this guard.Á Æw
|
|||
|
|
ú üÎwK
|
|||
|
|
H This method is useful when you need to ensure that all guards used withÁ üžx2
|
|||
|
|
/ a data structure come from the same collector.Á Õx
|
|||
|
|
ú üÝxT
|
|||
|
|
Q If this method is called from an [`unprotected`] guard, then `None` is returned.Á ¶y
|
|||
|
|
ú t¾y
|
|||
|
|
ÖÛ Ñy
|
|||
|
|
ú <Ùy
|
|||
|
|
©¼ üåy!
|
|||
|
|
Û³ ‹z
|
|||
|
|
ú ô“z
|
|||
|
|
’¿ ô¶z
|
|||
|
|
¹¿ üÙz6
|
|||
|
|
3 assert!(guard1.collector() == guard2.collector());Á <”{
|
|||
|
|
©¼L§{
|
|||
|
|
Ñ Ñ�Q ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ ÑŠM ‹ ±{
|
|||
|
|
‹
|
|||
|
|
$²{
|
|||
|
|
<ù{
|
|||
|
|
ìŒ ¡ …� ¡ £� ¡ ¡ ¡ S ŠM �eœŸ|
|
|||
|
|
�Q£ �" £ ”Ç|
|
|||
|
|
$Ê|
|
|||
|
|
Ò Ò�Q�e ¢ Ï|
|
|||
|
|
¢
|
|||
|
|
£ $Ô|
|
|||
|
|
ÌÈ}
|
|||
|
|
�Q¥ Àc ¥ üè}8
|
|||
|
|
ë}
|
|||
|
|
Ó Ô Õ Ó�Q Ô c c ˆ ¢cµ
|
|||
|
|
` £c—¢ ` àB¤GS
|
|||
|
|
Õ¾£ ¤ ï}
|
|||
|
|
¤
|
|||
|
|
¥ $ð}
|
|||
|
|
± ö}
|
|||
|
|
üœ•-
|
|||
|
|
üÊ~W
|
|||
|
|
T Returns a reference to a dummy guard that allows unprotected access to [`Atomic`]s.Á ¢
|
|||
|
|
ú ü¦_
|
|||
|
|
\ This guard should be used in special occasions only. Note that it doesn't actually keep anyÁ ü†€Y
|
|||
|
|
V thread pinned - it's just a fake guard that allows loading from [`Atomic`]s unsafely.Á à€
|
|||
|
|
ú üä€]
|
|||
|
|
Z Note that calling [`defer`] with a dummy guard will not defer the function - it will justÁ üÂ�%
|
|||
|
|
" execute the function immediately.Á è�
|
|||
|
|
ú üì�`
|
|||
|
|
] If necessary, it's possible to create more dummy guards by cloning: `unprotected().clone()`.Á Í‚
|
|||
|
|
ú dÑ‚
|
|||
|
|
³À Þ‚
|
|||
|
|
ú üâ‚Z
|
|||
|
|
W Loading and dereferencing data from an [`Atomic`] using this guard is safe only if theÁ ü½ƒC
|
|||
|
|
@ [`Atomic`] is not being concurrently modified by other threads.Á �„
|
|||
|
|
ú t…„
|
|||
|
|
ÖÛ ”„
|
|||
|
|
ú <˜„
|
|||
|
|
©¼ ü „1
|
|||
|
|
üä üÒ„-
|
|||
|
|
* use std::sync::atomic::Ordering::Relaxed;Á €…
|
|||
|
|
ú Ü„…
|
|||
|
|
let a = Atomic::new(7);Á …
|
|||
|
|
ú d¤…
|
|||
|
|
ÙØ ü±…7
|
|||
|
|
4 // Load `a` without pinning the current thread.Á üé….
|
|||
|
|
+ a.load(Relaxed, epoch::unprotected());Á ˜†
|
|||
|
|
ú üœ†5
|
|||
|
|
2 // It's possible to create more dummy guards.Á üÒ†)
|
|||
|
|
& let dummy = epoch::unprotected();Á ü†
|
|||
|
|
ú 쀇
|
|||
|
|
dummy.defer(move || {Á üž‡8
|