ratomic 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 997065e8a812fe84d836e06402ba1250d54116a251aa220cc255799f41c1da57
+  data.tar.gz: c0b6ea1afbf4d04b4638150a63063ad63e54d52aa0ee4ef4a6816d3240ec74a1
+SHA512:
+  metadata.gz: a085aa02d2ff513781b1ef44d89505f9bc397c254840126d3d8a2560b6c293257ff43b49c0c96450c915c1494d440e6272b6efb704a2477a0d1a60fd1ca6cd55
+  data.tar.gz: 92439604f4f93a306d6b672db005f1864d1afad8c9c5cd8b7e64dfb045c941ea576e6b45802647d5c32618db1e461715a8e27f7246028acfa5438c621624b331

data/ext/ratomic/counter.h

@@ -0,0 +1,45 @@
+#include "rust-atomics.h"
+#include <ruby.h>
+
+const rb_data_type_t atomic_counter_data = {
+    .function = {.dfree = RUBY_DEFAULT_FREE},
+    .flags = RUBY_TYPED_FROZEN_SHAREABLE};
+
+VALUE rb_atomic_counter_alloc(VALUE klass) {
+  atomic_counter_t *counter;
+  TypedData_Make_Struct0(obj, klass, atomic_counter_t, ATOMIC_COUNTER_SIZE,
+                         &atomic_counter_data, counter);
+  atomic_counter_init(counter, 0);
+  VALUE rb_cRactor = rb_const_get(rb_cObject, rb_intern("Ractor"));
+  rb_funcall(rb_cRactor, rb_intern("make_shareable"), 1, obj);
+  return obj;
+}
+
+VALUE rb_atomic_counter_increment(VALUE self, VALUE amt) {
+  atomic_counter_t *counter;
+  TypedData_Get_Struct(self, atomic_counter_t, &atomic_counter_data, counter);
+  atomic_counter_increment(counter, FIX2LONG(amt));
+  return Qnil;
+}
+
+VALUE rb_atomic_counter_decrement(VALUE self, VALUE amt) {
+  atomic_counter_t *counter;
+  TypedData_Get_Struct(self, atomic_counter_t, &atomic_counter_data, counter);
+  atomic_counter_decrement(counter, FIX2LONG(amt));
+  return Qnil;
+}
+
+VALUE rb_atomic_counter_read(VALUE self) {
+  atomic_counter_t *counter;
+  TypedData_Get_Struct(self, atomic_counter_t, &atomic_counter_data, counter);
+  return LONG2FIX(atomic_counter_read(counter));
+}
+
+static void init_counter(VALUE rb_mRoot) {
+  VALUE rb_cAtomicCounter =
+      rb_define_class_under(rb_mRoot, "Counter", rb_cObject);
+  rb_define_alloc_func(rb_cAtomicCounter, rb_atomic_counter_alloc);
+  rb_define_method(rb_cAtomicCounter, "increment", rb_atomic_counter_increment, 1);
+  rb_define_method(rb_cAtomicCounter, "decrement", rb_atomic_counter_decrement, 1);
+  rb_define_method(rb_cAtomicCounter, "read", rb_atomic_counter_read, 0);
+}

data/ext/ratomic/extconf.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+# Makes all symbols private by default to avoid unintended conflict
+# with other gems. To explicitly export symbols you can use RUBY_FUNC_EXPORTED
+# selectively, or entirely remove this flag.
+append_cflags("-fvisibility=hidden")
+
+rust_atomics_path = File.expand_path("../../../rs", __FILE__)
+# rubocop:disable Style/GlobalVars
+$INCFLAGS << " -I#{rust_atomics_path}"
+$LDFLAGS << " -L#{rust_atomics_path}/target/release -lrust_atomics"
+# rubocop:enable Style/GlobalVars
+
+create_makefile("ratomic/ratomic")

data/ext/ratomic/fixed-size-object-pool.h

