FPS 0.0.3

Flow processing system (under construction). 
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

#![feature(test)]
#[macro_use]
extern crate fps;
extern crate test;
use fps::n::packet::*;
use fps::n::*;
use test::Bencher;
const TEST_N: usize = 10000;

fn prepare_packet1<'a>(input: &'a mut Buffer) -> Field<'a> {
    let mut buffer = &mut input[0..54];
    move_field(&[0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0x08,
                 0x00, 0x45, 0x00, 0x00, 0x28, 0x00, 0x00, 0x40, 0x00, 0x40, 0x06, 0x6F, 0x1D,
                 0xC0, 0xA8, 0x00, 0x07, 0x0A, 0x00, 0x01, 0x04, 0x56, 0xCE, 0x30, 0x39, 0xFF,
                 0xFF, 0xF2, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02, 0xC8, 0x00, 0xA2, 0xB8,
                 0x00, 0x00],
               buffer);
    buffer
}

extern "C" {
    fn c_extern_bench(test_no: i32, repeat: usize) -> i32;
}

fn rust_c_extern_bench(test_no: i32, repeat: usize) -> bool {
    unsafe { c_extern_bench(test_no, repeat) == 0 }
}

#[bench]
fn bench_ethernet_swap_rust(bench: &mut Bencher) {
    bench.iter(|| {
        let mut temp_buffer = ZERO_BUFFER;
    
        let buffer = prepare_packet1(&mut temp_buffer);
    
        let mut packet = Packet::new(buffer);
        packet = phy::extract(packet);
        packet = ethernet::extract(packet);
        for _ in 0..TEST_N {
            packet = ethernet::swap_address(packet);
        }
    })
}

#[bench]
fn bench_dummy_move(bench: &mut Bencher) {
    bench.iter(|| {
        let mut temp_buffer = ZERO_BUFFER;
    
        let buffer = prepare_packet1(&mut temp_buffer);
    
        let mut packet = Packet::new(buffer);
        packet = phy::extract(packet);
        packet = ethernet::extract(packet);
        for _ in 0..TEST_N {
            packet = packet::dummy_move(packet);
        }
    })
}

#[bench]
fn bench_dummy_right_strip(bench: &mut Bencher) {
    bench.iter(|| {
        let mut temp_buffer = ZERO_BUFFER;
    
        let buffer = prepare_packet1(&mut temp_buffer);
    
        let mut packet = Packet::new(buffer);
        packet = phy::extract(packet);
        packet = ethernet::extract(packet);
        for _ in 0..TEST_N {
            packet = packet.right_strip(0);
        }
    })
}

#[bench]
fn bench_dummy_next(bench: &mut Bencher) {
    bench.iter(|| {
        let mut temp_buffer = ZERO_BUFFER;
    
        let buffer = prepare_packet1(&mut temp_buffer);
    
        let mut packet = Packet::new(buffer);
        packet = phy::extract(packet);
        packet = ethernet::extract(packet);
        for _ in 0..TEST_N {
            let (in_packet, _) = packet.right_packet(0);
            packet = in_packet;
        }
    })
}

#[bench]
fn c_with_rust_swap(bench: &mut Bencher) {
    bench.iter(|| rust_c_extern_bench(1, TEST_N))
}

#[bench]
fn c_native_swap(bench: &mut Bencher) {
    bench.iter(|| rust_c_extern_bench(2, TEST_N))
}

#[bench]
fn bench_dummy_move_ffi_mapping(bench: &mut Bencher) {
	let mapper = millefeuille_ffi_map!();
	if let (Some(phy),Some(eth),Some(dummy))
	= (mapper("phy::extract"),mapper("ethernet::extract"),mapper("packet::dummy_move")) {
	    bench.iter(|| {
	        let mut temp_buffer = ZERO_BUFFER;
	        let buffer = prepare_packet1(&mut temp_buffer);
	        let mut packet = Packet::new(buffer);
	    	packet = phy(packet);
	        packet = eth(packet);
	        for _ in 0..TEST_N {
	            packet = dummy(packet);
	        }
	    })
    } else {
    	panic!("Cannot reach here");
    }
}