1#[derive(Debug, Clone, Copy, PartialEq, Eq)]
22pub enum CacheLevel {
23 L1,
25 L2,
27 L3,
29 Ram,
31}
32
33impl CacheLevel {
34 pub fn name(&self) -> &'static str {
36 match self {
37 CacheLevel::L1 => "L1 cache",
38 CacheLevel::L2 => "L2 cache",
39 CacheLevel::L3 => "L3 cache",
40 CacheLevel::Ram => "main memory",
41 }
42 }
43
44 pub fn typical_latency_cycles(&self) -> u32 {
46 match self {
47 CacheLevel::L1 => 4,
48 CacheLevel::L2 => 12,
49 CacheLevel::L3 => 40,
50 CacheLevel::Ram => 200,
51 }
52 }
53
54 pub fn relative_bandwidth(&self) -> f64 {
56 match self {
57 CacheLevel::L1 => 1.0,
58 CacheLevel::L2 => 0.8,
59 CacheLevel::L3 => 0.5,
60 CacheLevel::Ram => 0.1,
61 }
62 }
63}
64
65#[derive(Debug, Clone)]
67pub struct CacheConfig {
68 pub l1_size: usize,
70 pub l2_size: usize,
72 pub l3_size: usize,
74 pub l3_sharing: usize,
76 pub line_size: usize,
78}
79
80impl Default for CacheConfig {
81 fn default() -> Self {
82 Self {
83 l1_size: 32 * 1024, l2_size: 512 * 1024, l3_size: 32 * 1024 * 1024, l3_sharing: 8, line_size: 64, }
89 }
90}
91
92impl CacheConfig {
93 pub fn zen4() -> Self {
95 Self {
96 l1_size: 32 * 1024, l2_size: 1024 * 1024, l3_size: 32 * 1024 * 1024, l3_sharing: 8,
100 line_size: 64,
101 }
102 }
103
104 pub fn sapphire_rapids() -> Self {
106 Self {
107 l1_size: 48 * 1024, l2_size: 2 * 1024 * 1024, l3_size: 60 * 1024 * 1024, l3_sharing: 16,
111 line_size: 64,
112 }
113 }
114
115 pub fn apple_m2() -> Self {
117 Self {
118 l1_size: 128 * 1024, l2_size: 16 * 1024 * 1024, l3_size: 0, l3_sharing: 1,
122 line_size: 128, }
124 }
125
126 pub fn classify(&self, working_set_bytes: usize) -> CacheLevel {
128 if working_set_bytes <= self.l1_size * 3 / 4 {
129 CacheLevel::L1
130 } else if working_set_bytes <= self.l2_size * 3 / 4 {
131 CacheLevel::L2
132 } else if self.l3_size > 0 && working_set_bytes <= self.l3_size * 3 / 4 {
133 CacheLevel::L3
134 } else {
135 CacheLevel::Ram
136 }
137 }
138
139 pub fn l3_per_core(&self) -> usize {
141 self.l3_size
142 .checked_div(self.l3_sharing)
143 .unwrap_or(self.l3_size)
144 }
145}
146
147#[derive(Debug, Clone)]
149pub struct WorkingSetAnalysis {
150 pub working_set_bytes: usize,
152 pub cache_level: CacheLevel,
154 pub utilization_percent: f64,
156 pub expected_efficiency: f64,
158 pub tiling_recommended: bool,
160 pub recommended_tile_bytes: Option<usize>,
162}
163
164impl WorkingSetAnalysis {
165 pub fn analyze(
167 elements: usize,
168 element_size: usize,
169 access_factor: f64,
170 config: &CacheConfig,
171 ) -> Self {
172 let working_set_bytes = (elements as f64 * element_size as f64 * access_factor) as usize;
173 let cache_level = config.classify(working_set_bytes);
174
175 let (utilization_percent, _cache_size) = match cache_level {
176 CacheLevel::L1 => (
177 (working_set_bytes as f64 / config.l1_size as f64) * 100.0,
178 config.l1_size,
179 ),
180 CacheLevel::L2 => (
181 (working_set_bytes as f64 / config.l2_size as f64) * 100.0,
182 config.l2_size,
183 ),
184 CacheLevel::L3 => (
185 (working_set_bytes as f64 / config.l3_size as f64) * 100.0,
186 config.l3_size,
187 ),
188 CacheLevel::Ram => (100.0, working_set_bytes),
189 };
190
191 let expected_efficiency = cache_level.relative_bandwidth();
192
193 let tiling_recommended = working_set_bytes > config.l2_size;
195
196 let recommended_tile_bytes = if tiling_recommended {
197 Some(config.l2_size * 3 / 4)
199 } else {
200 None
201 };
202
203 Self {
204 working_set_bytes,
205 cache_level,
206 utilization_percent,
207 expected_efficiency,
208 tiling_recommended,
209 recommended_tile_bytes,
210 }
211 }
212
213 pub fn recommendation(&self) -> String {
215 if self.tiling_recommended {
216 format!(
217 "Working set ({} bytes) exceeds L2. Recommend tiling with {} byte tiles for {} cache.",
218 self.working_set_bytes,
219 self.recommended_tile_bytes.unwrap_or(0),
220 CacheLevel::L2.name()
221 )
222 } else {
223 format!(
224 "Working set ({} bytes) fits in {}. No tiling needed.",
225 self.working_set_bytes,
226 self.cache_level.name()
227 )
228 }
229 }
230}
231
232pub fn matrix_working_set(m: usize, n: usize, k: usize, element_size: usize) -> usize {
234 let a_size = m * k * element_size;
236 let b_size = k * n * element_size;
237 let c_size = m * n * element_size;
238 a_size + b_size + c_size
239}
240
241pub fn optimal_matmul_tile(config: &CacheConfig, element_size: usize) -> usize {
243 let target_bytes = config.l2_size * 3 / 4;
247 let max_tile_elements = target_bytes / (3 * element_size);
248 let tile_size = (max_tile_elements as f64).sqrt() as usize;
249
250 let elements_per_line = config.line_size / element_size;
252 (tile_size / elements_per_line) * elements_per_line
253}
254
255pub fn elementwise_working_set(
257 elements: usize,
258 inputs: usize,
259 outputs: usize,
260 element_size: usize,
261) -> usize {
262 elements * (inputs + outputs) * element_size
263}
264
265#[derive(Debug, Clone, Copy, PartialEq, Eq)]
267pub enum AccessPattern {
268 Streaming,
270 Reuse,
272 Random,
274}
275
276impl AccessPattern {
277 pub fn estimate(working_set: usize, iterations: usize, config: &CacheConfig) -> Self {
279 if iterations == 1 {
280 AccessPattern::Streaming
281 } else if working_set <= config.l2_size {
282 AccessPattern::Reuse
283 } else {
284 AccessPattern::Random
285 }
286 }
287
288 pub fn name(&self) -> &'static str {
290 match self {
291 AccessPattern::Streaming => "streaming",
292 AccessPattern::Reuse => "reuse",
293 AccessPattern::Random => "random",
294 }
295 }
296
297 pub fn efficiency_factor(&self) -> f64 {
299 match self {
300 AccessPattern::Streaming => 0.5, AccessPattern::Reuse => 1.0, AccessPattern::Random => 0.1, }
304 }
305}
306
307#[derive(Debug, Clone)]
309pub struct BandwidthPrediction {
310 pub peak_bandwidth_gbps: f64,
312 pub predicted_bandwidth_gbps: f64,
314 pub efficiency_percent: f64,
316 pub limiting_factor: String,
318}
319
320impl BandwidthPrediction {
321 pub fn predict(
323 peak_bandwidth_gbps: f64,
324 working_set: usize,
325 access_pattern: AccessPattern,
326 config: &CacheConfig,
327 ) -> Self {
328 let cache_level = config.classify(working_set);
329 let cache_efficiency = cache_level.relative_bandwidth();
330 let pattern_efficiency = access_pattern.efficiency_factor();
331
332 let overall_efficiency = cache_efficiency * pattern_efficiency;
333 let predicted_bandwidth_gbps = peak_bandwidth_gbps * overall_efficiency;
334
335 let limiting_factor = if pattern_efficiency < cache_efficiency {
336 format!("{} access pattern", access_pattern.name())
337 } else {
338 format!("{} bandwidth", cache_level.name())
339 };
340
341 Self {
342 peak_bandwidth_gbps,
343 predicted_bandwidth_gbps,
344 efficiency_percent: overall_efficiency * 100.0,
345 limiting_factor,
346 }
347 }
348}
349
350#[cfg(test)]
351mod tests {
352 use super::*;
353
354 #[test]
355 fn test_cache_level_classification() {
356 let config = CacheConfig::default();
357
358 assert_eq!(config.classify(1024), CacheLevel::L1);
359 assert_eq!(config.classify(100 * 1024), CacheLevel::L2);
360 assert_eq!(config.classify(10 * 1024 * 1024), CacheLevel::L3);
361 assert_eq!(config.classify(100 * 1024 * 1024), CacheLevel::Ram);
362 }
363
364 #[test]
365 fn test_working_set_analysis() {
366 let config = CacheConfig::default();
367 let analysis = WorkingSetAnalysis::analyze(1000, 4, 2.0, &config);
368
369 assert_eq!(analysis.cache_level, CacheLevel::L1);
371 assert!(!analysis.tiling_recommended);
372 }
373
374 #[test]
375 fn test_matrix_working_set() {
376 let ws = matrix_working_set(1024, 1024, 1024, 4);
377 assert_eq!(ws, 3 * 1024 * 1024 * 4);
379 }
380
381 #[test]
382 fn test_optimal_tile_size() {
383 let config = CacheConfig::default();
384 let tile = optimal_matmul_tile(&config, 4);
385
386 assert!(tile > 0);
388 assert!(tile <= 512); }
390
391 #[test]
392 fn test_access_pattern() {
393 let config = CacheConfig::default();
394
395 assert_eq!(
396 AccessPattern::estimate(1024, 1, &config),
397 AccessPattern::Streaming
398 );
399 assert_eq!(
400 AccessPattern::estimate(1024, 10, &config),
401 AccessPattern::Reuse
402 );
403 assert_eq!(
404 AccessPattern::estimate(100 * 1024 * 1024, 10, &config),
405 AccessPattern::Random
406 );
407 }
408
409 #[test]
410 fn test_bandwidth_prediction() {
411 let config = CacheConfig::default();
412 let prediction = BandwidthPrediction::predict(
413 100.0, 1024, AccessPattern::Reuse,
416 &config,
417 );
418
419 assert!(prediction.efficiency_percent > 90.0);
421 }
422}