performance-metrics: Use QcowDisk for QCOW2 benchmarks

Replace QcowDiskSync and QcowDiskAsync with QcowDisk in all QCOW2
benchmark helpers. The sync helpers pass use_io_uring=false, the
async helpers pass use_io_uring=true.

Signed-off-by: Anatol Belski <anbelski@linux.microsoft.com>

performance-metrics/src/micro_bench_block.rs

@@ -334,8 +334,8 @@ pub fn micro_bench_qcow_l2_cache_miss(control: &PerformanceTestControl) -> f64 {
 /// Read num_ops clusters from a prepopulated qcow2 image through the
 /// QcowAsync io_uring path and time the total wall clock.
 ///
-/// Unlike micro_bench_qcow_read which uses QcowDiskSync (blocking),
+/// Unlike micro_bench_qcow_read which uses the synchronous backend,
-/// this uses QcowDiskAsync where single-allocated-cluster reads go
+/// this uses the io_uring backend where single allocated cluster reads go
 /// through io_uring for true asynchronous completion.
 ///
 /// Returns the total read wall clock time in seconds.

performance-metrics/src/util.rs

@@ -13,8 +13,7 @@ use std::time::Duration;
 
 use block::async_io::AsyncIo;
 use block::qcow::{BackingFileConfig, ImageType, QcowFile, RawFile};
-use block::qcow_async::QcowDiskAsync;
+use block::qcow_disk::QcowDisk;
-use block::qcow_sync::QcowDiskSync;
 use vmm_sys_util::eventfd::EventFd;
 use vmm_sys_util::tempfile::TempFile;
 
@@ -52,20 +51,26 @@ fn create_qcow_tempfile(num_clusters: usize) -> TempFile {
 }
 
 /// Create a QCOW2 image with `num_clusters` allocated clusters opened
-/// via `QcowDiskSync` (blocking I/O backend).
+/// via QcowDisk with synchronous backend.
-pub fn qcow_tempfile(num_clusters: usize) -> (TempFile, QcowDiskSync) {
+pub fn qcow_tempfile(num_clusters: usize) -> (TempFile, QcowDisk) {
     let tmp = create_qcow_tempfile(num_clusters);
-    let disk = QcowDiskSync::new(tmp.as_file().try_clone().unwrap(), false, false, true)
+    let disk = QcowDisk::new(
-        .expect("failed to open QCOW2 via QcowDiskSync");
+        tmp.as_file().try_clone().unwrap(),
+        false,
+        false,
+        true,
+        false,
+    )
+    .expect("failed to open QCOW2 via QcowDisk");
     (tmp, disk)
 }
 
 /// Create a QCOW2 image with `num_clusters` allocated clusters opened
-/// via `QcowDiskAsync` (io_uring backend).
+/// via QcowDisk with io_uring backend.
-pub fn qcow_async_tempfile(num_clusters: usize) -> (TempFile, QcowDiskAsync) {
+pub fn qcow_async_tempfile(num_clusters: usize) -> (TempFile, QcowDisk) {
     let tmp = create_qcow_tempfile(num_clusters);
-    let disk = QcowDiskAsync::new(tmp.as_file().try_clone().unwrap(), false, false, true)
+    let disk = QcowDisk::new(tmp.as_file().try_clone().unwrap(), false, false, true, true)
-        .expect("failed to open QCOW2 via QcowDiskAsync");
+        .expect("failed to open QCOW2 via QcowDisk");
     (tmp, disk)
 }
 
@@ -150,19 +155,25 @@ fn create_empty_qcow_tempfile(num_clusters: usize) -> TempFile {
     tmp
 }
 
-/// Empty QCOW2 opened via QcowDiskSync.
+/// Empty QCOW2 opened via QcowDisk with synchronous backend.
-pub fn empty_qcow_tempfile(num_clusters: usize) -> (TempFile, QcowDiskSync) {
+pub fn empty_qcow_tempfile(num_clusters: usize) -> (TempFile, QcowDisk) {
     let tmp = create_empty_qcow_tempfile(num_clusters);
-    let disk = QcowDiskSync::new(tmp.as_file().try_clone().unwrap(), false, false, true)
+    let disk = QcowDisk::new(
-        .expect("failed to open qcow2 via QcowDiskSync");
+        tmp.as_file().try_clone().unwrap(),
+        false,
+        false,
+        true,
+        false,
+    )
+    .expect("failed to open QCOW2 via QcowDisk");
     (tmp, disk)
 }
 
-/// Empty QCOW2 opened via QcowDiskAsync.
+/// Empty QCOW2 opened via QcowDisk with io_uring backend.
-pub fn empty_qcow_async_tempfile(num_clusters: usize) -> (TempFile, QcowDiskAsync) {
+pub fn empty_qcow_async_tempfile(num_clusters: usize) -> (TempFile, QcowDisk) {
     let tmp = create_empty_qcow_tempfile(num_clusters);
-    let disk = QcowDiskAsync::new(tmp.as_file().try_clone().unwrap(), false, false, true)
+    let disk = QcowDisk::new(tmp.as_file().try_clone().unwrap(), false, false, true, true)
-        .expect("failed to open qcow2 via QcowDiskAsync");
+        .expect("failed to open QCOW2 via QcowDisk");
     (tmp, disk)
 }
 
@@ -196,19 +207,31 @@ fn create_overlay_tempfiles(num_clusters: usize) -> (TempFile, TempFile) {
     (backing, overlay)
 }
 
-/// QCOW2 overlay with raw backing opened via QcowDiskSync.
+/// QCOW2 overlay with raw backing opened via QcowDisk with synchronous backend.
-pub fn qcow_overlay_tempfile(num_clusters: usize) -> (TempFile, TempFile, QcowDiskSync) {
+pub fn qcow_overlay_tempfile(num_clusters: usize) -> (TempFile, TempFile, QcowDisk) {
     let (backing, overlay) = create_overlay_tempfiles(num_clusters);
-    let disk = QcowDiskSync::new(overlay.as_file().try_clone().unwrap(), false, true, true)
+    let disk = QcowDisk::new(
-        .expect("failed to open overlay qcow2 via QcowDiskSync");
+        overlay.as_file().try_clone().unwrap(),
+        false,
+        true,
+        true,
+        false,
+    )
+    .expect("failed to open overlay QCOW2 via QcowDisk");
     (backing, overlay, disk)
 }
 
-/// QCOW2 overlay with raw backing opened via QcowDiskAsync.
+/// QCOW2 overlay with raw backing opened via QcowDisk with io_uring backend.
-pub fn qcow_async_overlay_tempfile(num_clusters: usize) -> (TempFile, TempFile, QcowDiskAsync) {
+pub fn qcow_async_overlay_tempfile(num_clusters: usize) -> (TempFile, TempFile, QcowDisk) {
     let (backing, overlay) = create_overlay_tempfiles(num_clusters);
-    let disk = QcowDiskAsync::new(overlay.as_file().try_clone().unwrap(), false, true, true)
+    let disk = QcowDisk::new(
-        .expect("failed to open overlay qcow2 via QcowDiskAsync");
+        overlay.as_file().try_clone().unwrap(),
+        false,
+        true,
+        true,
+        true,
+    )
+    .expect("failed to open overlay QCOW2 via QcowDisk");
     (backing, overlay, disk)
 }
 
@@ -251,31 +274,33 @@ fn create_compressed_qcow_tempfile(num_clusters: usize) -> TempFile {
     qcow_tmp
 }
 
-/// Compressed QCOW2 opened via QcowDiskSync.
+/// Compressed QCOW2 opened via QcowDisk with synchronous backend.
-pub fn compressed_qcow_tempfile(num_clusters: usize) -> (TempFile, QcowDiskSync) {
+pub fn compressed_qcow_tempfile(num_clusters: usize) -> (TempFile, QcowDisk) {
     let tmp = create_compressed_qcow_tempfile(num_clusters);
     let path = tmp.as_path().to_str().unwrap().to_string();
-    let disk = QcowDiskSync::new(
+    let disk = QcowDisk::new(
         File::open(&path).expect("failed to open compressed qcow2"),
         false,
         false,
         true,
+        false,
     )
-    .expect("failed to open compressed qcow2 via QcowDiskSync");
+    .expect("failed to open compressed QCOW2 via QcowDisk");
     (tmp, disk)
 }
 
-/// Compressed QCOW2 opened via QcowDiskAsync.
+/// Compressed QCOW2 opened via QcowDisk with io_uring backend.
-pub fn compressed_qcow_async_tempfile(num_clusters: usize) -> (TempFile, QcowDiskAsync) {
+pub fn compressed_qcow_async_tempfile(num_clusters: usize) -> (TempFile, QcowDisk) {
     let tmp = create_compressed_qcow_tempfile(num_clusters);
     let path = tmp.as_path().to_str().unwrap().to_string();
-    let disk = QcowDiskAsync::new(
+    let disk = QcowDisk::new(
         File::open(&path).expect("failed to open compressed qcow2"),
         false,
         false,
         true,
+        true,
     )
-    .expect("failed to open compressed qcow2 via QcowDiskAsync");
+    .expect("failed to open compressed QCOW2 via QcowDisk");
     (tmp, disk)
 }
 
@@ -300,19 +325,25 @@ fn create_sparse_qcow_tempfile(num_l2_tables: usize) -> TempFile {
     tmp
 }
 
-/// Sparse QCOW2 opened via QcowDiskSync.
+/// Sparse QCOW2 opened via QcowDisk with synchronous backend.
-pub fn sparse_qcow_tempfile(num_l2_tables: usize) -> (TempFile, QcowDiskSync) {
+pub fn sparse_qcow_tempfile(num_l2_tables: usize) -> (TempFile, QcowDisk) {
     let tmp = create_sparse_qcow_tempfile(num_l2_tables);
-    let disk = QcowDiskSync::new(tmp.as_file().try_clone().unwrap(), false, false, true)
+    let disk = QcowDisk::new(
-        .expect("failed to open qcow2 via QcowDiskSync");
+        tmp.as_file().try_clone().unwrap(),
+        false,
+        false,
+        true,
+        false,
+    )
+    .expect("failed to open QCOW2 via QcowDisk");
     (tmp, disk)
 }
 
-/// Sparse QCOW2 opened via QcowDiskAsync.
+/// Sparse QCOW2 opened via QcowDisk with io_uring backend.
-pub fn sparse_qcow_async_tempfile(num_l2_tables: usize) -> (TempFile, QcowDiskAsync) {
+pub fn sparse_qcow_async_tempfile(num_l2_tables: usize) -> (TempFile, QcowDisk) {
     let tmp = create_sparse_qcow_tempfile(num_l2_tables);
-    let disk = QcowDiskAsync::new(tmp.as_file().try_clone().unwrap(), false, false, true)
+    let disk = QcowDisk::new(tmp.as_file().try_clone().unwrap(), false, false, true, true)
-        .expect("failed to open qcow2 via QcowDiskAsync");
+        .expect("failed to open QCOW2 via QcowDisk");
     (tmp, disk)
 }