boc/aamos-ledger-rust/target/debug/deps/libarc_swap-ec08ea74b5f7d401.rlib

!<arch>
/               0           0     0     0       3874      `
0îÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐîÐ_ZN4core3ptr116drop_in_place$LT$alloc..boxed..Box$LT$core..mem..maybe_uninit..MaybeUninit$LT$arc_swap..debt..list..Node$GT$$GT$$GT$17hc0ea6edc94ef4df0E_ZN72_$LT$alloc..boxed..Box$LT$T$C$A$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17hce3b2cd6d5f2b45cE_ZN4core3ptr58drop_in_place$LT$arc_swap..debt..list..NodeReservation$GT$17h1ea9fe3258f50743E_ZN79_$LT$arc_swap..debt..list..NodeReservation$u20$as$u20$core..ops..drop..Drop$GT$4drop17h06b41d45759db406E_ZN4core3ptr7mut_ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6as_ref17hec601fc01ae0b1e2E_ZN4core3ptr9const_ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6as_ref17h2b16934d7a65b4ebE_ZN4core4cell13Cell$LT$T$GT$3get17h1ee94352da9755d8E_ZN4core4cell13Cell$LT$T$GT$3get17he21b641f2ffecc30E_ZN4core4cell13Cell$LT$T$GT$3set17h5970715363386798E_ZN4core4cell13Cell$LT$T$GT$4take17ha74a485a418e564fE_ZN72_$LT$core..option..Option$LT$T$GT$$u20$as$u20$core..default..Default$GT$7default17hdddad91a7d825813E_ZN4core4sync6atomic11atomic_load17h6f5e199e42e4bdadE_ZN4core4sync6atomic11atomic_load17hcc326f895f15a398E_ZN4core4sync6atomic12atomic_store17h6775a0c4e736977dE_ZN4core4sync6atomic12atomic_store17h71ce22ffffb729a7E_ZN4core4sync6atomic23atomic_compare_exchange17hd2d2eb090b823db3E_ZN4core4sync6atomic27Atomic$LT$$BP$mut$u20$T$GT$21compare_exchange_weak17h079d12a6c60785b5E_ZN4core4sync6atomic28atomic_compare_exchange_weak17h14ee1eec78ea9d0fE_ZN4core4sync6atomic27Atomic$LT$$BP$mut$u20$T$GT$3new17hd3c335be3608627fE_ZN4core4sync6atomic27Atomic$LT$$BP$mut$u20$T$GT$4load17hd741048b7dc5c194E_ZN4core4sync6atomic27Atomic$LT$$BP$mut$u20$T$GT$5store17hd3a8351fece0b576E_ZN4core4sync6atomic27Atomic$LT$$BP$mut$u20$T$GT$7get_mut17h0af4ad3828fdb5b4E_ZN4core5array75_$LT$impl$u20$core..default..Default$u20$for$u20$$u5b$T$u3b$$u20$8$u5d$$GT$7default17ha453e14793ced729E_ZN63_$LT$arc_swap..debt..Debt$u20$as$u20$core..default..Default$GT$7default17hb9fcc4811dad25aeE_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17had986ad4330c78f2E_ZN4core5slice4iter13Iter$LT$T$GT$3new17h090a3ce1342e9dddE_ZN4core6option15Option$LT$T$GT$14unwrap_or_else17haed191d583d20fa8E_ZN4core6option15Option$LT$T$GT$6expect17h60ca021bede5282cE_ZN4core6option15Option$LT$T$GT$7is_some17hebe5d4cd4820b0aaE_ZN4core6result19Result$LT$T$C$E$GT$3map17h299dbe8def3fee0fE_ZN4core6result19Result$LT$T$C$E$GT$5is_ok17h827ccddc2f1c9d9dE_ZN4core6result19Result$LT$T$C$E$GT$7map_err17hce390abfc528d8f2E_ZN5alloc5boxed16Box$LT$T$C$A$GT$4leak17h4762f059d4e1abbeE_ZN69_$LT$alloc..boxed..Box$LT$T$GT$$u20$as$u20$core..default..Default$GT$7default17h8d595b0fb8ecfdd5E_ZN69_$LT$arc_swap..debt..list..Node$u20$as$u20$core..default..Default$GT$7default17hff7264d2a551c77fE_ZN73_$LT$arc_swap..debt..helping..Slots$u20$as$u20$core..default..Default$GT$7default17h7217f83e19d4074dE_ZN73_$LT$arc_swap..debt..list..LocalNode$u20$as$u20$core..ops..drop..Drop$GT$4drop17hbcd343691805dedaE_ZN8arc_swap4debt4list4Node10fast_slots17h4d64e797ce609cc9E_ZN93_$LT$$RF$arc_swap..debt..fast..Slots$u20$as$u20$core..iter..traits..collect..IntoIterator$GT$9into_iter17hdd094a2c0e54688dE_ZN8arc_swap4debt4list4Node12helping_slot17h4691eb3f79687a66E_ZN8arc_swap4debt4list4Node14reserve_writer17hf27540e99a13a15cE_ZN8arc_swap4debt4list4Node3get17hb671a61f91c7b51aE_ZN8arc_swap4debt4list4Node8traverse17h6d11f71e28ee54e5E_ZN8arc_swap4debt4list9LIST_HEAD17ha9453a00f3ffd6e7E_ZN8arc_swap4debt4list9LocalNode11new_helping17h14b7d31295e9307fE_ZN8arc_swap4debt4list9LocalNode15confirm_helping17habd52a931a9ab730E_ZN8arc_swap4debt4list11THREAD_HEAD29_$u7b$$u7b$constant$u7d$$u7d$28_$u7b$$u7b$closure$u7d$$u7d$23__RUST_STD_INTERNAL_VAL17h49f472391cc1119cEDW.ref.rust_eh_personality//                                              66        `
arc_swap-ec08ea74b5f7d401.arc_swap.222cc81a0dc1998-cgu.0.rcgu.o/

lib.rmeta/      0           0     0     644     384688    `
ELF


·
0Ý@@GNUÀrust
„Ú#rustc 1.96.0 (ac68faa20 2026-05-25)ÁÀ뉊]!ÜÛê(¹Þ—šên-5be7b69c3ff7b5b8ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁ¤²XctÔ'ÐÓ©z¨ɽÓ-a4945860e1c53b00Á¤°ð¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁ
–�òÖÀH•‘PIÓHã#£-055f30b747f859b6Árustc_std_workspace_coreÁ­Cçß^ò½èÝ$­Çÿ+Cé-c4878ee60b2242c9ÁŸÃï+Ñ]ŠqB<ÏïW#-8dd1dd90e70d0b6aÁ
miniz_oxideÁ€š»J(P>àö÷g\K-1eb618da2918ab7fÁ
adler2ÁÆ;+Þ®5¥ÌýÝ°¦ÛLˆ-f7919172d268e069Á
	hashbrownÁPäV9ÒÆèÜ�"ÊÖVŽ\-0fc2184a5da6723aÁ
rustc_std_workspace_allocÁs&ØòØy¯s•bæ!‰ýŠ-97e4bf30be240674Á
std_detectÁhŠBîÙºÌI®Ë�Å�š-9dbbf8346ba7ac8bÁrustc_demangleÁûë9´Ç×@Œ�’ùXFº-f33013f239bf9f14Á
cfg_ifÁÜLh�ž§Œaã¯>­�-0a71c8f33a838301Á
	addr2lineÁ׎Þ!]8V$É@@T·-e618e6be60e87ba2Á
gimliÁ¸
°µ~Î1‹Ñt	ðÁ€w-1f7768a68858f670Á
objectÁ
áPÃ?­À¶¼QHJ¥�-914cd6a4dbe590d1Á
memchrÁ›º«8Ór­2Ù $¨ûib‚-cf21ca6f2bb15dcdÁ
ë
‹ás«L
Ö€îâƒ×ɯŒ
-ee6f3747e38367f0Á
rustversionÁTgÌüÁé¨Cå@Ö'G-f0da710c68354185ÁtestsÁ,Ý[‚$Ò[•

ù,ÅF
‚$ºF
í
OnceCellÁD‡»
experimental-thread-localÁüÏ%í
THREAD_HEADÁ\»e»

ºüÓd%í

ù,�f‚$öe¼

ù,‹&‚$€&Á
ù,�X‚$…XserdeÁ,ä-»

½	ŒÌ-à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
r

r
rsealedÁ
vSealedÁ
r
rAsRawÁ
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›
lj£§¬°µ
¡
¥



F


¥8
ØD


F

ØDÌì
8
ØD


F

ØD� Ìì
8
ØD


û
û
»+
þµ

ÿ
å+

€
Ÿ"

¾µÆî¸U1r
ÄD

¤
ÄD

¿c

½
½
¾
•0

Áˆ

—ê
G¸Ç!Z
ÄD
òE

é!

½
½
¾
•0

Áˆ

—ê
G¸Ç!Z
†J
†JK
‰Jµ
�7
ŠJphantomÁ
�7
‹J¤
�7
·0ØQd�è
ÄD
çE
çE

èEGlobalÁ
¿±‡§í#
òE


û
û
»+
þµ

ÿ
å+

€
Ÿ"

¾µÆî¸U1r
ñF
òE
ÄD

é!

½
½
¾
•0

Áˆ

—ê
G¸Ç!Z
òH
òHÆ

õHµ
Ñ,
öH
�F
Ñ,
÷H¤
Ñ,
+átLaû§
ÄD
ÀG
òE


û
û
»+
þµ

ÿ
å+

€
Ÿ"

¾µÆî¸U1r
ùH
òE
ÄD

é!

>
>
?
Õ

Aˆ

Æ_å€×-

ÄD

F

’
ÄD


M
M
N
Æ

Pˆ
=ÄQу‘ß


•
ÄD

Š 

Æ
Æ
à0
Ë£

Ì
˜1

Íý


wv>ÔAH
˜

—
¥
£

Ø

¡K

¿c

¡K

é!

¡K

Š 

ß
ß
­2
ã
ã

ä
˜1

åý


º±‘äyG‚
’
ØD
—

Ø

¡L

¿c

¡L


ß
ß
­2
ã
ã

ä
˜1

åý


º±‘äyG‚
äL
ðK
êK
öK

Š 

ô
ô
õ
Ë3

÷ˆ

ub°W–üE.

ÄD

Ø

ãM

¿c

ãM

™

ãM

Ðì


ãM

µß

ãM
ãM

º

ãM

íß

ãM
ãM

še

ãM

é!

ãM

Š 

’
’
“
 5

•ˆ
ÖÏŠ„Ý1<

ÄD

Ø

�O

¿c

�O

™

�O

Ðì


�O

µß

�O
�O

º

�O

íß

�O
�O

še

�O


�O
ÄD

w

8ØD

y
žP


ØDÈ

w

8Ù
Ù
°

Ü
Ó)

±†3ƒ*s/Á
ØD
ÿ
ÿ
�<

�
­<

;Íñïþø

ù
ù

ú
Ü;
²ýË”FZD

y
ÀP
°P

w

Ù
Ù
°

Ü
Ó)

±†3ƒ*s/Á
ÄD
õP

y
ÛQ


ÄDÈ

w

ÄD


y
§R
ÄD

w

ÄD

y
¾R
ÄD

Ø

°
°
ñ6
³
’
•

´
–7
•

*­PË€	¨:
äL
ØD

¿c

ÖR

›

ÖR


ØDê!

é
ÖR
äL

Ø

½
½
Þ7
Á
Ó)
•

Â
˜1
•

Ô45_â¤ÿ
äL
ØD
íL

¿c

ÈS

›

½
½
Þ7
Á
Ó)
•

Â
˜1
•

Ô45_â¤ÿ
äL
ØD
—
¦

³

Í
Í
à8

Ξ

Ã

å0žé
h©j

³

Ñ
Ñ
Ò
¡

Óˆ
Ã

Žc­pËÒ[L

ÇL


þ¤U

³

×
×
à8

Ø
¯9
Ð

ÍÄd‡7O

³

Û
Û
Ü
Í9

݈
Ð


–Ã
@XÓ©

³

Ý

Ý

¡
Þ

®
Ð

ß

½
Ð

à

É
Ð

á

Ü
Ð

â

ì
Ð

˜"�Áóróû

Œ"

‚
‚
ƒ
ý

…ˆ
í

"=ð¡#Z•7
8

³

ˆ
ˆ
¶
‰
¯
í

Š
¨
í

‹
Ò
í

Η	
í

�
è
í



¹ 5nâg&

Œ"

œ
œ
¬
�
½
í

ž
¯
í

Ÿ
¨
í

zfñØsÊûo

¿c

ç
ç
è
×:

éˆ

]ìÆë

³

³Y

Ç

ñF
Ç

ùH
Ç

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

ÄD
Ç

„¾
„¾PinÁ

†¾‰
˜X
$]È=„kt•

ñF
Ç

„¾
„¾
äY

†¾‰
˜X
$]È=„kt•

ùH
Œ"

õ
õ
œ#
÷
…
ä
øµ
ä
r·�óphK˜

ÄD

£
Ñ[
ÄD

 
Ñ[
ÄD

Ø

¢Q

³

¢Q

‰

¢Q

Ø

ÿ
ÿ
�<

�
­<

;Íñïþø


™%

³

Í\

§
ÿ
ÿ
�<

�
­<

;Íñïþø



™%
ÄD

¬
‘]
ÄD

°
òE
ÄD

µ
òE
ÄD

é!

Ù
Ù
°

Ü
Ó)

±†3ƒ*s/Á
Ä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é!FF
$Š Ø™8Ðì
µß
ºíß
šewy›
é³ÇL
MŒ"Ç£
& 
‰
§
¬
°
µ
Äc
d™%,ž%

ë!

¾D

$™%

<ž%
œ™%$¦%


×J
ÄD
H
4¦%
²%

üñ$A

×J
ÄD\ƒ%¾D,ù$×J–




B

’e²¾e‹

\¯&$´&

H

F

ØD
ØD

$¯&

4´&
À&

ü‡&9
>
>
?
Õ

Aˆ

Æ_å€×-

ØD\™&Ûf,�&




\


Öf«

\Ä'$É'

H
F

ØDÌì

ØD

$Ä'

4É'
Õ'
 
üœ'9
™g\®'“h,¤'




/


Žh„

\à($å(

H
F

ØD� Ìì

ØD

$à(

4å(
ñ(
$
ü¸(9
™g\Ê(¤i,À(




/


Ÿi‰

\�*$†*

œ
ÄD
òE

$�*

4†*
’*
)
üÙ)9
õ]\ë)¬E,á)




/


µjv
(Ÿ*Xè*

õ] 

¿c
SX


‡d
i
n
\

{
¤*
Å
’
Ö¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â


ŸÈ
ŸÈ

 ÈErrorÁ
O˜éBL
‚F$
 c
 cˆ

¢cµ

 `
£cbufÁ
 `
àB¤GS


k

ºks

ìkd
õ]r
ªnz
›



±©

´


¨nìk©
†lÆ


4ð+

Ù
Ù
°

Ü
Ó)

±†3ƒ*s/Á
ñF
òE
tð+,÷+

ë!

Šo

_

<÷+
´ð+,ÿ+

ë!

ñF
D
<ÿ+
Œ,
.
üÐ+<
ÄDã+ÀF,Ù+ñFŒ
ŠoÛ




F

Ío²÷o�

\´-$¹-

œ
ñF
òE

$´-

4¹-
Ĩ-	½
ñF
òE


Æ-
3
ü€-F
ÀF\’-õG,ˆ-
Šo}




6


‘q™

4Á.

Ù
Ù
°

Ü
Ó)

±†3ƒ*s/Á
ùH
òE
tÁ.,È.

ë!

·r

_

<È.
´Á.,Ð.

ë!

ùH
D
<Ð.
Ý.
8
ü¡.<
­p´.ÈH,ª.ùH‰
·rØ




C

úr¯¤sŠ

\‚0$‡0

œ
ùH
òE

$‚0

4‡0
Äö/	½
ùH
òE


”0
=
üÎ/F
ÈH\à/ÎI,Ö/
·r}




6


»t™
<Å1

�
�
žBoxÁ
¡ˆ
ˆ
¢‰
ˆ
l}.xÏ
é!
ê!ÄD
ÀGg
s	
›
›UniqueÁ
�‰
�
ž_markerÁ
�
�8Åá™-Ýñ

¢v
‰
‰§


‹‰
ï
íe¼îËè¿*

¢v¢v






ë!

¢v

(


1

Ò1
E
ü¥1-
­p¸1¡J,®1
¢vm
áux

áu€

Ìwˆ


1


U


íw¥


”ô8dô8
¾e

$�9


äë8Dë8


ª

öe

?
#'

áuüâ8&	>

ÄD


Ž9
L
üº8T
¡J\Ì8”f,Â8
áu�
�
�
ž
ït
¡ˆ
ˆ
¢‰
ˆ
l}.xÏ
öe
ÀGÉ
öeô

a


‚

¾e
·yò­záuù

4…F

‘K
l…F

ë!

‘K

-

 
&$ŒF

H


‘Kê!
ÄD
\
4ŒF
˜F
U
üÝE;
¡J\ïEæJ,åEø{Œ
‘K«




C

Í{²ó{·

@ïF

äK


Ù

äK
,

4
hýF


êK


Ù

êK
,
5
è�G

• 
• 

– PhantomDataÁ
Fu
\»Ÿ




ðK
öK

_d

Ù

…~
u
~
(ºF	Æ
äK
êK
ðK
öK


…~
¿F
¾F





]

Ø
k
¡Kv¡K€
äKz
äK…

êKU
êK`

