quantrs2_sim/automatic_parallelization/
autoparallelengine_caching.rs

1//! # AutoParallelEngine - caching Methods
2//!
3//! This module contains method implementations for `AutoParallelEngine`.
4//!
5//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
6
7use crate::distributed_simulator::{DistributedQuantumSimulator, DistributedSimulatorConfig};
8use crate::large_scale_simulator::{LargeScaleQuantumSimulator, LargeScaleSimulatorConfig};
9use quantrs2_circuit::builder::{Circuit, Simulator};
10use quantrs2_core::{
11    error::{QuantRS2Error, QuantRS2Result},
12    gate::GateOp,
13    qubit::QubitId,
14};
15use scirs2_core::parallel_ops::{current_num_threads, IndexedParallelIterator, ParallelIterator};
16use scirs2_core::Complex64;
17use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
18use std::sync::{Arc, Barrier, Mutex, RwLock};
19use uuid::Uuid;
20
21use super::types::{
22    AutoParallelConfig, DependencyGraph, GateNode, HardwareCharacteristics, LoadBalancer,
23    OptimizationRecommendation, ParallelPerformanceStats, ParallelTask, RecommendationComplexity,
24    RecommendationType, TaskPriority,
25};
26
27use super::autoparallelengine_type::AutoParallelEngine;
28
29impl AutoParallelEngine {
30    /// Create a new automatic parallelization engine
31    #[must_use]
32    pub fn new(config: AutoParallelConfig) -> Self {
33        let num_threads = config.max_threads;
34        Self {
35            config,
36            analysis_cache: Arc::new(RwLock::new(HashMap::new())),
37            performance_stats: Arc::new(Mutex::new(ParallelPerformanceStats::default())),
38            load_balancer: Arc::new(Mutex::new(LoadBalancer::new(num_threads))),
39        }
40    }
41    /// Execute a circuit using automatic parallelization
42    pub fn execute_parallel<const N: usize>(
43        &self,
44        circuit: &Circuit<N>,
45        simulator: &mut LargeScaleQuantumSimulator,
46    ) -> QuantRS2Result<Vec<Complex64>> {
47        let analysis = self.analyze_circuit(circuit)?;
48        if analysis.tasks.len() < self.config.min_gates_for_parallel {
49            return Self::execute_sequential(circuit, simulator);
50        }
51        let barrier = Arc::new(Barrier::new(self.config.max_threads));
52        let shared_state = Arc::new(RwLock::new(simulator.get_dense_state()?));
53        let task_results = Arc::new(Mutex::new(Vec::new()));
54        self.execute_parallel_tasks(&analysis.tasks, shared_state.clone(), task_results, barrier)?;
55        let final_state = shared_state
56            .read()
57            .expect("shared state read lock should not be poisoned")
58            .clone();
59        Ok(final_state)
60    }
61    /// Execute distributed tasks across nodes
62    pub(super) fn execute_distributed_tasks(
63        &self,
64        distributed_tasks: &[Vec<ParallelTask>],
65        distributed_sim: &DistributedQuantumSimulator,
66    ) -> QuantRS2Result<Vec<Vec<Complex64>>> {
67        use scirs2_core::parallel_ops::{parallel_map, IndexedParallelIterator, ParallelIterator};
68        let cluster_status = distributed_sim.get_cluster_status();
69        let num_nodes = cluster_status.len();
70        let node_results: Vec<Vec<Complex64>> =
71            parallel_map(&(0..num_nodes).collect::<Vec<_>>(), |&node_id| {
72                let tasks = &distributed_tasks[node_id];
73                let mut node_result = Vec::new();
74                for task in tasks {
75                    let task_result = Self::execute_task_on_node(task, node_id);
76                    node_result.extend(task_result);
77                }
78                node_result
79            });
80        Ok(node_results)
81    }
82    /// Execute a single task on a specific node
83    pub(super) const fn execute_task_on_node(
84        task: &ParallelTask,
85        node_id: usize,
86    ) -> Vec<Complex64> {
87        Vec::new()
88    }
89    /// Build dependency graph for the circuit
90    pub(super) fn build_dependency_graph<const N: usize>(
91        &self,
92        circuit: &Circuit<N>,
93    ) -> QuantRS2Result<DependencyGraph> {
94        let gates = circuit.gates();
95        let mut nodes = Vec::with_capacity(gates.len());
96        let mut edges: HashMap<usize, Vec<usize>> = HashMap::new();
97        let mut reverse_edges: HashMap<usize, Vec<usize>> = HashMap::new();
98        for (i, gate) in gates.iter().enumerate() {
99            let qubits: HashSet<QubitId> = gate.qubits().into_iter().collect();
100            let cost = Self::estimate_gate_cost(gate.as_ref());
101            nodes.push(GateNode {
102                gate_index: i,
103                gate: gate.clone(),
104                qubits,
105                layer: 0,
106                cost,
107            });
108            edges.insert(i, Vec::new());
109            reverse_edges.insert(i, Vec::new());
110        }
111        for i in 0..nodes.len() {
112            for j in (i + 1)..nodes.len() {
113                if !nodes[i].qubits.is_disjoint(&nodes[j].qubits) {
114                    if let Some(edge_list) = edges.get_mut(&i) {
115                        edge_list.push(j);
116                    }
117                    if let Some(reverse_edge_list) = reverse_edges.get_mut(&j) {
118                        reverse_edge_list.push(i);
119                    }
120                }
121            }
122        }
123        let layers = Self::compute_topological_layers(&nodes, &edges)?;
124        for (layer_idx, layer) in layers.iter().enumerate() {
125            for &node_idx in layer {
126                if let Some(node) = nodes.get_mut(node_idx) {
127                    node.layer = layer_idx;
128                }
129            }
130        }
131        Ok(DependencyGraph {
132            nodes,
133            edges,
134            reverse_edges,
135            layers,
136        })
137    }
138    /// Compute topological layers for parallel execution
139    pub(super) fn compute_topological_layers(
140        nodes: &[GateNode],
141        edges: &HashMap<usize, Vec<usize>>,
142    ) -> QuantRS2Result<Vec<Vec<usize>>> {
143        let mut in_degree: HashMap<usize, usize> = HashMap::new();
144        let mut layers = Vec::new();
145        let mut queue = VecDeque::new();
146        for i in 0..nodes.len() {
147            in_degree.insert(i, 0);
148        }
149        for to_list in edges.values() {
150            for &to in to_list {
151                if let Some(degree) = in_degree.get_mut(&to) {
152                    *degree += 1;
153                }
154            }
155        }
156        for i in 0..nodes.len() {
157            if in_degree[&i] == 0 {
158                queue.push_back(i);
159            }
160        }
161        while !queue.is_empty() {
162            let mut current_layer = Vec::new();
163            let layer_size = queue.len();
164            for _ in 0..layer_size {
165                if let Some(node) = queue.pop_front() {
166                    current_layer.push(node);
167                    if let Some(neighbors) = edges.get(&node) {
168                        for &neighbor in neighbors {
169                            let new_degree = in_degree[&neighbor] - 1;
170                            in_degree.insert(neighbor, new_degree);
171                            if new_degree == 0 {
172                                queue.push_back(neighbor);
173                            }
174                        }
175                    }
176                }
177            }
178            if !current_layer.is_empty() {
179                layers.push(current_layer);
180            }
181        }
182        Ok(layers)
183    }
184    /// Dependency-based parallelization strategy
185    pub(super) fn dependency_based_parallelization(
186        &self,
187        graph: &DependencyGraph,
188    ) -> QuantRS2Result<Vec<ParallelTask>> {
189        let mut tasks = Vec::new();
190        for layer in &graph.layers {
191            if layer.len() > 1 {
192                let chunks = self.partition_layer_into_tasks(layer, graph)?;
193                for chunk in chunks {
194                    let task = self.create_parallel_task(chunk, graph)?;
195                    tasks.push(task);
196                }
197            } else {
198                if let Some(&gate_idx) = layer.first() {
199                    let task = self.create_parallel_task(vec![gate_idx], graph)?;
200                    tasks.push(task);
201                }
202            }
203        }
204        Ok(tasks)
205    }
206    /// Layer-based parallelization strategy
207    pub(super) fn layer_based_parallelization(
208        &self,
209        graph: &DependencyGraph,
210    ) -> QuantRS2Result<Vec<ParallelTask>> {
211        let mut tasks = Vec::new();
212        for layer in &graph.layers {
213            let max_gates_per_task = self.config.resource_constraints.max_gates_per_thread;
214            for chunk in layer.chunks(max_gates_per_task) {
215                let task = self.create_parallel_task(chunk.to_vec(), graph)?;
216                tasks.push(task);
217            }
218        }
219        Ok(tasks)
220    }
221    /// Qubit partitioning parallelization strategy
222    pub(super) fn qubit_partitioning_parallelization<const N: usize>(
223        &self,
224        circuit: &Circuit<N>,
225        graph: &DependencyGraph,
226    ) -> QuantRS2Result<Vec<ParallelTask>> {
227        let qubit_partitions = self.partition_qubits(circuit)?;
228        let mut tasks = Vec::new();
229        for partition in qubit_partitions {
230            let mut partition_gates = Vec::new();
231            for (i, node) in graph.nodes.iter().enumerate() {
232                if node.qubits.iter().all(|q| partition.contains(q)) {
233                    partition_gates.push(i);
234                }
235            }
236            if !partition_gates.is_empty() {
237                let task = self.create_parallel_task(partition_gates, graph)?;
238                tasks.push(task);
239            }
240        }
241        Ok(tasks)
242    }
243    /// Hybrid parallelization strategy
244    pub(super) fn hybrid_parallelization<const N: usize>(
245        &self,
246        circuit: &Circuit<N>,
247        graph: &DependencyGraph,
248    ) -> QuantRS2Result<Vec<ParallelTask>> {
249        let dependency_tasks = self.dependency_based_parallelization(graph)?;
250        let layer_tasks = self.layer_based_parallelization(graph)?;
251        let partition_tasks = self.qubit_partitioning_parallelization(circuit, graph)?;
252        let strategies = vec![
253            ("dependency", dependency_tasks),
254            ("layer", layer_tasks),
255            ("partition", partition_tasks),
256        ];
257        let best_strategy = strategies.into_iter().max_by(|(_, tasks_a), (_, tasks_b)| {
258            let efficiency_a = Self::calculate_strategy_efficiency(tasks_a);
259            let efficiency_b = Self::calculate_strategy_efficiency(tasks_b);
260            efficiency_a
261                .partial_cmp(&efficiency_b)
262                .unwrap_or(std::cmp::Ordering::Equal)
263        });
264        match best_strategy {
265            Some((_, tasks)) => Ok(tasks),
266            None => Ok(Vec::new()),
267        }
268    }
269    /// Aggressive parallelization for highly independent circuits
270    pub(super) fn aggressive_parallelization(
271        &self,
272        graph: &DependencyGraph,
273    ) -> QuantRS2Result<Vec<ParallelTask>> {
274        let mut tasks = Vec::new();
275        let mut visited = vec![false; graph.nodes.len()];
276        for (idx, node) in graph.nodes.iter().enumerate() {
277            if visited[idx] {
278                continue;
279            }
280            let mut parallel_group = vec![idx];
281            visited[idx] = true;
282            for (other_idx, other_node) in graph.nodes.iter().enumerate() {
283                if visited[other_idx] {
284                    continue;
285                }
286                if !Self::gates_have_dependency(idx, other_idx, graph)
287                    && !Self::gates_share_qubits(&node.qubits, &other_node.qubits)
288                {
289                    parallel_group.push(other_idx);
290                    visited[other_idx] = true;
291                }
292            }
293            if !parallel_group.is_empty() {
294                tasks.push(self.create_parallel_task(parallel_group, graph)?);
295            }
296        }
297        Ok(tasks)
298    }
299    /// Calculate gate type distribution
300    pub(super) fn calculate_gate_distribution(
301        gates: &[Arc<dyn GateOp + Send + Sync>],
302    ) -> HashMap<String, usize> {
303        let mut distribution = HashMap::new();
304        for gate in gates {
305            let gate_type = format!("{gate:?}");
306            *distribution.entry(gate_type).or_insert(0) += 1;
307        }
308        distribution
309    }
310    /// Merge small tasks together
311    pub(super) fn merge_small_tasks(
312        &self,
313        tasks: Vec<ParallelTask>,
314    ) -> QuantRS2Result<Vec<ParallelTask>> {
315        let mut merged = Vec::new();
316        let mut current_batch = Vec::new();
317        let mut current_cost = 0.0;
318        const COST_THRESHOLD: f64 = 10.0;
319        for task in tasks {
320            if task.cost < COST_THRESHOLD {
321                current_batch.push(task);
322                if let Some(last_task) = current_batch.last() {
323                    current_cost += last_task.cost;
324                }
325                if current_cost >= COST_THRESHOLD {
326                    merged.push(Self::merge_task_batch(current_batch)?);
327                    current_batch = Vec::new();
328                    current_cost = 0.0;
329                }
330            } else {
331                merged.push(task);
332            }
333        }
334        if !current_batch.is_empty() {
335            merged.push(Self::merge_task_batch(current_batch)?);
336        }
337        Ok(merged)
338    }
339    /// Split large tasks for better parallelism
340    pub(super) fn split_large_tasks(tasks: Vec<ParallelTask>) -> QuantRS2Result<Vec<ParallelTask>> {
341        let mut split_tasks = Vec::new();
342        const COST_THRESHOLD: f64 = 100.0;
343        for task in tasks {
344            if task.cost > COST_THRESHOLD && task.gates.len() > 4 {
345                let mid = task.gates.len() / 2;
346                let (gates1, gates2) = task.gates.split_at(mid);
347                split_tasks.push(ParallelTask {
348                    id: Uuid::new_v4(),
349                    gates: gates1.to_vec(),
350                    qubits: task.qubits.clone(),
351                    cost: task.cost / 2.0,
352                    memory_requirement: task.memory_requirement / 2,
353                    dependencies: task.dependencies.clone(),
354                    priority: task.priority,
355                });
356                split_tasks.push(ParallelTask {
357                    id: Uuid::new_v4(),
358                    gates: gates2.to_vec(),
359                    qubits: task.qubits.clone(),
360                    cost: task.cost / 2.0,
361                    memory_requirement: task.memory_requirement / 2,
362                    dependencies: HashSet::new(),
363                    priority: task.priority,
364                });
365            } else {
366                split_tasks.push(task);
367            }
368        }
369        Ok(split_tasks)
370    }
371    /// Merge a batch of tasks into one
372    pub(super) fn merge_task_batch(batch: Vec<ParallelTask>) -> QuantRS2Result<ParallelTask> {
373        let mut merged_gates = Vec::new();
374        let mut merged_qubits = HashSet::new();
375        let mut merged_cost = 0.0;
376        let mut merged_memory = 0;
377        let mut merged_deps = HashSet::new();
378        let mut max_priority = TaskPriority::Low;
379        for task in batch {
380            merged_gates.extend(task.gates);
381            merged_qubits.extend(task.qubits);
382            merged_cost += task.cost;
383            merged_memory += task.memory_requirement;
384            merged_deps.extend(task.dependencies);
385            if task.priority as u8 > max_priority as u8 {
386                max_priority = task.priority;
387            }
388        }
389        Ok(ParallelTask {
390            id: Uuid::new_v4(),
391            gates: merged_gates,
392            qubits: merged_qubits,
393            cost: merged_cost,
394            memory_requirement: merged_memory,
395            dependencies: merged_deps,
396            priority: max_priority,
397        })
398    }
399    /// Cache-optimized parallelization
400    pub(super) fn cache_optimized_parallelization(
401        &self,
402        graph: &DependencyGraph,
403        hw_char: &HardwareCharacteristics,
404    ) -> QuantRS2Result<Vec<ParallelTask>> {
405        let max_task_size = hw_char.l2_cache_size / (16 * 2);
406        let mut tasks = Vec::new();
407        let mut current_group = Vec::new();
408        let mut current_size = 0;
409        for (idx, node) in graph.nodes.iter().enumerate() {
410            let gate_size = (1 << node.qubits.len()) * 16;
411            if current_size + gate_size > max_task_size && !current_group.is_empty() {
412                tasks.push(self.create_parallel_task(current_group, graph)?);
413                current_group = Vec::new();
414                current_size = 0;
415            }
416            current_group.push(idx);
417            current_size += gate_size;
418        }
419        if !current_group.is_empty() {
420            tasks.push(self.create_parallel_task(current_group, graph)?);
421        }
422        Ok(tasks)
423    }
424    /// SIMD-optimized parallelization
425    pub(super) fn simd_optimized_parallelization(
426        &self,
427        graph: &DependencyGraph,
428        hw_char: &HardwareCharacteristics,
429    ) -> QuantRS2Result<Vec<ParallelTask>> {
430        let mut rotation_gates = Vec::new();
431        let mut other_gates = Vec::new();
432        for (idx, node) in graph.nodes.iter().enumerate() {
433            if Self::is_rotation_gate(node.gate.as_ref()) {
434                rotation_gates.push(idx);
435            } else {
436                other_gates.push(idx);
437            }
438        }
439        let mut tasks = Vec::new();
440        let vec_width = hw_char.simd_width / 128;
441        for chunk in rotation_gates.chunks(vec_width) {
442            tasks.push(self.create_parallel_task(chunk.to_vec(), graph)?);
443        }
444        for idx in other_gates {
445            tasks.push(self.create_parallel_task(vec![idx], graph)?);
446        }
447        Ok(tasks)
448    }
449    /// NUMA-aware parallelization
450    pub(super) fn numa_aware_parallelization(
451        &self,
452        graph: &DependencyGraph,
453        hw_char: &HardwareCharacteristics,
454    ) -> QuantRS2Result<Vec<ParallelTask>> {
455        let num_nodes = hw_char.num_numa_nodes;
456        let mut node_tasks: Vec<Vec<usize>> = vec![Vec::new(); num_nodes];
457        for (idx, node) in graph.nodes.iter().enumerate() {
458            let numa_node = Self::select_numa_node(node, num_nodes);
459            node_tasks[numa_node].push(idx);
460        }
461        let mut tasks = Vec::new();
462        for node_task_indices in node_tasks {
463            if !node_task_indices.is_empty() {
464                tasks.push(self.create_parallel_task(node_task_indices, graph)?);
465            }
466        }
467        Ok(tasks)
468    }
469    /// Refine tasks for cache efficiency
470    pub(super) fn refine_for_cache(
471        tasks: Vec<ParallelTask>,
472        hw_char: &HardwareCharacteristics,
473    ) -> QuantRS2Result<Vec<ParallelTask>> {
474        let max_cache_size = hw_char.l2_cache_size;
475        let mut refined = Vec::new();
476        for task in tasks {
477            if task.memory_requirement > max_cache_size {
478                let mid = task.gates.len() / 2;
479                let (gates1, gates2) = task.gates.split_at(mid);
480                refined.push(ParallelTask {
481                    id: Uuid::new_v4(),
482                    gates: gates1.to_vec(),
483                    qubits: task.qubits.clone(),
484                    cost: task.cost / 2.0,
485                    memory_requirement: task.memory_requirement / 2,
486                    dependencies: task.dependencies.clone(),
487                    priority: task.priority,
488                });
489                refined.push(ParallelTask {
490                    id: Uuid::new_v4(),
491                    gates: gates2.to_vec(),
492                    qubits: task.qubits,
493                    cost: task.cost / 2.0,
494                    memory_requirement: task.memory_requirement / 2,
495                    dependencies: HashSet::new(),
496                    priority: task.priority,
497                });
498            } else {
499                refined.push(task);
500            }
501        }
502        Ok(refined)
503    }
504    /// Create a parallel task from a group of gate indices
505    pub(super) fn create_parallel_task(
506        &self,
507        gate_indices: Vec<usize>,
508        graph: &DependencyGraph,
509    ) -> QuantRS2Result<ParallelTask> {
510        let mut gates = Vec::new();
511        let mut qubits = HashSet::new();
512        let mut total_cost = 0.0;
513        let mut memory_requirement = 0;
514        for &idx in &gate_indices {
515            if let Some(node) = graph.nodes.get(idx) {
516                gates.push(node.gate.clone());
517                qubits.extend(&node.qubits);
518                total_cost += node.cost;
519                memory_requirement += Self::estimate_gate_memory(node.gate.as_ref());
520            }
521        }
522        let dependencies = self.calculate_task_dependencies(&gate_indices, graph)?;
523        Ok(ParallelTask {
524            id: Uuid::new_v4(),
525            gates,
526            qubits,
527            cost: total_cost,
528            memory_requirement,
529            dependencies,
530            priority: TaskPriority::Normal,
531        })
532    }
533    /// Calculate task dependencies
534    pub(super) fn calculate_task_dependencies(
535        &self,
536        gate_indices: &[usize],
537        graph: &DependencyGraph,
538    ) -> QuantRS2Result<HashSet<Uuid>> {
539        let mut dependencies = HashSet::new();
540        for &gate_idx in gate_indices {
541            if let Some(parent_indices) = graph.reverse_edges.get(&gate_idx) {
542                for &parent_idx in parent_indices {
543                    if !gate_indices.contains(&parent_idx) {
544                        let dep_uuid = Self::generate_gate_dependency_uuid(parent_idx);
545                        dependencies.insert(dep_uuid);
546                    }
547                }
548            }
549        }
550        Ok(dependencies)
551    }
552    /// Partition layer into parallel tasks
553    pub(super) fn partition_layer_into_tasks(
554        &self,
555        layer: &[usize],
556        graph: &DependencyGraph,
557    ) -> QuantRS2Result<Vec<Vec<usize>>> {
558        let max_gates_per_task = self.config.resource_constraints.max_gates_per_thread;
559        let mut chunks = Vec::new();
560        for chunk in layer.chunks(max_gates_per_task) {
561            chunks.push(chunk.to_vec());
562        }
563        Ok(chunks)
564    }
565    /// Partition qubits into independent subsystems
566    pub(super) fn partition_qubits<const N: usize>(
567        &self,
568        circuit: &Circuit<N>,
569    ) -> QuantRS2Result<Vec<HashSet<QubitId>>> {
570        let mut partitions = Vec::new();
571        let mut used_qubits = HashSet::new();
572        for i in 0..N {
573            let qubit = QubitId::new(i as u32);
574            if used_qubits.insert(qubit) {
575                let mut partition = HashSet::new();
576                partition.insert(qubit);
577                partitions.push(partition);
578            }
579        }
580        Ok(partitions)
581    }
582    /// Generate optimization recommendations
583    pub(super) fn generate_optimization_recommendations<const N: usize>(
584        &self,
585        circuit: &Circuit<N>,
586        graph: &DependencyGraph,
587        tasks: &[ParallelTask],
588    ) -> Vec<OptimizationRecommendation> {
589        let mut recommendations = Vec::new();
590        if graph.layers.iter().any(|layer| layer.len() == 1) {
591            recommendations.push(OptimizationRecommendation {
592                recommendation_type: RecommendationType::GateReordering,
593                description: "Consider reordering gates to create larger parallel layers"
594                    .to_string(),
595                expected_improvement: 0.2,
596                complexity: RecommendationComplexity::Medium,
597            });
598        }
599        let task_costs: Vec<f64> = tasks.iter().map(|t| t.cost).collect();
600        let cost_variance = Self::calculate_variance(&task_costs);
601        if cost_variance > 0.5 {
602            recommendations.push(OptimizationRecommendation {
603                recommendation_type: RecommendationType::ResourceAllocation,
604                description: "Task costs are unbalanced, consider load balancing optimization"
605                    .to_string(),
606                expected_improvement: 0.15,
607                complexity: RecommendationComplexity::Low,
608            });
609        }
610        recommendations
611    }
612    /// Execute circuit sequentially (fallback)
613    pub(super) fn execute_sequential<const N: usize>(
614        circuit: &Circuit<N>,
615        simulator: &LargeScaleQuantumSimulator,
616    ) -> QuantRS2Result<Vec<Complex64>> {
617        let result = simulator.run(circuit)?;
618        Ok(Vec::new())
619    }
620    /// Compute hash for circuit caching
621    pub(super) fn compute_circuit_hash<const N: usize>(circuit: &Circuit<N>) -> u64 {
622        use std::collections::hash_map::DefaultHasher;
623        use std::hash::{Hash, Hasher};
624        let mut hasher = DefaultHasher::new();
625        circuit.num_gates().hash(&mut hasher);
626        circuit.num_qubits().hash(&mut hasher);
627        for gate in circuit.gates() {
628            gate.name().hash(&mut hasher);
629            gate.qubits().len().hash(&mut hasher);
630        }
631        hasher.finish()
632    }
633}
quantrs2_sim/automatic_parallelization/autoparallelengine_caching.rs

quantrs2_sim/automatic_parallelization/
autoparallelengine_caching.rs
