auto commit

Author: rishav-karanjit

db-esdk-performance-testing/benchmarks/config/test-scenarios.yaml

@@ -0,0 +1,47 @@
+# 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
+    - 400000 # 400KB
+
+# Quick test configuration (reduced test set for faster execution)
+quick_config:
+  data_sizes:
+    small:
+      - 102400 # 100KB - within DynamoDB's 400KB limit
+  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"

db-esdk-performance-testing/benchmarks/go/README.md

@@ -0,0 +1,45 @@
+# ESDK Go Benchmark
+
+Performance benchmark suite for the AWS Encryption SDK (ESDK) Go implementation.
+
+## Quick Start
+
+```bash
+# Run quick benchmark
+go run . --config ../../config/test-scenarios.yaml --quick
+
+# Run full benchmark
+go run . --config ../../config/test-scenarios.yaml
+```
+
+## Build
+
+```bash
+# Build release binary
+go build -o esdk-benchmark .
+
+# Run built binary
+./esdk-benchmark --quick
+```
+
+## Configuration
+
+The benchmark uses YAML configuration files. See `../../config/test-scenarios.yaml` for the full configuration format.
+
+### Quick Mode
+
+Quick mode runs a subset of tests with reduced iterations:
+
+- Only runs test types specified in `quick_config.test_types`
+- Uses smaller data sizes from `quick_config.data_sizes.small`
+- Fewer iterations: `quick_config.iterations.measurement`
+
+## Test Types
+
+- **throughput**: Measures operations per second and latency
+- **memory**: Measures peak memory usage during operations
+- **concurrency**: Tests performance under concurrent load
+
+## Output
+
+Results are saved to JSON format in `../../results/raw-data/go_results.json` by default.

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

@@ -0,0 +1,172 @@
+// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package benchmark
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"runtime/metrics"
+	"strconv"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
+)
+
+// === Helper Functions ===
+
+// runBatchPutGetCycle performs a BatchWriteItem-BatchGetItem cycle with 25 items and measures performance
+func (b *DBESDKBenchmark) runBatchPutGetCycle(data []byte) (float64, float64, error) {
+	ctx := context.Background()
+	tableName := b.Config.TableName
+
+	// Create 25 write requests with same data, different sort_key
+	var items []map[string]types.AttributeValue
+
+	for i := 0; i < 25; i++ {
+		item := map[string]types.AttributeValue{
+			"partition_key": &types.AttributeValueMemberS{Value: "benchmark-test"},
+			"sort_key":      &types.AttributeValueMemberN{Value: strconv.Itoa(i)},
+			"attribute1": &types.AttributeValueMemberM{Value: map[string]types.AttributeValue{
+				"data": &types.AttributeValueMemberB{Value: data},
+			}},
+			"attribute2":  &types.AttributeValueMemberS{Value: "sign me!"},
+			":attribute3": &types.AttributeValueMemberS{Value: "ignore me!"},
+		}
+		items = append(items, item)
+	}
+
+	var writeRequests []types.WriteRequest
+	for _, item := range items {
+		writeRequests = append(writeRequests, types.WriteRequest{
+			PutRequest: &types.PutRequest{Item: item},
+		})
+	}
+
+	// BatchWriteItem
+	batchWriteStart := time.Now()
+	_, err := b.DbesdkClient.BatchWriteItem(ctx, &dynamodb.BatchWriteItemInput{
+		RequestItems: map[string][]types.WriteRequest{tableName: writeRequests},
+	})
+	if err != nil {
+		return 0, 0, fmt.Errorf("BatchWriteItem failed: %w", err)
+	}
+	batchWriteDuration := time.Since(batchWriteStart).Seconds() * 1000
+
+	// Create 25 keys for BatchGetItem
+	var keys []map[string]types.AttributeValue
+	for i := 0; i < 25; i++ {
+		keys = append(keys, map[string]types.AttributeValue{
+			"partition_key": &types.AttributeValueMemberS{Value: "benchmark-test"},
+			"sort_key":      &types.AttributeValueMemberN{Value: strconv.Itoa(i)},
+		})
+	}
+
+	// BatchGetItem
+	batchGetStart := time.Now()
+	result, err := b.DbesdkClient.BatchGetItem(ctx, &dynamodb.BatchGetItemInput{
+		RequestItems: map[string]types.KeysAndAttributes{
+			tableName: {Keys: keys, ConsistentRead: aws.Bool(true)},
+		},
+	})
+	if err != nil {
+		return 0, 0, fmt.Errorf("BatchGetItem failed: %w", err)
+	}
+	batchGetDuration := time.Since(batchGetStart).Seconds() * 1000
+
+	// Verify 25 items retrieved with correct data size
+	returnedItems := result.Responses[tableName]
+	if len(returnedItems) != 25 {
+		return 0, 0, fmt.Errorf("expected 25 items, got %d", len(returnedItems))
+	}
+
+	// Verify each returned item
+	for i, item := range returnedItems {
+		if _, ok := item["attribute1"]; !ok {
+			return 0, 0, fmt.Errorf("item %d missing attribute1", i)
+		}
+
+		// Verify attribute1
+		if attr1, ok := item["attribute1"].(*types.AttributeValueMemberM); ok {
+			if dataAttr, ok := attr1.Value["data"].(*types.AttributeValueMemberB); ok {
+				if !bytes.Equal(dataAttr.Value, data) {
+					return 0, 0, fmt.Errorf("item %d data mismatch", i)
+				}
+			}
+		}
+
+		// Verify attribute2 value
+		if attr2, ok := item["attribute2"].(*types.AttributeValueMemberS); ok {
+			if attr2.Value != "sign me!" {
+				return 0, 0, fmt.Errorf("item %d attribute2 mismatch: got %s", i, attr2.Value)
+			}
+		} else {
+			return 0, 0, fmt.Errorf("item %d attribute2 wrong type", i)
+		}
+
+		// Verify :attribute3 value
+		if attr3, ok := item[":attribute3"].(*types.AttributeValueMemberS); ok {
+			if attr3.Value != "ignore me!" {
+				return 0, 0, fmt.Errorf("item %d :attribute3 mismatch: got %s", i, attr3.Value)
+			}
+		} else {
+			return 0, 0, fmt.Errorf("item %d :attribute3 wrong type", i)
+		}
+	}
+
+	return batchWriteDuration, batchGetDuration, nil
+}
+
+// shouldRunTestType checks if a test type should be run based on quick config
+func (b *DBESDKBenchmark) shouldRunTestType(testType string) bool {
+	if b.Config.QuickConfig == nil || len(b.Config.QuickConfig.TestTypes) == 0 {
+		return true
+	}
+
+	for _, allowedType := range b.Config.QuickConfig.TestTypes {
+		if allowedType == testType {
+			return true
+		}
+	}
+	return false
+}
+
+// === Memory Test Implementation ===
+
+// sampleMemoryContinuously runs continuous memory sampling during operation
+func (b *DBESDKBenchmark) sampleMemoryContinuously(beforeHeap, beforeAllocs uint64, stopChan chan bool) []MemorySample {
+	var samples []MemorySample
+	ticker := time.NewTicker(SamplingIntervalMs * time.Millisecond)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-stopChan:
+			return samples
+		case <-ticker.C:
+			var currentSamples [2]metrics.Sample
+			currentSamples[0].Name = "/memory/classes/heap/objects:bytes"
+			currentSamples[1].Name = "/gc/heap/allocs:bytes"
+			metrics.Read(currentSamples[:])
+
+			var heapDelta, allocsDelta uint64
+			if currentSamples[0].Value.Uint64() > beforeHeap {
+				heapDelta = currentSamples[0].Value.Uint64() - beforeHeap
+			}
+			if currentSamples[1].Value.Uint64() > beforeAllocs {
+				allocsDelta = currentSamples[1].Value.Uint64() - beforeAllocs
+			}
+
+			sample := MemorySample{
+				Timestamp:        time.Now(),
+				HeapMB:           float64(heapDelta) / (1024 * 1024),
+				MetricsAllocsMB:  float64(allocsDelta) / (1024 * 1024),
+				MemStatsAllocsMB: 0,
+			}
+			samples = append(samples, sample)
+		}
+	}
+}

