Reference counting is a common approach to memory management.
One challenge with reference counting is cycles
that prevent objects from being deallocated. Systems such as
the C++ and Rust standard libraries introduce two types of
reference: strong and weak. A strong reference allows access
to the object and prevents the object from being deallocated,
while a weak reference only prevents deallocation. A weak
reference can be upgraded to provide a strong reference
provided there are other strong references to the object. Hence,
the upgrade operation is partial, and may fail dynamically.
The classic implementation of this upgrade operation is not
wait-free, that is, it can take arbitrarily long to complete if
there is contention on the reference count.

In this paper, we propose a wait-free algorithm for weak
reference counting. The algorithm requires primitive wait-
free atomic operations of “compare and swap”, and “fetch
and add”. We provide a correctness proof of the algorithm
using the Starling verification tool. We provide a full
implementation in C++ and demonstrate the best and worst case
performance using micro-benchmarks. For our best case
scenario with high contention, our new algorithm provides ~3x
more throughput, while for the worst case the new algorithm
is ~85% slower. Based on a worst case analysis, we provide
a second algorithm that combines the strengths of the two
algorithms, and has a significantly improved worst case with
~30% overhead, while maintaining the ~3x speedup for the
best case.