RcLite: small, fast, and memory-friendly reference counting for Rust

Khashayar Fereidani

Last update: Apr 14, 2023

Related tags

Learning Resources rust atomic structure concurrency memory-management reference-counting

Overview

RcLite: small, fast, and memory-friendly reference counting

RcLite is a lightweight reference-counting solution for Rust that serves as an alternative to the standard library's reference-counting. It offers both multi-threaded and single-threaded reference counting options with improved performance and reduced memory overhead, boasting at least 50% and up to 100% decrease in memory overhead compared to the standard library reference counting. RcLite is a suitable option when weak references are not necessary and optimizing for performance and memory usage is a priority.

Why use RcLite?

It's faster and smaller
Uses less memory
It provides lightweight drop-in replacements for standard library std::sync::Arc and std::rc::Rc
It supports no_std with extern alloc

Why not use RcLite?

It does not provide weak references
It does not support data as DSTs
With RcLite in 64-bit systems, you only can have 4,294,967,296 - 256 live references to an object which requires about 32GBs of ram for holding all these references to this single object location. if you need to have 18,446,744,073,709,551,616 live references to an object, use the standard library. In other systems with smaller pointer sizes like 32-bit, you will have usize::MAX live references limitation that is the same as the standard library.

Comparison

	rclite::{Arc,Rc}	std::*::{Arc,Rc}
Overhead in 64-bit systems	4 bytes	16 bytes
Overhead in 32-bit systems	4 or 2 bytes	8 bytes
Overhead in 16-bit systems	2 or 1 bytes	4 bytes
Weak References	❌	✅
DST Support	❌	✅

In 64-bit systems, RcLite has an advantage over the standard library's Arc as it can utilize the memory padding area, using only 4 bytes to store the counter. This results in a reduction in memory usage, as there is less memory waste on padding. However, in situations where there is not enough padding available in the structure, RcLite will have an overhead of 8 bytes, which is still half of the standard library's overhead.

For instance, in 64-bit systems, Rc<u32> and Arc<u32> allocate the same amount of memory as Box<u32>, since the Box<u32> allocation will be padded to u64 by the allocator.

In 32-bit and 16-bit systems, the memory overhead of the RcLite will be 50% of the standard library.

RcLite's structure is similar to a Box<(T,counter)>, where the counter is stored after the data, as opposed to being the first field in the standard library. This eliminates the need for pointer calculation when accessing the data, but also restricts RcLite from supporting DSTs.

Features

By default, RcLite uses a counter size of half the word size for 64-bit systems, with the usize-for-small-platforms feature enabled. This is because overflowing a 32-bit counter is harder compared to overflowing 16-bit counters. If you wish to use the half register size on other platforms, you can disable the default features by setting default-features = false. This will result in the use of 16-bit counters on 32-bit platforms and 8-bit counters on 16-bit platforms.

Comments

Add Cargo/Miri Test Pipeline

The following PR adds a simple pipeline using GitHub Actions to build and test rclite using both Cargo and Miri. The current configuration runs testing on push and pull request to the main branch.

opened by tomlegodais 7
`Borrow` & `make_mut`

I tried to integrate rclite in a project of mine (jaq), but I can't because jaq needs Rc::make_mut and Borrow. Could you implement these? If so, then I could integrate rclite into jaq, providing you with some real-life performance benchmarks of alloc::rc::Rc vs rclite::Rc. :)

opened by 01mf02 7
Add Cargo/Miri Test Pipeline for Debug/Release

Hi there @fereidani, I had to unfortunately re-create the PR as something had corrupted my previous fork. Here is all the work completed and due to the re-creation this is a single commit. Hope this satisfies all of your needs. Let me know if you need anything else!

opened by tomlegodais 1
Sized Constraint
This crate requires Sized. The std Arc does not have a size constraint, which is a quite common requirement when using Arc<dyn MyTrait>

pub struct Arc<T>where T: ?Sized{ /* private fields */ }
opened by PSeitz 1
Use C layout for `ArcInner` and `RcInner`

I'll check to see if anyone points out any issues after I take a nap, otherwise I would say this is good to merge. Both cargo test and miri are happy even with -Z randomize-layout after this change

Sidenote: It would be good to get CI running with at least cargo test and miri since this uses unsafe

opened by CosmicHorrorDev 1