WIP

Modified-by: Tomasz Andrzejak <andreiltd@gmail.com>

Author: andreiltd

Cargo.lock

@@ -48,6 +48,7 @@ hyperlight-component-macro = { path = "src/hyperlight_component_macro", version
 
 [workspace.lints.rust]
 unsafe_op_in_unsafe_fn = "deny"
+unexpected_cfgs = { level = "warn", check-cfg = [ 'cfg(loom)' ] }
 
 # this will generate symbols for release builds
 # so is handy for debugging issues in release builds

Cargo.toml

@@ -15,13 +15,19 @@ Hyperlight's components common to host and guest.
 workspace = true
 
 [dependencies]
-flatbuffers = { version = "25.9.23", default-features = false }
+arbitrary = {version = "1.4.2", optional = true, features = ["derive"]}
 anyhow = { version = "1.0.100", default-features = false }
+atomic_refcell = "0.1.13"
+bitflags = "2.10.0"
+bytemuck = { version = "1.24", features = ["derive"] }
+bytes = { version = "1",  default-features = false }
+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 +38,19 @@ 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"
+
+[target.'cfg(loom)'.dev-dependencies]
+loom = "0.7"
+
 [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::virtq::{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 virtq;