Merge branch 'mainline' into PerfTests/go

Author: Shubham Chaturvedi

esdk-performance-testing/benchmarks/go/benchmark/benchmark_tests.go

@@ -8,6 +8,7 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"os"
 	"runtime"
 	"runtime/metrics"
 	"sort"
@@ -117,8 +118,11 @@ func (b *ESDKBenchmark) runThroughputTest(dataSize int, iterations int) (*Benchm
 		endToEndLatencies = append(endToEndLatencies, iterationDuration)
 		totalBytes += int64(dataSize)
 
+		os.Stdout.Sync()
 		bar.Add(1)
+		fmt.Println()
 	}
+	fmt.Println()
 	totalDuration := time.Since(startTime).Seconds()
 
 	// Calculate metrics
@@ -267,11 +271,14 @@ func (b *ESDKBenchmark) runMemoryTest(dataSize int) (*BenchmarkResult, error) {
 		}
 		avgHeapValues = append(avgHeapValues, iterAvgHeap)
 
-		log.Printf("=== Iteration %d === Peak Heap: %.2f MB, Total Allocs: %.2f MB, Avg Heap: %.2f MB (%v, %d samples)",
+		log.Printf("=== Iteration %d === Peak Heap: %.2f MB, Total Allocs: %.2f MB, Avg Heap: %.2f MB (%v, %d samples)\n",
 			i+1, iterPeakHeap, iterTotalAllocs, iterAvgHeap, operationDuration, len(continuousSamples))
 
+		os.Stdout.Sync()
 		bar.Add(1)
+		fmt.Println()
 	}
+	fmt.Println()
 
 	if len(avgHeapValues) == 0 {
 		return nil, fmt.Errorf("all memory test iterations failed")
@@ -340,7 +347,9 @@ func (b *ESDKBenchmark) runConcurrentTest(dataSize int, concurrency int, iterati
 					return
 				}
 				workerTimes = append(workerTimes, time.Since(iterStart).Seconds()*1000)
+				os.Stdout.Sync()
 				bar.Add(1)
+				fmt.Println()
 			}
 
 			timesMutex.Lock()
@@ -350,6 +359,7 @@ func (b *ESDKBenchmark) runConcurrentTest(dataSize int, concurrency int, iterati
 	}
 
 	wg.Wait()
+	fmt.Println()
 	totalDuration := time.Since(startTime).Seconds()
 
 	// Check for errors
@@ -399,6 +409,7 @@ func (b *ESDKBenchmark) runThroughputTests(dataSizes []int, iterations int, over
 			b.Results = append(b.Results, *result)
 			log.Printf("Throughput test completed: %.2f ops/sec", result.OpsPerSecond)
 		}
+		os.Stdout.Sync()
 		overallBar.Add(1)
 	}
 }
@@ -414,6 +425,7 @@ func (b *ESDKBenchmark) runMemoryTests(dataSizes []int, overallBar *progressbar.
 			b.Results = append(b.Results, *result)
 			log.Printf("Memory test completed: %.2f MB peak", result.PeakMemoryMB)
 		}
+		os.Stdout.Sync()
 		overallBar.Add(1)
 	}
 }
@@ -431,6 +443,7 @@ func (b *ESDKBenchmark) runConcurrencyTests(dataSizes []int, concurrencyLevels [
 					b.Results = append(b.Results, *result)
 					log.Printf("Concurrent test completed: %.2f ops/sec @ %d threads", result.OpsPerSecond, concurrency)
 				}
+				os.Stdout.Sync()
 				overallBar.Add(1)
 			}
 		}

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