…~/
…~:


Â


Ì

£}È
Û}–
Ý~c

êK­
äK²
(ÁF
ºk@ïFºk

äK&
ìkhýF
ºk	


êK&
	ìkè�G
ºk


…~&
2
ìk
ÅÊ


ýc
Û
à
Ð
Õ
¤
©

x
}



ÆF
Þ


Âl*
ð2
Ñm:

ºkB

ºk5

ìk=
‚€
F

ºk

ìk 
•€
)

ºkû
ìk
¨€

¨€

¢



±°

»


‚€
ìk³
•€
ìk†
õƒ
ìkY
½‚
á

ŒÒH


êK\äH

äK


ë!

äK
+

3
ôÒH	


`

’"
êK

ðK
y
4
<
öH
\
ü²HD
öKÅHð,»H
•€
¿
È…
}Ê…
¼‚€
Ä

+


O

Œ…
á¿…
°

HèJ

äL


Ù

äL
,

4
h÷J


íL


Ù

íL
,
5
ЊK

• 
• 

– 
“}
Fu
\»Ÿ


ØD

BG

Ù

á‡

Y
b
(»J	ß
äL
ØD
íL

½
á‡

ÀJ
¿J





]

î
k
¡Lv¡L€
äL^
äLi

íL9
íLD

á‡

á‡
 


Ä


Î

ÿ†
¯
·‡
~
œˆ
L

íL²
äL·
(ÂJºkHèJºk

äL&
ìkh÷J
ºk	


íL&
	ìkЊK
ºk


á‡
'
3
ìk
ÆË

½‚
Ø
Ý
Í
Ò
¡
¦

u
z



ÇJ
ó


Âl'
°‰
0
Ñm8

ºk@

ºk3

ìk;
‰
D

ºk

ìk
Õ‰
'

ºkù
ìk
é‰

é‰

 



±®

¹


‰
ìk±
Õ‰
ìk„
¸�
ìkW
½‚
ß



ü›QX	ß
äL
ØD
íL
¤
á‡

ùQ
a
ü²PÇ

¡L$ÝPäL4ÀPíLTËP
ã



˜1
D



\ÆS

äL
”ÆS$ÒS


äL
ðK

1

4ÒS,ùS

|˜T



êK
¼˜T
,¨T
Û}

)
<¨T
üâSu
	Æ

äL
ðK
êK
ðK
öK

Å
…~
ÝT
ÖT



ü’SË


iüºS£


Æ
Æ
à0
Ë£

Ì
˜1

Íý


wv>ÔAH
�

êK
ðK
öK\¤S�M,šSÃ�
,¾S
‰
m

�
7

êK

•€
;

8


£;
Ì

�
›
Û}U

�
õ

ÐU

ÄD


Ù

ÄD
,

4
(ÿT	ô

ÄD


„U
ü
-
ãM8ãMB
ÄD�­pˆ

Y


c


–“
¥
(†U
ºkÐU

ÄD 
ìk
GL

†lX
]
M

j
‹U
ÿ
�
ÂlŒê“
”Ñm›
ºk¢
ìk”­pž­p¥Ã


±Ð
Ú

Ó•
ìkцlë


�U
‚�U

�mê“


%


/


ÐU

ÄD
ÄD
',

·ß

ÄD
ÄD
A
F

N
šU
‡
H‘U

ê“
ê“

­p‰
­p�4


¹
A
K


ž—
º
 ÐU

ÄD
ÄD
',

»

ÄD=B

J
 ŸU
Š
 œU
¿ß
Àß


Áß
LessÁÂß
Ãß


Äß
~Åß
Æß


Çß
GreaterÁÈß




åºÝÈnûê7nê“
vê“
~­pæ­pí•


¹
¢
¬


ã˜


!ÐU

ÄD
ÄD
',

ïß

ÄD
ÄDAF

N
!«U
�
P!¡U
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

ž™
Tê“
\ê“
d­pЭp×{


¹
ˆ
’


†›




"ÐU

ÄD


›e
ÄD

ù
2 "­U

B
"±U
�
"
�m-ê“
5‹�

@­p~P


º]
g


‚�
¨


<³V

ÄD
ÀV
m
ü“V-
­p¦Vê“
,œV




-



($¢Z

ÄD

–“

'

/
($ÖY	’

ÄD


$ÛY
š
-
�O8�OB
ÄD|­pƒ

Y


c


–“
 
(%ÝYºk(%¢Z

ÄD 
ìk
GL

†lX
]
M

j
%âY
�
�
ÂlŒäŸ
”Ñm›
ºk¢
ìk”Ó•
œ­p£Á


±Î
Ø

Ó•
ìkφlé


&æY
 &äY

�mäŸ


%


/


('¢Z

ÄD
ÄD
',
ž—

8
=

E
'ñY
¥
H'èY

äŸ
äŸ

­p€
­p‡4


¹
A
K


ž—
±
((¢Z

ÄD
ÄD
',
ã˜
8=

E
(öY
¨
(óY
ž™
äŸ
äŸ
­p‚­p‰6


¹
C
M


ã˜
³
()¢Z

ÄD
ÄD
',
†›
8=

E
)‚Z
«
P)øY
Å›
äŸ
äŸ
­p‚­p‰6


¹
C
M


†›
³

(*¢Z

ÄD

‚�
' *„Z

7
*ˆZ
®
"
�m-äŸ
5Ò�
=­ppM


ºZ
d


‚�
š

4³[

ÄD
t³[,º[
–“


*

<º[
ì¥[	ô

ÄD


È[
q
üýZK
ãM\�[äŸ
,…[
ÄDn
­pŠ




;


–“
’

$¹	


|¯	L¯	


Ê

ØD
+

#
Ä	
€

ü„	@
°P
d˜	ØD,Ž	
Õª






<


һ


$Ø





ë!

ÅP
&

.
|Î
LÎ


һ

J

ã

…

ü£
@
Ȫ
d·
ÅP,­
Õª
�
�¬





C

¨«
µ“ª
‡

$õ

ë!

ÛQ



 
|ëLë


Ê

ÄD
A
#
€
Š

üÀ@
—R
dÔÛQ,Ê­p„




8

â¬
¡‹­
�


,è


ó
�

üÃ0
§R4×§R,Í




/



,ß


|ß

§R
ô

”

üº
:
§R4Î
¾R,Ä

¾RS




6



X+¸


äL

ÿ†

'

/
H+É



ØD


Ù

ØD
,
5
(+Œ
	°
äL
ØD


+‘

+�



@

¸
N
ÖRYÖRc
äLÖ‰
Þ
ØD²Õª
º

Š


”

ÿ†


®°
Þ
äL}
(,“
	ºkX,¸

ºk

äL&
ìkH,É
ºk



ØD&	
2
	ìk
�”


ûc
¥
ª
š
Ÿ
n
s

Æ
,˜

¼
Ý
Âl褱
ðÑm÷
ºkþ
ºkð
ìk÷‰
ÿ
ºkÐ
ìk×Óª
ßÕª
ç;



±I

T


‰
ìkL
Óª
ìk
–³
q


D÷#


¤÷#


ë!

äL

(

!
'L€$


›
ØD
¤
U
\€$
Dœ$



Ì•$

	°
äL
ØD


´$

³$




üÀ#t


¢
üê#J


ÖR$Û#
äLDË#
ØD4î#
û
û
»+
þµ

ÿ
å+

€
Ÿ"

¾µÆî¸U1r
ØD
ŵ
)

‰
B

äLæ

’w



–7{
º

•µ
c
¼µ
j

äLã

t®%


äL

•µ

&

.
Â%

£

üÿ$C

å¶
T™%
¤±
,�%
‰
g




6


•µ
„

Ο(
T�)


¦

äL
ØD
ŵ


$ü(


d�)

$—)



Ì—)
”œ)


¥

äL
ØD
ŵ


2
¤œ)

¶)

¤

üÕ(a

Õª
ï(
ÖR
Lá(
�m§
¤±
~




?

£¹
Ìå¹
�


d÷)



ØD
‰*

¥

üÊ)?

Õª
ê)
¤±
,à)





.




dà*



ØD
äÑ*
tÑ*

һ

*


l“-



äL
Œ“-


•µ


(


¤]
¤]V

¦]Á
‚]

üß3ø¤”&

Ȫ
λ-

	¼À
ü“-)

$¥-


Ü]

°P
�
6
¼¥-

ÄÉ-
	


	
	
lþ-


äL
Ìþ-

•µ


(

!LŒ.

¼µ

I

\Œ.

\ð-



ØD




ØD


üÆ-\
	
1


ØD


ü�*‹


¨.

¦
üÀ*è

ü‚-¦





�mµ*
­º
L«*
Ȫ
TÄ*
Õª
Ȫ
T†-


̼
Î
å¶
×

‰
õ

¼À½À

¾ÀË

¿À

ÀÀÌ


ÁÀ

ÂÀG
ÃÀ

ÄÀF
ÅÀ

ÆÀ×



`šÁ¬SøBö

¹

ØD‹
å¶
”

‰
²

Û



cached_ptrÁè

shared_ptrÁêT


һ
ô•µ
Å¢½
X•µ
û
¼µ

ØDÄ



üî=H
	½
äL
ØD
ÜT

¼>

§

üˆ=´


œTŒ¨=
ÖR$™=
ÜTŸ=



±
C



\™@
$ž@


¤

äL
ØD
ŵ


$™@


4ž@

Ϫ@
,¥@


ë!

ØD
M
<¥@

²@

®

üî?D

°PT„@
­º
Lö?
Õª
’




8

¢Ã
¯ÕÃ
‚

œÛA
LÛA



¢

äL
ØD
ŵ


DåA


,
ôA

³

ü´A@

ÖR$ÌA
äLD¼A



’


-


åÄ
y

�-•D


ÖR


Ù

ÖR
,

4
h-­D



íL

·‡

'
0
(-ãC
	½
äL
ØD
íL


-èC

-çC



C

Ç
Q
ÈS\ÈSf
ÖRÙ¤±
á
íL°Õ‰
¸

�


—

úÅ


·‡
Ü
ÖR}
(.êC
ºk�.•D

ºk

ÖR&
ìkh.­D

ºk



íL&	
2
	ìk
�”

–³
¡
¦
–
›
j
o

Â
.ïC

Ì
Ù
Âlä¦Ç
ìÑmó
ºkú
ºkì
ìkó¤±
û
ºkÌ
ìkÓÕ‰
ÞÕ‰
æ:



±H

S


¤±
ìkK
 Ê
ìk
–³
p

ΠF



ÜTT˜F



ÖR
Œ˜F
$£F

¢Ã


+

4£F

ü†F$
	


d

•"
ÜT

Õª

{
3
;
°F

º

üãEM

âTùE
œT
LëE

ÜT
Ç
ìË
‚Õª
­
­º
Ë

-


T

¢Ã
ÒãË
µ

8Á
˜/£


´

á.
á.a

ã.»
Ì-
IÜž�B2®




I
8/�	Í



/–
Ð
*
ïT5
°Í
ŠD


ªÍ
›
DEBT_SLOT_CNTÁ
¨0„

´

³Y


*
80â
	Ñ



0é

Ö
*
¤U5
øÎ
kD


òÎ
|
d„
°Í

”„‘

‹/



0

,‘4ª


øÎ




³Ydª

0�
É
	�£

É
0„
É	

ÊL

�£
�£¹

ƒ£¹
„£þ
-'ºˆÉ
¬g




„	
Z
^
	
ø„
ÀŽ
x

‡Œ

ûM

¦Ñ


ž
¦
ª
¶



ÈÄ
Û


dæ
	





$×	Û¼

³Y
áO


Ӿ
"	
	2

Lº
$	

.
T¹

øÎ
4Ô
¤]
¤]V

¦]Á
‚]

üß3ø¤”&

<à	¼À
¤Ô$Û

–Ä
n
3
lÛ
üÔ"
Tì
±



4˜
„Õ
4©	¼À
Ę$Ÿ

˜Ä
B¤
:

ŒŸ13ß
 
Ê

93ç
 ‰3Þ
 	


A3ÿ
  

”×
I3‰ !


”×
I3® # 
Q3» $!
É3­ "
#
$


"
ù3è! %	ǽá3Ì 	'	Û¼

äÈ
äÈ	ArgumentsÁ
æÈtemplateÁ
 `
çÈÀ
 `
üöMõô]Td

ù3Œ] 	ù3Œ  

òW

%!3­  Q3³ !Y3¿ 
'§&Edõ)
°Í
,†+Š

$	
+



'

J*
+


¼õ‚

ƒ/


)‰
*z(
T‚
L«-
$	
-
.Tª,

øÎ
„¥	Û¼


²Ó

,
L
V
Ê

üª·	ü÷ê
ü Á

B
I
üÞð
ü® 
üŽ¶

ù3þ
Π
ù3ÝŸ 
.
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

²Ó
læ¤U,ÁÈïT,Ô4û
°Í
¤

ËÐ
î
øÎ
ú
¦Ñ
›
¦Ñ
Ö
¦Ñ
­
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

ú
¦Ñ


£Hâ
B
M
ö²Ó
$²
Æ
î
!
„Õ
ƒ
„À
L’
ðß
ð
„À
å
”×
”×

”×
´
”×
¡”×
†”×
{
N
v
nǽȽ

ɽ}
ʽ

˽NeÁ

̽

ͽMatchÁ

BÙe±æµé!3á 
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

ÓØ
Ô�m»
ÿÝ
3
'
¾ß
0²Ó
i
¸
u


µz
®|
ž
�
‘xù	´>´ú

½â
oldÁ½
left_valÁ 	right_valÁ!‚>
	%á

±TÓ
±
�Ð
%

Ús

³Yá	 Ñ
¨	£Ò
¯	ØÕ
~ÚÖ
½Ù
­ïÚ
ü

U
]
±ÿ



Ê


;
”×
+
�:

©
±
0b01Á0b10Á0b11Á
0Á
¸4Œ8	
ªÍ




84Å7		×



4Ì7	
Ú
*
îU5
°Í
XD


ªÍ
i
X5’9	

´

„Õ




85æ8		Û



5í8	
ß
*
£V5
„Õ
^D


®ç
o&ù=�[W X

1?ß
 
è

£
ØD

”×
d¤X		

„Õ
<¶X	
	¼À
Ô¤X	$±X	
ØÕ

	?

0

l±X	9?ç
 ‰?Þ
 	


A?ÿ
 

”×
I?‰ 


”×
I?® 

Q?» 

É?­ 









ù?è! 
	ǽá?Ì 	Û¼

ÓØ

ù?Œ] ù?Œ  
½Ù
!?­ Q?³ Y?¿ 
R=\›Y	
„Õ
4¬Y		¼À
Ä›Y	$§Y	
ØÕ

?
0
d§Y	<ÖY	”ÖY	
DàY	
Û

ÄÐY	

 8ˆ
×}	Rùˆ
ž"#Q	


R#WQ

”×

5:


Ðb

WNT
V<«Z	|«Z	
$¶Z	
Ü




 $ï\	


õ\	


”ç\	<ç\	

û

ÝV
8
/
'
-



	
éFã8l
¹Fã8l



¡G

