WIP

Modified-by: Tomasz Andrzejak <[email protected]>

Author: andreiltd

Cargo.lock

@@ -15,13 +15,18 @@ Hyperlight's components common to host and guest.
 workspace = true
 
 [dependencies]
-flatbuffers = { version = "25.9.23", default-features = false }
+allocator-api2 = "0.3.1"
+arbitrary = {version = "1.4.2", optional = true, features = ["derive"]}
 anyhow = { version = "1.0.100", default-features = false }
+bitflags = "2.10.0"
+bytemuck = { version = "1.24", features = ["derive"] }
+fixedbitset = { version = "0.5.7",  default-features = false }
+flatbuffers = { version = "25.9.23", default-features = false }
 log = "0.4.29"
-tracing = { version = "0.1.43", optional = true }
-arbitrary = {version = "1.4.2", optional = true, features = ["derive"]}
+smallvec = "1.15.1"
 spin = "0.10.0"
 thiserror = { version = "2.0.16", default-features = false }
+tracing = { version = "0.1.43", optional = true }
 
 [features]
 default = ["tracing"]
@@ -32,6 +37,16 @@ mem_profile = []
 std = ["thiserror/std", "log/std", "tracing/std"]
 init-paging = []
 
+[dev-dependencies]
+criterion = "0.8.1"
+hyperlight-testing = { workspace = true }
+quickcheck = "1.0.3"
+rand = "0.9.2"
+
 [lib]
 bench = false # see https://bheisler.github.io/criterion.rs/book/faq.html#cargo-bench-gives-unrecognized-option-errors-for-valid-command-line-options
 doctest = false # reduce noise in test output
+
+[[bench]]
+name = "buffer_pool"
+harness = false

src/hyperlight_common/Cargo.toml

