benchmark: add initial benchmark tests

These tests use the criterion plugin to collect
performance data for a given pub fn (selected 2 PVH
related functions for their relative complexity, as
well as a simple test for ARM) and (locally) compare
it with future runs.

This commit is part of a larger story spanning the
whole rust-vmm, kickstarting a centralized effort to
add benchmarks to crates used in production VMMs.

Signed-off-by: Alexandra Iordache <aghecen@amazon.com>

Author: Alexandra Iordache

Cargo.toml

@@ -4,15 +4,28 @@ version = "0.1.0"
 authors = ["Cathy Zhang <cathy.zhang@intel.com>"]
 edition = "2018"
 license = "Apache-2.0 AND BSD-3-Clause"
+autobenches = false
 
 [features]
 default = ["elf", "pe"]
-elf = []
 bzimage = []
+elf = []
 pe = []
 
 [dependencies]
 vm-memory = ">=0.2.0"
 
 [dev-dependencies]
+criterion = ">=0.3.0"
 vm-memory = {features = ["backend-mmap"]}
+
+[[bench]]
+name = "main"
+harness = false
+
+[lib]
+bench = false # https://bheisler.github.io/criterion.rs/book/faq.html#cargo-bench-gives-unrecognized-option-errors-for-valid-command-line-options
+
+[profile.bench]
+lto = true
+codegen-units = 1

benches/aarch64/mod.rs

@@ -0,0 +1,47 @@
+// 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;
+extern crate linux_loader;
+extern crate vm_memory;
+
+use linux_loader::configurator::fdt::FdtBootConfigurator;
+use linux_loader::configurator::{BootConfigurator, BootParams};
+use vm_memory::{ByteValued, GuestAddress, GuestMemoryMmap};
+
+use criterion::{black_box, Criterion};
+
+const MEM_SIZE: usize = 0x100_0000;
+const FDT_MAX_SIZE: usize = 0x20;
+
+fn create_guest_memory() -> GuestMemoryMmap {
+    GuestMemoryMmap::from_ranges(&[(GuestAddress(0x0), MEM_SIZE)]).unwrap()
+}
+
+#[derive(Clone, Copy, Default)]
+pub struct FdtPlaceholder([u8; FDT_MAX_SIZE]);
+
+unsafe impl ByteValued for FdtPlaceholder {}
+
+fn build_fdt_boot_params() -> BootParams {
+    let fdt = FdtPlaceholder([0u8; FDT_MAX_SIZE]);
+    let fdt_addr = GuestAddress((MEM_SIZE - FDT_MAX_SIZE - 1) as u64);
+    BootParams::new::<FdtPlaceholder>(&fdt, fdt_addr)
+}
+
+pub fn criterion_benchmark(c: &mut Criterion) {
+    let guest_mem = create_guest_memory();
+    let fdt_boot_params = build_fdt_boot_params();
+    c.bench_function("configure_fdt", |b| {
+        b.iter(|| {
+            black_box(FdtBootConfigurator::write_bootparams::<GuestMemoryMmap>(
+                fdt_boot_params.clone(),
+                &guest_mem,
+            ))
+            .unwrap();
+        })
+    });
+}

benches/main.rs

@@ -0,0 +1,31 @@
+// 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;
+extern crate linux_loader;
+extern crate vm_memory;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+mod x86_64;
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+use x86_64::*;
+
+#[cfg(target_arch = "aarch64")]
+mod aarch64;
+#[cfg(target_arch = "aarch64")]
+use aarch64::*;
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().sample_size(500);
+    targets = criterion_benchmark
+}
+
+criterion_main! {
+    benches
+}

benches/x86_64/mod.rs

@@ -0,0 +1,95 @@
+// 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(any(target_arch = "x86", target_arch = "x86_64"))]
+
+extern crate linux_loader;
+extern crate vm_memory;
+
+use linux_loader::configurator::pvh::PvhBootConfigurator;
+use linux_loader::configurator::{BootConfigurator, BootParams};
+use linux_loader::loader::elf::start_info::{hvm_memmap_table_entry, hvm_start_info};
+use linux_loader::loader::elf::Elf;
+use linux_loader::loader::KernelLoader;
+use vm_memory::{Address, GuestAddress, GuestMemoryMmap};
+
+use std::io::Cursor;
+
+use criterion::{black_box, Criterion};
+
+const MEM_SIZE: usize = 0x100_0000;
+const E820_RAM: u32 = 1;
+const XEN_HVM_START_MAGIC_VALUE: u32 = 0x336ec578;
+
+fn create_guest_memory() -> GuestMemoryMmap {
+    GuestMemoryMmap::from_ranges(&[(GuestAddress(0x0), MEM_SIZE)]).unwrap()
+}
+
+fn create_elf_pvh_image() -> Vec<u8> {
+    include_bytes!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/src/loader/x86_64/elf/test_elfnote.bin"
+    ))
+    .to_vec()
+}
+
+fn build_boot_params() -> (hvm_start_info, Vec<hvm_memmap_table_entry>) {
+    let mut start_info = hvm_start_info::default();
+    let memmap_entry = hvm_memmap_table_entry {
+        addr: 0x7000,
+        size: 0,
+        type_: E820_RAM,
+        reserved: 0,
+    };
+    start_info.magic = XEN_HVM_START_MAGIC_VALUE;
+    start_info.version = 1;
+    start_info.nr_modules = 0;
+    start_info.memmap_entries = 0;
+    (start_info, vec![memmap_entry])
+}
+
+fn build_pvh_boot_params() -> BootParams {
+    let (mut start_info, memmap_entries) = build_boot_params();
+    // Address in guest memory where the `start_info` struct will be written.
+    let start_info_addr = GuestAddress(0x6000);
+    // Address in guest memory where the memory map will be written.
+    let memmap_addr = GuestAddress(0x7000);
+    start_info.memmap_paddr = memmap_addr.raw_value();
+    // Write boot parameters in guest memory.
+    let mut boot_params = BootParams::new::<hvm_start_info>(&start_info, start_info_addr);
+    boot_params.set_sections::<hvm_memmap_table_entry>(&memmap_entries, memmap_addr);
+    boot_params
+}
+
+pub fn criterion_benchmark(c: &mut Criterion) {
+    let guest_mem = create_guest_memory();
+
+    let elf_pvh_image = create_elf_pvh_image();
+    let pvh_boot_params = build_pvh_boot_params();
+
+    c.bench_function("load_elf_pvh", |b| {
+        b.iter(|| {
+            black_box(Elf::load(
+                &guest_mem,
+                None,
+                &mut Cursor::new(&elf_pvh_image),
+                None,
+            ))
+            .unwrap();
+        })
+    });
+
+    c.bench_function("configure_pvh", |b| {
+        b.iter(|| {
+            black_box(PvhBootConfigurator::write_bootparams::<GuestMemoryMmap>(
+                pvh_boot_params.clone(),
+                &guest_mem,
+            ))
+            .unwrap();
+        })
+    });
+}

coverage_config_aarch64.json

@@ -1,5 +1,6 @@
 {
   "coverage_score": 80.7,
   "exclude_path": "",
-  "crate_features": "pe"
+  "crate_features": "pe",
+  "exclude_path": "benches/"
 }

coverage_config_x86_64.json

@@ -2,5 +2,5 @@
   "coverage_score": 80.8,
   "exclude_path": "",
   "crate_features": "bzimage,elf",
-  "exclude_path": "loader_gen"
+  "exclude_path": "benches/,loader_gen/"
 }