ºk
ü“])	'ºk/|Â`	
„Õ
4×`	 	¼À
äÂ`	$Ò`	
ØÕ

?
 0
dÒ`	
Ü÷`	!


!
\…b	#
„Õ
4–b	$	¼À
Ä…b	$‘b	
ØÕ

#?
$0"

d‘b	<Éb	&´ºb	%"
&


%
 
¬Þe	"
Â8
l�i	X



\�i	

’"
Çè

�mÿ8
�m='
E
dÍi	*'
¼Ãi	LÃi	

һ

*&)
#üÃi 	(
)|�l	,
¤]
¤]V

¦]Á
‚]

üß3ø¤”&

£V
4–l	-	¼À
ä�l	$‘l	

Ü]

£V
,r
-5+
#d‘l	„›m	/

ƒò
4±m	0	¼À
ì›m	$¬m	
Ùò

/?
00.
#d¬m	l‰o		Y.�m	Z	Y 	[)
‚

„Õ
9
K	\Z[Z	]\f
z		]
„
‚

„Õ
Z$

Œ­p		7.ä­p		6
7DÁp	
Û
1Gß
 	569Gç
 	8
è

Çè

ØD
”×
‰GÞ
 	4	

5
8AGÿ
 	94

”×
IG‰ 	:4


”×
IG® 
<9
QG» 
=:
ÉG­ 
;
<
=



;
œôp		B.üôp%		A

B|Šq	
Ù
ü²t$	D
„Õ
<�u	E4–u	F	¼À4žu	G	¼À
ü²ts	„ðt	

šÄ
De
EUATŠu	
FT
GEC
#üðt5	ùGè! 
>	ǽáGÌ @	Û¼

ÓØ

ùGŒ] ùGŒ  
½Ù
>!G­ 9QG³ :YG¿ 
@R?#>
´HC
ü¬ty	

H

Õ\�z	NC


¬¾|	
N
•}	'„­w	J

ƒò
4Ñw	K	¼À
ü­w+	,¾w	

Ý]

£V
JE+\Äw	
K=I
#Ô¾w	\Öx	X

M
'
ÄÊx	\Êx	



É

ØD

M<L
#$
¸XÀ

ë= 
ÔXÜ

ü½Y»$	cS	‚È
‚ÈArgumentÁ

„È´
Àb


ökÏ®ÝWj´


T¬Uµ

CÕVS
äê


«cC

UVP
'
ùN�@#áN�#

ÜW

PùOž"#O(
þ}	
üúV„'	

'!



X
!"
	^.Ùó
!	_	^0	`_=P	a`]

h	ba
w		b
	%
…	2.
„Õ
4«o		3	¼À
ü‰o)		,—o	

—Ä
2Ç(d�o	
3<1
#Ü—o	
è

ù?þ
Π
ù?ÝŸ 

ü‰Yõ$	
ü°`æ	
üóa×	
üûh›	
ü°iæ	
üïk§	
üŒmŠ	
ùGþ
Π
	ùGÝŸ 

üãp³	
	ü‰zå	
ü	


c
�mËW	ÝV,“W	ယW	d¦W	Çè
\»W	
 à
Ú
”×
h
”×
ü,
ðß
_
„À
T”×
û”×
ð
Ã
ë
ãéà
!?á 
�
Ëá
µ
\�Y	
ðß
j
„À
_

1
’

§

W

ÝV

È‚z
4
\´`	
ðß


„À


Ñ	\÷a	
ðß
Â	
„À
·	
s	
ˆ	ØD\ÿh	d´i	
Ȫ
	Õª
	°ò
\ók	
ƒò
ð
„À
·°ò
D�m	
܃†
„À
{�m–
ðß
M
„À
¾
 à
h
”×
¢Æ
Þ
”×
«”×
	”×
t	
G
o
géà
!Gá 
\
Ëá
�Tçp		
a
Ö¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â


A
ðß
–
‰
„À
…
„À
z
,Ôu	�m<
܃o
„À
dȪ

ØD)Åé
ÓØ
Ö
”×
+

”×
D
·û

K

·û
d

Ο
]
„‡i

”×
r

	
Ùó


	
	
	

	

	
 
	
Ùó
)
	
1
	
8
	
?
	
F
	µ


whoÁ¼
storage_addrÁÍ
replacementÁÙ

Ïâ
¤

ãâ
�
‚™
®Š
É;new_controlÁ0"
Ó‡'replace_addrÁ"(their_spaceÁ+my_spaceÁ	.
Ïâ
=

9
ãâ
6

:‚®>
space_addrÁ©A
ªˆº
NÀQÀSÀ
$žX	
Ü
l
Û
ß
Ü

Û
F

Ù

ØÕ
:½Ù
WØÕ
óûì
“úí
é»î
³ØÕ
]ØÕ
ñ
ˆñ
‹
һ
9
Ùò
´Ùò
c‰ÿ
“Ê÷
Y
½Ù
î	
ØDf	ƒú
4	Úú
ä¼ü
ëŒý
Ä
ØDˆ	

Ëp	

É

Ø

è


y
”×
õ
P

=

F

Ü
—

¦

è



7
”×
Ã
‡
Ó

”

Ü

0Á

1Á
2ÁLè

¤]
¤]V

¦]Á
‚]

üß3ø¤”&

€X
4÷	¼À
´è$ò

Ü]

€X
z
5

dò
üè4ÿ

Ï
€X

M
Dÿ
<ª
T�


	$¢
Û


€XÍ	
<Í
	


%

•"
êK

�
	<

2
;
4å
„å<ì

£T

Çè


+
Lì
,



4�

õ


LÄ
€X
”Ä4Î

è
€X

2

DÎ
ü±'


â
$ì
	Û¼

Çè

Š


ö
C


³




üÜš


ä

‘$üÍ©
ü²±


üÀ£


ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

Çè
L©
êK,œ
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

Ê�\Ñ
ž�õ
ïŽ^
„À

¥Ê�œ„”4Ä
êK
—
ƒ‘‘
I
„”e
Ü”ì»
•’
±Ë


currentÁ�

½
�qš



È�¥ù�|ú�¼‘Æ
êKƒª’e
„”1
êK—
„”>
êK¤

<¶A	Û¼


êK


”¬AL¬A


‚/

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

êK

|

h\ÈA


¡
Çè

êK

®

®£



°
Ó)

¨
it§ÅLS¶

æXüêAÐ


	¤
Çè

êK





æXÇè



á.
á.a

ã.»
Ì-
IÜž�B2®

Ø—


üÈAó

DáA


Â
æX
¤
Çè

êK

¥™
¼™
Çè




¸
üáAÚ
ü÷F‰
	
	¥
Çè

êK



åH

åH


æHAccessErrorÁ

–úrì$šÙ0Çè


¼™

	
üÈA¹
tèF

„\
Çè

óš
¥
Çè

êK

îš
¼™
õ
«
üèF™
†J
‡J



üÝ@ª	

¡ü¤Aã


Çè
˜AêK�AÀ™¨A
Ø—Î
Ö¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â

Çè

óšØ

ʘª
‘šd
¾™m
Ò›­

¾™¶

±§


±ª
í

ò
à̘
Ò—qˆšCÄ›Ž

˪D

˪K



-
6
à̘D

S

¡

K

ʘp
̘y�

†
à̘	
L†B
á.
á.a

ã.»
Ì-
IÜž�B2®

Ü”
|†B�B

‹/

Ü”

^

,�B
)
̆B<–B

¦T

�

R
L–B
+



L¶B
ÚŸ
\ÉBLÉB

—


ŒÄB		Û¼


�


ü¶B ÀB

ƒ/

Ü”
m
	>
´ÀB
‚C


¾™
D‚C$„C

•/

Ø—
/
4„C
Œ‚C4‹C

±T

êK

E
D‹C
<¥C

	



¥C

™"
êK

æX

6
>
ºC
¤:üúB@

Çè
ðA
‘šZŒ£$ëA
¥

Ü”è
Ü”ñ

ÚŸ@�mD

ƒ¤ž

ܔs
Ê�š
êKþB
Ø—.

Š£ä
¾™ÒheadÁ~
±


¾™±I


› „Ò T¡¡Ý¡Ø
Ÿ¢œ
Ê¢x
�£W


_ref__fÁ
\ÑGLÑG
¡¡


ŒÌG	Û¼


�

äÂGLÂG


‚/

Ü”

9
$
¤úG”úG

´

ïT

¼­H¬­H

´

îU
üœG»
	œ


ñH




¾™
DñH
$óH
Ÿ¢

)

	4óH
ΖH
4úH
Ê¢


;	
	DúHL–Id”I	


”I
�£	
)
	2
ÿI
€J




 

¥/ü�Gó
üéH—



Çè
úF
Ò›Z
óšøFæXD‘G
ÚŸ±

Ü”×
Ê�ü

ïT¡

îU†
êKíH

Ø—E

Š£öŒ£

¾™Ä±«

¾™tmp_nodeÁ}
±T	ü

	¡¡{›¦IĦ&ç¦
Ÿ¢¾
Ê¢Ÿ
�£t

æXB

æXH



Ť
LœP

ÚŸ
|œP¦P
› 

+

,¦P
ü³P#!ºk
üœP;4¬P

°T

�
V
8
ü¬P+ü›P<\òP



„Õ
<ƒQ
	¼À
ÌòP
$þP
ØÕ

K
0

lþP1Zß
 
	
9Zç
 


¦
”×
‰ZÞ
 
	

	

AZÿ
 


”×
IZ‰ 



”×
IZ® 
QZ» 
ÉZ­ 





ùZè! 	ǽáZÌ 	Û¼

ÓØ

ùZŒ] ùZŒ  
½Ù
!Z­ QZ³ YZ¿ 
R=L¡Q



¤UT¹Q



ïT
ü¡Q#
D«Q

Ê

L´Q9
Ì«Q
ÊQ
¦üÃO‡ü�Pº

ùZþ
Π

ùZÝŸ 

†Ý
¬ðOŒ£,ÚOáOÊ�$”PÊ�Ž
Ü”Ñ
ƒ¤ð
ºk¿
 à
ê

”×
M
ðß
Œ
„À
u
”×
0”×

”×


Ó

û

ó
éà
!Zá  

Ëá
Å

ÕÝ
q
êÝ
[

Ê�¹
Ê�Áà


µä

½ä

Ïâ
™
ãâ
’‚~c


L�Q
ÿ

› çó«´ØÕ
F½Ù
Iá¯Û


;
C
ÿ
<

K

¦

Í

”×
h
ƒw

�
ÿ

L—_

ÚŸ
|—_¡_
› 

+

,¡_
ü®_#	!ºk
ü—_;4§_
ó«
P
	2
ü§_+ü–_<\í_




„Õ
<þ_
	¼À
Ìí_
$ù_
ØÕ


K
0
lù_1cß
 
9cç
 

«
Çè

ØD
”×
‰cÞ
 

	


Acÿ
 



”×
Ic‰ 




”×
Ic® 
Qc» 
Éc­ 





ùcè! 	ǽácÌ 	Û¼

ÓØ

ùcŒ] ùcŒ  
½Ù
!c­ Qc³ Yc¿ 
R=dœ`




ÝVd®`


ÝV
üœ`:
$©`

è

Çè

ØD
S9d¼`\Ê`
ü©`-
Ü`
«üø]äü‹_Ñ

ùcþ
Π

ùcÝŸ 

�mÉ^Œ£,‘^Ê�˜^d¤^€�\¹^á°$�_Ê�®
Ü”ñ
ƒ¤
ºkß
 à
	
”×
Cs
ðß
²
„À
›
”×
V”×
*
”×


ò


éà
!cá ¿

Ëá
ä

�
á€z

Ê�¹
Ê�Áñ



¨‡õ

¹‡ú

Ó‡þ

½



Ïâ
Ö
ãâ
Ï‚œ‘


Lˆ`
ÿ

› %ó«òØÕ
Š½Ù
†î¸


;
C
ÿ
€

�

«

û

”×
¬
ƒ»

�
ÿ

ùj·™e



éj·e




¾

æX
ùjÕúe

â



ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ


ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

æX
æX
Ÿ¾²

à
ùi�f�
a

à


̘ái¢fa
+

ï
â

Ÿ¾Ÿ¾
_Á
$îc	Û¼

�
|äcLäc

›¦

0



¤ƒd”ƒd
Ħ

¼ªd¬ªd
ç¦

üÊc~	œ





j˜e

á
ùjÔDe

æXL¾c
ÚŸ©
Ü”Ë
ïT”
îU}7

›¦ÐĦ²ç¦šùjðe



éjðe


Ð

æX


/
5



ùj¦®e
	ã





¤¾·¿

�m1


Ÿ¾	j¿e

ùjíÔe
ùj‚!­e
	å


ÿÂ
�m$


Ÿ¾	j›!e

O
	jÀ$e


ùjÛôe

â

Ÿ¾ 


ã


ÿÂ
�mì
å


ÿÂ
�m¤V

_Á
¹jäe
ä
ùjäZe
Yjüe



Çi
æX
�m

á9Ájˆ e
Ùj¢ e

®Å

ùjüBe


jÔ e

ã
‘

·¿
jÀe

¿Ä­
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

ï¾
Áj§e

¾i

¾iStorageÁ

Ái»

¬i

Âiº

¬i

7·O|5‡
æX
�m5

__rust_std_internal_initÁu
}


¢Å\
(k€ºk°kŸ

„Õ
!
ìk
HM

†lY
^
N

k
k…
ë
‚
Âl�²Ó
•Ñmœ
ºk£
ìk•ðß
 ðß
¨Æ


±Ó
Ý

¥ÉìkÔ†lî0b11Á4á

„Õ
d±4Ë	¼À4Ó	¼À
üáù„ 
Ê÷

e
VT¿
±

[
L

ü :
E
üáŽ,è

Ð[



r
<è
õ
µ
ü–ß	
$Ò²Ó
,³—Rº
¨…¨…Ê
ðß
 



„À



„À

L


µN
{

ò
±
Ê÷
"
¸ËÖ
üãŒ	
(	º
ÄD

£



ª™�m

…Ì”×
ÁÍ



üÓ�	|Ó


¡
�m
º
ÄD
ÁÍ

ÊÍ
ØÍ

¢

>
õ%
ö%



ü¼º


·

�m‘…ÌØdíÁÍ\‚
�Π

ÚÍ)

”×
2

ãÍ;
µC



¹‡H

Ó‡L
�

‡Î	

ÁÍÌ
ÁÍÒ
˜


ÚÍ

„Œ\Œ


Ë

ÄD

;

#
$‹

d„
4„



Ì

ÄD
+
$ü·ä
	




”×
 




ãÍ0



ÚÍ@

L
	»
ÄD
ÁÍ

ƒ‘Û¼ݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

�m

Œ£”×
ãÍÚÍ­p
	



üŸý
¼Ÿ


‘
�m
»
ÄD
ÁÍ

ùÑ
ÊÒ



?
î%
ï%



W

ºfüùö

�mê
�ΆŒ£,äÄDý
…ÌÀ­
Æ
­pÞ
ÿÑÕ
ŠÓ·

ÌÒÀ

­pÈ

ÚÍÞ
”×
ç
ãÍð
ÚÍù®u
µ

ÚÍ
¹‡


”×

Ó‡!

ã͹±
Q

ÆЮýÐ~�Óƒ

ÄDD

ÄDJ

	_ref__ptrÁ_ref__storage_addrÁ_ref__replacementÁ
¬±t¶

–
$±

„¶,Ù


ÌÒ

dê



”×


dø


ãÍ
üÙ,
$ß

«
ÁÍ
ÄDr$ä
_E
üß&
ü¨ &
TÂ 

š
$¨ 
d 
Ϟ 
d€!

›
$û 	
t€!
üê %
„ê 

ØJ

²Ó


	F
%
ü¨ h
,ä 

’N
Äl
ÄlIterÁ
Çlµ
™l
Èl
end_or_lenÁ
™l
Él
öu
™l
ŒœjSž
³Y
â±
â±OnceÁ

ä±
Ó)
ÔJ
¹s§JE™

²Ó

*

Û
üä ,
HŠ
®!	

ÊL

ð¬
ð¬ChainÁ
ó¬¬
Ü6
ô¬­
Ü6
r_­koiÖ
“Ù
ìÙ
L®!

m
q


øŠ
¢!Õ
‹

šŸ

ûM

ÔÚ

±
	º
¾
Ê




Ü$¦!
Û


²Ó
Þ#

ÚÍ

”Ð#Õ#


µ

ÄD$Ð#
C

lÕ#
$‰%	Û¼

�m
š%
[



$É$

­p
dÂ$4Â$


ýÐ
*

›%
b


�

H
»™üžý
ü˜ ƒ

‹

’


ÿѽ
ŠÓ
ÕÊ�$¸‚
‚
ƒ
ý

…ˆ
í

"=ð¡#Z•7
d¢�mû
7ÔÚLœ 

“ÙÔ
ìÙˆ
²Ó
»
ÔÚ­
ÔÚ¶
†Ý
¿
ÔÚ
Ë
U²Ó
ú

È

…Ìò
À­
]

ÌÒ¨
Œ£±
”×
º
ãÍÃ
ÚÍÌ
­pÔ

½


®k

ÌÒ
¹‡	


”×

Ó‡	

ã͵2	

Ú͹°

­p_reservationÁA

	all_slotsÁ<
ùÐ
½ú�

ÐÖîË×{�Ø@·ØâØù�ÙÕÎÚäÛ!êÜ

úÞÊýО
úÞØ
_ref__localÁ
•Õ
ªÕ
‰Õ	_ref__valÁ
|ð\ð



Ù



ü

'
üátá


É

Æã

J
%
†
Ì
ü²T


ÆãÈ
|ÇÆã¹
Æã—

meÁ


E

Àã·îã�

œ°t°


Ë

Æã

¿

&
Ì«$«

Ý

Æã

G
#
Ë
Í
üûP
�m ¥ä‰�m\
Æã�

µ


?

Šå®µåˆ

Œµlµ


ß8

ÄD

Ã

%
ܵ
§R
Ö
Ñ
ü‰M
§R4¤ñF•
¾Rk


Ðã


5


ËæŠ

”(



lŠ(LŠ(

Ý

ñF

*

"
üó''ló'

Ëæ

�(
!l®(
§R¨)¾R
”š)lš)


Þ8

ÄD

-
#
ü…)*\…)

¼

ñF

ì‘)
%
Ã)
ÒüÛè	üé'Ú

ü¤(Ÿ



§R4õÅpå¾Rí'
ñFÒ
ñF*
�mŠ
ñFv
¾RÓ

Ðã<


µ@
µ¨(Š

ïçg
ËæF
ßè
ˆéä

”þ)lþ)

ßè

Œ*

 
–*
Ó
üÈ)N
ñF4í)¾RÛ)

