adaptions for proxmox 0.9 and proxmox-api-macro 0.3

[proxmox-backup.git] / src / bin / proxmox_backup_client / benchmark.rs

diff --git a/src/bin/proxmox_backup_client/benchmark.rs b/src/bin/proxmox_backup_client/benchmark.rs
index 9830c183243fe1aa8c2f68ad1f3bdae1ccc8f463..2ecb3dc9b6449efc5f61a4b0759481cf7b20f347 100644 (file)
--- a/src/bin/proxmox_backup_client/benchmark.rs
+++ b/src/bin/proxmox_backup_client/benchmark.rs
@@ -3,7 +3,6 @@ use std::sync::Arc;
 
 use anyhow::{Error};
 use serde_json::Value;
-use chrono::Utc;
 use serde::Serialize;
 
 use proxmox::api::{ApiMethod, RpcEnvironment};
@@ -16,12 +15,14 @@ use proxmox::api::{
         format_and_print_result_full,
         default_table_format_options,
     },
+    router::ReturnType,
 };
 
 use proxmox_backup::backup::{
     load_and_decrypt_key,
     CryptConfig,
     KeyDerivationConfig,
+    DataChunkBuilder,
 };
 
 use proxmox_backup::client::*;
@@ -61,6 +62,9 @@ struct Speed {
         "aes256_gcm": {
             type: Speed,
         },
+        "verify": {
+            type: Speed,
+        },
     },
 )]
 #[derive(Copy, Clone, Serialize)]
@@ -76,29 +80,34 @@ struct BenchmarkResult {
     decompress: Speed,
     /// AES256 GCM encryption speed
     aes256_gcm: Speed,
+    /// Verify speed
+    verify: Speed,
 }
 
-
 static BENCHMARK_RESULT_2020_TOP: BenchmarkResult =  BenchmarkResult {
     tls: Speed {
         speed: None,
-        top: 1_000_000.0 * 690.0, // TLS to localhost, AMD Ryzen 7 2700X
+        top: 1_000_000.0 * 1235.0, // TLS to localhost, AMD Ryzen 7 2700X
     },
     sha256: Speed {
         speed: None,
-        top: 1_000_000.0 * 2120.0, // AMD Ryzen 7 2700X
+        top: 1_000_000.0 * 2022.0, // AMD Ryzen 7 2700X
     },
     compress: Speed {
         speed: None,
-        top: 1_000_000.0 * 2158.0, // AMD Ryzen 7 2700X
+        top: 1_000_000.0 * 752.0, // AMD Ryzen 7 2700X
     },
     decompress: Speed {
         speed: None,
-        top: 1_000_000.0 * 8062.0, // AMD Ryzen 7 2700X
+        top: 1_000_000.0 * 1198.0, // AMD Ryzen 7 2700X
     },
     aes256_gcm: Speed {
         speed: None,
-        top: 1_000_000.0 * 3803.0, // AMD Ryzen 7 2700X
+        top: 1_000_000.0 * 3645.0, // AMD Ryzen 7 2700X
+    },
+    verify: Speed {
+        speed: None,
+        top: 1_000_000.0 * 758.0, // AMD Ryzen 7 2700X
     },
 };
 
@@ -143,7 +152,7 @@ pub async fn benchmark(
     let crypt_config = match keyfile {
         None => None,
         Some(path) => {
-            let (key, _) = load_and_decrypt_key(&path, &crate::key::get_encryption_key_password)?;
+            let (key, _, _) = load_and_decrypt_key(&path, &crate::key::get_encryption_key_password)?;
             let crypt_config = CryptConfig::new(key)?;
             Some(Arc::new(crypt_config))
         }
@@ -170,7 +179,7 @@ fn render_result(
 ) -> Result<(), Error> {
 
     let mut data = serde_json::to_value(benchmark_result)?;
-    let schema = &BenchmarkResult::API_SCHEMA;
+    let return_type = ReturnType::new(false, &BenchmarkResult::API_SCHEMA);
 
     let render_speed = |value: &Value, _record: &Value| -> Result<String, Error> {
         match value["speed"].as_f64() {
@@ -195,12 +204,15 @@ fn render_result(
         .column(ColumnConfig::new("decompress")
                 .header("ZStd level 1 decompression speed")
                 .right_align(false).renderer(render_speed))
-        .column(ColumnConfig::new("aes256_gcm")
+        .column(ColumnConfig::new("verify")
+                .header("Chunk verification speed")
+                .right_align(false).renderer(render_speed))
+       .column(ColumnConfig::new("aes256_gcm")
                 .header("AES256 GCM encryption speed")
                 .right_align(false).renderer(render_speed));
 
 
-    format_and_print_result_full(&mut data, schema, output_format, &options);
+    format_and_print_result_full(&mut data, &return_type, output_format, &options);
 
     Ok(())
 }
@@ -212,9 +224,9 @@ async fn test_upload_speed(
     verbose: bool,
 ) -> Result<(), Error> {
 
-    let backup_time = Utc::now();
+    let backup_time = proxmox::tools::time::epoch_i64();
 
-    let client = connect(repo.host(), repo.user())?;
+    let client = connect(&repo)?;
     record_repository(&repo);
 
     if verbose { eprintln!("Connecting to backup server"); }
@@ -258,7 +270,17 @@ fn test_crypt_speed(
 
     let crypt_config = CryptConfig::new(testkey)?;
 
-    let random_data = proxmox::sys::linux::random_data(1024*1024)?;
+    //let random_data = proxmox::sys::linux::random_data(1024*1024)?;
+    let mut random_data = vec![];
+        // generate pseudo random byte sequence
+        for i in 0..256*1024 {
+            for j in 0..4 {
+                let byte = ((i >> (j<<3))&0xff) as u8;
+                random_data.push(byte);
+            }
+        }
+
+    assert_eq!(random_data.len(), 1024*1024);
 
     let start_time = std::time::Instant::now();
 
@@ -323,5 +345,23 @@ fn test_crypt_speed(
 
     eprintln!("AES256/GCM speed: {:.2} MB/s", speed/1_000_000_.0);
 
+
+    let start_time = std::time::Instant::now();
+
+    let (chunk, digest) = DataChunkBuilder::new(&random_data)
+        .compress(true)
+        .build()?;
+
+    let mut bytes = 0;
+    loop  {
+        chunk.verify_unencrypted(random_data.len(), &digest)?;
+        bytes += random_data.len();
+        if start_time.elapsed().as_micros() > 1_000_000 { break; }
+    }
+    let speed = (bytes as f64)/start_time.elapsed().as_secs_f64();
+    benchmark_result.verify.speed = Some(speed);
+
+    eprintln!("Verify speed: {:.2} MB/s", speed/1_000_000_.0);
+
     Ok(())
 }