db-esdk-performance-testing/benchmarks/go/benchmark/config.go

@@ -0,0 +1,67 @@
+// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package benchmark
+
+import (
+	"fmt"
+	"os"
+
+	"gopkg.in/yaml.v3"
+)
+
+type KeyringType string
+
+const (
+	RawAESKeying KeyringType = "raw-aes"
+)
+
+// TestConfig represents the configuration for benchmark tests
+type TestConfig struct {
+	DataSizes struct {
+		Small  []int `yaml:"small"`
+		Medium []int `yaml:"medium"`
+		Large  []int `yaml:"large"`
+	} `yaml:"data_sizes"`
+	Iterations struct {
+		Warmup      int `yaml:"warmup"`
+		Measurement int `yaml:"measurement"`
+	} `yaml:"iterations"`
+	ConcurrencyLevels []int        `yaml:"concurrency_levels"`
+	QuickConfig       *QuickConfig `yaml:"quick_config"`
+	TableName         string       `yaml:"table_name"`
+	Keyring           KeyringType  `yaml:"keyring"`
+}
+
+// QuickConfig represents the quick test configuration
+type QuickConfig struct {
+	DataSizes struct {
+		Small []int `yaml:"small"`
+	} `yaml:"data_sizes"`
+	Iterations struct {
+		Warmup      int `yaml:"warmup"`
+		Measurement int `yaml:"measurement"`
+	} `yaml:"iterations"`
+	ConcurrencyLevels []int    `yaml:"concurrency_levels"`
+	TestTypes         []string `yaml:"test_types"`
+}
+
+// LoadConfig loads the test configuration from YAML file
+func LoadConfig(configPath string) (TestConfig, error) {
+	var config TestConfig
+
+	if _, err := os.Stat(configPath); os.IsNotExist(err) {
+		return config, fmt.Errorf("config file not found: %s", configPath)
+	}
+
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		return config, fmt.Errorf("failed to read config file: %w", err)
+	}
+
+	if err := yaml.Unmarshal(data, &config); err != nil {
+		return config, fmt.Errorf("failed to parse config file: %w", err)
+	}
+
+	return config, nil
+}