ratomic 0.1.0

data/rs/rust-atomics.h

@@ -0,0 +1,89 @@
+#ifndef RUST_ATOMICS_H
+#define RUST_ATOMICS_H
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define ATOMIC_COUNTER_SIZE 8
+
+#define CONCURRENT_HASH_MAP_SIZE 40
+
+#define FIXED_SIZE_OBJECT_POOL_SIZE 72
+
+#define MPMC_QUEUE_OBJECT_SIZE 80
+
+typedef struct atomic_counter_t atomic_counter_t;
+
+typedef struct concurrent_hash_map_t concurrent_hash_map_t;
+
+typedef struct fixed_size_object_pool_t fixed_size_object_pool_t;
+
+typedef struct mpmc_queue_t mpmc_queue_t;
+
+typedef struct {
+  uintptr_t idx;
+  unsigned long rbobj;
+} PooledItem;
+
+void atomic_counter_init(atomic_counter_t *counter, uint64_t n);
+
+void atomic_counter_increment(const atomic_counter_t *counter, uint64_t amt);
+
+void atomic_counter_decrement(const atomic_counter_t *counter, uint64_t amt);
+
+uint64_t atomic_counter_read(const atomic_counter_t *counter);
+
+extern unsigned long rb_hash(unsigned long obj);
+
+extern int rb_eql(unsigned long lhs, unsigned long rhs);
+
+void concurrent_hash_map_init(concurrent_hash_map_t *hashmap);
+
+void concurrent_hash_map_drop(concurrent_hash_map_t *hashmap);
+
+void concurrent_hash_map_clear(const concurrent_hash_map_t *hashmap);
+
+unsigned long concurrent_hash_map_get(const concurrent_hash_map_t *hashmap,
+                                      unsigned long key,
+                                      unsigned long fallback);
+
+void concurrent_hash_map_set(const concurrent_hash_map_t *hashmap,
+                             unsigned long key,
+                             unsigned long value);
+
+void concurrent_hash_map_mark(const concurrent_hash_map_t *hashmap, void (*f)(unsigned long));
+
+void concurrent_hash_map_fetch_and_modify(const concurrent_hash_map_t *hashmap,
+                                          unsigned long key,
+                                          unsigned long (*f)(unsigned long));
+
+void fixed_size_object_pool_alloc(fixed_size_object_pool_t *pool);
+
+void fixed_size_object_pool_init(fixed_size_object_pool_t *pool,
+                                 uintptr_t max_size,
+                                 uint64_t timeout_in_ms,
+                                 unsigned long (*rb_make_obj)(unsigned long));
+
+void fixed_size_object_pool_drop(fixed_size_object_pool_t *pool);
+
+void fixed_size_object_pool_mark(const fixed_size_object_pool_t *pool, void (*f)(unsigned long));
+
+PooledItem fixed_size_object_pool_checkout(fixed_size_object_pool_t *pool);
+
+void fixed_size_object_pool_checkin(fixed_size_object_pool_t *pool, uintptr_t idx);
+
+void mpmc_queue_alloc(mpmc_queue_t *q);
+
+void mpmc_queue_init(mpmc_queue_t *q, uintptr_t capacity, unsigned long default_);
+
+void mpmc_queue_drop(mpmc_queue_t *q);
+
+void mpmc_queue_mark(const mpmc_queue_t *q, void (*f)(unsigned long));
+
+void *mpmc_queue_push(void *push_paylod);
+
+void *mpmc_queue_pop(void *q);
+
+#endif  /* RUST_ATOMICS_H */

data/rs/src/bin/mpmc_queue.rs