µ


-


ßèm

„þ*dþ*


ÿ-

ÄD

‹+

%
Ôþ*
§R
ž+
×
üÓ*K
§R4í*ùHß*
¾Rk


Ðã


5


óëŠ

Ú3



lÐ3LÐ3

Ý

ùH

*

"
üº3&dº3

óë

ÄÇ3
!lô3
§Rí4¾R
Œà4dà4


þ-

ÄD

-
#
üË4)\Ë4

¼

ùH

ä×4
%
ˆ5
Øü£+å	ü°3Ø

üê3ž



§R4¼+ïs­+¾R´3
ùHÒ
ùH*
�mŠ
ùHv
¾RÓ

Ðã<


µ@
µî3Š

—íg
óëF
‡î
°îä

ŒÂ5dÂ5

‡î

Ï5

 
Ù5
Ù
ü�5L
ùH,²5¾R 5

µ


-


‡îm

œÝ6à6

·T
ÄD
À­


É

ÄD
Ý6\ä6

§ñ

„à6
üÝ61tñ6

³T
À­


²

—R
ll€7
ìñ

ìñ6
”7
Ý
ü¨6l
À­
dÆ6‰Z´6
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

À­




Ðã[


}

šñ 
âñà

\Í74Ð7

©T

ÄD

Í7

DÐ7
ÔÍ7Ù7

·T
­p
À­

‹­

NLÝ7

‹­

tÙ7
üÍ78tè7
âñ
Vl÷7
ìñ

ìè7
‹8
Þ
ü™7r
À­
d¶7‰Z£7
Ãò¨
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

­p 



Ðãb


‡

Îó@
úó
âñâ

lÒ8<Ö8

Ú

—R

Ò8

LÖ8
,



$î8	Û¼

ÄD
üÏ8a
„•9\•9

ÆÐ

¡9
 
´�9	Û¼


ÄD


L
¶9
ß
ü�8¦

‰ZL»8…Ì£8
Ù
ÄD�

µ


<

©öþÆÐ¥

ì„<Ì„<



ÿX

ñF

ž<

%
üí;7lí;

Ëæ

