PerfTest: rust

Author: Shubham Chaturvedi

esdk-performance-testing/benchmarks/rust/Cargo.lock

@@ -0,0 +1,61 @@
+[package]
+name = "esdk-benchmark"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "esdk_benchmark"
+path = "src/main.rs"
+
+[dependencies]
+# AWS Encryption SDK
+aws-esdk = { path = "../../../AwsEncryptionSDK/runtimes/rust" }
+
+# Async runtime
+tokio = { version = "1.0", features = ["full"] }
+
+# Serialization
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+serde_yaml = "0.9"
+
+# CLI and progress
+clap = { version = "4.0", features = ["derive"] }
+indicatif = "0.17"
+
+# Statistics and benchmarking
+hdrhistogram = "7.5"
+rand = "0.8"
+
+# System info
+sysinfo = "0.30"
+
+# Error handling
+anyhow = "1.0"
+thiserror = "1.0"
+
+# Logging
+log = "0.4"
+env_logger = "0.10"
+
+# Time
+chrono = { version = "0.4", features = ["serde"] }
+
+# Memory profiling
+memory-stats = "1.0"
+stats_alloc = "0.1"
+
+# Async utilities
+futures = "0.3"
+
+# Override AWS SDK versions to be compatible with Rust 1.85.0
+aws-config = "1.8.6"
+aws-sdk-dynamodb = "1.73.0"
+aws-sdk-kms = "1.67.0"
+aws-sdk-sso = "1.69.0"
+aws-sdk-ssooidc = "1.69.0"
+aws-sdk-sts = "1.69.0"
+aws-smithy-types = "1.2"
+
+[dev-dependencies]
+criterion = { version = "0.5", features = ["html_reports"] }

esdk-performance-testing/benchmarks/rust/Cargo.toml

