ratomic 0.1.0

data/rs/src/mpmc_queue.rs

@@ -0,0 +1,231 @@
+use crate::{GcGuard, sem::Semaphore};
+use std::{
+    cell::Cell,
+    ffi::c_ulong,
+    sync::atomic::{AtomicUsize, Ordering},
+};
+
+struct QueueElement {
+    sequence: AtomicUsize,
+    data: Cell<c_ulong>,
+}
+
+unsafe impl Send for QueueElement {}
+unsafe impl Sync for QueueElement {}
+
+pub struct MpmcQueue {
+    buffer: Vec<QueueElement>,
+    buffer_mask: usize,
+    enqueue_pos: AtomicUsize,
+    dequeue_pos: AtomicUsize,
+
+    gc_guard: GcGuard,
+    read_sem: Semaphore,
+    write_sem: Semaphore,
+}
+
+impl MpmcQueue {
+    fn alloc() -> Self {
+        Self {
+            buffer: vec![],
+            buffer_mask: 0,
+            enqueue_pos: AtomicUsize::new(0),
+            dequeue_pos: AtomicUsize::new(0),
+
+            gc_guard: GcGuard::alloc(),
+            read_sem: Semaphore::alloc(),
+            write_sem: Semaphore::alloc(),
+        }
+    }
+
+    fn init(&mut self, buffer_size: usize, default: c_ulong) {
+        assert!(buffer_size >= 2);
+        assert_eq!(buffer_size & (buffer_size - 1), 0);
+
+        let mut buffer = Vec::with_capacity(buffer_size);
+        for i in 0..buffer_size {
+            buffer.push(QueueElement {
+                sequence: AtomicUsize::new(i),
+                data: Cell::new(default),
+            });
+        }
+
+        self.buffer_mask = buffer_size - 1;
+        self.buffer = buffer;
+        self.enqueue_pos.store(0, Ordering::Relaxed);
+        self.dequeue_pos.store(0, Ordering::Relaxed);
+
+        self.gc_guard.init();
+        self.read_sem.init(0);
+        self.write_sem.init(buffer_size as u32);
+    }
+
+    pub fn new(buffer_size: usize, default: c_ulong) -> Self {
+        let mut q = Self::alloc();
+        q.init(buffer_size, default);
+        q
+    }
+
+    fn try_push(&self, data: c_ulong) -> bool {
+        let mut cell;
+        let mut pos = self.enqueue_pos.load(Ordering::Relaxed);
+        loop {
+            cell = &self.buffer[pos & self.buffer_mask];
+            let seq = cell.sequence.load(Ordering::Acquire);
+            let diff = seq as isize - pos as isize;
+            if diff == 0 {
+                if self
+                    .enqueue_pos
+                    .compare_exchange_weak(pos, pos + 1, Ordering::Relaxed, Ordering::Relaxed)
+                    .is_ok()
+                {
+                    break;
+                }
+            } else if diff < 0 {
+                return false;
+            } else {
+                pos = self.enqueue_pos.load(Ordering::Relaxed);
+            }
+        }
+        cell.data.set(data);
+        cell.sequence.store(pos + 1, Ordering::Release);
+        self.read_sem.post();
+        true
+    }
+
+    fn try_pop(&self) -> Option<c_ulong> {
+        let mut cell;
+        let mut pos = self.dequeue_pos.load(Ordering::Relaxed);
+        loop {
+            cell = &self.buffer[pos & self.buffer_mask];
+            let seq = cell.sequence.load(Ordering::Acquire);
+            let diff = seq as isize - (pos + 1) as isize;
+            if diff == 0 {
+                if self
+                    .dequeue_pos
+                    .compare_exchange_weak(pos, pos + 1, Ordering::Relaxed, Ordering::Relaxed)
+                    .is_ok()
+                {
+                    break;
+                }
+            } else if diff < 0 {
+                return None;
+            } else {
+                pos = self.dequeue_pos.load(Ordering::Relaxed);
+            }
+        }
+
+        let data = cell.data.get();
+        cell.sequence
+            .store(pos + self.buffer_mask + 1, Ordering::Release);
+        self.write_sem.post();
+
+        #[cfg(feature = "simulation")]
+        std::thread::sleep(std::time::Duration::from_millis(100));
+
+        Some(data)
+    }
+
+    pub fn push(&self, data: c_ulong) {
+        loop {
+            if self.try_push(data) {
+                return;
+            }
+            self.write_sem.wait();
+        }
+    }
+
+    pub fn pop(&self) -> c_ulong {
+        loop {
+            if let Some(data) = self.gc_guard.acquire_as_consumer(|| self.try_pop()) {
+                return data;
+            }
+            self.read_sem.wait();
+            // self.read_sem
+                // .wait_for(std::time::Duration::from_millis(100));
+        }
+    }
+
+    pub fn acquire_as_gc<F, T>(&self, f: F) -> T
+    where
+        F: FnOnce() -> T,
+    {
+        self.gc_guard.acquire_as_gc(f)
+    }
+
+    fn foreach<F>(&self, f: F)
+    where
+        F: Fn(c_ulong),
+    {
+        for item in self.buffer.iter() {
+            let value = item.data.get();
+            f(value);
+        }
+    }
+
+    fn mark(&self, mark: extern "C" fn(c_ulong)) {
+        self.acquire_as_gc(|| {
+            self.foreach(|item| {
+                mark(item);
+            });
+        });
+    }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn mpmc_queue_alloc(q: *mut MpmcQueue) {
+    unsafe { q.write(MpmcQueue::alloc()) }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn mpmc_queue_init(q: *mut MpmcQueue, capacity: usize, default: c_ulong) {
+    let q = unsafe { q.as_mut().unwrap() };
+    q.init(capacity, default);
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn mpmc_queue_drop(q: *mut MpmcQueue) {
+    unsafe { std::ptr::drop_in_place(q) };
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn mpmc_queue_mark(q: *const MpmcQueue, f: extern "C" fn(c_ulong)) {
+    let q = unsafe { q.as_ref().unwrap() };
+    q.mark(f);
+}
+
+#[repr(C)]
+pub struct MpmcQueuePushPayload {
+    queue: *mut MpmcQueue,
+    item: c_ulong,
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn mpmc_queue_push(
+    push_paylod: *mut std::ffi::c_void,
+) -> *mut std::ffi::c_void {
+    let push_payload = unsafe { push_paylod.cast::<MpmcQueuePushPayload>().as_ref().unwrap() };
+    let q = unsafe { push_payload.queue.as_ref().unwrap() };
+    q.push(push_payload.item);
+    return std::ptr::null_mut();
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn mpmc_queue_pop(q: *mut std::ffi::c_void) -> *mut std::ffi::c_void {
+    let q = unsafe { q.cast::<MpmcQueue>().as_ref().unwrap() };
+    let item = q.pop();
+    unsafe { std::mem::transmute(item) }
+}
+
+pub const MPMC_QUEUE_OBJECT_SIZE: usize = 80;
+
+#[test]
+fn test_mpmc_queue_size() {
+    assert_eq!(
+        MPMC_QUEUE_OBJECT_SIZE,
+        std::mem::size_of::<MpmcQueue>(),
+        "size mismatch"
+    );
+
+    assert!(crate::is_sync_and_send::<MpmcQueue>());
+}

data/rs/src/sem.rs

@@ -0,0 +1,75 @@
+use std::time::Duration;
+
+use libc::{
+    CLOCK_REALTIME, clock_gettime, sem_destroy, sem_init, sem_post, sem_t, sem_wait,
+};
+
+pub(crate) struct Semaphore {
+    inner: *mut sem_t,
+}
+
+impl Semaphore {
+    pub(crate) fn alloc() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+
+    pub(crate) fn init(&mut self, initial: u32) {
+        let ptr = Box::into_raw(Box::new(unsafe { std::mem::zeroed() }));
+
+        let res = unsafe { sem_init(ptr, 0, initial) };
+        if res != 0 {
+            panic!(
+                "failed to create semaphore: {:?}",
+                std::io::Error::last_os_error()
+            )
+        }
+
+        self.inner = ptr;
+    }
+
+    pub(crate) fn post(&self) {
+        let res = unsafe { sem_post(self.inner) };
+        if res != 0 {
+            panic!(
+                "failed to post to semaphore: {:?}",
+                std::io::Error::last_os_error()
+            )
+        }
+    }
+
+    pub(crate) fn wait(&self) {
+        let res = unsafe { sem_wait(self.inner) };
+        if res != 0 {
+            panic!(
+                "failed to wait for semaphore: {:?}",
+                std::io::Error::last_os_error()
+            )
+        }
+    }
+
+    // pub(crate) fn wait_for(&self, duration: Duration) -> bool {
+    //     let mut abstime = unsafe { std::mem::zeroed() };
+    //     let res = unsafe { clock_gettime(CLOCK_REALTIME, &mut abstime) };
+    //     if res != 0 {
+    //         panic!(
+    //             "failed to call clock_gettime: {:?}",
+    //             std::io::Error::last_os_error()
+    //         );
+    //     }
+    //     abstime.tv_nsec += duration.as_nanos() as i64;
+    //     let res = unsafe { sem_timedwait(self.inner, &abstime) };
+    //     res != -1
+    // }
+}
+
+impl Drop for Semaphore {
+    fn drop(&mut self) {
+        unsafe {
+            sem_destroy(self.inner);
+            drop(Box::from_raw(self.inner));
+        }
+    }
+}
+
+unsafe impl Send for Semaphore {}
+unsafe impl Sync for Semaphore {}

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: ratomic
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mike Perham
+bindir: bin
+cert_chain: []
+date: 2025-03-22 00:00:00.000000000 Z
+dependencies: []
+description: Mutable data structures for Ractors
+email:
+- mike@perham.net
+executables: []
+extensions:
+- ext/ratomic/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/ratomic/counter.h
+- ext/ratomic/extconf.rb
+- ext/ratomic/fixed-size-object-pool.h
+- ext/ratomic/hashmap.h
+- ext/ratomic/mpmc-queue.h
+- ext/ratomic/ratomic.c
+- lib/ratomic.rb
+- lib/ratomic/ratomic.bundle
+- lib/ratomic/version.rb
+- ratomic.gemspec
+- rs/Cargo.lock
+- rs/Cargo.toml
+- rs/cbindgen.toml
+- rs/rust-atomics.h
+- rs/src/bin/mpmc_queue.rs
+- rs/src/counter.rs
+- rs/src/fixed_size_object_pool.rs
+- rs/src/gc_guard.rs
+- rs/src/hashmap.rs
+- rs/src/lib.rs
+- rs/src/mpmc_queue.rs
+- rs/src/sem.rs
+homepage: https://github.com/mperham/ratomic
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/mperham/ratomic
+  source_code_uri: https://github.com/mperham/ratomic
+  changelog_uri: https://github.com/mperham/ratomic
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Mutable data structures for Ractors
+test_files: []