üû;(
"
üí;A
§R
´<
ð
üâ:Ò

§R4‚;ØZî:
¾Rj
ñFZ


Ðã


=

»ø»Ëæ–

ãE



lÙELÙE

Ý

ØZ

*

"
ü¿E(Ì¿E


»ø

?

ü¨EBl¨E

Ëæ

ü¶E3
"dþE
§R÷F¾R
”éFléF

ßè

(

üÔF*\ÔF
ˆé

ìàF
 
’G
ñüº<Ø
üŸEó

üôEž


	
§R4Ù<ØZÄ<¾R£E
ñFÌ
ØZ7

ØZQ
�m�
ñF�
¾RÔ

ÐãD



ÐãI
µøE–

–ú�
»øn
ËæP
ßè
ˆéò

”ÁHlÁH


ßè

ÏH

 
ü®H&”®H


öX

ñF

B
$
ÜH
ò
ü˜GÄ

ØZ$½G¾R«G
ñF�

µ


5

ßèŸöý

ì§ĶK



ÿX

ùH

ÁK

%
ü‘K6d‘K

óë

üžK(
"
ü‘K@
§R
×K
ö
ü‡JÐ

§R4¦J–[“J
¾Rj
ùHZ


Ðã


=

�ÿ»óë–

„U



lúTLúT

Ý

–[

*

"
üàT(ÌàT


�ÿ

?

üÊTAdÊT

óë

ü×T3
"dŸU
§R—V¾R
ŒŠVdŠV

‡î

(

üõU)\õU
°î

ä�V
 
²V
÷üÝKÕ
üÁTñ

ü•U�


	
§R4ûK–[çK¾RÅT
ùHÌ
–[7

–[Q
�m�
ùH�
¾RÔ

ÐãD



ÐãI
µ™U–

܀�
�ÿn
óëP
‡î
°îò

ŒáWdáW


‡î

îW

 
üÎW%”ÎW


öX

ùH

B
$
ûW
ø
ü¸VÃ

–[$ÝV¾RËV
ùH�

µ


5

‡îŸ¼„

„å

\å




ÆÐ

ñ



 
üÓ
#
ŒÓ




¼

ÄD

B
$
ü©
X
	õ

ÄD


‡

û
üÌ	»


Ñ[$š

…Ìå	
†Ý
$ú	

ÃÛ

ÃÛ
ManuallyDropÁ

ÅÛ
»
¬
„µÜÀ,�%*

ÄDÁ
ÄDîµa



…d
‘

ÆÐ
î…ú

4Õ
	¼À
¤È
$Ð


Ü]

—R<È

7

dÐ

d¹


Ü«

D°


¦
$«

0
´°

à‹
«

	

ž$

†Ý


I
#
'

3




E
ä«

	
l
²Ó
4æ
	¼À
¤Ù
$á

‡ˆ<Ù

2

dá

¤Œ
Æ


¡$
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

Ñ[
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

ˆê

)?ÈXM´­
?
芽
n

tú






<·

…ÌTÀ
	Û¼


²Ó

	
ô­
L­



û

ÄD
I
=

	(
üŸ/
	Û¼


Ñ[



ü÷ˆ

ï
…Ì
Ӈ
æ



êÜ	$á

0
læ

-




$�
	Û¼

Ñ[
üÞ¡
è
…Ì$í
	Û¼

²Ó

¤Þ
LÞ


¹Œ
A
5
#
üÐ%
	Û¼


Ñ[


z
…

üüȽ

ü¾
Ç

ü å


„

‹
’

÷
ü˺


 Šd†
Œ£$Ó
¤]
¤]V

¦]Á
‚]

üß3ø¤”&

À­
<å
À­
Â

„À
7
•¢˜¢
™¢l

š¢ˆ
ݢ
Ϣ[


�¢ˆ

e0<#˜
èŠ
²Ó

†Ý
C
]
|²Ó
ã
À­
<Ï

„À
ß
Õ
Ñ[ü¤)

…ÌÇ
†Ý
¿
B
…Ì^
Ñ[üÕ

…Ìÿ

†Ý
÷

½7



storageÁ

µ


…$¤
	Ž.
?
芹Ÿ	
È¿
î


‡ˆxȈ>öˆ‡ˆ¦šŠ%¹ŒjêÜ
¹Œ‡

<ó


äó

üâ.
\ç


§
$â

1

üç)

4Ü

	¼À
¤Ï

$×

‡ˆ<Ï

2
d×

”Ì
	
ü²-
|·


¨
$²
Ç

	8
ü·(

5

ü¬3





V\½



²Ó

²Ó
\Ê



½•

L� 
…Ì
üø
„ 


êÜ\ø

1
	œ„ 
$ñ

«

²Ó
L÷
…ÌT‚
	Û¼


²Ó


üí 
Lí


¹Œ
E
9

$
üí-
TŽ


¥
Ñ[
ÄD


H
dŽ

üÓJ
„Ó




¦
Ñ[
ÄD

üä8

*
ú




L¾ 
…Ì
Œ· 
4· 



Í

ÄD

.
#¬�"

À­
…Ì$¦"
	Û¼

²Ó

ü…"&
L…"


¹Œ
Q
6
$
Ë"

ýüÕö
üØó	

ü¿Œ


üî½


ü¸ƒ


Ñ[$”
Œ£$á
Ò�<ó
Ü

O
Ô�œó
À­
LÃ


„À
.
Ö¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â

²Ó

½•7
Q
Dî
²Ó
{
ÄDÆ

Ñ[E
…Ì|
†Ý
t²Ó
 
á
…Ìý�m×

…Ìó

…ÌÂ

À­
Ë

†Ý
´

½*




�‘/

53

	candidateÁ*

…2unused_debtÁÃ
Ó‡°Õ


	Ý“À‡ˆƒÝ”NêÜ«¹Œ@£—Ò—ö¢˜¬¹ŒR

D–#



߆
„–#
,Ÿ#


ë!

߆

1

<Ÿ#

܌#
LŒ#


‹­

A

"
…Ì
­#

þ
üß"N

…Ìtó"
Ñ[,é"

À­
h­pš
߆»

%


J

ö�‹­
�
	
L•$



†Ý

„•$
$Ÿ$


äT

²Ó


2

4Ÿ$

)
´�$




I$Ó&

Û


²Ó
L‚'




߆


ö�
'
/
¤ø&

Lø&


‹­

K

¯'

…Ì
”¡'
¦'



êÜ$¡'


0	
l¦'

-

	

lì)



߆
üÙ)!
”Ù)



Á

ÄD
3
$
ƒ*

�üò#‘
üÎ&Ê

üî&ª




�m„$
Ñ[
Lú#

†Ý
–

†Ý

¹

$¶%
²Ó
e
À­
ò&

­p_
†Ÿh



…Ì!
�mÄ
߆
æ
o



…¹

µW¿

àŸ&ö�Æ
‹­
˜
êÜj
…¢


$‘+
	Û¼

²Ó

´¨+
ά+


î…

º+


 
üø*Q
	õ

ÄD




Ï+

„
üÐ*

Ñ[$é*
ÄDÞ*

†Ý
�
߆}

µ


=


î…›
ü²-§



L¸-




†Ý

„¸-
$Â-

àŸ

+

4Â-

$
´²-




D$£.

Û


²Ó
LÏ.





߆


ö�
&
/
ŒÈ.

4È.


ýÐ
K

ý.

…Ì
ӕ.
ô.



êÜ$ï.


0	
lô.

.

	

¨/
…Ì
\¡/
4¡/


¢˜

)

D«1




߆
„«1
,´1

ö�

*
	<´1

$


Ü¡1
L¡1


Ý

ÄD

L


#$Ô1





ŒÈ1
\È1


¼

Ñ[

;
#
,ã1



î1

í1




üã+‹







.




0

…<üž.±


ü¾.‘



üŒ1b


ÄDþ+

Ñ[Dñ+

†Ý
—
í¢¶
$×-
²Ó
hÀ­
Â.

­pb†Ÿk

…Ì#�mÉ

…Ìå
ÄD,�1

¾R«
­p³

†ŸÑ
�mJ

Ñ[s



¤



…ô
µ�
Ó)_
=



àŸhö�
ýÐßêÜ°¢˜hö�7²©ú©Ë

ÄD‘

Ñ[—


LÙ2



߆

ö�
'

/
è2

ˆ
ü¸20

­pÌ2
ëž,Â2
†Ÿg




5


ö�„


uá3

ü
(uÜ3

¢Q¢Q

!


+



vê3

þ
8vã3


¢Q



trueÁ
¸w‹5


ú\


Ù

ú\
,

4
(wÕ4
	ÿ

ú\


wÚ4

„
-
Í\8Í\B
ú\�ú\‹

\


f


‘°¨

¸x‹5


´

ú\



8xÜ4
	ÿ

ú\



xã4

‡
-
Í\8
ú\_F


³±p
ü”7ü

	’
ÄD
¾]



ª™Ñ[


Ò�


ü„7�
|„7



¡
Ñ[
’
ÄD
¾]

Dz
Õ²

w

<
—9

‘
ü³6ä

Ñ[|ê6
‘],Â6
Ò�<É6

þ²Ä
ײÌ%



�‘)
X


õ²´

l·7



Š

¾]

<÷7



ײ

ü×7(
Ì×7




ü

ÄD$ñ7
C
+
$¥8
	Û¼

Ñ[
ü´7ƒ

$Å8


üÙ8,


	


ײ
	“
ÄD
¾]

�mÑ[

ÌÒײ
	
üÅ8A

tÊ8


³T
Ñ[
“
ÄD
¾]

öµ
�¶
‘
‰
üÊ8<

�9

’Jü©7ç




Ñ[š7

þ²jŒ£$•7
 Š$­7

 Šô
«¶ï
ÌÒ÷
ײŸ
Ò�¨
ײ±
½I

�‘

ײ
¯_
ä

å


Š

¾]
ñ´¾
¢¶



_ref__storageÁ$÷8



ÌÒ
<ý8




ײ

üÜ8)
ÔÜ8



ý

ÄDZA

)
…9

“
þ

Ñ[Û8

Ǧ
ÌÒ
Σ&
ײ/
Ò�8

½p


ÌÒ
�‘<


ײe


�¹±

_ref__nodeÁ
°·üÏ<"

	•
ÄD
¾]


�mÄD

˳ײ

<–=

	

ä–=

	
üû<E

¬û<



·
ÄD
•
ÄD
¾]


þº
‰»‘=

L\´=


I
Ç=

”üœ9«
ü½<Š




�mð9
˳,·9
…̾9
Ò�<Ó9
Õ»\Á<

‹»

ײ"
�m»
Ô
�šœ–=
S



Àâ
W

�‘[

Ó‡_
¨


Ì»

$Ò<


‹»
<Ü<



ײ

”Ò<
$×<


ª
‘]
ÄD]C

l×<

üÒ<
Tå<

£—

H
då<

ñ<

•
4
ÄDÑ<

Õ»M
Ñ[‰
‹»]
˳f
ײo
Ò�x
$¸9


‹»
�‘’



ײ§

§¾棗º

_ref__selfÁ
°·üÇ?›




*

üä?/
üä? 


§¾
$…@
<‹@

*
ï@


dï@

4ó@


þ

ÄD

*
Dó@

<ÿ@


„ÿ@

4‡A


{
”
—R

/

D‡A
.
	

…Ìüï@ 



	





©A



?

$œB



|’B

L’B



‹­


&

<áB

„áB
4éB

ÙÁ

%
DéB
4üB
	¼À<„C
	¼À
ü²BZ
¬ËB


á]

—R<²B

p<óB

X
I
	üËBA

C
ü²Bs
,žC


Ð[
À­

À­


q

<žC

1


ªD




„žD
\žD


§ñ

7

óD

dóD
4÷D

 Á

%

D÷D

üÀDI
üÀD,



«
‘]
ÄD
$íD

M<�E

7
 F

d F
4¤F

 Á

%
D¤F

¤™F
4™F


¢˜

<

ÆF


?

áF


çF




èF

=


;


ü�>Û


W
g


w



™BüÚ?ˆ

ü„BÞ



Ñ[|­?
˳,Ó>
Ò�<â>
ÞÁ<ˆ?
ÄDœ?
Ñ[Þ?

w
…Ìö
ëž
…ÌÏ
À­
Ø
ÞÁôÀ­
<ˆB

­p€
¥
Ö¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â

À­

À­
TÏÉ]
À­
´
¨ÉÍ
„À
¢
„À
—À­
Ù
ÄD�m�
…Ì¿
ëžØ�m9
…Ìh
�
X




�‘]


¥b

æ	g


Àâ
m

new_rawÁ?


§¾· Á€ÙÁN‹­
ÏÙÁ£áÃ\²Ä§ñ¹ Á�íÅn Á*¢˜
Ñ[Õ
ÞÁÊ
Ñ[â
ÞÁ×
ÄDÝ
ÄDã

\�;




òE
ÄD©
Ä�;Tœ;

¥
˜Í
ÄD

;

dœ;
®;
à
üâ:L
ÄD„;õ],ô:
˜Í|

leaseÁ


:


µÍ‚

ü¨@Ĩ@


¦
˜Í
ÄD

,Á@

*
ü�@E	Ù
ÄD
òE


Ø@
á
üß?y
õ]$þ?ÄD,ñ?
˜Í~


Ó)


5


ÆÎœ

TÛA

˜Í
œÛA4æA

¢
˜Í
ÄD

4

DæA
ôA
æ
ü»A9
­pÎAªn,ÄA
˜Íx




7


�Ð

¼ÚB„ÚB


á
ÄD
òE

,ëB

(
÷B
ê
ü¶BA
õ]$ËBÄD,¾B


Ó)


-


ŽÑu

díCTíC



´

ÄD



ÄâCTâC


ë
õ]
ÄD


B
&
€D
î
üÃC=
õ]$ÓC
ÄDw

�Òˆ´Òj

dˆE,�E

ë!

õ]

$ˆE

<�E
܈E•E

Àc

ÄDFL™E
t•E
©E
ò
üÈDa
ÂlLôDªn,ÏDÑmLÖD­p–


	formatterÁ(
R

ªÓÉÖÓ£

dµF,ºF
ªÓ

$µF

<ºF
ܵFÂF

Åc

ÄDALÆF
tÂF
ÖF
ö
üõEa
ÂlL¡Fªn,üEÑmLƒF­p‘



ÆÓ 
J

ªÓ¼­Õ›
	
“I

T“I4•I

{
×J

É 

/

D•I
«I

T«I
4­I

{
“
ëÖ

0
D­IÃIëÖÆIÏ×
l»I<»I

û

ëÖ
A
3
)
ÉI


ÊI
+


;



ü­H�


÷ü‹I?
ü£I'

	
$ÒH×JÃH¦×ÉHëÖ
�I
”fs
©Ù§I

¦×K

Ï×

Ï×
¬R


­U
¬V
­O¶

ãÖÍ
¡×–
ö×H

¦× 

×J&

¦×-

×J3

Â_



&


dÇ_TÇ_



´

òE


ü®_&

Ϩ_


™
ÄD
òE
‰
[
A
Ó_


Ú_
üŒ_N

+


;



„
1
¬E$Ÿ_ÄD”_
ÄD	

òEÞ
|

¹!


p

˜Û
ÐÛæ
ÄD¦

DÆ`


Ô�
”Æ`<Ï`

Ö]

—R

1

LÏ`œÅ`
l a


òE¿a
…ÌLÄa


Ô�
ü a.
„®a

«
òE
ÄD
X
J>
ü®a 
¡b

…Ì
\šb
4šb

¢˜


)	

¶b
ˆüž`˜ü»`û


�m°`¬E
L¦`À­
¿`
À­

*

Ô�
M
�mÎ
òE

…Ì
Ò�
�m¨
…ÌÃ
`


µc
š

ÇÝ’
¸Þ)
¢˜æ

dóc

ºk
üÐc0\çc

…d
LÐc
7

Ìçc
/

\•d$šd
µj

$•d	
4šdd”d	
ìk
üÐcQ,Žd

ð`
ž
A
œŽd
üÐcg4¯d

÷`
N
D¯d
¼d	
½d
	


ü�c­


Œ


ÂlL¼cùj,—cÑmLžc
ã`
ã`
DebugTupleÁ
æ`×
µ`
ç`�
µ`
è`Ë
µ`
é`
empty_nameÁ
µ`
ø/wŒ4@<)
,

»ã·

½ãÀ

ºkÞ

ìkn
ªnv
õ]¢
¸



ÆÓ½
ö

‰áµjÔ
ªnìk¸
‹âŸ
½ât

õ]M

õ]S


\Ûe$àe
µj

$Ûe

4àe
$
ÔÛeçe

Åc

õ]
LLëe
tçe
úe
ûe



ü›e`

�

ÂlLÇeùj,¢eÑmL©e
ªnÆõ]Í"



ÆÓ'
_

µj÷üåË
õ]ž
õ]£

dÿfTÿf


�Ò



¼õfLõf


˜
ÄD
òE


=
&
’g
”
üÖf<
¬E$æf
ÄDr

�Òƒþçj

|¶hT¶h


ë
¬E
ÄD

Áh

(
Ëh
˜
üïg\
¬E$…hÄDúg

¹


-


õèu

„Ëk\Ëk

§ñ

×k

!
œýk
týk



Ò]

—R
Œl
&DÅl

üåks
	û
ÄD
òE

?
• 
• 

– 
“}
Fu
\»Ÿ

ÄD

Þl
Ýl


ü�iÁ

™üÁk�


¬E$ÊiÄD²iòEDºiÀ­
Åk
Ô�ò
òEϹ.



Ÿ"2
µ5
€

§ñV
žê6

òE©
¶m



D½m



Ô�
”½m<Æm
ÇÝ

+

LÆmœ¼m
l‚n



òE¡n
…ÌL¦n



Ô�
ü‚n.
„�n
¸Þ
N
A5
ü�n $Èn







Œ¼n
\¼n

¼

¬E


;	
#
ìn
…Ì
„àn
\àn

ÆÐ

)

øn
ü‡mñ


÷n







š4ü²mÆ



ÄD¦m
¬ED™mÀ­
¼

Ü߉

èߨ
�m0

ûßq

…Ìh
Ò�`
�m

¬E+

…Ìì
¤
g


µ&
Ï

ÇÝý
¸Þš
ÛîP
ÆÐ

¬Eè

\úq$ÿq
µj

$úq

4ÿq
ôèqŒèq


à
ÄD
òE

D
&
Œr
›
üÁqK
ÄDÜqùj,Òq
õ]‚




3

µjžìñ~
l§ƒ


òELºƒ


Ô�
짃
$µƒ


ª
òE
ÄD
J;

|µƒ

ÔЃ

	Ù
ÄD
òE

ðƒ

œüâ‚
Ž
üŽƒ
b

õ]\ø‚
ùj,î‚
˜ÍL’ƒ

ûßÈÒ�¼
'


	protectedÁ2
i


¡óÖ

t²…
$·…


ž
ÄD
òE
$²…
¼…


L·…

¤­…
$­…


Ý

ÄD

W
$
È…

�
ü‡…
A
�m¢…
ùj,”…
ÄD›…
�mh
ÄDª$


¹'
T

„õÔ¿õŸ

„´†
\´†


§ñ
ˠ


#Dœˆ



Ô�„¯ˆ

	¼À
üœˆ
$
$¥ˆ


Þ]

—R
Iªˆ

A
Ü¥ˆ
l߈


òEþˆ
	…ÌLƒ‰



Ô�
ü߈
.„íˆ

¸Þ
U
	F
9
üíˆ
 
§‰
…Ì
„›‰
\›‰



ÆÐ

,
 
»‰

žü€†
»üª†
‘
ü’ˆ
©



ÄDž†
ùj,Œ†
ÄD“†
À­
®†
À­
–ˆ


Ò�z

„À
n
�mé
ûß.

…Ì#
Ò�

…ÌÚh


æ	k
æ	m

Àâ
nÆ

§ñ¿÷Ê
¸Þ[
ÆÐ

lʑ


òELé‘


Ô�
üÊ‘
7„Ø‘


®
òE
ÄD
ÞÁ
O@<ô‘
ý‘


üØ‘
)
Ô�’

	Ù
ÄD
òE

­’

Ÿü¦�
‡ü±‘
|

õ]\ß�
ùj,Á�
ÞÁ<È�
ÄDÔ�
˜ÍLµ‘

ûßóÒ�ç<



¥?
æ	B

ÊóE
‘


Îû

<³²



\½²
$²

µj

$½²

4²
ï²

$ñ²

	


ªÓ
	"
+
<ï²

	



V

•"
ÜT

­p
l
2
;
tï²

$÷²


è
£
ÄD

c
4÷²
ü²



®³

$­³

ªÓ

%
³³




ü–³
!„›³


Ÿ
ÄD
òE
­p
$–³
,¬³


U

䛳
¶³


ܳ

$Û³

ªÓ

%

$ã³


,â³

ªÓ

%

¬Ó³
4Ó³


÷
—R
­p
­p,Ú³
4á³

	6
<ù³



$¬´




¼š´
Œš´


ìñ

:
!ú´




€µ
$Þ´




Ø´


x€
Š
’

üÒ²
©


N

á´


š
�µ

´


Ä


ü®±
Ó












,




=





ä

¡aü¯²
Ò
üå²
–

ü‹³
ð

üų
¶


ÄDÓ±
ùj,¿±

ÜT,Ʊ

õ]rÄDé²


Åÿô
»Ì
<
“ÿ­p=ªnEõ]$�³
­p�
ªn¨
ÄD~<ɳ
­p
ªn­pâ
ªnû
õ]‚
õ]	
J
Q¼


±¿
curÁ7
æ	ÉprevÁ£
swappedÁ”°


µjMªÓŠÿó¿ÿ¹ªÓhÛ€,ªÓʪӟ˜‚ƒìñ
õ]Ó
õ]¦
ÜTß
õ]å
ÜTë
õ]
ÄD 

ŒÚÄ
DÚÄ



a
ùj
š
—
öK
$ãÄ
éÄ


>
ñÄ

¤
üÓÃ
ž

ß
ß
­2
ã
ã

ä
˜1

åý


º±‘äyG‚
ùj
ã‰
鉄÷Ã
ùj,çÃ
é‰îÃ



±
“


Û‰ò

lÔÈ
DÔÈ




“8

ÄD

ÝÈ


(
ÌÉÈ
TÉÈ



ë
õG
ñF

N
(
èÈ

­
üùÇ
o
õG$˜È
ÄD�È

ñF�

¹


7

Ú‹®ˆŒ†

TšÔ
$žÔ


è
§
‰Z

šÔ


4žÔ

ÄšÔ
¥Ô


·T
ÄD
ñF
Ú‹
YD©Ô



Ú‹
l¥Ô

ü�Ô
#L�Ô



˜
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

ñF
òE

©
n
¹Ô

³
ü¬Ó
�

û
û
»+
þµ

ÿ
å+

€
Ÿ"

¾µÆî¸U1r
›Ž
òE$ßÓ
 �ÔÓ

›Ž5

‰Zs


¹


Š

š�’
�c
•Ž'


$„Ö

	Û¼

ñF
|úÕ
LúÕ


•Ž


2

 
�Ö

µ
ü·Õ
X
•�$ÉÕ

›Žl"


•Žc

|çÜ
lçÜ


²

ÄD


üØÜ
tØÜ



Ò]

ÄD

C

&
üÀÜ
Ç
	û
›Ž
õP



?
• 
• 

– 
“}
Fu
\»Ÿ

›Ž?
õP
�Þ

¸
ü“Ü
ú

û
û
»+
þµ

ÿ
å+

€
Ÿ"

¾µÆî¸U1r
›Ž
õP$±Ü

¤]
¤]V

¦]Á
‚]

üß3ø¤”&

§R%

§RR
ž

Бd
÷‘F

Q

}
„


Œ
Š

Б

¢

‚


Š
‡


÷‘

Ã


§
öÜ
\“Ý
		• 

›Žü¶Ý
FlàÝ
		ù$	ÿ

¢Q

ûÝ
í
	û
›Ž
õP





†Þ
	

Ë

¸
É

‰“

Ú“v
§R£
¶’Ò
õP»
¢Q¸



ü¶*1	½
ÄD
òE



¾
,
‚F7õ]>
E




ô§0	>

ÄD



?
&
¡J1áu8
?




ܸD	M

•



N
)
M
M
N
Æ

Pˆ
=ÄQу‘ß

¾˜`¾˜h
o




Ü´U	ô

ÄD



õ
(
ãM3ÄD:
A




´‹Z	’

ÄD



“
(
�O3ÄD:
A




¼ì
	Ñ



Ò
%
¤U0øÎ
8
?



|‚9		Û



Ü
%
£V0„Õ
8
?



ô—	‚




ƒ
'
úÞ3Ê�;
B



´ˆ	ç



è
%
³Y0„Õ
8
?

r•
»
¼
¼ÁàºÙ÷û¨®¹À




Y4ê0 

»p,‚1¿c

½pÂc

½t<‰1Äc

¾ˆ
L’1
 c

¿	FmtResultÁL§1éb

À
“}\Å1
• 

Á
“}
– 

ÁíÜ1ë

Âr,ð1é!

õ�2“

Ä	AtomicPtrÁLŸ2¯]

Æ®
Dª2¼À

ÇKÊ2
†J
È‹
œ4ä2

Ê
­2ì2
ß

Ë
ø,‰3y
Ì
ñ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,Á
üˆSP 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Á
ü÷	EB   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Á
üàGD 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) {} }Á
üÉJG 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Á
üñUR characteristics than the [RwLock], both in contended and non-contended scenarios.Á
Çú
\Ë
„°
ä× # use arc_swap::ArcSwap;Á
üô 
Æ°
ü•]
ð°
üóFC 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Á
üîFC 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Á
ü¡YV 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Á
Ðú
üÔEB The data structure is a bit niche. Before using, please check theÁ
üš MJ [limitations and common pitfalls][docs::limitations] and the [performanceÁ
üè KH 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Á
ü­VS   hold the returned guard object for too long, but long enough to get consistency.Á
ü„YV * 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};Á
±ú
üµSP 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);Á
üä96             thread::sleep(Duration::from_millis(50));Á
lž
         }Á
T¬     })Á
,·
š´
½ú
üÁ'$ // Passing the whole thing directlyÁ
üéRO // (If we kept another Arc to it, we could change the value behind the scenes)Á
ü¼IF 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 }));Á
ü£UR let thread = work_with_usize(Map::new(Arc::clone(&cfg), |cfg: &Cfg| &cfg.value));Á
üù+( cfg.store(Arc::new(Cfg { value: 42 }));Á
Ü¥ thread.join().unwrap();Á
Áú
üÅPM // Passing a constant that can't change. Useful mostly for testing purposes.Á
ü–2/ work_with_usize(Constant(42)).join().unwrap();Á
<É
Ý´4æ,>?FMNß½¾Æôõ’“
“}\ã
• 


“}
– 

r,ÿé!

Kœ
†J
‹
ït¡
�
‰Æ
¦
òH
	Š
» 4ÀÇ



ä'DÝ°


»+Tó
û



°,ÿ
Ù

ÌÕÉ„ôªt‹ž ‹�xz´°iÌÌ\,ëOQ@BœòüˆC@ Abstracts over ways code can get access to a value of type `T`.ÁÌúüÐZW This is the trait that parts of code will use when accessing a subpart of the big dataÁü«FC 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
ÄDL–$é!

¾DŒ­$Íì


