Backend Internals & Memory Engine

Quick Reference Manual

Rust Architecture & Standard Library Cheat Sheet

Quick syntax references, memory footprint summaries, and thread safety traits for standard library smart pointers and concurrency primitives.

Smart Pointers & Memory Wrappers

Box<T>

let b = Box::new(5);

Unique heap allocation. 8-byte pointer on stack. Auto-deallocated on drop.

Deref & Drop implemented. Zero-cost heap indirection.

Rc<T>

let r = Rc::new(data); let r2 = Rc::clone(&r);

Single-threaded reference counting. Shared ownership. !Send, !Sync.

Heap header tracks strong and weak reference counts.

Arc<T>

let a = Arc::new(data); let a2 = Arc::clone(&a);

Atomic Reference Counting. Multi-threaded shared ownership. Send + Sync (if T is Send + Sync).

Uses atomic CPU instructions for thread-safe count manipulation.

RefCell<T>

let c = RefCell::new(0); *c.borrow_mut() += 1;

Dynamic interior mutability. Runtime borrow checking. Panics on aliasing violations.

Tracks active loan count at runtime. !Sync.

Mutex<T>

let m = Mutex::new(0); let mut g = m.lock().unwrap();

Thread-safe mutual exclusion. Grants RAII MutexGuard giving exclusive &mut T access.

Releases OS/futex lock deterministically when MutexGuard is dropped.

RwLock<T>

let lock = RwLock::new(data); let r = lock.read().unwrap();

Multiple concurrent readers OR one exclusive writer across threads.

Optimized for high read-to-write ratio workloads.

Standard Traits & Conversions

Deref / DerefMut

impl Deref for MyBox<T> { type Target = T; ... }

Implicit dereferencing coercions (e.g. &String -> &str, &Vec<T> -> &[T]).

Allows smart pointers to be used transparently as their underlying target.

From / Into

impl From<A> for B { fn from(a: A) -> Self { ... } }

Value-to-value conversion. Implementing From automatically implements Into.

Idiomatic and infallible conversion between types.

TryFrom / TryInto

impl TryFrom<i64> for u8 { type Error = ...; }

Fallible type conversion returning Result<T, Error>.

Used for bounds-checked numeric conversions and validated domain types.

AsRef / AsMut

fn process<P: AsRef<Path>>(path: P) { ... }

Cheap reference-to-reference conversion for generic function parameters.

Enables accepting &str, String, or Path in a single clean function signature.

Concurrency Primitives

mpsc::channel()

let (tx, rx) = std::sync::mpsc::channel();

Unbounded Multi-Producer, Single-Consumer FIFO queue.

tx can be cloned across multiple threads; rx consumes messages.

mpsc::sync_channel(N)

let (tx, rx) = std::sync::mpsc::sync_channel(10);

Bounded FIFO queue applying backpressure. Blocks senders when buffer reaches N.

Guarantees fixed memory consumption under heavy write load.

thread::spawn

thread::spawn(move || { ... });

Spawns an OS-level native thread with a 2MB default stack.

Requires closure to have a 'static lifetime unless scoped threads are used.

thread::scope

thread::scope(|s| { s.spawn(|| { ... }); });

Scoped threads that can borrow stack data from the parent scope without 'static.

Guarantees all child threads join before the scope function returns.

Loading RustViz Engine...