Struct EncryptionBenchmark 

pub struct EncryptionBenchmark {
    pub algorithm: EncryptionAlgorithm,
    pub throughput_mbps: f64,
    pub latency: Duration,
    pub memory_usage_mb: f64,
    pub cpu_usage_percent: f64,
    pub file_size_mb: f64,
    pub timestamp: DateTime<Utc>,
}

Encryption performance benchmark results for algorithm comparison and optimization.

EncryptionBenchmark is a value object that captures comprehensive performance metrics for encryption operations, enabling data-driven decisions about algorithm selection, resource allocation, and system optimization in the adaptive pipeline.

Key Features

• Comprehensive Metrics: Captures throughput, latency, memory usage, and CPU utilization
• Algorithm Tracking: Associates metrics with specific encryption algorithms
• Temporal Context: Includes RFC3339-compliant timestamp for trend analysis
• Immutable Snapshot: Represents performance at a specific point in time
• Serialization Ready: Full serde support for persistence and data exchange

Performance Metrics

• throughput_mbps: Data processing rate in megabytes per second
• latency: Time delay from operation start to completion
• memory_usage_mb: Peak memory consumption during encryption
• cpu_usage_percent: CPU utilization percentage during operation
• file_size_mb: Size of the file being encrypted (for context)

Usage Patterns

Integration with Monitoring

The benchmark integrates with the pipeline’s monitoring and optimization systems:

• Performance Tracking: Historical performance data for trend analysis
• Algorithm Selection: Data-driven algorithm choice based on workload characteristics
• Resource Planning: Memory and CPU requirement estimation
• Optimization Feedback: Performance regression detection and optimization validation

Thread Safety

EncryptionBenchmark is thread-safe through immutability. All fields are read-only after construction, making it safe to share across threads without synchronization.

Cross-Language Compatibility

The benchmark data structure maps well to other languages:

• JSON: Direct serialization for REST APIs and configuration
• Go: Struct with similar field types and JSON tags
• Python: Dataclass or NamedTuple with datetime handling
• Database: Relational table with appropriate column types

Performance Considerations

• Lightweight value object with minimal memory overhead
• Efficient serialization through serde derive macros
• Immutable design eliminates defensive copying
• Timestamp generation uses UTC to avoid timezone complexity

Fields

algorithm: EncryptionAlgorithm

The encryption algorithm that was benchmarked

throughput_mbps: f64

Data processing throughput in megabytes per second

latency: Duration

Operation latency from start to completion

memory_usage_mb: f64

Peak memory usage during encryption in megabytes

cpu_usage_percent: f64

CPU utilization percentage during the operation

file_size_mb: f64

Size of the file being encrypted in megabytes (for context)

timestamp: DateTime<Utc>

RFC3339-compliant timestamp when the benchmark was recorded

Implementations

impl EncryptionBenchmark

pub fn new( algorithm: EncryptionAlgorithm, throughput_mbps: f64, latency: Duration, memory_usage_mb: f64, cpu_usage_percent: f64, file_size_mb: f64, ) -> Self

Creates a new encryption benchmark with the specified performance metrics.

The benchmark captures a snapshot of encryption performance at the current time, providing comprehensive metrics for algorithm comparison and optimization decisions.

Arguments

• algorithm - The encryption algorithm that was benchmarked
• throughput_mbps - Data processing rate in megabytes per second
• latency - Operation latency from start to completion
• memory_usage_mb - Peak memory consumption during encryption
• cpu_usage_percent - CPU utilization percentage during operation
• file_size_mb - Size of the file being encrypted (for context)

Returns

A new EncryptionBenchmark instance with the current UTC timestamp.

Examples

Performance Metrics Guidelines

• Throughput: Measure sustained data processing rate, not peak burst
• Latency: Include full operation time from API call to completion
• Memory: Capture peak usage, not average or final usage
• CPU: Measure during active encryption, not including I/O wait
• File Size: Provide context for performance scaling analysis

Trait Implementations

impl Clone for EncryptionBenchmark

fn clone(&self) -> EncryptionBenchmark

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EncryptionBenchmark

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EncryptionBenchmark

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EncryptionBenchmark

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.