Fixed memory leak in ultragraph bench (#261)

* Updated docstring

Signed-off-by: Marvin Hansen <[email protected]>

* Fixed a memory leak in the ultragraph benchmark.

Signed-off-by: Marvin Hansen <[email protected]>

* Fixed typo in Rustdoc.

Signed-off-by: Marvin Hansen <[email protected]>

---------

Signed-off-by: Marvin Hansen <[email protected]>

Author: marvin-hansen

deep_causality/src/types/reasoning_types/propagating_effect.rs

@@ -23,10 +23,9 @@ pub enum PropagatingEffect {
     Probabilistic(NumericalValue),
 
     /// A propagating effect that directs the flow of causality.
-    ///
-    /// This instructs the reasoning engine to continue the propagation to the
-    /// Causaloid located at the linked Contextoid. The linked Contextoid
-    /// itself becomes the `Evidence` for the next step in the process.
+    /// It instructs the next Causaloid to locate the propagation effect
+    /// at the linked Contextoid. The linked Contextoid
+    /// itself becomes the `Evidence` for the next step in the reasoning process.
     /// This is the primary mechanism for data flow in the graph.
     ContextualLink(ContextId, ContextoidId),
 

ultragraph/README.md

@@ -75,6 +75,36 @@ into a `DynamicGraph`, allowing the cycle of mutation and analysis to begin agai
 
 ## 🚀 Benchmark Results
 
+### Dynamic Graph
+
+| Benchmark Name    | Graph Size | Operation  | Estimated Time (Median) | Outliers Detected |
+|:------------------|:-----------|:-----------|:------------------------|:------------------|
+| `small_add_node`  | 10         | `add_node` | 29.099 ns               | 14% (14 / 100)    |
+| `medium_add_node` | 100        | `add_node` | 45.864 ns               | 12% (12 / 100)    |
+| `large_add_node`  | 1,000      | `add_node` | 39.293 ns               | 11% (11 / 100)    |
+| `small_get_node`  | 10         | `get_node` | 3.9417 ns               | 8% (8 / 100)      |
+| `medium_get_node` | 100        | `get_node` | 3.9849 ns               | 2% (2 / 100)      |
+| `large_get_node`  | 1,000      | `get_node` | 3.9916 ns               | 7% (7 / 100)      |
+
+* SMALL = 10;
+* MEDIUM = 100;
+* LARGE = 1000;
+
+Benchmark source code in [ultragraph/benches ](../ultragraph/benches/benchmarks)
+
+---
+
+* **`add_node` Performance:** Adding a node is consistently fast, with median times ranging from **29 to 46 nanoseconds
+  **. This confirms it as an efficient O(1) operation. The minor time variations are expected and are due to
+  system-level memory allocation behavior.
+* **`get_node` Performance:** Accessing a node is extremely fast and stable across all graph sizes, with a median time
+  of approximately **4 nanoseconds**. This demonstrates the O(1) efficiency of retrieving data from the underlying
+  `Vec`.
+* **Outliers:** The presence of outliers is normal for benchmarks running on a non-dedicated machine and indicates that
+  `Criterion` is correctly identifying and filtering system-level interruptions to provide a more accurate measurement.
+
+### Static CSM Graph
+
 | Operation       | Scale | Graph Configuration                          |  Mean Time  | Throughput (Est.)        |
 |:----------------|:------|:---------------------------------------------|:-----------:|:-------------------------|
 | **Edge Lookup** | Tiny  | `contains_edge` (Linear Scan, degree < 64)   | **~7.7 ns** | ~130 Million lookups/sec |
@@ -92,6 +122,8 @@ into a `DynamicGraph`, allowing the cycle of mutation and analysis to begin agai
 *(Note: Time units are nanoseconds (ns), microseconds (µs), and milliseconds (ms). Throughput is an approximate
 calculation based on the mean time.)*
 
+Benchmark source code in [deep_causality/benches ](../deep_causality/benches)
+
 ## Performance Design
 
 The design of `ultragraph`'s static analysis structure, `CsmGraph`, is based on the principles for high-performance

ultragraph/benches/benchmarks/bench_linear.rs

@@ -2,23 +2,24 @@
  * SPDX-License-Identifier: MIT
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
-
-use criterion::{Criterion, criterion_group};
-use rand::Rng;
-
+use criterion::{BatchSize, Criterion, criterion_group};
+use rand::{Rng, rng};
+use std::hint::black_box;
+// Use modern rand imports
 use ultragraph::*;
 
 use crate::benchmarks::data::Data;
 use crate::benchmarks::fields::{LARGE, MEDIUM, SMALL};
 use crate::benchmarks::utils;
 
-fn get_empty_ultra_graph(capacity: usize) -> UltraGraph<Data> {
-    let g: UltraGraphContainer<Data, _> = UltraGraph::with_capacity(capacity, None);
+// Type alias for convenience
+type UGraph = UltraGraph<Data>;
 
-    g
+fn get_empty_ultra_graph(capacity: usize) -> UGraph {
+    UltraGraph::with_capacity(capacity, None)
 }
 
-fn get_pre_filled_ultra_graph(capacity: usize) -> UltraGraph<Data> {
+fn get_pre_filled_ultra_graph(capacity: usize) -> UGraph {
     match capacity {
         SMALL => utils::build_linear_graph(SMALL),
         MEDIUM => utils::build_linear_graph(MEDIUM),
@@ -27,65 +28,47 @@ fn get_pre_filled_ultra_graph(capacity: usize) -> UltraGraph<Data> {
     }
 }
 
-fn small_add_node_benchmark(criterion: &mut Criterion) {
-    let capacity = SMALL;
-    let mut g = get_empty_ultra_graph(capacity);
-    criterion.bench_function("small_add_node", |bencher| {
-        bencher.iter(|| g.add_node(Data::default()))
+// Generic benchmark function for adding nodes to avoid repetition
+fn bench_add_node(c: &mut Criterion, name: &str, capacity: usize) {
+    let d = Data::default();
+
+    c.bench_function(name, |b| {
+        // Use iter_batched to create a new graph for each measurement
+        b.iter_batched(
+            || get_empty_ultra_graph(capacity), // SETUP: Create a fresh, empty graph
+            |mut g| g.add_node(d),              // ROUTINE: The operation to benchmark
+            BatchSize::LargeInput,              // A hint for criterion about the workload
+        );
     });
 }
 
-fn small_get_node_benchmark(criterion: &mut Criterion) {
-    let capacity = SMALL;
+// Generic benchmark function for getting nodes to avoid repetition
+fn bench_get_node(c: &mut Criterion, name: &str, capacity: usize) {
     let g = get_pre_filled_ultra_graph(capacity);
+    let mut rng = rng(); // Create RNG once
 
-    criterion.bench_function("small_get_node", |bencher| {
-        bencher.iter(|| g.get_node(rand::rng().random_range(0..capacity)))
-    });
-}
-
-fn medium_add_node_benchmark(criterion: &mut Criterion) {
-    let capacity = MEDIUM;
-    let mut g = get_empty_ultra_graph(capacity);
-    criterion.bench_function("medium_add_node", |bencher| {
-        bencher.iter(|| g.add_node(Data::default()))
+    c.bench_function(name, |b| {
+        b.iter(|| {
+            let index = rng.random_range(0..capacity);
+            black_box(g.get_node(index))
+        })
     });
 }
 
-fn medium_get_node_benchmark(criterion: &mut Criterion) {
-    let capacity = MEDIUM;
-    let g = get_pre_filled_ultra_graph(capacity);
+fn linear_graph_benchmarks(c: &mut Criterion) {
+    // Benchmarks for adding nodes
+    bench_add_node(c, "small_add_node", SMALL);
+    bench_add_node(c, "medium_add_node", MEDIUM);
+    bench_add_node(c, "large_add_node", LARGE);
 
-    criterion.bench_function("medium_get_node", |bencher| {
-        bencher.iter(|| g.get_node(rand::rng().random_range(0..capacity)))
-    });
-}
-
-fn large_add_node_benchmark(criterion: &mut Criterion) {
-    let capacity = LARGE;
-    let mut g = get_empty_ultra_graph(capacity);
-    criterion.bench_function("large_add_node", |bencher| {
-        bencher.iter(|| g.add_node(Data::default()))
-    });
-}
-
-fn large_get_node_benchmark(criterion: &mut Criterion) {
-    let capacity = LARGE;
-    let g = get_pre_filled_ultra_graph(capacity);
-
-    criterion.bench_function("array_push", |bencher| {
-        bencher.iter(|| g.get_node(rand::rng().random_range(0..capacity)))
-    });
+    // Benchmarks for getting nodes
+    bench_get_node(c, "small_get_node", SMALL);
+    bench_get_node(c, "medium_get_node", MEDIUM);
+    bench_get_node(c, "large_get_node", LARGE);
 }
 
 criterion_group! {
     name = liner_graph_bench_collection;
     config = Criterion::default().sample_size(100);
-    targets =
-    small_add_node_benchmark,
-    small_get_node_benchmark,
-    medium_add_node_benchmark,
-    medium_get_node_benchmark,
-    large_add_node_benchmark,
-    large_get_node_benchmark,
+    targets = linear_graph_benchmarks
 }

ultragraph/benches/benchmarks/utils.rs

@@ -8,7 +8,7 @@ use ultragraph::*;
 use crate::benchmarks::data::Data;
 
 pub fn build_linear_graph(k: usize) -> UltraGraph<Data> {
-    let mut g: UltraGraphContainer<Data, _> = UltraGraph::new();
+    let mut g: UltraGraphContainer<Data, _> = UltraGraph::with_capacity(k, None);
 
     let d = Data::default();