barehttp 0.1.0

Blocking HTTP/1.1 client for no_std + alloc
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

//! Criterion: adversarial / pathological inputs (short samples for CI).
//!
//! Env:
//! - `BAREHTTP_ADV_SAMPLE_SIZE`: Criterion sample size (default 10)
//! - `BAREHTTP_ADV_MEASURE_SECS`: measurement seconds (default 0.5)
#![allow(clippy::unwrap_used, clippy::expect_used)]

use barehttp::Response;
use criterion::{Criterion, Throughput, criterion_group, criterion_main};
use std::env;
use std::hint::black_box;
use std::time::Duration;

fn sample_size() -> usize {
  env::var("BAREHTTP_ADV_SAMPLE_SIZE")
    .ok()
    .and_then(|s| s.parse().ok())
    .unwrap_or(10)
    .clamp(10, 100)
}

fn measure_secs() -> f64 {
  env::var("BAREHTTP_ADV_MEASURE_SECS")
    .ok()
    .and_then(|s| s.parse().ok())
    .unwrap_or(0.5_f64)
    .clamp(0.2_f64, 5.0_f64)
}

fn many_small_headers() -> Vec<u8> {
  let mut msg = b"HTTP/1.1 200 OK\r\n".to_vec();
  for i in 0..128 {
    msg.extend_from_slice(format!("X-H-{i}: v\r\n").as_bytes());
  }
  msg.extend_from_slice(b"Content-Length: 0\r\n\r\n");
  msg
}

fn pathological_chunked() -> Vec<u8> {
  // Many tiny chunks within a modest total size.
  let mut msg = b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n".to_vec();
  for _ in 0..64 {
    msg.extend_from_slice(b"1\r\nx\r\n");
  }
  msg.extend_from_slice(b"0\r\n\r\n");
  msg
}

fn medium_body_cl() -> Vec<u8> {
  let body = vec![b'y'; 4096];
  let mut msg = format!(
    "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
    body.len()
  )
  .into_bytes();
  msg.extend_from_slice(&body);
  msg
}

/// Accumulate `data` one byte at a time, then `Response::parse` the full buffer.
/// Measures parse cost of medium bodies; socket-level `max_read=1` lives in
/// transport unit tests.
fn fragmented_accumulate_then_parse(data: &[u8]) {
  let mut acc = Vec::with_capacity(data.len());
  for &b in data {
    acc.push(b);
  }
  let r = Response::parse(black_box(acc.as_slice())).unwrap();
  black_box(r.body().len());
}

fn adversarial_group(c: &mut Criterion) {
  let mut group = c.benchmark_group("adversarial");
  group.sample_size(sample_size());
  group.warm_up_time(Duration::from_millis(200));
  group.measurement_time(Duration::from_secs_f64(measure_secs()));

  let many = many_small_headers();
  group.throughput(Throughput::Bytes(many.len() as u64));
  group.bench_function("many_small_headers", |b| {
    b.iter(|| {
      let r = Response::parse(black_box(many.as_slice())).unwrap();
      black_box(r.headers().len());
    });
  });

  let chunked = pathological_chunked();
  group.throughput(Throughput::Bytes(chunked.len() as u64));
  group.bench_function("pathological_chunked_tiny", |b| {
    b.iter(|| {
      let r = Response::parse(black_box(chunked.as_slice())).unwrap();
      black_box(r.body().len());
    });
  });

  let medium = medium_body_cl();
  group.throughput(Throughput::Bytes(medium.len() as u64));
  group.bench_function("medium_body_byte_accumulate", |b| {
    b.iter(|| fragmented_accumulate_then_parse(black_box(medium.as_slice())));
  });

  group.finish();
}

criterion_group!(benches, adversarial_group);
criterion_main!(benches);