@@ -0,0 +1,43 @@
+# AWS Encryption SDK Python Benchmark
+
+Performance testing suite for the AWS Encryption SDK Python implementation.
+
+## Quick Start
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run benchmark
+python esdk_benchmark.py
+
+# Quick test (reduced iterations)
+python esdk_benchmark.py --quick
+```
+
+## Options
+
+- `--config` - Path to test configuration file (default: `../../config/test-scenarios.yaml`)
+- `--output` - Path to output results file (default: `../../results/raw-data/python_results.json`)
+- `--quick` - Run with reduced iterations for faster testing
+
+## Configuration
+
+Edit `../../config/test-scenarios.yaml` for test parameters:
+
+- Data sizes (small/medium/large)
+- Iterations and concurrency levels
+
+## Test Types
+
+- **Throughput** - Measures encryption/decryption operations per second
+- **Memory** - Tracks memory usage and allocations during operations
+- **Concurrency** - Tests performance under concurrent load
+
+## Output
+
+Results saved as JSON to `../../results/raw-data/python_results.json` with:
+
+- Performance metrics (ops/sec, latency percentiles)
+- Memory usage (peak, average, allocations, input data to memory ratio)
+- System information (CPU, memory, Python version)

esdk-performance-testing/benchmarks/python/benchmark.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+Core benchmark module for ESDK Python benchmark
+"""
+
+import logging
+import multiprocessing
+import secrets
+import sys
+
+import psutil
+from aws_cryptographic_material_providers.mpl import AwsCryptographicMaterialProviders
+from aws_cryptographic_material_providers.mpl.config import MaterialProvidersConfig
+from aws_cryptographic_material_providers.mpl.models import (
+    AesWrappingAlg,
+    CreateRawAesKeyringInput,
+)
+from aws_encryption_sdk import EncryptionSDKClient, CommitmentPolicy
+from config import load_config
+
+
+class ESDKBenchmark:
+    """Main benchmark class for ESDK Python performance testing"""
+
+    def __init__(self, config_path: str = "../../config/test-scenarios.yaml"):
+        self.config = load_config(config_path)
+        self.results = []
+
+        self._setup_logging()
+        self._setup_esdk()
+        self._setup_system_info()
+
+    def _setup_system_info(self):
+        """Initialize system information"""
+        self.cpu_count = multiprocessing.cpu_count()
+        self.total_memory_gb = psutil.virtual_memory().total / (1024**3)
+
+        self.logger.info(
+            f"Initialized ESDK Benchmark - CPU cores: {self.cpu_count}, "
+            f"Memory: {self.total_memory_gb:.1f}GB"
+        )
+
+    def _setup_logging(self):
+        """Setup logging configuration"""
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(message)s",
+            handlers=[logging.StreamHandler(sys.stdout)],
+        )
+        # Suppress AWS SDK logging
+        logging.getLogger("aws_encryption_sdk").setLevel(logging.WARNING)
+        logging.getLogger("botocore").setLevel(logging.WARNING)
+        logging.getLogger("boto3").setLevel(logging.WARNING)
+
+        self.logger = logging.getLogger(__name__)
+
+    def _setup_esdk(self):
+        """Initialize ESDK client and raw AES keyring"""
+        try:
+            self.keyring = self._create_keyring()
+            self.esdk_client = self._create_client()
+            self.logger.info("ESDK client initialized successfully")
+        except Exception as e:
+            self.logger.error(f"Failed to initialize ESDK: {e}")
+            raise
+
+    def _create_keyring(self):
+        """Create raw AES keyring"""
+        static_key = secrets.token_bytes(32)
+        mat_prov = AwsCryptographicMaterialProviders(config=MaterialProvidersConfig())
+
+        keyring_input = CreateRawAesKeyringInput(
+            key_namespace="esdk-performance-test",
+            key_name="test-aes-256-key",
+            wrapping_key=static_key,
+            wrapping_alg=AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16,
+        )
+
+        return mat_prov.create_raw_aes_keyring(input=keyring_input)
+
+    def _create_client(self):
+        """Create ESDK client"""
+        return EncryptionSDKClient(
+            commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
+        )
+
+    def should_run_test_type(self, test_type: str, is_quick_mode: bool = False) -> bool:
+        """Determine if a test type should be run based on configuration"""
+        if is_quick_mode:
+            quick_config = self.config.get("quick_config")
+            if quick_config and "test_types" in quick_config:
+                return test_type in quick_config["test_types"]
+        return True

esdk-performance-testing/benchmarks/python/config.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+"""
+Configuration module for ESDK Python benchmark
+"""
+
+import yaml
+
+
+def load_config(config_path: str):
+    """Load test configuration from YAML file"""
+    try:
+        with open(config_path, "r") as f:
+            return yaml.safe_load(f)
+    except FileNotFoundError:
+        raise FileNotFoundError(f"Config file not found: {config_path}")
+    except Exception as e:
+        raise RuntimeError(f"Failed to parse config file: {e}")

esdk-performance-testing/benchmarks/python/esdk_benchmark.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+ESDK Performance Benchmark Suite - Python Implementation
+
+This module provides comprehensive performance testing for the AWS Encryption SDK (ESDK)
+Python runtime, measuring throughput, latency, memory usage, and scalability.
+"""
+
+import sys
+import argparse
+from benchmark import ESDKBenchmark
+from tests import run_all_benchmarks
+
+
+def main():
+    """Main entry point for the benchmark suite"""
+    args = _parse_arguments()
+
+    try:
+        benchmark = ESDKBenchmark(config_path=args.config)
+
+        if args.quick:
+            _adjust_config_for_quick_mode(benchmark)
+
+        results = run_all_benchmarks(benchmark, is_quick_mode=args.quick)
+
+        _save_and_summarize_results(results, args.output)
+
+    except Exception as e:
+        print(f"Benchmark failed: {e}")
+        sys.exit(1)
+
+
+def _parse_arguments():
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(description="ESDK Python Performance Benchmark")
+    parser.add_argument(
+        "--config",
+        default="../../config/test-scenarios.yaml",
+        help="Path to test configuration file",
+    )
+    parser.add_argument(
+        "--output",
+        default="../../results/raw-data/python_results.json",
+        help="Path to output results file",
+    )
+    parser.add_argument(
+        "--quick", action="store_true", help="Run quick test with reduced iterations"
+    )
+    return parser.parse_args()
+
+
+def _adjust_config_for_quick_mode(benchmark):
+    """Adjust benchmark configuration for quick mode"""
+    quick_config = benchmark.config.get("quick_config")
+    if not quick_config:
+        raise RuntimeError(
+            "Quick mode requested but no quick_config found in config file"
+        )
+
+    benchmark.config["iterations"]["measurement"] = quick_config["iterations"][
+        "measurement"
+    ]
+    benchmark.config["iterations"]["warmup"] = quick_config["iterations"]["warmup"]
+    benchmark.config["data_sizes"]["small"] = quick_config["data_sizes"]["small"]
+    benchmark.config["data_sizes"]["medium"] = []
+    benchmark.config["data_sizes"]["large"] = []
+    benchmark.config["concurrency_levels"] = quick_config["concurrency_levels"]
+
+
+def _save_and_summarize_results(results, output_path):
+    """Save results and print summary"""
+    from results import save_results
+
+    save_results(results, output_path)
+
+    print("\n=== ESDK Python Benchmark Summary ===")
+    print(f"Total tests completed: {len(results)}")
+    print(f"Results saved to: {output_path}")
+
+    if results:
+        throughput_results = [r for r in results if r.test_name == "throughput"]
+        if throughput_results:
+            max_throughput = max(r.ops_per_second for r in throughput_results)
+            print("Maximum throughput: {:.2f} ops/sec".format(max_throughput))
+
+
+if __name__ == "__main__":
+    main()

esdk-performance-testing/benchmarks/python/requirements.txt

@@ -0,0 +1,15 @@
+# ESDK Performance Testing - Python Dependencies
+
+# Core dependencies
+pyyaml>=6.0
+psutil>=5.9.0
+
+# Performance measurement
+memory-profiler>=0.61.0
+
+# Progress and logging
+tqdm>=4.65.0
+
+# AWS and ESDK dependencies
+aws-encryption-sdk>=4.0.1
+aws-cryptographic-material-providers>=1.11.0