@@ -0,0 +1,89 @@
+use std::{
+    sync::Arc,
+    time::{Duration, Instant},
+};
+
+use libc::c_ulong;
+use rust_atomics::MpmcQueue;
+
+const RUN_GC_EVERY: Duration = Duration::from_millis(1000);
+const PUSH_ITERATIONS: u64 = 5;
+const THREADS_COUNT: u8 = 10;
+
+fn main() {
+    let q = make_q(16);
+
+    let mut consumers = vec![];
+    for _ in 0..THREADS_COUNT {
+        consumers.push(start_consumer(Arc::clone(&q)));
+    }
+
+    let last_pushed_value = start_producer(Arc::clone(&q));
+
+    let mut consumed = vec![];
+    for consumer in consumers {
+        let mut data = consumer.join().unwrap();
+        consumed.append(&mut data);
+    }
+
+    consumed.sort_unstable();
+
+    for (prev, next) in consumed.iter().zip(consumed.iter().skip(1)) {
+        assert_eq!(*prev + 1, *next);
+    }
+
+    assert_eq!(*consumed.last().unwrap(), last_pushed_value);
+}
+
+fn make_q(buffer_size: usize) -> Arc<MpmcQueue> {
+    Arc::new(MpmcQueue::new(buffer_size, 0))
+}
+
+const END: c_ulong = c_ulong::MAX;
+fn push_end(q: &MpmcQueue) {
+    q.push(END);
+}
+fn pop(q: &MpmcQueue) -> Option<c_ulong> {
+    match q.pop() {
+        END => None,
+        other => Some(other),
+    }
+}
+
+fn start_consumer(q: Arc<MpmcQueue>) -> std::thread::JoinHandle<Vec<c_ulong>> {
+    std::thread::spawn(move || {
+        let mut popped = vec![];
+
+        while let Some(value) = pop(&q) {
+            eprintln!("[{:?}] popped {value}", std::thread::current().id());
+            popped.push(value);
+        }
+
+        popped
+    })
+}
+
+fn start_producer(q: Arc<MpmcQueue>) -> c_ulong {
+    let mut value = 1;
+
+    for _ in 0..PUSH_ITERATIONS {
+        // push for `RUN_GC_EVERY`
+        let start = Instant::now();
+        while Instant::now() - start < RUN_GC_EVERY {
+            q.push(value);
+            value += 1;
+        }
+
+        q.acquire_as_gc(|| {
+            eprintln!("===== GC START ======");
+            std::thread::sleep(Duration::from_millis(1000));
+            eprintln!("===== GC END ========");
+        });
+    }
+
+    for _ in 0..THREADS_COUNT {
+        push_end(&q);
+    }
+
+    value - 1
+}

data/rs/src/counter.rs

