ratomic 0.1.0 → 0.2.0

data/rs/src/counter.rs

@@ -1,57 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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/hashmap.rs

@@ -1,129 +0,0 @@
-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

@@ -1,23 +0,0 @@
-#![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
-}

data/rs/src/mpmc_queue.rs

@@ -1,231 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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 {}