rs-netty 0.2.2

A Tokio-native typed TCP/UDP pipeline framework inspired by Netty.
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

# Benchmarks

This directory contains comparable benchmark harnesses for:

- `rs-netty`
- bare `tokio`
- Java `netty`

The wire protocols are aligned across implementations:

- `line`: TCP line echo, `payload + "\n"`
- `len`: TCP length-field echo, `u32be length + payload`
- `udp`: UDP datagram echo

## Run all benchmarks

```bash
python3 benchmarks/run.py \
  --impls rs-netty tokio netty \
  --protocols line len udp \
  --connections 100 \
  --messages 1000000 \
  --payload 128 \
  --in-flight 16 \
  --output-dir benchmarks/results
```

By default, the runner auto-detects a non-loopback local IPv4 address and uses
that NIC address for both server bind and client connect. To pin a specific
interface, pass:

```bash
python3 benchmarks/run.py --host 192.168.1.20
```

The runner refuses `localhost`, `127.0.0.1`, and `::1` because those use the
loopback path rather than the network interface.

The runner builds all implementations, starts each server, samples server RSS,
runs the matching client, and writes:

```text
benchmarks/results/results.csv
benchmarks/results/*.log
```

CSV metrics include:

- `throughput_msg_sec`
- `server_max_rss_kb`
- `server_avg_rss_kb`
- `p50_us`
- `p90_us`
- `p99_us`
- `p999_us`

## Quick smoke run

```bash
python3 benchmarks/run.py \
  --impls rs-netty tokio netty \
  --protocols len \
  --connections 2 \
  --messages 100 \
  --payload 32 \
  --in-flight 4
```

## Notes

- Use release builds for Rust; the runner does this automatically.
- Netty is launched with `java -cp target/classes:target/dependency/*` instead
  of `mvn exec:java`, so server memory sampling is not inflated by Maven.
- UDP currently sends one request at a time per logical client socket.