arc-swap

• Document RefCnt must not panic (#208).

• One more SeqCst :-| (#204).

Committing so it doesn't break again.

• Promote certain orderings to SeqCst. Original proofs based on wrong reading of standard :-(. Expect some performance degradation (#198, #200).

Proper version gate of the Pin.

• Proper gate of Pin (since 1.39 - we are not using only Pin, but also Pin::into_inner, #197).

• Some more careful orderings (#195).

• Support for Pin (#185, #183).
• Fix (hopefully) crash on ARM (#164).
• Fix Miri check (#186, #156).
• Fix support for Rust 1.31.0.
• Some minor clippy lints.

• Fix docs build (mutually exclusive features, #112).

• Support building for no_std using nightly Rust compiler

• Adds a new feature experimental-thread-local that enables building for no_std targets.
  If this feature is not enabled, the crate is identical as before,
  still allowing for compilation using Rust stable >= 1.38.0.

• The experimental-thread-local feature makes use of experimental features thread_local
  and lazy_cell, thus requiring a nightly Rust compiler.

• Support for std::sync::RwLock is dropped in no_std builds.

• Support for no-std builds with the experimental-thread-local. Needs nightly compiler. No stability guarantees with this feature (#93).

• Fix a data race reported by MIRI.
• Avoid violating stacked borrows (AFAIK these are still experimental and not normative, but better safe than sorry). (#80).
• The AccessConvert wrapper is needed less often in practice (#77).

• bug: Insufficient synchronization on weak platforms (#76).

  Never observed in practice (it's suspected practical weak platforms like ARM are still stronger than the model), but still technically UB.

• docs: Mention triomphe's ThinArc around the fat-pointer limitations.

• Support serde (by a feature).

• Allow const-initializing ArcSwapOption (const_empty method).

• More helpful description of the AsRaw trait (isn't implemented for owned Arc/Option<Arc>).

• Cache doc improvements.

• Allow mapping of DynAccess.
• Fix some lints.
• Don't leave threads running in tests/doctests. It's a bad form and annoys miri.

• Miri and 32 bit tests in CI.
• Making the writers lock-free. Soft-removing the IndependentStrategy, as it is no longer needed (hidden and the same as the DafultStrategy).

• Fix soundness bug around access::Map. Technically a breaking change, but unlikely to bite and breaking seems to be the least bad option. #45.

• Remove Clone implementation. People are often confused by it and it is easy to emulate by hand in the rare case it is actually needed.

• Get rid of the load_signal_safe. It only complicates things and it is niche; signal-hook-registry has its own simplified version.
• Avoid from_ptr(as_ptr()). Slight change in RefCnt::inc which technically is API breaking change, but this one should not matter in practice.
• Extend documentation about clone behaviour.
• Few more traits for Guard (From<T: RefCnt>, Default).
• Get rid of rcu_unwap, the whole concept is a trap.
• Hide the whole gen lock thing.
• Introduce the Strategy, as a high level way to choose how exactly the locking happens.
  • Not possible to implement by downstream users just yet, or call them.
  • The CaS is its own trait for flexibility.
• Adding the SimpleGenLock experimental strategy.
  • Not part of stability guarantees.

• Rename the unstable-weak to weak feature. The support is now available on 1.45 (currently in beta).

• Adjust to Weak::as_ptr from std (the weak pointer support, relying on unstable features).
• Support running on miri (without some optimizations), so dependencies may run miri tests.
• Little optimization when waiting out the contention on write operations.

• Added Guard::from_inner.

• Top-level docs rewrite (less rambling, hopefully more readable).

• Fix the Display implementation on Guard to correctly delegate to the underlying Display implementation.

• The Access functionality ‒ ability to pass a handle to subpart of held data to somewhere with the ability to update itself.
• Mapped cache can take FnMut as well as Fn.

• Mapped caches ‒ to allow giving access to parts of config only.

• Support for Weak pointers.
• RefCnt implemented for Rc.
• Breaking: Big API cleanups.
  • Peek is gone.
  • Terminology of getting the data unified to load.
  • There's only one kind of Guard now.
  • Guard derefs to the Arc/Option<Arc> or similar.
  • Cache got moved to top level of the crate.
  • Several now unneeded semi-internal traits and trait methods got removed.
• Splitting benchmarks into a separate sub-crate.
• Minor documentation improvements.

• Prevention against UB due to dropping Guards and overflowing the guard counter (aborting instead, such problem is very degenerate anyway and wouldn't work in the first place).

• Tweak slot allocation to take smaller performance hit if some leases are held.
• Increase the number of lease slots per thread to 8.
• Added a cache for faster access by keeping an already loaded instance around.

• Fix Send/Sync for Guard and Lease (they were broken in the safe but uncomfortable direction ‒ not implementing them even if they could).

• Lease<Option<_>>::unwrap(), expect() and into_option() for convenient use.

• Use the correct #[deprecated] syntax.

• Another locking store (PrivateSharded) to complement the global and private unsharded ones.
• Comparison to other crates/approaches in the docs.

• Updates to documentation, made it hopefully easier to digest.
• Added the ability to separate gen-locks of one ArcSwapAny from others.
• Some speed improvements by inlining.
• Simplified the lease method internally, making it faster in optimistic cases.

• Another potentially weak ordering discovered (with even less practical effect than the previous).

• Increased potentially weak ordering (probably without any practical effect).

• Documentation link fix.

• Few convenience constructors.
• More tests (some randomized property testing).

• compare_and_swap no longer takes &Guard as current as that is a sure way to create a deadlock.
• Introduced Lease for temporary storage, which doesn't suffer from contention like load, but doesn't block writes like Guard. The downside is it slows down with number of held by the current thread.
• compare_and_swap and rcu uses leases.
• Made the ArcSwap as small as the pointer itself, by making the shards/counters and generation ID global. This comes at a theoretical cost of more contention when different threads use different instances.

• Added an ArcSwapOption, which allows storing NULL values (as None) as well as a valid pointer.
• compare_and_swap accepts borrowed Arc as current and doesn't consume one ref count.
• Sharding internal counters, to improve performance on read-mostly contented scenarios.
• Providing peek_signal_safe as the only async signal safe method to use inside signal handlers. This removes the footgun with dropping the Arc returned from load inside a signal handler.

• The peek method to use the Arc inside without incrementing the reference count.
• Some more (and hopefully better) benchmarks.

• Documentation fix (swap is not lock-free in current implementation).

• More freedom in the rcu and rcu_unwrap return types.

• rcu support.
• compare_and_swap support.
• Added some primitive benchmarks.

• Initial implementation.