ramqp 0.8.2

Async AMQP 1.0 client for Rust on tokio — connects to RabbitMQ 4.x, ActiveMQ Artemis, and other AMQP 1.0 brokers.
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

//! Codec + framing micro-benchmarks (criterion).
//!
//! ```sh
//! cargo bench --bench codec
//! ```

use bytes::{Bytes, BytesMut};
use criterion::{Criterion, criterion_group, criterion_main};
use std::hint::black_box;

use ramqp::Message;
use ramqp::codec::{from_slice, to_vec};
use ramqp::transport::frame::{decode_frame, encode_amqp_frame};
use ramqp::types::performatives::{Open, Performative, Transfer};

fn bench_message(c: &mut Criterion) {
    let msg = Message::data(Bytes::from(vec![0u8; 1024]));
    let encoded = to_vec(&msg);

    c.bench_function("encode_message_1k", |b| {
        b.iter(|| black_box(to_vec(black_box(&msg))))
    });
    c.bench_function("decode_message_1k", |b| {
        b.iter(|| {
            let m: Message = from_slice(black_box(&encoded)).unwrap();
            black_box(m)
        })
    });
}

fn bench_performative(c: &mut Criterion) {
    let open = Performative::Open(Open::new("bench-container"));
    let bytes = to_vec(&open);
    c.bench_function("encode_open", |b| {
        b.iter(|| black_box(to_vec(black_box(&open))))
    });
    c.bench_function("decode_open", |b| {
        b.iter(|| {
            let p: Performative = from_slice(black_box(&bytes)).unwrap();
            black_box(p)
        })
    });
}

fn bench_framing(c: &mut Criterion) {
    let transfer = Performative::Transfer(Transfer {
        handle: 0,
        delivery_id: Some(1),
        delivery_tag: Some(Bytes::from_static(b"tag")),
        ..Default::default()
    });
    let payload = vec![0u8; 1024];

    c.bench_function("encode_transfer_frame_1k", |b| {
        let mut buf = BytesMut::with_capacity(2048);
        b.iter(|| {
            buf.clear();
            encode_amqp_frame(&mut buf, 0, black_box(&transfer), Some(black_box(&payload)));
            black_box(&buf);
        })
    });

    let mut framed = BytesMut::new();
    encode_amqp_frame(&mut framed, 0, &transfer, Some(&payload));
    c.bench_function("decode_transfer_frame_1k", |b| {
        b.iter(|| {
            let mut src = framed.clone();
            let frame = decode_frame(&mut src, 1 << 20).unwrap();
            black_box(frame)
        })
    });
}

criterion_group!(benches, bench_message, bench_performative, bench_framing);
criterion_main!(benches);