bench: add benchmark cases for Volatile interfaces

Add benchmark cases for VolatileSlice/VolatileArrarRef interfaces.

Signed-off-by: Liu Jiang <[email protected]>

Author: jiangliu

benches/guest_memory.rs

@@ -0,0 +1,28 @@
+// Copyright (C) 2020 Alibaba Cloud Computing. All rights reserved.
+//
+// SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
+#![cfg(feature = "backend-mmap")]
+
+pub use criterion::{black_box, Criterion};
+use vm_memory::{GuestAddress, GuestMemory, GuestMemoryMmap};
+
+const REGION_SIZE: u64 = 0x10_0000;
+const REGIONS_COUNT: u64 = 256;
+
+pub fn benchmark_for_guest_memory(c: &mut Criterion) {
+    benchmark_find_region(c);
+}
+
+fn find_region(mem: &GuestMemoryMmap) {
+    for i in 0..REGIONS_COUNT {
+        let _ = mem.find_region(GuestAddress(i * REGION_SIZE)).unwrap();
+    }
+}
+
+fn benchmark_find_region(c: &mut Criterion) {
+    let memory = super::create_guest_memory_mmap(REGION_SIZE, REGIONS_COUNT);
+
+    c.bench_function("find_region", |b| {
+        b.iter(|| black_box(find_region(&memory)))
+    });
+}

benches/main.rs

@@ -5,21 +5,39 @@
 extern crate criterion;
 
 pub use criterion::{black_box, criterion_group, criterion_main, Criterion};
+#[cfg(feature = "backend-mmap")]
+use vm_memory::{GuestAddress, GuestMemoryMmap};
 
+mod guest_memory;
 mod mmap;
+mod volatile;
+
+use volatile::benchmark_for_volatile;
 
 #[cfg(feature = "backend-mmap")]
-use mmap::benchmark_for_mmap;
+pub fn create_guest_memory_mmap(size: u64, count: u64) -> GuestMemoryMmap {
+    let mut regions: Vec<(GuestAddress, usize)> = Vec::new();
+    for i in 0..count {
+        regions.push((GuestAddress(i * size), size as usize));
+    }
+
+    GuestMemoryMmap::from_ranges(regions.as_slice()).unwrap()
+}
 
 pub fn criterion_benchmark(_c: &mut Criterion) {
     #[cfg(feature = "backend-mmap")]
-    benchmark_for_mmap(_c);
+    mmap::benchmark_for_mmap(_c);
+}
+
+pub fn benchmark_guest_memory(_c: &mut Criterion) {
+    #[cfg(feature = "backend-mmap")]
+    guest_memory::benchmark_for_guest_memory(_c)
 }
 
 criterion_group! {
     name = benches;
     config = Criterion::default().sample_size(200).measurement_time(std::time::Duration::from_secs(50));
-    targets = criterion_benchmark
+    targets = criterion_benchmark, benchmark_guest_memory, benchmark_for_volatile
 }
 
 criterion_main! {

benches/mmap/mod.rs

@@ -13,7 +13,7 @@ use std::path::Path;
 
 use criterion::{black_box, Criterion};
 
-use vm_memory::{ByteValued, Bytes, GuestAddress, GuestMemory, GuestMemoryMmap};
+use vm_memory::{ByteValued, Bytes, GuestAddress, GuestMemory};
 
 const REGION_SIZE: u64 = 0x8000_0000;
 const REGIONS_COUNT: u64 = 8;
@@ -62,12 +62,8 @@ impl AccessKind {
 }
 
 pub fn benchmark_for_mmap(c: &mut Criterion) {
-    let mut regions: Vec<(GuestAddress, usize)> = Vec::new();
-    for i in 0..REGIONS_COUNT {
-        regions.push((GuestAddress(i * REGION_SIZE), REGION_SIZE as usize));
-    }
+    let memory = super::create_guest_memory_mmap(REGION_SIZE, REGIONS_COUNT);
 
-    let memory = GuestMemoryMmap::from_ranges(regions.as_slice()).unwrap();
     // Just a sanity check.
     assert_eq!(
         memory.last_addr(),

benches/volatile.rs

@@ -0,0 +1,45 @@
+// Copyright (C) 2020 Alibaba Cloud. All rights reserved.
+//
+// SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
+
+pub use criterion::{black_box, Criterion};
+use vm_memory::volatile_memory::VolatileMemory;
+
+pub fn benchmark_for_volatile(c: &mut Criterion) {
+    let mut a = [0xa5u8; 1024];
+    let a_ref = &mut a[..];
+    let v_ref8 = a_ref.get_slice(0, a_ref.len()).unwrap();
+    let v_ref16 = a_ref.get_slice(0, a_ref.len() / 2).unwrap();
+    let mut d8 = [0u8; 1024];
+    let mut d16 = [0u16; 512];
+
+    // Check performance for read operations.
+    c.bench_function("VolatileSlice::copy_to_u8", |b| {
+        b.iter(|| black_box(v_ref8.copy_to(&mut d8[..])))
+    });
+    c.bench_function("VolatileSlice::copy_to_u16", |b| {
+        b.iter(|| black_box(v_ref16.copy_to(&mut d16[..])))
+    });
+    benchmark_volatile_copy_to_volatile_slice(c);
+
+    // Check performance for write operations.
+    c.bench_function("VolatileSlice::copy_from_u8", |b| {
+        b.iter(|| black_box(v_ref8.copy_from(&d8[..])))
+    });
+    c.bench_function("VolatileSlice::copy_from_u16", |b| {
+        b.iter(|| black_box(v_ref16.copy_from(&d16[..])))
+    });
+}
+
+fn benchmark_volatile_copy_to_volatile_slice(c: &mut Criterion) {
+    let mut a = [0xa5u8; 10240];
+    let a_ref = &mut a[..];
+    let a_slice = a_ref.get_slice(0, a_ref.len()).unwrap();
+    let mut d = [0u8; 10240];
+    let d_ref = &mut d[..];
+    let d_slice = d_ref.get_slice(0, d_ref.len()).unwrap();
+
+    c.bench_function("VolatileSlice::copy_to_volatile_slice", |b| {
+        b.iter(|| black_box(a_slice.copy_to_volatile_slice(d_slice)))
+    });
+}