Add basic performance tests

Added tests that measure the durations of read and write
operations from Bytes trait. These tests are applied only
on Bytes implementation from GuestRegionMmap.
To run the benches use:
`cargo bench --bench main --features backend-mmap`.

Signed-off-by: Laura Loghin <[email protected]>
Signed-off-by: Alexandru Agache <[email protected]>

Author: lauralt

Cargo.toml

@@ -8,6 +8,7 @@ repository = "https://github.com/rust-vmm/vm-memory"
 readme = "README.md"
 license = "Apache-2.0 OR BSD-3-Clause"
 edition = "2018"
+autobenches = false
 
 [features]
 default = []
@@ -24,5 +25,14 @@ version = ">=0.3"
 features = ["errhandlingapi"]
 
 [dev-dependencies]
+criterion = "0.3.0"
 matches = ">=0"
 vmm-sys-util = ">= 0.4.0"
+
+[[bench]]
+name = "main"
+harness = false
+
+[profile.bench]
+lto = true
+codegen-units = 1

benches/main.rs

@@ -0,0 +1,30 @@
+// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE-BSD-3-Clause file.
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+
+extern crate criterion;
+
+pub use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+mod mmap;
+
+#[cfg(feature = "backend-mmap")]
+use mmap::benchmark_for_mmap;
+
+pub fn criterion_benchmark(_c: &mut Criterion) {
+    #[cfg(feature = "backend-mmap")]
+    benchmark_for_mmap(_c);
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().sample_size(200).measurement_time(std::time::Duration::from_secs(50));
+    targets = criterion_benchmark
+}
+
+criterion_main! {
+    benches,
+}

benches/mmap/mod.rs