@@ -0,0 +1,76 @@
+#include "rust-atomics.h"
+#include <ruby.h>
+
+void rb_fixed_size_object_pool_mark(void *);
+void rb_fixed_size_object_pool_free(void *);
+
+const rb_data_type_t fixed_size_object_pool_data = {
+    .function = {.dfree = rb_fixed_size_object_pool_free,
+                 .dmark = rb_fixed_size_object_pool_mark},
+    .flags = RUBY_TYPED_FROZEN_SHAREABLE};
+
+void rb_fixed_size_object_pool_free(void *ptr) {
+  fixed_size_object_pool_t *pool = ptr;
+  fixed_size_object_pool_drop(pool);
+}
+
+void rb_fixed_size_object_pool_mark(void *ptr) {
+  fixed_size_object_pool_t *pool = ptr;
+  fixed_size_object_pool_mark(pool, rb_gc_mark);
+}
+
+VALUE rb_fixed_size_object_pool_alloc(VALUE klass) {
+  fixed_size_object_pool_t *pool;
+  TypedData_Make_Struct0(obj, klass, fixed_size_object_pool_t,
+                         FIXED_SIZE_OBJECT_POOL_SIZE,
+                         &fixed_size_object_pool_data, pool);
+  fixed_size_object_pool_alloc(pool);
+  VALUE rb_cRactor = rb_const_get(rb_cObject, rb_intern("Ractor"));
+  rb_funcall(rb_cRactor, rb_intern("make_shareable"), 1, obj);
+  return obj;
+}
+
+VALUE rb_fixed_size_object_pool_initialize(VALUE self, VALUE size,
+                                           VALUE timeout_in_ms) {
+  fixed_size_object_pool_t *pool;
+  TypedData_Get_Struct(self, fixed_size_object_pool_t,
+                       &fixed_size_object_pool_data, pool);
+  fixed_size_object_pool_init(pool, FIX2LONG(size), FIX2LONG(timeout_in_ms),
+                              rb_yield);
+  return Qnil;
+}
+
+VALUE rb_fixed_size_object_pool_checkout(VALUE self) {
+  fixed_size_object_pool_t *pool;
+  TypedData_Get_Struct(self, fixed_size_object_pool_t,
+                       &fixed_size_object_pool_data, pool);
+  PooledItem pooled = fixed_size_object_pool_checkout(pool);
+  if (pooled.idx == 0 && pooled.rbobj == 0) {
+    return Qnil;
+  }
+  VALUE ary = rb_ary_new_capa(2);
+  rb_ary_push(ary, pooled.rbobj);
+  rb_ary_push(ary, LONG2FIX(pooled.idx));
+  return ary;
+}
+
+VALUE rb_fixed_size_object_pool_checkin(VALUE self, VALUE idx) {
+  fixed_size_object_pool_t *pool;
+  TypedData_Get_Struct(self, fixed_size_object_pool_t,
+                       &fixed_size_object_pool_data, pool);
+  fixed_size_object_pool_checkin(pool, FIX2LONG(idx));
+  return Qnil;
+}
+
+static void init_fixed_size_object_pool(VALUE rb_mRoot) {
+  VALUE rb_cFixedSizeObjectPool =
+      rb_define_class_under(rb_mRoot, "FixedSizeObjectPool", rb_cObject);
+  rb_define_alloc_func(rb_cFixedSizeObjectPool,
+                       rb_fixed_size_object_pool_alloc);
+  rb_define_method(rb_cFixedSizeObjectPool, "initialize",
+                   rb_fixed_size_object_pool_initialize, 2);
+  rb_define_method(rb_cFixedSizeObjectPool, "checkout",
+                   rb_fixed_size_object_pool_checkout, 0);
+  rb_define_method(rb_cFixedSizeObjectPool, "checkin",
+                   rb_fixed_size_object_pool_checkin, 1);
+}

data/ext/ratomic/hashmap.h

