diff --git a/db-esdk-performance-testing/benchmarks/config/test-scenarios.yaml b/db-esdk-performance-testing/benchmarks/config/test-scenarios.yaml new file mode 100644 index 000000000..bfa825930 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/config/test-scenarios.yaml @@ -0,0 +1,56 @@ +# DB-ESDK Performance Test Scenarios Configuration + +# Data sizes to test (in bytes) +# Categories are for organization only - code processes all sizes regardless of category +data_sizes: + small: + - 1024 # 1KB + - 5120 # 5KB + - 10240 # 10KB + medium: + - 102400 # 100KB + - 512000 # 500KB + - 1048576 # 1MB + - 10000000 # 10 MB + large: + - 10485760 # 10MB + - 52428800 # 50MB + - 104857600 # 100MB + +# Quick test configuration (reduced test set for faster execution) +quick_config: + data_sizes: + small: + - 204904 # 200KB + - 400000 # 400KB + - 1000000 # 1MB + - 10000000 # 10MB + iterations: + warmup: 3 # Reduced warmup iterations + measurement: 3 # Reduced measurement iterations + concurrency_levels: + - 1 + - 2 + test_types: + - "throughput" + - "memory" + - "concurrency" + +# Test iterations for statistical significance +iterations: + warmup: 5 # Warmup iterations (not counted) + measurement: 10 # Measurement iterations + +# Concurrency levels to test +concurrency_levels: + - 1 + - 2 + - 4 + - 8 + - 16 + +# DynamoDB table name +table_name: "dbesdk-performance-testing" + +# Keyring +keyring: "raw-aes" \ No newline at end of file diff --git a/db-esdk-performance-testing/benchmarks/java/README.md b/db-esdk-performance-testing/benchmarks/java/README.md new file mode 100644 index 000000000..71201edd6 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/java/README.md @@ -0,0 +1,190 @@ +# DB-ESDK Performance Benchmark - Java + +This directory contains the Java implementation of the AWS Database Encryption SDK (DB-ESDK) performance benchmark suite. + +## Overview + +The Java benchmark provides comprehensive performance testing for the DB-ESDK Java runtime, measuring: + +- **Throughput**: Operations per second and bytes per second using DynamoDB batch operations +- **Latency**: Put, get, and end-to-end timing for encrypted DynamoDB operations +- **Memory Usage**: Peak memory consumption and efficiency +- **Concurrency**: Multi-threaded performance scaling +- **Statistical Analysis**: P50, P95, P99 latency percentiles + +## Prerequisites + +- Java 17 or higher +- Maven 3.6 or higher +- Local DynamoDB instance running on localhost:8000 +- Access to AWS Database Encryption SDK for DynamoDB Java libraries + +## Local DynamoDB Setup + +Start a local DynamoDB instance: + +```bash +# Using Docker +docker run -p 8000:8000 amazon/dynamodb-local + +# Or download and run DynamoDB Local +java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb -port 8000 +``` + +Create the test table: + +```bash +aws dynamodb create-table \ + --table-name db-esdk-performance-test \ + --attribute-definitions \ + AttributeName=partition_key,AttributeType=S \ + AttributeName=sort_key,AttributeType=N \ + --key-schema \ + AttributeName=partition_key,KeyType=HASH \ + AttributeName=sort_key,KeyType=RANGE \ + --billing-mode PAY_PER_REQUEST \ + --endpoint-url http://localhost:8000 +``` + +## Building + +```bash +# Build the project +mvn clean compile + +# Create executable JAR +mvn clean package + +# Run tests +mvn test +``` + +## Running Benchmarks + +### Quick Test + +```bash +# Using Maven +mvn exec:java -Dexec.mainClass="com.amazon.esdk.benchmark.Program" -Dexec.args="--quick" + +# Using JAR +java -jar target/esdk-benchmark.jar --quick +``` + +### Full Benchmark Suite + +```bash +# Using Maven +mvn exec:java -Dexec.mainClass="com.amazon.esdk.benchmark.Program" + +# Using JAR +java -jar target/esdk-benchmark.jar +``` + +### Custom Configuration + +```bash +# Specify custom config and output paths +java -jar target/esdk-benchmark.jar \ + --config /path/to/config.yaml \ + --output /path/to/results.json +``` + +## Command Line Options + +- `--config, -c`: Path to test configuration file (default: `../../config/test-scenarios.yaml`) +- `--output, -o`: Path to output results file (default: `../../results/raw-data/java_results.json`) +- `--quick, -q`: Run quick test with reduced iterations +- `--help, -h`: Show help message + +## Configuration + +The benchmark uses a YAML configuration file to define test parameters: + +```yaml +data_sizes: + small: [1024, 5120, 10240] + medium: [102400, 512000, 1048576] + large: [10485760, 52428800, 104857600] + +iterations: + warmup: 5 + measurement: 10 + +concurrency_levels: [1, 2, 4, 8] +``` + +## Output Format + +Results are saved in JSON format with the following structure: + +```json +{ + "metadata": { + "language": "java", + "timestamp": "2025-09-05T15:30:00Z", + "javaVersion": "17.0.2", + "cpuCount": 8, + "totalMemoryGB": 16.0, + "totalTests": 45 + }, + "results": [ + { + "test_name": "throughput", + "language": "java", + "data_size": 1024, + "concurrency": 1, + "put_latency_ms": 0.85, + "get_latency_ms": 0.72, + "end_to_end_latency_ms": 1.57, + "ops_per_second": 636.94, + "bytes_per_second": 652224.0, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 1.55, + "p95_latency": 1.89, + "p99_latency": 2.12, + "timestamp": "2025-09-05T15:30:15Z", + "java_version": "17.0.2", + "cpu_count": 8, + "total_memory_gb": 16.0 + } + ] +} +``` + +## Key Features + +### DB-ESDK Integration +- Uses AWS Database Encryption SDK for DynamoDB with transparent encryption +- Configures attribute actions (ENCRYPT_AND_SIGN, SIGN_ONLY, DO_NOTHING) +- Tests actual DynamoDB operations with client-side encryption +- Uses Raw AES keyring for consistent performance testing + +### Batch Operations +- Performs BatchWriteItem operations with 25 items per batch +- Measures BatchGetItem operations with consistent reads +- Tests realistic DynamoDB workloads with encryption overhead + +### Performance Metrics +- **Throughput Tests**: Measures ops/sec and bytes/sec for batch operations +- **Memory Tests**: Tracks peak memory usage during encrypted operations +- **Concurrency Tests**: Evaluates multi-threaded performance scaling +- **Latency Analysis**: P50, P95, P99 percentiles for operation timing + +## Dependencies + +Key dependencies used in this benchmark: + +- **AWS Database Encryption SDK for DynamoDB**: Core encryption functionality for DynamoDB +- **AWS Cryptographic Material Providers**: Keyring and cryptographic material management +- **AWS SDK for Java v2 DynamoDB**: DynamoDB client operations +- **Jackson**: JSON/YAML processing +- **Commons CLI**: Command line argument parsing +- **ProgressBar**: Visual progress indication +- **SLF4J**: Logging framework +- **JUnit**: Unit testing (test scope) + +## License + +This benchmark suite is part of the AWS Encryption SDK project and follows the same licensing terms. diff --git a/db-esdk-performance-testing/benchmarks/java/pom.xml b/db-esdk-performance-testing/benchmarks/java/pom.xml new file mode 100644 index 000000000..15634f36a --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/java/pom.xml @@ -0,0 +1,255 @@ + + + 4.0.0 + + com.amazon.esdk + esdk-performance-benchmark + 1.0.0 + jar + + ESDK Performance Benchmark - Java + Performance benchmarking suite for AWS Encryption SDK Java runtime + + + 17 + 17 + UTF-8 + + + 2.15.2 + 0.9.5 + 1.5.0 + 2.0.7 + 5.10.0 + + + + + + + software.amazon.awssdk + bom + 2.33.3 + pom + import + + + + + + + + software.amazon.cryptography + aws-database-encryption-sdk-dynamodb + 3.9.0 + + + + + software.amazon.cryptography + aws-cryptographic-material-providers + 1.11.0 + + + + + software.amazon.awssdk + dynamodb + + + + + com.fasterxml.jackson.core + jackson-databind + ${jackson.version} + + + com.fasterxml.jackson.dataformat + jackson-dataformat-yaml + ${jackson.version} + + + + + me.tongfei + progressbar + ${progressbar.version} + + + + + commons-cli + commons-cli + ${commons.cli.version} + + + + + org.slf4j + slf4j-api + ${slf4j.version} + + + + + org.junit.jupiter + junit-jupiter-engine + ${junit.version} + test + + + org.junit.jupiter + junit-jupiter-api + ${junit.version} + test + + + + + + + org.codehaus.mojo + exec-maven-plugin + 3.1.0 + + com.example.Main + + -Xmx32g + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + 17 + UTF-8 + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.1.2 + + + **/*Test.java + + + + + + + org.apache.maven.plugins + maven-shade-plugin + 3.5.0 + + + package + + shade + + + + + com.amazon.esdk.benchmark.Program + + + + + *:* + + META-INF/*.SF + META-INF/*.DSA + META-INF/*.RSA + + + + + + + + + + + org.codehaus.mojo + exec-maven-plugin + 3.1.0 + + com.amazon.esdk.benchmark.Program + + + + + + + + + + org.apache.maven.plugins + maven-clean-plugin + 3.3.1 + + + + + org.apache.maven.plugins + maven-resources-plugin + 3.3.1 + + + + + org.apache.maven.plugins + maven-jar-plugin + 3.3.0 + + + + + org.apache.maven.plugins + maven-install-plugin + 3.1.1 + + + + + org.apache.maven.plugins + maven-deploy-plugin + 3.1.1 + + + + + com.diffplug.spotless + spotless-maven-plugin + 2.40.0 + + + + 1.17.0 + + + + + + + + + + + + + + central + Maven Central Repository + https://repo1.maven.org/maven2 + + + diff --git a/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/ESDKBenchmark.java b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/ESDKBenchmark.java new file mode 100644 index 000000000..c67c59150 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/ESDKBenchmark.java @@ -0,0 +1,326 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package com.amazon.esdk.benchmark; + +import com.amazon.esdk.benchmark.model.Config; +import com.amazon.esdk.benchmark.model.TestResult; +import java.lang.management.ManagementFactory; +import java.net.URI; +import java.nio.ByteBuffer; +import java.security.SecureRandom; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import javax.crypto.KeyGenerator; +import javax.crypto.SecretKey; +import me.tongfei.progressbar.ProgressBar; +import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration; +import software.amazon.awssdk.core.SdkBytes; +import software.amazon.awssdk.services.dynamodb.DynamoDbClient; +import software.amazon.awssdk.services.dynamodb.model.AttributeDefinition; +import software.amazon.awssdk.services.dynamodb.model.AttributeValue; +import software.amazon.awssdk.services.dynamodb.model.BatchGetItemRequest; +import software.amazon.awssdk.services.dynamodb.model.BatchGetItemResponse; +import software.amazon.awssdk.services.dynamodb.model.BatchWriteItemRequest; +import software.amazon.awssdk.services.dynamodb.model.BatchWriteItemResponse; +import software.amazon.awssdk.services.dynamodb.model.BillingMode; +import software.amazon.awssdk.services.dynamodb.model.CreateTableRequest; +import software.amazon.awssdk.services.dynamodb.model.DescribeTableRequest; +import software.amazon.awssdk.services.dynamodb.model.KeySchemaElement; +import software.amazon.awssdk.services.dynamodb.model.KeyType; +import software.amazon.awssdk.services.dynamodb.model.KeysAndAttributes; +import software.amazon.awssdk.services.dynamodb.model.PutRequest; +import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException; +import software.amazon.awssdk.services.dynamodb.model.ScalarAttributeType; +import software.amazon.awssdk.services.dynamodb.model.WriteRequest; +import software.amazon.cryptography.dbencryptionsdk.dynamodb.DynamoDbEncryptionInterceptor; +import software.amazon.cryptography.dbencryptionsdk.dynamodb.itemencryptor.DynamoDbItemEncryptor; +import software.amazon.cryptography.dbencryptionsdk.dynamodb.itemencryptor.model.DecryptItemInput; +import software.amazon.cryptography.dbencryptionsdk.dynamodb.itemencryptor.model.DynamoDbItemEncryptorConfig; +import software.amazon.cryptography.dbencryptionsdk.dynamodb.itemencryptor.model.EncryptItemInput; +import software.amazon.cryptography.dbencryptionsdk.dynamodb.model.DynamoDbTableEncryptionConfig; +import software.amazon.cryptography.dbencryptionsdk.dynamodb.model.DynamoDbTablesEncryptionConfig; +import software.amazon.cryptography.dbencryptionsdk.structuredencryption.model.CryptoAction; +import software.amazon.cryptography.materialproviders.IKeyring; +import software.amazon.cryptography.materialproviders.MaterialProviders; +import software.amazon.cryptography.materialproviders.model.AesWrappingAlg; +import software.amazon.cryptography.materialproviders.model.CreateRawAesKeyringInput; +import software.amazon.cryptography.materialproviders.model.DBEAlgorithmSuiteId; +import software.amazon.cryptography.materialproviders.model.MaterialProvidersConfig; + +/** + * DB-ESDK Performance Benchmark Suite - Java Implementation + * + *

