Statically allocated, runtime initialized cell.

Last update: Oct 2, 2022

Related tags

Command-line static-cell

Overview

static-cell

Statically allocated, initialized at runtime cell.

StaticCell provides a no-std-compatible, no-alloc way to reserve memory at compile time for a value, but initialize it at runtime, and get a 'static reference to it.

This is useful in the following scenarios:

You need &'static T, but T can't be constructed in const context so you can't simply use a static.
You need &'static mut T, not just &'static T.

Example

use static_cell::StaticCell;

// Statically allocate memory for a `u32`.
static SOME_INT: StaticCell<u32> = StaticCell::new();

// Initialize it at runtime. This returns a `&'static mut`.
let x: &'static mut u32 = SOME_INT.init(42);
assert_eq!(*x, 42);

// Trying to call `.init()` again would panic, because the StaticCell is already initialized.
// SOME_INT.init(42);

Alternatives

If you can use alloc, you can use Box::leak().
If you're OK with unsafe, you can use static mut THING: MaybeUninit<T>.

Interoperability

This crate uses atomic-polyfill, so on targets without native atomics you must import a crate that provides a critical-section implementation. See the critical-section README for details.

Minimum Supported Rust Version (MSRV)

This crate is guaranteed to compile on stable Rust 1.56 and up. It might compile with older versions but that may change in any new patch release.

License

This work is licensed under either of

Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

JavaScript/TypeScript runtime Deno was meant to be.

Project Bueno (temporary name) Bueno is a web-standards focused JS/TS runtime with as much tooling built-in as possible. It is meant to be both a lear

22 Sep 3, 2023

excss is a small, simple, zero-runtime CSS-in-JS library with just two APIs.

excss excss is a small, simple, zero-runtime CSS-in-JS library with just two APIs.

12 Sep 12, 2023

A heap allocated runtime for deeply recursive algorithms.

Reblessive A heap allocated runtime for deeply recursive algorithms. Turn your cursed recursive algorithm into a blessed heap allocated structure whic

4 Feb 27, 2024

✨ Safe, global singletons initialized at program start

✨ magic_static Safe, global singletons initialized at program start. Usage Simply add magic_static as a dependency in your Cargo.toml to get started:

5 Nov 8, 2022

A stack-allocated box that stores trait objects.

This crate allows saving DST objects in the provided buffer. It allows users to create global dynamic objects on a no_std environment without a global allocator.

19 Dec 13, 2022

Cryptography-oriented big integer library with constant-time, stack-allocated (no_std-friendly) implementations of modern formulas

RustCrypto: Cryptographic Big Integers Pure Rust implementation of a big integer library which has been designed from the ground-up for use in cryptog

88 Dec 31, 2022

Stack buffer provides alternatives to Buf{Reader,Writer} allocated on the stack instead of the heap.

StackBuf{Reader,Writer} Stack buffer provides alternatives to BufReader and BufWriter allocated on the stack instead of the heap. Its implementation i

14 Nov 20, 2022

An implementation of Joshua Yanovski's Ghost Cell paper.

A novel safe and zero-cost borrow-checking paradigm from the GhostCell paper. Motivation A number of collections, such as linked-lists, binary-trees,

350 Dec 22, 2022

A cell-based esoteric programming language

Tape A cell-based esoteric programming language Tape is a cell-based, brainfuck-like programming language that has a readable syntax and a non-wasted

2 Feb 23, 2022

Like a cell, but make lifetimes dynamic instead of ownership

LendingCell is a mutable container that allows you to get an owned reference to the same object. When the owned reference is dropped, ownership return

19 Dec 15, 2022

Simulator of viral infection spread and containment in cell monolayer.

Overview VIS-A-VIS is an agent-based simulator of viral infection spread and viral infection self-containment in a monolayer of cell. The simulation m

2 Nov 20, 2022

The H3 Compressor: A compression scheme tailored for H3 cell indexes.

thc — The H3 Compressor This library allows to compress an H3 cell set into a compacted space-efficient representation. This is especially useful for

11 Jan 23, 2023

An alternative to `qcell` and `ghost-cell` that instead uses const generics

Purpose This crate is another attempt at the ghost-cell / qcell saga of cell crates. This provides an alternative to std::cell::RefCell that can allow

5 Feb 9, 2023

Thread-safe cell based on atomic pointers to externally stored data

Simple thread-safe cell PtrCell is an atomic cell type that allows safe, concurrent access to shared data. No std, no data races, no nasal demons (UB)

3 Mar 23, 2024

A rust drawing library for high quality data plotting for both WASM and native, statically and realtimely 🦀 📈🚀

Plotters - A Rust drawing library focus on data plotting for both WASM and native applications 🦀 📈 🚀 Plotters is drawing library designed for rende

2.7k Jan 4, 2023

Orion lang is a lispy programming language that is strongly and statically typed.

Orion Orion is a lisp inspired statically typed programming language written in Rust Install To install orion you can either: Download binary from the

226 Dec 17, 2022

EXPERIMENTAL: Bitcoin Core Prometheus exporter based on User-Space, Statically Defined Tracing and eBPF.

bitcoind-observer An experimental Prometheus metric exporter for Bitcoin Core based on Userspace, Statically Defined Tracing and eBPF. This demo is ba

24 Nov 8, 2022

A statically-typed, interpreted programming language, with generics and type inference

Glide A programming language. Currently, this includes: Static typing Generics, with monomorphization Type inference on function calls func identityT

1 Apr 10, 2022

Statically sized matrix using a definition with const generics

3 Aug 2, 2022

Comments

Allow creating initialized `StaticCell`.

Add StaticCell::new_with_value to create an initialized StaticCell which can be taken and restored.

Example

static DMA_BUF: StaticCell<[u8; 1024]> = StaticCell::new_with_value([0; 1024]);

fn start_dma_transfer(buf: &'static mut [u8; 1024]) {
  // ...
}

fn stop_dma_transfer() -> &'static mut [u8; 1024] {
  // ...
}

fn main() {
  start_dma_transfer(DMA_BUF.take().unwrap());
}

fn interrupt() {
  let buf = stop_dma_transfer();
  DMA_BUF.restore(buf);
}

Also, a question regarding init_with, which claims

The advantage over [StaticCell::init] is that this method allows the closure to construct the T value in-place directly inside the StaticCell, saving stack space.

Where/how is this guaranteed? Does it depend on the platform or compiler optimizations?

At least with the following example, it clearly doesn't work as described as it results in a stack overflow:

std::thread::Builder::new()
  .name("init_with".to_string())
  .stack_size(512)
  .spawn(|| {
    static BUF: StaticCell<[u8; 4096]> = StaticCell::new();
    let buf = BUF.init_with(|| [1; 4096]);

    let mut count = 0;
    for b in buf {
      count += *b as usize;
    }

    assert_eq!(count, 4096);
  })
  .unwrap()
  .join();

opened by reitermarkus 4

Add `StaticCell::uninit()`
Sometimes I find myself using something that could be distilled to ARRAY.init([0; BIG_NUMBER]), where

let arr = ARRAY.uninit(); unsafe { arr.as_mut_ptr().write_bytes(0x00, BIG_NUMBER); arr.assume_init_mut() }

Would guarantee no unnecessary memcpys or stack usage.
opened by zRedShift 1
Compare to once_cell

It seems once_cell is what "most people" use for this case (some use cases would also have been served by lazy_static, which would be one of the "related creates" listed on once_cell's readme). Having it as an alternative and listing the ups and downs seems practical.

opened by chrysn 1