@@ -0,0 +1,74 @@
+#include "rust-atomics.h"
+#include <ruby.h>
+
+void rb_concurrent_hash_map_mark(void *);
+void rb_concurrent_hash_map_free(void *);
+
+const rb_data_type_t concurrent_hash_map_data = {
+    .function = {.dfree = rb_concurrent_hash_map_free,
+                 .dmark = rb_concurrent_hash_map_mark},
+    .flags = RUBY_TYPED_FROZEN_SHAREABLE};
+
+void rb_concurrent_hash_map_free(void *ptr) {
+  concurrent_hash_map_t *hashmap = ptr;
+  concurrent_hash_map_drop(hashmap);
+}
+
+void rb_concurrent_hash_map_mark(void *ptr) {
+  concurrent_hash_map_t *hashmap = ptr;
+  concurrent_hash_map_mark(hashmap, rb_gc_mark);
+}
+
+VALUE rb_concurrent_hash_map_alloc(VALUE klass) {
+  concurrent_hash_map_t *hashmap;
+  TypedData_Make_Struct0(obj, klass, concurrent_hash_map_t,
+                         CONCURRENT_HASH_MAP_SIZE, &concurrent_hash_map_data,
+                         hashmap);
+  concurrent_hash_map_init(hashmap);
+  VALUE rb_cRactor = rb_const_get(rb_cObject, rb_intern("Ractor"));
+  rb_funcall(rb_cRactor, rb_intern("make_shareable"), 1, obj);
+  return obj;
+}
+
+VALUE rb_concurrent_hash_map_get(VALUE self, VALUE key) {
+  concurrent_hash_map_t *hashmap;
+  TypedData_Get_Struct(self, concurrent_hash_map_t, &concurrent_hash_map_data,
+                       hashmap);
+  return concurrent_hash_map_get(hashmap, key, Qnil);
+}
+
+VALUE rb_concurrent_hash_map_set(VALUE self, VALUE key, VALUE value) {
+  concurrent_hash_map_t *hashmap;
+  TypedData_Get_Struct(self, concurrent_hash_map_t, &concurrent_hash_map_data,
+                       hashmap);
+  concurrent_hash_map_set(hashmap, key, value);
+  return Qnil;
+}
+
+VALUE rb_concurrent_hash_map_clear(VALUE self) {
+  concurrent_hash_map_t *hashmap;
+  TypedData_Get_Struct(self, concurrent_hash_map_t, &concurrent_hash_map_data,
+                       hashmap);
+  concurrent_hash_map_clear(hashmap);
+  return Qnil;
+}
+
+VALUE rb_concurrent_hash_map_fetch_and_modify(VALUE self, VALUE key) {
+  rb_need_block();
+  concurrent_hash_map_t *hashmap;
+  TypedData_Get_Struct(self, concurrent_hash_map_t, &concurrent_hash_map_data,
+                       hashmap);
+  concurrent_hash_map_fetch_and_modify(hashmap, key, rb_yield);
+  return Qnil;
+}
+
+static void init_hashmap(VALUE rb_mRoot) {
+  VALUE rb_cConcurrentHashMap =
+      rb_define_class_under(rb_mRoot, "ConcurrentHashMap", rb_cObject);
+  rb_define_alloc_func(rb_cConcurrentHashMap, rb_concurrent_hash_map_alloc);
+  rb_define_method(rb_cConcurrentHashMap, "get", rb_concurrent_hash_map_get, 1);
+  rb_define_method(rb_cConcurrentHashMap, "set", rb_concurrent_hash_map_set, 2);
+  rb_define_method(rb_cConcurrentHashMap, "clear", rb_concurrent_hash_map_clear, 0);
+  rb_define_method(rb_cConcurrentHashMap, "fetch_and_modify",
+                   rb_concurrent_hash_map_fetch_and_modify, 1);
+}

data/ext/ratomic/mpmc-queue.h