ÄD�$¾D
ac^`TÖ$,Û$

öeìñ$$ô$




�
�¾D
¾D
ÄD


ù$


ÄD
×J
¾D
$ú$ü¶%+8Ž¥

Ž

úü»%ÐD
Tè%,í%

™gì‡&$Š&



�
�ÐD
ÐD
ØD


�&

8
ØD
$�&üÄ&28�¥

�

úüÉ&ëD 
 Tý&,‚'

™gìœ'$Ÿ'



‘
‘ëD
ëD
ØD


¤'

 8
ØD
$¥'üÙ'98’¥"

’"

úüÞ'‰E#$
$T™(,ž(
!
!™gì¸($»(



“
“‰E
‰E
ØD

!
À(
!
$8
ØD
$Á(üõ(>¥&
¤'

'
&áƒú(Íì


òE…)Ç

ÄD4ý(°
òE
ÄD\ˆ)¬E()
)EGBDTº),¿)
%
%õ]ìÙ)$Ü)



”
”¬E
¬E
ÄD

%
á)
%
)
ÄD
òE
$â)ü÷*=¥+
¤,

,
+áƒü*¦Šÿ*°
òE
ñF„‚+ÀF-.ê!ë!
.0257\»+4À+
*
*ÄD¬Ð+,Ó+



•
•ÀF
•ÄD

*
Ù+
*
.
ÄD
òE
$Ú+ü�,@¥0
¤1

1
0áƒ•,¦Š˜,±Œ„›,õG23
3$&)+T×,,Ü,
/
/ÀFì€-$ƒ-



–
–õG
õG
ÄD

/
ˆ-
/
3
ÄD
òE
$‰-üÊ-;¥5
¤6

56
áƒÏ-¦ŠÒ-°
òE
ùH|Õ-ÈH78ê!ë!
80257\Œ.4‘.
4
4ÄD¬¡.,¤.



—
—ÈH
—ÄD

4
ª.
4
8
ÄD
òE
$«.üá.>¥:
¤;

:;
áƒæ.¦Šé.‚�|ì.ÎI<=
=$&)+T¦/,«/
9
9ÈHìÎ/$Ñ/



˜
˜ÎI
ÎI
ÄD

9
Ö/
9
=
ÄD
òE
$×/·=
4ž0D²0

¥@

@
Îì


ÄD»0¡JÆ_å€×-



?A�
�
ž
ït
¡ˆ
ˆ
¢‰
ˆ
l}.xÏ
é!
ê!ÄD
ÀG¡J
v>¢

€”¡J

>

>
?

ÄD²´ÔÆ0

>

>€”üä0%
¥C

C
Õ“é0¡JDEê!ë!
E\�14•1
B

BÄD¬¥1,¨1


™
™¡J
™ÄD

B

®1
B
E

ÄD
$¯1´ü6üÖ130 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 dispatch), butÁüÐ3IF makes certain code simpler and possi
 4¦



ª
ªÀPȪ


ƒ

­

ƒ

…
8
ØD
$®
üç
#
¥‡


‡
áƒì
¶Š4ï
ÛQüŽ+
¥‰


‰
áƒ“¶Š4–ÛQŠ
{
Š
üÀ 4Ã


«
«ÛQÀ­


ˆ


Ê
ˆ

Š


Ä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ê!ç¶
Ì„
úüß
Íì


ŵ
â
é!

äLüþ 
õµÜ
·Ï4§
°
ŵ

ØD\¶
ÖR¢
£
¤
¥
¦
§






46jlfhüÀ#
üÉ!
 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

ž

ž
åÄ


’ÖZüÿ$$
üº$@
= 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

ž

á(

ž
¢Ã

$æ(
üÊ)"
”Í)


•




±
±ÖR
±ØD

ž

à)

ž
å¹

$á)
�*
T *


•





²
²ÖR
�m

ž

«*

ž
£¹

$°*
üˆ=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 the bigÁ|ê2
 structure).Áþ2
úl†3

 # 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
Ø`
±á`}z|üÀ>§

’«

¥¬


¤­

«
¬

­
	ìà̃?


ØDê!°Pä¬?
†áË>
—áüý> 
õµÅ>
é!

ØDü¦?#
úüÈ>
·Ï4Ì?
·á\Û?
ÖR®
�

®
:</1egüî? 
$ñ?





´
´ÖR

´ªS

ª

ö?

ª

®

äL
ØD
ŵ

$û?
ü¶@w
’°

¥±


¤²

±

²
°
ìàÌï@
úü¾@
†áÁ@
—áüé@ 
õµ»@
·Ï4’A
·á\¡A
ÖR³
ë
³
"$HJMOä´A
$·A


äLÖR

¯

¯

³

äL
ØD
ŵ


’/bü¿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Ù0
3
"
%
lü
DŒ$�
¼
È
ÍÑÒa$á
á.
Ã

Ä

�Ø$ø
Äl
Ã

Å

×:$¯
ç
Ã

Ç

×:è
Ã

Ç
Ë
n
½À
Ã


Æ
Ë
ƒ


¾À
Ã


Æ
Ì
l
¿À
Ã


Æ
Ì
�


ÀÀ
Ã


Æ
Gj
ÁÀ
Ã


Æ
G~


ÂÀ
Ã


Æ
Fh
ÃÀ
Ã


Æ
F|


ÄÀ
Ã


Æ
×
f
ÅÀ
Ã


Æ
×
{


ÆÀ
Ã


Æ
„Õ.
Α
ä‚\¨
Ô¶l¼
Ã
T�¤UÊ

üªID¸

¼

·
¸
·¤U

¸ïTÛ¼ݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ


·³Y

É

Á
É
á¯
$Â
µdn
®pnüå#

þÌ

Ì
ÝUÍ
Î
Ï
ÈLÉLÊL
Ï
êL�$”
Ë


Ë

þ³YlªD¯
Ë


Ë
Äl
Äl
�Ø
Çlµ
™l
Èl
¶Ø
™l
Él
öu
™l
ŒœjSž
þ
³YüÏ$LÒ
ÝU

ÝUÉL

Ë


Ë

Ï


þ
$Ü\–<š
¼
Ù
Ú
Û
Ü
Ý
×ÛÜa$ò4	
á.
Ð

Ñ
µ‚5	“
Ð

Ò

‹žLÅ5	¯]
Ð

Õ

Ć\Ð5	„Ä
Ð

Ö

×:$ê5	
ç
Ð

×

×:è
Ð

×

» 4û5	Ç
Ð
Ø
ÎË
½À
Ð


Ó
Ë
)

¾À
Ð


Ó


á.
í

î
µÕ
“
í

ï

�Ø$ë

Äl
í

ð

‹žL¯¯]
í

ó

Ć\º„Ä
í

ô

ït¦
�
í
õ
‰	FastLocalÁLÇ
Í
í

÷
	FastSlotsÁLÛ
Ñ
í

ø
HelpingLocalÁd…

×
í

ú
HelpingSlotsÁdœ

Ý

í

û

×:$¶

ç
í

ü

×:è
í

ü

» 4Ç
Ç
í
ý
ÎË
ù½À
í


ñ
Ë


¾À
í


ñ
Ì
÷¿À
í


ñ
Ì


ÀÀ
í


ñ
GõÁÀ
í


ñ
G	

ÂÀ
í


ñ
FóÃÀ
í


ñ
F

ÄÀ
í


ñ
×
ñÅÀ
í


ñ
×


ÆÀ
í


ñ
„¹
 LÏ
ŒÞ
äõ
”šø
û
è
ë
œ–Ü
\°,¾Å
,Ò®
të,ü˜
,“
~
\¯
p
lÀ
M
ÄÐ
\Ö

í
´î
Lô

í
ÔŠl�
í
üÑ!LØ
í
ñŽÃ
ãƒ|¢

þ„
„‚
‚
ƒ
ý

…ˆ
í

"=ð¡#Z•7

þ"=ð¡#Z•7



ƒ…
þ€Xç£
‡h„ƒ
í

º¤ç£

‚

‚
ƒ

þ²D¶
í

‚

‚º¤üÂ!
8Á
ÁÂW‡�"
‡”ê$í


Â
ÂÂW
�m

†

ò
†
‡
8
$÷´ø$Š
€X

¹ 5nâg&
‰Š‹Œ�|•$•
í

ˆ
ˆ¤U¬ª<ª
í

ˆ
ˆÝVœÅ4Å
í

ˆ
ˆ„Õ
Œ‚$‚
í

ˆ
ˆ•’Ü™t™
í

ˆ
ˆ„Õ
¬¹€X�´
�¤Õ<Ø
€X

Ž
Ž
�Lå€X‘”•–—š›






üÜVDê
êK„”

�£’
—“

’“

�¨šóê³ö“"
êK

€Xüù!
êK
ש˜"„”L‘
‘
Çè

êK
± NPSUÄ® t± 
í


Ã
ÀX�m

�
À 
�
”
$Á ÄÇ#tÊ#
í


Ä
Ä€X�m

�
Ù#
�
•
$Ú#üû*3t‚+

Å
Å€X‚
‚
ƒ
ý

…ˆ
í

"=ð¡#Z•7

Å

�
‘+
�ÐÖ
$’+Ìž-¡-
í

Ù©

�
�¡¡4‘.
—<closure_kind>Á˜
<closure_signature>Á˜

<upvars>Á˜

˜
—˜

ƒ‘Ü”

�m¢2
—
®¬™

Ǭ™


嬙

™
—™

�m�

�mü†;1T”;


Æ
Æ€XÄl
Äl
�Ø
Çlµ
™l
Èl
¶Ø
™l
Él
öu
™l
ŒœjSž
Æ
³Y

�
Ÿ;
��Ø
$ ;ü„<*d’<


Ç
Ç€X
dzY

�
Ÿ<
�·Ø
$ <ܤ=L¶=
æXzfñØsÊûo
�žŸ¯ü×>!$×>
í

œ
χ.
á.a

ã.»
Ì-
IÜž�B2®

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

Ù©|­?$­?
í

œ
œïT¬÷?<÷?
í

œ
œîUt‘@æX¡¦§¨«




üÝ@<
»

ºü°@%ü¯@'ü¦@2$ë@
êKÇè


 £¢
—£

£
¢
 ¨šð@ê³ó@

È–"
êK


ÈæX¼ö@

È
êK
§´˜"Çè
ŒA
¡
Çè

êK
±á�]_bd4êA
¡
®¬¤

Ǭ¤

嬤

¤
¡‘š÷F
¡
®¬¥

Ǭ¥

嬥

¥
¡Ò›üÃOBDÑO



É
ÉæXÛ¼ݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

³Y

 
ÚO
 Ȉ
$ÛO
µÛ—ü³R5\ÁR


Ê
ÊæX

 
ÍR
 Ý“
$ÎR
µÔRüØXŒ
|æX


Ë
ËæXÖ¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â

š·
š·

 
ÿX
 Ý”
$€Y
5ŽY
µ¢Y$å[
¨
®¬©

Ǭ©


嬩

©
¨©


�m²Ó



²Ó
4…\
¨
®¬ª

Ǭª


嬪

ª
¨ª


½•

ºüø]„
$†^
¼


Ì
Í
Î
ÌæX

Í€X
ÎÇè
�m

 £¬
¥­

¬­

‘^
 ¨š‹^úüŽ^·Ï4ß^ÉšLò^Üšú^
«
Çè

ØD
$’^

¨‡wœ

¹‡€œ

Ó‡ŠœOQTV¼à`æX¯�"
¯”þ`$�a

Ï
ÏæX
�m

®
†a
®
¯
$‹aL¹³Y±
ä�$¡

°
°¬¸³Y³´
³¤Ô<×
³Y

²
²
³LŸ³Yµ·

ü–@¤




Ð
гY…Ì

´
¥¶

¶
³
´áƒ¨¶Š4«êÜ
$´
µŠ¥ü¼ˆ
<Ê

…ÌÁÍ�m

´¥¸
£¹

¸¹

´áƒÒÍì


ÁÍÕ¶Š4§�"
ÁÍ
�mLº
ÁÍ
�m˜"ÄDÂ
·
ÄD
ÁÍ
µ§

¹‡§

Ó‡§hj
 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Á
üÄ	HE 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Á
ü‘30 [`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.Á
¬&ú

ú
üÉ


Žå
Üé

 [`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Á
ü€
JG 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Á
üÖRO 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Á
üûXU 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).Á
¯ú
ü³63 Therefore, what we have is `Arc<ArcSwap<Config>>`.Á
êú
\î
„°
Ìú # use std::sync::Arc;Á
ü”	41 # use std::sync::atomic::{AtomicBool, Ordering};Á
´É	 # use std::thread;Á
ôà	 # use std::time::Duration;Á
,ÿ	 #Á
ä…

ܶ
Ӣ
 # struct Work;Á
üµ
PM # impl Work { fn fetch() -> Self { Work } fn perform(&self, _: &Config) {} }Á
,†
ñ¬
ìŒ #[derive(Debug, Default)]Á
œª struct Config {Á
ü¾      // ... Stuff in here ...Á
,ß
š´
åú
üéKH // We wrap the ArcSwap into an Arc, so we can share it between threads.Á
üµDA let config = Arc::new(ArcSwap::from_pointee(Config::default()));Á
úú
üþ52 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 || {Á
ü‡63         while !terminate.load(Ordering::Relaxed) {Á
ü¾63             thread::sleep(Duration::from_secs(6));Á
üõ30             // 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);Á
ü·30         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Á
¯ú
ü³ZW 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Á
üË&
 ## SpeedsÁ
Èú
üÌZW The base line speed of read operations is similar to using an *uncontended* [`Mutex`].Á
ü§ZW However, [`load`] suffers no contention from any other read operations and only slightÁ
ü‚VS ones during updates. The [`load_full`] operation is additionally contended only onÁ
üÙYV the reference count of the [`Arc`] inside ‒ so, in general, while [`Mutex`] rapidlyÁ
ü³	RO 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Á
üëUR 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Á
üì
YV [`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Á
üòXU the speed than the wait-free guarantees, you're advised to do your own measurements.Á
Ëú
üÏIF 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Á
ãú
üçVS There are several load operations available. While the general go-to one should beÁ
ü¾MJ [`load`], there may be situations in which the others are a better match.Á
Μ
ü�ZW 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Á
üÈYV situations when this borrow isn't possible. If the content gets changed, all existingÁ
ü¢VS [`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Á
üÛ30 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Á
üÜVS [`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Á
üÓ LI 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Á
üƒ%HE [benchmarks]: https://github.com/vorner/arc-swap/tree/master/benchesÁ
üÌ%RO [lock-free]: https://en.wikipedia.org/wiki/Non-blocking_algorithm#Lock-freedomÁ
üŸ&RO [wait-free]: https://en.wikipedia.org/wiki/Non-blocking_algorithm#Wait-freedomÁ\¥\¹-<½-
Çí
ë
Á
µI“
Á
ÃKd
†J
ÁÅ‹Æ
i
òH
ÁÆŠ
äY:
„¾
Á
ìLlLC]tSOQ;=ô¤üo85 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.Áªúü®SP 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).ÁšúüžXU 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).Á„úüˆ41 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.Á$û
Ç


Çü‡)ü†YV 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Š
Æã¤ä

Ç


Çîã

