How do I atomically increment an element of the SharedArray

[vishpat]

I am trying to implement a histogram kernel as shown below. However, I am unable to figure out how to atomically increment an element of the SharedArray.

 #[kernel]
    pub fn histogram(in_vec: &[f32], out: DisjointSlice<u32>) {
        static mut TILE: SharedArray<u32, { N_BINS as usize }> = SharedArray::UNINIT;

        let thread_global_idx = thread::index_1d();
        let thread_id = thread_global_idx.get();

        let mut idx = thread_id;
        while idx < N {
            let val = in_vec[idx];
            let atomic_counter = unsafe { &*(TILE[val as usize].as_ptr() as *const DeviceAtomicU32) }; <<<< DOES NOT WORK
            atomic_counter.fetch_add(1, AtomicOrdering::Relaxed);
            idx += STRIDE as usize;
        }
    }

[nihalpasham]

Your code trips before the atomic part: TILE[i] returns the u32 element itself, not a pointer, so there's no .as_ptr() on it. Here's the supported pattern, three lines, each with one job:

use cuda_device::atomic::{AtomicOrdering, BlockAtomicU32};

let bin = val as usize;
let p       = unsafe { SharedArray::as_raw_mut_ptr(&raw mut TILE).add(bin) };  // 1
let counter = unsafe { BlockAtomicU32::from_ptr(p) };                          // 2
counter.fetch_add(1, AtomicOrdering::Relaxed);                                 // 3

1. Get the element's address as a raw pointer. Not &mut TILE[bin]: every thread in the block would be holding an exclusive reference to the same slot at once, which Rust forbids.
2. Put an atomic label on that address. from_ptr means "treat the u32 already sitting there as atomic", no copy, no wrapper in memory. It's cuda-oxide's version of C++'s cuda::atomic_ref.
3. The one-step increment. Compiles to atom.shared.add.u32, where the hardware does read + add + write as one uninterruptible step:

TILE[bin] = 0
t0: atom.add  → 0 becomes 1     ← one indivisible step
t4: atom.add  → 1 becomes 2     ← waits its turn, nobody sneaks in
t5: atom.add  → 2 becomes 3

Why BlockAtomicU32 and not DeviceAtomicU32: the prefix says who must see the update in order. Shared memory is only visible to your own block, so block scope is enough, and cheaper at stronger orderings.

Another rule to keep in mind: plain and atomic access to the same slot must not overlap in time, so structure the kernel in phases:

zero the counters (plain writes)
── sync_threads() ──
count (atomic adds)              ← the three lines above
── sync_threads() ──
copy counters out (plain reads)

Note, your original cast also works once the pointer is taken correctly (&TILE[bin] as *const u32 as *const DeviceAtomicU32) and emits the same shared-memory atomic. It just uses device scope on block-local memory, so I'd stick with BlockAtomicU32::from_ptr.

PS: The GitHub discussions tab isn't actively monitored. We have a community discord server for questions like these. Feel free to check it out