@@ -0,0 +1,176 @@
+use std::hint::black_box;
+
+use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
+use hyperlight_common::ring::{BufferPool, BufferProvider};
+
+// Helper to create a pool for benchmarking
+fn make_pool<const L: usize, const U: usize>(size: usize) -> BufferPool<L, U> {
+    let base = 0x10000;
+    BufferPool::<L, U>::new(base, size).unwrap()
+}
+
+// Single allocation performance
+fn bench_alloc_single(c: &mut Criterion) {
+    let mut group = c.benchmark_group("alloc_single");
+
+    for size in [64, 128, 256, 512, 1024, 1500, 4096].iter() {
+        group.throughput(Throughput::Elements(1));
+        group.bench_with_input(BenchmarkId::from_parameter(size), size, |b, &size| {
+            let pool = make_pool::<256, 4096>(4 * 1024 * 1024);
+            b.iter(|| {
+                let alloc = pool.alloc(black_box(size)).unwrap();
+                pool.dealloc(alloc).unwrap();
+            });
+        });
+    }
+    group.finish();
+}
+
+// LIFO recycling
+fn bench_alloc_lifo(c: &mut Criterion) {
+    let mut group = c.benchmark_group("alloc_lifo");
+
+    for size in [256, 1500, 4096].iter() {
+        group.throughput(Throughput::Elements(100));
+        group.bench_with_input(BenchmarkId::from_parameter(size), size, |b, &size| {
+            let pool = make_pool::<256, 4096>(4 * 1024 * 1024);
+            b.iter(|| {
+                for _ in 0..100 {
+                    let alloc = pool.alloc(black_box(size)).unwrap();
+                    pool.dealloc(alloc).unwrap();
+                }
+            });
+        });
+    }
+    group.finish();
+}
+
+// Fragmented allocation worst case
+fn bench_alloc_fragmented(c: &mut Criterion) {
+    let mut group = c.benchmark_group("alloc_fragmented");
+
+    group.bench_function("fragmented_256", |b| {
+        let pool = make_pool::<256, 4096>(4 * 1024 * 1024);
+
+        // Create fragmentation pattern: allocate many, free every other
+        let mut allocations = Vec::new();
+        for _ in 0..100 {
+            allocations.push(pool.alloc(128).unwrap());
+        }
+        for i in (0..100).step_by(2) {
+            pool.dealloc(allocations[i]).unwrap();
+        }
+
+        b.iter(|| {
+            let alloc = pool.alloc(black_box(256)).unwrap();
+            pool.dealloc(alloc).unwrap();
+        });
+    });
+
+    group.finish();
+}
+
+// Realloc operations
+fn bench_realloc(c: &mut Criterion) {
+    let mut group = c.benchmark_group("realloc");
+
+    // In-place grow (same tier)
+    group.bench_function("grow_inplace", |b| {
+        let pool = make_pool::<256, 4096>(4 * 1024 * 1024);
+        b.iter(|| {
+            let alloc = pool.alloc(256).unwrap();
+            let grown = pool.resize(alloc, black_box(512)).unwrap();
+            pool.dealloc(grown).unwrap();
+        });
+    });
+
+    // Relocate grow (cross tier)
+    group.bench_function("grow_relocate", |b| {
+        let pool = make_pool::<256, 4096>(4 * 1024 * 1024);
+        b.iter(|| {
+            let alloc = pool.alloc(128).unwrap();
+            // Block in-place growth
+            let blocker = pool.alloc(256).unwrap();
+            let grown = pool.resize(alloc, black_box(1500)).unwrap();
+            pool.dealloc(grown).unwrap();
+            pool.dealloc(blocker).unwrap();
+        });
+    });
+
+    // Shrink
+    group.bench_function("shrink", |b| {
+        let pool = make_pool::<256, 4096>(4 * 1024 * 1024);
+        b.iter(|| {
+            let alloc = pool.alloc(1500).unwrap();
+            let shrunk = pool.resize(alloc, black_box(256)).unwrap();
+            pool.dealloc(shrunk).unwrap();
+        });
+    });
+
+    group.finish();
+}
+
+// Free performance
+fn bench_free(c: &mut Criterion) {
+    let mut group = c.benchmark_group("free");
+
+    for size in [256, 1500, 4096].iter() {
+        group.bench_with_input(BenchmarkId::from_parameter(size), size, |b, &size| {
+            let pool = make_pool::<256, 4096>(4 * 1024 * 1024);
+            b.iter(|| {
+                let alloc = pool.alloc(size).unwrap();
+                pool.dealloc(black_box(alloc)).unwrap();
+            });
+        });
+    }
+
+    group.finish();
+}
+
+// Cursor optimization
+fn bench_last_free_run(c: &mut Criterion) {
+    let mut group = c.benchmark_group("last_free_run");
+
+    // With cursor optimization (LIFO)
+    group.bench_function("lifo_pattern", |b| {
+        let pool = make_pool::<256, 4096>(4 * 1024 * 1024);
+        b.iter(|| {
+            let alloc = pool.alloc(256).unwrap();
+            pool.dealloc(alloc).unwrap();
+            let alloc2 = pool.alloc(black_box(256)).unwrap();
+            pool.dealloc(alloc2).unwrap();
+        });
+    });
+
+    // Without cursor benefit (FIFO-like)
+    group.bench_function("fifo_pattern", |b| {
+        let pool = make_pool::<256, 4096>(4 * 1024 * 1024);
+        let mut queue = Vec::new();
+
+        // Pre-fill queue
+        for _ in 0..10 {
+            queue.push(pool.alloc(256).unwrap());
+        }
+
+        b.iter(|| {
+            // FIFO: free oldest, allocate new
+            let old = queue.remove(0);
+            pool.dealloc(old).unwrap();
+            queue.push(pool.alloc(black_box(256)).unwrap());
+        });
+    });
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_alloc_single,
+    bench_alloc_lifo,
+    bench_alloc_fragmented,
+    bench_realloc,
+    bench_free,
+    bench_last_free_run,
+);
+
+criterion_main!(benches);

src/hyperlight_common/benches/buffer_pool.rs

@@ -272,7 +272,7 @@ pub fn estimate_flatbuffer_capacity(function_name: &str, args: &[ParameterValue]
     estimated_capacity.next_power_of_two()
 }
 