@@ -0,0 +1,68 @@
+#include "rust-atomics.h"
+#include <ruby.h>
+#include <ruby/thread.h>
+
+void rb_mpmc_queue_mark(void *);
+void rb_mpmc_queue_free(void *);
+
+const rb_data_type_t mpmc_queue_data = {
+    .function = {.dfree = rb_mpmc_queue_free, .dmark = rb_mpmc_queue_mark},
+    .flags = RUBY_TYPED_FROZEN_SHAREABLE};
+
+void rb_mpmc_queue_free(void *ptr) {
+  mpmc_queue_t *queue = ptr;
+  mpmc_queue_drop(queue);
+}
+
+void rb_mpmc_queue_mark(void *ptr) {
+  mpmc_queue_t *queue = ptr;
+  mpmc_queue_mark(queue, rb_gc_mark);
+}
+
+VALUE rb_mpmc_queue_alloc(VALUE klass) {
+  mpmc_queue_t *queue;
+  TypedData_Make_Struct0(obj, klass, mpmc_queue_t, MPMC_QUEUE_OBJECT_SIZE,
+                         &mpmc_queue_data, queue);
+  mpmc_queue_alloc(queue);
+  VALUE rb_cRactor = rb_const_get(rb_cObject, rb_intern("Ractor"));
+  rb_funcall(rb_cRactor, rb_intern("make_shareable"), 1, obj);
+  return obj;
+}
+
+VALUE rb_mpmc_queue_initialize(VALUE self, VALUE cap) {
+  mpmc_queue_t *queue;
+  TypedData_Get_Struct(self, mpmc_queue_t, &mpmc_queue_data, queue);
+  mpmc_queue_init(queue, FIX2LONG(cap), Qnil);
+  return Qnil;
+}
+
+typedef struct {
+  mpmc_queue_t *queue;
+  VALUE value;
+} push_payload_t;
+
+VALUE rb_mpmc_queue_push(VALUE self, VALUE value) {
+  mpmc_queue_t *queue;
+  TypedData_Get_Struct(self, mpmc_queue_t, &mpmc_queue_data, queue);
+  push_payload_t push_payload = {.queue = queue, .value = value};
+  rb_thread_call_without_gvl(mpmc_queue_push, &push_payload, NULL, NULL);
+  return Qtrue;
+}
+
+VALUE rb_mpmc_queue_pop(VALUE self) {
+  mpmc_queue_t *queue;
+  TypedData_Get_Struct(self, mpmc_queue_t, &mpmc_queue_data, queue);
+  void *ptr = rb_thread_call_without_gvl(mpmc_queue_pop, queue, NULL, NULL);
+  VALUE item = (VALUE)ptr;
+  return item;
+}
+
+static void init_mpmc_queue(VALUE rb_mRoot) {
+  VALUE rb_cMpmcQueue =
+      rb_define_class_under(rb_mRoot, "Queue", rb_cObject);
+  rb_define_alloc_func(rb_cMpmcQueue, rb_mpmc_queue_alloc);
+
+  rb_define_method(rb_cMpmcQueue, "initialize", rb_mpmc_queue_initialize, 1);
+  rb_define_method(rb_cMpmcQueue, "push", rb_mpmc_queue_push, 1);
+  rb_define_method(rb_cMpmcQueue, "pop", rb_mpmc_queue_pop, 0);
+}

data/ext/ratomic/ratomic.c

@@ -0,0 +1,16 @@
+#include "counter.h"
+#include "fixed-size-object-pool.h"
+#include "hashmap.h"
+#include "mpmc-queue.h"
+#include <ruby.h>
+
+RUBY_FUNC_EXPORTED void Init_ratomic(void) {
+  rb_ext_ractor_safe(true);
+
+  VALUE rb_mRoot = rb_define_module("Ratomic");
+
+  init_counter(rb_mRoot);
+  init_hashmap(rb_mRoot);
+  init_fixed_size_object_pool(rb_mRoot);
+  init_mpmc_queue(rb_mRoot);
+}

data/lib/ratomic/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ratomic
+  VERSION = "0.1.0"
+end

