framealloc 0.11.1

Intent-aware, thread-smart memory allocation for Rust game engines
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Unified budget management for CPU and GPU memory

/// Manages unified memory budgets across CPU and GPU
pub struct UnifiedBudgetManager {
    /// Current CPU memory usage
    cpu_usage: usize,
    /// Current GPU memory usage
    gpu_usage: usize,
    /// CPU memory budget
    cpu_budget: usize,
    /// GPU memory budget
    gpu_budget: usize,
    /// Combined memory budget
    combined_budget: usize,
    /// Frame-local usage tracking
    frame_cpu_usage: usize,
    frame_gpu_usage: usize,
}

impl UnifiedBudgetManager {
    /// Create a new budget manager with default limits
    pub fn new() -> Self {
        Self {
            cpu_usage: 0,
            gpu_usage: 0,
            cpu_budget: 512 * 1024 * 1024, // 512 MB
            gpu_budget: 1024 * 1024 * 1024, // 1 GB
            combined_budget: 1536 * 1024 * 1024, // 1.5 GB
            frame_cpu_usage: 0,
            frame_gpu_usage: 0,
        }
    }
    
    /// Create a new budget manager with custom limits
    pub fn with_limits(cpu_budget: usize, gpu_budget: usize) -> Self {
        let combined_budget = cpu_budget + gpu_budget;
        Self {
            cpu_usage: 0,
            gpu_usage: 0,
            cpu_budget,
            gpu_budget,
            combined_budget,
            frame_cpu_usage: 0,
            frame_gpu_usage: 0,
        }
    }
    
    /// Check if we can allocate the given amount on CPU
    pub fn check_cpu_budget(&self, size: usize) -> bool {
        self.cpu_usage + size <= self.cpu_budget &&
        self.cpu_usage + self.gpu_usage + size <= self.combined_budget
    }
    
    /// Check if we can allocate the given amount on GPU
    pub fn check_gpu_budget(&self, size: usize) -> bool {
        self.gpu_usage + size <= self.gpu_budget &&
        self.cpu_usage + self.gpu_usage + size <= self.combined_budget
    }
    
    /// Check if we can allocate the given combined amount
    pub fn check_combined_budget(&self, size: usize) -> bool {
        self.cpu_usage + self.gpu_usage + size <= self.combined_budget
    }
    
    /// Add CPU memory usage
    pub fn add_cpu_usage(&mut self, size: usize) {
        self.cpu_usage += size;
        self.frame_cpu_usage += size;
    }
    
    /// Add GPU memory usage
    pub fn add_gpu_usage(&mut self, size: usize) {
        self.gpu_usage += size;
        self.frame_gpu_usage += size;
    }
    
    /// Remove CPU memory usage
    pub fn remove_cpu_usage(&mut self, size: usize) {
        self.cpu_usage = self.cpu_usage.saturating_sub(size);
    }
    
    /// Remove GPU memory usage
    pub fn remove_gpu_usage(&mut self, size: usize) {
        self.gpu_usage = self.gpu_usage.saturating_sub(size);
    }
    
    /// Get current CPU usage
    pub fn cpu_usage(&self) -> usize {
        self.cpu_usage
    }
    
    /// Get current GPU usage
    pub fn gpu_usage(&self) -> usize {
        self.gpu_usage
    }
    
    /// Get CPU budget
    pub fn cpu_budget(&self) -> usize {
        self.cpu_budget
    }
    
    /// Get GPU budget
    pub fn gpu_budget(&self) -> usize {
        self.gpu_budget
    }
    
    /// Get combined budget
    pub fn combined_budget(&self) -> usize {
        self.combined_budget
    }
    
    /// Get CPU utilization (0.0 to 1.0)
    pub fn cpu_utilization(&self) -> f32 {
        self.cpu_usage as f32 / self.cpu_budget as f32
    }
    
    /// Get GPU utilization (0.0 to 1.0)
    pub fn gpu_utilization(&self) -> f32 {
        self.gpu_usage as f32 / self.gpu_budget as f32
    }
    
    /// Get combined utilization (0.0 to 1.0)
    pub fn combined_utilization(&self) -> f32 {
        (self.cpu_usage + self.gpu_usage) as f32 / self.combined_budget as f32
    }
    
    /// Reset frame-local usage tracking
    pub fn reset_frame_usage(&mut self) {
        self.frame_cpu_usage = 0;
        self.frame_gpu_usage = 0;
    }
    
    /// Get frame-local CPU usage
    pub fn frame_cpu_usage(&self) -> usize {
        self.frame_cpu_usage
    }
    
    /// Get frame-local GPU usage
    pub fn frame_gpu_usage(&self) -> usize {
        self.frame_gpu_usage
    }
}

impl Default for UnifiedBudgetManager {
    fn default() -> Self {
        Self::new()
    }
}