real_comparison/
real_comparison.rs1use hft_benchmarks::*;
4
5fn sum_with_loop(n: u32) -> u32 {
7 let mut sum = 0;
8 for i in 0..n {
9 sum += i;
10 }
11 sum
12}
13
14fn sum_with_formula(n: u32) -> u32 {
15 n * (n - 1) / 2
16}
17
18fn is_even_modulo(n: u32) -> bool {
20 n % 2 == 0
21}
22
23fn is_even_bitwise(n: u32) -> bool {
24 n & 1 == 0
25}
26
27fn main() {
28 quick_calibrate_tsc_frequency();
29
30 println!("š¬ Real Algorithm Comparisons\n");
31
32 println!("=== Sum Algorithms (n=100) ===");
34
35 let loop_perf = SimpleBench::new("sum_with_loop")
36 .bench(10000, || sum_with_loop(100))
37 .analyze();
38
39 let formula_perf = SimpleBench::new("sum_with_formula")
40 .bench(10000, || sum_with_formula(100))
41 .analyze();
42
43 println!("Loop method: mean={}ns, P99={}ns", loop_perf.mean, loop_perf.p99);
44 println!("Formula method: mean={}ns, P99={}ns", formula_perf.mean, formula_perf.p99);
45
46 if formula_perf.mean < loop_perf.mean {
47 let improvement = (loop_perf.mean as f64 / formula_perf.mean as f64 - 1.0) * 100.0;
48 println!("ā
Formula is {:.1}% faster", improvement);
49 } else if loop_perf.mean < formula_perf.mean {
50 let degradation = (formula_perf.mean as f64 / loop_perf.mean as f64 - 1.0) * 100.0;
51 println!("ā ļø Loop is {:.1}% faster", degradation);
52 } else {
53 println!("š¤ Both methods perform similarly");
54 }
55
56 println!("\n=== Even Number Check ===");
58
59 let modulo_perf = SimpleBench::new("is_even_modulo")
60 .bench(10000, || is_even_modulo(12345))
61 .analyze();
62
63 let bitwise_perf = SimpleBench::new("is_even_bitwise")
64 .bench(10000, || is_even_bitwise(12345))
65 .analyze();
66
67 println!("Modulo method: mean={}ns, P99={}ns", modulo_perf.mean, modulo_perf.p99);
68 println!("Bitwise method: mean={}ns, P99={}ns", bitwise_perf.mean, bitwise_perf.p99);
69
70 if bitwise_perf.mean < modulo_perf.mean {
71 let improvement = (modulo_perf.mean as f64 / bitwise_perf.mean as f64 - 1.0) * 100.0;
72 println!("ā
Bitwise is {:.1}% faster", improvement);
73 } else if modulo_perf.mean < bitwise_perf.mean {
74 let degradation = (bitwise_perf.mean as f64 / modulo_perf.mean as f64 - 1.0) * 100.0;
75 println!("ā ļø Modulo is {:.1}% faster", degradation);
76 } else {
77 println!("š¤ Both methods perform similarly");
78 }
79
80 println!("\n=== Vector vs Array Access ===");
82
83 let vec_data = vec![1, 2, 3, 4, 5];
84 let array_data = [1, 2, 3, 4, 5];
85
86 let vec_perf = SimpleBench::new("vector_access")
87 .bench(10000, || {
88 let sum = vec_data.iter().sum::<i32>();
89 std::hint::black_box(sum);
90 })
91 .analyze();
92
93 let array_perf = SimpleBench::new("array_access")
94 .bench(10000, || {
95 let sum = array_data.iter().sum::<i32>();
96 std::hint::black_box(sum);
97 })
98 .analyze();
99
100 println!("Vector access: mean={}ns, P99={}ns", vec_perf.mean, vec_perf.p99);
101 println!("Array access: mean={}ns, P99={}ns", array_perf.mean, array_perf.p99);
102
103 if array_perf.mean < vec_perf.mean {
104 let improvement = (vec_perf.mean as f64 / array_perf.mean as f64 - 1.0) * 100.0;
105 println!("ā
Array is {:.1}% faster", improvement);
106 } else if vec_perf.mean < array_perf.mean {
107 let degradation = (array_perf.mean as f64 / vec_perf.mean as f64 - 1.0) * 100.0;
108 println!("ā ļø Vector is {:.1}% faster", degradation);
109 } else {
110 println!("š¤ Both perform similarly");
111 }
112
113 println!("\nš” Note: Results may vary between runs due to:");
114 println!(" - CPU cache state");
115 println!(" - System load");
116 println!(" - Compiler optimizations");
117 println!(" - Memory layout");
118}