This class provides comprehensive performance testing for the AWS Database Encryption SDK (DB-ESDK) Java + * runtime, measuring throughput, latency, memory usage, and scalability using DynamoDB operations. + */ +public final class ESDKBenchmark { + + final Config config; + final DynamoDbItemEncryptor itemEncryptor; + final IKeyring keyring; + final String tableName; + // System information + final int cpuCount; + final long totalMemoryMB; + + public ESDKBenchmark(final String configPath) throws Exception { + this.config = Config.loadConfig(configPath); + + // System info + this.cpuCount = Runtime.getRuntime().availableProcessors(); + this.totalMemoryMB = Runtime.getRuntime().maxMemory() / (1024 * 1024); + + // Table name for testing + this.tableName = "db-esdk-performance-test"; + + // Setup DB-ESDK with local DynamoDB + this.keyring = setupKeyring(); + this.itemEncryptor = setupItemEncryptorClient(); + + // Create table if it doesn't exist + // createTableIfNotExists(); + + System.out.println( + "Initialized DB-ESDK Benchmark - CPU cores: " + + cpuCount + + ", Memory: " + + (totalMemoryMB / 1024.0) + + "GB" + ); + } + + private IKeyring setupKeyring() throws Exception { + // Generate a 256-bit AES key for testing + final KeyGenerator aesGen = KeyGenerator.getInstance("AES"); + aesGen.init(256, new SecureRandom()); + final SecretKey encryptionKey = aesGen.generateKey(); + final ByteBuffer keyBytes = ByteBuffer.wrap(encryptionKey.getEncoded()); + + // Create Raw AES keyring using Material Providers + final String keyNamespace = "db-esdk-performance-test"; + final String keyName = "test-aes-256-key"; + + final CreateRawAesKeyringInput keyringInput = CreateRawAesKeyringInput + .builder() + .keyName(keyName) + .keyNamespace(keyNamespace) + .wrappingKey(keyBytes) + .wrappingAlg(AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16) + .build(); + + final MaterialProviders matProv = MaterialProviders + .builder() + .MaterialProvidersConfig(MaterialProvidersConfig.builder().build()) + .build(); + + return matProv.CreateRawAesKeyring(keyringInput); + } + + private DynamoDbItemEncryptor setupItemEncryptorClient() { + // Configure attribute actions for encryption + final Map attributeActionsOnEncrypt = new HashMap<>(); + attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY); + attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY); + attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN); + attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY); + attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING); + + // Configure table encryption + final DynamoDbItemEncryptorConfig tableConfig = DynamoDbItemEncryptorConfig + .builder() + .logicalTableName(tableName) + .partitionKeyName("partition_key") + .sortKeyName("sort_key") + .attributeActionsOnEncrypt(attributeActionsOnEncrypt) + .keyring(keyring) + .allowedUnsignedAttributePrefix(":") + .algorithmSuiteId(DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_ECDSA_P384_SYMSIG_HMAC_SHA384) + .build(); + + final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor + .builder() + .DynamoDbItemEncryptorConfig(tableConfig) + .build(); + + return itemEncryptor; + } + + /** + * Run a single batch put-get cycle and measure performance + */ + public Result runItemEncryptorCycle(final byte[] data) { + // Create 25 items with same data, different sort_key + final Map item = new HashMap<>(); + item.put("partition_key", AttributeValue.builder().s("benchmark-test").build()); + item.put("sort_key", AttributeValue.builder().n(String.valueOf(0)).build()); + item.put("attribute1", AttributeValue.builder() + .m(Map.of("data", AttributeValue.builder().b(SdkBytes.fromByteArray(data)).build())) + .build()); + item.put("attribute2", AttributeValue.builder().s("sign me!").build()); + item.put(":attribute3", AttributeValue.builder().s("ignore me!").build()); + + // Measure batch write + final long encryptStart = System.nanoTime(); + final Map encryptedItem = itemEncryptor + .EncryptItem( + EncryptItemInput.builder().plaintextItem(item).build() + ) + .encryptedItem(); + final long encryptTime = System.nanoTime() - encryptStart; + + // Measure batch get + final long decryptStart = System.nanoTime(); + final Map decryptedItem = itemEncryptor + .DecryptItem( + DecryptItemInput.builder().encryptedItem(encryptedItem).build() + ) + .plaintextItem(); + final long decryptTime = System.nanoTime() - decryptStart; + + return new Result( + encryptTime / 1_000_000.0, // Convert to milliseconds + decryptTime / 1_000_000.0 + ); + } + + public List runAllBenchmarks() { + System.out.println("Starting comprehensive ESDK benchmark suite"); + final List allResults = new ArrayList<>(); + + // Get test parameters from config + final List dataSizes = new ArrayList<>(); + if (config.dataSizes.small != null) dataSizes.addAll( + config.dataSizes.small + ); + if (config.dataSizes.medium != null) dataSizes.addAll( + config.dataSizes.medium + ); + if (config.dataSizes.large != null) dataSizes.addAll( + config.dataSizes.large + ); + + // Calculate actual total tests + final int throughputTests = dataSizes.size(); + final int memoryTests = dataSizes.size(); + final int concurrentTests = + dataSizes.size() * + (int) config.concurrencyLevels.stream().filter(c -> c > 1).count(); + final int totalTests = throughputTests + memoryTests + concurrentTests; + + System.out.println("Running " + totalTests + " total tests"); + + try ( + final ProgressBar pb = new ProgressBar("Running benchmarks", totalTests) + ) { + // Throughput tests + for (final int dataSize : dataSizes) { + try { + final TestResult result = Tests.runThroughputTest( + this, + dataSize, + config.iterations.measurement + ); + if (result != null) { + allResults.add(result); + System.out.println( + "Throughput test completed: " + + String.format("%.2f", result.opsPerSecond) + + " ops/sec" + ); + System.out.flush(); + System.out.println( + "Throughput test completed - Ops/sec: " + + String.format("%.2f", result.opsPerSecond) + + ", MB/sec: " + + String.format("%.2f", result.bytesPerSecond / (1024 * 1024)) + ); + } + } catch (final Exception e) { + System.err.println( + "Throughput test failed for data size " + + dataSize + + " bytes: " + + e.getMessage() + ); + } + System.out.flush(); + pb.step(); + System.out.flush(); + } + + // Memory tests + for (final int dataSize : dataSizes) { + try { + final TestResult result = Tests.runMemoryTest(this, dataSize); + allResults.add(result); + System.out.println( + "Memory test completed: " + + String.format("%.2f", result.peakMemoryMb) + + " MB peak" + ); + System.out.flush(); + } catch (final Exception e) { + System.err.println( + "Memory test failed for data size " + + dataSize + + " bytes: " + + e.getMessage() + ); + } + System.out.flush(); + pb.step(); + System.out.flush(); + } + + // Concurrent tests + for (final int dataSize : dataSizes) { + for (final int concurrency : config.concurrencyLevels) { + if (concurrency > 1) { // Skip single-threaded for concurrent tests + try { + final TestResult result = Tests.runConcurrentTest( + this, + dataSize, + concurrency, + 5 + ); + allResults.add(result); + System.out.println( + "Concurrent test completed: " + + String.format("%.2f", result.opsPerSecond) + + " ops/sec @ " + + concurrency + + " threads" + ); + } catch (final Exception e) { + System.err.println( + "Concurrent test failed for data size " + + dataSize + + " bytes with " + + concurrency + + " threads: " + + e.getMessage() + ); + } + System.out.flush(); + pb.step(); + System.out.flush(); + } + } + } + } + + System.out.println( + "Benchmark suite completed. Total results: " + allResults.size() + ); + return allResults; + } + + + public record Result( + double putLatencyMs, + double getLatencyMs + ) {} +} diff --git a/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/Program.java b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/Program.java new file mode 100644 index 000000000..94bc36a32 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/Program.java @@ -0,0 +1,122 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package com.amazon.esdk.benchmark; + +import com.amazon.esdk.benchmark.model.Report; +import com.amazon.esdk.benchmark.model.TestResult; +import java.util.List; +import java.util.OptionalDouble; + +public final class Program { + + public static void main(final String[] args) { + final CommandLineOptions options = parseArgs(args); + if (options == null) return; + + try { + final ESDKBenchmark benchmark = new ESDKBenchmark(options.configPath); + + if (options.quickTest) { + benchmark.config.adjustForQuickTest(); + } + + final List results = benchmark.runAllBenchmarks(); + Report.saveResults( + results, + options.outputPath, + benchmark.cpuCount, + benchmark.totalMemoryMB + ); + printSummary(results, options.outputPath); + } catch (final Exception ex) { + System.out.println("Benchmark failed: " + ex.getMessage()); + } + } + + private static CommandLineOptions parseArgs(final String[] args) { + // Default options + final CommandLineOptions options = new CommandLineOptions(); + options.configPath = "../config/test-scenarios.yaml"; + options.outputPath = "../results/raw-data/java_results.json"; + options.quickTest = false; + + // Simple argument parsing + for (int i = 0; i < args.length; i++) { + switch (args[i]) { + case "--config": + case "-c": + if (i + 1 < args.length) options.configPath = args[++i]; + break; + case "--output": + case "-o": + if (i + 1 < args.length) options.outputPath = args[++i]; + break; + case "--quick": + case "-q": + options.quickTest = true; + break; + case "--help": + case "-h": + printUsage(); + return null; + } + } + + return options; + } + + private static void printUsage() { + System.out.println("ESDK Java Performance Benchmark"); + System.out.println("Usage: java -jar esdk-benchmark.jar [options]"); + System.out.println("Options:"); + System.out.println( + " --config, -c Path to test configuration file (default: ../../config/test-scenarios.yaml)" + ); + System.out.println( + " --output, -o Path to output results file (default: ../../results/raw-data/java_results.json)" + ); + System.out.println( + " --quick, -q Run quick test with reduced iterations" + ); + System.out.println(" --help, -h Show this help message"); + } + + private static void printSummary( + final List results, + final String outputPath + ) { + System.out.println("\n=== ESDK Java Benchmark Summary ==="); + System.out.println("Total tests completed: " + results.size()); + System.out.println("Results saved to: " + outputPath); + + // Print some basic statistics + if (!results.isEmpty()) { + final OptionalDouble avgOps = results + .stream() + .filter(r -> "throughput".equals(r.testName)) + .mapToDouble(r -> r.opsPerSecond) + .average(); + final OptionalDouble maxOps = results + .stream() + .filter(r -> "throughput".equals(r.testName)) + .mapToDouble(r -> r.opsPerSecond) + .max(); + + if (avgOps.isPresent() && maxOps.isPresent()) { + System.out.printf( + "Throughput - Avg: %.2f ops/sec, Max: %.2f ops/sec%n", + avgOps.getAsDouble(), + maxOps.getAsDouble() + ); + } + } + } + + public static final class CommandLineOptions { + + public String configPath; + public String outputPath; + public boolean quickTest; + } +} diff --git a/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/Tests.java b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/Tests.java new file mode 100644 index 000000000..ebaa01b04 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/Tests.java @@ -0,0 +1,464 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package com.amazon.esdk.benchmark; + +import com.amazon.esdk.benchmark.model.TestResult; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import me.tongfei.progressbar.ProgressBar; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public final class Tests { + + private static final Logger logger = LoggerFactory.getLogger(Tests.class); + + // Constants for memory testing + private static final int MemoryTestIterations = 5; + private static final int SamplingIntervalMs = 1; + private static final int GcSettleTimeMs = 5; + private static final int FinalSampleWaitMs = 2; + + /** Run throughput benchmark test */ + public static TestResult runThroughputTest( + final ESDKBenchmark benchmark, + final int dataSize, + final int iterations + ) { + System.out.println( + "Running throughput test - Size: " + + dataSize + + " bytes, Iterations: " + + iterations + ); + System.out.flush(); + + final byte[] data = new byte[dataSize]; + new java.security.SecureRandom().nextBytes(data); + + // Warmup - run measurement but drop results + runMeasurementIterations( + benchmark, + data, + benchmark.config.iterations.warmup + ); + + // Measurement runs + final var results = runMeasurementIterations(benchmark, data, iterations); + final var encryptLatencies = results.encryptLatencies; + final var decryptLatencies = results.decryptLatencies; + final var totalLatencies = results.totalLatencies; + + if (encryptLatencies.isEmpty()) { + System.out.println("All test iterations failed"); + return null; + } + + return TestResult.createThroughputResult( + encryptLatencies, + decryptLatencies, + totalLatencies, + dataSize, + benchmark.cpuCount, + benchmark.totalMemoryMB + ); + } + + private static long getTotalAllocatedBytes() { + final var threadBean = + java.lang.management.ManagementFactory.getThreadMXBean(); + final var sunThreadBean = (com.sun.management.ThreadMXBean) threadBean; + + if (!sunThreadBean.isThreadAllocatedMemoryEnabled()) { + sunThreadBean.setThreadAllocatedMemoryEnabled(true); + } + + return sunThreadBean.getCurrentThreadAllocatedBytes(); + } + + private static MeasurementResults runMeasurementIterations( + final ESDKBenchmark benchmark, + final byte[] data, + final int iterations + ) { + final var encryptLatencies = new ArrayList(); + final var decryptLatencies = new ArrayList(); + final var totalLatencies = new ArrayList(); + + for (int i = 0; i < iterations; i++) { + try { + final long iterationStart = System.nanoTime(); + final var result = benchmark.runItemEncryptorCycle(data); + final double totalMs = + (System.nanoTime() - iterationStart) / 1_000_000.0; + + encryptLatencies.add(result.putLatencyMs()); + decryptLatencies.add(result.getLatencyMs()); + totalLatencies.add(totalMs); + } catch (final Exception e) { + System.out.println("Iteration " + i + " failed: " + e.getMessage()); + } + } + + return new MeasurementResults( + encryptLatencies, + decryptLatencies, + totalLatencies + ); + } + + /** Run memory usage benchmark test */ + public static TestResult runMemoryTest( + final ESDKBenchmark benchmark, + final int dataSize + ) { + System.out.println( + "Running memory test - Size: " + + dataSize + + " bytes (" + + MemoryTestIterations + + " iterations, continuous sampling)" + ); + System.out.flush(); + + final byte[] data = new byte[dataSize]; + new java.security.SecureRandom().nextBytes(data); + final var memoryResults = sampleMemoryDuringOperations(benchmark, data); + + if (memoryResults == null) { + throw new RuntimeException( + "Memory test failed: Unable to collect memory samples for data size " + + dataSize + + " bytes" + ); + } + + return TestResult.createMemoryResult( + memoryResults.peakMemoryMb, + memoryResults.avgMemoryMb, + dataSize, + benchmark.cpuCount, + benchmark.totalMemoryMB + ); + } + + private static MemoryResults sampleMemoryDuringOperations( + final ESDKBenchmark benchmark, + final byte[] data + ) { + double peakMemoryDelta = 0.0; + double peakAllocations = 0.0; + final var avgMemoryValues = new ArrayList(); + + for (int i = 0; i < MemoryTestIterations; i++) { + final var iterationResult = runSingleMemoryIteration( + benchmark, + data, + i + 1 + ); + + if (iterationResult.peakMemory > peakMemoryDelta) { + peakMemoryDelta = iterationResult.peakMemory; + } + if (iterationResult.totalAllocs > peakAllocations) { + peakAllocations = iterationResult.totalAllocs; + } + avgMemoryValues.add(iterationResult.avgMemory); + } + + final double overallAvgMemory = avgMemoryValues.isEmpty() + ? 0.0 + : avgMemoryValues + .stream() + .mapToDouble(Double::doubleValue) + .average() + .orElse(0.0); + + System.out.println("\nMemory Summary:"); + System.out.println( + "- Absolute Peak Heap: " + + String.format("%.2f", peakMemoryDelta) + + " MB (across all runs)" + ); + System.out.println( + "- Average Heap: " + + String.format("%.2f", overallAvgMemory) + + " MB (across all runs)" + ); + System.out.println( + "- Total Allocations: " + + String.format("%.2f", peakAllocations) + + " MB (max across all runs)" + ); + System.out.flush(); + + return new MemoryResults(peakMemoryDelta, overallAvgMemory); + } + + private static IterationResult runSingleMemoryIteration( + final ESDKBenchmark benchmark, + final byte[] data, + final int iteration + ) { + // Force GC and settle + System.gc(); + System.gc(); + try { + Thread.sleep(GcSettleTimeMs); + } catch (final InterruptedException e) { + Thread.currentThread().interrupt(); + throw new RuntimeException( + "Memory test interrupted during GC settle phase", + e + ); + } + + final long baselineMemory = + Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory(); + final long baselineAllocations = getTotalAllocatedBytes(); + final var memorySamples = new ArrayList(); + + final long operationStart = System.nanoTime(); + + // Start background sampling + final var samplingTask = new Thread(() -> { + try { + while (System.nanoTime() - operationStart < 100_000_000) { // 100ms + final long currentMemory = + Runtime.getRuntime().totalMemory() - + Runtime.getRuntime().freeMemory(); + final long currentAllocations = getTotalAllocatedBytes(); + final double heapDelta = + (currentMemory - baselineMemory) / (1024.0 * 1024.0); + final double cumulativeAllocs = + (currentAllocations - baselineAllocations) / (1024.0 * 1024.0); + + if (heapDelta > 0 || cumulativeAllocs > 0) { + synchronized (memorySamples) { + memorySamples.add( + new MemorySample( + Math.max(0, heapDelta), + Math.max(0, cumulativeAllocs) + ) + ); + } + } + Thread.sleep(SamplingIntervalMs); + } + } catch (final InterruptedException e) {} + }); + + samplingTask.start(); + + // Run the actual operation + try { + benchmark.runItemEncryptorCycle(data); + } catch (final Exception e) { + System.out.println( + "Memory test iteration " + iteration + " failed: " + e.getMessage() + ); + return new IterationResult(0.0, 0.0, 0.0); + } + + final double operationDurationMs = + (System.nanoTime() - operationStart) / 1_000_000.0; + + // Wait for sampling to complete + try { + Thread.sleep(FinalSampleWaitMs); + samplingTask.join(100); + } catch (final InterruptedException e) {} + + return calculateIterationMetrics( + baselineMemory, + baselineAllocations, + memorySamples, + iteration, + operationDurationMs + ); + } + + private static IterationResult calculateIterationMetrics( + final long baselineMemory, + final long baselineAllocations, + final ArrayList memorySamples, + final int iteration, + final double operationDurationMs + ) { + final long finalMemory = + Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory(); + final long finalAllocations = getTotalAllocatedBytes(); + final double finalHeapDelta = + (finalMemory - baselineMemory) / (1024.0 * 1024.0); + final double finalCumulativeAllocs = + (finalAllocations - baselineAllocations) / (1024.0 * 1024.0); + + final double iterPeakMemory; + final double iterTotalAllocs; + final double iterAvgMemory; + + synchronized (memorySamples) { + if (memorySamples.isEmpty()) { + iterPeakMemory = Math.max(0, finalHeapDelta); + iterTotalAllocs = Math.max(0, finalCumulativeAllocs); + iterAvgMemory = Math.max(0, finalHeapDelta); + } else { + iterPeakMemory = + memorySamples.stream().mapToDouble(s -> s.heapMB).max().orElse(0.0); + iterTotalAllocs = Math.max(0, finalCumulativeAllocs); + iterAvgMemory = + memorySamples + .stream() + .mapToDouble(s -> s.heapMB) + .average() + .orElse(0.0); + } + } + + System.out.println( + "=== Iteration " + + iteration + + " === Peak Heap: " + + String.format("%.2f", iterPeakMemory) + + " MB, Total Allocs: " + + String.format("%.2f", iterTotalAllocs) + + " MB, Avg Heap: " + + String.format("%.2f", iterAvgMemory) + + " MB (" + + String.format("%.0f", operationDurationMs) + + "ms, " + + memorySamples.size() + + " samples)" + ); + System.out.flush(); + + return new IterationResult(iterPeakMemory, iterTotalAllocs, iterAvgMemory); + } + + private record IterationResult( + double peakMemory, + double totalAllocs, + double avgMemory + ) {} + + /** Run concurrent operations benchmark test */ + public static TestResult runConcurrentTest( + final ESDKBenchmark benchmark, + final int dataSize, + final int concurrency, + final int iterationsPerThread + ) { + System.out.println( + "Running concurrent test - Size: " + + dataSize + + " bytes, Concurrency: " + + concurrency + + ", Iterations per thread: " + + iterationsPerThread + ); + System.out.flush(); + + if (concurrency <= 0) { + throw new IllegalArgumentException( + "Concurrency must be positive, got: " + concurrency + ); + } + if (iterationsPerThread <= 0) { + throw new IllegalArgumentException( + "Iterations per thread must be positive, got: " + iterationsPerThread + ); + } + + final byte[] data = new byte[dataSize]; + new java.security.SecureRandom().nextBytes(data); + final List allTimes = Collections.synchronizedList( + new ArrayList<>() + ); + + final ExecutorService executor = Executors.newFixedThreadPool(concurrency); + final List> futures = new ArrayList<>(); + + // Create progress bar for concurrent operations + final int expectedOperations = concurrency * iterationsPerThread; + try ( + final ProgressBar concurrentPb = new ProgressBar( + "Concurrent test", + expectedOperations + ) + ) { + // Submit concurrent tasks + for (int i = 0; i < concurrency; i++) { + final Future future = executor.submit(() -> { + for (int j = 0; j < iterationsPerThread; j++) { + try { + final long threadStartTime = System.nanoTime(); + benchmark.runItemEncryptorCycle(data); + final double elapsed = + (System.nanoTime() - threadStartTime) / 1_000_000.0; + allTimes.add(elapsed); + + System.out.flush(); + concurrentPb.step(); + System.out.flush(); + } catch (final Exception e) { + System.err.println( + "Concurrent test iteration failed: " + e.getMessage() + ); + } + } + return null; + }); + futures.add(future); + } + + // Wait for all tasks to complete + for (final Future future : futures) { + try { + future.get(); + } catch (final Exception e) { + System.err.println("Concurrent thread failed: " + e.getMessage()); + } + } + } + + executor.shutdown(); + + if (allTimes.isEmpty()) { + throw new RuntimeException( + "Concurrent test failed: No operations completed successfully. " + + "Concurrency: " + + concurrency + + ", Expected operations: " + + (concurrency * iterationsPerThread) + ); + } + + // Calculate metrics + final int totalOperations = allTimes.size(); + + return TestResult.createConcurrentResult( + allTimes, + totalOperations, + dataSize, + concurrency, + benchmark.cpuCount, + benchmark.totalMemoryMB + ); + } + + // Helper records + private record MeasurementResults( + List encryptLatencies, + List decryptLatencies, + List totalLatencies + ) {} + + private record MemoryResults(double peakMemoryMb, double avgMemoryMb) {} + + private record MemorySample(double heapMB, double allocsMB) {} +} \ No newline at end of file diff --git a/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/model/BenchmarkMetadata.java b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/model/BenchmarkMetadata.java new file mode 100644 index 000000000..cd1af5ad1 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/model/BenchmarkMetadata.java @@ -0,0 +1,24 @@ +package com.amazon.esdk.benchmark.model; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public final class BenchmarkMetadata { + + @JsonProperty("language") + public String language = "java"; + + @JsonProperty("timestamp") + public String timestamp = ""; + + @JsonProperty("java_version") + public String javaVersion = ""; + + @JsonProperty("cpu_count") + public int cpuCount; + + @JsonProperty("total_memory_gb") + public double totalMemoryGb; + + @JsonProperty("total_tests") + public int totalTests; +} diff --git a/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/model/Config.java b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/model/Config.java new file mode 100644 index 000000000..05985bd05 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/model/Config.java @@ -0,0 +1,99 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package com.amazon.esdk.benchmark.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.dataformat.yaml.YAMLFactory; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.util.List; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public final class Config { + + private static final Logger logger = LoggerFactory.getLogger(Config.class); + + @JsonProperty("data_sizes") + public DataSizes dataSizes; + + @JsonProperty("iterations") + public Iterations iterations; + + @JsonProperty("concurrency_levels") + public List concurrencyLevels; + + @JsonProperty("quick_config") + public QuickConfig quickConfig; + + @JsonProperty("table_name") + public String tableName; + + @JsonProperty("keyring") + public String keyring; + + /** + * Load test configuration from YAML file + */ + public static Config loadConfig(String configPath) throws IOException { + ObjectMapper mapper = new ObjectMapper(new YAMLFactory()); + File configFile = new File(configPath); + + if (!configFile.exists()) { + System.err.println("Config file not found, using default configuration"); + throw new FileNotFoundException(configPath); + } + + return mapper.readValue(configFile, Config.class); + } + + /** + * Adjust configuration for quick test + */ + public void adjustForQuickTest() { + this.iterations = quickConfig.iterations; + + this.dataSizes = quickConfig.dataSizes; + + this.concurrencyLevels = quickConfig.concurrencyLevels; + } + + public static final class DataSizes { + + @JsonProperty("small") + public List small; + + @JsonProperty("medium") + public List medium; + + @JsonProperty("large") + public List large; + } + + public static final class Iterations { + + @JsonProperty("warmup") + public int warmup; + + @JsonProperty("measurement") + public int measurement; + } + + public static final class QuickConfig { + + @JsonProperty("data_sizes") + public DataSizes dataSizes; + + @JsonProperty("iterations") + public Iterations iterations; + + @JsonProperty("concurrency_levels") + public List concurrencyLevels; + + @JsonProperty("test_types") + public List testTypes; + } +} diff --git a/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/model/Report.java b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/model/Report.java new file mode 100644 index 000000000..8eeea4cc5 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/model/Report.java @@ -0,0 +1,57 @@ +package com.amazon.esdk.benchmark.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.List; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public final class Report { + + private static final Logger logger = LoggerFactory.getLogger(Report.class); + + @JsonProperty("metadata") + public BenchmarkMetadata metadata; + + @JsonProperty("results") + public List results; + + public static void saveResults( + final List results, + final String outputPath, + final int cpuCount, + final double totalMemoryMB + ) throws IOException { + final Path outputFile = Paths.get(outputPath); + Files.createDirectories(outputFile.getParent()); + + final Report resultsData = new Report(); + + final BenchmarkMetadata metadata = new BenchmarkMetadata(); + metadata.language = "java"; + metadata.timestamp = + java.time.LocalDateTime + .now() + .format( + java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss") + ); + metadata.javaVersion = System.getProperty("java.version"); + metadata.cpuCount = cpuCount; + metadata.totalMemoryGb = totalMemoryMB / 1024.0; + metadata.totalTests = results.size(); + + resultsData.metadata = metadata; + resultsData.results = results; + + final ObjectMapper mapper = new ObjectMapper(); + mapper + .writerWithDefaultPrettyPrinter() + .writeValue(outputFile.toFile(), resultsData); + + System.out.println("Results saved to " + outputFile); + } +} diff --git a/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/model/TestResult.java b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/model/TestResult.java new file mode 100644 index 000000000..672d0d3e1 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/java/src/main/java/com/amazon/esdk/benchmark/model/TestResult.java @@ -0,0 +1,199 @@ +package com.amazon.esdk.benchmark.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.Collections; +import java.util.List; + +public final class TestResult { + + @JsonProperty("language") + public final String language = "java"; + + @JsonProperty("test_name") + public String testName; + + @JsonProperty("data_size") + public int dataSize; + + @JsonProperty("concurrency") + public int concurrency = 1; + + @JsonProperty("operations_per_second") + public double opsPerSecond; + + @JsonProperty("bytes_per_second") + public double bytesPerSecond; + + @JsonProperty("peak_memory_mb") + public double peakMemoryMb; + + @JsonProperty("memory_efficiency_ratio") + public double memoryEfficiencyRatio; + + @JsonProperty("avg_latency_ms") + public double avgLatencyMs; + + @JsonProperty("p50_latency_ms") + public double p50LatencyMs; + + @JsonProperty("p95_latency_ms") + public double p95LatencyMs; + + @JsonProperty("p99_latency_ms") + public double p99LatencyMs; + + @JsonProperty("encrypt_latency_ms") + public double encryptLatencyMs; + + @JsonProperty("decrypt_latency_ms") + public double decryptLatencyMs; + + @JsonProperty("timestamp") + public String timestamp = ""; + + @JsonProperty("java_version") + public String javaVersion = ""; + + @JsonProperty("cpu_count") + public int cpuCount; + + @JsonProperty("total_memory_gb") + public double totalMemoryGb; + + @JsonProperty("iterations") + public int iterations; + + public static TestResult createThroughputResult( + final List putLatencies, + final List getLatencies, + final List totalLatencies, + final int dataSize, + final int cpuCount, + final double totalMemoryMB + ) { + final double avgTotalLatency = totalLatencies + .stream() + .mapToDouble(Double::doubleValue) + .average() + .orElse(0.0); + final double opsPerSecond = avgTotalLatency > 0 + ? 1000.0 / avgTotalLatency + : 0.0; + + Collections.sort(totalLatencies); + + final var result = new TestResult(); + result.testName = "throughput"; + result.dataSize = dataSize; + result.concurrency = 1; + result.opsPerSecond = opsPerSecond; + result.bytesPerSecond = opsPerSecond * dataSize; + result.avgLatencyMs = avgTotalLatency; + result.p50LatencyMs = calculatePercentile(totalLatencies, 50); + result.p95LatencyMs = calculatePercentile(totalLatencies, 95); + result.p99LatencyMs = calculatePercentile(totalLatencies, 99); + result.encryptLatencyMs = + putLatencies + .stream() + .mapToDouble(Double::doubleValue) + .average() + .orElse(0.0); + result.decryptLatencyMs = + getLatencies + .stream() + .mapToDouble(Double::doubleValue) + .average() + .orElse(0.0); + result.iterations = putLatencies.size(); + result.timestamp = + java.time.LocalDateTime + .now() + .format( + java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss") + ); + result.javaVersion = System.getProperty("java.version"); + result.cpuCount = cpuCount; + result.totalMemoryGb = totalMemoryMB / 1024.0; + + return result; + } + + public static TestResult createMemoryResult( + final double peakMemoryMb, + final double avgMemoryMb, + final int dataSize, + final int cpuCount, + final double totalMemoryMB + ) { + final double memoryEfficiency = peakMemoryMb > 0 + ? dataSize / (peakMemoryMb * 1024 * 1024) + : 0.0; + + final var result = new TestResult(); + result.testName = "memory"; + result.dataSize = dataSize; + result.concurrency = 1; + result.peakMemoryMb = peakMemoryMb; + result.memoryEfficiencyRatio = memoryEfficiency; + result.timestamp = + java.time.LocalDateTime + .now() + .format( + java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss") + ); + result.javaVersion = System.getProperty("java.version"); + result.cpuCount = cpuCount; + result.totalMemoryGb = totalMemoryMB / 1024.0; + + return result; + } + + public static TestResult createConcurrentResult( + final List allTimes, + final int totalOps, + final int dataSize, + final int concurrency, + final int cpuCount, + final double totalMemoryMB + ) { + final double avgLatency = allTimes + .stream() + .mapToDouble(Double::doubleValue) + .average() + .orElse(0.0); + final double opsPerSecond = + totalOps / + (allTimes.stream().mapToDouble(Double::doubleValue).sum() / 1000.0); + + final var result = new TestResult(); + result.testName = "concurrent"; + result.dataSize = dataSize; + result.concurrency = concurrency; + result.opsPerSecond = opsPerSecond; + result.bytesPerSecond = opsPerSecond * dataSize; + result.avgLatencyMs = avgLatency; + result.iterations = totalOps; + result.timestamp = + java.time.LocalDateTime + .now() + .format( + java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss") + ); + result.javaVersion = System.getProperty("java.version"); + result.cpuCount = cpuCount; + result.totalMemoryGb = totalMemoryMB / 1024.0; + + return result; + } + + private static double calculatePercentile( + final List values, + final int percentile + ) { + if (values.isEmpty()) return 0.0; + + final int index = (int) Math.ceil((percentile / 100.0) * values.size()) - 1; + final int clampedIndex = Math.max(0, Math.min(index, values.size() - 1)); + return values.get(clampedIndex); + } +} \ No newline at end of file diff --git a/db-esdk-performance-testing/benchmarks/python/COMPREHENSIVE_PROFILING_GUIDE.md b/db-esdk-performance-testing/benchmarks/python/COMPREHENSIVE_PROFILING_GUIDE.md new file mode 100644 index 000000000..e1a26ae18 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/COMPREHENSIVE_PROFILING_GUIDE.md @@ -0,0 +1,212 @@ +# Comprehensive Profiling Suite + +This guide explains how to use the comprehensive profiling suite for DynamoDB encryption performance testing with configurable options. + +## Overview + +The comprehensive profiling suite (`profile_comprehensive.py`) allows you to systematically profile all combinations of: + +- **Test Base**: `item` (item encryption) vs `client` (EncryptedClient) +- **Provider**: `aes`, `kms`, `hierarchy` (most recent/hierarchy keyring) +- **Data Type**: `single`, `nested`, `flat` attributes +- **Operation**: `encrypt`, `decrypt` +- **Version**: `v3`, `v4` + +Note: Profiling High Level Client or KMS Operations would require AWS credentials. + +## Prerequisites + +- Python 3.11 or higher +- Poetry package manager + +## Setup + +### Install Poetry + +```bash +# Install Poetry (if not already installed) +curl -sSL https://install.python-poetry.org | python3 - + +# Or using pip +pip install poetry +``` + +### Install Dependencies + +### Compile DB-ESDK Python + +```bash +cd DynamoDbEncryption +make setup_python && make transpile_python +cd ../db-esdk-performance-testing/benchmarks/python/ +``` +### Install Benchmark framework +```bash +poetry lock +poetry install +``` + +## Quick Start + +### Quick Profiling for AES Only Operations(Do not need AWS Credentials) + +```bash +python profile_comprehensive.py --test-bases item --providers aes --data-types single --version v4 +``` + +### Profile All Combinations (Default) +```bash +# Profile all combinations with default settings (v4 only) +python profile_comprehensive.py + +# Generated configurations: 36 total +# 2 test bases × 3 providers × 3 data types × 2 operations × 1 version = 36 +``` + +### Profile Specific Configurations + +```bash +# Profile only AES provider with item-based tests +python profile_comprehensive.py --test-bases item --providers aes + +# Profile only encrypt operations +python profile_comprehensive.py --operations encrypt + +# Profile specific data types +python profile_comprehensive.py --data-types single flat + +# Profile with more iterations for higher precision +python profile_comprehensive.py --iterations 200 +``` + +### Compare v3 vs v4 Performance + +```bash +# Compare v3 and v4 for AES provider only +python profile_comprehensive.py --versions v3 v4 --providers aes + +# Compare versions for all providers (72 configurations total) +python profile_comprehensive.py --versions v3 v4 +``` + +### Advanced Profiling + +```bash +# Enable line-by-line profiling (requires line_profiler) +python profile_comprehensive.py --line-profile --providers aes --data-types single + +# Custom output directory +python profile_comprehensive.py --output-dir my_profiling_results + +# Profile specific combination for detailed analysis +python profile_comprehensive.py \ + --test-bases item \ + --providers aes \ + --data-types nested \ + --operations encrypt \ + --iterations 500 \ + --line-profile +``` + +## Configuration Options + +### Test Bases + +- **`item`**: Direct encryption using `encrypt_dynamodb_item()` and `decrypt_dynamodb_item()` + - Lower overhead, focuses on core encryption/decryption performance + - Best for profiling the encryption algorithms themselves + +- **`client`**: Encryption via `EncryptedClient` + - Higher-level API with additional overhead + - Best for profiling real-world usage patterns + +### Providers + +- **`aes`**: Raw AES encryption + - Fastest option, no key management overhead + - Uses fixed AES-256 key material + +- **`kms`**: AWS KMS key provider/keyring + - Production-ready key management + - Includes network calls to KMS (may be mocked in tests) + +- **`hierarchy`**: Hierarchy keyring (v4) / Most Recent key provider (v3) + - Advanced key management with key derivation + - Includes key caching and rotation capabilities + +### Data Types + +- **`single`**: Single attribute item + - Minimal data, fastest encryption + - Good for measuring base overhead + +- **`nested`**: Nested structure with maps and lists + - Complex data structures + - Tests serialization/deserialization performance + +- **`flat`**: Multiple flat attributes + - Many attributes at the same level + - Tests attribute action processing + +### Operations + +- **`encrypt`**: Measures encryption performance +- **`decrypt`**: Measures decryption performance + +## Output Structure + +The profiling suite generates comprehensive reports in the specified output directory: + +``` +comprehensive_profiling_results/ +├── comprehensive_profiling_report.txt # Human-readable summary +├── comprehensive_profiling_results.json # Machine-readable results +├── v4_item_aes_single_encrypt.prof # cProfile data files +├── v4_item_aes_single_encrypt.png # Call graphs (if graphviz available) +├── v4_item_aes_single_decrypt.prof +├── v4_client_kms_nested_encrypt.prof +└── ... (one .prof file per configuration) +``` + +## Report Analysis + +### Summary by Dimension + +The report includes performance summaries organized by: + +1. **Test Base**: Average performance for item vs client approaches +2. **Provider**: Comparison of AES, KMS, and hierarchy performance +3. **Data Type**: How data complexity affects performance +4. **Operation**: Encrypt vs decrypt timing differences + +### Detailed Results + +For each configuration, the report includes: + +- Configuration details +- Time per operation (milliseconds) +- Throughput (operations per second) +- Data size metrics +- Size increase ratio (encrypted vs original) +- Top 5 time-consuming functions + +### AWS Credentials + +Configure credentials using ada and assume the ddb role: + +```bash +# Configure ada credentials +ada credentials update --provider isengard --role=ToolsDevelopment --once \ + --account 370957321024 --profile=aws-crypto-tools-team+optools-ci-ToolsDevelopment + +# Set region and assume role for tests +export AWS_REGION="us-west-2" +TMP_ROLE=$(aws sts assume-role --role-arn "arn:aws:iam::370957321024:role/GitHub-CI-DDBEC-Dafny-Role-us-west-2" --role-session-name "${USER}-Tests-DBEC" --profile aws-crypto-tools-team+optools-ci-ToolsDevelopment) +export TMP_ROLE +export AWS_ACCESS_KEY_ID=$(echo "${TMP_ROLE}" | jq -r '.Credentials.AccessKeyId') +export AWS_SECRET_ACCESS_KEY=$(echo "${TMP_ROLE}" | jq -r '.Credentials.SecretAccessKey') +export AWS_SESSION_TOKEN=$(echo "${TMP_ROLE}" | jq -r '.Credentials.SessionToken') + +# Verify credentials are working +aws sts get-caller-identity +``` \ No newline at end of file diff --git a/db-esdk-performance-testing/benchmarks/python/README.md b/db-esdk-performance-testing/benchmarks/python/README.md new file mode 100644 index 000000000..33fef6934 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/README.md @@ -0,0 +1,196 @@ +# DB-ESDK Performance Benchmark - Python + +This directory contains the Python implementation of the AWS Database Encryption SDK (DB-ESDK) performance benchmark suite. + +## Overview + +The Python benchmark provides comprehensive performance testing for the DB-ESDK Python runtime, measuring: + +- **Throughput**: Operations per second and bytes per second using ItemEncryptor operations +- **Latency**: Encrypt, decrypt, and end-to-end timing for encrypted operations +- **Memory Usage**: Peak memory consumption and efficiency +- **Concurrency**: Multi-threaded performance scaling +- **Statistical Analysis**: P50, P95, P99 latency percentiles + +## Prerequisites + +- Python 3.11 or higher +- Poetry package manager + +## Setup + +### Install Poetry + +```bash +# Install Poetry (if not already installed) +curl -sSL https://install.python-poetry.org | python3 - + +# Or using pip +pip install poetry +``` + +### Install Dependencies + +### Compile DB-ESDK Python + +```bash +cd DynamoDbEncryption +make setup_python && make transpile_python +cd ../db-esdk-performance-testing/benchmarks/python/ +``` +### Install Benchmark framework +```bash +poetry lock +poetry install +``` + +## Running Benchmarks + +### Quick Test + +```bash +# Using Poetry +poetry run esdk-benchmark --quick + +# Using tox (recommended for isolated environment) +tox -e benchmark + +# Using module execution +poetry run python -m esdk_benchmark --quick + +# Direct script execution +poetry run python src/esdk_benchmark/program.py --quick +``` + +### Full Benchmark Suite + +```bash +# Using Poetry +poetry run esdk-benchmark + +# Using tox (recommended for isolated environment) +tox -e benchmark-full + +# Using module execution +poetry run python -m esdk_benchmark + +# Direct script execution +poetry run python src/esdk_benchmark/program.py +``` + +### Custom Configuration + +```bash +# Specify custom config and output paths +poetry run esdk-benchmark \ + --config /path/to/config.yaml \ + --output /path/to/results.json +``` + +## Command Line Options + +- `--config, -c`: Path to test configuration file (default: `../../../config/test-scenarios.yaml`) +- `--output, -o`: Path to output results file (default: `../../../results/raw-data/python_results.json`) +- `--quick, -q`: Run quick test with reduced iterations +- `--help, -h`: Show help message + +## Configuration + +The benchmark uses a YAML configuration file to define test parameters: + +```yaml +data_sizes: + small: [1024, 5120, 10240] + medium: [102400, 512000, 1048576] + large: [10485760, 52428800, 104857600] + +iterations: + warmup: 5 + measurement: 10 + +concurrency_levels: [1, 2, 4, 8] +``` + +## Output Format + +Results are saved in JSON format with the following structure: + +```json +{ + "metadata": { + "language": "python", + "timestamp": "2025-09-05T15:30:00Z", + "python_version": "3.11.5", + "platform": "Darwin-23.1.0-arm64-arm-64bit", + "cpu_count": 8, + "total_memory_gb": 16.0, + "total_tests": 45 + }, + "results": [ + { + "test_name": "throughput", + "language": "python", + "data_size": 1024, + "concurrency": 1, + "put_latency_ms": 0.85, + "get_latency_ms": 0.72, + "end_to_end_latency_ms": 1.57, + "ops_per_second": 636.94, + "bytes_per_second": 652224.0, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 1.55, + "p95_latency": 1.89, + "p99_latency": 2.12, + "timestamp": "2025-09-05T15:30:15Z", + "python_version": "3.11.5", + "cpu_count": 8, + "total_memory_gb": 16.0 + } + ] +} +``` + +## Key Features + +### DB-ESDK Integration + +- Uses AWS Database Encryption SDK for DynamoDB with transparent encryption +- Configures attribute actions (ENCRYPT_AND_SIGN, SIGN_ONLY, DO_NOTHING) +- Tests ItemEncryptor operations with client-side encryption +- Uses Raw AES keyring for consistent performance testing + +### ItemEncryptor Operations + +- Performs encrypt_python_item operations using Python dict format +- Measures decrypt_python_item operations for consistency +- Tests realistic workloads with encryption overhead +- Supports multiple data formats (Python dict, DynamoDB JSON, DBESDK shapes) + +### Performance Metrics + +- **Throughput Tests**: Measures ops/sec and bytes/sec for ItemEncryptor operations +- **Memory Tests**: Tracks peak memory usage during encrypted operations using psutil +- **Concurrency Tests**: Evaluates multi-threaded performance scaling with ThreadPoolExecutor +- **Latency Analysis**: P50, P95, P99 percentiles for operation timing + +## Project Structure + +``` +python/ +├── README.md # This file +├── pyproject.toml # Poetry configuration and dependencies +├── tox.ini # Tox configuration for testing +├── src/ +│ └── esdk_benchmark/ +│ ├── __init__.py # Package initialization +│ ├── __main__.py # Module execution entry point +│ ├── program.py # Main program and CLI +│ ├── benchmark.py # Core benchmark implementation +│ ├── models.py # Data models and configuration +│ └── tests.py # Individual test implementations +├── tests/ # Test suite +│ ├── __init__.py +│ └── test_benchmark.py +└── run_benchmark.py # Convenience runner script +``` diff --git a/db-esdk-performance-testing/benchmarks/python/profile_comprehensive.py b/db-esdk-performance-testing/benchmarks/python/profile_comprehensive.py new file mode 100644 index 000000000..839469ff9 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/profile_comprehensive.py @@ -0,0 +1,779 @@ +#!/usr/bin/env python3 +""" +Comprehensive profiling suite for DynamoDB encryption with configurable options. + +This script provides flexible profiling with configurable: +- Test Base: item (direct) vs client (EncryptedClient) +- Provider: aes, kms, hierarchy +- Data Type: single, nested, flat +- Operation: encrypt, decrypt +- Version: v3, v4 +""" + +import argparse +import cProfile +import json +import pstats +import sys +import time +from io import StringIO +from pathlib import Path +from typing import Dict, Any, List, Tuple, Optional, Type +import importlib + +# Try to import optional profiling tools +try: + from line_profiler import LineProfiler + HAS_LINE_PROFILER = True +except ImportError: + HAS_LINE_PROFILER = False + +try: + import snakeviz + HAS_SNAKEVIZ = True +except ImportError: + HAS_SNAKEVIZ = False + +# Add parent directory to path for imports +sys.path.insert(0, str(Path(__file__).parent)) + +from src.test_constants import TEST_DATA_CATEGORIES +from src.providers.v3_providers import V3AESProvider, V3KMSProvider, V3HierarchyProvider +from src.providers.v4_providers import V4AESKeyring, V4KMSKeyring, V4HierarchyKeyring +from src.test_bases.item_test_base import V3ItemTestBase, V4ItemTestBase +from src.test_bases.client_test_base import V3ClientTestBase, V4ClientTestBase + + +class ProfilingConfiguration: + """Configuration class for profiling parameters.""" + + def __init__(self, test_base: str, provider: str, data_type: str, + operation: str, version: str = "v4"): + """Initialize profiling configuration.""" + self.test_base = test_base # "item" or "client" + self.provider = provider # "aes", "kms", "hierarchy" + self.data_type = data_type # "single", "nested", "flat" + self.operation = operation # "encrypt", "decrypt" + self.version = version # "v3", "v4" + + # Validate configuration + self._validate() + + # Map data types to constants + self.data_type_map = { + "single": "single_attribute", + "nested": "nested_attributes", + "flat": "flat_attributes" + } + + self.actual_data_type = self.data_type_map[self.data_type] + + def _validate(self): + """Validate configuration parameters.""" + valid_test_bases = ["item", "client"] + valid_providers = ["aes", "kms", "hierarchy"] + valid_data_types = ["single", "nested", "flat"] + valid_operations = ["encrypt", "decrypt"] + valid_versions = ["v3", "v4"] + + if self.test_base not in valid_test_bases: + raise ValueError(f"Invalid test_base: {self.test_base}. Must be one of {valid_test_bases}") + if self.provider not in valid_providers: + raise ValueError(f"Invalid provider: {self.provider}. Must be one of {valid_providers}") + if self.data_type not in valid_data_types: + raise ValueError(f"Invalid data_type: {self.data_type}. Must be one of {valid_data_types}") + if self.operation not in valid_operations: + raise ValueError(f"Invalid operation: {self.operation}. Must be one of {valid_operations}") + if self.version not in valid_versions: + raise ValueError(f"Invalid version: {self.version}. Must be one of {valid_versions}") + + def get_test_class_name(self) -> str: + """Get the test class name based on configuration.""" + # Map provider names to test class names + provider_map = { + "v3": { + "aes": "V3AESKeyProvider", + "kms": "V3AWSKMSKeyProvider", + "hierarchy": "V3MostRecentKeyProvider" + }, + "v4": { + "aes": "V4RawAESKeyring", + "kms": "V4AWSKMSKeyring", + "hierarchy": "V4HierarchyKeyring" + } + } + + return provider_map[self.version][self.provider] + + def get_module_name(self) -> str: + """Get the module name to import.""" + # Map provider names to module names + module_map = { + "v3": { + "aes": "src.v3.aes_key_provider_test", + "kms": "src.v3.aws_kms_key_provider_test", + "hierarchy": "src.v3.most_recent_key_provider_test" + }, + "v4": { + "aes": "src.v4.raw_aes_keyring_test", + "kms": "src.v4.aws_kms_keyring_test", + "hierarchy": "src.v4.hierarchy_keyring_test" + } + } + + return module_map[self.version][self.provider] + + def get_identifier(self) -> str: + """Get a unique identifier for this configuration.""" + return f"{self.version}_{self.test_base}_{self.provider}_{self.data_type}_{self.operation}" + + def __str__(self) -> str: + """String representation of configuration.""" + return (f"Config(version={self.version}, test_base={self.test_base}, " + f"provider={self.provider}, data_type={self.data_type}, " + f"operation={self.operation})") + + +class ComprehensiveProfiler: + """Comprehensive profiler for all configuration combinations.""" + + def __init__(self, output_dir: str = "comprehensive_profiling_results"): + """Initialize the comprehensive profiler.""" + self.output_dir = Path(output_dir) + self.output_dir.mkdir(exist_ok=True) + + # Store profiling results organized by configuration + self.results = {} + + # Cache for test instances to avoid recreating them + self._test_instance_cache = {} + + def _get_test_instance(self, config: ProfilingConfiguration): + """Get or create a test instance for the given configuration.""" + cache_key = f"{config.version}_{config.provider}_{config.test_base}" + + if cache_key not in self._test_instance_cache: + try: + # Create the appropriate provider/keyring instance + if config.version == "v3": + if config.provider == "aes": + provider = V3AESProvider() + elif config.provider == "kms": + provider = V3KMSProvider() + elif config.provider == "hierarchy": + provider = V3HierarchyProvider() + else: + raise ValueError(f"Unknown v3 provider: {config.provider}") + + # Create the appropriate test base + if config.test_base == "item": + instance = V3ItemTestBase(provider) + elif config.test_base == "client": + instance = V3ClientTestBase(provider) + else: + raise ValueError(f"Unknown test base: {config.test_base}") + + elif config.version == "v4": + if config.provider == "aes": + keyring = V4AESKeyring() + elif config.provider == "kms": + keyring = V4KMSKeyring() + elif config.provider == "hierarchy": + keyring = V4HierarchyKeyring() + else: + raise ValueError(f"Unknown v4 provider: {config.provider}") + + # Create the appropriate test base + if config.test_base == "item": + instance = V4ItemTestBase(keyring) + elif config.test_base == "client": + instance = V4ClientTestBase(keyring) + else: + raise ValueError(f"Unknown test base: {config.test_base}") + + else: + raise ValueError(f"Unknown version: {config.version}") + + self._test_instance_cache[cache_key] = instance + + except Exception as e: + raise RuntimeError(f"Failed to create test instance for {config}: {e}") + + return self._test_instance_cache[cache_key] + + def profile_configuration(self, config: ProfilingConfiguration, + iterations: int = 100) -> Tuple[cProfile.Profile, float, Dict[str, Any]]: + """Profile a specific configuration.""" + print(f"Profiling: {config}") + + # Get test instance + test_instance = self._get_test_instance(config) + + # Get test item + test_item = test_instance.get_test_item(config.actual_data_type) + + # Pre-encrypt item for decrypt operations + encrypted_item = None + if config.operation == "decrypt": + encrypted_item = test_instance.encrypt_item(test_item) + + # Create profiler + profiler = cProfile.Profile() + # Define the operation to profile + if config.operation == "encrypt": + def target_operation(): + for _ in range(iterations): + test_instance.encrypt_item(test_item) + else: # decrypt + def target_operation(): + for _ in range(iterations): + test_instance.decrypt_item(encrypted_item) + + # Profile the operation with explicit profiler management + try: + start_time = time.time() + profiler.enable() + target_operation() + finally: + # Always disable profiler even if an error occurs + profiler.disable() + total_time = time.time() - start_time + + # # Decrypt if encrypt operation is used for verification + # if config.operation == "encrypt": + # test_instance.decrypt_item(encrypted_item) + + # # Verify that encrypted attributes were properly decrypted (back to original) + # for key, original_value in test_item.items(): + # assert key in decrypted_item, f"Missing attribute {key} in decrypted item" + # decrypted_value = decrypted_item[key] + # assert ( + # decrypted_value == original_value + # ), f"Attribute {key} not properly decrypted: {decrypted_value} != {original_value}" + + # Calculate additional metrics + original_size = test_instance.calculate_item_size(test_item) + encrypted_size = test_instance.calculate_item_size(encrypted_item) if encrypted_item else original_size + + metrics = { + "total_time": total_time, + "avg_time_per_iteration": total_time / iterations, + "iterations": iterations, + "original_size_bytes": original_size, + "encrypted_size_bytes": encrypted_size, + "size_increase_ratio": encrypted_size / original_size if original_size > 0 else 1.0, + "throughput_ops_per_sec": iterations / total_time if total_time > 0 else 0 + } + + return profiler, total_time, metrics + + def analyze_profile(self, profiler: cProfile.Profile, config: ProfilingConfiguration) -> Dict[str, Any]: + """Analyze profiling results and extract key metrics.""" + stats = pstats.Stats(profiler) + stats.sort_stats('cumulative') + + # Capture stats output + output = StringIO() + stats.stream = output + stats.print_stats(20) + + # Extract key function timings + stats_dict = stats.stats + key_functions = [] + + # Keywords to identify important functions + keywords = ['encrypt', 'decrypt', 'aes', 'gcm', 'hmac', 'sign', 'wrap', + 'unwrap', 'derive', 'material', 'crypto', 'kms', 'hierarchy'] + + for func_key, func_stats in stats_dict.items(): + filename, line_num, func_name = func_key + if any(keyword in func_name.lower() for keyword in keywords): + key_functions.append({ + 'function': func_name, + 'file': Path(filename).name, + 'line': line_num, + 'calls': func_stats[0], + 'total_time': func_stats[1], + 'cumulative_time': func_stats[2], + 'avg_time_per_call': func_stats[2] / func_stats[0] if func_stats[0] > 0 else 0 + }) + + # Sort by cumulative time + key_functions.sort(key=lambda x: x['cumulative_time'], reverse=True) + + return { + 'top_functions': key_functions[:10], + 'full_output': output.getvalue(), + 'total_calls': sum(v[0] for v in stats_dict.values()), + 'total_profile_time': stats.total_tt + } + + def save_profile_data(self, profiler: cProfile.Profile, config: ProfilingConfiguration) -> Path: + """Save profile data for later analysis.""" + filename = f"{config.get_identifier()}.prof" + profile_path = self.output_dir / filename + profiler.dump_stats(str(profile_path)) + return profile_path + + def generate_callgraph(self, profile_path: Path, config: ProfilingConfiguration) -> Optional[Path]: + """Generate a visual call graph from profile data.""" + try: + import subprocess + + output_name = config.get_identifier() + dot_file = self.output_dir / f"{output_name}.dot" + png_file = self.output_dir / f"{output_name}.png" + + # Use gprof2dot if available + try: + cmd = ["gprof2dot", "-f", "pstats", str(profile_path), "-o", str(dot_file)] + subprocess.run(cmd, check=True, capture_output=True) + + # Convert to PNG + cmd = ["dot", "-Tpng", str(dot_file), "-o", str(png_file)] + subprocess.run(cmd, check=True, capture_output=True) + + return png_file + except (subprocess.CalledProcessError, FileNotFoundError): + return None + + except Exception: + return None + + def profile_with_line_profiler(self, config: ProfilingConfiguration, + iterations: int = 10) -> Optional[str]: + """Profile with line-by-line analysis.""" + if not HAS_LINE_PROFILER: + return None + + test_instance = self._get_test_instance(config) + test_item = test_instance.get_test_item(config.actual_data_type) + + # Create line profiler + lp = LineProfiler() + + # Add functions to profile + if config.operation == "encrypt": + lp.add_function(test_instance.encrypt_item) + else: + encrypted_item = test_instance.encrypt_item(test_item) + lp.add_function(test_instance.decrypt_item) + + # Profile the operation + if config.operation == "encrypt": + wrapped = lp(lambda: [test_instance.encrypt_item(test_item) for _ in range(iterations)]) + else: + encrypted_item = test_instance.encrypt_item(test_item) + wrapped = lp(lambda: [test_instance.decrypt_item(encrypted_item) for _ in range(iterations)]) + + wrapped() + + # Capture output + output = StringIO() + lp.print_stats(stream=output) + + return output.getvalue() + + def run_comprehensive_profiling(self, configurations: List[ProfilingConfiguration], + iterations: int = 100, line_profile: bool = False): + """Run comprehensive profiling for all configurations.""" + print(f"\nRunning comprehensive profiling with {iterations} iterations per test...") + print("=" * 100) + + for i, config in enumerate(configurations, 1): + print(f"\n[{i}/{len(configurations)}] {config}") + print("-" * 80) + + try: + # Function-level profiling + profiler, total_time, metrics = self.profile_configuration(config, iterations) + + # Analyze results + analysis = self.analyze_profile(profiler, config) + + # Save profile data + profile_path = self.save_profile_data(profiler, config) + + # Generate call graph + callgraph_path = self.generate_callgraph(profile_path, config) + + # Line profiling (if requested) + line_profile_output = None + if line_profile and HAS_LINE_PROFILER: + print(" Running line profiler...") + line_profile_output = self.profile_with_line_profiler( + config, min(iterations, 10) + ) + + # Store results + config_id = config.get_identifier() + self.results[config_id] = { + "config": { + "version": config.version, + "test_base": config.test_base, + "provider": config.provider, + "data_type": config.data_type, + "operation": config.operation + }, + "metrics": metrics, + "analysis": analysis, + "profile_path": str(profile_path), + "callgraph_path": str(callgraph_path) if callgraph_path else None, + "line_profile": line_profile_output + } + + # Print summary + print(f" ✓ Total time: {total_time:.3f}s") + print(f" ✓ Avg per iteration: {metrics['avg_time_per_iteration']*1000:.3f}ms") + print(f" ✓ Throughput: {metrics['throughput_ops_per_sec']:.1f} ops/sec") + print(f" ✓ Size increase: {metrics['size_increase_ratio']:.2f}x") + + if analysis['top_functions']: + print(f" ✓ Top 3 time-consuming functions:") + for j, func in enumerate(analysis['top_functions'][:3], 1): + print(f" {j}. {func['function']} - {func['cumulative_time']:.3f}s " + f"({func['calls']} calls)") + + except Exception as e: + print(f" ✗ Failed: {e}") + self.results[config.get_identifier()] = { + "config": config.__dict__, + "error": str(e) + } + + # Generate comprehensive report + self.generate_comprehensive_report() + + def generate_comprehensive_report(self): + """Generate comprehensive profiling report organized by dimensions.""" + report_path = self.output_dir / "comprehensive_profiling_report.txt" + + with open(report_path, "w") as f: + f.write("COMPREHENSIVE PROFILING REPORT\n") + f.write("=" * 100 + "\n\n") + + # V3 vs V4 Comparison Section - New Primary Focus + f.write("V3 vs V4 PERFORMANCE COMPARISON\n") + f.write("=" * 100 + "\n\n") + + # Group results by common configuration (excluding version) + common_configs = {} + for config_id, result in self.results.items(): + if "error" in result or "metrics" not in result: + continue + + config = result["config"] + common_key = f"{config['test_base']}_{config['provider']}_{config['data_type']}_{config['operation']}" + + if common_key not in common_configs: + common_configs[common_key] = {} + common_configs[common_key][config['version']] = result + + # Generate V3 vs V4 comparisons + comparisons_found = False + for common_key, versions in common_configs.items(): + if 'v3' in versions and 'v4' in versions: + comparisons_found = True + + v3_result = versions['v3'] + v4_result = versions['v4'] + + v3_time = v3_result['metrics']['avg_time_per_iteration'] * 1000 # ms + v4_time = v4_result['metrics']['avg_time_per_iteration'] * 1000 # ms + + # Calculate performance difference - always relative to V4 + if v3_time > 0: + ratio = v4_time / v3_time + if v4_time < v3_time: + # V4 is faster - calculate improvement percentage + improvement = ((v3_time - v4_time) / v3_time) * 100 + status = f"V4 FASTER by {improvement:.1f}% ({ratio:.1f}x)" + else: + # V4 is slower - calculate how much slower as percentage and ratio + slowdown = ((v4_time - v3_time) / v3_time) * 100 + status = f"V4 SLOWER by {slowdown:.1f}% ({ratio:.1f}x slower)" + else: + status = "Cannot compare (zero time)" + + # Parse common key for readable output + test_base, provider, data_type, operation = common_key.split('_') + + f.write(f"{test_base.upper()}-{provider.upper()}-{data_type.upper()}-{operation.upper()}:\n") + f.write(f" V3 Time: {v3_time:.3f}ms | V4 Time: {v4_time:.3f}ms | {status}\n") + f.write(f" V3 Throughput: {v3_result['metrics']['throughput_ops_per_sec']:.1f} ops/sec\n") + f.write(f" V4 Throughput: {v4_result['metrics']['throughput_ops_per_sec']:.1f} ops/sec\n") + f.write("\n") + + if not comparisons_found: + f.write("No V3 vs V4 comparisons available (need both versions profiled for same configurations)\n\n") + + # Overall V3 vs V4 Summary + if comparisons_found: + f.write("V3 vs V4 SUMMARY\n") + f.write("-" * 50 + "\n") + + v4_wins = 0 + v3_wins = 0 + total_comparisons = 0 + + for common_key, versions in common_configs.items(): + if 'v3' in versions and 'v4' in versions: + total_comparisons += 1 + v3_time = versions['v3']['metrics']['avg_time_per_iteration'] + v4_time = versions['v4']['metrics']['avg_time_per_iteration'] + + if v4_time < v3_time: + v4_wins += 1 + else: + v3_wins += 1 + + f.write(f"Total Comparisons: {total_comparisons}\n") + f.write(f"V4 Faster: {v4_wins} configurations ({v4_wins/total_comparisons*100:.1f}%)\n") + f.write(f"V3 Faster: {v3_wins} configurations ({v3_wins/total_comparisons*100:.1f}%)\n") + f.write("\n") + + # Summary by test base + f.write("PERFORMANCE BY TEST BASE\n") + f.write("-" * 100 + "\n\n") + + for test_base in ["item", "client"]: + f.write(f"{test_base.upper()} Test Base:\n") + base_results = {k: v for k, v in self.results.items() + if v.get("config", {}).get("test_base") == test_base and "metrics" in v} + + if base_results: + avg_time = sum(r["metrics"]["avg_time_per_iteration"] + for r in base_results.values()) / len(base_results) + f.write(f" Average time per operation: {avg_time*1000:.3f}ms\n") + f.write(f" Number of configurations: {len(base_results)}\n") + f.write("\n") + + # Summary by provider + f.write("PERFORMANCE BY PROVIDER\n") + f.write("-" * 100 + "\n\n") + + for provider in ["aes", "kms", "hierarchy"]: + f.write(f"{provider.upper()} Provider:\n") + provider_results = {k: v for k, v in self.results.items() + if v.get("config", {}).get("provider") == provider and "metrics" in v} + + if provider_results: + encrypt_times = [r["metrics"]["avg_time_per_iteration"] + for r in provider_results.values() + if r["config"]["operation"] == "encrypt"] + decrypt_times = [r["metrics"]["avg_time_per_iteration"] + for r in provider_results.values() + if r["config"]["operation"] == "decrypt"] + + if encrypt_times: + f.write(f" Average encrypt time: {sum(encrypt_times)/len(encrypt_times)*1000:.3f}ms\n") + if decrypt_times: + f.write(f" Average decrypt time: {sum(decrypt_times)/len(decrypt_times)*1000:.3f}ms\n") + f.write("\n") + + # Summary by data type + f.write("PERFORMANCE BY DATA TYPE\n") + f.write("-" * 100 + "\n\n") + + for data_type in ["single", "nested", "flat"]: + f.write(f"{data_type.upper()} Data Type:\n") + data_results = {k: v for k, v in self.results.items() + if v.get("config", {}).get("data_type") == data_type and "metrics" in v} + + if data_results: + avg_size = sum(r["metrics"]["original_size_bytes"] + for r in data_results.values()) / len(data_results) + avg_time = sum(r["metrics"]["avg_time_per_iteration"] + for r in data_results.values()) / len(data_results) + f.write(f" Average data size: {avg_size:.0f} bytes\n") + f.write(f" Average processing time: {avg_time*1000:.3f}ms\n") + f.write("\n") + + # Detailed results + f.write("DETAILED RESULTS\n") + f.write("=" * 100 + "\n\n") + + for config_id, result in self.results.items(): + if "error" in result: + f.write(f"{config_id}: ERROR - {result['error']}\n\n") + continue + + config = result["config"] + metrics = result["metrics"] + analysis = result["analysis"] + + f.write(f"{config_id}\n") + f.write("-" * len(config_id) + "\n") + f.write(f"Configuration: {config}\n") + f.write(f"Time per operation: {metrics['avg_time_per_iteration']*1000:.3f}ms\n") + f.write(f"Throughput: {metrics['throughput_ops_per_sec']:.1f} ops/sec\n") + f.write(f"Data size: {metrics['original_size_bytes']} bytes\n") + f.write(f"Size increase: {metrics['size_increase_ratio']:.2f}x\n") + + if analysis.get("top_functions"): + f.write("Top 5 Functions:\n") + for i, func in enumerate(analysis["top_functions"][:5], 1): + f.write(f" {i}. {func['function']} - {func['cumulative_time']:.3f}s\n") + f.write("\n") + + # Save JSON results + json_path = self.output_dir / "comprehensive_profiling_results.json" + with open(json_path, "w") as f: + json.dump(self.results, f, indent=2, default=str) + + print(f"\nComprehensive reports saved to:") + print(f" - {report_path}") + print(f" - {json_path}") + + # Interactive visualization hint + if HAS_SNAKEVIZ: + print("\nTo view interactive visualizations, run:") + print(f" cd {self.output_dir}") + print(" snakeviz *.prof") + + +def generate_configurations(test_bases: List[str] = None, + providers: List[str] = None, + data_types: List[str] = None, + operations: List[str] = None, + versions: List[str] = None) -> List[ProfilingConfiguration]: + """Generate all combinations of profiling configurations.""" + test_bases = test_bases or ["item", "client"] + providers = providers or ["aes", "kms", "hierarchy"] + data_types = data_types or ["single", "nested", "flat"] + operations = operations or ["encrypt", "decrypt"] + versions = versions or ["v4"] # Default to v4 only + + configurations = [] + + for version in versions: + for test_base in test_bases: + for provider in providers: + for data_type in data_types: + for operation in operations: + try: + config = ProfilingConfiguration( + test_base=test_base, + provider=provider, + data_type=data_type, + operation=operation, + version=version + ) + configurations.append(config) + except ValueError as e: + print(f"Skipping invalid configuration: {e}") + + return configurations + + +def main(): + """Main entry point.""" + parser = argparse.ArgumentParser( + description="Comprehensive profiling suite for DynamoDB encryption", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + # Profile all combinations (default) + python profile_comprehensive.py + + # Profile only AES with item-based tests + python profile_comprehensive.py --test-bases item --providers aes + + # Profile encrypt operations only + python profile_comprehensive.py --operations encrypt + + # Profile specific data types + python profile_comprehensive.py --data-types single flat + + # Include v3 and v4 comparison + python profile_comprehensive.py --versions v3 v4 --providers aes + + # Profile with line profiling + python profile_comprehensive.py --line-profile --providers aes --data-types single + """ + ) + + parser.add_argument( + "--test-bases", + nargs="+", + choices=["item", "client"], + default=["item", "client"], + help="Test bases to profile (default: both)" + ) + parser.add_argument( + "--providers", + nargs="+", + choices=["aes", "kms", "hierarchy"], + default=["aes", "kms", "hierarchy"], + help="Providers to profile (default: all)" + ) + parser.add_argument( + "--data-types", + nargs="+", + choices=["single", "nested", "flat"], + default=["single", "nested", "flat"], + help="Data types to test (default: all)" + ) + parser.add_argument( + "--operations", + nargs="+", + choices=["encrypt", "decrypt"], + default=["encrypt", "decrypt"], + help="Operations to profile (default: both)" + ) + parser.add_argument( + "--versions", + nargs="+", + choices=["v3", "v4"], + default=["v4"], + help="Versions to profile (default: v4 only)" + ) + parser.add_argument( + "--iterations", + type=int, + default=100, + help="Number of iterations per test (default: 100)" + ) + parser.add_argument( + "--line-profile", + action="store_true", + help="Enable line-by-line profiling (requires line_profiler)" + ) + parser.add_argument( + "--output-dir", + default="comprehensive_profiling_results", + help="Output directory for results (default: comprehensive_profiling_results)" + ) + + args = parser.parse_args() + + # Generate configurations + configurations = generate_configurations( + test_bases=args.test_bases, + providers=args.providers, + data_types=args.data_types, + operations=args.operations, + versions=args.versions + ) + + if not configurations: + print("No valid configurations generated!") + return + + print(f"Generated {len(configurations)} configurations to profile:") + for config in configurations: + print(f" - {config}") + + # Create profiler + profiler = ComprehensiveProfiler(args.output_dir) + + # Run profiling + profiler.run_comprehensive_profiling( + configurations=configurations, + iterations=args.iterations, + line_profile=args.line_profile + ) + + +if __name__ == "__main__": + main() diff --git a/db-esdk-performance-testing/benchmarks/python/pyproject.toml b/db-esdk-performance-testing/benchmarks/python/pyproject.toml new file mode 100644 index 000000000..58f57a623 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/pyproject.toml @@ -0,0 +1,116 @@ +[build-system] +requires = ["poetry-core<2.0.0"] +build-backend = "poetry.core.masonry.api" + +[tool.poetry] +name = "esdk-benchmark-python" +version = "0.1.0" +description = "Performance tests DB-ESDK Python" +authors = ["AWS Crypto Tools "] +readme = "README.md" +packages = [{include = "esdk_benchmark", from = "src"}] + +[tool.poetry.dependencies] +python = "^3.11.0" +aws-dbesdk-dynamodb = { path = "../../../DynamoDbEncryption/runtimes/python", develop = false, extras = ["legacy-ddbec"]} +boto3 = ">=1.26.0" +PyYAML = "^6.0" +pydantic = "^2.0.0" +tqdm = "^4.66.0" +psutil = "^5.9.0" +numpy = "^1.24.0" + +[tool.poetry.group.dev.dependencies] +pytest = "^7.4.0" +pytest-cov = "^4.1.0" +black = "^23.0.0" +flake8 = "^6.0.0" +mypy = "^1.5.0" +memory-profiler = "^0.60.0" +tox = "^4.0.0" + +[tool.poetry.scripts] +esdk-benchmark = "esdk_benchmark.program:main" + +[tool.black] +line-length = 88 +target-version = ['py311'] +include = '\.pyi?$' +exclude = ''' +/( + \.eggs + | \.git + | \.hg + | \.mypy_cache + | \.tox + | \.venv + | _build + | buck-out + | build + | dist +)/ +''' + +[tool.mypy] +python_version = "3.11" +warn_return_any = true +warn_unused_configs = true +disallow_untyped_defs = true +disallow_incomplete_defs = true +check_untyped_defs = true +disallow_untyped_decorators = true +no_implicit_optional = true +warn_redundant_casts = true +warn_unused_ignores = true +warn_no_return = true +warn_unreachable = true +strict_equality = true + +[[tool.mypy.overrides]] +module = [ + "aws_cryptographic_material_providers.*", + "aws_dbesdk_dynamodb.*", + "tqdm", + "psutil", +] +ignore_missing_imports = true + +[tool.pytest.ini_options] +minversion = "7.0" +addopts = "-ra -q --strict-markers --strict-config" +testpaths = ["tests"] +pythonpath = ["src"] +markers = [ + "slow: marks tests as slow (deselect with '-m \"not slow\"')", + "integration: marks tests as integration tests", +] + +[tool.coverage.run] +source = ["src"] +omit = [ + "*/tests/*", + "*/test_*", +] + +[tool.coverage.report] +exclude_lines = [ + "pragma: no cover", + "def __repr__", + "if self.debug:", + "if settings.DEBUG", + "raise AssertionError", + "raise NotImplementedError", + "if 0:", + "if __name__ == .__main__.:", + "class .*\\bProtocol\\):", + "@(abc\\.)?abstractmethod", +] + +[tool.flake8] +max-line-length = 88 +extend-ignore = ["E203", "W503"] +max-complexity = 10 +per-file-ignores = [ + "__init__.py:F401", + "tests/*:S101,D103", +] diff --git a/db-esdk-performance-testing/benchmarks/python/resources/flat_attributes.json b/db-esdk-performance-testing/benchmarks/python/resources/flat_attributes.json new file mode 100644 index 000000000..98caa4fce --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/resources/flat_attributes.json @@ -0,0 +1,296 @@ +{ + "Attribute41": { + "b": "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" + }, + "Attribute40": { + "b": "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" + }, + "Attribute43": { + "b": "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" + }, + "Attribute42": { + "b": "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" + }, + "Attribute45": { + "b": "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" + }, + "Attribute44": { + "b": "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" + }, + "Attribute47": { + "b": "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" + }, + "Attribute46": { + "b": "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" + }, + "Attribute38": { + "b": "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" + }, + "Attribute37": { + "b": "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" + }, + "Attribute39": { + "b": "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" + }, + "Attribute30": { + "b": "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" + }, + "Attribute32": { + "b": "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" + }, + "Attribute31": { + "b": "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" + }, + "Attribute34": { + "b": "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" + }, + "Attribute33": { + "b": "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" + }, + "Attribute36": { + "b": "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" + }, + "Attribute35": { + "b": "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" + }, + "Attribute27": { + "b": "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" + }, + "Attribute26": { + "b": "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" + }, + "Attribute29": { + "b": "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" + }, + "Attribute28": { + "b": "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" + }, + "Attribute21": { + "b": "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" + }, + "Attribute20": { + "b": "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" + }, + "Attribute23": { + "b": "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" + }, + "Attribute22": { + "b": "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" + }, + "Attribute25": { + "b": "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" + }, + "Attribute24": { + "b": "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" + }, + "Attribute16": { + "b": "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" + }, + "Attribute15": { + "b": "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" + }, + "Attribute18": { + "b": "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" + }, + "Attribute17": { + "b": "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" + }, + "Attribute19": { + "b": "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" + }, + "Attribute90": { + "b": "bkBccBRobKcT7ECnPA2IwnBA2Bkqj+2Tk8YVapygMdN0lxtXs7owL8Ox8WKN/FaK8cCN9WQQo4yGiKZ87DJ1oMfk19j++k4UMdoJ398CtQtfj0ynnOmlE0rZMBBNmqMTD0hQHEswVieS8rWMkHoxXMKpSqbf3UUGRlASiGl0bjLX4f3TBJsEXqDN9RU073QhSrmc2pPmk1ukHizDXO9ljhGM1fgmQ4Z5GDBGuBCQeqLI0ood7ilrY9MDKz425EbpjyJYWcPWhmc6jSPFoHKVujLHjLp8QTKYB1IpBn3BATqLWzMigNgwh0zTdyQRpeuNJARQ6J3QDmS3At3GqEXEAiAw9SsXHnREF0hFZccQUWpaBGn7BGuF1x/bw7OlCZDnztSTB9aeLa1odSBh2Sys8jhQkuY5y79UvKD/x1PbJxz6Qcx5H5IKvZElS7eQgE6OQg6bdhhZ85/SXdTcCehdj2tMmVPm3UAe5W+CbOz16hikI2eaUACimum1+mIOtwyxz01FXDbVdgY/1dHMH/wT+6rkovHlVq8sTEo4Hx70RE80XdhPrEZ0qHxs/UQPemsmSVUMz68ThIOJLvAm6wl6To8X5cr62nZs/B5VSdiQ7uuV+XPV2dS53PNsnX2ajLfvOPj1WmbDQ8Il9QKISC4HRkk211hiNgmHI5tpIEJ0Ke9sQR3RSLhQ6eByJpVib037QkE2t584dKFzflEBcSeBBMp0aWKPR558GgRP99zSIvIEogfvt/bmZYLAiW+mVQE211tAGD1zHelFeSf7oDuRKDNCa9Mmrch5s7MVr9ihOv56oOKQ55+6NtSTZP1OwxcHGw5/YDsQN9StJ8IN7RzDe4D1mRY202e1wqJI6rlcTzAqJXfcmfLlRtxN9pdEkHLBGc9TomhCwDAML06KZkaRgnCaW6S6O92b760MrCyY7eRZq6p0zzAfRjK4y9MQTQm8JsWNvWcuj4dYKiYPao6JmLjqn45RHkRauoCi4Sbe3RQkIXeHQf8AZM8UqdK3RNP0kjiIeeZF3nStakpfS+pXLmm/AzM8u//Gz1LeTUCPQpWog+x7HmyZ+RjkzDLWlzTplkbK9x5+m4oYkl6rJZ/kUp6GYY+Y/YXPjeOA7VDFihBzgwNZBflizCuNQQ76LAe3e+CXKYx99gif9JkU+FvuSWmJsy7eSBm90V9BH0hzLrcsvSYxQkQsh2lU3KJCcrtmB2Omke4c4NeV60PmDfnfagAO00SZjW1mCB4IPVM+swV+UiI7TS0QPUVM/DA4LAwzLVJV0oHXXjgch81yh9hUbyWicWNmATp6dVyWay7MIDpK799XgZC5M0wsXA7szZu69QSmrHkGCf77SZ68SCQOS9MZ6JEyFrqJv23f5MSCDpMNhzcxGvYC1HQ6lmlSFsm8qU3zRMED3wKj23nSB2VGbC8OYWCvjF0Jvv/rBQ71E5ePVmvJcdDT3amykYze7luKQWpc7PWPZEl83ECyry6YJK7oun0XvqCsh2iAvSl54AnO9d+weyUq1ZZYNb5fx5rdEck0yZwXepV1SPds+91P/YPGfyIleXv3tiUrU7mj1fUqhodof7/I7bEfqxAY6yPJsm3UiaqzU3vLE69qT6M/30vAv1JQDkaf+/kYwX6k8yLSSIkHF0FHeIoVfTcli83CLgIbpDYBRSgZ7nX22VZIe/xhtCBLZ6H96FRQVDTAdUduKS2iariCUVT6G+INehIlcOAZXXksLsKhV/F/6NEA/wxfGhu6RRjl+fAF8bBj6EAOCT1TqI3qA7QzNGqj1HB365/nFwfLZ8vadCxEjMl4Td7OYFg2BRUw5dPYGTiMCT9T1SMYx+ge9MoF1vMiFNtBiPPZ7FFhWME6TH+/cGZDIHJ9a9OEfKhaJR0swyKBp0Hdt1TnfeoK/38+Il6IRTN61uOIy1qvp0ZFWqeB9RUBTkwc8FMR2rvtwk7JjbEaMeH06TLQfVRWog6/JLgzYvvRbbFQ9rkgic7Xp2XBj1DHIqVfrPOxl+DhY/y1Zy0SBox6+Axg9Xz3/9WPCuW7BTVfo+vFVdD7F4Cuzn6QZFFIIdFTFZeZ4Ubwlgz03UEXDSoRhASZSKkXhlxqMe8P/RWbdIf5WUssfRY7mA1yIvu7ivB27suaDLTsX/j735qm6CmIyS0qCSyhlKbl6mDTav5EqwLBDtzEz+eqIvmdIWaGzNlisWag9986/7RkBL3dkgiMfhBEOOLvVLmwdSb5fEDlVd+46zaUliAwuEuju9OvBkQTFalrdKmXBjSd3yjIc1qNzj3ewOt57WmH47yf7wjzZwOmSEdpwieVxF/C6AK1mjcUloSME1c6nKUX+K3hbKXtgyXaMbsf9mnNoi8o2VLArsh0T7niJSYBlZwNHSJGaLMk38Oj79qWDOkOyQvKFxtwqfaAuthnWZT7bvide4h/+MiapqvlGNALzgyeZtp1mp8ZnDHYUw03ktdi9M5l1ZrgL2YOa/R7xnhLw71GF4btgbJSza0XW+cAxLRWwy/htPUM16KXWUuBZ1Uox2johbEAZPCEqSOKPiRNzxiF+mJZobBHd/r3qelxIXdgwDK8sislwpqQ2Rs+ClW2AZGDGWq0QNDp8WV2uTRTnZfzSvAWszQQ4/lzHBUAiMq2V7+uQuSA/tXuS64H0DhxDdy33EM=" + }, + "Attribute92": { + "b": "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" + }, + "Attribute91": { + "b": "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" + }, + "Attribute94": { + "b": "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" + }, + "Attribute93": { + "b": "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" + }, + "Attribute96": { + "b": "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" + }, + "Attribute95": { + "b": "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" + }, + "Attribute10": { + "b": "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" + }, + "Attribute98": { + "b": "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" + }, + "Attribute97": { + "b": "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" + }, + "Attribute12": { + "b": "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" + }, + "Attribute11": { + "b": "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" + }, + "Attribute99": { + "b": "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" + }, + "Attribute14": { + "b": "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" + }, + "Attribute13": { + "b": "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" + }, + "Attribute81": { + "b": "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" + }, + "Attribute80": { + "b": "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" + }, + "Attribute83": { + "b": "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" + }, + "Attribute82": { + "b": "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" + }, + "Attribute85": { + "b": "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" + }, + "Attribute84": { + "b": "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" + }, + "Attribute87": { + "b": "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" + }, + "Attribute86": { + "b": "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" + }, + "Attribute89": { + "b": "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" + }, + "Attribute88": { + "b": "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" + }, + "Attribute70": { + "b": "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" + }, + "Attribute72": { + "b": "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" + }, + "Attribute71": { + "b": "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" + }, + "Attribute74": { + "b": "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" + }, + "Attribute73": { + "b": "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" + }, + "Attribute76": { + "b": "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" + }, + "Attribute75": { + "b": "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" + }, + "Attribute78": { + "b": "dmpim+nJf9Ze3cRPSNtEqdl3gFgr7VsH3UhOtcLMOXdzOrhTJ9+HXZFevN28n8azlNrz7sPonvtrVsj7nroqdrIvotZnkBM6UZ6md7rULPlZx84j4seZwjI8pwbUsPKEX+c+KI+Ua6havbHo5Hs7b1v/H02zlW0hBkfAKRnUGi5WPacEKQ2r9DucokshvK4OwznJSEBO94/TLIt3p/4qSKzuKyjktvxq14F1BB3GOPAubuSV+5bftxSblhC6bFHgJwy14xGqHdPoEf1FxsinQC3vl8g2B7nDXBWQ3hV5owzBPK2RJqtH5HeT+SbQ9SUjw1RjiaoAb1vRI/k7e2kJ+inQIuM+C+XgZYdifzKWxcTrNi+o9BeH0avR41I1Syc6QaEIiJgYsFPmjtxjpy7LWBC4qcoTDfcyuntQLpLf1M2hyMBoFB8gugGilRoutGdxk9+55OxTkaHe7gaTYpj2qBMfW4K5+EXCEZYB0ovQ1CxJxBP5xixKn4zWBLZ7pMl0FZAxejIueqRH9DA3wzYF+/qGN5fPTNe2UHvbzzUM9SVaPMwoS6d+CyUgvEakB1tU4xxlK5UWbDxF0ZZd7d3xk0lsN6956/XvBM58WDtGFpY16k58jWKUt5/WB5mFapyffFI1JVDyUcaPyY9zW1xtXZQslaGP12/lIUKMU+KRAJ9DnvWRCoScYEYMWW0dr4EmmDVUVVfTzyinga3nbR+ztB/ePKwHKrvv/COEM1pDoqhPdU/CBuP5q54IMWeTNkpxR7Il0kevEKJa6TrmM3KOZblUg9egyxBuh+5zhEXPxp0mz+XD8jCed1qGDBWKraolS+AnuYwiZvR43Sv3eUIBVtrPQPDQvgUGzMw+hoZUWadtQm4eF3Y2XppQ50Wn5mqqt9iSjNKLEBHU3INtE5jpm/wNg0rxBZInrCLn7ky8ttjCCZ1Fh66aDmobTtxgb84oyFif1q4LdP5+bCvkaio7yzfBfRGncQbn2Hg8g1+cD4gXpjKyRpNKq3ezzS8Gyx73BK5+jow0mYVAB1mRSMAmDyGhb5WV43A0EGgCX6lHouFLsqJltNtjFhThI5sWgLrXkafFodx2XhJXtFsD4EUZjeSVHVtB0ZghnF+k+Ai56YEKJBETPoOMgG2aJzO9Y2TO2IgfEnmVcQ50ofr2IsUYDKC4jLNEE1S1CGMDc1NE/hPndZ4MRt8F+gphK4+pz3KIWznNO1quRhHyW/7bPaztdwMlBxu2TLY4JBsgEas5kYy4dlLnT5HDJIjm5aIXri4O0y0AQ3yjDEtZhRVXdQ77kyfYdk3ZdsvAO9aUXgTnZEExuqgfbaEziZNU8qIaiG4yjsbH/Q/wVCYTH2CMJ8vot6wY/eAEXWhKk1NAPPOjJt/E5hB27UyjzSfU+toqAoKrBx9LW981B9htycFCGseOVhckpMfTFGItJnZrtbrTYNa4XOAKQFUWDgcw3e7tchYMx4qoqAYPh1/RkexgCKQoGGodXIuOvm8lnzpZppEJF+qI8nm9Lts8gH6u0sFJgB2+eztPxdHv7MVCLCPhbaL9qQR5Y53WGVgpl4zRhDe7xul/whMAORI2KVZ+Gder7ipjV8w+dfAkGXsZtDr7j5mY6bthBhmXuhbJEdcUVbotO4uRRcIxTlg8uRZTD3KRDnd3q66LXOE5es7/T6nkzjGohjjTh8oq6pqhM2z/LIOII7l8N4vgs31xOIAMWqdedPcUw7MWnp9T3kcqVbB3Ls3njpJlSsvJgOR8RyA546Y65lcgAHrOLUkIcEmF5HBf5g81BDDRpIdL0TbcxS1EI8pF8S4GLjU5Q9EX8rNeTGgeBX0bnkKscYQ6UBvlWkIZrXm3RHNu1IqWHx0ZR5rJnAwc69cZ0y2zkCf4s+lf8xAHysypTi+jzhwZtskRs4bWsWfWapJGAZlEWJ+o6W3JU/n7eRnESjATbZG9n2IWqPOkI0C6biCsGCSOKNIba2hwF+IIRr6t4E6k1qxNYtcGU0+HeONP7x1EM41zXJ6exrrr1v9VUY17170eehnCwLhcORTPs6NeoNhWNmxFjZ5DyotTi1317k7rexd5W7p9TvdmsXwtB/hfsURd0eJoej36PBSX7JANdingWskCWXSVEcQlrgd5vuVTBDz5Wsxb8ekofRSBU2WyFjTK1BAgKwQcocMVK1wN9WL/pfMpdBci+iExMBNgcNeZoRHeGvRTOYs/V7M5SmWEKqJcjJ6UaBTUdwzFiEdeAH9b1qXJWtYeWW6qkQS2EPMZjCfaXIDQ7ePb9S4/U1Cm+FVRu1sJc1ODNi8REV7KMD9QkjndnlRo1lU3vIef5DQYj1gjIsPadomXo/cbj89H1cVxzOqylBofSFFgJQYa6lfnGJ8EiFLV8VPA5JE2CJ2z6JLZJHHzSHaEeffS2NalEYoCAvkSP7nEzUT8FsUuRdhJNbJ/ZstRVnA4XrtrnMwH5qm0kagxWg/z8Y0B4SEB5Q8zFcEu6kt/OdbcAHAxiN01n7hrNVD6ZDpGRNvoyc6ih/hhCPvLW3Iaiuo1Hk2Amph+P7+8MkRWrwzr40U8f3hErU9BaFGZ+K6dGOMwjZwrurot1RaQZAAPES+NjgZu9tAwR7Gl6RycWPYJCK9AgN8L5K+M/1Osf/SK0P54y0hN78zwcOtq8Cyztrc=" + }, + "Attribute77": { + "b": "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" + }, + "Attribute79": { + "b": "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" + }, + "Attribute9": { + "b": "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" + }, + "Attribute8": { + "b": "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" + }, + "Attribute7": { + "b": "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" + }, + "Attribute6": { + "b": "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" + }, + "Attribute5": { + "b": "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" + }, + "Attribute61": { + "b": "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" + }, + "Attribute4": { + "b": "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" + }, + "Attribute60": { + "b": "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" + }, + "Attribute3": { + "b": "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" + }, + "Attribute63": { + "b": "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" + }, + "Attribute2": { + "b": "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" + }, + "Attribute62": { + "b": "FF4K7xRKfXRj5hE/MydHV3S67iEUZ7/w0jybZiHg0uCxb76D7R65uhjr9J5QdbGh0oMHBmFLYcAtJWd5xD9JocmC5jDbJg7NCD0ietnkvWHlKdCO1IRNRTF9KApAX1PTitaFD3isXQqTmGKtRhQKpySsVQKIuYY+lsPq81x5kPpZpWJ0gacuHW3Kx/nTDWs+fQTAUv5qgGqruBIy5qz7XUvX7hxavSC5HOYWd/17HRTQgQOimX7xXtJ8pcEw+Zr2qoSkzIjRjgZ9zNKrCe4X43LycvciVj9YAP/kv45KYeF2SIBnNCbD3EACoSB9LLFNq558FER4A4U+u5v92ZaVweFig8GvDF/VZ9YCgqWdDBA4Exz1EcltoCrJsQ/vCVEZ0qtnrugl2DXL2JwID7r+2Mm7ys97UoWEdzrlnjBC5v1jVe9X+DItppeghu0PkVt6hE35V9ycibtoyb9ZAp1DtmN+eoSXdTSuy+JcJTxd4Y2BAVydbpf2/VnXI3VPk6LB1ZTMQqOgJf262A968SgxYEufkyHUEO34NrsKGQImFn1viCtjoFhBkYz2p2DNgofvZVf9pJC/Aa8CYE5wjlrKHhzNQkEzRLjvvfF6lTNCJxDDbbO6itq0Q1IzmFNmxwYGey10paasM7+cF4uey1uoVE20CGuPQRQIz2PPsIYwRm9dbYDvaK6hQc3zCtH/xZwsYNUIC9A1Si24b6Dh6TP1c0u8sU+K+SZcyEY/XH9tPchMbsf2X6IamF0D+BwQBqrd/ffxjkIiWBZXTDkpvjkRtNf5hwu19JDupSeLEII+57zkvnbJbIEcvBxSIxRyIcDLuIoIli+FYB+JwMZ4RrS746FS7YoEpdwXCZ4ZIRhPhBcdVnnojI+5UJdbwD5qatFci0pQ7q1Q3ozlpMnTbVXrYyUO6/Jxu5RacE4CPYCMvbcuFtG+LQ7wM86QUb72c9nnZww+COU0t65KJU1NHHuji8dPfxruTcZ+shcasXnrABlqTNxw1VTx1m5hqKpX6Hzhyd6Xwn8XrFDUoaSygmI/4yo2yIuR2VmAu4dcBE8EmU9a6qUYEUpp7U7AhwvfWZPTmjjKBU2vh2Ahf7DXpLkkcNab38L7bICZifMTQCSxm2scNMcdoUgMICc/hMf9+c0ES7FoFTcQJknGwVrGKDvTvgq1iQQKh7DbZs4isoEa1In832Sp4ryTRZgdkqSGYvquMf6HJWczNrwMkeU2X0AXM98GBP7AdZhCaBwO6R3eYJlR43CNfAagmlrngjZG3fhNHzHymrXHiPjw/EoakXUBC55zibJyQUKlJhwimu07H8uaaNXuTWrw+MB9wVLI1aEdQnQlmlXWHYBao45WjBxuQ2NYww81cKcevYN/uW11aHTZqsS1lSBIaXOoJDJhYcYjQb/Ylr8HLaydEL9tcImaavP3ntmGLWGAA+1QTS3LXssvslwLYstp5WyJ9ciDCXTrlUGpXd+UWm4v973OtMXHUNquGbU4oju0CU0VEJ/ES5a4LV3RP+EQUTGQiF1BROxRJn7WOH8wbbGpmvtJfYV1RsmszamjiHn815IVRR+uoaup5hgVGdj6vVTIRPYeR5TSKFTS+PJ0Z1kCCmM3IduYNS8vnPALSccyY8kAzUR5TtupiFOLcRwo6Cmf7qMbIMKnNHElrwGiIY8IBQKF9lSWzRV5AcRPKnsz01iLgmZrdp5tu59sySC/eMZ8wNsAQfjQquj/Jhu3pk4gqcBCYHH3Sj8EqtHUYgrS9UILv3BGoTaXyVDSSBGqT0HMjEnq6Bi+RuwAsLg16qVAQQKGGpUPIoGnBw6wFdEU/HakCOjXJOPQUG54sPdhqiZPEpwVGJ+QAeKPtg4YKosp1YlDxe9MMWCuKOcaiK0lfJjt3T0aZJkkt4+CglugGTfYFIjs+TrSK1PMNvjHuhPpU7otr/oFu+kdMg0RG73Kp9VGOVBUknyeYVhFcKoihGjJ8XBP8YtRx3DhHCMiUU2QdYPM5X10idai2VlM1QNLyqipP0XjTdok6LzVA/WI6hrxiAIks1rcJimtpHvRYEkxsEEKe0d7gN/kUmZjiS0eA6HB9oua1gyVwoQnjsvjw5eir18hG+qIxwpqRNWOE5Qd3MjYGwEM4l07l2085Cl5RY7jSyrmH5ghK+M+U0f7680lPQXYpvWXbXCmX94Q+GpcY/56zM/GeSb//YC372LLjqw5/E0bx5boMcWK84v7l0/aVOsEwwAFgrKKIkS4DXNsGBFlBar9PKT1BmSd1fc1Z6p4fRCjSvXXPdIHG01BRIqpI+gTV/IcrFmDbiNEhFY+EMKe84/hEziRP6PH7vtfnKbqKIvr/pa/dlesbSS7QkSkE6D0OtzZro4TorIapdBuG5OTBhKICc4Cj26LanxEPoHSBx9Lase21K2srcP6fFvnwQIig37ogkMfay/yJQbBukxTwtHrCMFYNCpsGj151htbewBCKe6z0F37Lk/jK7sjCCnyztKms9GjZgjm2inlqmZdxehKP/ImnYgCLvdL62Sz8gTGgGll8pKRe2wgEaBlbHIZBfTMAArZd0tEoPVkY7MyFGKSziR0Mssn66oPt0rhMquElHZVt5xYSdF7CA73hq6BKkvpL/FT3FCfolXqJIB1qjEeb5rojLZkroc4JfF6tG5HE8w=" + }, + "Attribute65": { + "b": "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" + }, + "Attribute64": { + "b": "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" + }, + "Attribute67": { + "b": "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" + }, + "Attribute66": { + "b": "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" + }, + "Attribute69": { + "b": "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" + }, + "Attribute68": { + "b": "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" + }, + "Attribute59": { + "b": "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" + }, + "Attribute50": { + "b": "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" + }, + "Attribute52": { + "b": "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" + }, + "Attribute51": { + "b": "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" + }, + "Attribute54": { + "b": "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" + }, + "Attribute53": { + "b": "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" + }, + "Attribute56": { + "b": "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" + }, + "Attribute55": { + "b": "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" + }, + "Attribute58": { + "b": "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" + }, + "Attribute57": { + "b": "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" + }, + "Attribute49": { + "b": "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" + }, + "Attribute48": { + "b": "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" + } +} diff --git a/db-esdk-performance-testing/benchmarks/python/resources/nested_attributes.json b/db-esdk-performance-testing/benchmarks/python/resources/nested_attributes.json new file mode 100644 index 000000000..1e64bd5bb --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/resources/nested_attributes.json @@ -0,0 +1,96 @@ +{ + "Attribute45": { + "m": { + "Attribute10": { + "m": { + "Attribute9": { + "m": { + "Attribute8": { + "m": { + "Attribute7": { + "m": { + "Attribute6": { + "m": { + "Attribute5": { + "m": { + "Attribute4": { + "m": { + "Attribute3": { + "m": { + "Attribute2": { + "m": { + "Attribute1": { + "m": { + "Attribute0": { + "b": "PBiVnjpJfmvs49prCPbDKmv2bGIbQJWPPBiRgUOcCO9xErWly9m4qmv4acQ7GVqnGO4ScAisgjEnCW8rfL+3GblVbnhVchiZnRuc8vUTDpojT6U/Dp2ZUPkwgXsyRT1XwJJVp7s97twtkiDC0WGzh/ryYUeo5Kcl8h8wvC4Cz+HaVVzetEOa4wwf0YVgWVYO8iRjQGmq2iXRBEJGaeGZx31Xi5dNrzKV6wdC3agWmY3Eet5+d5oDolx5FleS9vJhwlyG/2RlXRLCKZ7FoTXT9Ao9NiUKZOV+3F7f4ItgqFnop3tFLutVkkwdQe23XH5+x1+fI/KHIUKeymgR7PubrtH4YGKxnFl8iGvB/UuXucfcCl6sD3ehyHMCQox/5REUhB2gPUsz9EQ60lyUMoDtAZSy2gLWAJX8MIlZXcLMXPapEpX3KZzmbGeY+Ow0PNvzGcARUtMRYMovO155aBbSqRC0fwzRHqI83fIn2I5EoB78yR+FIcIRZc16dznYzi+WKv3K9JnTkXypeOpwcQF5orFc7PL0sz6k6mwmoK1s3qyO2cvhLWqsd56nFCuANExuEFM1DA/CWOZsRWJdNGO4G3aFWTgNQAgL1XiUP1YzSdzWvnwhTv7da7yjQXjxhEH5P37hdAzHa2InBQQw/vEiHSJhm8QeAPmQR//CPBo2eJrtAtk20jsUR7U5PBd53bG6+LL5PwCDbKT+I4aMGm+qXaQkrktbrCyTYZzZwDyGBgrBfbEbClXkW9a+iPkQj/j4MGeas3ZOr3FSIOUNrxo3nMkDGq9llQUPSfo3Ik3+b8Z+8fjESCarj3QKEwGvsXGcwLiAS9BC2PPUKmme2qDnGiFOAsXG/CdJ9eVJ6QxlHZE6ihCjGxpkkHeLC23vGAhwzrsPhz6mIinKiGOFDDwUJS+4Ka2txJp2OAqlOn3ZKQ3gDcjlz5hbySgoWqjm5T91ez2sb/9W6SigJOwIpgjz5dUc2DPr0vE7C31T2UhEI95fyPbCHx8LtzzUELg/Mt+YzsYYFNwRBK6y+Dun0sUabP5CnFwuw/c7HYuGslXKGtMTgESDPVjS3yAJ5OuZkF3g4esRK+KvBudYQGGEpX9c4o1znj99xBlknW3RBqV8CbR0/tdSBdeho4eMl3ciXqboSzMtJWC3pFU0mzYsc97DoYbr3uv0vSHER9a7ZnLBGPn9+GqHfUpJVzMxwkBzIbkFzSEr9CDcrE24jv7XchdBYHx2jQvAFtA/rX04X4syBdNgZvnKkUk0pAB+ixquco59QDbHCOpKfcj7EQkRkrrO9Du95e1evedeyB+UkOns1d7oiyT+DBI28g==" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "Attribute44": { + "m": { + "Attribute10": { + "m": { + "Attribute9": { + "m": { + "Attribute8": { + "m": { + "Attribute7": { + "m": { + "Attribute6": { + "m": { + "Attribute5": { + "m": { + "Attribute4": { + "m": { + "Attribute3": { + "m": { + "Attribute2": { + "m": { + "Attribute1": { + "m": { + "Attribute0": { + "b": "agSrC9AV3DqIEivxHVVW3hSYngXPJWrRrn1bQ3Pv/N7/UdGAFdUjN5Oxkrj0WB6otjXbFw6V9IUCIM9KB9HdKopUqJE1BVtcw4qqkdgTQXeVfVAvyXwShkFdMe4m3Zq8+2lr/sD7XnBsfKMCW0Sa33PpxMT8tnLn4LCX6txF60MF04iGvLMjnkYP6ROiDUZpFb42O1Ummzn6AmgtCdePo5/HKewgiA8f7t6+w+h1iYzD54Chtpg1Xc0YlGHh3LQwhJv4Y1q+I31jkvJL+TTcWczmDmy2eSZCO5Wi0WpaOn2z8tbUyuC7zIlkpBG30u2SAMxx0yFV181Kiae0AZBcpe8Fdk9F6e2LqTxoVZkVwPo0ReiMdClfLqSUjt7W0XbuP/cCcpM71czvVkGAJ8EwjMK5K2JiinIKGJZYtmuu2sFvNlkA8G9S7+t8Ojh/pIwXBncUxlGTRVEX7C5HGGX1s471bNWP7Ql2Ec6cPdP4BYHi7Obj3anJ6DhFbjuKrD1Vbq3fdhJVq3E5GAdw6Q8oezr6W89VEPEbtAALk0DJo/8osvD/FLvLlB/A50CaUqIheUm2azlI4nXqHvHwDfR9sJXXO82fstxB5DkbR1OPBEoLvXZYwkRFqtzBQW2ZECtE1SX4TrYnCsyLEbGdl5hGueHrgbJabRRGsT2Q9OCz5RXMnairzQkJs32DGTZ6MzWu8K3IwB9wmycxuYBesXqBG6ANcWlLxiDZBqU9TCdWHlqyuMWzZeSNJ0xeapAwsAwSPfWAKA+T+ZHVHES5XLZW8qNLYncxvV/wkxrfMlREkDXRekaV6Ij574BrBPjpp3L+xewTN76LSby97zq7ahJoS1BvWx0cjjrl/sNqTDVLTGgcNUWc/JGilSTUnMyQd+178WJenuIQY6QrdE6luQsxnDOtW/8MpXrARSPrPTs5bpWvySk66JHrLEfdfH6CbtC4lrnsu8XfnSdEnsVksbup18gvG7jN/poVd/z6PrMwxmdWl/OYMiVsAmX8hp+QiE5UQn5cX6jcQ3dDg79NAbbZeIhoGr4Scy5slAu4ekUlMkZhT2ECf0IMURaAZ101x0zDxlBo/1cE1FDeYJY4ljk9fjJTCgjRo8rewpanPa6g0yGsoeZgqENB5vaYkPMZBkYqBMQgmw1rQSH5yHvX3FAQl1wXD5TejZrksSjaDroqU8fq6hvNGGRDR9TOV9fGZqvJ+yQV2YrENNOKvXgqOb0ABjq0YmXL9gq+UP/Z7oXwYxAxUVwebrAVCx8ubVqprwHFEFR7SnMxTm7NyMKFx8mwN62irXAANC6DsvrZ8vOG9wrM+truUKPZEg==" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } +} diff --git a/db-esdk-performance-testing/benchmarks/python/resources/single_attribute.json b/db-esdk-performance-testing/benchmarks/python/resources/single_attribute.json new file mode 100644 index 000000000..71df9a99b --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/resources/single_attribute.json @@ -0,0 +1,5 @@ +{ + "Attribute1": { + "b": "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" + } +} diff --git a/db-esdk-performance-testing/benchmarks/python/run_benchmark.py b/db-esdk-performance-testing/benchmarks/python/run_benchmark.py new file mode 100755 index 000000000..90174dfff --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/run_benchmark.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 + +import os +import sys +import subprocess +from pathlib import Path + + +def main(): + script_dir = Path(__file__).parent.absolute() + os.chdir(script_dir) + + print("=== DB-ESDK Python Performance Benchmark ===") + print(f"Working directory: {script_dir}") + + # Check virtual environment + in_venv = hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix) + if not in_venv: + print("WARNING: Not running in a virtual environment.") + print("It's recommended to create and activate a virtual environment:") + print(" python -m venv benchmark-env") + print(" source benchmark-env/bin/activate # (macOS/Linux)") + print(" benchmark-env\\Scripts\\activate # (Windows)") + print() + + # Check Poetry availability + try: + subprocess.run(["poetry", "--version"], check=True, capture_output=True) + print("Found Poetry package manager") + except (subprocess.CalledProcessError, FileNotFoundError): + print("Poetry not found. Please install Poetry first:") + print(" curl -sSL https://install.python-poetry.org | python3 -") + print(" # or") + print(" pip install poetry") + return 1 + + # Check package installation + try: + result = subprocess.run(["poetry", "run", "python", "-c", "import esdk_benchmark; print(esdk_benchmark.__file__)"], + check=True, capture_output=True, text=True, cwd=script_dir) + print(f"Found esdk_benchmark package at: {result.stdout.strip()}") + except subprocess.CalledProcessError: + print("Installing benchmark package with Poetry...") + try: + subprocess.run(["poetry", "install"], check=True, cwd=script_dir) # Install dependencies via Poetry + print("Package installed successfully.") + except subprocess.CalledProcessError as e: + print(f"Failed to install package: {e}") + print("Please install manually with: poetry install") + return 1 + + args = sys.argv[1:] + + if not args: + print("\nRunning benchmark with default settings...") + print("Use --help to see all available options.") + print("Use --quick for a faster test run.") + print() + + # Execute benchmark via Poetry + try: + cmd = ["poetry", "run", "esdk-benchmark"] + args + print(f"Running: {' '.join(cmd)}") + result = subprocess.run(cmd, cwd=script_dir) + return result.returncode + except Exception as e: + print(f"Benchmark execution failed: {e}") + import traceback + traceback.print_exc() + return 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/__init__.py b/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/__init__.py new file mode 100644 index 000000000..b2fd07a44 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/__init__.py @@ -0,0 +1,12 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 + +""" +AWS Database Encryption SDK (DB-ESDK) Performance Benchmark Suite - Python Implementation + +This package provides comprehensive performance testing for the DB-ESDK Python runtime, +measuring throughput, latency, memory usage, and concurrency scaling. +""" + +__version__ = "1.0.0" +__author__ = "AWS Cryptography Team" diff --git a/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/__main__.py b/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/__main__.py new file mode 100644 index 000000000..cee63fc93 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/__main__.py @@ -0,0 +1,7 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 + +from .program import main + +if __name__ == "__main__": + exit(main()) diff --git a/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/benchmark.py b/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/benchmark.py new file mode 100644 index 000000000..150a66f7c --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/benchmark.py @@ -0,0 +1,371 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 + +import secrets +import time +from typing import Dict, List, NamedTuple, Any + +import boto3 +import psutil +from tqdm import tqdm + +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, + DBEAlgorithmSuiteId, +) +from aws_cryptographic_material_providers.mpl.references import IKeyring + +from aws_dbesdk_dynamodb.encrypted.item import ItemEncryptor +from aws_dbesdk_dynamodb.encrypted.resource import EncryptedResource +from aws_dbesdk_dynamodb.structures.item_encryptor import DynamoDbItemEncryptorConfig +from aws_dbesdk_dynamodb.structures.dynamodb import ( + DynamoDbTableEncryptionConfig, + DynamoDbTablesEncryptionConfig, +) +from aws_dbesdk_dynamodb.structures.structured_encryption import CryptoAction + +# Legacy V3 imports for comparison +from dynamodb_encryption_sdk.encrypted.item import encrypt_dynamodb_item, decrypt_dynamodb_item +from dynamodb_encryption_sdk.encrypted import CryptoConfig +from dynamodb_encryption_sdk.identifiers import CryptoAction as V3CryptoAction +from dynamodb_encryption_sdk.structures import AttributeActions, EncryptionContext +from dynamodb_encryption_sdk.material_providers.wrapped import WrappedCryptographicMaterialsProvider +from dynamodb_encryption_sdk.delegated_keys.jce import JceNameLocalDelegatedKey +from dynamodb_encryption_sdk.identifiers import EncryptionKeyType, KeyEncodingType + +from .models import Config, TestResult +from .tests import Tests + + +class BenchmarkResult(NamedTuple): + """Result from a single encrypt/decrypt cycle.""" + + put_latency_ms: float + get_latency_ms: float + + +class ESDKBenchmark: + def __init__(self, config_path: str): + self.config = Config.load_config(config_path) + self.cpu_count = psutil.cpu_count(logical=True) + self.total_memory_mb = psutil.virtual_memory().total / (1024 * 1024) + self.table_name = self.config.table_name or "db-esdk-performance-test" + self.keyring = self._setup_keyring() + self.item_encryptor = self._setup_item_encryptor() + print(f"Initialized DB-ESDK Benchmark - CPU cores: {self.cpu_count}, Memory: {self.total_memory_mb / 1024.0:.1f}GB") + + def _setup_keyring(self) -> IKeyring: + encryption_key = secrets.token_bytes(32) # 256-bit AES key for testing + mat_prov = AwsCryptographicMaterialProviders(config=MaterialProvidersConfig()) + keyring_input = CreateRawAesKeyringInput( + key_name="test-aes-256-key", + key_namespace="db-esdk-performance-test", + wrapping_key=encryption_key, + wrapping_alg=AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16, # AES-256-GCM for secure wrapping + ) + return mat_prov.create_raw_aes_keyring(input=keyring_input) + + def _setup_item_encryptor(self) -> ItemEncryptor: + attribute_actions_on_encrypt = { + "partition_key": CryptoAction.SIGN_ONLY, # Keys must be signed for searchability + "sort_key": CryptoAction.SIGN_ONLY, + "attribute1": CryptoAction.ENCRYPT_AND_SIGN, # Sensitive data encrypted and signed + "attribute2": CryptoAction.SIGN_ONLY, # Non-sensitive data signed only + ":attribute3": CryptoAction.DO_NOTHING, # Prefix ':' allows unsigned attributes + } + table_config = DynamoDbItemEncryptorConfig( + logical_table_name=self.table_name, + partition_key_name="partition_key", + sort_key_name="sort_key", + attribute_actions_on_encrypt=attribute_actions_on_encrypt, + keyring=self.keyring, + allowed_unsigned_attribute_prefix=":", # Allow ':' prefixed attributes to be unsigned + algorithm_suite_id=DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_ECDSA_P384_SYMSIG_HMAC_SHA384, # Strong encryption with commitment + ) + return ItemEncryptor(table_config) + + def run_item_encryptor_cycle(self, data: bytes) -> BenchmarkResult: + plaintext_item = { + "partition_key": "benchmark-test", + "sort_key": 0, + "attribute1": {"data": data}, # Test payload data + "attribute2": "sign me!", + ":attribute3": "ignore me!", # Unsigned attribute for testing + } + + encrypt_start = time.perf_counter() + encrypted_item = self.item_encryptor.encrypt_python_item(plaintext_item).encrypted_item + encrypt_time = (time.perf_counter() - encrypt_start) * 1000.0 + + decrypt_start = time.perf_counter() + decrypted_item = self.item_encryptor.decrypt_python_item(encrypted_item).plaintext_item + decrypt_time = (time.perf_counter() - decrypt_start) * 1000.0 + + return BenchmarkResult(put_latency_ms=encrypt_time, get_latency_ms=decrypt_time) + + def _setup_legacy_client(self): + """Setup legacy V3 DynamoDB Encryption Client for comparison.""" + # AES Key Material (32 bytes for AES-256) - same as test constants + aes_256_key_material = bytes([ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, + ]) + + # Create wrapping key using JceNameLocalDelegatedKey + wrapping_key = JceNameLocalDelegatedKey( + key=aes_256_key_material, + algorithm="AES", + key_type=EncryptionKeyType.SYMMETRIC, + key_encoding=KeyEncodingType.RAW, + ) + + # Create signing key (using same key for simplicity in testing) + signing_key = JceNameLocalDelegatedKey( + key=aes_256_key_material, + algorithm="HmacSHA256", + key_type=EncryptionKeyType.SYMMETRIC, + key_encoding=KeyEncodingType.RAW, + ) + + # Create the materials provider + materials_provider = WrappedCryptographicMaterialsProvider( + wrapping_key=wrapping_key, + unwrapping_key=wrapping_key, + signing_key=signing_key + ) + + # Create attribute actions for legacy client + attribute_actions = { + "partition_key": V3CryptoAction.SIGN_ONLY, + "sort_key": V3CryptoAction.SIGN_ONLY, + "attribute1": V3CryptoAction.ENCRYPT_AND_SIGN, + "attribute2": V3CryptoAction.SIGN_ONLY, + ":attribute3": V3CryptoAction.DO_NOTHING, + } + + actions = AttributeActions( + default_action=V3CryptoAction.ENCRYPT_AND_SIGN, + attribute_actions=attribute_actions, + ) + + # Create encryption context + encryption_context = EncryptionContext( + table_name=self.table_name, + partition_key_name="partition_key", + sort_key_name="sort_key", + ) + + # Create crypto config + self.legacy_crypto_config = CryptoConfig( + materials_provider=materials_provider, + encryption_context=encryption_context, + attribute_actions=actions, + ) + + def run_legacy_item_encryptor_cycle(self, data: bytes) -> BenchmarkResult: + """ + Run legacy V3 item encryptor cycle for comparison with V4. + Uses the legacy DynamoDB Encryption Client (V3). + """ + # Ensure legacy client is set up + if not hasattr(self, 'legacy_crypto_config'): + self._setup_legacy_client() + + # Convert data to DynamoDB format + plaintext_item = { + "partition_key": {"S": "benchmark-test"}, + "sort_key": {"N": "0"}, + "attribute1": {"B": data}, # Binary data for test payload + "attribute2": {"S": "sign me!"}, + ":attribute3": {"S": "ignore me!"}, # Unsigned attribute + } + + # Measure encryption latency + encrypt_start = time.perf_counter() + encrypted_item = encrypt_dynamodb_item(plaintext_item, self.legacy_crypto_config) + encrypt_time = (time.perf_counter() - encrypt_start) * 1000.0 + + # Measure decryption latency + decrypt_start = time.perf_counter() + # Make a copy to avoid mutating the original encrypted item + encrypted_item_copy = encrypted_item.copy() + decrypted_item = decrypt_dynamodb_item(encrypted_item_copy, self.legacy_crypto_config) + decrypt_time = (time.perf_counter() - decrypt_start) * 1000.0 + + return BenchmarkResult(put_latency_ms=encrypt_time, get_latency_ms=decrypt_time) + + + # def run_batch_read_write_cycle(self, item_size_kb: int = 200, batch_size: int = 6) -> BenchmarkResult: + # """ + # Run batch read/write cycle with specified item size and batch size. + # Creates items with same partition key and incremental sort keys. + # + # Args: + # item_size_kb: Size of each item in KB (default: 200KB) + # batch_size: Number of items in batch (default: 25) + # + # Returns: + # BenchmarkResult with batch put and get latencies + # """ + # # Create EncryptedResource for batch operations + # encrypted_resource = self._setup_encrypted_resource() + # + # # Generate test data for the specified item size + # item_data = secrets.token_bytes(item_size_kb * 1024) # Convert KB to bytes + # partition_key = "batch-benchmark-test" + # + # # Create batch of items with same partition key and incremental sort keys + # items = [] + # for i in range(batch_size): + # item = { + # "partition_key": partition_key, + # "sort_key": i, + # "attribute1": {"data": item_data}, # Large test payload + # "attribute2": f"batch_item_{i}", + # ":attribute3": f"unsigned_data_{i}", + # } + # items.append(item) + # + # # Prepare batch write request + # batch_write_request = { + # "RequestItems": { + # self.table_name: [{"PutRequest": {"Item": item}} for item in items], + # }, + # } + # + # # Measure batch write latency + # batch_write_start = time.perf_counter() + # batch_write_response = encrypted_resource.batch_write_item(**batch_write_request) + # batch_write_time = (time.perf_counter() - batch_write_start) * 1000.0 + # + # # Verify batch write succeeded + # if batch_write_response["ResponseMetadata"]["HTTPStatusCode"] != 200: + # raise RuntimeError(f"Batch write failed with status: {batch_write_response['ResponseMetadata']['HTTPStatusCode']}") + # + # # Prepare batch get request + # batch_get_request = { + # "RequestItems": { + # self.table_name: { + # "Keys": [{"partition_key": partition_key, "sort_key": i} for i in range(batch_size)], + # } + # }, + # } + # + # # Measure batch get latency + # batch_get_start = time.perf_counter() + # batch_get_response = encrypted_resource.batch_get_item(**batch_get_request) + # batch_get_time = (time.perf_counter() - batch_get_start) * 1000.0 + # + # # Verify batch get succeeded and returned expected items + # if batch_get_response["ResponseMetadata"]["HTTPStatusCode"] != 200: + # raise RuntimeError(f"Batch get failed with status: {batch_get_response['ResponseMetadata']['HTTPStatusCode']}") + # + # retrieved_items = batch_get_response["Responses"][self.table_name] + # if len(retrieved_items) != batch_size: + # raise RuntimeError(f"Expected {batch_size} items, got {len(retrieved_items)}") + # + # # Clean up: Delete the batch items + # batch_delete_request = { + # "RequestItems": { + # self.table_name: [ + # {"DeleteRequest": {"Key": {"partition_key": partition_key, "sort_key": i}}} + # for i in range(batch_size) + # ], + # }, + # } + # + # try: + # encrypted_resource.batch_write_item(**batch_delete_request) + # except Exception as e: + # print(f"Warning: Failed to clean up batch items: {e}") + # + # return BenchmarkResult(put_latency_ms=batch_write_time, get_latency_ms=batch_get_time) + # + # def _setup_encrypted_resource(self) -> EncryptedResource: + # """Setup EncryptedResource for batch operations.""" + # attribute_actions_on_encrypt = { + # "partition_key": CryptoAction.SIGN_ONLY, + # "sort_key": CryptoAction.SIGN_ONLY, + # "attribute1": CryptoAction.ENCRYPT_AND_SIGN, + # "attribute2": CryptoAction.SIGN_ONLY, + # ":attribute3": CryptoAction.DO_NOTHING, + # } + # + # table_config = DynamoDbTableEncryptionConfig( + # logical_table_name=self.table_name, + # partition_key_name="partition_key", + # sort_key_name="sort_key", + # attribute_actions_on_encrypt=attribute_actions_on_encrypt, + # keyring=self.keyring, + # allowed_unsigned_attribute_prefix=":", + # algorithm_suite_id=DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_ECDSA_P384_SYMSIG_HMAC_SHA384, + # ) + # + # table_configs = {self.table_name: table_config} + # tables_config = DynamoDbTablesEncryptionConfig(table_encryption_configs=table_configs) + # + # return EncryptedResource( + # resource=boto3.resource("dynamodb"), + # encryption_config=tables_config, + # ) + + def run_all_benchmarks(self) -> List[TestResult]: + print("Starting comprehensive ESDK benchmark suite") + all_results = [] + + # Collect all data sizes from config + data_sizes = [] + for size_list in [self.config.data_sizes.small, self.config.data_sizes.medium, self.config.data_sizes.large]: + if size_list: + data_sizes.extend(size_list) + + concurrent_levels = [c for c in self.config.concurrency_levels if c > 1] # Skip single-threaded for concurrent tests + total_tests = len(data_sizes) * (2 + len(concurrent_levels)) # throughput + memory + concurrent tests + print(f"Running {total_tests} total tests") + + with tqdm(total=total_tests, desc="Running benchmarks") as pbar: + for data_size in data_sizes: + # Throughput test + try: + result = Tests.run_throughput_test(self, data_size, self.config.iterations.measurement) + if result: + all_results.append(result) + print(f"Throughput test completed: {result.ops_per_second:.2f} ops/sec") + except Exception as e: + print(f"Throughput test failed for data size {data_size} bytes: {e}") + pbar.update(1) + + # Memory test + try: + result = Tests.run_memory_test(self, data_size) + all_results.append(result) + print(f"Memory test completed: {result.peak_memory_mb:.2f} MB peak") + except Exception as e: + print(f"Memory test failed for data size {data_size} bytes: {e}") + pbar.update(1) + + # Concurrent tests + for concurrency in concurrent_levels: + try: + result = Tests.run_concurrent_test(self, data_size, concurrency, 5) + all_results.append(result) + print(f"Concurrent test completed: {result.ops_per_second:.2f} ops/sec @ {concurrency} threads") + except Exception as e: + print(f"Concurrent test failed for data size {data_size} bytes with {concurrency} threads: {e}") + pbar.update(1) + + print(f"Benchmark suite completed. Total results: {len(all_results)}") + return all_results + + def get_system_info(self) -> Dict[str, Any]: + return { + "cpu_count": self.cpu_count, + "total_memory_mb": self.total_memory_mb, + "platform": psutil.platform, + "python_version": f"{psutil.sys.version_info.major}.{psutil.sys.version_info.minor}.{psutil.sys.version_info.micro}", + } \ No newline at end of file diff --git a/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/models.py b/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/models.py new file mode 100644 index 000000000..cbf691d8b --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/models.py @@ -0,0 +1,299 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 + +import json +import platform +import sys +from dataclasses import dataclass, field +from datetime import datetime +from pathlib import Path +from typing import Dict, List, Optional +from statistics import mean + +import psutil +import yaml + + +@dataclass +class DataSizes: + small: Optional[List[int]] = None # Small data sizes (e.g., 1KB-10KB) + medium: Optional[List[int]] = None # Medium data sizes (e.g., 100KB-1MB) + large: Optional[List[int]] = None # Large data sizes (e.g., 10MB+) + + +@dataclass +class Iterations: + warmup: int = 5 # Warmup iterations to stabilize performance + measurement: int = 10 # Measurement iterations for averaging + + +@dataclass +class QuickConfig: + data_sizes: DataSizes = field(default_factory=DataSizes) + iterations: Iterations = field(default_factory=Iterations) + concurrency_levels: List[int] = field(default_factory=lambda: [1, 2]) # Reduced concurrency for quick tests + test_types: List[str] = field(default_factory=lambda: ["throughput", "memory", "concurrency"]) + + +@dataclass +class Config: + data_sizes: DataSizes = field(default_factory=DataSizes) + iterations: Iterations = field(default_factory=Iterations) + concurrency_levels: List[int] = field(default_factory=lambda: [1, 2, 4, 8]) # Thread counts for concurrent testing + table_name: str = "DynamoDbEncryptionInterceptorTestTable" # DynamoDB table name for testing + keyring: str = "raw-aes" # Keyring type (raw-aes for testing) + quick_config: Optional[QuickConfig] = None # Optional quick test configuration + + @classmethod + def load_config(cls, config_path: str) -> "Config": + """Load configuration from YAML file.""" + config_file = Path(config_path) + if not config_file.exists(): + raise FileNotFoundError(f"Configuration file not found: {config_path}") + + with open(config_file, "r") as f: + data = yaml.safe_load(f) + + # Parse data sizes + data_sizes_data = data.get("data_sizes", {}) + data_sizes = DataSizes( + small=data_sizes_data.get("small"), + medium=data_sizes_data.get("medium"), + large=data_sizes_data.get("large"), + ) + + # Parse iterations + iterations_data = data.get("iterations", {}) + iterations = Iterations( + warmup=iterations_data.get("warmup", 5), + measurement=iterations_data.get("measurement", 10), + ) + + # Parse quick config if present + quick_config = None + if "quick_config" in data: + quick_data = data["quick_config"] + quick_data_sizes_data = quick_data.get("data_sizes", {}) + quick_data_sizes = DataSizes( + small=quick_data_sizes_data.get("small"), + medium=quick_data_sizes_data.get("medium"), + large=quick_data_sizes_data.get("large"), + ) + quick_iterations_data = quick_data.get("iterations", {}) + quick_iterations = Iterations( + warmup=quick_iterations_data.get("warmup", 3), + measurement=quick_iterations_data.get("measurement", 3), + ) + quick_config = QuickConfig( + data_sizes=quick_data_sizes, + iterations=quick_iterations, + concurrency_levels=quick_data.get("concurrency_levels", [1, 2]), + test_types=quick_data.get( + "test_types", ["throughput", "memory", "concurrency"] + ), + ) + + return cls( + data_sizes=data_sizes, + iterations=iterations, + concurrency_levels=data.get("concurrency_levels", [1, 2, 4, 8]), + table_name=data.get("table_name", "dbesdk-performance-testing"), + keyring=data.get("keyring", "raw-aes"), + quick_config=quick_config, + ) + + def adjust_for_quick_test(self): + """Apply quick test configuration to reduce test time.""" + if self.quick_config: + self.data_sizes = self.quick_config.data_sizes + self.iterations = self.quick_config.iterations + self.concurrency_levels = self.quick_config.concurrency_levels + + +@dataclass +class BenchmarkMetadata: + language: str = "python" + timestamp: str = field(default_factory=lambda: datetime.utcnow().isoformat() + "Z") # ISO timestamp for results + python_version: str = field(default_factory=lambda: f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}") + platform: str = field(default_factory=platform.platform) # OS platform info + cpu_count: int = field(default_factory=lambda: psutil.cpu_count(logical=True)) # Logical CPU count + total_memory_gb: float = field(default_factory=lambda: psutil.virtual_memory().total / (1024**3)) # Total system memory in GB + total_tests: int = 0 # Number of tests executed + + +@dataclass +class TestResult: + test_name: str + language: str = "python" + data_size: int = 0 # Size of test data in bytes + concurrency: int = 1 # Number of concurrent threads + put_latency_ms: float = 0.0 # Encryption latency in milliseconds + get_latency_ms: float = 0.0 # Decryption latency in milliseconds + end_to_end_latency_ms: float = 0.0 # Total operation latency + ops_per_second: float = 0.0 # Operations per second throughput + bytes_per_second: float = 0.0 # Bytes per second throughput + peak_memory_mb: float = 0.0 # Peak memory usage in MB + memory_efficiency_ratio: float = 0.0 # Data size to memory usage ratio + p50_latency: float = 0.0 # 50th percentile latency + p95_latency: float = 0.0 # 95th percentile latency + p99_latency: float = 0.0 # 99th percentile latency + timestamp: str = field(default_factory=lambda: datetime.utcnow().isoformat() + "Z") + python_version: str = field(default_factory=lambda: f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}") + cpu_count: int = field(default_factory=lambda: psutil.cpu_count(logical=True)) + total_memory_gb: float = field(default_factory=lambda: psutil.virtual_memory().total / (1024**3)) + + @classmethod + def create_throughput_result( + cls, + encrypt_latencies: List[float], + decrypt_latencies: List[float], + total_latencies: List[float], + data_size: int, + cpu_count: int, + total_memory_mb: float, + ) -> "TestResult": + if not total_latencies: + raise ValueError("No latency data provided for throughput result") + + # Calculate latency percentiles for performance analysis + sorted_latencies = sorted(total_latencies) + p50 = sorted_latencies[int(len(sorted_latencies) * 0.5)] + p95 = sorted_latencies[int(len(sorted_latencies) * 0.95)] + p99 = sorted_latencies[int(len(sorted_latencies) * 0.99)] + + # Calculate average latencies + avg_encrypt = mean(encrypt_latencies) if encrypt_latencies else 0.0 + avg_decrypt = mean(decrypt_latencies) if decrypt_latencies else 0.0 + avg_total = mean(total_latencies) + + # Calculate throughput metrics + ops_per_second = 1000.0 / avg_total if avg_total > 0 else 0.0 # Convert ms to ops/sec + bytes_per_second = ops_per_second * data_size + + return cls( + test_name="throughput", + data_size=data_size, + put_latency_ms=avg_encrypt, + get_latency_ms=avg_decrypt, + end_to_end_latency_ms=avg_total, + ops_per_second=ops_per_second, + bytes_per_second=bytes_per_second, + p50_latency=p50, + p95_latency=p95, + p99_latency=p99, + cpu_count=cpu_count, + total_memory_gb=total_memory_mb / 1024.0, + ) + + @classmethod + def create_memory_result( + cls, + peak_memory_mb: float, + avg_memory_mb: float, + data_size: int, + cpu_count: int, + total_memory_mb: float, + ) -> "TestResult": + # Calculate memory efficiency as data size to memory usage ratio + memory_efficiency = (data_size / (1024 * 1024) / peak_memory_mb if peak_memory_mb > 0 else 0.0) + + return cls( + test_name="memory", + data_size=data_size, + peak_memory_mb=peak_memory_mb, + memory_efficiency_ratio=memory_efficiency, + cpu_count=cpu_count, + total_memory_gb=total_memory_mb / 1024.0, + ) + + @classmethod + def create_concurrent_result( + cls, + all_times: List[float], + total_operations: int, + data_size: int, + concurrency: int, + cpu_count: int, + total_memory_mb: float, + ) -> "TestResult": + if not all_times: + raise ValueError("No timing data provided for concurrent result") + + # Calculate concurrent performance metrics + avg_latency = mean(all_times) + sorted_times = sorted(all_times) + p50 = sorted_times[int(len(sorted_times) * 0.5)] + p95 = sorted_times[int(len(sorted_times) * 0.95)] + p99 = sorted_times[int(len(sorted_times) * 0.99)] + + # Calculate concurrent throughput + ops_per_second = 1000.0 / avg_latency if avg_latency > 0 else 0.0 + bytes_per_second = ops_per_second * data_size + + return cls( + test_name="concurrency", + data_size=data_size, + concurrency=concurrency, + end_to_end_latency_ms=avg_latency, + ops_per_second=ops_per_second, + bytes_per_second=bytes_per_second, + p50_latency=p50, + p95_latency=p95, + p99_latency=p99, + cpu_count=cpu_count, + total_memory_gb=total_memory_mb / 1024.0, + ) + + def to_dict(self) -> Dict: + return { + "test_name": self.test_name, + "language": self.language, + "data_size": self.data_size, + "concurrency": self.concurrency, + "put_latency_ms": self.put_latency_ms, + "get_latency_ms": self.get_latency_ms, + "end_to_end_latency_ms": self.end_to_end_latency_ms, + "ops_per_second": self.ops_per_second, + "bytes_per_second": self.bytes_per_second, + "peak_memory_mb": self.peak_memory_mb, + "memory_efficiency_ratio": self.memory_efficiency_ratio, + "p50_latency": self.p50_latency, + "p95_latency": self.p95_latency, + "p99_latency": self.p99_latency, + "timestamp": self.timestamp, + "python_version": self.python_version, + "cpu_count": self.cpu_count, + "total_memory_gb": self.total_memory_gb, + } + + +class Report: + @staticmethod + def save_results(results: List[TestResult], output_path: str, cpu_count: int, total_memory_mb: float): + """Save benchmark results to JSON file with metadata.""" + metadata = BenchmarkMetadata( + cpu_count=cpu_count, + total_memory_gb=total_memory_mb / 1024.0, + total_tests=len(results), + ) + + report_data = { + "metadata": { + "language": metadata.language, + "timestamp": metadata.timestamp, + "python_version": metadata.python_version, + "platform": metadata.platform, + "cpu_count": metadata.cpu_count, + "total_memory_gb": metadata.total_memory_gb, + "total_tests": metadata.total_tests, + }, + "results": [result.to_dict() for result in results], + } + + output_file = Path(output_path) + output_file.parent.mkdir(parents=True, exist_ok=True) # Create output directory if needed + + with open(output_file, "w") as f: + json.dump(report_data, f, indent=2) + + print(f"Results saved to: {output_path}") diff --git a/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/program.py b/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/program.py new file mode 100644 index 000000000..f849db859 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/program.py @@ -0,0 +1,137 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 + +import argparse +import sys +from pathlib import Path +from statistics import mean +from typing import List, Optional + +from .benchmark import ESDKBenchmark +from .models import Report, TestResult + + +class CommandLineOptions: + def __init__(self): + self.config_path = "../../../config/test-scenarios.yaml" # Default config file path + self.output_path = "../../../results/raw-data/python_results.json" # Default output path + self.quick_test = False # Quick test mode flag + + +def parse_args(args: List[str]) -> Optional[CommandLineOptions]: + parser = argparse.ArgumentParser( + description="ESDK Python Performance Benchmark", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + python -m esdk_benchmark.program # Run full benchmark suite + python -m esdk_benchmark.program --quick # Run quick test + python -m esdk_benchmark.program -c config.yaml # Use custom config + python -m esdk_benchmark.program -o results.json # Custom output file + """, + ) + + parser.add_argument( + "--config", "-c", + default="../../../config/test-scenarios.yaml", + help="Path to test configuration file", # Configuration file for test parameters + ) + + parser.add_argument( + "--output", "-o", + default="../../../results/raw-data/python_results.json", + help="Path to output results file", # JSON output file for results + ) + + parser.add_argument( + "--quick", "-q", + action="store_true", + help="Run quick test with reduced iterations", # Enable quick test mode + ) + + try: + parsed_args = parser.parse_args(args) + options = CommandLineOptions() + options.config_path = parsed_args.config + options.output_path = parsed_args.output + options.quick_test = parsed_args.quick + return options + except SystemExit: + return None + + +def print_summary(results: List[TestResult], output_path: str): + print("\n=== ESDK Python Benchmark Summary ===") + print(f"Total tests completed: {len(results)}") + print(f"Results saved to: {output_path}") + + if not results: + return + + # Throughput summary + throughput_results = [r for r in results if r.test_name == "throughput"] + if throughput_results: + avg_ops = mean(r.ops_per_second for r in throughput_results) + max_ops = max(r.ops_per_second for r in throughput_results) + print(f"Throughput - Avg: {avg_ops:.2f} ops/sec, Max: {max_ops:.2f} ops/sec") + + # Memory summary + memory_results = [r for r in results if r.test_name == "memory"] + if memory_results: + avg_memory = mean(r.peak_memory_mb for r in memory_results) + max_memory = max(r.peak_memory_mb for r in memory_results) + print(f"Memory - Avg: {avg_memory:.2f} MB, Max: {max_memory:.2f} MB") + + # Concurrency summary + concurrent_results = [r for r in results if r.test_name == "concurrency"] + if concurrent_results: + avg_concurrent_ops = mean(r.ops_per_second for r in concurrent_results) + max_concurrent_ops = max(r.ops_per_second for r in concurrent_results) + print(f"Concurrency - Avg: {avg_concurrent_ops:.2f} ops/sec, Max: {max_concurrent_ops:.2f} ops/sec") + + +def main(args: Optional[List[str]] = None) -> int: + if args is None: + args = sys.argv[1:] + + options = parse_args(args) + if options is None: + return 1 + + try: + # Resolve relative paths to absolute paths + config_path = options.config_path + if not Path(config_path).is_absolute(): + current_dir = Path(__file__).parent + config_path = str(current_dir / config_path) + + benchmark = ESDKBenchmark(config_path) + + if options.quick_test: + benchmark.config.adjust_for_quick_test() # Apply quick test settings + + results = benchmark.run_all_benchmarks() + + # Resolve output path + output_path = options.output_path + if not Path(output_path).is_absolute(): + current_dir = Path(__file__).parent + output_path = str(current_dir / output_path) + + Report.save_results(results, output_path, benchmark.cpu_count, benchmark.total_memory_mb) + print_summary(results, output_path) + + return 0 + + except FileNotFoundError as e: + print(f"Configuration file not found: {e}") + return 1 + except Exception as e: + print(f"Benchmark failed: {e}") + import traceback + traceback.print_exc() + return 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/tests.py b/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/tests.py new file mode 100644 index 000000000..f25482241 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/esdk_benchmark/tests.py @@ -0,0 +1,382 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 + +""" +ESDK Benchmark Test Suite + +This module contains the core test implementations for benchmarking the AWS Database Encryption SDK. +It provides three main test types: +1. Throughput Test - Measures operations per second for encrypt/decrypt cycles +2. Memory Test - Tracks peak memory usage during operations using tracemalloc +3. Concurrent Test - Evaluates performance under multithreaded load + +Each test is designed to provide accurate, repeatable measurements of ESDK performance +characteristics under different conditions. +""" + +import gc +import secrets +import time +import tracemalloc +from concurrent.futures import ThreadPoolExecutor, as_completed +from statistics import mean +from typing import List, NamedTuple, Optional, TYPE_CHECKING + +from tqdm import tqdm + +if TYPE_CHECKING: + from .benchmark import ESDKBenchmark + +from .models import TestResult + + +class MeasurementResults(NamedTuple): + """ + Container for latency measurements from throughput testing. + + Attributes: + encrypt_latencies: List of encryption operation times in milliseconds + decrypt_latencies: List of decryption operation times in milliseconds + total_latencies: List of complete encrypt/decrypt cycle times in milliseconds + """ + encrypt_latencies: List[float] + decrypt_latencies: List[float] + total_latencies: List[float] + + +class MemoryResults(NamedTuple): + """ + Container for memory usage measurements. + + Attributes: + peak_memory_mb: Maximum memory usage observed across all iterations (MB) + avg_memory_mb: Average memory usage across all iterations (MB) + """ + peak_memory_mb: float + avg_memory_mb: float + +# Since tracemalloc gives the peak heap allocated, we donot need to collect memory samples +# class MemorySample(NamedTuple): +# """ +# Single point-in-time memory measurement. +# +# Attributes: +# heap_mb: Heap memory usage in megabytes +# timestamp: Time when sample was taken (seconds since epoch) +# """ +# heap_mb: float +# timestamp: float + + +class IterationResult(NamedTuple): + """ + Memory measurement result from a single test iteration. + + Attributes: + peak_memory: Peak memory usage during this iteration (MB) + avg_memory: Average memory usage during this iteration (MB) + """ + peak_memory: float + avg_memory: float + + +class Tests: + MEMORY_TEST_ITERATIONS = 5 # Number of memory test iterations for averaging + SAMPLING_INTERVAL_MS = 1 # Memory sampling interval in milliseconds + GC_SETTLE_TIME_MS = 5 # Time to wait for GC to settle before measurement + FINAL_SAMPLE_WAIT_MS = 2 # Wait time for final sample collection + + @staticmethod + def run_throughput_test(benchmark: "ESDKBenchmark", data_size: int, iterations: int) -> Optional[TestResult]: + """ + Execute throughput benchmark measuring encrypt/decrypt operations per second. + + This test performs warmup iterations followed by measured iterations to determine + the sustained throughput of ESDK operations. It measures individual encrypt and + decrypt latencies as well as total cycle time. + + Args: + benchmark: The ESDK benchmark instance to test + data_size: Size of test data in bytes + iterations: Number of measurement iterations to perform + + Returns: + TestResult containing throughput metrics, or None if all iterations failed + """ + print(f"\n--- Throughput Test ---") + print(f"Data size: {data_size:,} bytes | Iterations: {iterations}") + + # Generate random test data + data = secrets.token_bytes(data_size) + + warmup_iterations = benchmark.config.iterations.warmup + print(f"Warming up with {warmup_iterations} iterations...") + Tests._run_measurement_iterations(benchmark, data, warmup_iterations) + + # Measurement + print(f"Measuring performance over {iterations} iterations...") + results = Tests._run_measurement_iterations(benchmark, data, iterations) + + if not results.total_latencies: + print("ERROR: All test iterations failed") + return None + + # Calculate and display basic statistics + avg_total_ms = mean(results.total_latencies) + ops_per_sec = 1000.0 / avg_total_ms if avg_total_ms > 0 else 0 + print(f"Throughput test completed: {ops_per_sec:.2f} ops/sec") + + return TestResult.create_throughput_result( + results.encrypt_latencies, + results.decrypt_latencies, + results.total_latencies, + data_size, + benchmark.cpu_count, + benchmark.total_memory_mb, + ) + + @staticmethod + def _run_measurement_iterations(benchmark: "ESDKBenchmark", data: bytes, iterations: int) -> MeasurementResults: + encrypt_latencies, decrypt_latencies, total_latencies = [], [], [] + + for i in range(iterations): + try: + iteration_start = time.perf_counter() + result = benchmark.run_item_encryptor_cycle(data) + total_ms = (time.perf_counter() - iteration_start) * 1000.0 + + encrypt_latencies.append(result.put_latency_ms) + decrypt_latencies.append(result.get_latency_ms) + total_latencies.append(total_ms) + except Exception as e: + print(f"Iteration {i} failed: {e}") + + return MeasurementResults(encrypt_latencies, decrypt_latencies, total_latencies) + + @staticmethod + def run_memory_test(benchmark: "ESDKBenchmark", data_size: int) -> TestResult: + """ + Execute memory usage benchmark using tracemalloc for precise memory tracking. + + This test measures peak memory consumption during ESDK encrypt/decrypt operations. + It uses Python's tracemalloc module to track memory allocations with high precision, + running multiple iterations to ensure consistent measurements. + + The test methodology: + 1. Force garbage collection to establish clean baseline + 2. Start tracemalloc to monitor memory allocations + 3. Execute encrypt/decrypt cycle + 4. Measure peak memory delta from baseline + 5. Repeat across multiple iterations for statistical accuracy + + Args: + benchmark: The ESDK benchmark instance to test + data_size: Size of test data in bytes + + Returns: + TestResult containing memory usage metrics + + Raises: + RuntimeError: If memory sampling fails completely + """ + print(f"\n--- Memory Test ---") + print(f"Data size: {data_size:,} bytes | Iterations: {Tests.MEMORY_TEST_ITERATIONS}") + print("Using tracemalloc for precise memory tracking") + + # Generate test data + data = secrets.token_bytes(data_size) + + # Execute memory sampling across multiple iterations + memory_results = Tests._sample_memory_during_operations(benchmark, data) + + if memory_results is None: + raise RuntimeError(f"Memory test failed: Unable to collect memory samples for data size {data_size:,} bytes") + + print(f"Memory test completed: {memory_results.peak_memory_mb:.2f} MB peak") + + return TestResult.create_memory_result( + memory_results.peak_memory_mb, + memory_results.avg_memory_mb, + data_size, + benchmark.cpu_count, + benchmark.total_memory_mb, + ) + + @staticmethod + def _sample_memory_during_operations(benchmark: "ESDKBenchmark", data: bytes) -> Optional[MemoryResults]: + peak_memory_delta = 0.0 + peak_allocations = 0.0 + avg_memory_values = [] + + for i in range(Tests.MEMORY_TEST_ITERATIONS): + iteration_result = Tests._run_single_memory_iteration(benchmark, data, i + 1) + + if iteration_result.peak_memory > peak_memory_delta: + peak_memory_delta = iteration_result.peak_memory + + avg_memory_values.append(iteration_result.avg_memory) + + overall_avg_memory = mean(avg_memory_values) if avg_memory_values else 0.0 + + print(f"\nMemory Summary:") + print(f"- Absolute Peak Heap: {peak_memory_delta:.2f} MB (across all runs)") + print(f"- Average Heap: {overall_avg_memory:.2f} MB (across all runs)") + print(f"- Total Allocations: {peak_allocations:.2f} MB (max across all runs)") + + return MemoryResults(peak_memory_delta, overall_avg_memory) + + @staticmethod + def _run_single_memory_iteration(benchmark: "ESDKBenchmark", data: bytes, iteration: int) -> IterationResult: + # Force GC and settle + gc.collect() + gc.collect() + time.sleep(Tests.GC_SETTLE_TIME_MS / 1000.0) + + # Start tracemalloc for peak memory tracking + tracemalloc.start() + baseline_current, baseline_peak = tracemalloc.get_traced_memory() + + operation_start = time.perf_counter() + + # Run the actual operation + try: + benchmark.run_item_encryptor_cycle(data) + except Exception as e: + print(f"Memory test iteration {iteration} failed: {e}") + tracemalloc.stop() + return IterationResult(0.0, 0.0) + + operation_duration_ms = (time.perf_counter() - operation_start) * 1000.0 + + # Get final memory measurements from tracemalloc + final_current, final_peak = tracemalloc.get_traced_memory() + tracemalloc.stop() + + # Calculate memory deltas in MB + net_peak_mb = max(0, (final_peak - baseline_peak) / (1024 * 1024)) + net_current_mb = max(0, (final_current - baseline_current) / (1024 * 1024)) + + print(f"=== Iteration {iteration} === Peak Heap: {net_peak_mb:.2f} MB " + f"({operation_duration_ms:.0f}ms)") + + return IterationResult(net_peak_mb, net_current_mb) + + + + @staticmethod + def run_concurrent_test(benchmark: "ESDKBenchmark", data_size: int, concurrency: int, iterations_per_thread: int) -> TestResult: + """ + Execute concurrent benchmark testing multi-threaded ESDK performance. + + This test evaluates how well ESDK operations scale under concurrent load by + running multiple threads simultaneously, each performing encrypt/decrypt cycles. + It measures the aggregate throughput and individual operation latencies. + + The test methodology: + 1. Create a thread pool with specified concurrency level + 2. Each thread performs the specified number of iterations + 3. All operations run concurrently with shared progress tracking + 4. Collect timing data from all threads for analysis + + Args: + benchmark: The ESDK benchmark instance to test + data_size: Size of test data in bytes + concurrency: Number of concurrent threads to run + iterations_per_thread: Number of operations each thread performs + + Returns: + TestResult containing concurrent performance metrics + + Raises: + ValueError: If concurrency or iterations_per_thread are not positive + RuntimeError: If no operations complete successfully + """ + print(f"\n--- Concurrent Test ---") + print(f"Data size: {data_size:,} bytes | Threads: {concurrency} | Iterations per thread: {iterations_per_thread}") + + # Validate input parameters + if concurrency <= 0 or iterations_per_thread <= 0: + raise ValueError(f"Concurrency and iterations must be positive, got: {concurrency}, {iterations_per_thread}") + + # Generate test data and initialize result collection + data = secrets.token_bytes(data_size) + all_times = [] + expected_operations = concurrency * iterations_per_thread + + print(f"Starting {expected_operations} total operations across {concurrency} threads...") + + # Execute concurrent operations with thread pool + with ThreadPoolExecutor(max_workers=concurrency) as executor: + with tqdm(total=expected_operations, desc="Progress", unit="ops", + bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]") as pbar: + + # Submit all thread tasks + futures = [ + executor.submit(Tests._run_concurrent_thread, benchmark, data, iterations_per_thread, thread_id, pbar) + for thread_id in range(concurrency) + ] + + # Collect results as threads complete + for future in as_completed(futures): + try: + thread_times = future.result() + all_times.extend(thread_times) + except Exception as e: + print(f"\nERROR: Concurrent thread failed: {e}") + + # Validate results + if not all_times: + raise RuntimeError(f"Concurrent test failed: No operations completed successfully. " + f"Concurrency: {concurrency}, Expected operations: {expected_operations}") + + # Calculate and display summary statistics + completed_ops = len(all_times) + avg_latency_ms = mean(all_times) + aggregate_ops_per_sec = completed_ops / (sum(all_times) / 1000.0) if all_times else 0 + + print(f"Concurrent test completed: {aggregate_ops_per_sec:.2f} ops/sec @ {concurrency} threads") + + return TestResult.create_concurrent_result( + all_times, + completed_ops, + data_size, + concurrency, + benchmark.cpu_count, + benchmark.total_memory_mb, + ) + + @staticmethod + def _run_concurrent_thread(benchmark: "ESDKBenchmark", data: bytes, iterations: int, thread_id: int, pbar: tqdm) -> List[float]: + """ + Execute encrypt/decrypt operations in a single thread for concurrent testing. + + This method runs in a separate thread as part of the concurrent test. Each thread + performs the specified number of iterations independently, measuring the latency + of each operation and updating the shared progress bar. + + Args: + benchmark: The ESDK benchmark instance to test + data: Test data bytes to encrypt/decrypt + iterations: Number of operations this thread should perform + thread_id: Unique identifier for this thread (for error reporting) + pbar: Shared progress bar for tracking overall test progress + + Returns: + List of operation latencies in milliseconds for this thread + """ + thread_times = [] + + for j in range(iterations): + try: + # Measure single encrypt/decrypt cycle + thread_start_time = time.perf_counter() + benchmark.run_item_encryptor_cycle(data) + elapsed = (time.perf_counter() - thread_start_time) * 1000.0 + + # Record timing and update progress + thread_times.append(elapsed) + pbar.update(1) + except Exception as e: + print(f"\nERROR: Concurrent test iteration failed in thread {thread_id}: {e}") + + return thread_times diff --git a/db-esdk-performance-testing/benchmarks/python/src/providers/__init__.py b/db-esdk-performance-testing/benchmarks/python/src/providers/__init__.py new file mode 100644 index 000000000..60b89b191 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/providers/__init__.py @@ -0,0 +1 @@ +# Provider classes separated from test bases diff --git a/db-esdk-performance-testing/benchmarks/python/src/providers/v3_providers.py b/db-esdk-performance-testing/benchmarks/python/src/providers/v3_providers.py new file mode 100644 index 000000000..c547d0a5e --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/providers/v3_providers.py @@ -0,0 +1,108 @@ +"""V3 Provider implementations for performance testing.""" + +import sys +from pathlib import Path +from abc import ABC, abstractmethod + +# Add parent directory to path for imports +sys.path.insert(0, str(Path(__file__).parent.parent)) + +import boto3 +from dynamodb_encryption_sdk.material_providers.aws_kms import AwsKmsCryptographicMaterialsProvider +from dynamodb_encryption_sdk.material_providers.most_recent import CachingMostRecentProvider +from dynamodb_encryption_sdk.delegated_keys.jce import JceNameLocalDelegatedKey +from dynamodb_encryption_sdk.identifiers import EncryptionKeyType, KeyEncodingType +from dynamodb_encryption_sdk.material_providers.wrapped import WrappedCryptographicMaterialsProvider +from dynamodb_encryption_sdk.material_providers.aws_kms import AwsKmsCryptographicMaterialsProvider +from dynamodb_encryption_sdk.material_providers.most_recent import CachingMostRecentProvider +from dynamodb_encryption_sdk.material_providers.store.meta import MetaStore + +from ..test_constants import AES_256_KEY_MATERIAL, KMS_KEY_ARN, ENCRYPTION_CONTEXT + + +class V3ProviderBase(ABC): + """Base class for V3 provider implementations.""" + + @abstractmethod + def get_materials_provider(self): + """Get the cryptographic materials provider.""" + pass + + def get_provider_name(self) -> str: + """Get the provider name.""" + return self.__class__.__name__ + + +class V3AESProvider(V3ProviderBase): + """V3 AES Key Provider using static key material.""" + + def __init__(self): + """Initialize the AES provider.""" + # Create a static master key using our AES key material + # Create wrapping key using JceNameLocalDelegatedKey as shown in example + wrapping_key = JceNameLocalDelegatedKey( + key=AES_256_KEY_MATERIAL, + algorithm="AES", + key_type=EncryptionKeyType.SYMMETRIC, + key_encoding=KeyEncodingType.RAW, + ) + + # For performance testing, we'll use the same key for signing + # In production, you would use a separate HMAC key + signing_key = JceNameLocalDelegatedKey( + key=AES_256_KEY_MATERIAL, + algorithm="HmacSHA256", + key_type=EncryptionKeyType.SYMMETRIC, + key_encoding=KeyEncodingType.RAW, + ) + + # Create the materials provider + self.materials_provider = WrappedCryptographicMaterialsProvider( + wrapping_key=wrapping_key, unwrapping_key=wrapping_key, signing_key=signing_key + ) + + def get_materials_provider(self): + """Get the cryptographic materials provider.""" + return self.materials_provider + + +class V3KMSProvider(V3ProviderBase): + """V3 AWS KMS Key Provider.""" + + def __init__(self): + """Initialize the KMS provider.""" + self.materials_provider = AwsKmsCryptographicMaterialsProvider( + key_id=KMS_KEY_ARN + ) + + def get_materials_provider(self): + """Get the cryptographic materials provider.""" + return self.materials_provider + + +class V3HierarchyProvider(V3ProviderBase): + """V3 Most Recent Key Provider (equivalent to hierarchy).""" + + def __init__(self): + """Initialize the hierarchy provider.""" + # Create a real table resource for the meta store + # For performance testing, we'll use a simplified approach without actual DDB operations + meta_table = boto3.resource("dynamodb", region_name="us-west-2").Table("v2MostRecentKeyProviderPerfTestKeys") + + # Create a crypto materials provider for the meta store using AWS KMS + # As shown in most_recent_provider_encrypted_table.py example + aws_kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=KMS_KEY_ARN) + + # Create a meta store using the AWS KMS crypto materials provider + meta_store = MetaStore(table=meta_table, materials_provider=aws_kms_cmp) + + # Wrap with MostRecentProvider for hierarchy-like behavior + self.materials_provider = CachingMostRecentProvider( + provider_store=meta_store, + material_name="test_material", + version_ttl=600.0, # Check for a new material version every 10 minutes + ) + + def get_materials_provider(self): + """Get the cryptographic materials provider.""" + return self.materials_provider diff --git a/db-esdk-performance-testing/benchmarks/python/src/providers/v4_providers.py b/db-esdk-performance-testing/benchmarks/python/src/providers/v4_providers.py new file mode 100644 index 000000000..866a56cb4 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/providers/v4_providers.py @@ -0,0 +1,182 @@ +"""V4 Keyring implementations for performance testing.""" + +import sys +from pathlib import Path +from abc import ABC, abstractmethod + +# Add parent directory to path for imports +sys.path.insert(0, str(Path(__file__).parent.parent)) + +import boto3 +from aws_cryptographic_material_providers.mpl import AwsCryptographicMaterialProviders +from aws_cryptographic_material_providers.mpl.config import MaterialProvidersConfig +from aws_cryptographic_material_providers.mpl.references import IKeyring +from aws_cryptographic_material_providers.mpl.models import ( + AesWrappingAlg, + CreateRawAesKeyringInput, + CreateAwsKmsMrkMultiKeyringInput, + CacheTypeDefault, + CreateAwsKmsHierarchicalKeyringInput, + DefaultCache, +) + +from aws_cryptographic_material_providers.keystore.client import KeyStore +from aws_cryptographic_material_providers.keystore.config import KeyStoreConfig +from aws_cryptographic_material_providers.keystore.models import ( + CreateKeyInput, + KMSConfigurationKmsKeyArn, +) + +from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.client import ( + DynamoDbEncryption, +) +from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.config import ( + DynamoDbEncryptionConfig, +) +from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.references import ( + IDynamoDbKeyBranchKeyIdSupplier, +) +from aws_dbesdk_dynamodb.structures.dynamodb import ( + CreateDynamoDbEncryptionBranchKeyIdSupplierInput, + GetBranchKeyIdFromDdbKeyInput, + GetBranchKeyIdFromDdbKeyOutput, +) + + + +from ..test_constants import AES_256_KEY_MATERIAL, KMS_KEY_ARN, HIERARCHY_KEYRING_NAMESPACE, HIERARCHY_KEYRING_PARTITION + + +_kms_client = boto3.client("kms", region_name="us-west-2") +_ddb_client = boto3.client("dynamodb", region_name="us-west-2") + +class V4KeyringBase(ABC): + """Base class for V4 keyring implementations.""" + + def __init__(self): + """Initialize the base keyring.""" + self.mat_prov = AwsCryptographicMaterialProviders( + config=MaterialProvidersConfig() + ) + + @abstractmethod + def get_keyring(self) -> IKeyring: + """Get the keyring.""" + pass + + def get_keyring_name(self) -> str: + """Get the keyring name.""" + return self.__class__.__name__ + + +class V4AESKeyring(V4KeyringBase): + """V4 Raw AES Keyring using static key material.""" + + def __init__(self): + """Initialize the AES keyring.""" + super().__init__() + + # Create Raw AES Keyring input matching the example + keyring_input = CreateRawAesKeyringInput( + key_name="my-aes-key-name", + key_namespace="my-key-namespace", + wrapping_key=AES_256_KEY_MATERIAL, + wrapping_alg=AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16, + ) + + self.keyring = self.mat_prov.create_raw_aes_keyring(input=keyring_input) + + def get_keyring(self) -> IKeyring: + """Get the keyring.""" + return self.keyring + + +class V4KMSKeyring(V4KeyringBase): + """V4 AWS KMS Multi-Region Keyring.""" + + def __init__(self): + """Initialize the KMS keyring.""" + super().__init__() + + # Create the KMS MRK Multi-Keyring + keyring_input = CreateAwsKmsMrkMultiKeyringInput( + generator=KMS_KEY_ARN + ) + + self.keyring = self.mat_prov.create_aws_kms_mrk_multi_keyring(input=keyring_input) + + def get_keyring(self) -> IKeyring: + """Get the keyring.""" + return self.keyring + +class PerformanceBranchKeyIdSupplier(IDynamoDbKeyBranchKeyIdSupplier): + """Branch Key ID Supplier for performance testing .""" + + def __init__(self, tenant1_branch_key_id: str, tenant2_branch_key_id: str): + """Initialize with branch key IDs for two tenants.""" + self.tenant1_branch_key_id = tenant1_branch_key_id + self.tenant2_branch_key_id = tenant2_branch_key_id + + def get_branch_key_id_from_ddb_key(self, param: GetBranchKeyIdFromDdbKeyInput) -> GetBranchKeyIdFromDdbKeyOutput: + """Get branch key ID based on partition key .""" + key = param.ddb_key + + if "partition_key" not in key: + raise ValueError("Item invalid, does not contain expected partition key attribute.") + + tenant_key_id = key["partition_key"]["S"] + + # if partition_key equals TEST_PK, use tenant1, otherwise tenant2 + if tenant_key_id == "test_pk": + branch_key_id = self.tenant1_branch_key_id + else: + branch_key_id = self.tenant2_branch_key_id + + return GetBranchKeyIdFromDdbKeyOutput(branch_key_id=branch_key_id) + +class V4HierarchyKeyring(V4KeyringBase): + """V4 AWS KMS Hierarchical Keyring.""" + + def __init__(self): + """Initialize the hierarchy keyring.""" + super().__init__() + + # Create the KMS Hierarchical Keyring + keystore = KeyStore( + config=KeyStoreConfig( + ddb_client=_ddb_client, + ddb_table_name="KeyStoreTestTable", + logical_key_store_name="KeyStoreTestTable", + kms_client=_kms_client, + kms_configuration=KMSConfigurationKmsKeyArn(KMS_KEY_ARN), + ) + ) + + # 2. Re-use two branch keys for tenants + tenant1_branch_key = "247b2cf7-6db9-47b3-a6de-7c1fbad88cc8" + tenant2_branch_key = "28115a523-e1d4-477f-9b3e-774fbb799ac7" + + # 3. Create DynamoDbEncryption and BranchKeyIdSupplier + ddb_enc = DynamoDbEncryption(config=DynamoDbEncryptionConfig()) + + branch_key_id_supplier = ddb_enc.create_dynamo_db_encryption_branch_key_id_supplier( + input=CreateDynamoDbEncryptionBranchKeyIdSupplierInput( + ddb_key_branch_key_id_supplier=PerformanceBranchKeyIdSupplier(tenant1_branch_key, tenant2_branch_key) + ) + ).branch_key_id_supplier + + # 4. Create Hierarchical Keyring + mat_prov = AwsCryptographicMaterialProviders(config=MaterialProvidersConfig()) + + keyring_input = CreateAwsKmsHierarchicalKeyringInput( + key_store=keystore, + branch_key_id_supplier=branch_key_id_supplier, + ttl_seconds=60, + cache=CacheTypeDefault(value=DefaultCache(entry_capacity=100)), # Same maxCacheSize=100 + ) + + self.keyring = mat_prov.create_aws_kms_hierarchical_keyring(input=keyring_input) + + def get_keyring(self) -> IKeyring: + """Get the keyring.""" + return self.keyring diff --git a/db-esdk-performance-testing/benchmarks/python/src/test_bases/__init__.py b/db-esdk-performance-testing/benchmarks/python/src/test_bases/__init__.py new file mode 100644 index 000000000..1d3ce22f3 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/test_bases/__init__.py @@ -0,0 +1 @@ +# Test base classes separated from provider implementations diff --git a/db-esdk-performance-testing/benchmarks/python/src/test_bases/client_test_base.py b/db-esdk-performance-testing/benchmarks/python/src/test_bases/client_test_base.py new file mode 100644 index 000000000..b722ab26c --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/test_bases/client_test_base.py @@ -0,0 +1,253 @@ +"""EncryptedClient-based test bases for performance testing.""" + +import json +import sys +from abc import ABC, abstractmethod +from pathlib import Path +from typing import Any, Dict + +import boto3 + +# Add parent directory to path for imports +sys.path.insert(0, str(Path(__file__).parent.parent)) + +# V3 imports +from dynamodb_encryption_sdk.encrypted.client import EncryptedClient as V3EncryptedClient +from dynamodb_encryption_sdk.identifiers import CryptoAction as V3CryptoAction +from dynamodb_encryption_sdk.structures import AttributeActions + +# V4 imports +from aws_cryptographic_material_providers.mpl.models import DBEAlgorithmSuiteId +from aws_dbesdk_dynamodb.encrypted.client import EncryptedClient as V4EncryptedClient +from aws_dbesdk_dynamodb.structures.dynamodb import ( + DynamoDbTableEncryptionConfig, + DynamoDbTablesEncryptionConfig, +) +from aws_dbesdk_dynamodb.structures.structured_encryption import CryptoAction as V4CryptoAction + +from ..test_constants import ( + FLAT_ATTRIBUTES_FILE, + NESTED_ATTRIBUTES_FILE, + PARTITION_KEY, + SINGLE_ATTRIBUTE_FILE, + SORT_KEY, + TABLE_NAME, +) +from ..providers.v3_providers import V3ProviderBase +from ..providers.v4_providers import V4KeyringBase + + +class ClientTestBase(ABC): + """Base class for EncryptedClient-based performance tests.""" + + def __init__(self): + """Initialize the test base.""" + self.table_name = TABLE_NAME + self.partition_key = PARTITION_KEY + self.sort_key = SORT_KEY + + # Load test data + self.test_data = self._load_test_data() + + # Create a mock DynamoDB client for testing + self.ddb_client = boto3.client("dynamodb", region_name="us-west-2") + + def _load_test_data(self) -> Dict[str, Any]: + """Load test data from JSON files in DynamoDB format.""" + data = {} + + # Load single attribute data + with open(SINGLE_ATTRIBUTE_FILE, "r") as f: + single_data = json.load(f) + data["single_attribute"] = self._convert_to_ddb_format(single_data) + + # Load nested attributes data + with open(NESTED_ATTRIBUTES_FILE, "r") as f: + nested_data = json.load(f) + data["nested_attributes"] = self._convert_to_ddb_format(nested_data) + + # Load flat attributes data + with open(FLAT_ATTRIBUTES_FILE, "r") as f: + flat_data = json.load(f) + data["flat_attributes"] = self._convert_to_ddb_format(flat_data) + + return data + + def _convert_to_ddb_value(self, value: Any) -> Dict[str, Any]: + """Convert a Python value to DynamoDB format.""" + if isinstance(value, str): + return {"S": value} + elif isinstance(value, (int, float)): + return {"N": str(value)} + elif isinstance(value, bool): + return {"BOOL": value} + elif isinstance(value, list): + return {"L": [self._convert_to_ddb_value(item) for item in value]} + elif isinstance(value, dict): + return {"M": {k: self._convert_to_ddb_value(v) for k, v in value.items()}} + else: + return {"S": str(value)} + + def _convert_to_ddb_format(self, item: Dict[str, Any]) -> Dict[str, Any]: + """Convert a Python dict to DynamoDB format.""" + return {k: self._convert_to_ddb_value(v) for k, v in item.items()} + + def get_test_item(self, data_type: str) -> Dict[str, Any]: + """Get a test item for the specified data type.""" + if data_type not in self.test_data: + raise ValueError(f"Unknown data type: {data_type}") + item = self.test_data[data_type].copy() + + # Add partition and sort keys + item[self.partition_key] = {"S": "test_pk"} + item[self.sort_key] = {"N": "0"} + + return item + + def calculate_item_size(self, item: Dict[str, Any]) -> int: + """Calculate the size of a DynamoDB item in bytes.""" + # Convert the item to JSON and calculate size + item_json = json.dumps(item, default=str) + return len(item_json.encode("utf-8")) + + @abstractmethod + def encrypt_item(self, item: Dict[str, Any]) -> Dict[str, Any]: + """Encrypt a DynamoDB item using EncryptedClient.""" + pass + + @abstractmethod + def decrypt_item(self, encrypted_item: Dict[str, Any]) -> Dict[str, Any]: + """Decrypt a DynamoDB item using EncryptedClient.""" + pass + + +class V3ClientTestBase(ClientTestBase): + """V3 EncryptedClient-based test base.""" + + def __init__(self, provider: V3ProviderBase): + """Initialize the V3 client test base with a provider.""" + super().__init__() + self.provider = provider + self.materials_provider = provider.get_materials_provider() + + # Create attribute actions - same as defined in original client test bases + attribute_actions = { + self.partition_key: V3CryptoAction.SIGN_ONLY, + self.sort_key: V3CryptoAction.SIGN_ONLY, + } + + # Add all other attributes as ENCRYPT_AND_SIGN + for data_type, item in self.test_data.items(): + for key in item: + if key not in attribute_actions: + attribute_actions[key] = V3CryptoAction.ENCRYPT_AND_SIGN + + self.actions = AttributeActions( + default_action=V3CryptoAction.ENCRYPT_AND_SIGN, + attribute_actions=attribute_actions, + ) + + # Create the encrypted client following the migration example pattern + self.encrypted_client = V3EncryptedClient( + client=self.ddb_client, + materials_provider=self.materials_provider, + attribute_actions=self.actions + ) + + def encrypt_item(self, item: Dict[str, Any]) -> Dict[str, Any]: + """Encrypt a DynamoDB item using V3 EncryptedClient.""" + # Focus only on the actual put_item call - this is what gets profiled + response = self.encrypted_client.put_item( + TableName=self.table_name, + Item=item + ) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 + # For profiling purposes, return the input item since put_item doesn't return encrypted data + # The profiler measures the put_item performance + return item + + def decrypt_item(self, encrypted_item: Dict[str, Any]) -> Dict[str, Any]: + """Decrypt a DynamoDB item using V3 EncryptedClient.""" + # Focus only on the actual get_item call - this is what gets profiled + key = { + self.partition_key: encrypted_item[self.partition_key], + self.sort_key: encrypted_item[self.sort_key], + } + + response = self.encrypted_client.get_item( + TableName=self.table_name, + Key=key + ) + + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 + return response["Item"] + + +class V4ClientTestBase(ClientTestBase): + """V4 EncryptedClient-based test base.""" + + def __init__(self, keyring: V4KeyringBase): + """Initialize the V4 client test base with a keyring.""" + super().__init__() + self.keyring = keyring + self.keyring_impl = keyring.get_keyring() + + # Create attribute actions - same as defined in original client test bases + attribute_actions = { + self.partition_key: V4CryptoAction.SIGN_ONLY, + self.sort_key: V4CryptoAction.SIGN_ONLY, + } + + # Add all other attributes as ENCRYPT_AND_SIGN + for data_type, item in self.test_data.items(): + for key in item: + if key not in attribute_actions: + attribute_actions[key] = V4CryptoAction.ENCRYPT_AND_SIGN + + # Create table encryption config following the migration example pattern + table_config = DynamoDbTableEncryptionConfig( + logical_table_name=self.table_name, + partition_key_name=self.partition_key, + sort_key_name=self.sort_key, + attribute_actions_on_encrypt=attribute_actions, + keyring=self.keyring_impl, + # Use unsigned attribute prefix pattern from migration examples + allowed_unsigned_attribute_prefix=":", + algorithm_suite_id=DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384, + ) + + # Create tables config + table_configs = {self.table_name: table_config} + tables_config = DynamoDbTablesEncryptionConfig(table_encryption_configs=table_configs) + + # Create the encrypted client following the migration example pattern + self.encrypted_client = V4EncryptedClient( + client=self.ddb_client, + encryption_config=tables_config, + ) + + def encrypt_item(self, item: Dict[str, Any]) -> Dict[str, Any]: + """Encrypt a DynamoDB item using V4 EncryptedClient.""" + # Focus only on the actual put_item call - this is what gets profiled + self.encrypted_client.put_item( + TableName=self.table_name, + Item=item + ) + # For profiling purposes, we don't need the encrypted result + # The profiler measures the put_item performance + return item + + def decrypt_item(self, encrypted_item: Dict[str, Any]) -> Dict[str, Any]: + """Decrypt a DynamoDB item using V4 EncryptedClient.""" + # Focus only on the actual get_item call - this is what gets profiled + key = { + self.partition_key: encrypted_item[self.partition_key], + self.sort_key: encrypted_item[self.sort_key], + } + + response = self.encrypted_client.get_item( + TableName=self.table_name, + Key=key + ) + + return response.get('Item', encrypted_item) diff --git a/db-esdk-performance-testing/benchmarks/python/src/test_bases/item_test_base.py b/db-esdk-performance-testing/benchmarks/python/src/test_bases/item_test_base.py new file mode 100644 index 000000000..0e6735671 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/test_bases/item_test_base.py @@ -0,0 +1,217 @@ +"""Item-based test bases for direct encryption/decryption performance testing.""" + +import json +import sys +from abc import ABC, abstractmethod +from pathlib import Path +from typing import Any, Dict, Union + +# Add parent directory to path for imports +sys.path.insert(0, str(Path(__file__).parent.parent)) + +# V3 imports +from dynamodb_encryption_sdk.encrypted.item import encrypt_dynamodb_item, decrypt_dynamodb_item +from dynamodb_encryption_sdk.encrypted import CryptoConfig +from dynamodb_encryption_sdk.identifiers import CryptoAction as V3CryptoAction +from dynamodb_encryption_sdk.structures import AttributeActions, EncryptionContext + +# V4 imports +from aws_cryptographic_material_providers.mpl.models import DBEAlgorithmSuiteId +from aws_dbesdk_dynamodb.encrypted.item import ItemEncryptor +from aws_dbesdk_dynamodb.structures.item_encryptor import DynamoDbItemEncryptorConfig +from aws_dbesdk_dynamodb.structures.structured_encryption import CryptoAction as V4CryptoAction + +from ..test_constants import ( + FLAT_ATTRIBUTES_FILE, + NESTED_ATTRIBUTES_FILE, + PARTITION_KEY, + SINGLE_ATTRIBUTE_FILE, + SORT_KEY, + TABLE_NAME, +) +from ..providers.v3_providers import V3ProviderBase +from ..providers.v4_providers import V4KeyringBase + + +class ItemTestBase(ABC): + """Base class for item-based performance tests.""" + + def __init__(self): + """Initialize the test base.""" + self.table_name = TABLE_NAME + self.partition_key = PARTITION_KEY + self.sort_key = SORT_KEY + + # Load test data + self.test_data = self._load_test_data() + + def _load_test_data(self) -> Dict[str, Any]: + """Load test data from JSON files in DynamoDB format.""" + data = {} + + # Load single attribute data + with open(SINGLE_ATTRIBUTE_FILE, "r") as f: + single_data = json.load(f) + data["single_attribute"] = self._convert_to_ddb_format(single_data) + + # Load nested attributes data + with open(NESTED_ATTRIBUTES_FILE, "r") as f: + nested_data = json.load(f) + data["nested_attributes"] = self._convert_to_ddb_format(nested_data) + + # Load flat attributes data + with open(FLAT_ATTRIBUTES_FILE, "r") as f: + flat_data = json.load(f) + data["flat_attributes"] = self._convert_to_ddb_format(flat_data) + + return data + + def _convert_to_ddb_value(self, value: Any) -> Dict[str, Any]: + """Convert a Python value to DynamoDB format.""" + if isinstance(value, str): + return {"S": value} + elif isinstance(value, (int, float)): + return {"N": str(value)} + elif isinstance(value, bool): + return {"BOOL": value} + elif isinstance(value, list): + return {"L": [self._convert_to_ddb_value(item) for item in value]} + elif isinstance(value, dict): + return {"M": {k: self._convert_to_ddb_value(v) for k, v in value.items()}} + else: + return {"S": str(value)} + + def _convert_to_ddb_format(self, item: Dict[str, Any]) -> Dict[str, Any]: + """Convert a Python dict to DynamoDB format.""" + return {k: self._convert_to_ddb_value(v) for k, v in item.items()} + + def get_test_item(self, data_type: str) -> Dict[str, Any]: + """Get a test item for the specified data type.""" + if data_type not in self.test_data: + raise ValueError(f"Unknown data type: {data_type}") + item = self.test_data[data_type].copy() + + # Add partition and sort keys + item[self.partition_key] = {"S": "test_pk"} + item[self.sort_key] = {"N": "0"} + + return item + + def calculate_item_size(self, item: Dict[str, Any]) -> int: + """Calculate the size of a DynamoDB item in bytes.""" + # Convert the item to JSON and calculate size + item_json = json.dumps(item, default=str) + return len(item_json.encode("utf-8")) + + @abstractmethod + def encrypt_item(self, item: Dict[str, Any]) -> Dict[str, Any]: + """Encrypt a DynamoDB item directly.""" + pass + + @abstractmethod + def decrypt_item(self, encrypted_item: Dict[str, Any]) -> Dict[str, Any]: + """Decrypt a DynamoDB item directly.""" + pass + + +class V3ItemTestBase(ItemTestBase): + """V3 item-based test base using direct encryption methods.""" + + def __init__(self, provider: V3ProviderBase): + """Initialize the V3 test base with a provider.""" + super().__init__() + self.provider = provider + self.materials_provider = provider.get_materials_provider() + + # Create attribute actions - same as defined in original item test bases + attribute_actions = { + self.partition_key: V3CryptoAction.SIGN_ONLY, + self.sort_key: V3CryptoAction.SIGN_ONLY, + } + + # Add all other attributes as ENCRYPT_AND_SIGN + for data_type, item in self.test_data.items(): + for key in item: + if key not in attribute_actions: + attribute_actions[key] = V3CryptoAction.ENCRYPT_AND_SIGN + + self.actions = AttributeActions( + default_action=V3CryptoAction.ENCRYPT_AND_SIGN, + attribute_actions=attribute_actions, + ) + + # Create encryption context + self.encryption_context = EncryptionContext( + table_name=self.table_name, + partition_key_name=self.partition_key, + sort_key_name=self.sort_key, + ) + + self.crypto_config = CryptoConfig( + materials_provider=self.materials_provider, + encryption_context=self.encryption_context, + attribute_actions=self.actions, + ) + + def encrypt_item(self, item: Dict[str, Any]) -> Dict[str, Any]: + """Encrypt a DynamoDB item directly - REAL encryption only.""" + # Use the proper DDBEC v3 API + + encrypted_item = encrypt_dynamodb_item(item, self.crypto_config) + return encrypted_item + + def decrypt_item(self, encrypted_item: Dict[str, Any]) -> Dict[str, Any]: + """Decrypt a DynamoDB item directly - REAL decryption only.""" + # Make a copy to avoid mutating the original encrypted item + # The decrypt_dynamodb_item function modifies the input by removing signature attributes + encrypted_item_copy = encrypted_item.copy() + decrypted_item = decrypt_dynamodb_item(encrypted_item_copy, self.crypto_config) + return decrypted_item + + +class V4ItemTestBase(ItemTestBase): + """V4 item-based test base using direct encryption methods.""" + + def __init__(self, keyring: V4KeyringBase): + """Initialize the V4 test base with a keyring.""" + super().__init__() + self.keyring = keyring + self.keyring_impl = keyring.get_keyring() + + # Create attribute actions - same as defined in original item test bases + attribute_actions = { + self.partition_key: V4CryptoAction.SIGN_ONLY, + self.sort_key: V4CryptoAction.SIGN_ONLY, + } + + # Add all other attributes as ENCRYPT_AND_SIGN + for data_type, item in self.test_data.items(): + for key in item: + if key not in attribute_actions: + attribute_actions[key] = V4CryptoAction.ENCRYPT_AND_SIGN + + # Create table encryption config + self.table_config = DynamoDbItemEncryptorConfig( + logical_table_name=self.table_name, + partition_key_name=self.partition_key, + sort_key_name=self.sort_key, + attribute_actions_on_encrypt=attribute_actions, + keyring=self.keyring_impl, + # Use unsigned attribute prefix pattern from migration examples + allowed_unsigned_attribute_prefix=":", + algorithm_suite_id=DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384, + ) + + # Create the item encryptor + self.item_encryptor = ItemEncryptor(self.table_config) + + def encrypt_item(self, item: Dict[str, Any]) -> Dict[str, Any]: + """Encrypt a DynamoDB item directly - REAL encryption only.""" + encrypted_item = self.item_encryptor.encrypt_dynamodb_item(item) + return encrypted_item.encrypted_item + + def decrypt_item(self, encrypted_item: Dict[str, Any]) -> Dict[str, Any]: + """Decrypt a DynamoDB item directly - REAL decryption only.""" + encrypted_item_copy = encrypted_item.copy() + decrypted_item = self.item_encryptor.decrypt_dynamodb_item(encrypted_item_copy) + return decrypted_item.plaintext_item diff --git a/db-esdk-performance-testing/benchmarks/python/src/test_constants.py b/db-esdk-performance-testing/benchmarks/python/src/test_constants.py new file mode 100644 index 000000000..fc50100b0 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/src/test_constants.py @@ -0,0 +1,76 @@ +"""Constants used across performance tests.""" + +import os +from pathlib import Path + +# Table Configuration +TABLE_NAME = "DynamoDbEncryptionInterceptorTestTable" +PARTITION_KEY = "partition_key" +SORT_KEY = "sort_key" + +# AWS Configuration +AWS_REGION = os.environ.get("AWS_REGION", "us-west-2") +KMS_KEY_ARN = "arn:aws:kms:us-west-2:370957321024:key/9d989aa2-2f9c-438c-a745-cc57d3ad0126" + +# Test Data Files +RESOURCES_DIR = Path(__file__).parent.parent / "resources" +SINGLE_ATTRIBUTE_FILE = RESOURCES_DIR / "single_attribute.json" +NESTED_ATTRIBUTES_FILE = RESOURCES_DIR / "nested_attributes.json" +FLAT_ATTRIBUTES_FILE = RESOURCES_DIR / "flat_attributes.json" + +# Benchmark Configuration +BENCHMARK_ROUNDS = 10 +BENCHMARK_ITERATIONS = 5 +BENCHMARK_WARMUP_ROUNDS = 2 + +# Encryption Context +ENCRYPTION_CONTEXT = {"purpose": "performance_test", "origin": "aws-database-encryption-sdk-dynamodb"} + +# AES Key Material (32 bytes for AES-256) +AES_256_KEY_MATERIAL = bytes( + [ + 0x00, + 0x01, + 0x02, + 0x03, + 0x04, + 0x05, + 0x06, + 0x07, + 0x08, + 0x09, + 0x0A, + 0x0B, + 0x0C, + 0x0D, + 0x0E, + 0x0F, + 0x10, + 0x11, + 0x12, + 0x13, + 0x14, + 0x15, + 0x16, + 0x17, + 0x18, + 0x19, + 0x1A, + 0x1B, + 0x1C, + 0x1D, + 0x1E, + 0x1F, + ] +) + +# Hierarchy Keyring Configuration +HIERARCHY_KEYRING_NAMESPACE = "performance-test" +HIERARCHY_KEYRING_PARTITION = "benchmark" + +# Test Data Categories +TEST_DATA_CATEGORIES = ["single_attribute", "nested_attributes", "flat_attributes"] + +# Performance Thresholds (in seconds) +ENCRYPT_THRESHOLD = 1.0 # Maximum acceptable time for encryption +DECRYPT_THRESHOLD = 1.0 # Maximum acceptable time for decryption diff --git a/db-esdk-performance-testing/benchmarks/python/tests/__init__.py b/db-esdk-performance-testing/benchmarks/python/tests/__init__.py new file mode 100644 index 000000000..f94fd12a2 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/tests/__init__.py @@ -0,0 +1,2 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 diff --git a/db-esdk-performance-testing/benchmarks/python/tests/test_benchmark.py b/db-esdk-performance-testing/benchmarks/python/tests/test_benchmark.py new file mode 100644 index 000000000..40148d835 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/tests/test_benchmark.py @@ -0,0 +1,258 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 + +""" +Basic tests for the DB-ESDK Performance Benchmark Suite. + +These tests validate the core functionality of the benchmark components. +""" + +import tempfile +import json +from pathlib import Path +from unittest.mock import patch, MagicMock + +import pytest + +from esdk_benchmark.models import Config, TestResult, DataSizes, Iterations + + +class TestConfig: + """Test configuration loading and manipulation.""" + + def test_config_creation(self): + """Test basic config creation.""" + config = Config() + assert config.table_name == "dbesdk-performance-testing" + assert config.keyring == "raw-aes" + assert config.concurrency_levels == [1, 2, 4, 8] + + def test_config_load_from_yaml(self): + """Test loading configuration from YAML.""" + yaml_content = """ +data_sizes: + small: [1024, 5120] + medium: [102400] + +iterations: + warmup: 3 + measurement: 5 + +concurrency_levels: [1, 2] +table_name: "test-table" +keyring: "test-keyring" +""" + + with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f: + f.write(yaml_content) + f.flush() + + try: + config = Config.load_config(f.name) + assert config.data_sizes.small == [1024, 5120] + assert config.data_sizes.medium == [102400] + assert config.iterations.warmup == 3 + assert config.iterations.measurement == 5 + assert config.concurrency_levels == [1, 2] + assert config.table_name == "test-table" + assert config.keyring == "test-keyring" + finally: + Path(f.name).unlink() + + def test_config_quick_test_adjustment(self): + """Test quick test configuration adjustment.""" + yaml_content = """ +data_sizes: + small: [1024, 5120] + medium: [102400] + +iterations: + warmup: 5 + measurement: 10 + +concurrency_levels: [1, 2, 4, 8] + +quick_config: + data_sizes: + small: [1024] + iterations: + warmup: 2 + measurement: 3 + concurrency_levels: [1, 2] +""" + + with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f: + f.write(yaml_content) + f.flush() + + try: + config = Config.load_config(f.name) + + # Before adjustment + assert config.data_sizes.small == [1024, 5120] + assert config.iterations.warmup == 5 + assert config.iterations.measurement == 10 + assert config.concurrency_levels == [1, 2, 4, 8] + + # After adjustment + config.adjust_for_quick_test() + assert config.data_sizes.small == [1024] + assert config.iterations.warmup == 2 + assert config.iterations.measurement == 3 + assert config.concurrency_levels == [1, 2] + finally: + Path(f.name).unlink() + + +class TestTestResult: + """Test TestResult creation and serialization.""" + + def test_throughput_result_creation(self): + """Test creating a throughput test result.""" + encrypt_latencies = [1.0, 1.1, 0.9, 1.2, 1.0] + decrypt_latencies = [0.8, 0.9, 0.7, 1.0, 0.8] + total_latencies = [1.8, 2.0, 1.6, 2.2, 1.8] + + result = TestResult.create_throughput_result( + encrypt_latencies=encrypt_latencies, + decrypt_latencies=decrypt_latencies, + total_latencies=total_latencies, + data_size=1024, + cpu_count=8, + total_memory_mb=16384, + ) + + assert result.test_name == "throughput" + assert result.data_size == 1024 + assert result.put_latency_ms == 1.04 # mean of encrypt_latencies + assert result.get_latency_ms == 0.84 # mean of decrypt_latencies + assert result.end_to_end_latency_ms == 1.88 # mean of total_latencies + assert result.ops_per_second > 0 + assert result.bytes_per_second > 0 + assert result.p50_latency > 0 + assert result.p95_latency > 0 + assert result.p99_latency > 0 + + def test_memory_result_creation(self): + """Test creating a memory test result.""" + result = TestResult.create_memory_result( + peak_memory_mb=50.0, + avg_memory_mb=35.0, + data_size=1024, + cpu_count=8, + total_memory_mb=16384, + ) + + assert result.test_name == "memory" + assert result.data_size == 1024 + assert result.peak_memory_mb == 50.0 + assert result.memory_efficiency_ratio > 0 + + def test_concurrent_result_creation(self): + """Test creating a concurrent test result.""" + all_times = [1.5, 1.8, 1.2, 2.0, 1.6, 1.9, 1.4, 1.7] + + result = TestResult.create_concurrent_result( + all_times=all_times, + total_operations=len(all_times), + data_size=1024, + concurrency=4, + cpu_count=8, + total_memory_mb=16384, + ) + + assert result.test_name == "concurrency" + assert result.data_size == 1024 + assert result.concurrency == 4 + assert result.ops_per_second > 0 + assert result.bytes_per_second > 0 + assert result.p50_latency > 0 + assert result.p95_latency > 0 + assert result.p99_latency > 0 + + def test_result_serialization(self): + """Test TestResult serialization to dictionary.""" + result = TestResult( + test_name="test", + data_size=1024, + concurrency=2, + ops_per_second=100.0, + bytes_per_second=102400.0, + ) + + result_dict = result.to_dict() + + assert isinstance(result_dict, dict) + assert result_dict["test_name"] == "test" + assert result_dict["data_size"] == 1024 + assert result_dict["concurrency"] == 2 + assert result_dict["ops_per_second"] == 100.0 + assert result_dict["bytes_per_second"] == 102400.0 + assert "timestamp" in result_dict + assert "python_version" in result_dict + + +class TestBenchmark: + """Test benchmark functionality with mocked dependencies.""" + + @patch("esdk_benchmark.benchmark.AwsCryptographicMaterialProviders") + @patch("esdk_benchmark.benchmark.ItemEncryptor") + def test_benchmark_initialization( + self, mock_item_encryptor, mock_material_providers + ): + """Test benchmark initialization with mocked dependencies.""" + # Mock the material providers and keyring + mock_mat_prov = MagicMock() + mock_keyring = MagicMock() + mock_mat_prov.create_raw_aes_keyring.return_value = mock_keyring + mock_material_providers.return_value = mock_mat_prov + + # Mock the item encryptor + mock_encryptor = MagicMock() + mock_item_encryptor.return_value = mock_encryptor + + # Create a temporary config file + yaml_content = """ +data_sizes: + small: [1024] +iterations: + warmup: 1 + measurement: 2 +concurrency_levels: [1] +""" + + with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f: + f.write(yaml_content) + f.flush() + + try: + from esdk_benchmark.benchmark import ESDKBenchmark + + benchmark = ESDKBenchmark(f.name) + + assert benchmark.config is not None + assert benchmark.keyring == mock_keyring + assert benchmark.item_encryptor == mock_encryptor + assert benchmark.cpu_count > 0 + assert benchmark.total_memory_mb > 0 + finally: + Path(f.name).unlink() + + +def test_imports(): + """Test that all required modules can be imported.""" + # Test basic imports + import esdk_benchmark + from esdk_benchmark import models, benchmark, tests, program + + # Test that key classes are available + assert hasattr(models, "Config") + assert hasattr(models, "TestResult") + assert hasattr(models, "Report") + assert hasattr(benchmark, "ESDKBenchmark") + assert hasattr(tests, "Tests") + assert hasattr(program, "main") + + +if __name__ == "__main__": + pytest.main([__file__]) diff --git a/db-esdk-performance-testing/benchmarks/python/tox.ini b/db-esdk-performance-testing/benchmarks/python/tox.ini new file mode 100644 index 000000000..b72ff6660 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/python/tox.ini @@ -0,0 +1,120 @@ +[tox] +min_version = 4.0 +env_list = + py311 + lint + type + format-check + +[testenv] +description = Run unit tests +deps = + pytest + pytest-cov + memory-profiler +commands = pytest {posargs:tests} + +[testenv:py311] +description = Run tests under Python 3.11 +base_python = python3.11 +deps = + pytest + pytest-cov + memory-profiler +commands = pytest {posargs:tests} + +[testenv:lint] +description = Run linting checks +deps = + flake8 + flake8-docstrings + flake8-import-order +commands = flake8 src tests + +[testenv:type] +description = Run type checking +deps = + mypy + types-PyYAML + types-psutil +commands = mypy src + +[testenv:format] +description = Apply code formatting +deps = black +commands = black src tests + +[testenv:format-check] +description = Check code formatting +deps = black +commands = black --check --diff src tests + +[testenv:benchmark] +description = Run benchmark suite +deps = + aws-dbesdk-dynamodb[legacy-ddbec] @ file:///{toxinidir}/../../../../DynamoDbEncryption/runtimes/python + boto3>=1.26.0 + PyYAML>=6.0 + pydantic>=2.0.0 + tqdm>=4.66.0 + psutil>=5.9.0 + numpy>=1.24.0 +allowlist_externals = python +commands = + python -m esdk_benchmark --quick + +[testenv:benchmark-full] +description = Run full benchmark suite +deps = + aws-dbesdk-dynamodb[legacy-ddbec] @ file:///{toxinidir}/../../../../DynamoDbEncryption/runtimes/python + boto3>=1.26.0 + PyYAML>=6.0 + pydantic>=2.0.0 + tqdm>=4.66.0 + psutil>=5.9.0 + numpy>=1.24.0 +allowlist_externals = python +commands = + python -m esdk_benchmark + +[testenv:verify] +description = Verify setup and dependencies +deps = + PyYAML>=6.0 + pydantic>=2.0.0 + tqdm>=4.66.0 + psutil>=5.9.0 + numpy>=1.24.0 +allowlist_externals = python +commands = + python verify_setup.py + +[testenv:clean] +description = Clean up build artifacts +deps = +allowlist_externals = + rm + find +commands = + rm -rf build/ + rm -rf dist/ + rm -rf *.egg-info/ + find . -type d -name __pycache__ -exec rm -rf {} + + find . -type f -name "*.pyc" -delete + +[flake8] +max-line-length = 88 +extend-ignore = E203, W503 +max-complexity = 10 +per-file-ignores = + __init__.py:F401 + tests/*:S101,D103 +exclude = + .git, + __pycache__, + .tox, + .eggs, + *.egg, + build, + dist, + .venv diff --git a/db-esdk-performance-testing/benchmarks/results/raw-data/java_results.json b/db-esdk-performance-testing/benchmarks/results/raw-data/java_results.json new file mode 100644 index 000000000..a4196239d --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/results/raw-data/java_results.json @@ -0,0 +1,1091 @@ +{ + "metadata" : { + "language" : "java", + "timestamp" : "2025-09-08 11:55:39", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "total_tests" : 54 + }, + "results" : [ { + "language" : "java", + "test_name" : "throughput", + "data_size" : 1024, + "concurrency" : 1, + "operations_per_second" : 115.0451198907053, + "bytes_per_second" : 117806.20276808222, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 8.6922418, + "p50_latency_ms" : 7.8825, + "p95_latency_ms" : 14.78225, + "p99_latency_ms" : 14.78225, + "encrypt_latency_ms" : 3.9275998999999997, + "decrypt_latency_ms" : 4.7478499, + "timestamp" : "2025-09-08 11:46:45", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 5120, + "concurrency" : 1, + "operations_per_second" : 143.8708341462635, + "bytes_per_second" : 736618.6708288691, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 6.950679099999999, + "p50_latency_ms" : 6.874625, + "p95_latency_ms" : 7.555458, + "p99_latency_ms" : 7.555458, + "encrypt_latency_ms" : 3.4125791999999997, + "decrypt_latency_ms" : 3.5264916, + "timestamp" : "2025-09-08 11:46:45", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 10240, + "concurrency" : 1, + "operations_per_second" : 155.5157590728088, + "bytes_per_second" : 1592481.3729055622, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 6.4302165, + "p50_latency_ms" : 6.281583, + "p95_latency_ms" : 7.201583, + "p99_latency_ms" : 7.201583, + "encrypt_latency_ms" : 3.1387957, + "decrypt_latency_ms" : 3.2792123, + "timestamp" : "2025-09-08 11:46:45", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 102400, + "concurrency" : 1, + "operations_per_second" : 79.32329235830495, + "bytes_per_second" : 8122705.137490427, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 12.6066376, + "p50_latency_ms" : 12.51525, + "p95_latency_ms" : 13.038959, + "p99_latency_ms" : 13.038959, + "encrypt_latency_ms" : 6.6231543, + "decrypt_latency_ms" : 5.9605042, + "timestamp" : "2025-09-08 11:46:45", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 512000, + "concurrency" : 1, + "operations_per_second" : 25.50681245639674, + "bytes_per_second" : 1.305948797767513E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 39.2052124, + "p50_latency_ms" : 38.225042, + "p95_latency_ms" : 44.972083, + "p99_latency_ms" : 44.972083, + "encrypt_latency_ms" : 21.9098082, + "decrypt_latency_ms" : 17.2458585, + "timestamp" : "2025-09-08 11:46:46", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 1048576, + "concurrency" : 1, + "operations_per_second" : 13.961656753017767, + "bytes_per_second" : 1.4639858191452358E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 71.62473750000001, + "p50_latency_ms" : 71.51675, + "p95_latency_ms" : 72.820375, + "p99_latency_ms" : 72.820375, + "encrypt_latency_ms" : 40.0376915, + "decrypt_latency_ms" : 31.5381958, + "timestamp" : "2025-09-08 11:46:47", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 10485760, + "concurrency" : 1, + "operations_per_second" : 1.5027615971107828, + "bytes_per_second" : 1.5757597444520362E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 665.4415457, + "p50_latency_ms" : 665.21775, + "p95_latency_ms" : 668.471125, + "p99_latency_ms" : 668.471125, + "encrypt_latency_ms" : 374.6874331, + "decrypt_latency_ms" : 290.3426126, + "timestamp" : "2025-09-08 11:46:57", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 52428800, + "concurrency" : 1, + "operations_per_second" : 0.29788644207688386, + "bytes_per_second" : 1.5617828694360528E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 3356.9839332999995, + "p50_latency_ms" : 3345.4625, + "p95_latency_ms" : 3409.787, + "p99_latency_ms" : 3409.787, + "encrypt_latency_ms" : 1878.5476334999998, + "decrypt_latency_ms" : 1475.6690290000001, + "timestamp" : "2025-09-08 11:47:48", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 104857600, + "concurrency" : 1, + "operations_per_second" : 0.14872135089533312, + "bytes_per_second" : 1.5594563923642483E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 6723.9841084, + "p50_latency_ms" : 6730.469416, + "p95_latency_ms" : 6816.788042, + "p99_latency_ms" : 6816.788042, + "encrypt_latency_ms" : 3789.1793335, + "decrypt_latency_ms" : 2930.9112166, + "timestamp" : "2025-09-08 11:49:31", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 1024, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 3.4590606689453125, + "memory_efficiency_ratio" : 2.8232014221877167E-4, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:49:32", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 5120, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 3.4590530395507812, + "memory_efficiency_ratio" : 0.001411603824564112, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:49:33", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 10240, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 3.3278121948242188, + "memory_efficiency_ratio" : 0.002934548113979683, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:49:33", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 102400, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 5.15667724609375, + "memory_efficiency_ratio" : 0.01893782475410418, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:49:34", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 512000, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 15.132316589355469, + "memory_efficiency_ratio" : 0.03226744874895572, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:49:35", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 1048576, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 36.000083923339844, + "memory_efficiency_ratio" : 0.027777713022265275, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:49:36", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 10485760, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 52.01019287109375, + "memory_efficiency_ratio" : 0.19227000416600656, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:49:39", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 52428800, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 211.35906219482422, + "memory_efficiency_ratio" : 0.23656425932620553, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:49:57", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 104857600, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 419.2744369506836, + "memory_efficiency_ratio" : 0.23850726680902398, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:33", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1024, + "concurrency" : 2, + "operations_per_second" : 179.75171363150534, + "bytes_per_second" : 184065.75475866147, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 5.563229300000001, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:34", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1024, + "concurrency" : 4, + "operations_per_second" : 156.38164402270888, + "bytes_per_second" : 160134.8034792539, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 6.3946124, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:34", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1024, + "concurrency" : 8, + "operations_per_second" : 125.57271241921629, + "bytes_per_second" : 128586.45751727748, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 7.963513575, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:34", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1024, + "concurrency" : 16, + "operations_per_second" : 109.29949669754097, + "bytes_per_second" : 111922.68461828196, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 9.1491729625, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:34", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 5120, + "concurrency" : 2, + "operations_per_second" : 163.98752592806773, + "bytes_per_second" : 839616.1327517068, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 6.0980248, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:34", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 5120, + "concurrency" : 4, + "operations_per_second" : 140.20300876918645, + "bytes_per_second" : 717839.4048982346, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 7.132514550000001, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:34", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 5120, + "concurrency" : 8, + "operations_per_second" : 119.00508783344551, + "bytes_per_second" : 609306.049707241, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 8.403002075, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:35", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 5120, + "concurrency" : 16, + "operations_per_second" : 71.57089052780145, + "bytes_per_second" : 366442.95950234344, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 13.972160925, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:35", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10240, + "concurrency" : 2, + "operations_per_second" : 158.46678693028062, + "bytes_per_second" : 1622699.8981660735, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 6.3104706, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:35", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10240, + "concurrency" : 4, + "operations_per_second" : 142.06441631090718, + "bytes_per_second" : 1454739.6230236895, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 7.03906035, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:35", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10240, + "concurrency" : 8, + "operations_per_second" : 112.89122542366842, + "bytes_per_second" : 1156006.1483383647, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 8.858084375, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:35", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10240, + "concurrency" : 16, + "operations_per_second" : 112.19235228461446, + "bytes_per_second" : 1148849.687394452, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 8.913263512499999, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:36", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 102400, + "concurrency" : 2, + "operations_per_second" : 74.1860857215621, + "bytes_per_second" : 7596655.1778879585, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 13.4796167, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:36", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 102400, + "concurrency" : 4, + "operations_per_second" : 65.68432992521649, + "bytes_per_second" : 6726075.384342168, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 15.2243313, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:36", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 102400, + "concurrency" : 8, + "operations_per_second" : 57.45536995059531, + "bytes_per_second" : 5883429.88294096, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 17.404813525, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:36", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 102400, + "concurrency" : 16, + "operations_per_second" : 42.34140567892608, + "bytes_per_second" : 4335759.94152203, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 23.617543724999997, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:36", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 512000, + "concurrency" : 2, + "operations_per_second" : 21.127508179599303, + "bytes_per_second" : 1.0817284187954843E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 47.331658399999995, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:37", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 512000, + "concurrency" : 4, + "operations_per_second" : 22.39972864789518, + "bytes_per_second" : 1.1468661067722332E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 44.64339795, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:37", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 512000, + "concurrency" : 8, + "operations_per_second" : 16.69883656479568, + "bytes_per_second" : 8549804.321175389, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 59.884411475, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:37", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 512000, + "concurrency" : 16, + "operations_per_second" : 11.670848738304166, + "bytes_per_second" : 5975474.554011733, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 85.6835713, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:38", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1048576, + "concurrency" : 2, + "operations_per_second" : 12.987509177331141, + "bytes_per_second" : 1.3618390423129179E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 76.9970582, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:39", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1048576, + "concurrency" : 4, + "operations_per_second" : 12.91239814930342, + "bytes_per_second" : 1.3539630801803984E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 77.44494775, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:39", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1048576, + "concurrency" : 8, + "operations_per_second" : 10.917783209385842, + "bytes_per_second" : 1.1448125446564969E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 91.59368535, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:40", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1048576, + "concurrency" : 16, + "operations_per_second" : 6.155327672561361, + "bytes_per_second" : 6454328.869583702, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 162.4608880625, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:41", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10485760, + "concurrency" : 2, + "operations_per_second" : 1.3674876283055815, + "bytes_per_second" : 1.4339147073381534E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 731.2680417, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:44", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10485760, + "concurrency" : 4, + "operations_per_second" : 1.4272412226250475, + "bytes_per_second" : 1.4965708922552818E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 700.6524084, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:48", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10485760, + "concurrency" : 8, + "operations_per_second" : 1.2630863706628956, + "bytes_per_second" : 1.3244420542042164E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 791.711495925, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:50:53", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10485760, + "concurrency" : 16, + "operations_per_second" : 0.695257000414006, + "bytes_per_second" : 7290298.044661167, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 1438.317053125, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:51:00", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 52428800, + "concurrency" : 2, + "operations_per_second" : 0.2898646061358695, + "bytes_per_second" : 1.5197253462176275E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 3449.8865292, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:51:18", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 52428800, + "concurrency" : 4, + "operations_per_second" : 0.2868660356107121, + "bytes_per_second" : 1.5040042007826904E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 3485.9477103, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:51:37", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 52428800, + "concurrency" : 8, + "operations_per_second" : 0.2757878797339764, + "bytes_per_second" : 1.4459227588996701E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 3625.975155125, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:51:56", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 52428800, + "concurrency" : 16, + "operations_per_second" : 0.1436821204142847, + "bytes_per_second" : 7533081.154776449, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 6959.808201025, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:52:32", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 104857600, + "concurrency" : 2, + "operations_per_second" : 0.1468282540478687, + "bytes_per_second" : 1.5396058331649797E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 6810.678275, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:53:07", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 104857600, + "concurrency" : 4, + "operations_per_second" : 0.14162462338136642, + "bytes_per_second" : 1.4850418108673967E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 7060.9190416500005, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:53:44", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 104857600, + "concurrency" : 8, + "operations_per_second" : 0.13455770234792894, + "bytes_per_second" : 1.4109397729718193E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 7431.755912525, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:54:23", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 104857600, + "concurrency" : 16, + "operations_per_second" : 0.0672335755582277, + "bytes_per_second" : 7049951.372454417, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 14873.5210301875, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 11:55:39", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + } ] +} \ No newline at end of file diff --git a/db-esdk-performance-testing/benchmarks/results/raw-data/java_results_10MBdata.json b/db-esdk-performance-testing/benchmarks/results/raw-data/java_results_10MBdata.json new file mode 100644 index 000000000..17f0b028e --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/results/raw-data/java_results_10MBdata.json @@ -0,0 +1,851 @@ +{ + "metadata" : { + "language" : "java", + "timestamp" : "2025-09-08 16:47:05", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "total_tests" : 42 + }, + "results" : [ { + "language" : "java", + "test_name" : "throughput", + "data_size" : 1024, + "concurrency" : 1, + "operations_per_second" : 114.43617103987165, + "bytes_per_second" : 117182.63914482857, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 8.738495799999999, + "p50_latency_ms" : 7.87575, + "p95_latency_ms" : 15.502958, + "p99_latency_ms" : 15.502958, + "encrypt_latency_ms" : 3.8807543000000004, + "decrypt_latency_ms" : 4.840279300000001, + "timestamp" : "2025-09-08 16:46:20", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 5120, + "concurrency" : 1, + "operations_per_second" : 142.19374201644348, + "bytes_per_second" : 728031.9591241906, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 7.0326583, + "p50_latency_ms" : 7.044292, + "p95_latency_ms" : 7.397542, + "p99_latency_ms" : 7.397542, + "encrypt_latency_ms" : 3.4365, + "decrypt_latency_ms" : 3.5825332000000003, + "timestamp" : "2025-09-08 16:46:20", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 10240, + "concurrency" : 1, + "operations_per_second" : 152.49646162460093, + "bytes_per_second" : 1561563.7670359134, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 6.5575292, + "p50_latency_ms" : 6.484709, + "p95_latency_ms" : 7.240083, + "p99_latency_ms" : 7.240083, + "encrypt_latency_ms" : 3.2205416999999996, + "decrypt_latency_ms" : 3.3228082, + "timestamp" : "2025-09-08 16:46:20", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 102400, + "concurrency" : 1, + "operations_per_second" : 63.59790777383748, + "bytes_per_second" : 6512425.756040958, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 15.723787699999999, + "p50_latency_ms" : 12.931416, + "p95_latency_ms" : 38.401584, + "p99_latency_ms" : 38.401584, + "encrypt_latency_ms" : 8.52655, + "decrypt_latency_ms" : 7.1710335, + "timestamp" : "2025-09-08 16:46:20", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 512000, + "concurrency" : 1, + "operations_per_second" : 25.28969088006202, + "bytes_per_second" : 1.2948321730591755E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 39.541804, + "p50_latency_ms" : 39.252166, + "p95_latency_ms" : 40.548958, + "p99_latency_ms" : 40.548958, + "encrypt_latency_ms" : 22.0167292, + "decrypt_latency_ms" : 17.469662500000002, + "timestamp" : "2025-09-08 16:46:21", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 1048576, + "concurrency" : 1, + "operations_per_second" : 13.582811844816092, + "bytes_per_second" : 1.4242610512989879E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 73.6224584, + "p50_latency_ms" : 72.973708, + "p95_latency_ms" : 76.11475, + "p99_latency_ms" : 76.11475, + "encrypt_latency_ms" : 41.2115001, + "decrypt_latency_ms" : 32.3443501, + "timestamp" : "2025-09-08 16:46:22", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "throughput", + "data_size" : 10000000, + "concurrency" : 1, + "operations_per_second" : 1.5284864113360808, + "bytes_per_second" : 1.5284864113360807E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 654.2419956, + "p50_latency_ms" : 648.106666, + "p95_latency_ms" : 689.763791, + "p99_latency_ms" : 689.763791, + "encrypt_latency_ms" : 369.118229, + "decrypt_latency_ms" : 284.7368376, + "timestamp" : "2025-09-08 16:46:32", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 1024, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 3.3156280517578125, + "memory_efficiency_ratio" : 2.945331879075718E-4, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:33", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 5120, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 2.257843017578125, + "memory_efficiency_ratio" : 0.0021626005271338784, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:34", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 10240, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 3.457855224609375, + "memory_efficiency_ratio" : 0.0028241856195998483, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:34", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 102400, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 4.816246032714844, + "memory_efficiency_ratio" : 0.02027642469605164, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:35", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 512000, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 15.407798767089844, + "memory_efficiency_ratio" : 0.031690526166718906, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:36", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 1048576, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 36.92132568359375, + "memory_efficiency_ratio" : 0.02708461794058378, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:36", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "memory", + "data_size" : 10000000, + "concurrency" : 1, + "operations_per_second" : 0.0, + "bytes_per_second" : 0.0, + "peak_memory_mb" : 52.01019287109375, + "memory_efficiency_ratio" : 0.18336296478844313, + "avg_latency_ms" : 0.0, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:40", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 0 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1024, + "concurrency" : 2, + "operations_per_second" : 179.75696750139633, + "bytes_per_second" : 184071.13472142984, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 5.563066699999999, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:40", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1024, + "concurrency" : 4, + "operations_per_second" : 182.44180272971067, + "bytes_per_second" : 186820.40599522373, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 5.48119995, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:40", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1024, + "concurrency" : 8, + "operations_per_second" : 148.7957303124705, + "bytes_per_second" : 152366.8278399698, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 6.720622950000001, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:40", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1024, + "concurrency" : 16, + "operations_per_second" : 138.87402020689902, + "bytes_per_second" : 142206.9966918646, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 7.200770875000001, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:41", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 5120, + "concurrency" : 2, + "operations_per_second" : 168.60835201808936, + "bytes_per_second" : 863274.7623326175, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 5.9309043, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:41", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 5120, + "concurrency" : 4, + "operations_per_second" : 169.1067931382551, + "bytes_per_second" : 865826.7808678662, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 5.913423, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:41", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 5120, + "concurrency" : 8, + "operations_per_second" : 131.33023555075857, + "bytes_per_second" : 672410.8060198838, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 7.6143928, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:41", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 5120, + "concurrency" : 16, + "operations_per_second" : 105.80449559836701, + "bytes_per_second" : 541719.0174636391, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 9.4513942375, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:41", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10240, + "concurrency" : 2, + "operations_per_second" : 163.6512853605628, + "bytes_per_second" : 1675789.1620921632, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 6.1105539, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:42", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10240, + "concurrency" : 4, + "operations_per_second" : 151.44253711318964, + "bytes_per_second" : 1550771.580039062, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 6.6031645999999995, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:42", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10240, + "concurrency" : 8, + "operations_per_second" : 129.70191617038958, + "bytes_per_second" : 1328147.6215847894, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 7.709986325, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:42", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10240, + "concurrency" : 16, + "operations_per_second" : 78.00538278289041, + "bytes_per_second" : 798775.1196967978, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 12.8196281375, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:42", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 102400, + "concurrency" : 2, + "operations_per_second" : 77.9955140412126, + "bytes_per_second" : 7986740.63782017, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 12.8212502, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:42", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 102400, + "concurrency" : 4, + "operations_per_second" : 75.83197209256029, + "bytes_per_second" : 7765193.942278174, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 13.1870499, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:42", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 102400, + "concurrency" : 8, + "operations_per_second" : 68.21811219428038, + "bytes_per_second" : 6985534.688694311, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 14.658863575000002, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:43", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 102400, + "concurrency" : 16, + "operations_per_second" : 47.46238907645142, + "bytes_per_second" : 4860148.641428626, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 21.06931445, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:43", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 512000, + "concurrency" : 2, + "operations_per_second" : 24.597117237045566, + "bytes_per_second" : 1.259372402536733E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 40.6551707, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:43", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 512000, + "concurrency" : 4, + "operations_per_second" : 24.22039219935766, + "bytes_per_second" : 1.2400840806071123E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 41.287523, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:43", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 512000, + "concurrency" : 8, + "operations_per_second" : 21.207543374301284, + "bytes_per_second" : 1.0858262207642257E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 47.15303335, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:44", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 512000, + "concurrency" : 16, + "operations_per_second" : 12.701903282243414, + "bytes_per_second" : 6503374.480508628, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 78.728358875, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:44", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1048576, + "concurrency" : 2, + "operations_per_second" : 13.398087074183973, + "bytes_per_second" : 1.4048912551899534E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 74.63752059999999, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:45", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1048576, + "concurrency" : 4, + "operations_per_second" : 13.02752980594925, + "bytes_per_second" : 1.366035509380304E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 76.7605229, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:45", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1048576, + "concurrency" : 8, + "operations_per_second" : 11.442604144627765, + "bytes_per_second" : 1.1998440083557203E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 87.392693775, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:46", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 1048576, + "concurrency" : 16, + "operations_per_second" : 6.566227623799001, + "bytes_per_second" : 6885188.696852662, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 152.2944462625, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:47", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10000000, + "concurrency" : 2, + "operations_per_second" : 1.5271685382817055, + "bytes_per_second" : 1.5271685382817056E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 654.806575, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:50", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 10 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10000000, + "concurrency" : 4, + "operations_per_second" : 1.4978267092763307, + "bytes_per_second" : 1.4978267092763307E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 667.63397515, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:54", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 20 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10000000, + "concurrency" : 8, + "operations_per_second" : 1.3425611721051591, + "bytes_per_second" : 1.342561172105159E7, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 744.8450177, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:46:58", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 40 + }, { + "language" : "java", + "test_name" : "concurrent", + "data_size" : 10000000, + "concurrency" : 16, + "operations_per_second" : 0.7310966037322482, + "bytes_per_second" : 7310966.037322481, + "peak_memory_mb" : 0.0, + "memory_efficiency_ratio" : 0.0, + "avg_latency_ms" : 1367.8082963250001, + "p50_latency_ms" : 0.0, + "p95_latency_ms" : 0.0, + "p99_latency_ms" : 0.0, + "encrypt_latency_ms" : 0.0, + "decrypt_latency_ms" : 0.0, + "timestamp" : "2025-09-08 16:47:05", + "java_version" : "17.0.16", + "cpu_count" : 10, + "total_memory_gb" : 8.0, + "iterations" : 80 + } ] +} \ No newline at end of file diff --git a/db-esdk-performance-testing/benchmarks/results/raw-data/python_results_db_esdk_pre_optimizations.json b/db-esdk-performance-testing/benchmarks/results/raw-data/python_results_db_esdk_pre_optimizations.json new file mode 100644 index 000000000..4d4c11850 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/results/raw-data/python_results_db_esdk_pre_optimizations.json @@ -0,0 +1,253 @@ +{ + "metadata": { + "language": "python", + "timestamp": "2025-09-12T12:25:16.602580Z", + "python_version": "3.12.11", + "platform": "macOS-15.6.1-arm64-arm-64bit", + "cpu_count": 10, + "total_memory_gb": 32.0, + "total_tests": 12 + }, + "results": [ + { + "test_name": "throughput", + "language": "python", + "data_size": 204904, + "concurrency": 1, + "put_latency_ms": 167.2078056629592, + "get_latency_ms": 198.00823633462036, + "end_to_end_latency_ms": 365.2204166622444, + "ops_per_second": 2.7380725566741777, + "bytes_per_second": 561042.0191527657, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 366.2523329985561, + "p95_latency": 368.30887499672826, + "p99_latency": 368.30887499672826, + "timestamp": "2025-09-12T12:12:47.306340Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 204904, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 13.24461841583252, + "memory_efficiency_ratio": 0.01475404394401522, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-12T12:12:55.767866Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 204904, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 710.1961042004405, + "ops_per_second": 1.40806179319419, + "bytes_per_second": 288517.4936726623, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 714.5711250050226, + "p95_latency": 734.5971670001745, + "p99_latency": 734.5971670001745, + "timestamp": "2025-09-12T12:12:59.345614Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "throughput", + "language": "python", + "data_size": 400000, + "concurrency": 1, + "put_latency_ms": 318.18818066676613, + "get_latency_ms": 375.3186946608669, + "end_to_end_latency_ms": 693.511013664344, + "ops_per_second": 1.4419381672343494, + "bytes_per_second": 576775.2668937398, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 683.0248329933966, + "p95_latency": 731.9190419948427, + "p99_latency": 731.9190419948427, + "timestamp": "2025-09-12T12:13:03.438736Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 400000, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 25.70949649810791, + "memory_efficiency_ratio": 0.01483769729176043, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-12T12:13:20.706526Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 400000, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 1415.9630707988981, + "ops_per_second": 0.7062331077856372, + "bytes_per_second": 282493.2431142549, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 1442.751208000118, + "p95_latency": 1467.0746250048978, + "p99_latency": 1467.0746250048978, + "timestamp": "2025-09-12T12:13:27.813266Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "throughput", + "language": "python", + "data_size": 1000000, + "concurrency": 1, + "put_latency_ms": 768.3273193300314, + "get_latency_ms": 899.5437359990319, + "end_to_end_latency_ms": 1667.8751943351624, + "ops_per_second": 0.5995652452872012, + "bytes_per_second": 599565.2452872013, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 1664.4525000010617, + "p95_latency": 1686.7195410013665, + "p99_latency": 1686.7195410013665, + "timestamp": "2025-09-12T12:13:38.283071Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 1000000, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 64.04707050323486, + "memory_efficiency_ratio": 0.014890209792781736, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-12T12:14:17.869233Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 1000000, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 3327.767358098936, + "ops_per_second": 0.3005017756323186, + "bytes_per_second": 300501.77563231863, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 3323.649790996569, + "p95_latency": 3393.2539579982404, + "p99_latency": 3393.2539579982404, + "timestamp": "2025-09-12T12:14:34.544106Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "throughput", + "language": "python", + "data_size": 10000000, + "concurrency": 1, + "put_latency_ms": 7502.706972004186, + "get_latency_ms": 8922.449360999357, + "end_to_end_latency_ms": 16425.16023599698, + "ops_per_second": 0.06088220666538305, + "bytes_per_second": 608822.0666538305, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 16436.953374999575, + "p95_latency": 16444.18287499866, + "p99_latency": 16444.18287499866, + "timestamp": "2025-09-12T12:16:13.493495Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 10000000, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 639.1127805709839, + "memory_efficiency_ratio": 0.014921847057325886, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-12T12:22:34.396830Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 10000000, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 32424.851345802017, + "ops_per_second": 0.030840542315376508, + "bytes_per_second": 308405.4231537651, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 32389.564750003046, + "p95_latency": 32829.3382920092, + "p99_latency": 32829.3382920092, + "timestamp": "2025-09-12T12:25:16.602065Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + } + ] +} \ No newline at end of file diff --git a/db-esdk-performance-testing/benchmarks/results/raw-data/python_results_db_esdk_v4_post_optimizations.json b/db-esdk-performance-testing/benchmarks/results/raw-data/python_results_db_esdk_v4_post_optimizations.json new file mode 100644 index 000000000..29d80c05e --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/results/raw-data/python_results_db_esdk_v4_post_optimizations.json @@ -0,0 +1,253 @@ +{ + "metadata": { + "language": "python", + "timestamp": "2025-09-12T10:51:41.992732Z", + "python_version": "3.12.11", + "platform": "macOS-15.6.1-arm64-arm-64bit", + "cpu_count": 10, + "total_memory_gb": 32.0, + "total_tests": 12 + }, + "results": [ + { + "test_name": "throughput", + "language": "python", + "data_size": 204904, + "concurrency": 1, + "put_latency_ms": 38.35765266800687, + "get_latency_ms": 23.63131899862007, + "end_to_end_latency_ms": 61.991333333329145, + "ops_per_second": 16.131287169175277, + "bytes_per_second": 3305365.266112691, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 61.53912500303704, + "p95_latency": 63.359040999785066, + "p99_latency": 63.359040999785066, + "timestamp": "2025-09-12T10:49:38.201137Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 204904, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 13.243301391601562, + "memory_efficiency_ratio": 0.014755511209072798, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-12T10:49:39.904080Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 204904, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 123.04774999865913, + "ops_per_second": 8.126926335596524, + "bytes_per_second": 1665239.7138690702, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 122.60720799531555, + "p95_latency": 147.29774999432266, + "p99_latency": 147.29774999432266, + "timestamp": "2025-09-12T10:49:40.533767Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "throughput", + "language": "python", + "data_size": 400000, + "concurrency": 1, + "put_latency_ms": 71.59037466529601, + "get_latency_ms": 40.713361333473586, + "end_to_end_latency_ms": 112.30652766729084, + "ops_per_second": 8.904201926378756, + "bytes_per_second": 3561680.7705515022, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 112.01312499906635, + "p95_latency": 113.24574999889592, + "p99_latency": 113.24574999889592, + "timestamp": "2025-09-12T10:49:41.216402Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 400000, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 25.70802879333496, + "memory_efficiency_ratio": 0.014838544395181301, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-12T10:49:44.201824Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 400000, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 226.31782080061384, + "ops_per_second": 4.418564991755558, + "bytes_per_second": 1767425.996702223, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 228.39750000275671, + "p95_latency": 253.42125000315718, + "p99_latency": 253.42125000315718, + "timestamp": "2025-09-12T10:49:45.357786Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "throughput", + "language": "python", + "data_size": 1000000, + "concurrency": 1, + "put_latency_ms": 173.76462533381223, + "get_latency_ms": 94.61969433323247, + "end_to_end_latency_ms": 268.38762466650223, + "ops_per_second": 3.7259542098582132, + "bytes_per_second": 3725954.209858213, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 268.84995799628086, + "p95_latency": 270.6690830018488, + "p99_latency": 270.6690830018488, + "timestamp": "2025-09-12T10:49:46.967975Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 1000000, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 64.0456314086914, + "memory_efficiency_ratio": 0.014890544373286173, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-12T10:49:54.007710Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 1000000, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 541.3238918001298, + "ops_per_second": 1.8473228600248532, + "bytes_per_second": 1847322.8600248531, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 540.2384170010919, + "p95_latency": 579.3557500001043, + "p99_latency": 579.3557500001043, + "timestamp": "2025-09-12T10:49:56.739037Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "throughput", + "language": "python", + "data_size": 10000000, + "concurrency": 1, + "put_latency_ms": 1657.4462220014539, + "get_latency_ms": 853.7097499987188, + "end_to_end_latency_ms": 2511.159416998756, + "ops_per_second": 0.39822242794731155, + "bytes_per_second": 3982224.2794731157, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 2507.6615840007435, + "p95_latency": 2533.201124999323, + "p99_latency": 2533.201124999323, + "timestamp": "2025-09-12T10:50:11.988601Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 10000000, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 639.111569404602, + "memory_efficiency_ratio": 0.014921875335392463, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-12T10:51:16.824011Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 10000000, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 5012.676012698648, + "ops_per_second": 0.1994942416918015, + "bytes_per_second": 1994942.4169180149, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 5089.780249996693, + "p95_latency": 5146.593417004624, + "p99_latency": 5146.593417004624, + "timestamp": "2025-09-12T10:51:41.992456Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + } + ] +} \ No newline at end of file diff --git a/db-esdk-performance-testing/benchmarks/results/raw-data/python_results_db_esdk_v4_robins_optimizations.json b/db-esdk-performance-testing/benchmarks/results/raw-data/python_results_db_esdk_v4_robins_optimizations.json new file mode 100644 index 000000000..a3d4379ea --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/results/raw-data/python_results_db_esdk_v4_robins_optimizations.json @@ -0,0 +1,253 @@ +{ + "metadata": { + "language": "python", + "timestamp": "2025-09-25T17:51:02.971634Z", + "python_version": "3.12.11", + "platform": "macOS-15.6.1-arm64-arm-64bit", + "cpu_count": 10, + "total_memory_gb": 32.0, + "total_tests": 12 + }, + "results": [ + { + "test_name": "throughput", + "language": "python", + "data_size": 204904, + "concurrency": 1, + "put_latency_ms": 15.68620800003373, + "get_latency_ms": 12.070068999984565, + "end_to_end_latency_ms": 27.75933366664655, + "ops_per_second": 36.02391945025402, + "bytes_per_second": 7381445.19103485, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 27.796749999993153, + "p95_latency": 28.080541999997877, + "p99_latency": 28.080541999997877, + "timestamp": "2025-09-25T17:50:42.047505Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 204904, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 6.759592056274414, + "memory_efficiency_ratio": 0.028908798120075973, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-25T17:50:42.548299Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 204904, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 52.13440840000203, + "ops_per_second": 19.18119013315515, + "bytes_per_second": 3930302.5830440233, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 54.78004199994757, + "p95_latency": 62.64700000008361, + "p99_latency": 62.64700000008361, + "timestamp": "2025-09-25T17:50:42.822363Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "throughput", + "language": "python", + "data_size": 400000, + "concurrency": 1, + "put_latency_ms": 25.567041999996338, + "get_latency_ms": 17.596499666675907, + "end_to_end_latency_ms": 43.16740266669209, + "ops_per_second": 23.165628187576793, + "bytes_per_second": 9266251.275030717, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 43.29979099998127, + "p95_latency": 43.625875000088854, + "p99_latency": 43.625875000088854, + "timestamp": "2025-09-25T17:50:43.080357Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 400000, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 13.084304809570312, + "memory_efficiency_ratio": 0.029154756948453223, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-25T17:50:43.655014Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 400000, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 81.18548319999945, + "ops_per_second": 12.317473033159292, + "bytes_per_second": 4926989.213263717, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 85.25654200002464, + "p95_latency": 100.81354099997952, + "p99_latency": 100.81354099997952, + "timestamp": "2025-09-25T17:50:44.096237Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "throughput", + "language": "python", + "data_size": 1000000, + "concurrency": 1, + "put_latency_ms": 55.89075000000321, + "get_latency_ms": 33.06997233331307, + "end_to_end_latency_ms": 88.96444399999837, + "ops_per_second": 11.240445677376664, + "bytes_per_second": 11240445.677376665, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 88.89733299997715, + "p95_latency": 89.92429099998844, + "p99_latency": 89.92429099998844, + "timestamp": "2025-09-25T17:50:44.635947Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 1000000, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 32.53925132751465, + "memory_efficiency_ratio": 0.02930842835956213, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-25T17:50:45.457801Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 1000000, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 174.481908499979, + "ops_per_second": 5.731253220445605, + "bytes_per_second": 5731253.220445605, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 171.81487499999548, + "p95_latency": 198.4482499999558, + "p99_latency": 198.4482499999558, + "timestamp": "2025-09-25T17:50:46.385180Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "throughput", + "language": "python", + "data_size": 10000000, + "concurrency": 1, + "put_latency_ms": 486.46387499998883, + "get_latency_ms": 274.04104166665394, + "end_to_end_latency_ms": 760.5099306666337, + "ops_per_second": 1.314907221689319, + "bytes_per_second": 13149072.216893189, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 760.5407919999152, + "p95_latency": 763.0202499999541, + "p99_latency": 763.0202499999541, + "timestamp": "2025-09-25T17:50:51.015023Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 10000000, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 324.3635416030884, + "memory_efficiency_ratio": 0.029401402873237396, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-25T17:50:55.215358Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 10000000, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 1500.161562400001, + "ops_per_second": 0.6665948688887693, + "bytes_per_second": 6665948.688887693, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 1488.8832090000506, + "p95_latency": 1563.6509160000287, + "p99_latency": 1563.6509160000287, + "timestamp": "2025-09-25T17:51:02.971310Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + } + ] +} \ No newline at end of file diff --git a/db-esdk-performance-testing/benchmarks/results/raw-data/python_results_ddbec_v3_legacy.json b/db-esdk-performance-testing/benchmarks/results/raw-data/python_results_ddbec_v3_legacy.json new file mode 100644 index 000000000..8bdef4e56 --- /dev/null +++ b/db-esdk-performance-testing/benchmarks/results/raw-data/python_results_ddbec_v3_legacy.json @@ -0,0 +1,253 @@ +{ + "metadata": { + "language": "python", + "timestamp": "2025-09-12T12:25:44.967261Z", + "python_version": "3.12.11", + "platform": "macOS-15.6.1-arm64-arm-64bit", + "cpu_count": 10, + "total_memory_gb": 32.0, + "total_tests": 12 + }, + "results": [ + { + "test_name": "throughput", + "language": "python", + "data_size": 204904, + "concurrency": 1, + "put_latency_ms": 0.40786067256703973, + "get_latency_ms": 0.2507083360493804, + "end_to_end_latency_ms": 0.6604583322769031, + "ops_per_second": 1514.1000592006174, + "bytes_per_second": 310245158.5304433, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 0.6597500032512471, + "p95_latency": 0.6697920034639537, + "p99_latency": 0.6697920034639537, + "timestamp": "2025-09-12T12:25:43.271894Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 204904, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 0.9861278533935547, + "memory_efficiency_ratio": 0.19816059495372473, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-12T12:25:43.485646Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 204904, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.6651336036156863, + "ops_per_second": 1503.457342350424, + "bytes_per_second": 308064423.2769713, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 0.6468750070780516, + "p95_latency": 0.7265839958563447, + "p99_latency": 0.7265839958563447, + "timestamp": "2025-09-12T12:25:43.493817Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "throughput", + "language": "python", + "data_size": 400000, + "concurrency": 1, + "put_latency_ms": 0.723847338425306, + "get_latency_ms": 0.38984733691904694, + "end_to_end_latency_ms": 1.117694332303169, + "ops_per_second": 894.6989987319315, + "bytes_per_second": 357879599.4927726, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 1.1477499938337132, + "p95_latency": 1.1488750024000183, + "p99_latency": 1.1488750024000183, + "timestamp": "2025-09-12T12:25:43.502440Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 400000, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 1.9160442352294922, + "memory_efficiency_ratio": 0.19909233803091705, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-12T12:25:43.718342Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 400000, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 1.1325040002702735, + "ops_per_second": 882.9990885342115, + "bytes_per_second": 353199635.4136846, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 1.1431669990997761, + "p95_latency": 1.2219580094097182, + "p99_latency": 1.2219580094097182, + "timestamp": "2025-09-12T12:25:43.731958Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "throughput", + "language": "python", + "data_size": 1000000, + "concurrency": 1, + "put_latency_ms": 1.705250329299209, + "get_latency_ms": 0.9230143332388252, + "end_to_end_latency_ms": 2.6354859971130886, + "ops_per_second": 379.4366583982613, + "bytes_per_second": 379436658.39826125, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 2.6274160045431927, + "p95_latency": 2.6552499912213534, + "p99_latency": 2.6552499912213534, + "timestamp": "2025-09-12T12:25:43.752654Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 1000000, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 4.777067184448242, + "memory_efficiency_ratio": 0.19963594389271724, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-12T12:25:43.975026Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 1000000, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 2.7947334019700065, + "ops_per_second": 357.8158830087694, + "bytes_per_second": 357815883.0087694, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 2.730791995418258, + "p95_latency": 3.3408330054953694, + "p99_latency": 3.3408330054953694, + "timestamp": "2025-09-12T12:25:44.007781Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "throughput", + "language": "python", + "data_size": 10000000, + "concurrency": 1, + "put_latency_ms": 17.675805332449574, + "get_latency_ms": 9.190846996110244, + "end_to_end_latency_ms": 27.202583330411773, + "ops_per_second": 36.761214471936796, + "bytes_per_second": 367612144.719368, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 27.09066600073129, + "p95_latency": 27.47549999912735, + "p99_latency": 27.47549999912735, + "timestamp": "2025-09-12T12:25:44.218064Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "memory", + "language": "python", + "data_size": 10000000, + "concurrency": 1, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 0.0, + "ops_per_second": 0.0, + "bytes_per_second": 0.0, + "peak_memory_mb": 47.69241142272949, + "memory_efficiency_ratio": 0.19996353464982125, + "p50_latency": 0.0, + "p95_latency": 0.0, + "p99_latency": 0.0, + "timestamp": "2025-09-12T12:25:44.603571Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + }, + { + "test_name": "concurrency", + "language": "python", + "data_size": 10000000, + "concurrency": 2, + "put_latency_ms": 0.0, + "get_latency_ms": 0.0, + "end_to_end_latency_ms": 60.67753729730612, + "ops_per_second": 16.480563393669517, + "bytes_per_second": 164805633.93669516, + "peak_memory_mb": 0.0, + "memory_efficiency_ratio": 0.0, + "p50_latency": 57.336290992680006, + "p95_latency": 89.28437498980202, + "p99_latency": 89.28437498980202, + "timestamp": "2025-09-12T12:25:44.966768Z", + "python_version": "3.12.11", + "cpu_count": 10, + "total_memory_gb": 32.0 + } + ] +} \ No newline at end of file