Ðã“üÒ(ü¶<9 Provides a view into the smart pointer as a raw pointer.Á÷úüÿNK 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.ÁãúüëXU 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Áü�XU (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.Á»úüÃDA 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£
¨¬´úü¼:
·Á…
ôå�m
Ç


Ç
Í

Æã
µz²üÏ 
¥Ï

Ï
áƒÛñFÐÑÒÓÈÉÊËÒÑÓ/1Lö$û
Î

ÎÄDü‰!DŒ
ñF§R

Î

Î
Ñ

ÄD

Ðã³üÛ 4Þ


Ó
ÓñF§R

Î

é
Î
Ò

ÄD

Ðã`´üÈ)+DÒ)
¾RñF
Î

Î
Ó

ÄD
µ7µüš*
¥Õ

Õ
áƒ¦*ùHÖ×ØÙÈÉÊËÙØ×/1LÀ*$Å*
Ô

ÔÄDüÓ* DÖ*
ùH§R

Ô

Ô
×

ÄD

ÐãƵü£+4¦+


Ô
ÔùH§R

Ô

±+
Ô
Ø

ÄD

Ðã·ü�5*D—5
¾RùH
Ô

Ô
Ù

ÄD
µß·üÝ5+
¥Û

Ûáƒé5¶Š4ì5‰ZÜÝÞßÈÉÊËÞÝß79L�6$”6
Ú

Ú—Rü¨6*D«6
‰ZÀ­


Ú

Ú
Ý

ÄD

Ð㽸ü™7)4œ7


Õ
Õ‰ZÀ­


Ú

§7
Ú
Þ

ÄD

Ðã
ºü�84Dš8
…̉Z
Ú

Ú
ß

ÄD
µl»„ë-
ü30 Strategies for protecting the reference counts.Á
4ú
ü8a^ There are multiple algorithms how to protect the reference counts while they're being updatedÁ
üš
c` by multiple threads, each with its own set of pros and cons. The [`DefaultStrategy`] is used byÁ
üþ
c` default and should generally be the least surprising option. It is possible to pick a differentÁ
lâ
 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:Á
Éú
üÍ74 * [`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`].Á
ó
ú
ü÷
63 *This is not meant to be used in production code*.Á
®ú
ü²
Žå
üÒ%
È×Dó-䞟 °µY4‹ 
à
á
‹žL«¯]
à
â
» 4ËÇ
à
ã
Ü;l�
ù
à
œ
Ü;
ú
à
œ
�<tž
ÿ
à
�¤ý€ì—p´»a¬Ô4ã
õ‰ùúÿY4«
 
ä
åí$Ã
ë
ä
ç
ë…dÉ

ÃÛ

ä
èr,ç
é!
ä
éµø
“
ä
ê
‹žL•
¯]
ä
ë
Á'Ú
¬
ä
î
Œ'lß
§
ä
ï
¤%Lî
£
ä
ð
×:$Œ

ç
ä
ò
×:è
ä
ò
¬L’

œ
äóÀ

» 4²
Ç
ä
ôË
h®½À
ä

ìË
}®

¾À
ä

ìÌ
f®¿À
ä

ìÌ
{®

ÀÀ
ä

ìGd®ÁÀ
ä

ìGx®

ÂÀ
ä

ìFb®ÃÀ
ä

ìFv®

ÄÀ
ä

ì×
`®ÅÀ
ä

ì×
u®

ÆÀ
ä

�
ð
L·
â
½
Ó
Ö
„Ü
È
Lò
º
ì�
«
ä¤
lÊ
¡
¤
’
•
ƒ
†
\þ
x
{
T
W
´¢
E
ü»&
„Æ

¥ö

öáƒ×
¶Š4Ú
Ñ[r·�óphK˜



÷ø�*,Üè
$è

ä
õ

õÕ¶¤‰	
‰	

ä
õ

õ߆ü¢	#

¥ú

úáƒ§	
¶Š4ª	
Ñ[ûüýþ



üÌ	R
á	

à
…ÌÕ¶Ñ[
ù

ù¹Œ
µÏÂ

…ÙÂüÈJ
<Ë


ä

Ö
×
ÖæX

×Ô� Š

ù

Ù

ùñ´

½LÇ

�‘†ÇüÕC
DØ

ä

Ø
Ù
ØæX

ÙÔ�Ñ[

ù

ç

ù�¹

½oÌ

�‘yÌüß""
4â"


ä


Ú
ÚÑ[…Ì

ù

é"

ù Á
$ê"
ü±#,

¥€

€áƒ¶#
¶Š4¹#
Ñ[��"
�”ò#
$õ#




Û
ÛÑ[
�m

ÿ

ú#

ÿ
�

ÄD
$ÿ#
ü‡*4

¥ƒ

ƒáƒŒ*
¶Š4�*
Ñ[„…¦¥…„%'ìÐ*
TÓ*


ÄDÑ[

‚

‚
„

ÄD
µ%Òäã+
Tæ+


Ñ[ÄD

‚

‚
…

ÄD
$õ+
üò11

¥‡

‡áƒ÷1
¶Š4ú1
Ñ[ˆ¢
ˆ´¸2
4»2




Ü
ÜÑ[
ÜÄD

†

Â2

†
ˆ

ÄD
$Ã2
„ì2
4ö2

‰

‰

çüüì2e
‰

çüçüŠŠ¤º3
DÀ3

‰


‰ìˆ4
¢QŒŠ¤¬4
D²4

‹
‹ü§5[
¥Ž

™%�

Ž�
áƒ¬5
Íì


¾]¯5
¶Š4ê5
‰

¾]4û5
‘]�‘”©ª«”‘KMHJt‰6
LŽ6

�
�Ñ[ü³6F
$½6



Ý
Þ
Ý‘]

ÞÔ�
‘]
ÄD©
�
Â6

�
‘
ÄD
¾]
$Ã6


�‘[Ù4”7

‘
®¬’

Ǭ’

嬒

’
‘þ²Ù8

‘
®¬“

Ǭ“

嬓

“
‘«¶üœ9T
„¦9


ß
à
ß‘]…Ì

àÔ��m
�
·9

�
”
ÄD
¾]
Oß

Àâ
ÈÝ

�‘ÒÝÏ<

”
®¬•

Ǭ•

嬕

•
”Õ»üË=;
¥—

™%˜

˜
—áƒÐ=
ŽòÛ=
¶Š4Ó=
¦ò4à=
‘]™®
™*,/1ü�>¯

„—>



á
â
á‘]

âÔ�ÞÁÄDËó
–
”š

š
Ó>

–Íì


ÞÁ¨>
y
ÞÁ
—Rì«>

™
ÄD
¾]
ÞÁ
$Ô>


�‘Ûã

¬•åã
æ	îãCEd€ª­†‰Ĩ%Ì° The default strategy.ÁÊúüÎB? It is used by the type aliases [`ArcSwap`][crate::ArcSwap] andÁü‘b_ [`ArcSwapOption`][crate::ArcSwapOption]. Only the other strategies need to be used explicitly.Áôúüø! # Performance characteristicsÁšúüža^ * It is optimized for read-heavy situations, with possibly many concurrent read accesses fromÁü€@=   multiple threads. Readers don't contend each other at all.ÁüÁc` * Readers are wait-free (with the exception of at most once in `usize::MAX / 4` accesses, whichÁÌ¥   is only lock-free).Áä¿ * Writers are lock-free.ÁüÜa^ * Reclamation is exact ‒ the resource is released as soon as possible (works like RAII, notÁü¾LI   like a traditional garbage collector; can contain non-`'static` data).Á‹úü�\Y Each thread has a limited number of fast slots (currently 8, but the exact number is notÁüì_\ guaranteed). If it holds at most that many [`Guard`]s at once, acquiring them is fast. OnceÁüÌa^ these slots are used up (by holding to these many [`Guard`]s), acquiring more of them will beÁü®)& slightly slower, but still wait-free.ÁØúüÜa^ If you expect to hold a lot of "handles" to the data around, or hold onto it for a long time,Áü¾RO you may want to prefer the [`load_full`][crate::ArcSwapAny::load_full] method.Á‘úü•c` The speed of the fast slots is in the ballpark of locking an *uncontented* mutex. The advantageÁüùc` over the mutex is the stability of speed in the face of contention from other threads ‒ whileÁüÝb_ the performance of mutex goes rapidly down, the slowdown of running out of held slots or heavyÁüÀC@ concurrent writer thread in the area of single-digit multiples.Á„ úüˆ b_ The ballpark benchmark figures (my older computer) are around these, but you're welcome to runÁüë ;8 the benchmarks in the git repository or write your own.Á§!úü«!A> * Load (both uncontented and contented by other loads): ~30nsÁüí!b_ * `load_full`: ~50ns uncontented, goes up a bit with other `load_full` in other threads on theÁüÐ"#    same `Arc` value (~80-100ns).Áüô"UR * Loads after running out of the slots ‒ about 10-20ns slower than `load_full`.ÁüÊ#MJ * Stores: Dependent on number of threads, but generally low microseconds.Áü˜$IF * Loads with heavy concurrent writer (to the same `ArcSwap`): ~250ns.Áâ$úüæ$%
È×ÜŒ%
àš|±%õPäÃ,üã%%" Strategy for isolating instances.Á‰&úü�&b_ It is similar to [`DefaultStrategy`], however the spin lock is not sharded (therefore multipleÁüð&c` concurrent threads might get bigger hit when multiple threads have to fall back). Nevertheless,ÁüÔ'_\ each instance has a private spin lock, not influencing the other instances. That also makesÁÔ´( them bigger in memory.ÁÏ(úüÓ(?< The hazard pointers are still shared between all instances.Á“)úü—)ZW The purpose of this strategy is meant for cases where a single instance is going to beÁüò)C@ "tortured" a lot, so it should not overflow to other instances.Á¶*úüº*_\ This too may be changed for something else (but with at least as good guarantees, primarilyÁüš+@= that other instances won't get influenced by the "torture").Á
4º,œÌ,õP¬¿-4Î-
£§¬
ø,€.y
 
¢Yë 
 
¡á
‹žî¯]
 
¡â
» ñÇ
 
¡ã
¾" ä
 

¡
¨&3ž
 

¡
¿&¨Ÿ
 

¡
Ú¦ 
 

¡
ä'DŒ8°
 

¡
Ü;W
ù
 
¡œ
Ü;o
ú
 
¡œ
�<_
ÿ
 
¡�,ß-¤ñ-
üŒ.!L–.£
¥¤

¤
£
çüüŒ.r 
Æã
ØDL¤.úü .£

çü4÷—	&çü@÷—	2¥¦¥¦¥¦?A̸.T».ÆãØD

£

£
¥
 # ExampleÁ�=ú\‰=
„°ü™=63 # use arc_swap::{ArcSwap, DefaultStrategy, Guard};ÁÌÔ=
Ë«üò=(% # let p = ArcSwap::from_pointee(42);ÁüŸ>41 // Create two guards pointing to the same objectÁ´Ø> let g1 = p.load();Áüó>GD let g2 = Guard::<_, DefaultStrategy>::from_inner(Arc::clone(&*g1));Á|¿? # drop(g2);Á<Ó?
Ý´Tæ?

ÄDõ]

Ý
ÝŽÑ

Ó)*çüÜ@5¥ã
¤ä

ä
ãáƒá@¦Šì@¶Š4ä@ÅŠ\ï@õ]åæê!ë!
æ1368\˜A4�A
â
âÄD¬»A,¾A




é
éõ]
éÄD

â
ÄA
â
æ
ÄD
òE
$ÅAüøA7¥è
¤é

èé
áƒýA¦ŠˆB¶Š4€BÅŠ\‹Bõ]êë
ê*,/1̶B$¹B

ÄDõ]

ç
ç
ê
ÄD
òE

Ó)Tèüû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
òl
 `
àB¤GS


ì
Âl

ï
ÏD
ï
ò
ÄD
òE
$ÐD

ÆÓ©éü­EA¥ô
¤õ

ôõ
áƒ²E¦ŠÇEÄc

ÄD<µE¶Š4¿EÅŠ\ÊEõ]öÅc
ö9;>@üõE5øE


í
î
ï
íõ]

î c
 cˆ

¢cµ

 `
