secbuf 0.1.7

Secure, high-performance buffer management with automatic memory zeroing and aggressive cleanup
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

// examples/network_simulation.rs
//! Simulates network packet handling with buffer pooling

use secbuf::prelude::*;
use std::time::Instant;

fn main() -> Result<()> {
    println!("=== Network Packet Simulation ===\n");

    // Create a buffer pool for packet handling
    let pool = BufferPool::new(PoolConfig {
        buffer_size: 1500, // MTU size
        max_pool_size: 1000,
        min_pool_size: 100,
    });

    let num_packets = 10_000;
    let start = Instant::now();

    // Simulate processing packets
    for i in 0..num_packets {
        let mut packet = pool.acquire();

        // Write packet header
        packet.put_u32(i)?; // Sequence number
        packet.put_u32(1400)?; // Payload length

        // Write payload
        let payload = vec![0x42; 1400];
        packet.put_bytes(&payload)?;

        // Process packet (simulate)
        packet.set_pos(0)?;
        let seq = packet.get_u32()?;
        let len = packet.get_u32()?;

        if i % 1000 == 0 {
            println!("Processed packet {} (seq={}, len={})", i, seq, len);
        }

        // Packet buffer is automatically returned to pool when dropped
    }

    let elapsed = start.elapsed();
    println!("\nProcessed {} packets in {:?}", num_packets, elapsed);
    println!(
        "Average: {:.2} µs per packet",
        elapsed.as_micros() as f64 / num_packets as f64
    );

    let stats = pool.stats();
    println!("\nPool Statistics:");
    println!("  Available: {}", stats.available);
    println!("  Total allocated: {}", stats.total_allocated);
    println!("  Total acquired: {}", stats.total_acquired);
    println!("  Total returned: {}", stats.total_returned);
    println!("  In use: {}", stats.in_use());
    println!("  Hit rate: {:.1}%", stats.hit_rate());

    // Compare with non-pooled allocation
    println!("\n=== Non-Pooled Comparison ===\n");
    let start = Instant::now();

    for i in 0..num_packets {
        let mut packet = Buffer::new(1500); // Allocate fresh each time
        packet.put_u32(i)?;
        packet.put_u32(1400)?;
        let payload = vec![0x42; 1400];
        packet.put_bytes(&payload)?;

        // Drop happens here, buffer is freed
    }

    let elapsed_no_pool = start.elapsed();
    println!("Non-pooled time: {:?}", elapsed_no_pool);
    println!(
        "Speedup: {:.2}x faster with pooling",
        elapsed_no_pool.as_secs_f64() / elapsed.as_secs_f64()
    );

    // Fast pool comparison
    println!("\n=== Fast Pool Comparison ===\n");

    let fast_pool = FastBufferPool::new(PoolConfig {
        buffer_size: 1500,
        max_pool_size: 1000,
        min_pool_size: 100,
    });

    let start = Instant::now();
    for i in 0..num_packets {
        let mut packet = fast_pool.acquire();
        packet.put_u32(i)?;
        packet.put_u32(1400)?;
        let payload = vec![0x42; 1400];
        packet.put_bytes(&payload)?;
    }
    let elapsed_fast = start.elapsed();

    println!("Fast pool time: {:?}", elapsed_fast);
    println!(
        "Speedup vs standard: {:.2}x faster",
        elapsed.as_secs_f64() / elapsed_fast.as_secs_f64()
    );

    let fast_stats = fast_pool.stats();
    println!("\nFast Pool Statistics:");
    println!("  Cache hit rate: {:.1}%", fast_stats.cache_hit_rate());
    println!("  Pool hit rate: {:.1}%", fast_stats.pool_hit_rate());

    Ok(())
}