Initial commit

.github/workflows/ci.yml

@@ -0,0 +1,55 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust-toolchain: [nightly]
+        targets: [x86_64-unknown-linux-gnu, x86_64-unknown-none, riscv64gc-unknown-none-elf, aarch64-unknown-none-softfloat]
+    steps:
+    - uses: actions/checkout@v4
+    - uses: dtolnay/rust-toolchain@nightly
+      with:
+        toolchain: ${{ matrix.rust-toolchain }}
+        components: rust-src, clippy, rustfmt
+        targets: ${{ matrix.targets }}
+    - name: Check rust version
+      run: rustc --version --verbose
+    - name: Check code format
+      run: cargo fmt --all -- --check
+    - name: Clippy
+      run: cargo clippy --target ${{ matrix.targets }} --all-features -- -A clippy::new_without_default
+    - name: Build
+      run: cargo build --target ${{ matrix.targets }} --all-features
+    - name: Unit test
+      if: ${{ matrix.targets == 'x86_64-unknown-linux-gnu' }}
+      run: cargo test --target ${{ matrix.targets }} -- --nocapture
+
+  doc:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    permissions:
+      contents: write
+    env:
+      default-branch: ${{ format('refs/heads/{0}', github.event.repository.default_branch) }}
+      RUSTDOCFLAGS: -D rustdoc::broken_intra_doc_links -D missing-docs
+    steps:
+    - uses: actions/checkout@v4
+    - uses: dtolnay/rust-toolchain@nightly
+    - name: Build docs
+      continue-on-error: ${{ github.ref != env.default-branch && github.event_name != 'pull_request' }}
+      run: |
+        cargo doc --no-deps --all-features
+        printf '<meta http-equiv="refresh" content="0;url=%s/index.html">' $(cargo tree | head -1 | cut -d' ' -f1) > target/doc/index.html
+    - name: Deploy to Github Pages
+      if: ${{ github.ref == env.default-branch }}
+      uses: JamesIves/github-pages-deploy-action@v4
+      with:
+        single-commit: true
+        branch: gh-pages
+        folder: target/doc

.gitignore

@@ -0,0 +1,3 @@
+/target
+/.vscode
+.DS_Store

Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "handler_table"
+version = "0.1.0"
+edition = "2021"
+authors = ["Yuekai Jia <[email protected]>"]
+description = "A lock-free table of event handlers"
+license = "GPL-3.0-or-later OR Apache-2.0 OR MulanPSL-2.0"
+homepage = "https://github.com/arceos-org/arceos"
+repository = "https://github.com/arceos-org/arceos/tree/main/crates/handler_table"
+documentation = "https://docs.rs/handler_table"
+keywords = ["arceos", "event", "lock-free"]
+categories = ["no-std"]
+
+[dependencies]

README.md

@@ -0,0 +1,23 @@
+# handler_table
+
+[![Crates.io](https://img.shields.io/crates/v/handler_table)](https://crates.io/crates/handler_table)
+
+A lock-free table of event handlers.
+
+## Examples
+
+```rust
+use handler_table::HandlerTable;
+
+static TABLE: HandlerTable<8> = HandlerTable::new();
+
+TABLE.register_handler(0, || {
+   println!("Hello, event 0!");
+});
+TABLE.register_handler(1, || {
+   println!("Hello, event 1!");
+});
+
+assert!(TABLE.handle(0)); // print "Hello, event 0!"
+assert!(!TABLE.handle(2)); // unregistered
+```

src/lib.rs

@@ -0,0 +1,49 @@
+#![no_std]
+#![doc = include_str!("../README.md")]
+
+use core::sync::atomic::{AtomicUsize, Ordering};
+
+/// The type of an event handler.
+///
+/// Currently no arguments and return values are supported.
+pub type Handler = fn();
+
+/// A lock-free table of event handlers.
+///
+/// It internally uses an array of `AtomicUsize` to store the handlers.
+pub struct HandlerTable<const N: usize> {
+    handlers: [AtomicUsize; N],
+}
+
+impl<const N: usize> HandlerTable<N> {
+    /// Creates a new handler table with all entries empty.
+    #[allow(clippy::declare_interior_mutable_const)]
+    pub const fn new() -> Self {
+        const EMPTY: AtomicUsize = AtomicUsize::new(0);
+        Self {
+            handlers: [EMPTY; N],
+        }
+    }
+
+    /// Registers a handler for the given index.
+    pub fn register_handler(&self, idx: usize, handler: Handler) -> bool {
+        self.handlers[idx]
+            .compare_exchange(0, handler as usize, Ordering::Acquire, Ordering::Relaxed)
+            .is_ok()
+    }
+
+    /// Handles the event with the given index.
+    ///
+    /// Returns `true` if the event is handled, `false` if no handler is
+    /// registered for the given index.
+    pub fn handle(&self, idx: usize) -> bool {
+        let handler = self.handlers[idx].load(Ordering::Acquire);
+        if handler != 0 {
+            let handler: Handler = unsafe { core::mem::transmute(handler) };
+            handler();
+            true
+        } else {
+            false
+        }
+    }
+}