-#[cfg(test)]
+#[cfg(all(test, not(miri)))]
 mod tests {
     use alloc::string::ToString;
     use alloc::vec;

src/hyperlight_common/src/flatbuffer_wrappers/util.rs

@@ -18,7 +18,7 @@ limitations under the License.
 #![cfg_attr(not(any(test, debug_assertions)), warn(clippy::expect_used))]
 #![cfg_attr(not(any(test, debug_assertions)), warn(clippy::unwrap_used))]
 // We use Arbitrary during fuzzing, which requires std
-#![cfg_attr(not(feature = "fuzzing"), no_std)]
+#![cfg_attr(not(any(feature = "fuzzing", test, miri)), no_std)]
 
 extern crate alloc;
 
@@ -41,3 +41,6 @@ pub mod func;
 // cbindgen:ignore
 #[cfg(feature = "init-paging")]
 pub mod vmem;
+
+/// cbindgen:ignore
+pub mod ring;

src/hyperlight_common/src/lib.rs

@@ -0,0 +1,111 @@
+use core::marker::PhantomData;
+use core::ptr::NonNull;
+
+use bytemuck::Pod;
+
+pub trait MmioAccess: Pod {
+    /// Acquire-ordered read from base pointer
+    ///
+    /// # Safety
+    ///
+    /// `base` must point to a valid Self in MMIO.
+    unsafe fn read_acquire(base: core::ptr::NonNull<Self>) -> Self;
+
+    /// Plain volatile read from base pointer (no ordering)
+    ///
+    /// # Safety
+    ///
+    /// `base` must point to a valid Self in MMIO.
+    unsafe fn read_volatile(base: core::ptr::NonNull<Self>) -> Self {
+        unsafe { core::ptr::read_volatile(base.as_ptr()) }
+    }
+
+    /// Release-ordered write to base pointer
+    ///
+    /// # Safety
+    ///
+    /// `base` must point to a valid Self in MMIO.
+    unsafe fn write_release(base: core::ptr::NonNull<Self>, val: Self);
+
+    /// Plain volatile write to base pointer (no ordering)
+    ///
+    /// # Safety
+    ///
+    /// `base` must point to a valid Self in MMIO.
+    unsafe fn write_volatile(base: core::ptr::NonNull<Self>, val: Self) {
+        unsafe { core::ptr::write_volatile(base.as_ptr(), val) }
+    }
+}
+
+/// A view into a `T` stored in shared memory.
+#[derive(Debug)]
+pub struct MmioView<'a, T: MmioAccess> {
+    base: NonNull<T>,
+    owner: PhantomData<&'a T>,
+}
+
+impl<'a, T: MmioAccess> MmioView<'a, T> {
+    /// # Safety
+    ///
+    /// `base` must be valid for 'a and point to a valid T in MMIO.
+    pub unsafe fn new(base: NonNull<T>) -> Self {
+        Self {
+            base,
+            owner: PhantomData,
+        }
+    }
+
+    #[inline(always)]
+    pub fn read_acquire(&self) -> T {
+        unsafe { T::read_acquire(self.base) }
+    }
+
+    #[inline(always)]
+    pub fn read_volatile(&self) -> T {
+        unsafe { T::read_volatile(self.base) }
+    }
+}
+
+/// A mutable view into a `T` stored in shared memory.
+#[derive(Debug)]
+pub struct MmioViewMut<'a, T: MmioAccess> {
+    base: NonNull<T>,
+    owner: PhantomData<&'a mut T>,
+}
+
+impl<'a, T: MmioAccess> MmioViewMut<'a, T> {
+    /// # Safety
+    ///
+    /// `base` must be valid for 'a and point to a valid T in MMIO.
+    pub unsafe fn new(base: NonNull<T>) -> Self {
+        Self {
+            base,
+            owner: PhantomData,
+        }
+    }
+
+    #[inline(always)]
+    pub fn read_acquire(&self) -> T {
+        unsafe { T::read_acquire(self.base) }
+    }
+
+    #[inline(always)]
+    pub fn read_volatile(&self) -> T {
+        unsafe { T::read_volatile(self.base) }
+    }
+
+    #[inline(always)]
+    pub fn write_release(&mut self, val: T) {
+        unsafe { T::write_release(self.base, val) }
+    }
+
+    #[inline(always)]
+    pub fn write_volatile(&mut self, val: T) {
+        unsafe { T::write_volatile(self.base, val) }
+    }
+
+    #[inline(always)]
+    pub fn as_view(&self) -> MmioView<'_, T> {
+        unsafe { MmioView::new(self.base) }
+    }
+}