£c
òl
 `
àB¤GS


ï
Âl

ó
üE
ó
ö
ÄD
òE
$ýE

ÆÓ€êü­HW4°H

×J¦×

É ø
’ù

“ú
øúù
Íì


ëÖ$·HΟ½HÍì


¦×ÀHy
×J
ëÖ\äHy
¦×
ëÖ\øH
÷
ëÖ
×J
¦×
“
­#ì`begacü¹[BüÌIZW 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úüÌKLI 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Áü¥MDA both `Arc` and `Option<Arc>` (and possibly other similar types).ÁêMúüîMHE 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ÁüÏRIF   provide implementations of the [`RefCnt`] trait and plug in others.Áü™SYV * `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Áü‡Y96 work properly. A proper solution is being looked intoÁüÁY74 ([#81](https://github.com/vorner/arc-swap/issues)).ÁùYúüýY?< [`Arc`]: https://doc.rust-lang.org/std/sync/struct.Arc.htmlÁü½ZYV [`from`]: https://doc.rust-lang.org/nightly/std/convert/trait.From.html#tymethod.fromÁü—[! [`RefCnt`]: trait.RefCnt.htmlÁTÄ[
¥ü
¤ý


üý
áƒÏ[¦ŠüÚ[ ¶Š4Ò[ÅŠ\Ý[¬E¾µÆî¸U1r

þÿ€ˆ=?BÚ[õP¼Ú\Ú\

û
ûÔ�äæ]dæ]

û
ûêê\¯^D¯^

û
ûòEü¿^F¥‚
¤ƒ

‚ƒ
áƒÄ^¦ŠÏ^¶Š4Ç^³

òE<Ò^ÅŠ\Ü^¬E„ë
„9;>@¼Œ_$�_
ÄD¬E

�
�
„
ÄD
òE
¹ÖíüÞ_9¥†
¤‡

‡
†áƒã_¦Šî_¶Š4æ_ÅŠ\ñ_¬Eˆ�"
ˆ*,/1”ž`$¡`



ð
ð¬E
�m

…
¦`
…
ˆ
ÄD
òE
$«`üºbO¥Š
¤‹

‹
Šáƒ¿b¦ŠÂbÅŠ\Åb”À	,úb¶Š4‚c¬EŒÀc
Œ2479ü�c5“c

ñ
ò
ó
ñ¬E

ò c
 cˆ

¢cµ

 `
£c
òl
 `
àB¤GS


ó
Âl

‰
—c
‰
Œ
ÄD
òE
$˜c

ÆÓ5ñüÁdS¥Ž
¤�

Ž�
áƒÆd¦ŠÉdÅŠ\ÌdÑÂ	<ƒe¶Š4�e¬E�Åc
�2479ü›e5že

ô
õ
ö
ô¬E

õ c
 cˆ

¢cµ

 `
£c
òl
 `
àB¤GS


ö
Âl

�
¢e
�
�
ÄD
òE
$£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þç
¹;ôü�i1üÑhGD Constructs a new storage while customizing the protection strategy.Ál¤i

ÄDòE¬E

•
•ÐÛ
¹dõ

Ÿ"mõü‡m ôäl Extracts the value inside.ÁTŽm
¬EÄD

•
•
š
ÄD
òE
$�mäÁq¤þn Loads the value.Á—oúüŸoQN This makes another copy of the held pointer and returns it, atomically (it isÁüõoPM safe even when other thread stores into the same instance at the same time).ÁÊpúüÒpJG The method is lock-free and wait-free, but usually more expensive thanÁÜ¡q
ÕÈ	LÈq


÷
÷¬EÄD

•
Òq
•
›
ÄD
òE
$Óqüâ‚
!ü’r52 Provides a temporary borrow of the object inside.ÁÌrúüÔrZW 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Áü–tXU 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ÁüêyZW 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>) {ÁüÄ|NK     // 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);Áü…~JG     // 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>) {ÁüÞMJ     // 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õ]

•
î‚

•µj
$ï‚
܇…
üöƒ
,) Replaces the value inside this instance.Á§„
úü¯„
SP Further loads will yield the new value. Uses [`swap`](#method.swap) internally.Á,Ž…



ù
ù¬EÄD�m

•
”…

•
�
ÄD
òE
$•…

¹�úü€†
üÎ…
-* Exchanges the value inside this instance.Á$‡†



ú
ú¬EÄDÄD

•
Π

•„õ
$�†

æ	[üü¦�
|üÁ‰
30 Swaps the stored Arc if it equals to `current`.Áù‰
ú
,ÓŸ

ñ¬üÝŸ
'
ó“
܉ 

ŽËÄ© 

ãÌüÆ 
:7         scope.spawn(|_| cnt.rcu(|inner| **inner + 1));ÁL…¡

óÏ„“¡

…Ðü¨¡
%" assert_eq!(10, *cnt.load_full());Á<Ò¡

Ý´Þ¡
úüæ¡
[X Due to the retries, you might want to perform all the expensive operations *before* theÁüÆ¢
^[ rcu. As an example, if there's a cache of some computations as a map, and the map is cheapÁü©£
LI to clone but the computations are not, you could do something like this:Áú£
ú\‚¤

„°ü’¤
$! # use std::collections::HashMap;Á,»¤

ñ¬äŤ

ܶüæ¤
 
Æ°,‹¥

ñ¬ü•¥
1. fn expensive_computation(x: usize) -> usize {ÁüË¥
MJ     x * 2 // Let's pretend multiplication is *really expensive expensive*Á,�¦

š´§¦
úü¯¦
'$ type Cache = HashMap<usize, usize>;ÁÛ¦
úüã¦
JG static CACHE: Lazy<ArcSwap<Cache>> = Lazy::new(|| ArcSwap::default());Á²§
úüº§
.+ fn cached_computation(x: usize) -> usize {Áüí§
!     let cache = CACHE.load();Áü“¨
-*     if let Some(result) = cache.get(&x) {ÁÜŨ
         return *result;ÁLå¨

óÏüó¨
+(     // Not in cache. Compute and store.Áü£©
HE     // The expensive computation goes outside, so it is not retried.Áüð©
.+     let result = expensive_computation(x);ÁÜ£ª
     CACHE.rcu(|cache| {Áüê
HE         // The cheaper clone of the cache can be retried if need be.Áü�«
30         let mut cache = HashMap::clone(&cache);ÁüÈ«
$!         cache.insert(x, result);ÁŒñ«
         cacheÁ\‡¬

ÏÌt—¬
     resultÁ,ª¬

š´´¬
úü¼¬
+( assert_eq!(42, cached_computation(21));Áüì¬
+
±¦
<œ­

Ý´¨­
úÌ°­
 # The cost of cloningÁέ
úüÖ­
\Y Depending on the size of cache above, the cloning might not be as cheap. You can howeverÁü·®
]Z use persistent data structures ‒ each modification creates a new data structure, but itÁü™¯
[X shares most of the data with the old one (which is usually accomplished by using `Arc`sÁüù¯
96 inside to share the unchanged values). Something likeÁü·°
[X [`rpds`](https://crates.io/crates/rpds) or [`im`](https://crates.io/crates/im) might doÁ”—±
 what you need.統




ý
ý¬EÜTÄD

•£¢
—£
¢£
¿±

•Íì


Åÿ¹±
¨þ¼±


ü“"
ÜT


üÄDtê±


ü
ÜT
í
˜"Åÿ÷±
æ
Åÿ
ÄD<…²
„Œ
4™²

¡
ÄD
òE
Åÿ
ÜT
$˱

±ʱ
Ž�’”üÓÃ
xü‡µ
GD Provides an access to an up to date projection of the carried data.ÁÓµ
ú„Ûµ

¤¤ðµ
úüøµ
^[ Sometimes, an application consists of components. Each component has its own configurationÁüÛ¶
MJ structure. The whole configuration contains all the smaller config parts.Á­·
úüµ·
UR For the sake of separation and abstraction, it is not desirable to pass the wholeÁü�¸
]Z configuration to each of the components. This allows the component to take only access toÁŒñ¸
 its own part.Á‡¹
úì�¹
 # Lifetimes & flexibilityÁ±¹
úü¹¹
^[ This method is not the most flexible way, as the returned type borrows into the `ArcSwap`.Áüœº
_\ To provide access into eg. `Arc<ArcSwap<T>>`, you can create the [`Map`] type directly. SeeÁÔ€»
 the [`access`] module.ÁŸ»
úŒ§»

ðä½»
úüÅ»
VS As the provided function is called on each load from the shared storage, it shouldÁü ¼
^[ generally be cheap. It is expected this will usually be just referencing of a field insideÁ”ƒ½
 the structure.Áš½
út¢½

“ɵ½
ú\½½

„°¼Í½

ÃÉé½
úÔñ½

ïÉü�¾
! use arc_swap::access::Access;Á¶¾
ú„¾¾

�ó¬Ó¾

¶ó,í¾

š´÷¾
úüÿ¾
52 fn print_many_times<V: Access<usize>>(value: V) {ÁĹ¿
     for _ in 0..25 {ÁüÖ¿
%"         let value = value.load();Áü€À
#          println!("{}", *value);ÁL¨À

óÏ,¶À

š´ÀÀ
úüÈÀ
96 let shared = ArcSwap::from_pointee(Cfg { value: 0 });Áü†Á
0- let mapped = shared.map(|c: &Cfg| &c.value);Áü»Á
(% crossbeam_utils::thread::scope(|s| {ÁüèÁ
/,     // Will print some zeroes and some twosÁüœÂ
.+     s.spawn(|_| print_many_times(mapped));ÁüÏÂ
>;     s.spawn(|_| shared.store(Arc::new(Cfg { value: 2 })));Áü’Ã
0- }).expect("Something panicked in a thread");Á<ÇÃ

Ý´ÚÃ






ÿ
ÿ¬Eé‰ß
ß
­2
ã
ã

ä
˜1

åý


º±‘äyG‚
ؾ

ã‰
é‰

•š¥
£¦
—§
¥¦§
çÃ

•Íì


ã‰ÞÃ
£³áÃ
Íì


é‰äÃ


þ�"
é‰


þã‰d�Ä


þ
é‰
¶À
˜"
þöK§Ä
Ø

é‰,¬Ä

¬E
ã‰LÁÄ

¤
ÄD
òE
ã‰
öK
é‰
$èÃ

±
¶¸º¼µ·œŠÆ
üõÄ
  An atomic storage for `Arc`.Á–Å
úüšÅ
C@ This is a type alias only. Most of its methods are described onÁüÞÅ
+( [`ArcSwapAny`](struct.ArcSwapAny.html).Á<“Æ

¥©

©
áƒ›Æ
û
û
»+
þµ

ÿ
å+

€
Ÿ"

¾µÆî¸U1r
ñF
õPMOüµÆ
2¥«
¤¬

«¬
áƒºÆ
¦Š½Æ
±Œ„ÀÆ
õG­
!#üùÇ
AüîÆ
A> A convenience constructor directly from the pointed-to value.Á´Ç
úü¼Ç
85 Direct equivalent for `ArcSwap::new(Arc::new(val))`.Ád€È

ÄDõG

ª
ª
ÃÝ	<²È

­
ÄD
òE
¹Ï
̹Î
üìÈ
(% An atomic storage for `Option<Arc>`.Á•É
úü™É
a^ This is very similar to [`ArcSwap`](type.ArcSwap.html), but allows storing NULL values, whichÁüûÉ
! is useful in some situations.Á�Ê
úü¡Ê
C@ This is a type alias only. Most of the methods are described onÁüåÊ
_\ [`ArcSwapAny`](struct.ArcSwapAny.html). Even though the examples there often use `ArcSwap`,ÁüÅË
DA they are applicable to `ArcSwapOption` with appropriate changes.ÁŠÌ
útŽÌ

“É�Ì
ú<¡Ì

Ý´¼©Ì

ÃÉüÁÌ
 
ÇÆâÌ
úüæÌ
+( let shared = ArcSwapOption::from(None);Áü’Í
*' assert!(shared.load_full().is_none());Áü½Í
74 assert!(shared.swap(Some(Arc::new(42))).is_none());ÁüõÍ
;8 assert_eq!(42, **shared.load_full().as_ref().unwrap());Á<±Î

Ý´lÂÎ

¥¯

¯
áƒÐÎ
‰“
üòÎ
B¥±
¤²

±²
áƒ÷Î
¦ŠúÎ
°
òE
›ŽÄýÎ
•�³µ

,.02ü¬Ó
Uü»Ï
?< A convenience constructor directly from a pointed-to value.ÁÿÏ
úü‡Ð
1. This just allocates the `Arc` under the hood.Á½Ð
útÅÐ

“ÉØÐ
ú\àÐ

„°üðÐ
 
ÇÆ•Ñ
úü�Ñ
HE let empty: ArcSwapOption<usize> = ArcSwapOption::from_pointee(None);ÁüêÑ
$! assert!(empty.load().is_none());Áü“Ò
JG let non_empty: ArcSwapOption<usize> = ArcSwapOption::from_pointee(42);ÁüâÒ
96 assert_eq!(42, **non_empty.load().as_ref().unwrap());Á< Ó

Ý´d³Ó

 �•�

°
§´

´
°Íì


 �ÀÓ
æ
 �
‰Z|ÃÓ
ÃÝ	<ùÓ

³
ÄD
òE
 �
¹j
9;ü·Õ
4ü¿Ô
1. A convenience constructor for an empty value.ÁõÔ
úüýÔ
52 This is equivalent to `ArcSwapOption::new(None)`.Á,¾Õ


•�

°
°
ÃÝ	<ãÕ

µ
ÄD
òEÄ“Ö

¥·

·
áƒ˜Ö
‰“¸
ü“Ü
"ü²Ö
%" A const-fn equivalent of [empty].ÁÜÖ
úüäÖ
_\ Just like [empty], this creates an `None`-holding `ArcSwapOption`. The [empty] is, however,ÁüÈ×
^[ more general ‒ this is available only for the default strategy, while [empty] is for anyÁü«Ø
=: [Default]-constructible strategy (current or future one).璯
úôõØ
 [empty]: ArcSwapAny::emptyÁ˜Ù
út Ù

“ɳÙ
ú\»Ù

„°ÌËÙ

Ë«üéÙ
" # use arc_swap::ArcSwapOption;Áü�Ú
LI static GLOBAL_DATA: ArcSwapOption<usize> = ArcSwapOption::const_empty();ÁáÚ
úüéÚ
*' assert!(GLOBAL_DATA.load().is_none());Áü˜Û
*' GLOBAL_DATA.store(Some(Arc::new(42)));ÁüÇÛ
;8 assert_eq!(42, **GLOBAL_DATA.load().as_ref().unwrap());Á<‡Ü

Ý´\ Ü


‰“

¶

¶
¸

ÄDôËá
ü‘Þ
SP An atomic storage that doesn't share the internal generation locks with others.ÁåÞ
úüéÞ
`] This makes it bigger and it also might suffer contention (on the HW level) if used from manyÁüÊß
QN threads at once. On the other hand, it can't block writes in other instances.Áœà
úü à
85 See the [`IndependentStrategy`] for further details.Á
4Âá
”Ôá

¥º

º
áƒçá
ÉÃ

tÝå
êå

ìå
ùô

òå
Žæ

	,óå
8Ð	$ôå

&øå
8¼,úå

$ÿå
,�æ
8
Ÿ"D‚æ

&Šæ
8´Œæ
*�æ

“æ
öô

+�æ

žæ
¨æ
8âŸæ

¢æ
§æ

8‚$£æ
8²æ
,¶æ
8Ð	$·æ

¼æ
ðô
à
8#Êæ
8¤,Îæ

'Óæ
8
Ó$4Õæ

'Ûæ
8ToOwnedÁ<Ýæ

%äæ
8#òæ
8¤,öæ

'ûæ
8stringÁ4ýæ

'č
8ß
4…ç

%‹ç
8#™ç
8¤,�ç

'¢ç
8Á¤ç

'§ç
8ö
©ç

%
8#ºç
8í$¾ç

'Âç
8ç$Äç

'Èç
8atomicÁ4Êç

'Ðç

Òç
äç


8$Óç

$×ç
8
Ć\Ùç
%åç
8#ôç
8adaptive_barrierÁ„øç

'ˆè

Šè
�è


8BarrierÁ<‹è

$’è
8	PanicModeÁL”è
%žè
8#
8crossbeam_utilsÁ|°è

'¿è
8Š4Áè

%Çè
8#Öè
8,Úè

'ßè


áè

%âè
8,ñè
8
ITERATIONSÁT÷è

&�é
8¬,ƒé
‰é
710Á‹é

%�é
+ώ

�é
¯é
8«,žé

£é
®é

8±T¤é
8!$ðé
8AsÁõé


֎
8¥øé

ùé
ûé
8
»+Týé


‡ê
8Kˆê


‹ê
8¥Œê

�ê

$Žê
,�ê
8
Ÿ"D‘ê

™ê

%šê
+¨ê

©ê
Ȑ
8«,ªê

¯ê
ºê

8±T°ê
8!$üê
8AsoÁ�ë


„ë
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·í
8publishÁ<ºí

Áí
Âí

Äí
ó÷

8,Öí
8READERSÁ<Üí

&ãí
8¬,åí
ëí
7Šíí

%îí
8
۔
8„î
8†î
7ˆ‰î

!Šî
8
Çæ
TΔ

—î
å÷

08­î
8configÁ4±î
¸î
8
Ùç
ºî

'¼î


¾î
8ß
4¿î

Åî

'Æî
8><Èî

Ïî
Ðî

%Ñî
8çî
8endedÁ,ëî
ñî
8
Ć\óî

'þî
8æ	€ï

ĕ
…ï


7ˆ„ï
%†ï
8Š4œï

'¢ï
8scopeÁ,¤ï

©ï
Äõ

ªï
8
Àð
,«ï

°ï

²ï
Ãõ

8
Ìï
8Ðï
8Òï
7ˆÕï

!Öï
8
­í
<Øï

àï
Þó

8
Àð
,þï

 ƒð
8spawnÁ,„ð

‰ð
Ãó


Šð
8‹ð

Œð
8$Žð

“ð
Âó

8µð
8â¹ð
½ð
8
Îî
4¿ð

 Åð
8
Å-LÆð

Ïð
Ðð

%Ñð
8óð
	öð
8â÷ð

 úð
8is_emptyÁDûð

Ė
„ñ

†ñ
êò

8ÔL¬ñ

	µñ

¶ñ
Ðñ



·ñ
8â¸ñ

$Ȗ
7New configurationÁœ½ñ
%Ññ
8
Îï
,֖

 üñ
8	fetch_addÁLýñ

†ò
›ò

7‰‡ò

$ˆò
8®
DŠò

'’ò
8Ë
<”ò
%Ϙ
84Âò

%Èò
8
…ä
4Η

'’ó
8spin_loop_hintÁt”ó

¢ó
£ó

%¤ó
%Äó
8
Àð
,øó

 ýó
8
óñ
,þó

ƒô
¬õ


„ô
8…ô

†ô

ˆô
«õ


8¦ô
8new_confÁDªô
³ô
8Kµô

'¸ô
8æ	ºô

½ô
Üô

7
¸ô
œ¾ô

 Ñô
8to_ownedÁDÒô

Úô
Ûô
%Ýô
8
Îî
4ûô

 �õ
8È,‚õ

‡õ
�õ


8
š÷
Dˆõ
%‘õ
%­õ
 Úõ
8¢4Ûõ

áõ
âõ

%ãõ
8ÔLùõ

	‚ö

ƒö
ªö

8
­í
<„ö

$‹ö
8
Îï
,�ö

 ’ö
8¬$“ö

—ö
©ö
8®
D˜ö

' ö
8Ë
<¢ö
%«ö
8Áö
8arcÁÅö
Éö
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ˆ�ù

!Žù
7100Á�ù

”ù
ʀ
@8ªù
8
¸ú
®ù
²ù
8K´ù

'·ù
8æ	¹ù

¼ù
¿ù


742Á½ù
%Àù
8Öù
8
’DÚù
ãù
8
Ùç
åù

'çù
8÷$éù

íù
þù

8Kîù

'ñù
8ƒ,óù

øù
ýù

ùù
8
¸ú
úù
%ÿù
8ÔL•ú

	žú

Ÿú
µú

7
óÿ
 ú

$¢ú

¤ú


¥ú
8
’D¦ú

 ®ú
8¬$¯ú

³ú
´ú
%¶ú
8ÔL�û

	Šû

‹û
¡û

7
óÿ
Ξ

$Žû

�û


‘û
8
’D’û

 šû
8¬$›û

Ÿû
 û
%¢û
8çû
8new_arcÁ<ëû
óû
8Kõû

'øû
8æ	úû

ýû
ÿû


7ˆþû
%۟
8ÔL–ü

	Ÿü

 ü
Éü

7
óÿ
¡ü

$£ü

¥ü
8
’D¦ü

 ®ü
8
æ-$¯ü

³ü
Èü
8K´ü

'·ü
8ƒ,¹ü

¾ü
Çü

¿ü
8
®ƒ<Àü
%Êü
8ÔLàü

	éü

êü
ÿü

7ˆëü

$ìü

îü


ïü
8
’Dðü

 øü
8¬$ùü

ýü
þü
%€ý
8âý
8loadedÁ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ä‚
ñ‚ò‚
ô‚�™
G8†ƒ8first_valueÁ\Šƒ–ƒ8K˜ƒ
'›ƒ8æ	�ƒ
 ƒ§ƒ


¡ƒ¦ƒ7ˆ¢ƒ
$£ƒ7ˆ¥ƒ%¨ƒ8ºƒ8sharedÁ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,ð…8SEQÁö…
&ù…8¬,û…�†750Áƒ†
%…†8—†8barrierÁ<›†£†8
ӌ
<¥†
'¬†8æ	®†
±†Æ
8
¯å
L²†
'»†8PoisonÁ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
Ë”<ÊŠ
 ÑŠ8waitÁ$ÒŠ
֊׊
%ØŠ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ô�8previousÁDø��‘
ƒ‘‘‘
7ˆ„‘
%…‘8
°�T‡‘%’‘8´‘8¸‘8‹$¼‘Á‘8KÑ
'Æ‘8ƒ,È‘
Í‘Ú‘

Α8
ÿ�\Ï‘%Û‘8$ý‘
‚’Ñ—
*8¨’8
�‡¬’°’8
��4²’
 ¸’8¬$¹’
½’¾’
%¿’8å’8Kè’
'ë’8
–+4í’
ó’ÿ’
ô’8‹$õ’
$ù’û’8
�‡ü’
�“›”
8
…ä
4«“
'±“8
ûõ
t³“
Á““
%Ó8Dí“
%õ“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£,®š
 ³š8is_noneÁ<´š
»š¼š%¾š8
��4К
 Öš8È,ך
Üšïš
8Û
$Ýš
ášîš8Kâš
'åš8æ	çš
êšíš
7
óÿ
ëš%ðš8ÔL‚›
	‹›
Œ›²›
7
óÿ
�›
$�›
‘›