735 lines
315 KiB
Plaintext
735 lines
315 KiB
Plaintext
|
rust
|
|||
|
|
@é #rustc 1.96.0 (ac68faa20 2026-05-25)ÁÀ뉊 ]!ÜÛê(¹Þ—šên -5be7b69c3ff7b5b8Á íàÄTËŸ ÜJîÄ)'ß\¥! -3d1337db07d0b3aeÁ ¤²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Á rustversionÁTgÌüÁ é¨Cå@Ö'G -f0da710c68354185Á testsÁ,Ý[ ‚ $Ò[ •ù,ÅF‚ $ºFí OnceCellÁD‡ » experimental-thread-localÁüÏ %í THREAD_HEADÁ\»e»ºüÓd%íù,�f‚ $öe¼ù,‹&‚ $€&Áù,�X‚ $…X serdeÁ,ä-»½ ŒÌ-à rw_lockÁ<ô» internal-test-strategiesÁüÉ$à test_strategiesÁ|ê»ì ü¬$ Ü$š.»Ü„ƒ. ArcSwapWeakÁ\©å»Ü„�å internal_strategiesÁœñõ»ì üªõ$ ù,Æ÷‚ $»÷
|
|||
|
|
tests_defaultÁlÿô‚ £æ À accessÁ
|
|||
|
|
AccessÁ ¥ GuardÁ ¬ ¥ ’ ¡ ° ¬ ¥ ° ¬ ¥ ° ¬ !¥ !° !¬ %¥ %¤ %° %¬ *¥ *¤ *å *´ /¥ /¤ /° /¬ 4¥ 4¤ 4å 4´ 9¥ 9¤ 9° 9¬ DynGuardÁ >
|
|||
|
|
>¥ >ˆ B¥ Bå B´ DynAccessÁ F¥ F¬
|
|||
|
|
I¥ I’ I¬
|
|||
|
|
AccessConvertÁ M
|
|||
|
|
M• Mˆ Q¥ Q• Q° Q¬ V˜ V— V¥ V£ Vå V´
|
|||
|
|
]’ ]¥ ]— ]æ a£ c’ c— c¥ c£ c° c¬ j¥ jå j´ n¥ n° n¬ as_rawÁ r rrr sealedÁ v SealedÁ rr AsRawÁ y¥ yÁ r |¥ r~¥ ~Á r�¥ rƒ¥ ƒÁ r†¥ rˆ¥ ˆÁ r‹¥ r�¥ �Á r�¥ r ’¥ ’Á cacheÁ • •••••œ ›¥ ›¬ • ž’ ž¥ ž¤ žæ ž arc_swapÁ ž¬ ž load_no_revalidateÁ ž
|
|||
|
|
revalidateÁ žØ §— §¦ •ª’ ª¥ ª¤ ª¬ •¯’ ¯¥ ¯¤ ¯÷ •´’ ´¥ ´¤ ´— ´¦ ´¬ compile_fail_testsÁ debtÁ ¼ ¼¼¼¼¼¼ fastÁ à ÃÃÃÃ
|
|||
|
|
DEBT_SLOT_CNTÁ Ã É get_debtÁ ÃË 'aÁ Ë› Ë IntoIterÁ Ëê ¼ helpingÁ Ð ÐÐÐÐÐÐÐÐ REPLACEMENT_TAGÁ Ð GEN_TAGÁ Ð TAG_MASKÁ Ð IDLEÁ Ð SlotsÁ Ý controlÁ Ý slotÁ Ý active_addrÁ Ý handoverÁ Ý space_offerÁ Ð ã> Ðå½ åé å helpÁ è£ è¥ å initÁ å confirmÁ ¼ listÁ í ííííííííí í
|
|||
|
|
í í í
|
|||
|
|
ííí NODE_UNUSEDÁ í NODE_USEDÁ í
|
|||
|
|
NODE_COOLDOWNÁ í LIST_HEADÁ í NodeReservationÁ ‚
|
|||
|
|
‚þ ‚ˆ í †ã í NodeÁ ˆ¯ ˆ¨ ˆ in_useÁ ˆó ˆ active_writersÁ íŽ> í� traverseÁ ‘£ ‘— � start_cooldownÁ � check_cooldownÁ � reserve_writerÁ � getÁ — — �
|
|||
|
|
fast_slotsÁ � helping_slotÁ í LocalNodeÁ œ nodeÁ œ¯ œ¨ í withÁ ¡£ ¡— ¡ ¡ new_fastÁ new_helpingÁ confirm_helpingÁ ¨ ¨ «£ «¥ í®ã ¼ ° NONEÁ ¼²> ¼´ payÁ µ¥ ´ pay_allÁ ·¥ ·£ · º docsÁ ¼å ¼ limitationsÁ ¼ patternsÁ ¼ performanceÁ ref_cntÁ Á ÁÁÁÁÁ RefCntÁ Ç BaseÁ Ç into_ptrÁ Ç as_ptrÁ Ç from_ptrÁ Ç incÁ Ç decÁ Á Î¥ ÎÉ ÎÕ Îå Îó ÁÔ¥ ÔÉ ÔÕ Ôå Ôó ÁÚ¥ ÚÉ ÚÕ Úå Úó strategyÁ à ààà hybridÁ ä äääääääää ä
|
|||
|
|
ä ä ä
|
|||
|
|
äää HybridProtectionÁ õ¥ õ… õµ ä ù¥ ùæ ù attemptÁ ù¸ ùå äÿ¥ ÿã ä‚¥ ‚
|
|||
|
|
from_innerÁ ‚
|
|||
|
|
into_innerÁ 䆥 † borrowÁ ä ConfigÁ ‰ USE_FASTÁ ä‹ï$ ä�¥ � CfgÁ � ProtectedÁ �¬ ‘ ’ � wait_for_readersÁ ” ä–¥ –™% – compare_and_swapÁ ™” àààà DefaultStrategyÁ à IndependentStrategyÁ àÚ ¤% £¥ £´$ £¢$
|
|||
|
|
InnerStrategyÁ §¥ §¤% §¬ §Ç% CaSÁ ¬¥ ¬ù% ®” à StrategyÁ °¥ à ²¥ ²¤ àÁ' µ¥ à·¥ ·¤ importsÁ
|
|||
|
|
|
|||
|
|
° Ù¥ Ù¤ Ù innerÁ Ý¥ ݤ Ý´$ Ý¢$ ⥠⤠âå â´ ç¥ ç¤ ç÷ ë¥ ë¤ ë> ï¥ ï¤ ï× ó¥ ó¤ ó× ptr_eqÁ ÷É ÷’ ÷“
|
|||
|
|
ArcSwapAnyÁ û¥ û¤ ûµ û _phantom_arcÁ ûŸ" �¥ �¤ �÷ …¥ …¤ …ã ‰¥ ‰¤ ‰× �¥ �¤ �×
|
|||
|
|
‘¥ ‘¤ ‘> •¥ •¤ •æ •
|
|||
|
|
with_strategyÁ •´$ • load_fullÁ •¬ •È • swapÁ •ù% Ÿ” • rcuÁ ¡£ ¡— •Ø ¤š ¤£ ¤— ArcSwapÁ ¨¥ ª¥ ª¤ ª from_pointeeÁ
|
|||
|
|
ArcSwapOptionÁ ®¥
|
|||
|
|
°¥ °¤ °ç. ³§ ° emptyÁ ¶¥ ¶ const_emptyÁ IndependentArcSwapÁ ¹¥ ¿ ¤ DirectDerefÁ ½
|
|||
|
|
½¥ ½¤ ½ˆ Â¥ ¤ Â× MapGuardÁ Ƙ Æ— Æ¥ Æ£ Æ£ Æ
|
|||
|
|
projectionÁ Æý Θ Η Î¥ Σ Ó˜ Ó— Ó¥ Ó£ Óƒ Ù˜ Ù— Ù¥ Ù£ Ù× MapÁ ß’ ߥ ß— ßã ߘ1 ßý æ’ æ¥ æ— ê’ ê¥ ê— êƒ ï’ ï¥ ï— ï×
|
|||
|
|
ConstantDerefÁ ô
|
|||
|
|
ô¥ ôˆ ø¥ ú¥ úƒ ý¥ ý× €¥ €Ö ƒ¥ …¥ …� ˆ¥ ˆ‹ ‹¥ ‹ï
|
|||
|
|
Ž¥ Ž§ �ù ConstantÁ ’
|
|||
|
|
’¥ ’ˆ !–¥ "˜¥ ˜ƒ #›¥ ›× $ž¥ žÖ %¡¥ &£¥ £� '¦¥ ¦‹ (©¥ ©ï
|
|||
|
|
)¬¥ ¬§ ®ù • CacheÁ °’ °¥ °’ ° cachedÁ •µ’ µ¥ µƒ •¹’ ¹¥ ¹× • MapCacheÁ ½’ ½¥ ½— ½Ó) ½˜1 •Ã’ Ã¥ × Ã •È’ È¥ È— È× Ã LocalÁ Íž
|
|||
|
|
ÃÏ> á Ñ
|
|||
|
|
ш Ó ÃÕ> Ðà8 ×
|
|||
|
|
generationÁ ÐÙ> Ð HandoverÁ Û
|
|||
|
|
Ûˆ ÐÞ> íß à __rust_std_internal_init_fnÁ à â ã __RUST_STD_INTERNAL_VALÁ â å«: ¼ DebtÁ ç
|
|||
|
|
çˆ ¼ê× ÁÁí¥ íÉ íÕ íå íó Áó¥ óÉ óÕ óå óó ä
|
|||
|
|
DefaultConfigÁ ù
|
|||
|
|
äûƒ äý> ä HybridStrategyÁ ÿ™% ÿ _configÁ ä ‚™% ‚ƒ ä
|
|||
|
|
…™% …> º ººº
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
!
|
|||
|
|
$
|
|||
|
|
)
|
|||
|
|
.
|
|||
|
|
3
|
|||
|
|
8
|
|||
|
|
=
|
|||
|
|
E
|
|||
|
|
H
|
|||
|
|
L
|
|||
|
|
U
|
|||
|
|
V
|
|||
|
|
\
|
|||
|
|
a
|
|||
|
|
c
|
|||
|
|
i
|
|||
|
|
m
|
|||
|
|
q
|
|||
|
|
{
|
|||
|
|
|
|
|||
|
|
~
|
|||
|
|
€
|
|||
|
|
�
|
|||
|
|
ƒ
|
|||
|
|
…
|
|||
|
|
Š
|
|||
|
|
�
|
|||
|
|
”
|
|||
|
|
�
|
|||
|
|
£
|
|||
|
|
¤
|
|||
|
|
¥
|
|||
|
|
¦
|
|||
|
|
§
|
|||
|
|
®
|
|||
|
|
´
|
|||
|
|
º
|
|||
|
|
Ê
|
|||
|
|
Ê
|
|||
|
|
æ
|
|||
|
|
ç
|
|||
|
|
ç
|
|||
|
|
è
|
|||
|
|
è
|
|||
|
|
è
|
|||
|
|
ë
|
|||
|
|
ì
|
|||
|
|
†
|
|||
|
|
‡
|
|||
|
|
”
|
|||
|
|
•
|
|||
|
|
–
|
|||
|
|
š
|
|||
|
|
›
|
|||
|
|
¡
|
|||
|
|
¦
|
|||
|
|
§
|
|||
|
|
¨
|
|||
|
|
«
|
|||
|
|
«
|
|||
|
|
«
|
|||
|
|
¯
|
|||
|
|
µ
|
|||
|
|
Ê
|
|||
|
|
Ì
|
|||
|
|
Ò
|
|||
|
|
Ø
|
|||
|
|
Þ
|
|||
|
|
ü
|
|||
|
|
ü
|
|||
|
|
ý
|
|||
|
|
ý
|
|||
|
|
þ
|
|||
|
|
�
|
|||
|
|
ˆ
|
|||
|
|
‘
|
|||
|
|
‘
|
|||
|
|
”
|
|||
|
|
”
|
|||
|
|
™
|
|||
|
|
™
|
|||
|
|
ª
|
|||
|
|
ª
|
|||
|
|
«
|
|||
|
|
«
|
|||
|
|
®
|
|||
|
|
®
|
|||
|
|
æ
|
|||
|
|
ò
|
|||
|
|
ò
|
|||
|
|
ò
|
|||
|
|
ö
|
|||
|
|
ö
|
|||
|
|
ö
|
|||
|
|
ˆ
|
|||
|
|
Œ
|
|||
|
|
Œ
|
|||
|
|
Œ
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
›
|
|||
|
|
œ
|
|||
|
|
�
|
|||
|
|
ž
|
|||
|
|
Ÿ
|
|||
|
|
¡
|
|||
|
|
¡
|
|||
|
|
¤
|
|||
|
|
¤
|
|||
|
|
Å
|
|||
|
|
Å
|
|||
|
|
Å
|
|||
|
|
Æ
|
|||
|
|
Ø
|
|||
|
|
Þ
|
|||
|
|
Þ
|
|||
|
|
Þ
|
|||
|
|
î
|
|||
|
|
ó
|
|||
|
|
ó
|
|||
|
|
ó
|
|||
|
|
ü
|
|||
|
|
ÿ
|
|||
|
|
ÿ
|
|||
|
|
ÿ
|
|||
|
|
‚
|
|||
|
|
‡
|
|||
|
|
‡
|
|||
|
|
Š
|
|||
|
|
Š
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
š
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
|
|||
|
|
¥
|
|||
|
|
¥
|
|||
|
|
¨
|
|||
|
|
¨
|
|||
|
|
«
|
|||
|
|
«
|
|||
|
|
®
|
|||
|
|
®
|
|||
|
|
¸
|
|||
|
|
¼
|
|||
|
|
¼
|
|||
|
|
¼
|
|||
|
|
Ç
|
|||
|
|
Ì
|
|||
|
|
Ì
|
|||
|
|
Ì
|
|||
|
|
ë
|
|||
|
|
ë
|
|||
|
|
ë
|
|||
|
|
ñ
|
|||
|
|
÷
|
|||
|
|
ü
|
|||
|
|
„
|
|||
|
|
Fwy›Ç‰£§¬°µ ¡ ¥ F¥ 8ØD FØD Ìì 8ØD FØD � Ìì 8ØD û û »+ þµ ÿå+ €Ÿ" ë§oŽB‹ÄD¤ÄD ¿c ½ ½ ¾•0 Áˆ PzèýuÄDòE é! ½ ½ ¾•0 Áˆ Pzèýu†J†J K ‰Jµ �7 ŠJ phantomÁ�7 ‹J¤�7 ·0ØQd�èÄDçEçEèE GlobalÁ ¿±‡§í# òE û û »+ þµ ÿå+ €Ÿ" ë§oŽB‹ñFòEÄD é! ½ ½ ¾•0 Áˆ PzèýuòHòH Æ õHµ Ñ, öH�FÑ, ÷H¤Ñ, +átLaû§ÄDÀGòE û û »+ þµ ÿå+ €Ÿ" ë§oŽB‹ùHòEÄD é! > > ?Õ Aˆ âù&ÄD F’ÄD M M NÆ Pˆ á³æÇ—†¹‘•ÄD Š Æ Æ à0 Ë£ ̘1 Íý æ:óFŸ�‰` ˜—¥£ Ø¡K ¿c¡K é!¡K Š ß ß 2 ãã ä˜1 åý ±ìi0�Â% ’ØD— Ø¡L ¿c¡L ß ß 2 ãã ä˜1 åý ±ìi0�Â% äLðKêKöK Š ô ô õË3 ÷ˆ p²1=Ã�HÄD ØãM ¿cãM ™ãM ÐìãM µßãMãM ºãM íßãMãM šeãM é!ãM Š ’ ’ “ 5 •ˆ ìXN#£¤¬ÄD Ø�O ¿c�O ™�O Ðì�O µß�O�O º�O íß�O�O še�O �OÄD w 8ØD yžPØD È w 8 Ù Ù ° ÜÓ) Ù¡âßñ:¢ØD ÿ ÿ �< �< 8öÞÃP›l ù ù úÜ; Õì4õ´\) yÀP°P w Ù Ù ° ÜÓ) Ù¡âßñ:¢ÄDõP yÛQÄD È w ÄD y§RÄD w ÄD y¾RÄD Ø ° ° ñ6 ³’ • ´–7 •
|
|||
|
|
ê ·zäLØD ¿cÖR ›ÖRØD ê! é ÖRäL Ø ½ ½ Þ7 ÁÓ) • ˜1 • ùœ"‡²Vð5äLØDíL ¿cÈS › ½ ½ Þ7 ÁÓ) • ˜1 • ùœ"‡²Vð5äLØD—¦ ³ Í Í à8 Ξ
|
|||
|
|
à ݉™cªƒ† ³ Ñ Ñ Ò¡ Óˆ à ¹Þm8–s ÇL þ¤U ³ × × à8 د9 Ð ¸Doº-1 ³ Û Û ÜÍ9 ݈ Ð ôò±À˜9 £ ³ Ý Ý ¡ Þ® Ð ß½ Ð àÉ Ð áÜ Ð âì Ð âyU=øž Œ" ‚ ‚ ƒý …ˆ í AWÍÀ£¾k~ 8 ³ ˆ ˆ ¶ ‰¯ í Š¨ í ‹Ò í Œó í �è í ¬f{ÞgÚ Œ" œ œ ¬ �½ í ž¯ í Ÿ¨ í c7û‘„<[ ¿c ç ç è×: éˆ ‹Í€™Cö ³ ³Y ÇñF ÇùH Çۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙÄD Ç„¾„¾ PinÁ †¾‰ ˜X $ ]È=„kt•ñF Ç„¾„¾ äY †¾‰ ˜X $ ]È=„kt•ùH Œ" õ õ œ# ÷… ä øµ ä ¹Òóû÷O ¡ÄD £Ñ[ÄD Ñ[ÄD Ø¢Q ³ ¢Q ‰¢Q Ø ÿ ÿ �< �< 8öÞÃP›l ™% ³ Í\ § ÿ ÿ �< �< 8öÞÃP›l™%ÄD ¬‘]ÄD °òEÄD µòEÄD é! Ù Ù ° ÜÓ) Ù¡âßñ:¢ÄDòE é õ]ÄD ³ õ] ¿cõ] Äcõ] é ¬EÄD Œ"¬E ¿c¬E Äc¬E ³ ¬E F F! F% û/ û9 ûQ Mc ßn ’ ½Ù Æï ßý ô› ’¹ °È ½ê çï Ù‰ û* ½4 ½B >V Æj ôâ ÙI Î Ææ ßø ô– ’Ó Æê ßú ô˜ ’µ °Ã ½û ù‚ ÿ€ ôž ’ƒ ô¡ ’… ô£ ’ˆ ô¦ ’‹ ô© ’Ž ô¬ ’|
|
|||
|
|
�
|
|||
|
|
† Ù‹ � ~
|
|||
|
|
ƒ
|
|||
|
|
ˆ Ù� ’ ª °´ ½¯ °ç Ù� ûÏ ÍÕ ÑÙ ×Þ Ûã ÝŽ ˆ² çý ù… ÿë Ù‘ ûË
|
|||
|
|
† ‚® œÿ õ… ûΆJÔòHÚۼ턾󄾂 õ† õ‹ ù� ÿ– ÿ² · ó Ù� û
|
|||
|
|
ê¿c
|
|||
|
|
4é!F F$Š Ø ™8Ðìµßºíßše w y ›é ³ ÇLMŒ" Ç £& ‰ § ¬ ° µÄc 8Á ‹e
|
|||
|
|
DEBT_SLOT_CNTÁ ‹e 0b01Á ‹e 0b10Á ‹e 0b11Á ‹e 0Á ‹e 0Á ‹e 1Á ‹e 2Áùj· ™e
|
|||
|
|
|
|||
|
|
éj· e
|
|||
|
|
¾æXùjÕ úe â ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡z٠ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙæX æX €g± ß ùi�f�a à ®® £ °Ó)¨ it§ÅLS¶æX ái¢fa X â€g €g _Á ùjð e
|
|||
|
|
éjð e
|
|||
|
|
ÐæX / 5 ùj¦ ®e ã …g˜h / €g j¿ e ùjí Ôe ùj‚!e å‡jŠj™j # €g j›!e M jÀ$e ùjÛ ôe â €g ã‡jŠj™j å å‡jŠj™j Ÿ S _Á ‹e 0b11Á trueÁüØÜ |çÜ
|
|||
|
|
lçÜ
|
|||
|
|
²ÄD , :
|
|||
|
|
A tØÜ
|
|||
|
|
Ò]ÄD Q c öÜ \“Ý • ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙñF ü¶ÝF làÝ ù $ ÿ ¢Q ûÝ üÀÜÇ û ®mõP †Þ �Þ ¸ ü“Üú û û »+ þµ ÿå+ €Ÿ" ë§oŽB‹®mõP $±Ü ¤]¤] V ¦]Á‚] üß3ø¤”&§R ñ §R ï • • – PhantomDataÁ Fu\»Ÿ®m  õP h ¢Q f æ ü¶*1 ½ ÄDòE ¾ , ‚F 7 õ] > E ô§0 > ÄD ? & ¡J 1 �� ž BoxÁ ¡ˆˆ ¢‰ˆ l }.xÏ é! ê! ÄDÀG Œ “ ܸD M • N ) M M NÆ Pˆ á³æÇ—†¹‘�s _ �s f m Ü´U ô ÄD õ ( ãM 3 ÄD : A ´‹Z ’ ÄD “ ( �O 3 ÄD : A ¼ì
|
|||
|
|
Ñ Ò % ¤U 0 ³Y‹e E L |‚9 Û Ü % £V 0 ¤]¤] V ¦]Á‚] üß3ø¤”&‹e d k ô— ‚ ƒ ' ‚ ‚ ƒý …ˆ í AWÍÀ£¾k~ c €X m t ´ˆ ç è % ³Y 0 ™v 7 > r•»¼¼ÁàºÙ÷û¨®¹À Y4ê0 »p,‚1 ¿c ½p Âc ½t<‰1 Äc ¾ˆL’1 c ¿ FmtResultÁL§1 éb À³o\Å1 • Á³o – Áí Ü1 ë Âr,ð1 é! õ �2 “ Ä AtomicPtrÁLŸ2 ¯] Æ®Dª2 ¼À ÇK Ê2 †J È ‹œ 4ä2 Ê2 ì2 ß Ëø,‰3 y Ìñ6,¦3 ° Í» 4Å3 Ç ÎÜ;lë3 ù ÐÜ; ú Ð�<tú3 ÿ Ѥ%L¨4 £ ÒÁ' É4 µ Ôä'DÎ4 ° Õ¨&|ó4 ž ׿&œ„5 Ÿ ؤ,Ö, ¼ü ¾‹ ü€ Making [`Arc`] itself atomicÁ ¡ú ü¥b _ The [`ArcSwap`] type is a container for an `Arc` that can be changed atomically. Semantically,Á üˆS P it is similar to something like `Atomic<Arc<T>>` (if there was such a thing) orÁ üÜ\ Y `RwLock<Arc<T>>` (but without the need for the locking). It is optimized for read-mostlyÁ ü¹; 8 scenarios, with consistent performance characteristics.Á õú „ù
|
|||
|
|
# MotivationÁ Šú üŽ_ \ There are many situations in which one might want to have some data structure that is oftenÁ üîa ^ read and seldom updated. Some examples might be a configuration of a service, routing tables,Á üÐA > snapshot of some data that is renewed every few minutes, etc.Á ’ú ü–! In all these cases one needs:Á ü¸c ` * Being able to read the current value of the data structure, fast, often and concurrently fromÁ œœ many threads.Á ü°c ` * Using the same version of the data structure over longer period of time ‒ a query should beÁ ü” b _ answered by a consistent version of data, a packet should be routed either by an old or by aÁ ü÷ E B new version of the routing table but not by a combination, etc.Á ü½
|
|||
|
|
: 7 * Perform an update without disrupting the processing.Á ø
|
|||
|
|
ú üü
|
|||
|
|
c ` The first idea would be to use [`RwLock<T>`][RwLock] and keep a read-lock for the whole time ofÁ üà G D processing. Update would, however, pause all processing until done.Á ¨ ú ü¬ c ` Better option would be to have [`RwLock<Arc<T>>`][RwLock]. Then one would lock, clone the [Arc]Á ü�
|
|||
|
|
a ^ and unlock. This suffers from CPU-level contention (on the lock and on the reference count ofÁ üò
|
|||
|
|
` ] the [Arc]) which makes it relatively slow. Depending on the implementation, an update may beÁ üÓB ? blocked for arbitrary long time by a steady inflow of readers.Á –ú \š ```rustÁ ü¦# # use std::sync::{Arc, RwLock};Á üÊ # use once_cell::sync::Lazy;Á üë] Z # struct RoutingTable; struct Packet; impl RoutingTable { fn route(&self, _: Packet) {} }Á üÉJ G static ROUTING_TABLE: Lazy<RwLock<Arc<RoutingTable>>> = Lazy::new(|| {Á ü”+ ( RwLock::new(Arc::new(RoutingTable))Á <À });Á Èú üÌ' $ fn process_packet(packet: Packet) {Á üô? < let table = Arc::clone(&ROUTING_TABLE.read().unwrap());Á ä´ table.route(packet);Á ,Ñ }Á ü×+ ( # fn main() { process_packet(Packet); }Á <ƒ ```Á ‹ú ü�a ^ The [ArcSwap] can be used instead, which solves the above problems and has better performanceÁ üñU R characteristics than the [RwLock], both in contended and non-contended scenarios.Á Çú \˯‹ ä× # use arc_swap::ArcSwap;Á üô ñ‹ ü•]›Œ üóF C static ROUTING_TABLE: Lazy<ArcSwap<RoutingTable>> = Lazy::new(|| {Á üº+ ( ArcSwap::from_pointee(RoutingTable)Á <抎 îú üò'§Ž üš) & let table = ROUTING_TABLE.load();Á äÄ � ,áÅ� üç+Ô� <“ˆ� ›ú ¤Ÿ # Crate contentsÁ ´ú ü¸b _ At the heart of the crate there are [`ArcSwap`] and [`ArcSwapOption`] types, containers for anÁ ü›( % [`Arc`] and [`Option<Arc>`][Option].Á Äú üÈb _ Technically, these are type aliases for partial instantiations of the [`ArcSwapAny`] type. TheÁ ü«c ` [`ArcSwapAny`] is more flexible and allows tweaking of many things (can store other things thanÁ ü�^ [ [`Arc`]s, can configure the locking [`Strategy`]). For details about the tweaking, see theÁ üîF C documentation of the [`strategy`] module and the [`RefCnt`] trait.Á µ ú ü¹ ` ] The [`cache`] module provides means for speeding up read access of the contained data at theÁ üš cost of delayed reclamation.Á » ú ü¿ a ^ The [`access`] module can be used to do projections into the contained data to separate partsÁ ü¡ Y V of application from each other (eg. giving a component access to only its own part ofÁ üû = : configuration while still having it reloaded as a whole).Á ¹ ú ”½ # Before usingÁ Ð ú üÔ E B The data structure is a bit niche. Before using, please check theÁ üš M J [limitations and common pitfalls][docs::limitations] and the [performanceÁ üè K H characteristics][docs::performance], including choosing the right [readÁ ü´!2 / operation][docs::performance#read-operations].Á ç!ú üë!b _ You can also get an inspiration about what's possible in the [common patterns][docs::patterns]Á dÎ" section.Á Û"ú Œß" # Release 1.9Á ñ"ú üõ"^ [ Unfortunately, several orderings were too weak in the original code (proofs based on wrongÁ üÔ#_ \ assumptions / wrong reading of the standard). The 1.9 version should fix them, but probablyÁ ü´$, ) introduces some performance degradation.Á á$ú üå$_ \ I hope to re-design and rewrite from scratch eventually, with less amount of SeqCst needed.Á Å%ú tÉ% # ExamplesÁ Ø%ú \Ü%¯‹ ¼è% use std::sync::Arc;Á €&ú Ô„& use arc_swap::ArcSwap;Á üŸ& use crossbeam_utils::thread;Á À&ú üÄ&< 9 let config = ArcSwap::from(Arc::new(String::default()));Á Ü�' thread::scope
|
|||
|
|
ú üº
|
|||
|
|
b _ For some cases, it is possible to use [`ArcSwapAny::map`]. If that is not flexible enough, theÁ ü� ) & [`Map`] type can be created directly.Á Ç ú üË _ \ Note that the [`Access`] trait is also implemented for [`ArcSwapAny`] itself. Additionally,Á ü« ^ [ there's the [`Constant`] helper type, which is useful mostly for testing (it doesn't allowÁ |Š
|
|||
|
|
reloading).Á š
|
|||
|
|
ú Œž
|
|||
|
|
# PerformanceÁ °
|
|||
|
|
ú ü´
|
|||
|
|
_ \ In general, these utilities use [`ArcSwapAny::load`] internally and then apply the providedÁ ü”2 / transformation. This has several consequences:Á Ç ú üËa ^ * Limitations of the [`load`][ArcSwapAny::load] apply ‒ including the recommendation to notÁ üV S hold the returned guard object for too long, but long enough to get consistency.Á ü„Y V * The transformation should be cheap ‒ optimally just borrowing into the structure.Á Þ ú tâ ¾¤ ñ ú \õ ¯‹ ¼� î¤ ü™( % use std::thread::{self, JoinHandle};Á ä use std::time::Duration;Á ß ú Ôã š¥ üþ2 / use arc_swap::access::{Access, Constant, Map};Á ± ú üµS P fn work_with_usize<A: Access<usize> + Send + 'static>(a: A) -> JoinHandle<()> {Á ü‰ thread::spawn(move || {Á ô© let mut value = 0;Á üÈ while value != 42 {Á üè% " let guard = a.load();Á üŽ value = *guard;Á ü®& # println!("{}", value);Á üÕ_ \ // Not strictly necessary, but dropping the guard can free some resources, likeÁ üµa ^ // slots for tracking what values are still in use. We do it before the sleeping,Á ü—/ , // not at the end of the scope.Á äÇ drop(guard);Á üä9 6 thread::sleep(Duration::from_millis(50));Á lž
|
|||
|
|
}Á T¬ })Á ,· Å� ½ ú üÁ' $ // Passing the whole thing directlyÁ üéR O // (If we kept another Arc to it, we could change the value behind the scenes)Á ü¼I F work_with_usize(Arc::new(ArcSwap::from_pointee(42))).join().unwrap();Á † ú üŠ& # // Passing a subset of a structureÁ „±
|
|||
|
|
struct Cfg {Á ¬Â value: usize,Á ,Ø Å� Þ ú üâ@ = let cfg = Arc::new(ArcSwap::from_pointee(Cfg { value: 0 }));Á ü£U R let thread = work_with_usize(Map::new(Arc::clone(&cfg), |cfg: &Cfg| &cfg.value));Á üù+ ( cfg.store(Arc::new(Cfg { value: 42 }));Á Ü¥ thread.join().unwrap();Á Á ú üÅP M // Passing a constant that can't change. Useful mostly for testing purposes.Á ü– 2 / work_with_usize(Constant(42)).join().unwrap();Á <É ˆ� 4æ, >?FMNß½¾Æôõ’“³o\ã • ³o – r,ÿ é! K œ †J ‹”q ¡ � ‰Æ¦ òH Š» 4À Ç
|
|||
|
|
ä'DÝ ° »+Tó û
|
|||
|
|
° ,ÿ Ù ÌÕ É„ô ªt‹ ž ‹�xz´° iÌÌ \,ë OQ@Bœò üˆ C @ Abstracts over ways code can get access to a value of type `T`.Á Ì ú üÐ Z W This is the trait that parts of code will use when accessing a subpart of the big dataÁ ü« F C structure. See the [module documentation](index.html) for details.Á 4ü ¥ Îì üò — ÍìØD ƒ �Ø) �Ø/ Íì˜ØØD ô¤" é!ÜØ Œ°" ÜØê! ØDT¶" ÔØ* îØ þØ wy ì¤" üŒ = : A guard object containing the value and keeping it alive.Á Î ú üÖ [ X For technical reasons, the library doesn't allow direct access into the stored value. AÁ ü¶!\ Y temporary guard object must be loaded, that keeps the actual value alive for the time ofÁ D—" use.Á,©" ôé# ¼È" The loading method.Á ä" ú üì"_ \ This returns the guard that holds the actual value. Should be called anew each time a freshÁ ¤Ð# value is needed.Á$ì# Œ Œ˜Ø ÜØ ñ#
|
|||
|
|
˜ØØD$ò# ü‹$D ¥ ’ ¡ ¾Dê! ×JT³$ Îì×J “$ Íì¾D ª$ ×JÄD L–$ é!¾D Œ$ ÍìÄD �$ ¾D ac ^` TÖ$ ,Û$ ×JÄD ìñ$ $ô$ � �¾D ¾DÄD ù$
|
|||
|
|
ÄD×J¾D$ú$ ü¶%+ 8 Ž ¥ Ž ¤Ø »% ÐD Tè% ,í% > > ?Õ Aˆ âù&ØDì‡& $Š& � �ÐD ÐDØD �&
|
|||
|
|
8ØD$�& üÄ&2 8 � ¥ � ¤Ø É& ëD Tý& ,‚' ·áìœ' $Ÿ' ‘ ‘ëD ëDØD ¤'
|
|||
|
|
8ØD$¥' üÙ'9 8 ’ ¥ " ’ " ¤Ø Þ' ‰E#$ $ T™( ,ž( ! ! ·áì¸( $»( “ “‰E ‰EØD ! À( !
|
|||
|
|
$ 8ØD$Á( üõ(> ¥ & ¤ ' ' & ‹ß ú( ÍìòE …) ÇÄD 4ý( °òEÄD \ˆ) ¬E() ) EG BD Tº) ,¿) % % õ]ìÙ) $Ü) ” ”¬E ¬EÄD % á) %
|
|||
|
|
)ÄDòE$â) ü÷*= ¥ + ¤ , , + ‹ß ü* ˆæ ÿ* °òEñF „‚+ ÀF-. ê! ë! . 02 57 \»+ 4À+ * * ÄD¬Ð+ ,Ó+ • •ÀF •ÄD * Ù+ *
|
|||
|
|
.ÄDòE$Ú+ ü�,@ ¥ 0 ¤ 1 1 0 ‹ß •, ˆæ ˜, “è„›, õG23 3 $& )+ T×, ,Ü, / / ÀFì€- $ƒ- – –õG õGÄD / ˆ- /
|
|||
|
|
3ÄDòE$‰- üÊ-; ¥ 5 ¤ 6 5 6 ‹ß Ï- ˆæ Ò- °òEùH |Õ- ÈH78 ê! ë! 8 02 57 \Œ. 4‘. 4 4 ÄD¬¡. ,¤. — —ÈH —ÄD 4 ª. 4
|
|||
|
|
8ÄDòE$«. üá.> ¥ : ¤ ; : ; ‹ß æ. ˆæ é. äë|ì. ÎI<= = $& )+ T¦/ ,«/ 9 9 ÈHìÎ/ $Ñ/ ˜ ˜ÎI ÎIÄD 9 Ö/ 9
|
|||
|
|
=ÄDòE$×/ Q8 4ž0 D²0 ¥ @ @ ÎìÄD »0 ¡J âù& ? A �� ž”q ¡ˆˆ ¢‰ˆ l }.xÏ é! ê! ÄDÀG¡J Q8¢ âï¡J > >
|
|||
|
|
?ÄD²´ ÔÆ0 > > âïüä0% ¥ C C ·ï é0 ¡JDE ê! ë! E \�1 4•1 B B ÄD¬¥1 ,¨1 ™ ™¡J ™ÄD B ®1 B
|
|||
|
|
EÄD$¯1 ´ü6 üÖ13 0 An object-safe version of the [`Access`] trait.Á Š2 ú üŽ2` ] This can be used instead of the [`Access`] trait in case a type erasure is desired. This hasÁ üï2` ] the effect of performance hit (due to boxing of the result and due to dynamic dispatc
|
|||
|
|
4¦
|
|||
|
|
ª ªÀP ’ ƒ
|
|||
|
|
ƒ
|
|||
|
|
… 8ØD$®
|
|||
|
|
üç
|
|||
|
|
# ¥ ‡ ‡ ‹ß ì
|
|||
|
|
˜æ4ï
|
|||
|
|
ÛQ üŽ + ¥ ‰ ‰ ‹ß “ ˜æ4– ÛQŠ { Š üÀ 4à « «ÛQ —R ˆ Ê ˆ
|
|||
|
|
ŠÄD$Ë Ì„ ¥ Œ Œ ‹ß ‰ §R Ü¡ ¥ Ž Ž ‹ß ¦ §R� { � Ôà 4Æ ¬ ¬§R §R � Í �
|
|||
|
|
�ÄD$Î Ü÷ ¥ ‘ ‘ ‹ß ü ¾R ì–
|
|||
|
|
¥ “ “ ‹ß ›
|
|||
|
|
¾R” { ” Ôº
|
|||
|
|
4½
|
|||
|
|
¾R §R ’ Ä
|
|||
|
|
’
|
|||
|
|
”ÄD$Å
|
|||
|
|
lú, ü) & Caching handle into the [ArcSwapAny].Á Aú üEE B The [Cache] keeps a copy of the internal [Arc] for faster access.Á ‹ú Ì� [Arc]: std::sync::ArcÁ ,‚- ›°½r,¹ é! • –®DØ ¼À • —» 4÷ Ç • ˜ä'D” ° • ™»+T© û • š„®käÄ\´çL̃=Œ¢.œó ü¶5 2 Generalization of caches providing access to `T`.Á ìú üðb _ This abstracts over all kinds of caches that can provide a cheap access to values of type `T`.Á üÓb _ This is useful in cases where some code doesn't care if the `T` is the whole structure or justÁ Œ¶ a part of it.Á Èú üÌ& # See the example at [`Cache::map`].Á 4ý › ¥ œ œ › �ØüóÀ ¤Ø „ › �Ø" �Ø(�� � *, ̘ ü� Loads the value from cache.Á ±ú ü¹Z W This revalidates the value in the cache, then provides the access to the cached value.Á$› ® ®˜Ø ®ØD › ›
|
|||
|
|
�˜ØØD$¥ü× k ’ Ÿ ¥ ¤ ¡ Ÿ ¡ äLê! û û »+ þµ ÿå+ €Ÿ" ë§oŽB‹ØD¤Ì„ ¤Ø ß Íì÷½ â é!äL üþ Ø‘ Ü ð«4§ °÷½ØD \¶ ÖR¢£¤¥¦§ 46 jl fh üÀ# üÉ ! Creates a new caching handle.Á ï ú ü÷ ^ [ The parameter is something dereferencing into an [`ArcSwapAny`] (eg. either to [`ArcSwap`]Á üÚ ] Z or [`ArcSwapOption`]). That can be [`ArcSwapAny`] itself, but that's not very useful. ButÁ ü¼!S P it also can be a reference to it or `Arc`, which makes it possible to share theÁ ü”"K H [`ArcSwapAny`] with multiple caches or access it in non-cached way too.Á ä"ú üì"+ ( [`ArcSwapOption`]: crate::ArcSwapOptionÁ üœ# [`ArcSwap`]: crate::ArcSwapÁ Ç# äLÖR ž ž
|
|||
|
|
¢äLØD÷½’DË#üÿ$$ üº$@ = Gives access to the (possibly shared) cached [`ArcSwapAny`].ÁD†% ¯ ¯ÖR ¯äL ê! ž �% ž
|
|||
|
|
£äLØD÷½$�%äÕ( üÈ%# Loads the currently held value.Á ð%ú üø%R O This first checks if the cached value is up to date. This check is very cheap.Á Ï&ú ü×&_ \ If it is up to date, the cached value is simply returned without additional costs. If it isÁ ü»'] Z outdated, a load is done on the underlying shared storage. The newly loaded value is thenÁ ü�(% " stored in the cache and returned.Á$Ü( ° °ÖR °ØD ž á( ž
|
|||
|
|
¤äLØD÷½$æ(üÊ)"”Í) • ± ±ÖR ±ØD ž à) ž
|
|||
|
|
¥äLØD÷½$á)Ä�*T * • ² ²ÖR™j ž «* ž
|
|||
|
|
¦äLØD÷½$°*üˆ=W ü®.L I Turns this cache into a cache with a projection inside the cached value.Á ÿ.ú ü‡/^ [ You'd use this in case when some part of code needs access to fresh values of `U`, howeverÁ üê/^ [ a bigger structure containing `U` is provided by this cache. The possibility of giving theÁ üÍ0\ Y whole structure to the part of the code falls short in terms of reusability (the part ofÁ ü®1[ X the code could be used within multiple contexts, each with a bigger different structureÁ üŽ2W T containing `U`) and code separation (the code shouldn't needs to know about t
|
|||
|
|
# WarningÁ ˜3ú ü 3Y V As the provided `f` is called inside every [`load`][Access::load], this one should beÁ üþ3_ \ cheap. Most often it is expected to be just a closure taking reference of some inner field.Á â4ú üê4\ Y For the same reasons, it should not have side effects and should never panic (these willÁ üË5Q N not break Rust's safety rules, but might produce behaviour you don't expect).Á ¡6ú t©6¾¤ ¼6ú \Ä6¯‹ ÔÔ6š¥ üó6) & use arc_swap::cache::{Access, Cache};Á ¡7ú ¬©7 struct InnerCfg {Á ´Ã7 answer: usize,Á ,Þ7Å� è7ú ¤ð7 struct FullCfg {Á ĉ8 inner: InnerCfg,Á ,¦8Å� °8ú ü¸86 3 fn use_inner<A: Access<InnerCfg>>(cache: &mut A) {Á üó8! let value = cache.load();Á ü™94 1 println!("The answer is: {}", value.answer);Á ,Ò9Å� Ü9ú üä92 / let full_cfg = ArcSwap::from_pointee(FullCfg {Á Ì›: inner: InnerCfg {Á ¼¹: answer: 42,Á LÕ:ž« <ã:ŠŽ üï:& # let cache = Cache::new(&full_cfg);Á üš;2 / use_inner(&mut cache.map(|full| &full.inner));Á Ñ;ú üÙ;C @ let inner_cfg = ArcSwap::from_pointee(InnerCfg { answer: 24 });Á ü¡<1 . let mut inner_cache = Cache::new(&inner_cfg);Á ü×< use_inner(&mut inner_cache);Á <ü<ˆ� �= ÖRÜTœT ž— ¨ ¦ © ¨ © ž ÍìÜT “= ÍìâT –= ³ “"ÜT ³ØD |Ï= ³ ÜT‹Ü˜" ³âT Ü=
|
|||
|
|
§äLØD÷½ÜTâT$™=± Ÿ=� |~ üÀ>§ ’ « ¥ ¬ ¤ « ¬ §½Ìƒ? ØDê! °Pä¬? ‰¾ Ë> š¾üý> Ø‘ Å> é!ØD ü¦?# ¤Ø È> ð«4Ì? º¾\Û?ÖR® � ® :< /1 eg üî? $ñ? ´ ´ÖR ´ªS ª ö? ª
|
|||
|
|
®äLØD÷½$û?ü¶@w ’ ° ¥ ± ¤ ² ± ² ° §½Ìï@ ¤Ø ¾@ ‰¾ Á@ š¾üé@ Ø‘ »@ ð«4’A º¾\¡AÖR³ ë ³ "$ HJ MO ä´A$·A äLÖR ¯ ¯
|
|||
|
|
³äLØD÷½’D¼Aü¿D� ’ µ ¥ ¶ ¤ · — ¸ ¦ ¹ ¶ ¸ ¹ · µ §½Ì†E µ ÜT µØD ˜" µâT ÙE ‰¾ ÊD ÜÛ ÍD ìÛ ÐD š¾ü€E Ø‘ ÄD ð«4©E º¾\¸E µ “"ÜT�â |ÌE ¤Ø ÇDœTº � º BD ! } ‚„ ‡‰ ÄãE$æE ¶ ¶œT ¶âT ´ ëE ´
|
|||
|
|
ºäLØD÷½ÜTâT$ðE´‰- ”�- D¡- $¥- ÃÐíçè AtomicUsizeÁ\— „Ä ¼ ½¬ Læ œ À¶$ñ ˆ Á» 4ƒ Ç ¼  ÎË=Û ½À ¼ ¾Ë ¾À ¼ ¾Ì=æ¦ ¿À ¼ ¾Ì ÀÀ ¼ ¾G=í¬ ÁÀ ¼ ¾G ÂÀ ¼ ¾F5ç² ÃÀ ¼ ¾F ÄÀ ¼ ¾×5Õ¶ ÅÀ ¼ ¾× ÆÀ ¼ ¾üƒ ;ä¨TÙ03"%lüDŒ $�¼ÈÍÑÒa$á á. Ã Ä IterÁ$ø Äl à Å×:$¯ ç à Ç×: è à ÇËq ½À à ƈ ¾À à ÆÌo ¿À à ÆÌ„ ÀÀ à ÆGm ÁÀ à ÆG� ÂÀ à ÆFk ÃÀ à ÆF ÄÀ à Æ×i ÅÀ à Æ×~ ÆÀ à ƄÕ1Œë ä‚\¨Ô¶l¼Ã ‹eT� ¤UÊ üª ID¸ ¼ · ¸ ·¤U ‹e ¸ïT ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ ·³Y É Á É
|
|||
|
|
Ê $Â µ È ®,Ô üå# þ Ì Ì ÝUÍÎÏ ÈL ÉL ÊL Ï êL�$” Ë Ë þ³Y lªD¯ Ë Ë ÄlÄl ‹ç Çlµ ™l Èl
|
|||
|
|
end_or_lenÁ™l Él _markerÁ™l ŒœjSž þ³YüÏ$LÒ ÝUÝU ÉL Ë Ë
|
|||
|
|
Ï þ$Ü\– <š¼ÙÚÛÜÝ×ÛÜa$ò4 á. Рѵ ‚5 “ Ð Ò¶yLÅ5 ¯] Ð Õûã\Ð5 „Ä Ð Ö×:$ê5 ç Ð ××: è Ð ×» 4û5 Ç Ð Ø ÎË* ½À Ð ÓË? ¾À Ð ÓÌ( ¿À Ð ÓÌ= ÀÀ Ð ÓG& ÁÀ Ð ÓG: ÂÀ Ð ÓF$ ÃÀ Ð ÓF8 ÄÀ Ð Ó×" ÅÀ Ð Ó×7 ÆÀ Ð Ó„æ4rLü4dä‹5”°5Z]JM\ã5>lô5ü„6 |Ž6 ‹eÄ6<·6 ‹eÌÎ6DØ6 ‹e¬ð6$ú6 ‹e¼É9 ,Û9¼ ÝV âyU=øž Þßàáâ¤ô@<ô@Ð Ý Ý ™vT®A$®AÐ Ý Ý ³YıB\±BÐ Ý Ý ™v”ŒEDŒEÐ Ý Ý £VüëF \ëFÐ Ý Ý ¤]¤] V ¦]Á‚] üß3ø¤”& £V´�G ÝVä ´ ä ¤G<°G ÝV ã ã
|
|||
|
|
ä TóK ÝVæçèëì ü„L"$’L ¼ ¹ ¹ÝV ¹³Y å —L å
|
|||
|
|
æ $˜LüÇLIDÕL ¼ º » ºÝV ‹e »îU ‹e å ÞL å
|
|||
|
|
ç $ßLµ åL®,ñLüúV„$ˆW ¼ ¼ ½ ¾ ¼ÝV ½ÝV ‹e ¾ £ ™j å £ é ¥ ê é ê “W å Íìé÷ �W ¤Ø �W ð«4áW �"é÷™j LôW é÷™j˜" ØD üW
|
|||
|
|
èé÷ØD$”W whoÁ šW storage_addrÁd¦W replacementÁ\»W�ƒ †ˆ ì„~$’~ ¼ ¿ ¿ÝV™j å —~ å
|
|||
|
|
ë $œ~üé~I<÷~ ¼ À ÀÝV ‹e‹eÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
™j‹e å ÿ~ å
|
|||
|
|
ì $€5 †µ ’D£ $§¼þÿ€�‚ƒˆœàa$Å
|
|||
|
|
á. í îµ Õ
|
|||
|
|
“ í ï‹ç$ë
|
|||
|
|
Äl í ð¶yL¯ ¯] í óûã\º „Ä í ô”q ¦ � í õ ‰ FastLocalÁLÇ Í í ÷ FastSlotsÁLÛ Ñ í ø HelpingLocalÁd…
|
|||
|
|
× í ú HelpingSlotsÁdœ
|
|||
|
|
Ý í û×:$¶
|
|||
|
|
ç í ü×: è í ü» 4Ç
|
|||
|
|
Ç í ý ÎËa ½À í ñËv ¾À í ñÌ_ ¿À í ñÌt ÀÀ í ñG] ÁÀ í ñGq ÂÀ í ñF[ ÃÀ í ñFo ÄÀ í ñ×Y ÅÀ í ñ×n ÆÀ í ñ„¹
|
|||
|
|
LÏ
|
|||
|
|
ŒÞ
|
|||
|
|
äõ
|
|||
|
|
”š øûè뜖 Ü\° ,¾ Å,Ò ®të ,ü ˜,“
|
|||
|
|
~\¯
|
|||
|
|
plÀ
|
|||
|
|
MÄÐ
|
|||
|
|
\Ö
|
|||
|
|
í ‹e´î
|
|||
|
|
Lô
|
|||
|
|
í ‹eÔŠl�í ‹eüÑ!LØ í ¤]¤] V ¦]Á‚] üß3ø¤”& €Xà Þ: |¢ þ „ „ ‚ ‚ ƒý …ˆ í AWÍÀ£¾k~ þ AWÍÀ£¾k~ ƒ … þ€X ´‚ ‡Þ:ƒ í ‡ƒ´‚ ‚ ‚
|
|||
|
|
ƒ þ²D¶í ‚ ‚ ‡ƒüÂ! 8 Á Á ÂW‡ �" ‡ ”ê$í  ÂÂW™j † ò †
|
|||
|
|
‡ 8$÷´ø $Š €X ¬f{ÞgÚ ‰Š‹Œ�|•$•í ˆ ˆ ¤U¬ª<ªí ˆ ˆ ÝVœÅ4Åí ˆ ˆ ™vŒ‚$‚í ˆ ˆ €X Ü™t™í ˆ ˆ ™v¬¹ €X� ´ � ¤Õ<Ø €X Ž Ž
|
|||
|
|
� Lå €X‘”•–—š› üÜVDê êKۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙé÷ � £ ’ — “ ’ “ � ¥ø ó Í� ö “"êK €X üù! êK舘" Ö‡L‘
|
|||
|
|
‘é÷êK± NP SU Ä® t± í à ÀX ™j � À �
|
|||
|
|
” $Á ÄÇ#tÊ# í Ä Ä€X ™j � Ù# �
|
|||
|
|
• $Ú#üû*3t‚+ ŠŀX ‚ ‚ ƒý …ˆ í AWÍÀ£¾k~ Å � ‘+ �
|
|||
|
|
– $’+Ìž- ¡- í êˆ � �
|
|||
|
|
— 4‘. — <closure_kind>Á ˜ <closure_signature>Á ˜ <upvars>Á ˜ ˜ — ˜ Åwۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙÅw ™j¢2 — Ë ™ Ü‹ ™ ú‹ ™ ™ — ™ ™jÅw ™jü†;1T”; Æ Æ€X ÄlÄl ‹ç Çlµ ™l ÈlÃì™l ÉlÙì™l ŒœjSž ƳY � Ÿ; �
|
|||
|
|
š $ ;ü„<*d’< Ç Ç€X dzY � Ÿ< �
|
|||
|
|
› $ <ܤ= L¶= æX c7û‘„<[ �žŸ ¯ü×>!$×>í œ œ á.á. a ã.»Ì- IÜž�B2®Û¼Ý¼Þ¼© ß¼ à¼ÛἈ cSñŸ«‡zÙêˆ|?$?í œ œ ïT¬÷?<÷?í œ œ îUt‘@ æX¡¦§¨« üÝ@< »ºü°@%ü¯@'ü¦@2$ë@ êKé÷ £ ¢ — £ £ ¢ ¥ø ð@ Í� ó@ È –"êK ÈæX ¼ö@ È êK…”˜" é÷ ŒA
|
|||
|
|
¡é÷êK± �A^` ce 4êA ¡Ã‹ ¤ Ü‹ ¤ ú‹ ¤ ¤ ¡ ¤é÷êK æX é÷ á.á. a ã.»Ì- IÜž�B2®Û¼Ý¼Þ¼© ß¼ à¼ÛἈ cSñŸ«‡zÙêK ÷F ¡Ã‹ ¥ Ü‹ ¥ ú‹ ¥ ¥ ¡ ¥é÷êK åHåHæH AccessErrorÁ –úrì$šÙ0 é÷ Õ•üÃOBDÑO É ÉæX ‹eۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ ³Y ÚO
|
|||
|
|
¦ $ÛOµ áOü³R5\ÁR Ê ÊæX ‹e‹e ÍR
|
|||
|
|
§ $ÎRµ ÔRüØXŒ|æX Ë ËæX ‹e‹eÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
â˜â˜‹e ÿX
|
|||
|
|
¨ $€Y5 ŽYµ ¢Y$å[ ¨ Ë © Ü‹ © ú‹ © © ¨ © ™j ³Y Šœ 4…\ ¨ Ë ª Ü‹ ª ú‹ ª ª ¨ ª ‹eŠœ‹e “œüø]„$†^ ¼ Ì Í Î ÌæX Í€X ‹e Îé÷ ™j £ ¬ ¥ ¬ ‘^ ¥ø ‹^ ¤Ø Ž^ ð«4ß^ ÆøLò^ Ùø ú^
|
|||
|
|
«é÷ØD$’^‚ø ˜^�ød¤^¡ø\¹^RT WY ¼à` æX¯ �" ¯ ”þ`$�a Ï ÏæX™j ® †a ®
|
|||
|
|
¯ $‹aL¹ ³Y± ä� $¡ ° ° ‹e¬¸
|
|||
|
|
Additional documentation.Á
|
|||
|
|
ú ü"_
|
|||
|
|
\ Here we have some more general topics that might be good to know that just don't fit to theÁ ´‚
|
|||
|
|
crate level intro.Á ™
|
|||
|
|
ú ü�_
|
|||
|
|
\ Also, there were some previous blog posts about the crate which you might find interesting.Á ý
|
|||
|
|
ú ´�
|
|||
|
|
# Atomic orderingsÁ ˜
|
|||
|
|
ú üœa
|
|||
|
|
^ Each operation on the [`ArcSwapAny`] with [`DefaultStrategy`] type callable concurrently (eg.Á üþc
|
|||
|
|
` [`load`], but not [`into_inner`]) contains at least one [`SeqCst`] atomic read-write operation,Á üâ_
|
|||
|
|
\ therefore even operations on different instances have a defined global order of operations.Á Â
|
|||
|
|
ú tÆ
|
|||
|
|
# FeaturesÁ Õ
|
|||
|
|
ú üÙV
|
|||
|
|
S The `weak` feature adds the ability to use arc-swap with the [`Weak`] pointer too,Á ü°c
|
|||
|
|
` through the [`ArcSwapWeak`] type. The needed std support is stabilized in rust version 1.45 (asÁ ¤”
|
|||
|
|
of now in beta).Á ©
|
|||
|
|
ú ü_
|
|||
|
|
\ The `experimental-strategies` enables few more strategies that can be used. Note that theseÁ ü�c
|
|||
|
|
` **are not** part of the API stability guarantees and they may be changed, renamed or removed atÁ lñ
|
|||
|
|
|
|||
|
|
any time.Á ÿ
|
|||
|
|
ú üƒb
|
|||
|
|
_ The `experimental-thread-local` feature can be used to build arc-swap for `no_std` targets, byÁ üæ]
|
|||
|
|
Z replacing occurences of [`std::thread_local!`] with the `#[thread_local]` directive. ThisÁ üÄ H
|
|||
|
|
E requires a nightly Rust compiler as it makes use of the experimentalÁ ü�
|
|||
|
|
a
|
|||
|
|
^ [`thread_local`](https://doc.rust-lang.org/unstable-book/language-features/thread-local.html)Á üï
|
|||
|
|
a
|
|||
|
|
^ feature. Using this features, thread-local variables are compiled using LLVM built-ins, whichÁ üÑ %
|
|||
|
|
" have [several underlying modes ofÁ ü÷ c
|
|||
|
|
` operation](https://doc.rust-lang.org/beta/unstable-book/compiler-flags/tls-model.html). To addÁ üÛ a
|
|||
|
|
^ support for thread-local variables on a platform that does not have OS or linker support, theÁ ü½
|
|||
|
|
a
|
|||
|
|
^ easiest way is to use `-Ztls-model=emulated` and to implement `__emutls_get_address` by hand,Á |Ÿ
|
|||
|
|
as in [thisÁ ü¯
|
|||
|
|
| example](https://opensource.apple.com/source/clang/clang-800.0.38/src/projects/compiler-rt/lib/builtins/emutls.c.auto.html)Á |¯
|
|||
|
|
from Clang.Á ¿
|
|||
|
|
ú ôÃ
|
|||
|
|
# Minimal compiler versionÁ â
|
|||
|
|
ú üæ^
|
|||
|
|
[ The `1` versions will compile on all compilers supporting the 2018 edition. Note that thisÁ üÅ^
|
|||
|
|
[ applies only if no additional feature flags are enabled and does not apply to compiling orÁ ”¤
|
|||
|
|
running tests.Á ·
|
|||
|
|
ú ü»%
|
|||
|
|
" [`ArcSwapAny`]: crate::ArcSwapAnyÁ üá'
|
|||
|
|
$ [`ArcSwapWeak`]: crate::ArcSwapWeakÁ ü‰%
|
|||
|
|
" [`load`]: crate::ArcSwapAny::loadÁ ü¯1
|
|||
|
|
. [`into_inner`]: crate::ArcSwapAny::into_innerÁ üá/
|
|||
|
|
, [`DefaultStrategy`]: crate::DefaultStrategyÁ ü‘3
|
|||
|
|
0 [`SeqCst`]: std::sync::atomic::Ordering::SeqCstÁ ìÅ
|
|||
|
|
[`Weak`]: std::sync::WeakÁ $³- ½¾¿À„ä
|
|||
|
|
¬ Internal details.Á ú üb _ While the other parts of documentation are useful to users of the crate, this part is probablyÁ ü}` ] helpful only if you want to look into the code or are curious about how it works internally.Á Þ ú üâ] Z Also note that any of these details may change in future versions and are not part of theÁ üÀ6 3 stability guarantees. Don't rely on anything here.Á ÷ ú Ôû # Storing the [`Arc`].Á – ú üš_ \ The [`Arc`] can be turned into a raw pointer and back. This is abstracted by the [`RefCnt`]Á üúZ W trait and it is technically possible to implement it for custom types (this crate alsoÁ üÕY V implements it for [`Rc`] and [`Weak`], though the actual usefulness of these is a bitÁ ”¯ questionable).Á  ú üÆ6 3 The raw pointer is stored inside an [`AtomicPtr`].Á ý ú ü�$ ! # Protection of reference countsÁ ¦ ú üªb _ The first idea would be to just use [`AtomicPtr`] with whatever the [`Arc::into_raw`] returns.Á ü�] Z Then replacing it would be fine (there's no need to update ref counts). The load needs toÁ üëc ` increment the reference count ‒ one still stays inside and another is returned to the caller.Á üÏ^ [ This is done by re-creating the Arc from the raw pointer and then cloning it, throwing oneÁ ü® * ' instance away (without destroying it).Á Ù ú üÝ c ` This approach has a problem. There's a short time between we read the raw pointer and incrementÁ üÁ
|
|||
|
|
c ` the count. If some other thread replaces the stored Arc and throws it away, the ref count couldÁ ü¥ a ^ drop to 0, get destroyed and we would be trying to bump ref counts in a ghost, which would beÁ œ‡ totally broken.Á › ú üŸ G D To prevent this, we actually use two approaches in a hybrid manner.Á ç ú üë [ X The first one is based on hazard pointers idea, but slightly modified. There's a globalÁ üÇ
|
|||
|
|
a ^ repository of pointers that owe a reference. When someone swaps a pointer, it walks this listÁ ü©B ? and pays all the debts (and takes them out of the repository).Á ì ú üð` ] For simplicity and performance, storing into the repository is fallible. If storing into theÁ üÑ^ [ repository fails (because the thread used up all its own slots, or because the pointer gotÁ ü°\ Y replaced in just the wrong moment and it can't confirm the reservation), unlike the fullÁ ü�T Q hazard-pointers approach, we don't retry, but fall back onto secondary strategy.Á â ú üæb _ The secondary strategy is similar, but a bit more complex (and therefore slower, that's why itÁ üÉb _ is only a fallback). We first publish an intent to read a pointer (and where we are reading itÁ ü¬H E from). Then we actually do so and publish the debt, like previously.Á õ ú üùc ` The writer pays the debts as usual. But also, if it sees the intent to read the value, it helpsÁ üÝ^ [ along, reads it, bumps the reference and passes it to the reader. Therefore, if the readerÁ ü¼Y V fails to do the protection itself, because it got interrupted by a writer, it finds aÁ ü–\ Y ready-made replacement value it can just use and doesn't have to retry. Also, the writerÁ üób _ doesn't have to wait for the reader in any way, because it can just solve its problem and moveÁ <Ö on.Á Þ ú tâ # UnsafetyÁ ñ ú üõa ^ All the uses of the unsafe keyword is just to turn the raw pointer back to Arc. It originatedÁ ü×d a from an Arc in the first place, so the only thing to ensure is it is still valid. That means itsÁ ü¼! ref count never dropped to 0.Á Þ ú üâ] Z At the beginning, there's ref count of 1 stored in the raw pointer (and maybe some othersÁ üÀ` ] elsewhere, but we can't rely on these). This 1 stays there for the whole time the pointer isÁ ü¡` ] stored there. When the arc is replaced, this 1 is returned to the caller, so we just have toÁ ü‚ 5 2 make sure no more readers access it by that time.Á ¸ ú ´¼ # Leases and debtsÁ Ó ú ü× d a Instead of incrementing the reference count, the pointer reference can be owed. In such case, itÁ ü¼ ` ] is recorded into a global storage. As each thread has its own storage (the global storage isÁ ü� c ` composed of multiple thread storages), the readers don't contend. When the pointer is no longerÁ ü� in use, the debt is erased.Á ¡ ú ü¥ d a The writer pays all the existing debts, therefore the reader have the full Arc with ref count atÁ üŠ ] Z that time. The reader is made aware the debt was paid and decrements the reference count.Á è ú œì # Memory ordersÁ €! ú ü„!8 5 ## Synchronizing the data pointed to by the pointer.Á ½! ú üÁ!d a We have AcqRel (well, SeqCst, but that's included) on the swap and Acquire on the loads. In caseÁ ü¦"^ [ of the double read around the debt allocation, we do that on the *second*, because of ABA.Á ü…#O L That's also why that SeqCst on the allocation of debt itself is not enough.Á üÕ#c ` the *latest* decrement. By making both the increment and decrement AcqRel, we effectively chainÁ ¼¹$ the edges together.Á Ñ$ ú üÕ$ # Memory orders around debtsÁ ö$ ú üú$[ X The linked list of debt nodes only grows. The shape of the list (existence of nodes) isÁ üÖ%U R synchronized through Release on creation and Acquire on load on the head pointer.Á ¬& ú
|
|||
|
|
Ϛ
|
|||
|
|
ü $ ! Limitations and common pitfalls.Á % ú Œ) # Sized typesÁ ; ú ü?g d This currently works only for `Sized` types. Unsized types have „fat pointers“, which are twiceÁ ü§` ] as large as the normal ones. The [`AtomicPtr`] doesn't support them. One could use somethingÁ üˆ` ] like `AtomicU128` for them. The catch is this doesn't exist and the difference would make itÁ üéL I really hard to implement the debt storage/stripped down hazard pointers.Á ¶ ú üº. + A workaround is to use double indirection:Á é ú \í ¯‹ äù ‡’ Ì– // This doesn't work:Á ü°D A // let data: ArcSwap<[u8]> = ArcSwap::new(Arc::from([1, 2, 3]));Á õ ú ¬ù // But this does:Á ü�N K let data: ArcSwap<Box<[u8]>> = ArcSwap::from_pointee(Box::new([1, 2, 3]));Á ŒÞ # drop(data);Á <ð ˆ� ø ú üü] Z It also may be possible to use `ArcSwap` with the [`triomphe::ThinArc`] (that crate needsÁ üÚ9 6 enabling a feature flag to cooperate with `ArcSwap`).Á ” ú ̘ # Too many [`Guard`]sÁ ² ú ü¶^ [ There's only limited number of "fast" slots for borrowing from [`ArcSwap`] for each singleÁ ü•c ` thread (currently 8, but this might change in future versions). If these run out, the algorithmÁ ôù falls back to slower path.Á ˜ ú üœ a ^ If too many [`Guard`]s are kept around, the performance might be poor. These are not intendedÁ üþ F C to be stored in data structures or used across async yield points.Á Å
|
|||
|
|
ú üÉ
|
|||
|
|
‘Â Üé
|
|||
|
|
[`Guard`]: crate::GuardÁ ü… / ßð µ ú ü¹ # No `Clone` implementationÁ Ù ú üÝ c ` Previous version implemented [`Clone`], but it turned out to be very confusing to people, sinceÁ üÁ ] Z it created fully independent [`ArcSwap`]. Users expected the instances to be tied to eachÁ üŸ
|
|||
|
|
Q N other, that store in one would change the result of future load of the other.Á ñ
|
|||
|
|
ú üõ
|
|||
|
|
F C To emulate the original behaviour, one can do something like this:Á ¼ ú \À ¯‹ äÌ ‡’ üé* ' # let old = ArcSwap::from_pointee(42);Á ü”, ) let new = ArcSwap::new(old.load_full());Á ”Á # let _ = new;Á <Ô ˆ� Ü ú üàW T [`triomphe::ThinArc`]: https://docs.rs/triomphe/latest/triomphe/struct.ThinArc.htmlÁ \þ
|
|||
|
|
„‹
|
|||
|
|
¼
|
|||
|
|
Common use patternsÁ
|
|||
|
|
ú ü c
|
|||
|
|
` Here are some common patterns one can use for inspiration. These are mostly covered by examplesÁ ü€J
|
|||
|
|
G at the right type in the crate, but this lists them at a single place.Á Ë
|
|||
|
|
ú üÏ#
|
|||
|
|
# Sharing of configuration dataÁ ó
|
|||
|
|
ú ü÷^
|
|||
|
|
[ We want to share configuration from some source with rare updates to some high performanceÁ üÖR
|
|||
|
|
O worker threads. It can be configuration in its true sense, or a routing table.Á ©
|
|||
|
|
ú üa
|
|||
|
|
^ The idea here is, each new version is a newly allocated in its own [`Arc`]. It is then storedÁ ü�'
|
|||
|
|
$ into a *shared* `ArcSwap` instance.Á ·
|
|||
|
|
ú ü»_
|
|||
|
|
\ Each worker then loads the current version before each work chunk. In case a new version isÁ ü›_
|
|||
|
|
\ stored, the worker keeps using the loaded one until it ends the work chunk and, if it's theÁ üûX
|
|||
|
|
U last one to have the version, deallocates it automatically by dropping the [`Guard`]Á Ô
|
|||
|
|
ú üØ^
|
|||
|
|
[ Note that the configuration needs to be passed through a *single shared* [`ArcSwap`]. ThatÁ ü·`
|
|||
|
|
] means we need to share that instance and we do so through an [`Arc`] (one could use a globalÁ ´˜
|
|||
|
|
variable instead).Á ¯
|
|||
|
|
ú ü³6
|
|||
|
|
3 Therefore, what we have is `Arc<ArcSwap<Config>>`.Á ê
|
|||
|
|
ú \î
|
|||
|
|
¯‹ Ìú
|
|||
|
|
# use std::sync::Arc;Á ü” 4
|
|||
|
|
1 # use std::sync::atomic::{AtomicBool, Ordering};Á ´É
|
|||
|
|
# use std::thread;Á ôà
|
|||
|
|
# use std::time::Duration;Á ,ÿ
|
|||
|
|
#Á ä…
|
|||
|
|
|
|||
|
|
‡’ ”¢
|
|||
|
|
|
|||
|
|
# struct Work;Á üµ
|
|||
|
|
P
|
|||
|
|
M # impl Work { fn fetch() -> Self { Work } fn perform(&self, _: &Config) {} }Á ,†
|
|||
|
|
ù� ìŒ
|
|||
|
|
#[derive(Debug, Default)]Á œª
|
|||
|
|
struct Config {Á ü¾
|
|||
|
|
// ... Stuff in here ...Á ,ß
|
|||
|
|
Å� å
|
|||
|
|
ú üé K
|
|||
|
|
H // We wrap the ArcSwap into an Arc, so we can share it between threads.Á üµ D
|
|||
|
|
A let config = Arc::new(ArcSwap::from_pointee(Config::default()));Á ú
|
|||
|
|
ú üþ 5
|
|||
|
|
2 let terminate = Arc::new(AtomicBool::new(false));Á ü´
|
|||
|
|
!
|
|||
|
|
let mut threads = Vec::new();Á Ö
|
|||
|
|
|
|||
|
|
ú üÚ
|
|||
|
|
|
|||
|
|
// The configuration threadÁ üú
|
|||
|
|
|
|||
|
|
threads.push(thread::spawn({Á ü›)
|
|||
|
|
& let config = Arc::clone(&config);Á üÅ/
|
|||
|
|
, let terminate = Arc::clone(&terminate);Á Œõ
|
|||
|
|
move || {Á ü‡6
|
|||
|
|
3 while !terminate.load(Ordering::Relaxed) {Á ü¾6
|
|||
|
|
3 thread::sleep(Duration::from_secs(6));Á üõ3
|
|||
|
|
0 // Actually, load it from somewhereÁ ü©=
|
|||
|
|
: let new_config = Arc::new(Config::default());Á üç)
|
|||
|
|
& config.store(new_config);Á l‘
|
|||
|
|
èË LŸ
|
|||
|
|
ž« D©
|
|||
|
|
À† ²
|
|||
|
|
ú Ķ
|
|||
|
|
// The worker threadÁ ¤Ï
|
|||
|
|
for _ in 0..10 {Á üä$
|
|||
|
|
! threads.push(thread::spawn({Á ü‰-
|
|||
|
|
* let config = Arc::clone(&config);Á ü·3
|
|||
|
|
0 let terminate = Arc::clone(&terminate);Á ¬ë
|
|||
|
|
move || {Á ü�:
|
|||
|
|
7 while !terminate.load(Ordering::Relaxed) {Á ü¼-
|
|||
|
|
* let work = Work::fetch();Á üê/
|
|||
|
|
, let config = config.load();Á üš*
|
|||
|
|
' work.perform(&config);Á ŒÅ
|
|||
|
|
ìª l×
|
|||
|
|
èË då
|
|||
|
|
}));Á ,ò
|
|||
|
|
Å� ø
|
|||
|
|
ú Üü
|
|||
|
|
// Terminate gracefullyÁ ü˜-
|
|||
|
|
* terminate.store(true, Ordering::Relaxed);Á ÜÆ
|
|||
|
|
for thread in threads {Á üâ
|
|||
|
|
thread.join().unwrap();Á ,‚
|
|||
|
|
Å� <ˆ
|
|||
|
|
ˆ� �
|
|||
|
|
ú Ô”
|
|||
|
|
# Consistent snapshotsÁ ¯
|
|||
|
|
ú ü³Z
|
|||
|
|
W While one probably wants to get a fresh instance every time a work chunk is available,Á üŽb
|
|||
|
|
_ therefore there would be one [`load`] for each work chunk, it is often also important that theÁ üñ[
|
|||
|
|
X configuration doesn't change in the *middle* of processing of one chunk. Therefore, oneÁ üÍc
|
|||
|
|
` commonly wants *exactly* one [`load`] for the work chunk, not *at least* one. If the processingÁ ü±;
|
|||
|
|
8 had multiple phases, one would use something like this:Á í
|
|||
|
|
ú \ñ
|
|||
|
|
¯‹ Ìý
|
|||
|
|
ÓŽ ,—
|
|||
|
|
ù� ä�
|
|||
|
|
‡’ ¤º
|
|||
|
|
# struct Config;Á ”Ï
|
|||
|
|
”� Œâ
|
|||
|
|
# impl Work {Á üô%
|
|||
|
|
" # fn fetch() -> Self { Work }Á üš*
|
|||
|
|
' # fn phase_1(&self, _: &Config) {}Á üÅ*
|
|||
|
|
' # fn phase_2(&self, _: &Config) {}Á <ð
|
|||
|
|
# }Á üø;
|
|||
|
|
8 # let config = Arc::new(ArcSwap::from_pointee(Config));Á ì´
|
|||
|
|
let work = Work::fetch();Á üÒ
|
|||
|
|
let config = config.load();Á Ôò
|
|||
|
|
work.phase_1(&config);Á ü� )
|
|||
|
|
& // We keep the same config value hereÁ Ô·
|
|||
|
|
work.phase_2(&config);Á <Ò
|
|||
|
|
ˆ� Ú
|
|||
|
|
ú tÞ
|
|||
|
|
Over this:Á í
|
|||
|
|
ú \ñ
|
|||
|
|
¯‹ Ìý
|
|||
|
|
ÓŽ ,—
|
|||
|
|
ù� ä�
|
|||
|
|
‡’ ¤º
|
|||
|
|
Õ£ ”Ï
|
|||
|
|
”� Œâ
|
|||
|
|
ÿ£ üô %
|
|||
|
|
š¤ üš *
|
|||
|
|
ɤ üÅ *
|
|||
|
|
ý¤ <ð
|
|||
|
|
°¥ üø ;
|
|||
|
|
Á¥ ì´
|
|||
|
|
…¦ üÒ !
|
|||
|
|
work.phase_1(&config.load());Á üô _
|
|||
|
|
\ // WARNING!! This is broken, because in between phase_1 and phase_2, the other thread couldÁ üÔ!a
|
|||
|
|
^ // have replaced the config. Then each phase would be performed with a different one and thatÁ ü¶"
|
|||
|
|
// could lead to surprises.Á üÖ"!
|
|||
|
|
work.phase_2(&config.load());Á <ø"
|
|||
|
|
ˆ� €#
|
|||
|
|
ú ü„#"
|
|||
|
|
# Caching of the configurationÁ §#
|
|||
|
|
ú ü«#b
|
|||
|
|
_ Let's say that the work chunks are really small, but there's *a lot* of them to work on. MaybeÁ üŽ$`
|
|||
|
|
] we are routing packets and the configuration is the routing table that can sometimes change,Á ¼ï$
|
|||
|
|
but mostly doesn't.Á ‡%
|
|||
|
|
ú ü‹%c
|
|||
|
|
` There's an overhead to [`load`]. If the work chunks are small enough, that could be measurable.Á üï%[
|
|||
|
|
X We can reach for [`Cache`]. It makes loads much faster (in the order of accessing localÁ üË&
|
|||
|
|
œ�
|
|||
|
|
ü Performance characteristics.Á !ú ü%L I There are several performance advantages of [`ArcSwap`] over [`RwLock`].Á rú Äv ## Lock-free readersÁ �ú ü“W T All the read operations are always [lock-free]. Most of the time, they are actuallyÁ üë\ Y [wait-free]. They may wait from time to time, with at least `usize::MAX / 4` [wait-free]Á ôÈ accesses in between waits.Á çú äë Writers are [lock-free].Á ˆú üŒ_ \ Whenever the documentation talks about *contention* in the context of [`ArcSwap`], it talksÁ üìe b about contention on the CPU level ‒ multiple cores having to deal with accessing the same cacheÁ üÒ\ Y line. This slows things down (compared to each one accessing its own cache line), but anÁ ü¯b _ eventual progress is still guaranteed and the cost is significantly lower than parking threadsÁ ü’# as with mutex-style contention.Á ¶ú lº
|
|||
|
|
## SpeedsÁ Èú üÌZ W The base line speed of read operations is similar to using an *uncontended* [`Mutex`].Á ü§Z W However, [`load`] suffers no contention from any other read operations and only slightÁ ü‚V S ones during updates. The [`load_full`] operation is additionally contended only onÁ üÙY V the reference count of the [`Arc`] inside ‒ so, in general, while [`Mutex`] rapidlyÁ ü³ R O loses its performance when being in active use by multiple threads at once andÁ ü†
|
|||
|
|
` ] [`RwLock`] is slow to start with, [`ArcSwap`] mostly keeps its performance even when read byÁ ìç
|
|||
|
|
many threads in parallel.Á … ú ü‰ a ^ Write operations are considered expensive. A write operation is more expensive than access toÁ üë U R an *uncontended* [`Mutex`] and on some architectures even slower than uncontendedÁ üÁ C @ [`RwLock`]. However, it is faster than either under contention.Á …
|
|||
|
|
ú ü‰
|
|||
|
|
b _ There are some (very unscientific) [benchmarks] within the source code of the library, and theÁ üì
|
|||
|
|
Y V [`DefaultStrategy`][crate::DefaultStrategy] has some numbers measured on my computer.Á Æú üÊb _ The exact numbers are highly dependent on the machine used (both absolute numbers and relativeÁ üc ` between different data structures). Not only architectures have a huge impact (eg. x86 vs ARM),Á ü‘` ] but even AMD vs. Intel or two different Intel processors. Therefore, if what matters is moreÁ üòX U the speed than the wait-free guarantees, you're advised to do your own measurements.Á Ëú üÏI F Further speed improvements may be gained by the use of the [`Cache`].Á ™ú ”� ## ConsistencyÁ °ú ü´] Z The combination of [wait-free] guarantees of readers and no contention between concurrentÁ ü’a ^ [`load`]s provides *consistent* performance characteristics of the synchronization mechanism.Á üô` ] This might be important for soft-realtime applications (the CPU-level contention caused by aÁ üÕ] Z recent update/write operation might be problematic for some hard-realtime cases, though).Á ³ú ü·+ ( ## Choosing the right reading operationÁ ãú üçV S There are several load operations available. While the general go-to one should beÁ ü¾M J [`load`], there may be situations in which the others are a better match.Á Œú ü�Z W The [`load`] usually only borrows the instance from the shared [`ArcSwap`]. This makesÁ üë\ Y it faster, because different threads don't contend on the reference count. There are twoÁ üÈY V situations when this borrow isn't possible. If the content gets changed, all existingÁ ü¢V S [`Guard`]s are promoted to contain an owned instance. The promotion is done by theÁ üùa ^ writer, but the readers still need to decrement the reference counts of the old instance whenÁ üÛ3 0 they no longer use it, contending on the count.Á �ú ü“c ` The other situation derives from internal implementation. The number of borrows each thread canÁ ü÷] Z have at each time (across all [`Guard`]s) is limited. If this limit is exceeded, an ownedÁ üÕ instance is created instead.Á ö ú üú a ^ Therefore, if you intend to hold onto the loaded value for extended time span, you may preferÁ üÜ V S [`load_full`]. It loads the pointer instance ([`Arc`]) without borrowing, which isÁ ü³ b _ slower (because of the possible contention on the reference count), but doesn't consume one ofÁ ü– [ X the borrow slots, which will make it more likely for following [`load`]s to have a slotÁ üò ` ] available. Similarly, if some API needs an owned `Arc`, [`load_full`] is more convenient andÁ üÓ L I potentially faster then first [`load`]ing and then cloning that [`Arc`].Á !ú ü¤![ X Additionally, it is possible to use a [`Cache`] to get further speed improvement at theÁ ü€"\ Y cost of less comfortable API and possibly keeping the older values alive for longer thanÁ tÝ" necessary.Á ì"ú üð" ‘ ü�#"ò٠ܳ#èý üÏ#%к üõ#/ , [`load_full`]: crate::ArcSwapAny::load_fullÁ Ü¥$Ôï üÁ$ [`Mutex`]: std::sync::MutexÁ üá$! [`RwLock`]: std::sync::RwLockÁ üƒ%H E [benchmarks]: https://github.com/vorner/arc-swap/tree/master/benchesÁ üÌ%R O [lock-free]: https://en.wikipedia.org/wiki/Non-blocking_algorithm#Lock-freedomÁ üŸ&R O [wait-free]: https://en.wikipedia.org/wiki/Non-blocking_algorithm#Wait-freedomÁ \¥
|
|||
|
|
\¹- <½- Çí
|
|||
|
|
ë Á µ I “ Á ÃK d †J Á Å ‹Æi òH Á Æ ŠäY : „¾ Á ìLlLC]tSOQ;=ô¤ üo8 5 A trait describing smart reference counted pointers.Á ¨ú ü¬a ^ Note that in a way [`Option<Arc<T>>`][Option] is also a smart reference counted pointer, justÁ ÜŽ one that can hold NULL.Á ªú ü®S P The trait is unsafe, because a wrong implementation will break the [ArcSwapAny]Á ü‚" implementation and lead to UB.Á ¥ú ü©` ] This is not actually expected for downstream crate to implement, this is just means to reuseÁ üŠb _ code for [Arc] and [`Option<Arc>`][Option] variants. However, it is theoretically possible (ifÁ üí, ) you have your own [Arc] implementation).Á šú üžX U It is also implemented for [Rc], but that is not considered very useful (because theÁ ü÷^ [ [ArcSwapAny] is not `Send` or `Sync`, therefore there's very little advantage for it to beÁ dÖ atomic).Á ãú dç # SafetyÁ ôú üø` ] Aside from the obvious properties (like that incrementing and decrementing a reference countÁ üÙb _ cancel each out and that having less references tracked than how many things actually point toÁ ü¼_ \ the value is fine as long as the count doesn't drop to 0), it also must satisfy that if twoÁ üœ b _ pointers have the same value, they point to the same object. This is specifically not true forÁ üÿ b _ ZSTs, but it is true for `Arc`s of ZSTs, because they have the reference counts just after theÁ üâ
|
|||
|
|
` ] value. It would be fine to point to a type-erased version of the same object, though (if oneÁ üà @ = could use this trait with unsized types in the first place).Á „ ú üˆ 4 1 Methods in this trait must not panic nor unwind.Á ½ ú üÁ \ Y Furthermore, the type should be Pin (eg. if the type is cloned or moved, it should stillÁ üž
|
|||
|
|
- * point/deref to the same place in memory).Á Ì
|
|||
|
|
ú ÌÐ
|
|||
|
|
Ñ´ ¬ê
|
|||
|
|
[Rc]: std::rc::RcÁ ü€# [ArcSwapAny]: crate::ArcSwapAnyÁ 4µ Ç Ç �Øü¤© Ø˜Ø ,½ Ç �Ø* ‘™ �Ø6 ‘™*ÈÉÊËÌÍÈÉÊËÌÍ Íì˜Ø È Tö â™ Í Ë É Ì Ê Lö üÉ( % The base type the pointer points to.Á$û Ç Ç ü‡) ü†Y V Converts the smart pointer into a raw pointer, without affecting the reference count.Á äú üì\ Y This can be seen as kind of freezing the pointer ‒ it'll be later converted back usingÁ üÍ# [`from_ptr`](#method.from_ptr).Á õú üý^ [ The pointer must point to the value stored (and the value must be the same as one returnedÁ üà" by [`as_ptr`](#method.as_ptr).ÁDŠ ˜Ø ê™ Ç Ç
|
|||
|
|
É˜Ø meÁ“üÒ( ü¶< 9 Provides a view into the smart pointer as a raw pointer.Á ÷ú üÿN K This must not affect the reference count ‒ the pointer is only borrowed.Á4Õ Ñ Ñ˜Ø §ž Ç à Ç
|
|||
|
|
ʘØÈ�Üü‚3 ü€^ [ Converts a raw pointer back into the smart pointer, without affecting the reference count.Á ãú üëX U This is only called on values previously returned by [`into_ptr`](#method.into_ptr).Á üÈa ^ However, it is not guaranteed to be 1:1 relation ‒ `from_ptr` may be called more times thanÁ ü®\ Y `into_ptr` temporarily provided the reference count never drops under 1 during that timeÁ ü�X U (the implementation sometimes owes a reference). These extra pointers will either beÁ üì1 . converted back using `into_ptr` or forgotten.Á ¢ú dª°� »ú üÃ: 7 This must not be called by code outside of this crate.ÁDŒ ê™ ˜Ø Ç Ç
|
|||
|
|
˘ص •ü²$ ü»* ' Increments the reference count by one.Á êú üò; 8 Return the pointer to the inner thing as a side effect.Á µ Ò Ò˜Ø §ž Ç ½ Ç
|
|||
|
|
̘ØÈ�¹üû % üŒ* ' Decrements the reference count by one.Á »ú üÃD A Note this is called on a raw pointer (one previously returned byÁ üŒ ] Z [`into_ptr`](#method.into_ptr). This may lead to dropping of the reference count to 0 andÁ üî ( % destruction of the internal pointer.Á › ú d£ °� ´ ú ü¼ :Ϥ … £¦™j Ç Ç
|
|||
|
|
͘ص ‰ üÏ ¥ Ï Ï ‹ß Û ñFÐÑÒÓ È É Ê Ë Ò Ñ Ó /1 Lö $û Î Î ÄDü‰ !DŒ ñF§R Î Î
|
|||
|
|
ÑÄDÈ�• üÛ 4Þ Ó ÓñF §R Î é Î
|
|||
|
|
ÒÄDÈ�å üÈ)+DÒ) ¾RñF Î Î
|
|||
|
|
ÓÄDµ Û)üš* ¥ Õ Õ ‹ß ¦*ùHÖ×ØÙ È É Ê Ë Ù Ø × /1 LÀ*$Å* Ô Ô ÄDüÓ* DÖ* ùH§R Ô Ô
|
|||
|
|
×ÄDÈ�ß*ü£+ 4¦+ Ô ÔùH §R Ô ±+ Ô
|
|||
|
|
ØÄDÈ�+ü�5*D—5 ¾RùH Ô Ô
|
|||
|
|
ÙÄDµ 5üÝ5+ ¥ Û Û ‹ß é5 ˜æ4ì5‰ZÜÝÞß È É Ê Ë Þ Ý ß 79 L�6$”6 Ú Ú —Rü¨6*D«6 ‰Zð° Ú Ú
|
|||
|
|
ÝÄDÈ�´6ü™7)4œ7 Õ Õ‰Z ð° Ú §7 Ú
|
|||
|
|
ÞÄDÈ�£7ü�84Dš8 ¼¡‰Z Ú Ú
|
|||
|
|
ßÄDµ £8„ë- ü 3 0 Strategies for protecting the reference counts.Á 4ú ü8a ^ There are multiple algorithms how t
|
|||
|
|
strategy.Á ðú üôb _ For now, the traits in here are sealed and don't expose any methods to the users of the crate.Á ü×\ Y This is because we are not confident about the details just yet. In the future it may beÁ ü´] Z possible for downstream users to implement their own, but for now it is only so users canÁ ü’ choose one of the provided.Á ²ú ü¶a ^ It is expected that future strategies would come with different capabilities and limitations.Á ü˜b _ In particular, some that are not "tight" in the cleanup (delay the cleanup) or not support theÁ üû compare and swap operations.Á œú ü ( % Currently, we have these strategies:Á Éú üÍ7 4 * [`DefaultStrategy`] (this one is used implicitly)Á ü…' $ * [`RwLock<()>`][std::sync::RwLock]Á ú l±
|
|||
|
|
# TestingÁ ¿ú üÃb _ Formally, the [`RwLock<()>`][std::sync::RwLock] may be used as a strategy too. It doesn't haveÁ ü¦ a ^ the performance characteristics or lock-free guarantees of the others, but it is much simplerÁ üˆ
|
|||
|
|
c ` and contains less `unsafe` code (actually, less code altogether). Therefore, it can be used forÁ üì
|
|||
|
|
( % testing purposes and cross-checking.Á • ú ü™ [ X Note that generally, using [`RwLock<Arc<T>>`][std::sync::RwLock] is likely to be betterÁ üõ [ X performance wise. So if the goal is to not use third-party unsafe code, only the one inÁ üÑ ` ] [`std`], that is the better option. This is provided mostly for investigation and testing ofÁ ü²
|
|||
|
|
@ = [`ArcSwap`] itself or algorithms written to use [`ArcSwap`].Á ó
|
|||
|
|
ú ü÷
|
|||
|
|
6 3 *This is not meant to be used in production code*.Á ®ú ü² ‘ üÒ%к Dó- 䞟 °µY4‹ à á¶yL« ¯] à â» 4Ë Ç à ãÜ;l� ù à œÜ; ú à œ�<tž ÿ à �¤ýì—p´»a¬Ô 4ã õ‰ùúÿY4« ä åí$à ë ä ç ManuallyDropÁdÉ ÃÛ ä èr,ç é! ä éµ ø “ ä ê¶yL• ¯] ä ëÁ' Ú ¬ ä îŒ'lß § ä ï¤%Lî £ ä ð×:$Œ ç ä ò×: è ä ò¬ L’ œ ä ó À» 4² Ç ä ôËe± ½À ä ìËz± ¾À ä ìÌc± ¿À ä ìÌx± ÀÀ ä ìGa± ÁÀ ä ìGu± ÂÀ ä ìF_± ÃÀ ä ìFs± ÄÀ ä ì×]± ÅÀ ä ì×r± ÆÀ ä ì¤�úL·ì ½ÒÕ„ÜÇLò¹ì�«ä¤lÊ¡¤’•ƒ†\þx{TW´¢Eü»& „Æ ¥ ö ö ‹ß × ˜æ4ÚÑ[ ¹Òóû÷O ¡ ÷ø �*, Üè$èä õ õ �˜¤‰ ‰ ä õ õ ÃÛÃÛ ËÅ ÅÛ»¬ „ µÜÀ,�%*ÄDü¢ # ¥ ú ú ‹ß § ˜æ4ª Ñ[ûüýþ üÌ R á à ¼¡�˜Ñ[ ù ù
|
|||
|
|
ûÄDµ å …$ú üÈ J<Ë ä Ö × ÖæX פ]¤] V ¦]Á‚] üß3ø¤”&ð° ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙÑ[ ù Ù ù
|
|||
|
|
üÄD½ $Ó storageÁ<å üÕCDØ ä Ø Ù ØæX Ù�Î Ñ[ ù ç ù
|
|||
|
|
ýÄD½ $á¼Î<óüß""4â" ä Ú ÚÑ[ ¼¡ ù é" ù
|
|||
|
|
þÄD$ê"ü±#, ¥ € € ‹ß ¶# ˜æ4¹#Ñ[� �" � ”ò#$õ# Û ÛÑ[™j ÿ ú# ÿ
|
|||
|
|
�ÄD$ÿ#ü‡*4 ¥ ƒ ƒ ‹ß Œ* ˜æ4�*Ñ[„… ¦ ¥ … „ %' ìÐ*TÓ* ÄDÑ[ ‚ ‚
|
|||
|
|
„ÄDµ Þ*äã+Tæ+ Ñ[ÄD ‚ ‚
|
|||
|
|
…ÄD$õ+üò11 ¥ ‡ ‡ ‹ß ÷1 ˜æ4ú1Ñ[ˆ ¢ ˆ ´¸24»2 Ü ÜÑ[ ÜÄD † Â2 †
|
|||
|
|
ˆÄD$Ã2„ì2 4ö2 ‰ ‰ �Øüì2e ‰ �Ø �Ø ŠŠ ¤º3DÀ3 ‰ ‰ ìˆ4 ¢QŒ Š ¤¬4D²4 ‹ ‹ ü§5[ ¥ Ž ™% � Ž � ‹ß ¬5 Íì¾] ¯5 ˜æ4ê5 ‰¾] 4û5‘]�‘” © ª « ” ‘ KM HJ t‰6LŽ6 � � Ñ[ü³6F$½6 Ý Þ Ý‘] Þ�Î ‘]ÄD © � Â6 �
|
|||
|
|
‘ÄD¾]$Ã6¼Î<É64”7 ‘Ë ’ Ü‹ ’ ú‹ ’ ’ ‘ ’ÄD¾] ÕÑ[ �Î Ù8 ‘Ë “ Ü‹ “ ú‹ “ “ ‘ “ÄD¾] ™jÑ[ ®¦êÙüœ9T„¦9 ß à ß‘] ¼¡ à�Î ™j � ·9 �
|
|||
|
|
”ÄD¾]$¸9 oldÁ ¾9¼Î<Ó9Ï< ”Ë • Ü‹ • ú‹ • • ” •ÄD¾]‡j ™jÄD ‘] êÙüË=; ¥ — ™% ˜ ˜ — ‹ß Ð= …× Û= ˜æ4Ó= �×4à=‘]™ ® ™ *, /1 ü�>¯„—> á â á‘] â�Î ”ÄDÂØ –” š š Ó> – Íì•Þ ¨> y•Þ—R ì«>
|
|||
|
|
™ÄD¾]•Þ$Ô>¼Î<â> currentÁ<ˆ?æ œ?LN d€ð ó Ì Ï Ä¨% Ì° The default strategy.Á Êú üÎB ? It is used by the type aliases [`ArcSwap`][crate::ArcSwap] andÁ ü‘b
|
|||
|
|
# ExampleÁ �=ú \‰=¯‹ ü™=6 3 # use arc_swap::{ArcSwap, DefaultStrategy, Guard};Á ÌÔ=ÓŽ üò=( % # let p = ArcSwap::from_pointee(42);Á üŸ>4 1 // Create two guards pointing to the same objectÁ ´Ø> let g1 = p.load();Á üó>G D let g2 = Guard::<_, DefaultStrategy>::from_inner(Arc::clone(&*g1));Á |¿? # drop(g2);Á <Ó?ˆ�Tæ? ÄDõ] Ý Ý
|
|||
|
|
áÄDòEÓ),ñ?üÜ@5 ¥ ã ¤ ä ä ã ‹ß á@ ˆæ ì@ ˜æ4ä@ §æ\ï@õ]åæ ê! ë! æ 13 68 \˜A4�A â â ÄD¬»A,¾A é éõ] éÄD â ÄA â
|
|||
|
|
æÄDòE$ÅAüøA7 ¥ è ¤ é è é ‹ß ýA ˆæ ˆB ˜æ4€B §æ\‹Bõ]ê ë ê *, /1 ̶B$¹B ÄDõ] ç ç
|
|||
|
|
êÄDòEÓ),¾BüûBA ¥ ì ¤ í ì í ‹ß €C ˆæ •C ³ ÄD <ƒC ˜æ4�C §æ\˜Cõ]î ´ î 9; >@ ¤ÃC<ÆC õ] ë ë
|
|||
|
|
îÄDòEü„D= ¥ ð ¤ ñ ð ñ ‹ß ‰D ˆæ œD ¿cÄD ,ŒD ˜æ4”D §æ\ŸDõ]ò Àc ò 9; >@ üÈD5 ËD ê ë ì êõ] ë c c ˆ ¢cµ
|
|||
|
|
` £c bufÁ ` àB¤GS
|
|||
|
|
ìÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
™jŸÈŸÈ È ErrorÁ O˜éBL ï ÏD ï
|
|||
|
|
òÄDòE$ÐD formatterÁLÖDüEA ¥ ô ¤ õ ô õ ‹ß ²E ˆæ ÇE ÄcÄD <µE ˜æ4¿E §æ\ÊEõ]ö Åc ö 9; >@ üõE5 øE í î ï íõ] î c c ˆ ¢cµ
|
|||
|
|
` £cÒ¦ ` àB¤GS
|
|||
|
|
ïù§ ó üE ó
|
|||
|
|
öÄDòE$ýE ¨LƒFüHW4°H ×J“ É ø ’ ù “ ú ø ú ù Íì É $·H ±û ½H Í씬 ÀH y×JÛ¬ \äH y”¬Û¬ \øH
|
|||
|
|
÷Û¬×J”¬¬ ÃH ÉHbd gi ce ü¹[B üÌIZ W An atomic storage for a reference counted smart pointer like [`Arc`] or `Option<Arc>`.Á §Jú ü«J` ] This is a storage where a smart pointer may live. It can be read and written atomically fromÁ üŒK; 8 several threads, but doesn't act like a pointer itself.Á ÈKú üÌKL I One can be created [`from`] an [`Arc`]. To get the pointer back, use theÁ Ü™L [`load`](#method.load).Á µLú T¹L # NoteÁ ÄLú üÈL\ Y This is the common generic implementation. This allows sharing the same code for storingÁ ü¥MD A both `Arc` and `Option<Arc>` (and possibly other similar types).Á êMú üîMH E In your code, you most probably want to interact with it through theÁ ü·Nc ` [`ArcSwap`](type.ArcSwap.html) and [`ArcSwapOption`](type.ArcSwapOption.html) aliases. However,Á ü›O` ] the methods they share are described here and are applicable to both of them. That's why theÁ üüO] Z examples here use `ArcSwap` ‒ but they could as well be written with `ArcSwapOption` orÁ ŒÚP `ArcSwapAny`.Á ìPú ¬ðP # Type parametersÁ †Qú üŠQc ` * `T`: The smart pointer to be kept inside. This crate provides implementation for `Arc<_>` andÁ üîQ` ] `Option<Arc<_>>` (`Rc` too, but that one is not practically useful). But third party couldÁ üÏRI F provide implementations of the [`RefCnt`] trait and plug in others.Á ü™SY V * `S`: Chooses the [strategy] used to protect the data inside. They come with variousÁ üóS` ] performance trade offs, the default [`DefaultStrategy`] is good rule of thumb for most useÁ dÔT cases.Á áTú tåT¾¤ ôTú \øT¯‹ Ì„UÓŽ äžU‡’ Ü»U let arc = Arc::new(42);Á ü×U& # let arc_swap = ArcSwap::from(arc);Á üþU& # assert_eq!(42, **arc_swap.load());Á ü¥V$ ! // It can be read multiple timesÁ üÊV&–» ñVú ìõV // Put a new one in thereÁ ô“W let new_arc = Arc::new(0);Á ü²W, ) assert_eq!(42, *arc_swap.swap(new_arc));Á üßW% " assert_eq!(0, **arc_swap.load());Á <…Xˆ� �Xú „‘X
|
|||
|
|
# Known bugsÁ ¢Xú ü¦X` ] Currently, things like `ArcSwapAny<Option<Option<Arc<_>>>>` (notice the double Option) don'tÁ ü‡Y9 6 work properly. A proper solution is being looked intoÁ üÁY7 4 ([#81](https://github.com/vorner/arc-swap/issues)).Á ùYú üýY? < [`Arc`]: https://doc.rust-lang.org/std/sync/struct.Arc.htmlÁ ü½ZY V [`from`]: https://doc.rust-lang.org/nightly/std/convert/trait.From.html#tymethod.fromÁ ü—[! [`RefCnt`]: trait.RefCnt.htmlÁ TÄ[ ¥ ü ¤ ý ü ý ‹ß Ï[ ˆæüÚ[ ˜æ4Ò[ §æ\Ý[¬E ë§oŽB‹ þÿ€ ˆ=? B Ú[ õP ¼Ú\ Ú\ û û �Îäæ]dæ] û û • • – ³o Fu\»ŸÄD\¯^D¯^ û û òEü¿^F ¥ ‚ ¤ ƒ ‚ ƒ ‹ß Ä^ ˆæ Ï^ ˜æ4Ç^ ³ òE <Ò^ §æ\Ü^¬E„ ë „ 9; >@ ¼Œ_$�_ ÄD¬E � �
|
|||
|
|
„ÄDòE¹ ”_üÞ_9 ¥ † ¤ ‡ ‡ † ‹ß ã_ ˆæ î_ ˜æ4æ_ §æ\ñ_¬Eˆ �" ˆ *, /1 ”ž`$¡` ð ð¬E™j … ¦` …
|
|||
|
|
ˆÄDòE$«`üºbO ¥ Š ¤ ‹ ‹ Š ‹ß ¿b ˆæ Âb §æ\Åb ¨¦,úb ˜æ4‚c¬EŒ Àc Œ 24 79 ü�c5 “c ñ ò ó ñ¬E ò c c ˆ ¢cµ
|
|||
|
|
` £cÒ¦ ` àB¤GS
|
|||
|
|
óù§ ‰ —c ‰
|
|||
|
|
ŒÄDòE$˜c ¨LžcüÁdS ¥ Ž ¤ � Ž � ‹ß Æd ˆæ Éd §æ\Ìd í©<ƒe ˜æ4�e¬E� Åc � 24 79 ü›e5 že ô õ ö ô¬E õ c c ˆ ¢cµ
|
|||
|
|
` £cÒ¦ ` àB¤GS
|
|||
|
|
öù§ � ¢e �
|
|||
|
|
�ÄDòE$£e ¨L©eüÿeP ¥ ’ ¤ “ “ ’ ‹ß „f ˆæ ™f ˜æ4‡f æ¤<�f �Å<œf §æ\¦f¬E” ´ ” :< ?A ¤Öf<Ùf ¬E ‘ ‘
|
|||
|
|
”ÄDòEü–g0 ¥ – ¤ — – — ‹ß ›g ˆæ ¦g ˜æ4žg §æ\©g¬E˜™š›œ�žŸ¡¤ =? BD üïg8 ìÍg Constructs a new storage.Á ög ÄD¬E • • �Å<Ÿh
|
|||
|
|
˜ÄDòE¹ úgü�i1 üÑhG D Constructs a new storage while customizing the protection strategy.Ál¤i ÄDòE¬E • •
|
|||
|
|
™ÄDòE¹ ²iŸ"Dºiü‡m ôäl Extracts the value inside.ÁTŽm ¬EÄD • •
|
|||
|
|
šÄDòE$�mäÁq ¤þn Loads the value.Á —oú üŸoQ N This makes another copy of the held pointer and returns it, atomically (it isÁ üõoP M safe even when other thread stores into the same instance at the same time).Á Êpú üÒpJ G The method is lock-free and wait-free, but usually more expensive thanÁ Ü¡qú¯LÈq ÷ ÷¬E ÄD • Òq •
|
|||
|
|
›ÄDòE$Óqüâ‚! ü’r5 2 Provides a temporary borrow of the object inside.Á Ìrú üÔrZ W This returns a proxy object allowing access to the thing held inside. However, there'sÁ ü³s^ [ only limited amount of possible cheap proxies in existence for each thread ‒ if more areÁ ü–tX U created, it falls back to equivalent of [`load_full`](#method.load_full) internally.Á ótú üût] Z This is therefore a good choice to use for eg. searching a data structure or juggling theÁ üÝu] Z pointers around a bit, but not as something to store in larger amounts. The rule of thumbÁ ü¿v[ X is this is suited for local variables on stack, but not in long-living data structures.Á Ÿwú Œ§w # ConsistencyÁ ½wú üÅw[ X In case multiple related operations are to be done on the loaded value, it is generallyÁ ü¥x\ Y recommended to call `load` just once and keep the result over calling it multiple times.Á ü†y_ \ First, keeping it is usually faster. But more importantly, the value can change between theÁ üêyZ W calls to load, returning different objects, which could lead to logical inconsistency.Á üÉz: 7 Keeping the result makes sure the same object is used.Á ˆ{ú \�{¯‹ ä {‡’ ”Á{ struct Point {Á ŒØ{ x: usize,Á Œî{ y: usize,Á ,„|Å� Ž|ú ü–|) & fn print_broken(p: &ArcSwap<Point>) {Á üÄ|N K // This is broken, because the x and y may come from different points,Á ü—}> ; // combining into an invalid point that never existed.Á üÚ}& # println!("X: {}", p.load().x);Á ü…~J G // If someone changes the content now, between these two loads, weÁ ÌÔ~ // have a problemÁ üò~& # println!("Y: {}", p.load().y);Á ,�Å� §ú ü¯* ' fn print_correct(p: &ArcSwap<Point>) {Á üÞM J // Here we take a snapshot of one specific point so both x and y comeÁ ì°€ // from the same one.Á ìÒ€ let point = p.load();Á üô€# println!("X: {}", point.x);Á üœ�# println!("Y: {}", point.y);Á ,Ä�Å� üÎ�< 9 # let p = ArcSwap::from_pointee(Point { x: 10, y: 20 });Á Ä�‚ # print_correct(&p);Á ¼¬‚ # print_broken(&p);Á <È‚ˆ�$é‚ ø ø¬E õ] • î‚ •
|
|||
|
|
œÄDòE$ï‚܇… üöƒ, ) Replaces the value inside this instance.Á §„ú ü¯„S P Further loads will yield the new value. Uses [`swap`](#method.swap) internally.Á,Ž… ù ù¬E ÄD™j • ”… •
|
|||
|
|
�ÄDòE$•…¹ ›…ü€† üÎ…- * Exchanges the value inside this instance.Á$‡† ú ú¬E ÄDÄD • Œ† •
|
|||
|
|
žÄDòE$�†æ “†ü¦�| üÁ‰3 0 Swaps the stored A
|
|||
|
|
tÝå êå ìå ùô òå Žæ , óå 8Ð $ôå & øå 8¼ ,úå $ ÿå , �æ 8Ÿ" D‚æ & Šæ 8´ Œæ *�æ “æ öô + �æ žæ ¨æ 8â Ÿæ ¢æ §æ 8‚ $£æ 8 ²æ , ¶æ 8Ð $·æ ¼æ ðô à 8# Êæ 8¤ ,Îæ 'Óæ 8Ó$ 4Õæ 'Ûæ 8 ToOwnedÁ <Ýæ % äæ 8# òæ 8¤ ,öæ 'ûæ 8 stringÁ 4ýæ 'ƒç 8ß 4…ç % ‹ç 8# ™ç 8¤ ,�ç '¢ç 8Á ¤ç '§ç 8ö ©ç % ¬ç 8# ºç 8í $¾ç 'Âç 8ç $Äç 'Èç 8 atomicÁ 4Êç 'Ðç Òç äç 8 $Óç $ ×ç 8ûã \Ùç % åç 8# ôç 8 adaptive_barrierÁ „øç 'ˆè Šè �è 8 BarrierÁ <‹è $ ’è 8 PanicModeÁ L”è % žè 8# ¬è 8 crossbeam_utilsÁ |°è '¿è 8Š 4Áè % Çè 8# Öè 8 ,Úè 'ßè
|
|||
|
|
áè % âè 8 ,ñè 8
|
|||
|
|
ITERATIONSÁ T÷è & �é 8¬ ,ƒé ‰é 7 10Á ‹é % �é + œé �é ¯é 8« ,žé £é ®é 8± T¤é 8! $ðé 8 AsÁ õé ÷é 8¥ øé ùé ûé 8»+ Týé ‡ê 8K ˆê ‹ê 8¥ Œê �ê $ Žê , �ê 8Ÿ" D‘ê ™ê % šê + ¨ê ©ê »ê 8« ,ªê ¯ê ºê 8± T°ê 8! $üê 8 AsoÁ �ë „ë 8¥ …ë †ë ˆë 8»+ TŠë ”ë 8¬ 4•ë ›ë 8K œë Ÿë 8¥ ë ¡ë $ £ë , ¥ë 8Ÿ" D¦ë ®ë % ¯ë < R Similar to the one in doc tests of the lib, but more times and more intensive (weÁü¾ëU < want to torture it a bit).Áô ì + Ëì Ìì Ñì 8‚ $Íì + ßì àì ÷ì 8ä Dáì éì öì 8µ $êì $ îì 8Á 4ðì 8 ·í 8 publishÁ <ºí Áí Âí Äí ó÷ 8 ,Öí 8 READERSÁ <Üí & ãí 8¬ ,åí ëí 7Š íí % îí 8
|
|||
|
|
€î 8 „î 8 †î 7ˆ ‰î !Šî 8�Ï TŒî —î å÷ 0 8 î 8 configÁ 4±î ¸î 8¡Ð ºî '¼î ¾î 8ß 4¿î Åî 'Æî 8> <Èî Ïî Ðî % Ñî 8 çî 8 endedÁ ,ëî ñî 8ûã \óî 'þî 8æ €ï ƒï …ï 7ˆ „ï % †ï 8Š 4œï '¢ï 8 scopeÁ ,¤ï ©ï Äõ ªï 8ˆÙ ,«ï °ï ²ï Ãõ 8
|
|||
|
|
Ìï 8 Ðï 8 Òï 7ˆ Õï !Öï 8õÕ <Øï àï Þó 8ˆÙ ,þï ƒð 8 spawnÁ ,„ð ‰ð Ãó Šð 8 ‹ð Œð 8 $Žð “ð Âó 8 µð 8â ¹ð ½ð 8–× 4¿ð Åð 8Å- LÆð Ïð Ðð % Ñð 8 óð öð 8â ÷ð úð 8 is_emptyÁ Dûð ƒñ „ñ †ñ êò 8Ô L¬ñ µñ ¶ñ Ðñ
|
|||
|
|
·ñ 8â ¸ñ $ »ñ 7 New configurationÁ œ½ñ % Ññ 8–Ø ,÷ñ üñ 8 fetch_addÁ Lýñ †ò ›ò 7‰ ‡ò $ ˆò 8® DŠò '’ò 8Ë <”ò % œò 8 4Âò % Èò 8ÍÌ 4Œó '’ó 8 spin_loop_hintÁ t”ó ¢ó £ó % ¤ó % Äó 8ˆÙ ,øó ýó 8»Ú ,þó ƒô ¬õ „ô 8 …ô †ô ˆô «õ
|
|||
|
|
8 ¦ô 8 new_confÁ Dªô ³ô 8K µô '¸ô 8æ ºô ½ô Üô 7€Ý œ¾ô Ñô 8 to_ownedÁ DÒô Úô Ûô % Ýô 8–× 4ûô �õ 8È ,‚õ ‡õ �õ 8âß Dˆõ % ‘õ % õ Úõ 8¢ 4Ûõ áõ âõ % ãõ 8Ô Lùõ ‚ö ƒö ªö 8õÕ <„ö $ ‹ö 8–Ø ,�ö ’ö 8¬ $“ö —ö ©ö 8® D˜ö ' ö 8Ë <¢ö % «ö 8 Áö 8 arcÁ Åö Éö 8–× 4Ëö Ñö 8Å- LÒö Ûö Üö % Ýö 8Ô Lóö üö ýö ˜÷ 7Š þö $ ÿö 8K �÷ '„÷ 8 strong_countÁ d†÷ ’÷ —÷ “÷ 8€ã ”÷ % ™÷ 8Ô L¯÷ ¸÷ ¹÷ Ò÷ 7ˆ º÷ $ »÷ 8K ½÷ 'À÷ 8
|
|||
|
|
weak_countÁ TÂ÷ Ì÷ Ñ÷ Í÷ 8€ã Î÷ % Ó÷ < = Similar to the doc tests of ArcSwap, but happens more times.Áü‚ø@ + Ïø Ðø Õø 8‚ $Ñø 8 ãø 8 swap_loadÁ Læø ïø ðø òø Ø€ 8
|
|||
|
|
„ù 8 ˆù 8 Šù 7ˆ �ù !Žù 7 100Á �ù ”ù Ê€ @ 8 ªù 8€ã ®ù ²ù 8K ´ù '·ù 8æ ¹ù ¼ù ¿ù 7 42Á ½ù % Àù 8 Öù 8’ DÚù ãù 8¡Ð åù 'çù 8÷ $éù íù þù 8K îù 'ñù 8ƒ ,óù øù ýù ùù 8€ã úù % ÿù 8Ô L•ú žú Ÿú µú 7»è ú $ ¢ú
|
|||
|
|
¤ú
|
|||
|
|
¥ú 8’ D¦ú ®ú 8¬ $¯ú ³ú ´ú % ¶ú 8Ô L�û Šû ‹û ¡û 7»è Œû $ Žû
|
|||
|
|
�û
|
|||
|
|
‘û 8’ D’û šû 8¬ $›û Ÿû û % ¢û 8 çû 8 new_arcÁ <ëû óû 8K õû 'øû 8æ úû ýû ÿû 7ˆ þû % €ü 8Ô L–ü Ÿü ü Éü 7»è ¡ü $ £ü
|
|||
|
|
¥ü 8’ D¦ü ®ü 8æ- $¯ü ³ü Èü 8K ´ü '·ü 8ƒ ,¹ü ¾ü Çü ¿ü 8öë <Àü % Êü 8Ô Làü éü êü ÿü 7ˆ ëü $ ìü
|
|||
|
|
îü
|
|||
|
|
ïü 8’ Dðü øü 8¬ $ùü ýü þü % €ý 8 âý 8 loadedÁ 4æý íý 8’ Dïý ÷ý 8Å- Løý �þ ‚þ % ƒþ 8Ô L™þ ¢þ £þ Áþ 7‹ ¤þ $ ¥þ 8K §þ 'ªþ 8šä d¬þ ¸þ Àþ ¹þ 8™ï 4ºþ % Âþ 8Ô LØþ áþ âþ þþ 7ˆ ãþ $ äþ 8K æþ 'éþ 8©å Tëþ õþ ýþ öþ 8™ï 4÷þ % ÿþ 8Ô LØÿ áÿ âÿ ýÿ 7‰ ãÿ $ äÿ 8K æÿ 'éÿ 8šä dëÿ ÷ÿ üÿ øÿ 8€ã ùÿ % þÿ 8Ô L”€ �€ ž€ ·€ 7ˆ Ÿ€ $ € 8K ¢€ '¥€ 8©å T§€ ±€ ¶€ ²€ 8€ã ³€ % ¸€ < Q Two different writers publish two series of values. The readers check that it isÁüç€T < " always increasing in each series.ÁüÈ�% < ú ú� < 3 For performance, we try to reuse the threads here.ÁüŠ‚6 + Í‚ ΂ Ó‚ 8‚ $Ï‚ 8 á‚ 8
|
|||
|
|
multi_writersÁ lä‚ ñ‚ ò‚ ô‚ �™ G 8 †ƒ 8 first_valueÁ \Šƒ –ƒ 8K ˜ƒ '›ƒ 8æ �ƒ ƒ §ƒ ¡ƒ ¦ƒ 7ˆ ¢ƒ $ £ƒ 7ˆ ¥ƒ % ¨ƒ 8 ºƒ 8 sharedÁ 4¾ƒ Ń 8¡Ð ǃ 'Ƀ 8÷ $˃ σ èƒ 8K Ѓ 'Óƒ 8ƒ ,Õƒ Úƒ çƒ Ûƒ 8Çö \܃ % éƒ 8 ,ûƒ 8
|
|||
|
|
WRITER_CNTÁ T�„ & ‹„ 8¬ ,�„ “„ 7Š •„ % –„ 8 ,¨„ 8
|
|||
|
|
READER_CNTÁ T®„ & ¸„ 8¬ ,º„ À„ 7‹ „ % Ä + Õ„ Ö„ à„ 8â ׄ Ú„ ß„ 8µ $Û„ 8 ,ò„ 8�Ï Tø„ & ‚… 8¬ ,„… Š… 7� Œ… % �… + Ÿ… … ¯… 8â ¡… ¤… ®… 8”
|
|||
|
|
¥… ¨… … 8µ $©… 8 ,Á… 8�Ï TÇ… & Ñ… 8¬ ,Ó… Ù… 7Îç Û… % Þ… 8 ,ð… 8 SEQÁ ö… & ù… 8¬ ,û… �† 7 50Á ƒ† % …† 8 —† 8 barrierÁ <›† £† 8ÜÍ <¥† '¬† 8æ ®† ±† Æ 8÷Í L²† '»† 8 PoisonÁ 4½† % Ć 8Š 4Ö† '܆ 8ˆÙ ,Þ† ㆠؘ ä† 8ˆÙ ,å† ê† ì† ×˜ 8
|
|||
|
|
‚‡ 8 †‡ 8 ˆ‡ 7ˆ ‹‡ !Œ‡ 8øø TŽ‡ ™‡ ¼� 8 ½ˆ 8 Áˆ 8“ý <ň ͈ 8“ý <ψ Öˆ 8ƒ ,׈ ܈ ݈ % Þˆ 8 øˆ 8Ø÷ 4üˆ ƒ‰ …‰ 8Ø÷ 4†‰ % Œ‰ 8 ¦‰ 8Çö \ª‰ ¶‰ ¸‰ 8Çö \¹‰ % ĉ 8ˆÙ ,Þ‰ ㉠8»Ú ,ä‰ é‰ ¥� 8 $ê‰ ï‰ 8 ð‰ ñ‰ ó‰ ¤� 8
|
|||
|
|
‘Š 8 •Š 8 —Š 7ˆ šŠ !›Š 8�Ï T�Š ¨Š Š� 8“ý <ÊŠ ÑŠ 8 waitÁ $ÒŠ ÖŠ ׊ % ØŠ 8Ø÷ 4úŠ €‹ 8È ,�‹ †‹ Ÿ‹ 8K ‡‹ 'Š‹ 8ƒ ,Œ‹ ‘‹ ž‹ ’‹ 8Çö \“‹ % ‹ 8“ý <‹ É‹ 8æ‚ $Ê‹ ΋ Ï‹ % Ћ 8
|
|||
|
|
ò‹ 8´ ö‹ 8 ø‹ 7ˆ û‹ !ü‹ 8Æü þ‹ ‚Œ ìŒ 8Ø÷ 4¨Œ ®Œ 8È ,¯Œ ´Œ ÉŒ 8K µŒ '¸Œ 8æ ºŒ ½Œ ÈŒ ¾Œ ÇŒ 8 ¿Œ $ ÀŒ 8´ ÂŒ ÄŒ 7‰ ÆŒ % ÊŒ % ¦� 8
|
|||
|
|
Ò� 8 Ö� 8 Ø� 7ˆ Û� !Ü� 8Êù TÞ� é� ¡˜ 8 ƒŽ 8 ‡Ž 8“ý <‹Ž “Ž 8“ý <•Ž œŽ 8ƒ ,�Ž ¢Ž £Ž % ¤Ž 8 ¾Ž 8Ø÷ 4ÂŽ ÉŽ ËŽ 8Ø÷ 4ÌŽ % ÒŽ 8 ìŽ 8Çö \ðŽ üŽ þŽ 8Çö \ÿŽ % Š� 8ˆÙ ,¤� ©� 8»Ú ,ª� ¯� Š˜ 8 $°� µ� 8 ¶� ·� ¹� ‰˜ 8
|
|||
|
|
×� 8 Û� 8 Ý� 7ˆ à� !á� 8�Ï Tã� î� ï— 8“ý <�� —� 8æ‚ $˜� œ� �� % ž� 8“ý <À� Ç� 8æ‚ $È� Ì� Í� % Î� 8 ð� 8 ô� 8 previousÁ Dø� �‘ ƒ‘ ‘‘ 7ˆ „‘ % …‘ 8øø T‡‘ % ’‘ 8 ´‘ 8 ¸‘ 8‹ $¼‘ Á‘ 8K Ñ 'Æ‘ 8ƒ ,È‘ Í‘ Ú‘ Α 8Çö \Ï‘ % Û‘ 8 $ý‘ ‚’ Ñ— * 8 ¨’ 8 curÁ ¬’ °’ 8Ø÷ 4²’ ¸’ 8¬ $¹’ ½’ ¾’ % ¿’ 8 å’ 8K è’ 'ë’ 8–+ 4í’ ó’ ÿ’ ô’ 8‹ $õ’ $ ù’ û’ 8¤� ü’ �“ ›” 8ÍÌ 4«“ '±“ 8ÃÞ t³“ Á“ “ % Ó 8 Dí“ % õ“ 8 Á” Å” Ê” 8 Ɣ $ Ç” 8¾ É” Ì”
|
|||
|
|
Δ
|
|||
|
|
Ï” 8¤� Д % Ó” 8Ó 4ù” ÿ” €• ¯•
|
|||
|
|
8µ‹ D�• ‰• ‹• 8 Š• �• 8¾ �• $ �• 7 {:?} vs {:?}Á t’• $ • 8µ‹ D¢• $ ª• 8¤� ¬• % °• 8µ‹ DÖ• Þ• à• 8 ߕ â• 8¾ ä• % å• 8‹ $‹– �– 8° ,’– '—– 8´$ T™– £– §– 8¤� ¤– % ¨– 8 Ζ 8¾ Ñ– Ó– 8Æü Ö– Ú– ¯— 8 ,„— % ‰— % ‹˜ 8ã $¸˜ ¼˜ Ę 8“ý <½˜ % Ř ê˜ 8¢ 4ë˜ ñ˜ ò˜ % ó˜ + �™ ‘™ –™ 8‚ $’™ 8 ¤™ 8 load_nullÁ L§™ °™ ±™ ³™ Á› ! 8 Å™ 8Ø÷ 4É™ Й 8ƒÒ Ò™ 'Õ™ ×™ 8¬ ,Ø™ Ý™ 'Þ™ 8> <à™ ç™ è™ % é™ 8 û™ 8£ ,ÿ™ …š 8Ø÷ 4‡š �š 8¬ $Žš ’š “š % ”š 8Ó 4¦š ¬š š ½š 8£ ,®š ³š 8 is_noneÁ <´š »š ¼š % ¾š 8Ø÷ 4К Öš 8È ,ך Üš ïš 8Û $Ýš áš îš 8K âš 'åš 8æ çš êš íš 7»è ëš % ðš 8Ô L‚› ‹› Œ› ²› 7»è �› $ �›
|
|||
|
|
‘›
|
|||
|
|
’› 8Ø÷ 4“› ™› 8¬ $š› ž› Ÿ› › 8É 4¡› §› ¨› ©› 8¢ 4ª› °› ±› % ³› + Л Ñ› Ö› 8‚ $Ò› 8 ä› 8 from_intoÁ Lç› ð› ñ› ó› Õž / 8 …œ 8¬ ‰œ ‹œ 8K �œ '�œ 8æ ’œ •œ ˜œ 7»è –œ % ™œ 8 «œ 8Ø÷ 4¯œ ¶œ 8¡Ð ¸œ 'ºœ 8æ ¼œ ¿œ Áœ 8¬ Àœ % Âœ 8 Ôœ 8£ ,Øœ Þœ 8Ø÷ 4àœ æœ 8¬ $çœ ëœ ìœ % íœ 8 ÿœ 8¬ ƒ� …� 8Ø÷ 4‡� �� 8´$ TŽ� ˜� ™� % š� 8Ô L¬� µ� ¶� ½� 7»è ·� $ ¹�
|
|||
|
|
»� 8¬ ¼� % ¾� 8Ô LÐ� Ù� Ú� ó� 7Š Û� $ Ü� 8K Þ� 'á� 8šä dã� ï� ò� ð� 8¬ ñ� % ô� 8ã $†ž Šž �ž 8£ ,‹ž % ‘ž 8Ô L£ž ¬ž ž Æž 7‰ ®ž $ ¯ž 8K ±ž '´ž 8šä d¶ž ž Åž Þ 8¬ Äž % Çž + ¹¡ º¡ Ê¡ 8º 4»¡ Á¡ É¡ 8q <¡ 8 4Ø¡ 8
|
|||
|
|
ReportDropÁ Tß¡ é¡ ú¡ 8K ê¡ í¡ 8ûã \î¡ ù¡ % û¡ 8 $‰¢ 8 DropÁ $Ž¢ 8
|
|||
|
|
“¢ 8°¡ T—¢ ¢¢ ££ 8 ´¢ 8ã $·¢ »¢ Å¢ ¼¢ 8 ½¢ 8 $Á¢ Ç¢ •£ 8 $Ý¢ ᢠ7ˆ ⢠㢠8ºÝ Lä¢ í¢ ‚£ 7‰ î¢ $ ï¢ 8® Dñ¢ 'ù¢ 8Ë <û¢ % ƒ£ < : Interaction of two threads about a guard and dropping it.Áü²£= < ú ü£ < X We make sure everything works in timely manner (eg. dropping of stuff) even if multipleÁüŒ¤[ < threads interact.Á¬ô¤ < ú –¥ <
|
|||
|
|
The idea is:Á„¦¥ < * Thread 1 loads a value.ÁìÃ¥ < K * Thread 2 replaces the shared value. The original value is not destroyed.Áüí¥N < [ * Thread 1 drops the guard. The value is destroyed and this is observable in both threads.ÁüȦ^ + ³§ ´§ ¹§ 8‚ $µ§ 8 ǧ 8 guard_drop_in_threadÁ ¤Ê§ Þ§ ߧ ᧠ĸ 8
|
|||
|
|
ó§ 8 ÷§ 8 ù§ 7ˆ ü§ !ý§ 8�Ï Tÿ§ Š¨ ¶¸ $ 8 ¨ 8 cntÁ ¤¨ ¨¨ 8K ª¨ '¨ 8æ ¯¨ ²¨ ƨ 8ûã \³¨ '¾¨ 8æ À¨ è Ũ 7ˆ Ĩ % Ǩ 8 Þ¨ 8Ø÷ 4â¨ é¨ 8¡Ð ë¨ 'í¨ 8ç. dï¨ û¨ “© 8°¡ Tü¨ †© ’© 8Ω ‡© Š© 8ƒ ,‹© �© ‘© % ”© 8Ô Lª© ³© ´© ê© 8Ω µ© ¸© 8¬ $¹© ½© Ï© 8® D¾© 'Æ© 8Ë <È© $ Щ 7ˆ Ò© $ Ó© 7 Dropped prematurelyÁ ¬Õ© % ë© 8 Ϊ 8ç $Òª ת 8ÜÍ <Ùª 'ઠ8æ âª åª ÷ª 8÷Í Læª 'ïª 8óý 4ñª % øª 8Š 4�« '•« 8ˆÙ ,—« œ« …¸ �« 8ˆÙ ,ž« £« ¥« „¸
|
|||
|
|
8ˆÙ ,¿« Ä« 8»Ú ,Å« Ê« §± Ë« ¦± 8 é« 8ç $í« ò« 8ç $ô« ø« 8ƒ ,ù« þ« ÿ« % €¬ ž¬ 8 Ÿ¬ ¬ ¢¬ Œ± $ 8 Ĭ 8 Ȭ 8ç $̬ Ѭ 8ç $Ó¬ % ׬ 8 ’ 8£ ,– œ 8Ø÷ 4ž ¤ 8¬ $¥ © ª % « 8ç $Í Ñ 8æ‚ $Ò Ö × % Ø 8ç $Ü® à® 8æ‚ $á® å® æ® % ç® 8ã $‰¯ �¯ “¯ 8£ ,Ž¯ % ”¯ 8Ô L¶¯ ¿¯ À¯ ô¯ 8Ω Á¯ į 8¬ $ů ɯ Û¯ 8® Dʯ 'Ò¯ 8Ë <Ô¯ $ ܯ 7‰ Þ¯ $ ߯ 7 Value not droppedÁ œá¯ % õ¯ 8ç $ã° ç° 8æ‚ $è° ì° í° % î° % ¨± 8ˆÙ ,ñ ȱ 8»Ú ,ɱ α í· Ï± 8 б ѱ Ó± ì· " 8 ñ± 8 õ± 8ç $ù± þ± 8ç $€² % „² 8ç $â² æ² 8æ‚ $ç² ë² ì² % í² 8Ø÷ 4‹³ ‘³ 8È ,’³ —³ ª³ 8q <˜³ 'Ÿ³ 8> <¡³ ¨³ ©³ % «³ 8Ô Lɳ Ò³ Ó³ Žµ 8Ω õ³ ø³ 8¬ $ù³ ý³ �´ 8® Dþ³ '†´ 8Ë <ˆ´ $ �´ 7ˆ ²´ $ ³´ 7 Dropped while still in useÁ äÕ´ % �µ 8ç $íµ ñµ 8æ‚ $òµ öµ ÷µ % øµ 8ç $ê¶ î¶ 8æ‚ $ï¶ ó¶ ô¶ % õ¶ 8Ô L“· œ· �· Ñ· 8Ω ž· ¡· 8¬ $¢· ¦· ¸· 8® D§· '¯· 8Ë <±· $ ¹· 7‰ »· $ ¼· 7Ž´ œ¾· % Ò· % î· ›¸ 8¢ 4œ¸ ¢¸ £¸ % ¤¸ < S Check dropping a lease in a different thread than it was created doesn't cause anyÁüÓ¸V <
|
|||
|
|
problems.Ál¶¹ + й ѹ Ö¹ 8‚ $Ò¹ 8 ä¹ 8 guard_drop_in_another_threadÁ äç¹ ƒº „º †º ú¿ 8
|
|||
|
|
˜º 8 œº 8 žº 7ˆ ¡º !¢º 8�Ï T¤º ¯º ì¿ / 8 ź 8Ω ɺ ͺ 8K Ϻ 'Òº 8æ Ôº ׺ ëº 8ûã \غ '㺠8æ åº èº êº 7ˆ éº % ìº 8 ‚» 8Ø÷ 4†» �» 8¡Ð �» '‘» 8ç. d“» Ÿ» ·» 8°¡ T » ª» ¶» 8Ω «» ®» 8ƒ ,¯» ´» µ» % ¸» 8Ô Lλ ×» Ø» Ž¼ 8Ω Ù» Ü» 8¬ $Ý» á» ó» 8® Dâ» 'ê» 8Ë <ì» $ ô» 7ˆ ö» $ ÷» 7� ¬ù» % �¼ 8 ¥¼ 8£ ,©¼ ¯¼ 8Ø÷ 4±¼ ·¼ 8¬ $¸¼ ¼¼ ½¼ % ¾¼ 8ã $Õ¼ Ù¼ ༠8Ø÷ 4Ú¼ % á¼ 8Ô L÷¼ €½ �½ ·½ 8Ω ‚½ …½ 8¬ $†½ Š½ œ½ 8® D‹½ '“½ 8Ë <•½ $ �½ 7ˆ Ÿ½ $ ½ 7� ¬¢½ % ¸½ 8Š 4Ͻ 'Õ½ 8ˆÙ ,×½ ܽ ë¾ Ý½ 8ˆÙ ,Þ½ ã½ å½ ê¾ 8ˆÙ ,ÿ½ „¾ 8»Ú ,…¾ Š¾ Ó¾ ‹¾ 8 Œ¾ �¾ �¾ Ò¾ 8ã $¾ ±¾ ·¾ 8£ ,²¾ % ¸¾ % Ô¾ �¿ 8¢ 4‚¿ ˆ¿ ‰¿ % Š¿ 8Ô L¡¿ ª¿ «¿ Ù¿ 8Ω ¬¿ ¯¿ 8¬ $°¿ ´¿ Æ¿ 8® Dµ¿ '½¿ 8Ë <¿¿ $ Ç¿ 7‰ É¿ $ Ê¿ 7 Not droppedÁ lÌ¿ % Ú¿ + ‰À ŠÀ �À 8‚ $‹À 8 �À 8 load_optionÁ \ À «À ¬À ®À ¤Ã " 8 ÀÀ 8Ø÷ 4ÄÀ ËÀ 8ƒÒ ÍÀ 'ÐÀ 8ç. dÒÀ ÞÀ áÀ 7»è ßÀ % âÀ 8 ÛÁ 8 optÁ ßÁ & âÁ 8¬ 4äÁ êÁ 8 ëÁ ìÁ îÁ 8° ,ðÁ 'õÁ 8´$ T÷Á � � 8Ø÷ 4‚ ˆÂ 8¬ $‰Â � ŽÂ % � 8Ô L¢Â «Â ¬Â ¾Â 7»è  $ ¯Â
|
|||
|
|
±Â 8–É ²Â µÂ 8¢ 4¶Â ¼Â ½Â % ¿Â 8Ø÷ 4Ò Ø 8È ,Ù Þ ã 8© $ß % ä 8Ó 4ö ü ý •Ã 8Ø÷ 4þ „à 8¬ $…à ‰Ã ŠÃ ‹Ã 8ˆ— <ŒÃ “à ”à % –à + àà áà æà 8‚ $âà 8 ôà 8
|
|||
|
|
debug_implÁ T÷à �Ä ‚Ä „Ä ÐÅ 8 –Ä 8Ø÷ 4šÄ ¡Ä 8¡Ð £Ä '¥Ä 8ç. d§Ä ³Ä ¶Ä 7»è ´Ä % ·Ä 8Ô LÉÄ ÒÄ ÓÄ þÄ 7 ArcSwapAny(42)Á „ÔÄ $ äÄ æÄ 8 formatÁ 4çÄ íÄ îÄ ýÄ 7 {:?}Á 4ïÄ $ õÄ 8Ø÷ 4÷Ä % ÿÄ 8Ô L‘Å šÅ ›Å ÁÅ 7»è $œÅ $ Å ¢Å 8•Ï 4£Å ©Å ªÅ ÀÅ 7¿Ï 4«Å $ ±Å 8Ø÷ 4³Å ¹Å 8¬ $ºÅ ¾Å ¿Å % ÂÅ + ßÅ àÅ åÅ 8‚ $áÅ 8 óÅ 8 display_implÁ döÅ ‚Æ ƒÆ …Æ ÁÇ 8 —Æ 8Ø÷ 4›Æ ¢Æ 8¡Ð ¤Æ '¦Æ 8ç. d¨Æ ´Æ ·Æ 7»è µÆ % ¸Æ 8Ô LÊÆ ÓÆ ÔÆ ñÆ 7»è $ÕÆ $ ÙÆ ÛÆ 8•Ï 4ÜÆ âÆ ãÆ ðÆ 7û $äÆ $ èÆ 8Ø÷ 4êÆ % òÆ 8Ô L„Ç �Ç ŽÇ ²Ç 7»è $�Ç $ “Ç •Ç 8•Ï 4–Ç œÇ �Ç ±Ç 7û $žÇ $ ¢Ç 8Ø÷ 4¤Ç ªÇ 8¬ $«Ç ¯Ç °Ç % ³Ç 8 ÞÈ 8 _check_stuff_is_send_syncÁ ÌáÈ úÈ ûÈ ýÈ ÎÍ 4 8 �É 8Ø÷ 4“É šÉ 8¡Ð œÉ 'žÉ 8ç. d É ¬É ¯É 7»è É % °É 8 ÂÉ 8 movedÁ ,ÆÉ ÌÉ 8¡Ð ÎÉ 'ÐÉ 8ç. dÒÉ ÞÉ áÉ 7»è ßÉ % âÉ 8 ôÉ 8
|
|||
|
|
shared_refÁ TøÉ ƒÊ …Ê 8Ø÷ 4†Ê % ŒÊ 8 žÊ 8Ìš ,¢Ê ¨Ê 8Ø÷ 4ªÊ °Ê 8¬ $±Ê µÊ ¶Ê % ·Ê 8 ÉÊ 8 lease_refÁ LÍÊ ×Ê ÙÊ 8Ìš ,ÚÊ % ßÊ 8 ñÊ 8Ìš ,õÊ ûÊ 8Ø÷ 4ýÊ ƒË 8¬ $„Ë ˆË ‰Ë % ŠË 8Š 4œË '¢Ë 8ˆÙ ,¤Ë ©Ë ¥Í ªË 8¾ «Ë ¬Ë ®Ë ¤Í 8¾ ÄË ÅË 8»Ú ,ÆË ËË ‘Í 8 $ÌË ÑË 8 ÒË ÓË ÕË �Í 8 ïË 8 óË õË 8Ìš ,÷Ë % üË 8 –Ì 8 šÌ œÌ 8ñØ LžÌ % §Ì 8 ÁÌ 8 ÅÌ ÇÌ 8Ó× TÉÌ % ÓÌ 8 íÌ 8 ñÌ óÌ 8éÖ ,õÌ % úÌ % ’Í ·Í 8¢ 4¸Í ¾Í ¿Í % ÀÍ < R We have a callback in RCU. Check what happens if we access the value from within.ÁüÝÍU + ¿Î ÀÎ ÅÎ 8‚ $ÁÎ 8 ÓÎ 8 recursiveÁ LÖÎ ßÎ àÎ âÎ ØÑ 8 ôÎ 8Ø÷ 4øÎ ÿÎ 8¼. <�Ï 'ˆÏ 8÷ $ŠÏ ŽÏ šÏ 8K �Ï '’Ï 8æ ”Ï —Ï ™Ï 7ˆ ˜Ï % ›Ï 8Ø÷ 4®Ï ´Ï 8‚. µÏ ¸Ï ÑÐ ¹Ï 8´ ºÏ »Ï ½Ï ÐÐ
|
|||
|
|
8 ÓÏ
|
|||
|
|
ÖÏ
|
|||
|
|
×Ï 8´ ØÏ ÚÏ 7ÂÏ ÜÏ ßÏ ¦Ð 8Ø÷ 4ùÏ ÿÏ 8‚. €Ð ƒÐ �Ð „Ð 8´ …Ð †Ð
|
|||
|
|
ˆÐ
|
|||
|
|
‰Ð 8´ ŠÐ ŒÐ 7‰ ŽÐ % �Ð
|
|||
|
|
¼Ð
|
|||
|
|
½Ð 8´ ¾Ð % ÒÐ 8Ô LäÐ íÐ îÐ ‚Ñ 7ÂÏ ïÐ $ ñÐ
|
|||
|
|
óÐ
|
|||
|
|
ôÐ 8Ø÷ 4õÐ ûÐ 8¬ $üÐ €Ñ �Ñ % ƒÑ 8Ô L•Ñ žÑ ŸÑ ÉÑ 7Š Ñ $ ¡Ñ 8K £Ñ '¦Ñ 8šä d¨Ñ ´Ñ ÈÑ µÑ 8Ø÷ 4¶Ñ ¼Ñ 8Å- L½Ñ ÆÑ ÇÑ % ÊÑ < A A panic from within the rcu callback should not change anything.ÁüçÑD + ¸Ò ¹Ò ¾Ò 8‚ $ºÒ + ÌÒ ÍÒ ýÒ 8â ÎÒ ÑÒ üÒ 8”
|
|||
|
|
ÒÒ ÕÒ ûÒ 8» <ÖÒ ÞÒ 7º ÜàÒ 8 ‹Ó 8 rcu_panicÁ LŽÓ —Ó ˜Ó šÓ °Õ 8# ¬Ó 8À °Ó '³Ó 8Á
|
|||
|
|
,µÓ % ºÓ 8 ÌÓ 8Ø÷ 4ÐÓ ×Ó 8¼. <ÙÓ 'àÓ 8÷ $âÓ æÓ òÓ 8K çÓ 'êÓ 8æ ìÓ ïÓ ñÓ 7ˆ ðÓ % óÓ 8Ó 4…Ô ‹Ô ŒÔ ÓÔ 8Á
|
|||
|
|
,�Ô '’Ô 8Û d”Ô Ô ÉÔ ¡Ô 8Ø÷ 4¤Ô ªÔ 8‚. «Ô ®Ô ÈÔ ¯Ô 8 °Ô ±Ô (³Ô 8¬ ,¶Ô ¼Ô ÇÔ 8Á
|
|||
|
|
,¾Ô ÃÔ ÄÔ ÅÔ ÊÔ 8 is_errÁ 4ËÔ ÑÔ ÒÔ % ÔÔ 8Ô LæÔ ïÔ ðÔ ¡Õ 7‰ ñÔ $ òÔ 8K ôÔ '÷Ô 8šä dùÔ …Õ Õ †Õ 8Ø÷ 4‡Õ �Õ 8æ- $ŽÕ ’Õ ŸÕ 8K “Õ '–Õ 8æ ˜Õ ›Õ žÕ 7»è œÕ % ¢Õ < Handling null/none valuesÁì¿Õ + éÕ êÕ ïÕ 8‚ $ëÕ 8 ýÕ 8 nullsÁ ,€Ö …Ö †Ö ˆÖ ºÛ H 8 šÖ 8Ø÷ 4žÖ ¥Ö 8ú. l§Ö '´Ö 8÷ $¶Ö ºÖ ÌÖ 8Û $»Ö ¿Ö ËÖ 8K ÀÖ 'ÃÖ 8æ ÅÖ ÈÖ ÊÖ 7ˆ ÉÖ % ÍÖ 8 ßÖ 8 origÁ $ãÖ èÖ 8Ø÷ 4êÖ ðÖ 8æ- $ñÖ õÖ úÖ 8© $öÖ % ûÖ 8Ô L�× –× —× ¼× 7‰ ˜× $ ™× 8K ›× 'ž× 8šä d × ¬× »× × 8«ï $®× ²× 8¢ 4³× ¹× º× % ½× 8 Ï× 8—
|
|||
|
|
$Ó× Ø× 8Ø÷ 4Ú× à× 8¬ $á× å× æ× % ç× 8Ó 4ù× ÿ× €Ø �Ø 8—
|
|||
|
|
$�Ø …Ø 8ˆ— <†Ø �Ø ŽØ % �Ø 8 ¢Ø 8¬ ¦Ø ¨Ø 8K ªØ 'Ø 8æ ¯Ø ²Ø µØ 7»è ³Ø % ¶Ø 8 ÈØ 8«ï $ÌØ ÑØ 8Ø÷ 4ÓØ ÙØ 8ù% „ÚØ êØ ŒÙ 8µ ëØ 'îØ 8—
|
|||
|
|
$ðØ ôØ õØ $ öØ 8Û $øØ üØ ‹Ù 8K ýØ '€Ù 8ƒ ,‚Ù ‡Ù ŠÙ ˆÙ 8¬ ‰Ù % �Ù 8Ó 4ŸÙ ¥Ù ¦Ù µÙ 8«ï $§Ù «Ù 8ˆ— <¬Ù ³Ù ´Ù % ¶Ù 8Ô LÈÙ ÑÙ ÒÙ ëÙ 7Š ÓÙ $ ÔÙ 8K ÖÙ 'ÙÙ 8šä dÛÙ çÙ êÙ èÙ 8¬ éÙ % ìÙ 8 þÙ 8«ï $‚Ú ‡Ú 8° ,‰Ú 'ŽÚ 8´$ T�Ú šÚ ÉÚ 8Ø÷ 4›Ú ¡Ú 8ù% „¢Ú ²Ú ÈÚ
|
|||
|
|
³Ú 8© $´Ú '¸Ú ºÚ 8K »Ú ¾Ú 8 ¿Ú ÀÚ $ ÂÚ 8© $ÄÚ % ÊÚ 8Ô LÜÚ åÚ æÚ ÿÚ 7‹ çÚ $ èÚ 8K êÚ 'íÚ 8šä dïÚ ûÚ þÚ üÚ 8¬ ýÚ % €Û 8Ó 4’Û ˜Û ™Û «Û 8–+ 4šÛ Û ªÛ ¡Û 8¬ ¢Û $ £Û ¥Û 8«ï $¦Û % ¬Û + ÉÛ ÊÛ ÏÛ 8‚ $ËÛ < Multiple RCUs interacting.ÁôÝÛ 8 ˆÜ 8‚. ‹Ü ŽÜ �Ü ‘Ü àà " 8 ,£Ü 8�Ï T©Ü & ³Ü 8¬ ,µÜ »Ü 7òü ½Ü % ¿Ü 8 ,ÑÜ 8 THREADSÁ <×Ü & ÞÜ 8¬ ,àÜ æÜ 7ÂÏ èÜ % êÜ 8 üÜ 8Ø÷ 4€Ý ‡Ý 8¼. <‰Ý '�Ý 8÷ $’Ý –Ý ¢Ý 8K —Ý 'šÝ 8æ œÝ ŸÝ ¡Ý 7ˆ Ý % £Ý 8Š 4µÝ '»Ý 8ˆÙ ,½Ý ÂÝ ôß ÃÝ 8ˆÙ ,ÄÝ ÉÝ ËÝ óß 8
|
|||
|
|
áÝ 8 åÝ 8 çÝ 7ˆ êÝ !ëÝ 8Âü <íÝ õÝ áß 8ˆÙ ,�Þ ”Þ 8»Ú ,•Þ šÞ Êß ›Þ 8 œÞ �Þ ŸÞ Éß 8
|
|||
|
|
½Þ 8 ÁÞ 8 ÃÞ 7ˆ ÆÞ !ÇÞ 8�Ï TÉÞ ÔÞ ¯ß 8Ø÷ 4öÞ üÞ 8‚. ýÞ €ß �ß �ß 8ÔÚ ‚ß …ß
|
|||
|
|
‡ß
|
|||
|
|
ˆß 8ÔÚ ‰ß �ß 7‰ �ß % ‘ß % Ëß †à 8¢ 4‡à �à Žà % �à 8Ô L¡à ªà «à Ñà
|
|||
|
|
8Âü <¬à
|
|||
|
|
´à 8�Ï T¶à $ Àà
|
|||
|
|
Âà
|
|||
|
|
Ãà 8Ø÷ 4Äà Êà 8¬ $Ëà Ïà Ðà % Òà + ïà ðà õà 8‚ $ñà < F Make sure the reference count and compare_and_swap works as expected.ÁüƒáI 8 Ùá 8 cas_ref_cntÁ \Üá çá èá êá æô 4 + üá ýá ‡â 8â þá �â †â 8µ $‚â 8 ,™â 8�Ï TŸâ & ©â 8¬ ,«â ±â 7ÂÏ ³â % µâ + Çâ Èâ ×â 8â Éâ Ìâ Öâ 8”
|
|||
|
|
Íâ Ðâ Õâ 8µ $Ñâ 8 ,éâ 8�Ï Tïâ & ùâ 8¬ ,ûâ �ã 7òü ƒã % …ã 8 —ã 8Ø÷ 4›ã ¢ã 8¼. <¤ã '«ã 8÷ $㠱㠽ã 8K ²ã 'µã 8æ ·ã ºã ¼ã 7ˆ »ã % ¾ã 8
|
|||
|
|
Ðã 8´ Ôã 8 Öã 7ˆ Ùã !Úã 8�Ï TÜã çã Óò r 8 ýã 8«ï $�ä †ä 8Ø÷ 4ˆä Žä 8Å- L�ä ˜ä ™ä % šä 8Ô L°ä ¹ä ºä Ãä 8´ »ä $ ¼ä
|
|||
|
|
¾ä 8«ï $¿ä % Ää 8 Úä 8´ Ýä ßä 7Š áä ãä 7‰ æä èä ÷å 8Ô Lºå Ãå Äå àå 7Š Åå $ Æå 8K Èå 'Ëå 8šä dÍå Ùå ßå Úå 8«ï $Ûå % áå 8 �æ 8 n1Á ‘æ ”æ 8K –æ '™æ 8æ ›æ žæ ¤æ 8´ Ÿæ ¡æ 7‰ £æ % ¥æ 8 îæ 8 fillupÁ 4òæ ùæ ûæ þæ õè 8 ˜ç 8´ ›ç �ç 7Š Ÿç ¡ç 7ˆ ¤ç ¦ç �è 8Û $Äç Èç ƒè
|
|||
|
|
Éç ×ç 7ˆ Êç !Ëç 8�Ï TÍç Øç 8Ø Ùç Üç îç Ýç 8 Þç ßç 8Ø÷ 4áç çç 8¬ $èç ìç íç ïç 8 collectÁ <ðç '÷ç ùç 8ö úç ýç 8 þç ÿç �è ‚è 8 $Ÿè ¤è ßè 8© $Âè % öè 8 Œé 8 guardsÁ 4�é —é 8�� 4™é Ÿé é % ¡é 8 Öé 8 prevÁ $Úé ßé 8Ø÷ 4áé çé 8ù% „èé øé �ê ùé 8«ï $úé $ þé 8K €ê 'ƒê 8ƒ ,…ê Šê Žê ‹ê 8•Œ Œê % �ê 8Ó 4¦ê ¬ê ê Âê 8–+ 4®ê ´ê Áê µê 8«ï $¶ê $ ºê ¼ê 8«‘ $½ê % Ãê 8ã $Ùê Ýê äê 8â� 4Þê % åê 8Ô Lë ¶ë ·ë Óë 7Š ¸ë $ ¹ë 8K »ë '¾ë 8šä dÀë Ìë Òë Íë 8«ï $Îë % Ôë 8Ô Lœì ¥ì ¦ì Àì 7Š §ì $ ¨ì 8K ªì 'ì 8šä d¯ì »ì ¿ì ¼ì 8•Œ ½ì % Áì 8Ô L×ì àì áì øì
|
|||
|
|
8´ âì äì 7‰ æì $ çì
|
|||
|
|
éì
|
|||
|
|
êì 8Ø÷ 4ëì ñì 8¬ $òì öì ÷ì % ùì 8 �í 8 n2Á “í –í 8K ˜í '›í 8æ �í í ¢í 8´ ¡í % £í 8ã $¹í ½í Âí 8«‘ $¾í % Ãí 8 Ùí 8â� 4Ýí äí 8�� 4æí ìí íí % îí 8 £î 8«‘ $§î ¬î 8° ,®î '³î 8´$ Tµî ¿î ïî 8Ø÷ 4Àî Æî 8ù% „Çî ×î îî Øî 8«ï $Ùî $ Ýî 8K ßî 'âî 8ƒ ,äî éî íî êî 8ª— ëî % ðî 8ã $†ï Šï ‘ï 8â� 4‹ï % ’ï 8Ó 4¨ï ®ï ¯ï Âï 8–+ 4°ï ¶ï Áï ·ï 8•Œ ¸ï $ ºï ¼ï 8«‘ $½ï % Ãï 8Ô Lýï †ð ‡ð £ð 7‰ ˆð $ ‰ð 8K ‹ð 'Žð 8šä d�ð œð ¢ð �ð 8«ï $žð % ¤ð 8Ô Lúð ƒñ „ñ žñ 7‹ …ñ $ †ñ 8K ˆñ '‹ñ 8šä d�ñ ™ñ �ñ šñ 8•Œ ›ñ % Ÿñ 8Ô Läñ íñ îñ ˆò 7‰ ïñ $ ðñ 8K òñ 'õñ 8šä d÷ñ ƒò ‡ò „ò 8ª— …ò % ‰ò 8Ô LŸò ¨ò ©ò Àò
|
|||
|
|
8´ ªò ¬ò 7‰ ®ò $ ¯ò
|
|||
|
|
±ò
|
|||
|
|
²ò 8Ø÷ 4³ò ¹ò 8¬ $ºò ¾ò ¿ò % Áò 8 æò 8¬ êò ìò 8Ø÷ 4îò ôò 8Å- Lõò þò ÿò % €ó 8Ô LÂó Ëó Ìó åó 7Š Íó $ Îó 8K Ðó 'Óó 8šä dÕó áó äó âó 8¬ ãó % æó 8ã $øó üó ƒô 8Ø÷ 4ýó % „ô 8Ô L´ô ½ô ¾ô ×ô 7‰ ¿ô $ Àô 8K Âô 'Åô 8šä dÇô Óô Öô Ôô 8¬ Õô % Øô % ÷ô ”É,ù=þ7 4* \Á* ¥ ¿ ¤ À À ¿ ‹ß Í* ˆæ Ø* ˜æ4Ð* §æ\Û* ‚F Pzèýu ¾ Á õ]‚F þ7u õ]‚F ½ ½
|
|||
|
|
¾ÄDòE�ƒ †ˆ \è* ½ ½ õ](Ÿ* & ¥ à ¤ Ä Ã Ä ‹ßè ˆææ ¨¦Í* ˜æí ¿còE Ø* §æû‚FÅ Àc Å #& *- Ž� € � ‚ €‚F � c c ˆ ¢cµ
|
|||
|
|
` £cÒ¦ ` àB¤GS
|
|||
|
|
‚ù§ Â Ÿ* Â
|
|||
|
|
ÅÄDòE9±@üÉF 4¢F DÔF ˜ Ç — È ¥ É £ Ê È Ê É Ç ¥� ÝF Í� àF öŽ ãF †� æF ¡K æ:óFŸ�‰` ËÌÍ9; >@ CE HJ DïF ,ïF Æ Æ äKlýF TýF Æ Æ êKì�G �G Æ Æ • • – ³o Fu\»Ÿ ƒ ƒðK ƒöK ´F ' ˜ Ï — Ð ¥ Ñ £ Ò Ñ Ï Ò Ð ¥�U Í�T öŽS †�R Š äK ÝF Š êK àF Š ðK ãF Š öK æF ¡K °³ ·º ¾Á ÅÈ (ºF ( ˜ Ô — Õ ¥ Ö £ × Õ Ô Ö × ¥�? Í�> öŽ= †�< ØäK ÝF ÑšàF ØðK ãF ØöK æF ¡KØ Ù Ø ž¡ ¥¨ ¬¯ ³¶ îð „ „¡K ¡K Ó ºF Ó
|
|||
|
|
ØäKêKðKöKI(ÁF ) ˜ Ú — Û ¥ Ü £ Ý Ú Ü Ý Û ¥�‹ Í�Š öŽ‰ †�ˆ ¿cäK ÝF ¿cêK àF ¿cðK ãF ¿cöK æF ¡KÞ Àc Þ ñô øû ÿ õ÷ … † ‡ …¡K † c c ˆ ¢cµ
|
|||
|
|
` £cÒ¦ ` àB¤GS
|
|||
|
|
‡ù§ Ù ÁF Ù
|
|||
|
|
ÞäKêKðKöK¨±¯¼ÊJ üúH? < An adaptor to provide access to a part of larger structure.Á ºI ú ü¾I` ] This is the *active* part of this module. Use the [module documentation](index.html) for theÁ dŸJ details.Á ÕJ ’ à ¥ á — â à á â Ø‘ ÙJ ¤Ø ÜJ ð‘ ßJ ¡L ±ìi0�Â% ãäå13 68 ;= LèJ 4èJ ß ß äLl÷J T÷J ß ß íLÔŠK ŠK ß ß • • – ³o Fu\»Ÿ ØD µJ * ’ ç ¥ è — é è ç é Ø‘ ¤Ø ð‘ Š äL ÙJ Š ØD ÜJ Š íL ßJ ¡L Z] ad hk (»J + ’ ë ¥ ì — í ë ì í Ø‘Ë ¤ØÊ ð‘É ØäL ÙJ ØØD ÜJ Ú˜ßJ ¡Lî Ù î !$ ¹» ˆ ˆ¡L ¡L ê »J ê
|
|||
|
|
îäLØDíL(ÂJ , ’ ð ¥ ñ — ò ò ñ ð Ø‘Þ ¤ØÝ ð‘Ü ¿cäL ÙJ ¿cØD ÜJ ¿cíL ßJ ¡Ló Àc ó -0 47 ;> À ‰ Š ‹ ‰¡L Š c c ˆ ¢cµ
|
|||
|
|
` £cÒ¦ ` àB¤GS
|
|||
|
|
‹ù§ ï ÂJ ï
|
|||
|
|
óäLØDíLo±vm9 4çT l¿U ¥ ö ö ‹ß ÍU ãM p²1=Ã�H õ ÷ ÄDãM m9M ÄDãM ô ô
|
|||
|
|
õÄDeg ÐU ô ô ÄD ùT - ¥ ù ù ‹ß° Š ÄD ÍU ãM ÅÇ ( ÿT . ¥ û û ‹ßø Óž ÍU ãMü Ù ü NP Œ ŒãM ãM ú ÿT ú
|
|||
|
|
üÄD�( †U / ¥ þ þ ‹ß— ¨¦ ÍU ãMÿ Àc ÿ ±´ OQ � Ž � �ãM Ž c c ˆ ¢cµ
|
|||
|
|
` £cÒ¦ ` àB¤GS
|
|||
|
|
�ù§ ý †U ý
|
|||
|
|
ÿÄDö±ü �U 0 ¥ � � ‹ß• ™ÄD ÍU ãM‚ › ‚ ¶¹ V \ q � �ãM ™j € �U €
|
|||
|
|
‚ÄD¾H ‘U 1 ¥ „ „ ‹ßUãM [^ ; ? 1 ¥ † † ‹ß� µßÄDÄD ÍU ãM‡ ·ß ‡ ³¶ “• ‘ ’ ‘ãM ’ãM … ‘U …
|
|||
|
|
‡ÄDò¹
|
|||
|
|
ø œU 2 ¥ ‰ ‰ ‹ßO ºÄD ÍU ãMŠ » Š ps VX “ ” “ãM ”ãM ¿ßÀßÁß LessÁ Âß ÃßÄß~ Åß ÆßÇß GreaterÁ Èß åºÝÈnûê7 ˆ œU ˆ
|
|||
|
|
ŠÄD¹
|
|||
|
|
P!¡U 3 ¥ Œ Œ ‹ßo íßÄDÄD !ÍU ãM� ïß � •˜ [] • – •ãM –ãM ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ�È ‹ !¡U ‹
|
|||
|
|
�ÄD¹
|
|||
|
|
"U 4 ¥ � � ‹ßz šeÄD "ÍU ãM� ›e � ›ž VX — ˜ —ãM ˜ù™j Žù ‘ ‘ "U Ž Íì¶Ì Ë ¢e¶Ì Ù
|
|||
|
|
�ÄD¶Ì êºðòô ¼9 ÔÄV Access to an constant.Á ßV ú üãV^ [ This wraps a constant value to provide [`Access`] to it. It is constant in the sense that,Á üÂW] Z unlike [`ArcSwapAny`] and [`Map`], the loaded value will always stay the same (there's noÁ ¤ X remote `store`).Á µX ú ü¹X` ] The purpose is mostly testing and plugging a parameter that works generically from code thatÁ üšY, ) doesn't need the updating functionality.Á D–Z ¥ ” ” ‹ß ŸZ �O ìXN#£¤¬ “ • ÄD�O ¼9M ÄD�O ’ ’
|
|||
|
|
“ÄDdf ,¢Z ’ ’ ÄD #ÐY 5 ¥ — — ‹ß® „À #ŸZ �O ¼¾ ($ÖY 6 ¥ ™ ™ ‹ßï Óž$ŸZ �Oš Ù š NP ™ ™�O �O ˜ $ÖY ˜
|
|||
|
|
šÄD�(%ÝY 7 ¥ œ œ ‹ßŽ ¨¦%ŸZ �O� Àc � ¨« OQ š › œ š�O › c c ˆ ¢cµ
|
|||
|
|
` £cÒ¦ ` àB¤GS
|
|||
|
|
œù§ › %ÝY ›
|
|||
|
|
�ÄDö±ü&äY 8 ¥ Ÿ Ÿ ‹ßŒ êà &ŸZ �O › ¦© O U j � ��O ™j ž &äY ž
|
|||
|
|
ÄD·H'èY 9 ¥ ¢ ¢ ‹ßE�O KN ; ? 9 ¥ ¤ ¤ ‹ß} âÅ 'ŸZ �O¥ ·ß ¥ ˜› ˆŠ ž Ÿ ž�O Ÿ�O £ 'èY £
|
|||
|
|
¥ÄDç¹
|
|||
|
|
í(óY : ¥ § § ‹ß4 ¤Ç (ŸZ �O¨ » ¨ NQ OQ ¡ �O ¡�O �È ¦ (óY ¦
|
|||
|
|
¨ÄD°¹
|