@@ -0,0 +1,57 @@
+use std::sync::atomic::{AtomicU64, Ordering};
+
+#[derive(Debug)]
+pub struct AtomicCounter {
+    value: AtomicU64,
+}
+
+impl AtomicCounter {
+    pub fn new(n: u64) -> Self {
+        Self {
+            value: AtomicU64::new(n),
+        }
+    }
+
+    pub fn inc(&self, amt: u64) {
+        self.value.fetch_add(amt, Ordering::Relaxed);
+    }
+
+    pub fn dec(&self, amt: u64) {
+        self.value.fetch_sub(amt, Ordering::Relaxed);
+    }
+
+    pub fn read(&self) -> u64 {
+        self.value.load(Ordering::Relaxed)
+    }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn atomic_counter_init(counter: *mut AtomicCounter, n: u64) {
+    unsafe { counter.write(AtomicCounter::new(n)) }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn atomic_counter_increment(counter: *const AtomicCounter, amt: u64) {
+    let counter = unsafe { counter.as_ref().unwrap() };
+    counter.inc(amt);
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn atomic_counter_decrement(counter: *const AtomicCounter, amt: u64) {
+    let counter = unsafe { counter.as_ref().unwrap() };
+    counter.dec(amt);
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn atomic_counter_read(counter: *const AtomicCounter) -> u64 {
+    let counter = unsafe { counter.as_ref().unwrap() };
+    counter.read()
+}
+
+pub const ATOMIC_COUNTER_SIZE: usize = 8;
+
+#[test]
+fn test_atomic_counter() {
+    assert_eq!(ATOMIC_COUNTER_SIZE, std::mem::size_of::<AtomicCounter>());
+    assert!(crate::is_sync_and_send::<AtomicCounter>());
+}

data/rs/src/fixed_size_object_pool.rs

@@ -0,0 +1,120 @@
+use crossbeam_channel::{Receiver, Sender};
+use std::{ffi::c_ulong, time::Duration};
+
+pub struct FixedSizeObjectPool {
+    pool: Vec<c_ulong>,
+    tx: Sender<usize>,
+    rx: Receiver<usize>,
+    timeout: Duration,
+}
+
+#[repr(C)]
+pub struct PooledItem {
+    pub idx: usize,
+    pub rbobj: c_ulong,
+}
+
+impl FixedSizeObjectPool {
+    fn new() -> Self {
+        let (tx, rx) = crossbeam_channel::unbounded();
+
+        Self {
+            pool: vec![],
+            tx,
+            rx,
+            timeout: Duration::MAX,
+        }
+    }
+
+    fn init(
+        &mut self,
+        size: usize,
+        timeout_in_ms: u64,
+        rb_make_obj: extern "C" fn(c_ulong) -> c_ulong,
+    ) {
+        self.timeout = Duration::from_millis(timeout_in_ms);
+
+        self.pool = Vec::with_capacity(size);
+        for idx in 0..size {
+            self.pool.push((rb_make_obj)(0));
+            self.tx.send(idx).unwrap();
+        }
+    }
+
+    fn mark(&self, f: extern "C" fn(c_ulong)) {
+        for item in self.pool.iter() {
+            f(*item);
+        }
+    }
+
+    fn checkout(&mut self) -> Option<PooledItem> {
+        let idx = self.rx.recv_timeout(self.timeout).ok()?;
+        Some(PooledItem {
+            idx,
+            rbobj: self.pool[idx],
+        })
+    }
+
+    fn checkin(&mut self, idx: usize) {
+        self.tx.send(idx).unwrap();
+    }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn fixed_size_object_pool_alloc(pool: *mut FixedSizeObjectPool) {
+    unsafe { pool.write(FixedSizeObjectPool::new()) }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn fixed_size_object_pool_init(
+    pool: *mut FixedSizeObjectPool,
+    max_size: usize,
+    timeout_in_ms: u64,
+    rb_make_obj: extern "C" fn(c_ulong) -> c_ulong,
+) {
+    let pool = unsafe { pool.as_mut().unwrap() };
+    pool.init(max_size, timeout_in_ms, rb_make_obj);
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn fixed_size_object_pool_drop(pool: *mut FixedSizeObjectPool) {
+    unsafe { std::ptr::drop_in_place(pool) };
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn fixed_size_object_pool_mark(
+    pool: *const FixedSizeObjectPool,
+    f: extern "C" fn(c_ulong),
+) {
+    let pool = unsafe { pool.as_ref().unwrap() };
+    pool.mark(f);
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn fixed_size_object_pool_checkout(
+    pool: *mut FixedSizeObjectPool,
+) -> PooledItem {
+    let pool = unsafe { pool.as_mut().unwrap() };
+    pool.checkout().unwrap_or(PooledItem { idx: 0, rbobj: 0 })
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn fixed_size_object_pool_checkin(
+    pool: *mut FixedSizeObjectPool,
+    idx: usize,
+) {
+    let pool = unsafe { pool.as_mut().unwrap() };
+    pool.checkin(idx);
+}
+
+pub const FIXED_SIZE_OBJECT_POOL_SIZE: usize = 72;
+
+#[test]
+fn test_concurrent_hash_map() {
+    assert_eq!(
+        FIXED_SIZE_OBJECT_POOL_SIZE,
+        std::mem::size_of::<FixedSizeObjectPool>(),
+        "size mismatch"
+    );
+    assert!(crate::is_sync_and_send::<FixedSizeObjectPool>());
+}

data/rs/src/gc_guard.rs

@@ -0,0 +1,88 @@
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+
+pub(crate) struct GcGuard {
+    locked: AtomicBool,
+    count: AtomicUsize,
+}
+
+impl GcGuard {
+    pub(crate) fn alloc() -> Self {
+        GcGuard {
+            locked: AtomicBool::new(false),
+            count: AtomicUsize::new(0),
+        }
+    }
+
+    pub(crate) fn init(&mut self) {
+        self.locked.store(false, Ordering::Relaxed);
+        self.count.store(0, Ordering::Relaxed);
+    }
+
+    fn add_consumer(&self) {
+        self.count.fetch_add(1, Ordering::SeqCst);
+    }
+    fn remove_consumer(&self) {
+        self.count.fetch_sub(1, Ordering::SeqCst);
+    }
+    fn wait_for_no_consumers(&self) {
+        loop {
+            let count = self.count.load(Ordering::SeqCst);
+            if count == 0 {
+                #[cfg(feature = "simulation")]
+                eprintln!("[producer] 0 running consumers");
+                break;
+            } else {
+                // spin until they are done
+                #[cfg(feature = "simulation")]
+                eprintln!("[producer] waiting for {count} consumers to finish");
+            }
+        }
+    }
+
+    fn lock(&self) {
+        self.locked.store(true, Ordering::SeqCst);
+    }
+    fn unlock(&self) {
+        self.locked.store(false, Ordering::SeqCst)
+    }
+    fn is_locked(&self) -> bool {
+        self.locked.load(Ordering::SeqCst)
+    }
+    fn wait_until_unlocked(&self) {
+        while self.is_locked() {
+            // spin
+        }
+    }
+
+    pub(crate) fn acquire_as_gc<F, T>(&self, f: F) -> T
+    where
+        F: FnOnce() -> T,
+    {
+        #[cfg(feature = "simulation")]
+        eprintln!("Locking consumers");
+        self.lock();
+        #[cfg(feature = "simulation")]
+        eprintln!("Waiting for consumers to finish");
+        self.wait_for_no_consumers();
+        #[cfg(feature = "simulation")]
+        eprintln!("All consumers have finished");
+        let out = f();
+        #[cfg(feature = "simulation")]
+        eprintln!("Unlocking consumers");
+        self.unlock();
+        out
+    }
+
+    pub(crate) fn acquire_as_consumer<F, T>(&self, f: F) -> T
+    where
+        F: FnOnce() -> T,
+    {
+        if self.is_locked() {
+            self.wait_until_unlocked();
+        }
+        self.add_consumer();
+        let out = f();
+        self.remove_consumer();
+        out
+    }
+}

data/rs/src/hashmap.rs

@@ -0,0 +1,129 @@
+use std::ffi::{c_int, c_ulong};
+
+#[derive(Debug)]
+struct RubyHashEql(c_ulong);
+
+impl PartialEq for RubyHashEql {
+    fn eq(&self, other: &Self) -> bool {
+        unsafe { rb_eql(self.0, other.0) != 0 }
+    }
+}
+impl Eq for RubyHashEql {}
+
+impl std::hash::Hash for RubyHashEql {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        let ruby_hash = unsafe { rb_hash(self.0) };
+        ruby_hash.hash(state);
+    }
+}
+
+pub struct ConcurrentHashMap {
+    map: dashmap::DashMap<RubyHashEql, c_ulong>,
+}
+
+unsafe extern "C" {
+    fn rb_hash(obj: c_ulong) -> c_ulong;
+    fn rb_eql(lhs: c_ulong, rhs: c_ulong) -> c_int;
+}
+
+impl ConcurrentHashMap {
+    fn new() -> Self {
+        Self {
+            map: dashmap::DashMap::new(),
+        }
+    }
+
+    fn get(&self, key: c_ulong) -> Option<c_ulong> {
+        let key = RubyHashEql(key);
+        self.map.get(&key).map(|v| *v)
+    }
+
+    fn set(&self, key: c_ulong, value: c_ulong) {
+        let key = RubyHashEql(key);
+        self.map.insert(key, value);
+    }
+
+    fn clear(&self) {
+        self.map.clear()
+    }
+
+    fn fetch_and_modify(&self, key: c_ulong, f: extern "C" fn(c_ulong) -> c_ulong) {
+        let key = RubyHashEql(key);
+        self.map.alter(&key, |_, v| f(v));
+    }
+
+    fn mark(&self, f: extern "C" fn(c_ulong)) {
+        for pair in self.map.iter() {
+            f(pair.key().0);
+            f(*pair.value());
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn concurrent_hash_map_init(hashmap: *mut ConcurrentHashMap) {
+    unsafe { hashmap.write(ConcurrentHashMap::new()) }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn concurrent_hash_map_drop(hashmap: *mut ConcurrentHashMap) {
+    unsafe { std::ptr::drop_in_place(hashmap) };
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn concurrent_hash_map_clear(hashmap: *const ConcurrentHashMap) {
+    let hashmap = unsafe { hashmap.as_ref().unwrap() };
+    hashmap.clear();
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn concurrent_hash_map_get(
+    hashmap: *const ConcurrentHashMap,
+    key: c_ulong,
+    fallback: c_ulong,
+) -> c_ulong {
+    let hashmap = unsafe { hashmap.as_ref().unwrap() };
+    hashmap.get(key).unwrap_or(fallback)
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn concurrent_hash_map_set(
+    hashmap: *const ConcurrentHashMap,
+    key: c_ulong,
+    value: c_ulong,
+) {
+    let hashmap = unsafe { hashmap.as_ref().unwrap() };
+    hashmap.set(key, value);
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn concurrent_hash_map_mark(
+    hashmap: *const ConcurrentHashMap,
+    f: extern "C" fn(c_ulong),
+) {
+    let hashmap = unsafe { hashmap.as_ref().unwrap() };
+    hashmap.mark(f);
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn concurrent_hash_map_fetch_and_modify(
+    hashmap: *const ConcurrentHashMap,
+    key: c_ulong,
+    f: extern "C" fn(c_ulong) -> c_ulong,
+) {
+    let hashmap = unsafe { hashmap.as_ref().unwrap() };
+    hashmap.fetch_and_modify(key, f);
+}
+
+pub const CONCURRENT_HASH_MAP_SIZE: usize = 40;
+
+#[test]
+fn test_concurrent_hash_map() {
+    assert_eq!(
+        CONCURRENT_HASH_MAP_SIZE,
+        std::mem::size_of::<ConcurrentHashMap>(),
+        "size mismatch"
+    );
+
+    assert!(crate::is_sync_and_send::<ConcurrentHashMap>());
+}

data/rs/src/lib.rs

@@ -0,0 +1,23 @@
+#![expect(clippy::missing_safety_doc)]
+
+mod counter;
+pub use counter::*;
+
+mod hashmap;
+pub use hashmap::*;
+
+mod fixed_size_object_pool;
+pub use fixed_size_object_pool::*;
+
+mod mpmc_queue;
+pub use mpmc_queue::*;
+
+mod gc_guard;
+pub(crate) use gc_guard::GcGuard;
+
+mod sem;
+
+#[cfg(test)]
+pub(crate) fn is_sync_and_send<T: Sync + Send>() -> bool {
+    true
+}