wireframe 0.3.0

Simplify building servers and clients for custom binary protocols.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Criterion benchmarks for codec throughput, latency, and fragmentation overhead.
//!
//! This benchmark suite covers:
//! - encode and decode throughput/latency for small and large payloads,
//! - default and custom codec paths (`LengthDelimitedFrameCodec`, `HotlineFrameCodec`), and
//! - fragmented versus unfragmented payload-wrapping overhead.

use criterion::{BenchmarkId, Criterion, Throughput, black_box};

#[path = "../tests/common/codec_benchmark_support.rs"]
mod codec_benchmark_support;

#[path = "../tests/common/codec_fragmentation_benchmark_support.rs"]
mod codec_fragmentation_benchmark_support;

use codec_benchmark_support::{
    Measurement,
    PayloadClass,
    VALIDATION_ITERATIONS,
    benchmark_workloads,
    measure_decode,
    measure_encode,
};
use codec_fragmentation_benchmark_support::{
    FRAGMENT_PAYLOAD_CAP_BYTES,
    MeasurementExt as _,
    measure_fragmentation_overhead,
    measure_fragmented_wrap,
    measure_unfragmented_wrap,
};

fn fragmented_measurement(payload_class: PayloadClass, iterations: u64) -> Measurement {
    match measure_fragmented_wrap(payload_class, iterations, FRAGMENT_PAYLOAD_CAP_BYTES) {
        Ok(measurement) => measurement,
        Err(err) => panic!("fragmented benchmark setup failed: {err}"),
    }
}

fn benchmark_encode(c: &mut Criterion) {
    let mut group = c.benchmark_group("codec/encode");

    for workload in benchmark_workloads() {
        let bytes = workload.payload_class.len() as u64;
        group.throughput(Throughput::Bytes(bytes));
        group.bench_function(BenchmarkId::from_parameter(workload.label()), |b| {
            b.iter_custom(|iters| match measure_encode(workload, iters) {
                Ok(measurement) => {
                    black_box(measurement.payload_bytes);
                    measurement.elapsed
                }
                Err(err) => panic!("encode benchmark setup failed: {err}"),
            });
        });
    }

    group.finish();
}

fn benchmark_decode(c: &mut Criterion) {
    let mut group = c.benchmark_group("codec/decode");

    for workload in benchmark_workloads() {
        let bytes = workload.payload_class.len() as u64;
        group.throughput(Throughput::Bytes(bytes));
        group.bench_function(BenchmarkId::from_parameter(workload.label()), |b| {
            b.iter_custom(|iters| match measure_decode(workload, iters) {
                Ok(measurement) => {
                    black_box(measurement.payload_bytes);
                    measurement.elapsed
                }
                Err(err) => panic!("decode benchmark setup failed: {err}"),
            });
        });
    }

    group.finish();
}

fn benchmark_fragmentation_overhead(c: &mut Criterion) {
    let mut group = c.benchmark_group("codec/fragmentation_overhead");

    for payload_class in [PayloadClass::Small, PayloadClass::Large] {
        let baseline = match measure_fragmentation_overhead(
            payload_class,
            VALIDATION_ITERATIONS,
            FRAGMENT_PAYLOAD_CAP_BYTES,
        ) {
            Ok(result) => result,
            Err(err) => panic!("fragmentation baseline setup failed: {err}"),
        };
        let Some(ratio) = baseline.nanos_ratio() else {
            panic!(
                "fragmentation baseline has no valid nanos_ratio for payload_class={}",
                payload_class.label()
            );
        };
        black_box(baseline.unfragmented.nanos_per_op());
        black_box(baseline.fragmented.nanos_per_op());

        group.bench_function(
            BenchmarkId::new("unfragmented", payload_class.label()),
            |b| {
                b.iter_custom(|iters| {
                    let measurement = measure_unfragmented_wrap(payload_class, iters);
                    black_box(measurement.payload_bytes);
                    measurement.elapsed
                });
            },
        );

        group.bench_function(
            BenchmarkId::new(
                "fragmented",
                format!("{}_ratio_{ratio:.3}", payload_class.label()),
            ),
            |b| {
                b.iter_custom(|iters| {
                    let measurement = fragmented_measurement(payload_class, iters);
                    black_box(measurement.payload_bytes);
                    measurement.elapsed
                });
            },
        );
    }

    group.finish();
}

/// Entrypoint for codec throughput, latency, and fragmentation benchmarks.
fn main() {
    let mut criterion = Criterion::default().configure_from_args();
    benchmark_encode(&mut criterion);
    benchmark_decode(&mut criterion);
    benchmark_fragmentation_overhead(&mut criterion);
    criterion.final_summary();
}