arbiter_machines 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 631441a58f585ccf0a154daffdc7791851adbc9705f49eb5a9693a6fc7e11532
+  data.tar.gz: 0ca24642601f50c6692a6d6afd22ff1aecbbf73cf4b9111e21c576a2be1920be
+SHA512:
+  metadata.gz: d7047d5fcdb4ae35ee82c5202deca7c654d3dcf2d2b5caa4d3fd6429a619cb816e67b836bbed6cf4f65560673c366885f7ecce449c584a185ede1274853403f2
+  data.tar.gz: 62d9c925acb317f45209402825cfeb1a646cea095e65ef2c68336cd1745711d2f16f3ef005fa3a66623dbbef2470bc0c62d684716a90f5374c568957ac01d9f9

data/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+## [0.1.5](https://github.com/seuros/arbiter_machines/compare/arbiter_machines/v0.1.4...arbiter_machines/v0.1.5) (2026-11-06)
+
+
+### Bug Fixes
+
+* share RArray count conversion in arbiter ffi ([0a026aa](https://github.com/seuros/arbiter_machines/commit/0a026aac2e17efecc2546bb8b9532b89f516e7f0))
+
+## [0.1.4](https://github.com/seuros/arbiter_machines/compare/arbiter_machines/v0.1.3...arbiter_machines/v0.1.4) (2026-11-06)
+
+
+### Bug Fixes
+
+* crates.io keywords and categories for the core ([10c8cad](https://github.com/seuros/arbiter_machines/commit/10c8cad0f35cb6c44dbe0e5573275f2267afc306))
+
+## [0.1.3](https://github.com/seuros/arbiter_machines/compare/arbiter_machines/v0.1.2...arbiter_machines/v0.1.3) (2026-11-06)
+
+
+### Bug Fixes
+
+* keep test sources out of the packaged gem and crate ([513f507](https://github.com/seuros/arbiter_machines/commit/513f5074a2058f23742ee47b2289cd8b8872d6d3))
+
+## [0.1.2](https://github.com/seuros/arbiter_machines/compare/arbiter_machines/v0.1.1...arbiter_machines/v0.1.2) (2026-11-06)
+
+
+### Bug Fixes
+
+* cross builds no longer compile for the host ([feeb4f0](https://github.com/seuros/arbiter_machines/commit/feeb4f09e5d0b20b81a3fffb35562594b80e2e0a))
+
+## [0.1.1](https://github.com/seuros/arbiter_machines/compare/arbiter_machines-v0.1.0...arbiter_machines/v0.1.1) (2026-11-06)
+
+
+### Features
+
+* initial extraction ([0ce828b](https://github.com/seuros/arbiter_machines/commit/0ce828bfacd5c9ef7482136b73d7be18339e19b9))

data/Cargo.toml

@@ -0,0 +1,21 @@
+[workspace]
+members = ["ext/arbiter_machines_native/core", "ext/arbiter_machines_native/ffi"]
+default-members = ["ext/arbiter_machines_native/core"]
+resolver = "3"
+[workspace.dependencies]
+arbiter-machines = { path = "ext/arbiter_machines_native/core" }
+magnus = { version = "0.9.3", default-features = false }
+rb-sys = { version = "0.9.130", default-features = false, features = ["stable-api-compiled-fallback"] }
+[workspace.package]
+edition = "2024"
+rust-version = "1.99"
+license = "MIT"
+[workspace.lints.rust]
+unsafe_code = "deny"
+unused_must_use = "warn"
+[workspace.lints.clippy]
+all = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+unwrap_used = "deny"
+expect_used = "deny"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abdelkader Boudih
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,221 @@
+# ArbiterMachines
+
+> When the slow job holds the key the urgent job needs, more workers won't help. 🛰️
+
+A priority arbiter for Ruby. You declare your tasks with their priorities and your resources with their ceilings. The `Arbiter` tells you who may take what, who has to wait, who just inherited someone else's urgency, and who is about to deadlock. Your code still takes and releases the actual locks. The arbiter only ever answers one question: is this a good idea right now?
+
+## Quick Start
+
+```bash
+gem 'arbiter_machines'
+```
+
+```ruby
+# Two tasks: a janitor at priority 1, a payment at priority 10.
+# One resource: the ledger lock, ceiling 10.
+arbiter = ArbiterMachines::Arbiter.new(
+  priorities: [1, 10],
+  ceilings: [10],
+  protocol: :inheritance
+)
+
+arbiter.acquire(task: 0, resource: 0)   # => [:granted, nil]   janitor takes the ledger
+arbiter.acquire(task: 1, resource: 0)   # => [:blocked, 0]     payment waits on resource 0
+arbiter.effective_priorities            # => [10, 10]          janitor now runs as urgent
+
+arbiter.release(task: 0, resource: 0)   # => true              janitor done, wait cleared
+arbiter.acquire(task: 1, resource: 0)   # => [:granted, nil]   payment retries and gets in
+```
+
+Tasks and resources are positional indices into the arrays you passed in. Larger number means more urgent.
+
+## A Message to the Resistance
+
+So you gave the nightly cleanup job priority 1, the payment processor priority 10, and a pile of report builders priority 5. Sensible. Then one night the cleanup job took the ledger lock for a quick vacuum, the payment job arrived and blocked on it, and twelve report builders showed up and ran. All of them. Before the cleanup job got another slice of CPU.
+
+The payment job, your most urgent work, sat behind priority-5 reports because a priority-1 job was holding its lock and nobody told the scheduler that the priority-1 job was suddenly very important.
+
+That's priority inversion. It put a rover on Mars into a reboot loop in 1997, and it's been quietly doing the same thing to job queues ever since. The fix has been known just as long: while the janitor holds something the payment job needs, the janitor *is* the payment job. It inherits the urgency, finishes fast, hands the lock over.
+
+This gem does the accounting for that. Who holds what, who waits on whom, what everybody's priority really is right now, and whether the next acquire closes a loop nobody can escape from.
+
+## Chapter 1: Stardate 2025.186, the AMS Dijkstra
+
+> **AMS Dijkstra**, NCC-4201, *Dijkstra*-class traffic-control vessel.
+> One airlock. Two waiting crews. No circular holding pattern.
+
+The vessel doesn't open airlocks. It keeps the chart: which crew is in which lock, which crew is waiting at which door, and which crew's urgency has been lent to the crew blocking it. Before any crew is cleared to wait, the chart is checked for a loop. A loop is never charted, because a charted loop is a ship nobody leaves.
+
+Somewhere on the bridge, a junior officer suggests:
+
+```ruby
+def process_payment
+  ledger_lock.synchronize do   # the janitor has this, and the janitor is slow
+    charge_card
+  end
+end
+```
+
+"That," says the traffic controller, "is how urgent work waits for the floor to be mopped."
+
+## The Flight Plan
+
+Every resource is either free or held. Every task is either running, holding, or waiting at exactly one door.
+
+```mermaid
+stateDiagram-v2
+    [*] --> free
+    free --> held: acquire, granted
+    held --> held: holder acquires again, already_owned
+    held --> held: other task acquires, blocked (holder inherits urgency)
+    held --> free: holder releases, waiters cleared to retry
+    held --> held: acquire would close a wait loop, deadlock (nothing changes)
+    free --> [*]
+```
+
+And the night the janitor held the ledger:
+
+```mermaid
+sequenceDiagram
+    participant J as Janitor (task 0, prio 1)
+    participant A as Arbiter
+    participant P as Payment (task 1, prio 10)
+
+    J->>A: acquire(task 0, resource 0)
+    A-->>J: granted
+    Note over J: starts vacuuming the ledger
+
+    P->>A: acquire(task 1, resource 0)
+    A-->>P: blocked on resource 0
+    Note over A: effective priorities now [10, 10]
+    Note over J: runs as priority 10, no report builder gets ahead
+
+    J->>A: release(task 0, resource 0)
+    A-->>J: true
+    Note over A: effective priorities back to [1, 10], wait cleared
+
+    P->>A: acquire(task 1, resource 0)
+    A-->>P: granted
+```
+
+## How Arbitration Works
+
+### Acquire
+
+`acquire` returns a two-element array: a status and, when blocked, the resource index you're waiting on.
+
+```ruby
+arbiter = ArbiterMachines::Arbiter.new(
+  priorities: [1, 5, 10], ceilings: [10, 10], protocol: :inheritance
+)
+
+arbiter.acquire(task: 0, resource: 0)   # => [:granted, nil]
+arbiter.acquire(task: 0, resource: 0)   # => [:already_owned, nil]
+arbiter.acquire(task: 1, resource: 1)   # => [:granted, nil]
+arbiter.acquire(task: 1, resource: 0)   # => [:blocked, 0]
+```
+
+Task 1 now holds resource 1 and is waiting on resource 0, which task 0 holds.
+
+### Inheritance is transitive
+
+Urgency flows up the chain. If a third task waits on task 1, task 1 gets its priority, and so does task 0 behind it.
+
+```ruby
+arbiter.acquire(task: 2, resource: 1)   # => [:blocked, 1]
+arbiter.effective_priorities            # => [10, 10, 10]
+```
+
+Task 2, priority 10, waits on task 1. Task 1 waits on task 0. Everybody in the chain runs at 10 until the chain clears.
+
+### Release and retry
+
+Releasing clears the waits on that resource. It does not hand the resource to anyone. The waiters call `acquire` again, and the arbiter decides fresh.
+
+```ruby
+arbiter.release(task: 0, resource: 0)   # => true
+arbiter.effective_priorities            # => [1, 10, 10]  task 1 still blocks task 2
+arbiter.acquire(task: 1, resource: 0)   # => [:granted, nil]
+```
+
+Release by a task that doesn't hold the resource returns `false` and changes nothing.
+
+### Stop waiting
+
+A task that gives up on a door calls `cancel_wait`. Its held resources stay held. Only the wait is dropped, and the urgency it was lending goes with it.
+
+```ruby
+arbiter = ArbiterMachines::Arbiter.new(
+  priorities: [1, 5, 10], ceilings: [10, 10], protocol: :inheritance
+)
+arbiter.acquire(task: 0, resource: 0)
+arbiter.acquire(task: 2, resource: 0)   # => [:blocked, 0]
+arbiter.effective_priorities            # => [10, 5, 10]
+
+arbiter.cancel_wait(task: 2)            # => true
+arbiter.effective_priorities            # => [1, 5, 10]
+```
+
+### Deadlock is refused, not reported after the fact
+
+Two tasks each holding what the other wants is a loop. The arbiter sees it before charting the second wait and returns `:deadlock`. Nothing about the current state changes, so you can back out cleanly.
+
+```ruby
+arbiter = ArbiterMachines::Arbiter.new(
+  priorities: [1, 5, 10], ceilings: [10, 10], protocol: :inheritance
+)
+arbiter.acquire(task: 0, resource: 0)
+arbiter.acquire(task: 1, resource: 1)
+arbiter.acquire(task: 0, resource: 1)   # => [:blocked, 1]
+arbiter.acquire(task: 1, resource: 0)   # => [:deadlock, nil]
+arbiter.effective_priorities            # => [1, 5, 10]  untouched
+
+arbiter.cancel_wait(task: 0)            # => true, task 0 backs off
+arbiter.acquire(task: 1, resource: 0)   # => [:blocked, 0]  now it's a plain wait
+```
+
+### The other protocol: immediate ceiling
+
+With `:immediate_ceiling`, a task jumps to the resource's ceiling the moment it takes the resource, before anyone has to wait. Nobody with a priority at or below the ceiling can get in behind it.
+
+```ruby
+arbiter = ArbiterMachines::Arbiter.new(
+  priorities: [1, 5, 10], ceilings: [8, 10], protocol: :immediate_ceiling
+)
+arbiter.acquire(task: 0, resource: 0)   # => [:granted, nil]
+arbiter.effective_priorities            # => [8, 5, 10]   task 0 raised to the ceiling
+arbiter.acquire(task: 1, resource: 1)   # => [:blocked, 0] priority 5 can't clear a ceiling of 8
+arbiter.acquire(task: 2, resource: 1)   # => [:granted, nil] priority 10 can
+```
+
+A ceiling has to be at least as high as every task that will ever take the resource. Task 2 at priority 10 asking for resource 0 with ceiling 8 is a misdeclaration, and the arbiter says so:
+
+```ruby
+arbiter.acquire(task: 2, resource: 0)   # => [:invalid, nil]
+```
+
+## The Rules of the Vessel
+
+- **Up to 8 tasks and 8 resources**, chosen independently by the lengths of `priorities:` and `ceilings:`. Empty or longer arrays raise `ArgumentError`.
+- **Priorities, ceilings, and indices are non-negative Integers** below `2**32`. Floats and strings raise `TypeError`, out-of-range raises `RangeError`.
+- **Out-of-range task or resource indices** in `acquire` return `[:invalid, nil]`. In `cancel_wait` they return `false`. Nothing raises for a bad index, only for a bad type.
+- **`effective_priorities` is a fresh Array** every call. Mutate it all you like, the arbiter doesn't care.
+- **Frozen means frozen.** `freeze` the arbiter and `acquire`, `release`, and `cancel_wait` raise `FrozenError`. Reads still work.
+- **Ceilings are always required**, even under `:inheritance`, where they're not consulted.
+
+## What You Think You're Doing vs Reality
+
+### You Think: "Priority 10 means it runs first."
+### Reality: Priority 10 means it waits first, behind whoever holds its lock.
+
+A priority is a promise about scheduling, not about locks. The moment a high-priority task blocks on a lock held by a low-priority one, every medium task in the system is effectively more urgent than your most urgent work. Inheritance is what makes the number mean something again.
+
+## What's Yours
+
+The arbiter never touches a mutex, a thread, or a scheduler. When it says `:granted`, you take the lock. When it says `:blocked`, you wait however you wait, then ask again after the holder releases. When it reports an effective priority, you're the one who has to tell your scheduler. Keep one arbiter per group of resources, and keep its calls serialized.
+
+## License
+
+MIT License. See [LICENSE.txt](LICENSE.txt) for details.
+
+**Remember: Nobody can hear the payment job scream while the janitor mops at priority 1.**

data/ext/arbiter_machines_native/core/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+## [0.2.2](https://github.com/seuros/arbiter_machines/compare/arbiter-machines-v0.2.1...arbiter-machines-v0.2.2) (2026-11-06)
+
+
+### Bug Fixes
+
+* crates.io keywords and categories for the core ([10c8cad](https://github.com/seuros/arbiter_machines/commit/10c8cad0f35cb6c44dbe0e5573275f2267afc306))
+
+## [0.2.1](https://github.com/seuros/arbiter_machines/compare/arbiter-machines-v0.2.0...arbiter-machines-v0.2.1) (2026-11-06)
+
+
+### Bug Fixes
+
+* keep test sources out of the packaged gem and crate ([513f507](https://github.com/seuros/arbiter_machines/commit/513f5074a2058f23742ee47b2289cd8b8872d6d3))
+
+## [0.2.0](https://github.com/seuros/arbiter_machines/compare/arbiter-machines-v0.1.0...arbiter-machines-v0.2.0) (2026-11-06)
+
+
+### Features
+
+* initial extraction ([0ce828b](https://github.com/seuros/arbiter_machines/commit/0ce828bfacd5c9ef7482136b73d7be18339e19b9))

data/ext/arbiter_machines_native/core/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "arbiter-machines"
+version = "0.2.2"
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+description = "Bounded ownership, priority inheritance, ceilings, and wait-cycle detection"
+readme = "README.md"
+exclude = ["src/**/tests.rs", "tests/"]
+keywords = ["priority-inheritance", "priority-ceiling", "deadlock", "arbitration", "no-std"]
+categories = ["no-std", "algorithms", "concurrency"]
+[lints]
+workspace = true

data/ext/arbiter_machines_native/core/README.md

@@ -0,0 +1,20 @@
+# arbiter-machines
+
+> **AMS Dijkstra**, NCC-4201, *Dijkstra*-class traffic-control vessel.
+
+Engine-room flight manual: coordinate airlock ownership without a circular wait.
+
+Allocation-free `no_std` ownership and wait-for decisions for fixed tasks/resources.
+Larger numeric priority means higher priority. One outstanding wait per task;
+nonrecursive ownership. Releases wake affected waiters to retry but never silently
+transfer ownership.
+
+Inheritance propagates priorities transitively to owners. Immediate-ceiling mode
+raises owners to held-resource ceilings and blocks acquisition unless effective
+priority exceeds every ceiling held by another task. Each configured resource
+ceiling must bound all tasks permitted to use it; requests exceeding it reject.
+The core detects prospective wait-for cycles before inserting a wait.
+
+These decisions require an executor honoring priorities and ownership. No OS
+priority manipulation, lock implementation, waiter-queue fairness, preemption
+driver, multi-resource atomic acquisition, or Ruby scheduling guarantee.

data/ext/arbiter_machines_native/core/src/lib.rs

@@ -0,0 +1,150 @@
+#![no_std]
+#![doc = include_str!("../README.md")]
+
+/// Resource priority protocol.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Protocol {
+    /// Transitive inheritance from blocked waiters.
+    Inheritance,
+    /// Immediate ceilings plus system-ceiling admission.
+    ImmediateCeiling,
+}
+/// Acquisition decision; no underlying lock is manipulated.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Acquisition {
+    /// Caller may acquire the resource.
+    Granted,
+    /// Caller owns it; recursion depth is not tracked.
+    AlreadyOwned,
+    /// Caller must wait on this blocking resource index.
+    Blocked(usize),
+    /// This wait would create a cycle; old state is retained.
+    Deadlock,
+    /// Invalid index or declared ceiling.
+    Invalid,
+}
+/// Fixed task/resource ownership and wait-for graph.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Arbiter<const T: usize, const R: usize> {
+    base: [u32; T],
+    ceilings: [u32; R],
+    protocol: Protocol,
+    owners: [Option<usize>; R],
+    waiting: [Option<usize>; T],
+}
+impl<const T: usize, const R: usize> Arbiter<T, R> {
+    /// Configure base priorities and resource ceilings.
+    #[must_use]
+    pub const fn new(base: [u32; T], ceilings: [u32; R], protocol: Protocol) -> Self {
+        Self {
+            base,
+            ceilings,
+            protocol,
+            owners: [None; R],
+            waiting: [None; T],
+        }
+    }
+    /// Acquire or record one wait; the caller enforces the decision.
+    #[must_use]
+    pub fn acquire(&mut self, task: usize, resource: usize) -> Acquisition {
+        if task >= T || resource >= R {
+            return Acquisition::Invalid;
+        }
+        if self.protocol == Protocol::ImmediateCeiling && self.base[task] > self.ceilings[resource]
+        {
+            return Acquisition::Invalid;
+        }
+        if self.owners[resource] == Some(task) {
+            return Acquisition::AlreadyOwned;
+        }
+        let blocker = if self.owners[resource].is_some() {
+            Some(resource)
+        } else if self.protocol == Protocol::ImmediateCeiling {
+            let effective = self.effective_priorities()[task];
+            self.owners
+                .iter()
+                .enumerate()
+                .find(|&(index, owner)| {
+                    owner.is_some_and(|owner| owner != task) && effective <= self.ceilings[index]
+                })
+                .map(|(index, _)| index)
+        } else {
+            None
+        };
+        let Some(blocker) = blocker else {
+            self.owners[resource] = Some(task);
+            self.waiting[task] = None;
+            return Acquisition::Granted;
+        };
+        let mut holder = self.owners[blocker];
+        for _ in 0..T {
+            let Some(owner) = holder else {
+                break;
+            };
+            if owner == task {
+                return Acquisition::Deadlock;
+            }
+            holder = self.waiting[owner].and_then(|resource| self.owners[resource]);
+        }
+        self.waiting[task] = Some(blocker);
+        Acquisition::Blocked(blocker)
+    }
+    /// Release owned state and clear affected waits for explicit retries.
+    #[must_use]
+    pub fn release(&mut self, task: usize, resource: usize) -> bool {
+        let Some(owner) = self.owners.get_mut(resource) else {
+            return false;
+        };
+        if *owner != Some(task) {
+            return false;
+        }
+        *owner = None;
+        for wait in &mut self.waiting {
+            if *wait == Some(resource) {
+                *wait = None;
+            }
+        }
+        true
+    }
+    /// Cancel a wait without releasing owned resources.
+    #[must_use]
+    pub fn cancel_wait(&mut self, task: usize) -> bool {
+        let Some(wait) = self.waiting.get_mut(task) else {
+            return false;
+        };
+        *wait = None;
+        true
+    }
+    /// Effective priorities for the runtime executor.
+    #[must_use]
+    pub fn effective_priorities(&self) -> [u32; T] {
+        let mut effective = self.base;
+        if self.protocol == Protocol::ImmediateCeiling {
+            for (resource, owner) in self.owners.iter().enumerate() {
+                if let Some(owner) = owner {
+                    effective[*owner] = effective[*owner].max(self.ceilings[resource]);
+                }
+            }
+        } else {
+            for _ in 0..T {
+                let mut changed = false;
+                for (task, resource) in self.waiting.iter().enumerate() {
+                    if let Some(owner) = resource.and_then(|resource| self.owners[resource])
+                        && effective[owner] < effective[task]
+                    {
+                        effective[owner] = effective[task];
+                        changed = true;
+                    }
+                }
+                if !changed {
+                    break;
+                }
+            }
+        }
+        effective
+    }
+}
+#[cfg(test)]
+mod tests;

data/ext/arbiter_machines_native/extconf.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'ffi/extconf'

data/ext/arbiter_machines_native/ffi/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "arbiter_machines_native"
+version = "0.1.3"
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+description = "Native Ruby bindings for bounded priority arbitration"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+test = false
+doctest = false
+
+[dependencies]
+arbiter-machines.workspace = true
+magnus.workspace = true
+rb-sys.workspace = true
+
+[lints]
+workspace = true

data/ext/arbiter_machines_native/ffi/extconf.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'pathname'
+require 'rb_sys/mkmf'
+
+create_rust_makefile('arbiter_machines_native/arbiter_machines_native') do |extension|
+  extension.ext_dir = Pathname(__dir__).relative_path_from(Pathname(Dir.pwd)).to_s
+  extension.profile = ENV.fetch('RB_SYS_CARGO_PROFILE', :release).to_sym
+end
+
+makefile = File.join(Dir.pwd, 'Makefile')
+File.write(makefile, File.read(makefile).gsub(
+  /^RB_SYS_CARGO_MANIFEST_DIR \?=.*$/,
+  "RB_SYS_CARGO_MANIFEST_DIR ?= #{File.expand_path(__dir__)}"
+))

data/ext/arbiter_machines_native/ffi/src/arbiter.rs

@@ -0,0 +1,182 @@
+//! Erase exact task/resource const-generic counts without adding participants.
+
+use crate::Count;
+use arbiter_machines::{Acquisition, Arbiter, Protocol};
+use magnus::{
+    Error, RArray, RHash, RModule, Ruby, Symbol, Value, function, method,
+    prelude::*,
+    scan_args::{get_kwargs, scan_args},
+    typed_data::Obj,
+};
+use std::cell::RefCell;
+
+trait Decisions: Send {
+    fn acquire(&mut self, task: usize, resource: usize) -> Acquisition;
+    fn release(&mut self, task: usize, resource: usize) -> bool;
+    fn cancel_wait(&mut self, task: usize) -> bool;
+    fn effective_priorities(&self) -> Vec<u32>;
+}
+
+impl<const T: usize, const R: usize> Decisions for Arbiter<T, R> {
+    fn acquire(&mut self, task: usize, resource: usize) -> Acquisition {
+        self.acquire(task, resource)
+    }
+    fn release(&mut self, task: usize, resource: usize) -> bool {
+        self.release(task, resource)
+    }
+    fn cancel_wait(&mut self, task: usize) -> bool {
+        self.cancel_wait(task)
+    }
+    fn effective_priorities(&self) -> Vec<u32> {
+        self.effective_priorities().to_vec()
+    }
+}
+
+fn resources<const T: usize>(
+    ruby: &Ruby,
+    base: [u32; T],
+    ceilings: &[u32],
+    protocol: Protocol,
+) -> Result<Box<dyn Decisions>, Error> {
+    macro_rules! sized {
+        ($($n:literal),*) => {
+            match ceilings.len() {
+                $($n => Ok(Box::new(Arbiter::<T, $n>::new(
+                    base,
+                    std::array::from_fn(|i| ceilings[i]),
+                    protocol,
+                )) as Box<dyn Decisions>),)*
+                _ => Err(Error::new(ruby.exception_arg_error(), "resource count must be 1..8")),
+            }
+        };
+    }
+    sized!(1, 2, 3, 4, 5, 6, 7, 8)
+}
+
+/// Every element of `array` as a non-negative `Integer` count.
+fn counts(array: RArray) -> Result<Vec<u32>, Error> {
+    array
+        .into_iter()
+        .map(|v| Count::try_convert(v).map(|v| v.0))
+        .collect()
+}
+
+#[magnus::wrap(class = "ArbiterMachines::Arbiter", free_immediately, size)]
+struct Wrapper {
+    core: RefCell<Box<dyn Decisions>>,
+    tasks: usize,
+    resources: usize,
+}
+
+impl Wrapper {
+    fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
+        let args = scan_args::<(), (), (), (), RHash, ()>(args)?;
+        let (priorities, ceilings, protocol) = get_kwargs::<_, (RArray, RArray, Symbol), (), ()>(
+            args.keywords,
+            &["priorities", "ceilings", "protocol"],
+            &[],
+        )?
+        .required;
+        let protocol = match protocol.name()?.as_ref() {
+            "inheritance" => Protocol::Inheritance,
+            "immediate_ceiling" => Protocol::ImmediateCeiling,
+            _ => {
+                return Err(Error::new(
+                    ruby.exception_arg_error(),
+                    "protocol must be :inheritance or :immediate_ceiling",
+                ));
+            }
+        };
+        let base = counts(priorities)?;
+        let ceilings = counts(ceilings)?;
+        macro_rules! sized {
+            ($($n:literal),*) => {
+                match base.len() {
+                    $($n => resources::<$n>(
+                        ruby,
+                        std::array::from_fn(|i| base[i]),
+                        &ceilings,
+                        protocol,
+                    )?,)*
+                    _ => {
+                        let message = "task count must be 1..8";
+                        return Err(Error::new(ruby.exception_arg_error(), message));
+                    }
+                }
+            };
+        }
+        let core = sized!(1, 2, 3, 4, 5, 6, 7, 8);
+        Ok(Self {
+            core: RefCell::new(core),
+            tasks: base.len(),
+            resources: ceilings.len(),
+        })
+    }
+
+    fn indices(args: &[Value]) -> Result<(usize, usize), Error> {
+        let args = scan_args::<(), (), (), (), RHash, ()>(args)?;
+        let (task, resource) =
+            get_kwargs::<_, (Count, Count), (), ()>(args.keywords, &["task", "resource"], &[])?
+                .required;
+        Ok((task.0 as usize, resource.0 as usize))
+    }
+
+    fn acquire(
+        ruby: &Ruby,
+        rb_self: Obj<Self>,
+        args: &[Value],
+    ) -> Result<(Symbol, Option<usize>), Error> {
+        rb_self.check_frozen()?;
+        let (task, resource) = Self::indices(args)?;
+        let decision = rb_self.core.borrow_mut().acquire(task, resource);
+        let (status, blocker) = match decision {
+            Acquisition::Granted => ("granted", None),
+            Acquisition::AlreadyOwned => ("already_owned", None),
+            Acquisition::Blocked(index) => ("blocked", Some(index)),
+            Acquisition::Deadlock => ("deadlock", None),
+            _ => ("invalid", None),
+        };
+        // Ruby allocation only after the RefCell borrow has ended.
+        Ok((ruby.to_symbol(status), blocker))
+    }
+
+    fn release(rb_self: Obj<Self>, args: &[Value]) -> Result<bool, Error> {
+        rb_self.check_frozen()?;
+        let (task, resource) = Self::indices(args)?;
+        let released = rb_self.core.borrow_mut().release(task, resource);
+        Ok(released)
+    }
+
+    fn cancel_wait(rb_self: Obj<Self>, args: &[Value]) -> Result<bool, Error> {
+        rb_self.check_frozen()?;
+        let args = scan_args::<(), (), (), (), RHash, ()>(args)?;
+        let (task,) = get_kwargs::<_, (Count,), (), ()>(args.keywords, &["task"], &[])?.required;
+        let canceled = rb_self.core.borrow_mut().cancel_wait(task.0 as usize);
+        Ok(canceled)
+    }
+
+    fn effective_priorities(&self) -> Vec<u32> {
+        self.core.borrow().effective_priorities()
+    }
+
+    const fn task_count(&self) -> usize {
+        self.tasks
+    }
+    const fn resource_count(&self) -> usize {
+        self.resources
+    }
+}
+
+pub fn define(ruby: &Ruby, module: RModule) -> Result<(), Error> {
+    let class = module.define_class("Arbiter", ruby.class_object())?;
+    class.define_singleton_method("new", function!(Wrapper::new, -1))?;
+    class.define_method("acquire", method!(Wrapper::acquire, -1))?;
+    class.define_method("release", method!(Wrapper::release, -1))?;
+    class.define_method("cancel_wait", method!(Wrapper::cancel_wait, -1))?;
+    class.define_method(
+        "effective_priorities",
+        method!(Wrapper::effective_priorities, 0),
+    )?;
+    class.define_method("task_count", method!(Wrapper::task_count, 0))?;
+    class.define_method("resource_count", method!(Wrapper::resource_count, 0))
+}

data/ext/arbiter_machines_native/ffi/src/init.rs

@@ -0,0 +1,6 @@
+use magnus::{Error, Ruby};
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    crate::arbiter::define(ruby, ruby.define_module("ArbiterMachines")?)
+}

data/ext/arbiter_machines_native/ffi/src/lib.rs

@@ -0,0 +1,21 @@
+//! Thin host adapters for priority inheritance and immediate ceiling decisions.
+
+mod arbiter;
+mod init;
+
+use magnus::{Error, Integer, Ruby, TryConvert, Value};
+
+#[derive(Clone, Copy)]
+pub(crate) struct Count(pub(crate) u32);
+
+impl TryConvert for Count {
+    fn try_convert(value: Value) -> Result<Self, Error> {
+        if Integer::from_value(value).is_none() {
+            return Err(Error::new(
+                Ruby::get_with(value).exception_type_error(),
+                "expected an Integer",
+            ));
+        }
+        u32::try_convert(value).map(Self)
+    }
+}

data/lib/arbiter_machines/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ArbiterMachines
+  VERSION = '0.1.5'
+end

data/lib/arbiter_machines.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'arbiter_machines/version'
+require 'arbiter_machines_native/arbiter_machines_native'

data/sig/arbiter_machines.rbs

@@ -0,0 +1,12 @@
+module ArbiterMachines
+  VERSION: String
+  class Arbiter
+    def self.new: (priorities: Array[Integer], ceilings: Array[Integer], protocol: :inheritance | :immediate_ceiling) -> instance
+    def acquire: (task: Integer, resource: Integer) -> [Symbol, Integer?]
+    def release: (task: Integer, resource: Integer) -> bool
+    def cancel_wait: (task: Integer) -> bool
+    def effective_priorities: () -> Array[Integer]
+    def task_count: () -> Integer
+    def resource_count: () -> Integer
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: arbiter_machines
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: ruby
+authors:
+- Abdelkader Boudih
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+description: Thin Ruby adapter to the standalone allocation-free arbiter-machines
+  Rust core. Initial unstable local implementation; caller enforces all decisions.
+email:
+- oss@seuros.com
+executables: []
+extensions:
+- ext/arbiter_machines_native/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Cargo.toml
+- LICENSE.txt
+- README.md
+- ext/arbiter_machines_native/core/CHANGELOG.md
+- ext/arbiter_machines_native/core/Cargo.toml
+- ext/arbiter_machines_native/core/README.md
+- ext/arbiter_machines_native/core/src/lib.rs
+- ext/arbiter_machines_native/extconf.rb
+- ext/arbiter_machines_native/ffi/Cargo.toml
+- ext/arbiter_machines_native/ffi/extconf.rb
+- ext/arbiter_machines_native/ffi/src/arbiter.rs
+- ext/arbiter_machines_native/ffi/src/init.rs
+- ext/arbiter_machines_native/ffi/src/lib.rs
+- lib/arbiter_machines.rb
+- lib/arbiter_machines/version.rb
+- sig/arbiter_machines.rbs
+homepage: https://github.com/seuros/arbiter_machines
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/seuros/arbiter_machines
+  bug_tracker_uri: https://github.com/seuros/arbiter_machines/issues
+  rubygems_mfa_required: 'true'
+  cargo_crate_name: arbiter_machines_native
+  cargo_manifest_path: ext/arbiter_machines_native/ffi/Cargo.toml
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Native bounded priority inheritance and resource ceiling decisions
+test_files: []