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

// Demonstrating struct field ordering optimization
use std::mem;

// Poorly ordered struct - causes padding
#[repr(C)]  // Prevents reordering for demonstration
struct PoorlyOrdered {
    a: u8,     // 1 byte
    b: u64,    // 8 bytes (7 bytes padding before this)
    c: u8,     // 1 byte
    d: u32,    // 4 bytes (3 bytes padding before this)
}

// Well-ordered struct - minimal padding
#[repr(C)]
struct WellOrdered {
    b: u64,    // 8 bytes
    d: u32,    // 4 bytes
    a: u8,     // 1 byte
    c: u8,     // 1 byte (2 bytes padding at end for alignment)
}

// Rust automatically reorders fields for optimal layout (without #[repr(C)])
struct AutoOptimized {
    a: u8,
    b: u64,
    c: u8,
    d: u32,
}

fn analyze_struct_sizes() {
    println!("Struct size analysis:");
    println!("PoorlyOrdered: {} bytes", mem::size_of::<PoorlyOrdered>());
    println!("WellOrdered: {} bytes", mem::size_of::<WellOrdered>());
    println!("AutoOptimized: {} bytes", mem::size_of::<AutoOptimized>());

    // Advanced memory layout analysis
    println!("\nAlignment requirements:");
    println!("u8 align: {}", mem::align_of::<u8>());
    println!("u32 align: {}", mem::align_of::<u32>());
    println!("u64 align: {}", mem::align_of::<u64>());
}

// Generic programming with zero-cost abstractions
trait DataProcessor<T> {
    fn process(&self, data: &[T]) -> Vec<T>;
}

struct FilterProcessor<F> {
    filter: F,
}

impl<T, F> DataProcessor<T> for FilterProcessor<F>
where
    T: Clone,
    F: Fn(&T) -> bool,
{
    fn process(&self, data: &[T]) -> Vec<T> {
        // This compiles to highly optimized code with inlining
        data.iter()
            .filter(|&item| (self.filter)(item))
            .cloned()
            .collect()
    }
}

// Usage demonstrates zero-cost abstraction
fn demonstrate_generic_optimization() {
    let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    let processor = FilterProcessor {
        filter: |&x| x % 2 == 0,  // This closure is inlined
    };

    let result = processor.process(&data);
    println!("Filtered (even numbers): {:?}", result);
}