Atomic types for unsupported platforms

2 unstable releases

0.2.0 Sep 12, 2021
0.1.0 May 20, 2020

#236 in Concurrency

Download history 10967/week @ 2023-02-04 8556/week @ 2023-02-11 11667/week @ 2023-02-18 9644/week @ 2023-02-25 6346/week @ 2023-03-04 12120/week @ 2023-03-11 12058/week @ 2023-03-18 11270/week @ 2023-03-25 9842/week @ 2023-04-01 11094/week @ 2023-04-08 14467/week @ 2023-04-15 13076/week @ 2023-04-22 12504/week @ 2023-04-29 11443/week @ 2023-05-06 9220/week @ 2023-05-13 8582/week @ 2023-05-20

44,172 downloads per month
Used in 39 crates (2 directly)


216 lines


Atomic types shims for unsupported architectures.

This crate provides shims for std::sync::AtomicU64 and std::sync::AtomicI64 for mips and powerpc.

The std primitives are not available on all platforms, and that makes it tricky to write code for mips, such as OpenWRT Routers. This crate provides it's own AtomicU64 and AtomicI64, which can directly replace the std::sync structs.

The crate does target detection and on supported architectures it will use std::sync structures. When it detects it is running on unsupported platforms, it fallbacks to the shim implementation, using crossbeam Mutex.

For testing purposes, and for other reasons, you can replace the default implementation with the Mutex implementation by using the features = ["mutex"]


Replace any imports of use std::sync::AtomicU64; with use atomic_shim::Atomic64;


Add the dependency to your Cargo.toml, and optionally, exposes the mutex feature to test without cross-compiling:

atomic-shim = "*"

# Optional
#mutex = ["atomic-shim/mutex"]


To run tests, it is important to enable the --features mutex.

cargo test --features mutex


A simple spinlock:

use std::sync::Arc;
use std::sync::atomic::Ordering;
use std::thread;
use atomic_shim::AtomicU64;

fn main() {
    let spinlock = Arc::new(AtomicU64::new(1));

    let spinlock_clone = spinlock.clone();
    let thread = thread::spawn(move|| {
        spinlock_clone.store(0, Ordering::SeqCst);

    // Wait for the other thread to release the lock
    while spinlock.load(Ordering::SeqCst) != 0 {}

    if let Err(panic) = thread.join() {
        println!("Thread had an error: {:?}", panic);

Keep a global count of live threads:

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;

let global_thread_count = AtomicU64::new(0);

let old_thread_count = global_thread_count.fetch_add(1, Ordering::SeqCst);
println!("live threads: {}", old_thread_count + 1);


Licensed under either of

at your option.


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.