inferno-ai 0.10.3

Enterprise AI/ML model runner with automatic updates, real-time monitoring, and multi-interface support
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

/// Error Enum Size Analysis
///
/// This test analyzes the size of InfernoError variants to identify
/// which variants should be boxed to reduce the overall enum size.
///
/// Target: Reduce from ~208 bytes to <64 bytes
use inferno::InfernoError;
use std::mem::size_of;

#[test]
fn analyze_error_sizes() {
    println!("\n=== InfernoError Size Analysis ===");
    println!("Overall enum size: {} bytes", size_of::<InfernoError>());
    println!("\nComponent sizes:");
    println!("  String: {} bytes", size_of::<String>());
    println!("  std::io::Error: {} bytes", size_of::<std::io::Error>());
    println!(
        "  serde_json::Error: {} bytes",
        size_of::<serde_json::Error>()
    );
    println!("  figment::Error: {} bytes", size_of::<figment::Error>());

    // Calculate expected enum size (largest variant + discriminant)
    let max_variant_size = size_of::<figment::Error>()
        .max(size_of::<std::io::Error>())
        .max(size_of::<serde_json::Error>())
        .max(size_of::<String>());

    println!("\nLargest variant: {} bytes", max_variant_size);
    println!(
        "Expected enum size (variant + discriminant): ~{} bytes",
        max_variant_size + 8
    );

    // Recommendations
    println!("\n=== Optimization Recommendations ===");
    if size_of::<figment::Error>() > 64 {
        println!(
            "⚠️  Box figment::Error ({} bytes)",
            size_of::<figment::Error>()
        );
    }
    if size_of::<std::io::Error>() > 64 {
        println!(
            "⚠️  Box std::io::Error ({} bytes)",
            size_of::<std::io::Error>()
        );
    }
    if size_of::<serde_json::Error>() > 64 {
        println!(
            "⚠️  Box serde_json::Error ({} bytes)",
            size_of::<serde_json::Error>()
        );
    }

    let target_size = 64;
    if size_of::<InfernoError>() > target_size {
        println!(
            "\n⚠️  Current size ({} bytes) exceeds target ({} bytes)",
            size_of::<InfernoError>(),
            target_size
        );
        println!(
            "   Reduction needed: {} bytes",
            size_of::<InfernoError>() - target_size
        );
    } else {
        println!(
            "\n✅ Size ({} bytes) within target ({} bytes)",
            size_of::<InfernoError>(),
            target_size
        );
    }
}

#[test]
fn measure_boxed_error_sizes() {
    println!("\n=== Boxed Error Sizes ===");
    println!(
        "Box<figment::Error>: {} bytes",
        size_of::<Box<figment::Error>>()
    );
    println!(
        "Box<std::io::Error>: {} bytes",
        size_of::<Box<std::io::Error>>()
    );
    println!(
        "Box<serde_json::Error>: {} bytes",
        size_of::<Box<serde_json::Error>>()
    );
    println!("\nNote: Box is typically 8 bytes (pointer) on 64-bit systems");
}