@@ -0,0 +1,227 @@
+// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE-BSD-3-Clause file.
+//
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+#![cfg(feature = "backend-mmap")]
+
+extern crate criterion;
+extern crate vm_memory;
+extern crate vmm_sys_util;
+
+use std::fs::{File, OpenOptions};
+use std::io::Cursor;
+use std::mem::size_of;
+use std::path::Path;
+
+use criterion::{black_box, Criterion};
+
+use vm_memory::{ByteValued, Bytes, GuestAddress, GuestMemory, GuestMemoryMmap};
+
+const REGION_SIZE: u64 = 0x8000_0000;
+const REGIONS_COUNT: u64 = 8;
+const ACCESS_SIZE: usize = 0x200;
+
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+struct SmallDummy {
+    a: u32,
+    b: u32,
+}
+unsafe impl ByteValued for SmallDummy {}
+
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+struct BigDummy {
+    elements: [u64; 12],
+}
+
+unsafe impl ByteValued for BigDummy {}
+
+fn make_image(size: usize) -> Vec<u8> {
+    let mut image: Vec<u8> = Vec::with_capacity(size);
+    for i in 0..size {
+        // We just want some different numbers here, so the conversion is OK.
+        image.push(i as u8);
+    }
+    image
+}
+
+enum AccessKind {
+    // The parameter represents the index of the region where the access should happen.
+    // Indices are 0-based.
+    InRegion(u64),
+    // The parameter represents the index of the first region (i.e. where the access starts).
+    CrossRegion(u64),
+}
+
+impl AccessKind {
+    fn make_offset(&self, access_size: usize) -> u64 {
+        match *self {
+            AccessKind::InRegion(idx) => REGION_SIZE * idx,
+            AccessKind::CrossRegion(idx) => REGION_SIZE * (idx + 1) - (access_size / 2) as u64,
+        }
+    }
+}
+
+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 = GuestMemoryMmap::from_ranges(regions.as_slice()).unwrap();
+    // Just a sanity check.
+    assert_eq!(
+        memory.last_addr(),
+        GuestAddress(REGION_SIZE * REGIONS_COUNT - 0x01)
+    );
+
+    let some_small_dummy = SmallDummy {
+        a: 0x1111_2222,
+        b: 0x3333_4444,
+    };
+
+    let some_big_dummy = BigDummy {
+        elements: [0x1111_2222_3333_4444; 12],
+    };
+
+    let mut image = make_image(ACCESS_SIZE);
+    let buf = &mut [0u8; ACCESS_SIZE];
+    let mut file = File::open(Path::new("/dev/zero")).expect("Could not open /dev/zero");
+    let mut file_to_write = OpenOptions::new()
+        .write(true)
+        .open("/dev/null")
+        .expect("Could not open /dev/null");
+
+    let accesses = &[
+        AccessKind::InRegion(0),
+        AccessKind::CrossRegion(0),
+        AccessKind::CrossRegion(REGIONS_COUNT - 2),
+        AccessKind::InRegion(REGIONS_COUNT - 1),
+    ];
+
+    for access in accesses {
+        let offset = access.make_offset(ACCESS_SIZE);
+        let address = GuestAddress(offset);
+
+        // Check performance for read operations.
+        c.bench_function(format!("read_from_{:#0X}", offset).as_str(), |b| {
+            b.iter(|| {
+                black_box(
+                    memory
+                        .read_from(address, &mut Cursor::new(&image), ACCESS_SIZE)
+                        .unwrap(),
+                )
+            })
+        });
+
+        c.bench_function(format!("read_from_file_{:#0X}", offset).as_str(), |b| {
+            b.iter(|| black_box(memory.read_from(address, &mut file, ACCESS_SIZE).unwrap()))
+        });
+
+        c.bench_function(format!("read_exact_from_{:#0X}", offset).as_str(), |b| {
+            b.iter(|| {
+                black_box(
+                    memory
+                        .read_exact_from(address, &mut Cursor::new(&mut image), ACCESS_SIZE)
+                        .unwrap(),
+                )
+            })
+        });
+
+        c.bench_function(
+            format!("read_entire_slice_from_{:#0X}", offset).as_str(),
+            |b| b.iter(|| black_box(memory.read_slice(buf, address).unwrap())),
+        );
+
+        c.bench_function(format!("read_slice_from_{:#0X}", offset).as_str(), |b| {
+            b.iter(|| black_box(memory.read(buf, address).unwrap()))
+        });
+
+        let obj_off = access.make_offset(size_of::<SmallDummy>());
+        let obj_addr = GuestAddress(obj_off);
+
+        c.bench_function(
+            format!("read_small_obj_from_{:#0X}", obj_off).as_str(),
+            |b| b.iter(|| black_box(memory.read_obj::<SmallDummy>(obj_addr).unwrap())),
+        );
+
+        let obj_off = access.make_offset(size_of::<BigDummy>());
+        let obj_addr = GuestAddress(obj_off);
+
+        c.bench_function(format!("read_big_obj_from_{:#0X}", obj_off).as_str(), |b| {
+            b.iter(|| black_box(memory.read_obj::<BigDummy>(obj_addr).unwrap()))
+        });
+
+        // Check performance for write operations.
+        c.bench_function(format!("write_to_{:#0X}", offset).as_str(), |b| {
+            b.iter(|| {
+                black_box(
+                    memory
+                        .write_to(address, &mut Cursor::new(&mut image), ACCESS_SIZE)
+                        .unwrap(),
+                )
+            })
+        });
+
+        c.bench_function(format!("write_to_file_{:#0X}", offset).as_str(), |b| {
+            b.iter(|| {
+                black_box(
+                    memory
+                        .write_to(address, &mut file_to_write, ACCESS_SIZE)
+                        .unwrap(),
+                )
+            })
+        });
+
+        c.bench_function(format!("write_exact_to_{:#0x}", offset).as_str(), |b| {
+            b.iter(|| {
+                black_box(
+                    memory
+                        .write_all_to(address, &mut Cursor::new(&mut image), ACCESS_SIZE)
+                        .unwrap(),
+                )
+            })
+        });
+
+        c.bench_function(
+            format!("write_entire_slice_to_{:#0X}", offset).as_str(),
+            |b| b.iter(|| black_box(memory.write_slice(buf, address).unwrap())),
+        );
+
+        c.bench_function(format!("write_slice_to_{:#0X}", offset).as_str(), |b| {
+            b.iter(|| black_box(memory.write(buf, address).unwrap()))
+        });
+
+        let obj_off = access.make_offset(size_of::<SmallDummy>());
+        let obj_addr = GuestAddress(obj_off);
+
+        c.bench_function(
+            format!("write_small_obj_to_{:#0X}", obj_off).as_str(),
+            |b| {
+                b.iter(|| {
+                    black_box(
+                        memory
+                            .write_obj::<SmallDummy>(some_small_dummy, obj_addr)
+                            .unwrap(),
+                    )
+                })
+            },
+        );
+
+        let obj_off = access.make_offset(size_of::<BigDummy>());
+        let obj_addr = GuestAddress(obj_off);
+
+        c.bench_function(format!("write_big_obj_to_{:#0X}", obj_off).as_str(), |b| {
+            b.iter(|| {
+                black_box(
+                    memory
+                        .write_obj::<BigDummy>(some_big_dummy, obj_addr)
+                        .unwrap(),
+                )
+            })
+        });
+    }
+}

src/bytes.rs

@@ -438,6 +438,6 @@ mod tests {
         let mut s: S = Default::default();
         s.as_bytes().copy_from(&a);
         assert_eq!(s.a, 0);
-        assert_eq!(s.b, 0x1010101);
+        assert_eq!(s.b, 0x0101_0101);
     }
 }