@@ -0,0 +1,65 @@
+# ESDK Rust Performance Benchmark
+
+Rust implementation of the AWS Encryption SDK performance benchmark suite.
+
+## Features
+
+- **Throughput**: Operations per second and latency analysis (P50, P95, P99)
+- **Memory**: Peak memory consumption monitoring
+- **Concurrency**: Multi-threaded performance testing
+- **Raw AES Keyring**: Local 256-bit AES keys (no KMS dependency)
+
+## Prerequisites
+
+- Rust 1.70.0+ ([rustup.rs](https://rustup.rs/))
+- Build tools (Xcode CLI Tools on macOS, build-essential on Linux)
+
+## Quick Start
+
+```bash
+# Build and run
+cargo build --release
+./target/release/esdk_benchmark --config ../../config/test-scenarios.yaml
+
+# Quick test (requires quick_config in YAML)
+./target/release/esdk_benchmark --quick
+```
+
+## Configuration
+
+### Command Line
+- `--config`: Path to YAML config file (required)
+- `--output`: Results output path (default: `../../results/raw-data/rust_results.json`)
+- `--quick`: Quick test mode (requires `quick_config` section in YAML)
+
+## Logging
+
+Default: info level. Override with `RUST_LOG`:
+```bash
+RUST_LOG=debug ./target/release/esdk_benchmark --config config.yaml
+```
+
+## Development
+
+```bash
+# Format and lint
+cargo fmt
+cargo clippy -- -D warnings
+
+# Test
+cargo test
+
+# Debug build
+cargo build
+RUST_LOG=debug ./target/debug/esdk_benchmark --config config.yaml
+```
+
+## Troubleshooting
+
+- **Build issues**: `rustup update && cargo clean && cargo build --release`
+- **Config issues**: Validate YAML syntax and check file permissions
+- **Memory issues**: Monitor with `htop` or Activity Monitor
+
+## License
+
+Apache License 2.0

esdk-performance-testing/benchmarks/rust/README.md

@@ -0,0 +1,99 @@
+// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use anyhow::{Context, Result};
+use aws_esdk::client as esdk_client;
+use aws_esdk::material_providers::client as mpl_client;
+use aws_esdk::material_providers::types::material_providers_config::MaterialProvidersConfig;
+use aws_esdk::material_providers::types::AesWrappingAlg;
+use aws_esdk::material_providers::types::EsdkCommitmentPolicy;
+use aws_esdk::types::aws_encryption_sdk_config::AwsEncryptionSdkConfig;
+use log::info;
+use rand::Rng;
+use sysinfo::System;
+
+use crate::config::{load_config, TestConfig};
+use crate::results::BenchmarkResult;
+
+// Constants for memory testing
+pub const MEMORY_TEST_ITERATIONS: usize = 5;
+
+pub struct EsdkBenchmark {
+    pub esdk_client: esdk_client::Client,
+    pub raw_keyring: aws_esdk::material_providers::types::keyring::KeyringRef,
+    pub config: TestConfig,
+    pub results: Vec<BenchmarkResult>,
+    pub cpu_count: usize,
+    pub total_memory_gb: f64,
+}
+
+impl EsdkBenchmark {
+    pub async fn new(config_path: &str) -> Result<Self> {
+        // Get system info
+        let mut system = System::new_all();
+        system.refresh_all();
+        let cpu_count = system.cpus().len();
+        let total_memory_gb = system.total_memory() as f64 / (1024.0 * 1024.0 * 1024.0);
+
+        // Load configuration
+        let config = load_config(config_path)?;
+
+        // Setup ESDK
+        let (esdk_client, raw_keyring) = Self::setup_esdk().await?;
+
+        info!(
+            "Initialized ESDK Benchmark - CPU cores: {}, Memory: {:.1}GB",
+            cpu_count, total_memory_gb
+        );
+
+        Ok(Self {
+            esdk_client,
+            raw_keyring,
+            config,
+            results: Vec::new(),
+            cpu_count,
+            total_memory_gb,
+        })
+    }
+
+    async fn setup_esdk() -> Result<(
+        esdk_client::Client,
+        aws_esdk::material_providers::types::keyring::KeyringRef,
+    )> {
+        // Initialize ESDK client with commitment policy
+        let esdk_config = AwsEncryptionSdkConfig::builder()
+            .commitment_policy(EsdkCommitmentPolicy::RequireEncryptRequireDecrypt)
+            .build()?;
+        let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
+
+        // Initialize material providers client
+        let mpl_config = MaterialProvidersConfig::builder().build()?;
+        let mpl_client = mpl_client::Client::from_conf(mpl_config)?;
+
+        // Create default AES-256 keyring
+        let mut key = [0u8; 32]; // 256-bit key
+        rand::thread_rng().fill(&mut key);
+
+        let raw_keyring = mpl_client
+            .create_raw_aes_keyring()
+            .key_name("test-aes-256-key")
+            .key_namespace("esdk-performance-test")
+            .wrapping_key(key.to_vec())
+            .wrapping_alg(AesWrappingAlg::AlgAes256GcmIv12Tag16)
+            .send()
+            .await
+            .context("Failed to create keyring")?;
+
+        info!("ESDK client initialized successfully");
+        Ok((esdk_client, raw_keyring))
+    }
+
+    pub fn save_results(&self, output_path: &str) -> Result<()> {
+        crate::results::save_results(
+            &self.results,
+            output_path,
+            self.cpu_count,
+            self.total_memory_gb,
+        )
+    }
+}

esdk-performance-testing/benchmarks/rust/src/benchmark.rs

@@ -0,0 +1,60 @@
+// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
+use std::fs;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TestConfig {
+    pub data_sizes: DataSizes,
+    pub iterations: IterationConfig,
+    pub concurrency_levels: Vec<usize>,
+    pub quick_config: Option<QuickConfig>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DataSizes {
+    pub small: Vec<usize>,
+    pub medium: Vec<usize>,
+    pub large: Vec<usize>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IterationConfig {
+    pub warmup: usize,
+    pub measurement: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct QuickConfig {
+    pub data_sizes: QuickDataSizes,
+    pub iterations: QuickIterationConfig,
+    pub concurrency_levels: Vec<usize>,
+    pub test_types: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct QuickDataSizes {
+    pub small: Vec<usize>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct QuickIterationConfig {
+    pub warmup: usize,
+    pub measurement: usize,
+}
+
+pub fn load_config(config_path: &str) -> Result<TestConfig> {
+    if !std::path::Path::new(config_path).exists() {
+        return Err(anyhow::anyhow!("Config file not found: {}", config_path));
+    }
+
+    let config_content = fs::read_to_string(config_path)
+        .with_context(|| format!("Failed to read config file: {}", config_path))?;
+
+    let config: TestConfig =
+        serde_yaml::from_str(&config_content).with_context(|| "Failed to parse config file")?;
+
+    Ok(config)
+}

esdk-performance-testing/benchmarks/rust/src/config.rs

@@ -0,0 +1,89 @@
+// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+mod benchmark;
+mod config;
+mod results;
+mod tests;
+
+use anyhow::Result;
+use clap::{Arg, Command};
+
+use benchmark::EsdkBenchmark;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    env_logger::Builder::from_default_env()
+        .filter_level(log::LevelFilter::Info)
+        .init();
+
+    let matches = Command::new("ESDK Rust Benchmark")
+        .version("1.0")
+        .about("AWS Encryption SDK Performance Benchmark Suite - Rust Implementation")
+        .arg(
+            Arg::new("config")
+                .long("config")
+                .value_name("FILE")
+                .help("Path to test configuration file")
+                .default_value("../../config/test-scenarios.yaml"),
+        )
+        .arg(
+            Arg::new("output")
+                .long("output")
+                .value_name("FILE")
+                .help("Path to output results file")
+                .default_value("../../results/raw-data/rust_results.json"),
+        )
+        .arg(
+            Arg::new("quick")
+                .long("quick")
+                .help("Run quick test with reduced iterations")
+                .action(clap::ArgAction::SetTrue),
+        )
+        .get_matches();
+
+    let config_path = matches.get_one::<String>("config").unwrap();
+    let output_path = matches.get_one::<String>("output").unwrap();
+    let quick = matches.get_flag("quick");
+
+    // Initialize benchmark
+    let mut bench = EsdkBenchmark::new(config_path).await?;
+
+    // Adjust config for quick test
+    if quick {
+        let quick_config = bench.config.quick_config.as_ref()
+            .ok_or_else(|| anyhow::anyhow!("Quick mode requested but no quick_config found in config file"))?;
+        
+        bench.config.iterations.measurement = quick_config.iterations.measurement;
+        bench.config.iterations.warmup = quick_config.iterations.warmup;
+        bench.config.data_sizes.small = quick_config.data_sizes.small.clone();
+        bench.config.data_sizes.medium = Vec::new();
+        bench.config.data_sizes.large = Vec::new();
+        bench.config.concurrency_levels = quick_config.concurrency_levels.clone();
+    }
+
+    // Run benchmarks
+    bench.run_all_benchmarks().await?;
+
+    // Save results
+    bench.save_results(output_path)?;
+
+    // Print summary
+    println!("\n=== ESDK Rust Benchmark Summary ===");
+    println!("Total tests completed: {}", bench.results.len());
+    println!("Results saved to: {}", output_path);
+
+    if !bench.results.is_empty() {
+        let mut max_throughput = 0.0;
+        for result in &bench.results {
+            if result.test_name == "throughput" && result.ops_per_second > max_throughput {
+                max_throughput = result.ops_per_second;
+            }
+        }
+        if max_throughput > 0.0 {
+            println!("Maximum throughput: {:.2} ops/sec", max_throughput);
+        }
+    }
+
+    Ok(())
+}