data/lib/ratomic.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "ratomic/version"
+require_relative "ratomic/ratomic"
+
+module Ratomic
+  class Error < StandardError; end
+
+  ##
+  # An atomic counter which can be incremented and decremented
+  # safely by multiple Ractors concurrently.
+  class Counter
+    def value
+      read
+    end
+
+    def inc(amt = 1)
+      raise ArgumentError, "amount must be positive: #{amt}" if amt < 0
+      increment(amt)
+    end
+
+    def dec(amt = 1)
+      raise ArgumentError, "amount must be positive: #{amt}" if amt < 0
+      decrement(amt)
+    end
+  end
+
+  class Undefined
+    def inspect
+      "#<Undefined>"
+    end
+  end
+  UNDEFINED = Ractor.make_shareable(Undefined.new)
+
+  class Pool < FixedSizeObjectPool
+    def initialize(size = 5, timeout = 1.0)
+      super(size, (timeout * 1000).to_i)
+    end
+
+    def with
+      obj_and_idx = checkout
+      if obj_and_idx.nil?
+        raise Ratomic::Error, "pool checkout timeout"
+      else
+        yield obj_and_idx[0]
+      end
+    ensure
+      unless obj_and_idx.nil?
+        checkin(obj_and_idx[1])
+      end
+    end
+  end
+
+  class Map < ConcurrentHashMap
+    def []=(key, value)
+      set(key, value)
+    end
+
+    def [](key)
+      get(key)
+    end
+
+    # TODO add as much of the Hash API as possible.
+    # Stretch goal? Support Enumerable if DashMap can safely
+    # iterate.
+  end
+
+end

data/ratomic.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lib/ratomic/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ratomic"
+  spec.version = Ratomic::VERSION
+  spec.authors = ["Mike Perham"]
+  spec.email = ["mike@perham.net"]
+
+  spec.summary = "Mutable data structures for Ractors"
+  spec.description = spec.summary
+  spec.homepage = "https://github.com/mperham/ratomic"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.4.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/mperham/ratomic"
+  spec.metadata["changelog_uri"] = "https://github.com/mperham/ratomic"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  gemspec = File.basename(__FILE__)
+  spec.files = IO.popen(%w[git ls-files -z], chdir: __dir__, err: IO::NULL) do |ls|
+    ls.readlines("\x0", chomp: true).select do |f|
+      (f == gemspec) || f.start_with?(*%w[lib/ ext/ rs/])
+    end
+  end
+  %w(lib/ratomic/ratomic.bundle lib/ratomic/ratomic.so).each do |file|
+    File.exist?(file) && spec.files << file
+  end
+  spec.require_paths = ["lib"]
+  spec.extensions = ["ext/ratomic/extconf.rb"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/rs/Cargo.lock

@@ -0,0 +1,196 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+
+[[package]]
+name = "bitflags"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06ba6d68e24814cb8de6bb986db8222d3a027d15872cabc0d18817bc3c0e4471"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "dashmap"
+version = "6.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+ "hashbrown",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
+[[package]]
+name = "libc"
+version = "0.2.171"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
+
+[[package]]
+name = "lock_api"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d75b0bedcc4fe52caa0e03d9f1151a323e4aa5e2d78ba3580400cd3c9e2bc4bc"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-targets",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b8c0c260b63a8219631167be35e6a988e9554dbd323f8bd08439c8ed1302bd1"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "rust-atomics"
+version = "0.1.0"
+dependencies = [
+ "crossbeam-channel",
+ "dashmap",
+ "libc",
+ "parking_lot",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "smallvec"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"

data/rs/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "rust-atomics"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["lib", "staticlib"]
+
+[features]
+simulation = []
+
+[dependencies]
+crossbeam-channel = "0.5.14"
+dashmap = "6.1.0"
+parking_lot = "0.12.3"
+libc = "0.2.170"
+
+[profile.release]
+panic = "abort"
+lto = true
+codegen-units = 1
+
+[[bin]]
+bench = false
+name = "mpmc_queue"
+test = false

data/rs/cbindgen.toml

@@ -0,0 +1,12 @@
+language = "c"
+include_guard = "RUST_ATOMICS_H"
+style = "type"
+
+[export.rename]
+"AtomicCounter" = "atomic_counter_t"
+"ConcurrentHashMap" = "concurrent_hash_map_t"
+"FixedSizeObjectPool" = "fixed_size_object_pool_t"
+"MpmcQueue" = "mpmc_queue_t"
+
+[export]
+include = ["QueuePushArg"]