#126: Vertices removed

Cargo.toml

@@ -21,7 +21,7 @@ regex = "1.8.1"
 lazy_static = "1.4.0"
 simple_logger = "4.1.0"
 micromap = { version = "0.0.12", features = ["serde"] }
-emap = {version = "0.0.8", features = ["serde"] }
+emap = {version = "0.0.12", features = ["serde"] }
 nohash-hasher = "0.2.0"
 libc = "0.2.142"
 sxd-xpath = "0.4.2"

src/bin/malloc.rs

@@ -19,7 +19,7 @@
 // SOFTWARE.
 
 use sodg::{Hex, Label, Sodg};
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 trait Book {
     fn price(&self) -> i64;
@@ -45,54 +45,53 @@ impl Book for Discounted {
     }
 }
 
-pub fn on_graph(total: usize) -> i64 {
-    let mut sum = 0;
-    let mut g: Sodg<16> = Sodg::empty(256);
+pub fn on_graph(total: usize) -> (i64, Duration) {
+    let mut g: Sodg<16> = Sodg::empty(total * 4);
     g.add(0);
+    let mut sum = 0;
+    let start = Instant::now();
+    let mut v1 = 1;
     for _ in 0..total {
-        let v1 = g.next_id();
         g.add(v1);
-        let v2 = v1 + 1;
-        g.add(v2);
-        g.bind(v1, v2, Label::Alpha(0));
-        let v3 = v2 + 1;
-        g.add(v3);
-        g.bind(v2, v3, Label::Greek('Δ'));
-        g.put(v3, &Hex::from(42));
-        let v4 = v3 + 1;
-        g.add(v4);
-        g.bind(v4, v1, Label::Greek('φ'));
-        assert!(g.kid(v4, Label::Alpha(0)).is_none());
-        g.kid(v4, Label::Greek('φ')).unwrap();
-        g.kid(v1, Label::Alpha(0)).unwrap();
-        let k = g.kid(v2, Label::Greek('Δ')).unwrap();
-        sum += g.data(k).unwrap().to_i64().unwrap() / 2;
+        // let v2 = v1 + 1;
+        // g.add(v2);
+        // g.bind(v1, v2, Label::Alpha(0));
+        // let v3 = v2 + 1;
+        // g.add(v3);
+        // g.bind(v2, v3, Label::Greek('Δ'));
+        // g.put(v3, &Hex::from(42));
+        // let v4 = v3 + 1;
+        // g.add(v4);
+        // g.bind(v4, v1, Label::Greek('φ'));
+        // assert!(g.kid(v4, Label::Alpha(0)).is_none());
+        // g.kid(v4, Label::Greek('φ')).unwrap();
+        // g.kid(v1, Label::Alpha(0)).unwrap();
+        // let k = g.kid(v2, Label::Greek('Δ')).unwrap();
+        // sum += g.data(k).unwrap().to_i64().unwrap() / 2;
+        v1 += 4;
     }
-    std::hint::black_box(sum)
+    (std::hint::black_box(sum), start.elapsed())
 }
 
-pub fn on_heap(total: usize) -> i64 {
+pub fn on_heap(total: usize) -> (i64, Duration) {
     let mut sum = 0;
+    let start = Instant::now();
     for _ in 0..total {
         let prime = Box::new(Prime { usd: 42 });
         let discounted = Box::new(Discounted { book: prime });
         let price = discounted.price();
         sum += std::hint::black_box(price);
     }
-    std::hint::black_box(sum)
+    (std::hint::black_box(sum), start.elapsed())
 }
 
 fn main() {
-    let total = 10000000;
-    let start1 = Instant::now();
-    let s1 = on_graph(total);
-    let e1 = start1.elapsed();
-    println!("on_graph: {:?}", e1);
-    let start2 = Instant::now();
-    let s2 = on_heap(total);
-    let e2 = start2.elapsed();
-    println!("on_heap: {:?}", e2);
-    println!("gain: {:.2}x", e2.as_nanos() as f64 / e1.as_nanos() as f64);
-    println!("loss: {:.2}x", e1.as_nanos() as f64 / e2.as_nanos() as f64);
+    let total = 1000000;
+    let (s1, d1) = on_graph(total);
+    println!("on_graph: {:?}", d1);
+    let (s2, d2) = on_heap(total);
+    println!("on_heap: {:?}", d2);
+    println!("gain: {:.2}x", d2.as_nanos() as f64 / d1.as_nanos() as f64);
+    println!("loss: {:.2}x", d1.as_nanos() as f64 / d2.as_nanos() as f64);
     assert_eq!(s1, s2);
 }

src/clone.rs

@@ -24,12 +24,11 @@ impl<const N: usize> Clone for Sodg<N> {
     /// Make a clone of the graph.
     fn clone(&self) -> Self {
         Self {
-            vertices: self.vertices.clone(),
+            alive: self.alive.clone(),
+            edges: self.edges.clone(),
+            data: self.data.clone(),
+            taken: self.taken.clone(),
             next_v: self.next_v,
-            alerts: vec![],
-            alerts_active: false,
-            #[cfg(feature = "sober")]
-            finds: self.finds.clone(),
         }
     }
 }
@@ -47,14 +46,14 @@ fn makes_a_clone() -> Result<()> {
     g.add(42);
     g.bind(1, 42, Label::Alpha(0));
     let c = g.clone();
-    assert_eq!(2, c.vertices.len());
+    assert_eq!(2, c.len());
     Ok(())
 }
 
 #[test]
 fn makes_an_empty_clone() -> Result<()> {
     let g: Sodg<16> = Sodg::empty(256);
     let c = g.clone();
-    assert_eq!(0, c.vertices.len());
+    assert_eq!(0, c.len());
     Ok(())
 }

src/ctors.rs

@@ -19,9 +19,6 @@
 // SOFTWARE.
 
 use crate::Sodg;
-use crate::Vertices;
-#[cfg(feature = "sober")]
-use std::collections::HashSet;
 
 impl<const N: usize> Sodg<N> {
     /// Make an empty [`Sodg`], with no vertices and no edges.
@@ -31,77 +28,24 @@ impl<const N: usize> Sodg<N> {
     /// May panic if vertices provided to alerts are absent (should never happen, though).
     #[must_use]
     pub fn empty(cap: usize) -> Self {
-        let mut g = Self {
-            vertices: Vertices::with_capacity(cap),
+        Self {
+            alive: Map::with_capacity_none(cap),
+            edges: Map::with_capacity_some(cap, micromap::Map::new()),
+            data: Map::with_capacity_none(cap),
+            taken: Map::with_capacity_none(cap),
             next_v: 0,
-            alerts: vec![],
-            alerts_active: true,
-            #[cfg(feature = "sober")]
-            finds: HashSet::new(),
-        };
-        g.alert_on(|g, vx| {
-            let mut errors = Vec::new();
-            for v in &vx {
-                for e in &g.vertices.get(*v).unwrap().edges {
-                    if !g.vertices.contains(e.1) {
-                        errors.push(format!("Edge ν{v}.{} arrives to lost ν{}", e.0, e.1));
-                    }
-                }
-            }
-            errors
-        });
-        g.alert_on(|g, vx| {
-            let mut errors = Vec::new();
-            for v in &vx {
-                for e in &g.vertices.get(*v).unwrap().edges {
-                    if e.1 == *v {
-                        errors.push(format!("Edge ν{v}.{} arrives to ν{} (loop)", e.0, e.1));
-                    }
-                }
-            }
-            errors
-        });
-        g.alert_on(|g, vx| {
-            let mut errors = Vec::new();
-            for v in &vx {
-                for e in &g.vertices.get(*v).unwrap().edges {
-                    if !g.vertices.contains(e.1) {
-                        errors.push(format!(
-                            "Edge ν{v}.{} points to ν{}, which doesn't exist",
-                            e.0, e.1
-                        ));
-                    }
-                }
-            }
-            errors
-        });
-        g.alerts_off();
-        #[cfg(feature = "sober")]
-        g.alerts_on().unwrap();
-        g
+        }
     }
 }
 
 #[cfg(test)]
 use anyhow::Result;
-
-#[cfg(test)]
-use crate::Label;
+use emap::Map;
 
 #[test]
 fn makes_an_empty_sodg() -> Result<()> {
     let mut g: Sodg<16> = Sodg::empty(256);
     g.add(0);
-    assert_eq!(1, g.vertices.len());
-    Ok(())
-}
-
-#[test]
-fn prohibits_loops() -> Result<()> {
-    let mut g: Sodg<16> = Sodg::empty(256);
-    g.alerts_off();
-    g.add(0);
-    g.bind(0, 0, Label::Alpha(0));
-    assert!(g.alerts_on().is_err());
+    assert_eq!(1, g.len());
     Ok(())
 }