Add basic LAGraph expression evaluation

georgiy-belyanin · georgiy-belyanin · commit 790df0281a28 · 2025-08-03T09:57:51.000+03:00
This patch introduces basic RPQ evaluation logic. It basically interfaces the LAGraph (experimental) library that offers a collection of the sparse linear algebra-based algorithms. It uses GraphBLAS [^1] as a backend library for evaluating sparse matrix algebra. Rust <-> C interfacing is done via FFI. Currently, the project requires our fork [^2] since the required algorithm is not upstreamed yet. If you are reading this and notice we occasionally have removed this from the fork we are asking for an excuse and hope that you will be able to find the suitable algorithm by yourself from the interfaces described on the Rust side. [^1] https://github.com/DrTimothyAldenDavis/GraphBLAS [^2] https://github.com/SparseLinearAlgebra/LAGraph
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -15,9 +15,24 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          submodules: recurse
       - uses: crate-ci/typos@master
       - run: rustup update stable && rustup default stable
       - run: cargo fmt --check
       - run: cargo clippy
+      - run: |
+          git clone https://github.com/DrTimothyAldenDavis/GraphBLAS.git
+          cd GraphBLAS
+          git checkout tags/v${{ matrix.config.grb_version }}
+          make compact
+          sudo make install
+          cd ..
+      - run: |
+          cd vendor/LAGraph
+          git checkout rpq-matrix
+          make
+          sudo make install
+          cd ../..
       - run: cargo build --verbose
       - run: cargo test --verbose
diff --git a/.gitmodules b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "vendor/LAGraph"]
+	path = vendor/LAGraph
+	url = https://github.com/SparseLinearAlgebra/LAGraph.git
diff --git a/build.rs b/build.rs
@@ -0,0 +1,7 @@
+fn main() {
+    println!("cargo:rustc-link-lib=dylib=lagraphx");
+    println!("cargo:rustc-link-search=native=../rpq-matrix-lagraph/LAGraph/build/experimental");
+
+    println!("cargo:rustc-link-lib=dylib=lagraph");
+    println!("cargo:rustc-link-search=native=../rpq-matrix-lagraph/LAGraph/build/src");
+}
diff --git a/src/eval.rs b/src/eval.rs
@@ -0,0 +1,120 @@
+use std::ptr::null_mut;
+
+use crate::graph::Graph;
+use crate::plan::Plan;
+use std::collections::HashMap;
+
+#[repr(C)]
+pub enum RpqMatrixOp {
+    Label,
+    Lor,
+    Concat,
+    Kleene,
+    KleeneL,
+    KleeneR,
+}
+
+#[repr(C)]
+pub struct RpqMatrixPlan {
+    pub op: RpqMatrixOp,
+    pub lhs: *mut RpqMatrixPlan,
+    pub rhs: *mut RpqMatrixPlan,
+    pub mat: *mut libc::c_void,
+    pub res_mat: *mut libc::c_void,
+}
+
+#[link(name = "lagraphx")]
+extern "C" {
+    pub fn LAGraph_RpqMatrix_initialize() -> libc::c_longlong;
+    pub fn LAGraph_RPQMatrix(plan: *mut RpqMatrixPlan, msg: *mut libc::c_char) -> libc::c_longlong;
+    pub fn LAGraph_RPQMatrix_label(
+        mat: *mut *mut libc::c_void,
+        x: usize,
+        i: usize,
+        j: usize,
+    ) -> libc::c_longlong;
+}
+
+#[link(name = "lagraph")]
+extern "C" {
+    pub fn LAGraph_MMRead(
+        mat: *mut *mut libc::c_void,
+        f: *mut libc::FILE,
+        msg: *mut libc::c_char,
+    ) -> libc::c_int;
+}
+
+pub fn eval(graph: &Graph, expr: egg::RecExpr<Plan>) {
+    let mut plans: HashMap<egg::Id, RpqMatrixPlan> = HashMap::with_capacity(expr.len());
+    expr.items().for_each(|(id, plan)| {
+        let eval_plan = match plan {
+            &Plan::Seq([lhs, rhs]) => RpqMatrixPlan {
+                op: RpqMatrixOp::Concat,
+                lhs: plans.get_mut(&lhs).unwrap() as *mut RpqMatrixPlan,
+                rhs: plans.get_mut(&rhs).unwrap() as *mut RpqMatrixPlan,
+                res_mat: null_mut(),
+                mat: null_mut(),
+            },
+            &Plan::Alt([lhs, rhs]) => RpqMatrixPlan {
+                op: RpqMatrixOp::Lor,
+                lhs: plans.get_mut(&lhs).unwrap() as *mut RpqMatrixPlan,
+                rhs: plans.get_mut(&rhs).unwrap() as *mut RpqMatrixPlan,
+                res_mat: null_mut(),
+                mat: null_mut(),
+            },
+            &Plan::Star([lhs]) => RpqMatrixPlan {
+                op: RpqMatrixOp::Kleene,
+                lhs: null_mut(),
+                rhs: plans.get_mut(&lhs).unwrap() as *mut RpqMatrixPlan,
+                res_mat: null_mut(),
+                mat: null_mut(),
+            },
+            &Plan::LStar([lhs, rhs]) => RpqMatrixPlan {
+                op: RpqMatrixOp::KleeneL,
+                lhs: plans.get_mut(&lhs).unwrap() as *mut RpqMatrixPlan,
+                rhs: plans.get_mut(&rhs).unwrap() as *mut RpqMatrixPlan,
+                res_mat: null_mut(),
+                mat: null_mut(),
+            },
+            &Plan::RStar([lhs, rhs]) => RpqMatrixPlan {
+                op: RpqMatrixOp::KleeneR,
+                lhs: plans.get_mut(&lhs).unwrap() as *mut RpqMatrixPlan,
+                rhs: plans.get_mut(&rhs).unwrap() as *mut RpqMatrixPlan,
+                res_mat: null_mut(),
+                mat: null_mut(),
+            },
+            Plan::Label(meta) => {
+                let mut mat: *mut libc::c_void = std::ptr::null_mut();
+                let mat = *graph
+                    .mats
+                    .get(&meta.name)
+                    .or({
+                        graph.verts.get(&meta.name).map(|vert_idx| {
+                            unsafe {
+                                LAGraph_RPQMatrix_label(
+                                    &mut mat as *mut *mut libc::c_void,
+                                    *vert_idx,
+                                    graph.verts.len(),
+                                    graph.verts.len(),
+                                );
+                            }
+                            &mat
+                        })
+                    })
+                    .unwrap();
+                RpqMatrixPlan {
+                    op: RpqMatrixOp::Label,
+                    lhs: null_mut(),
+                    rhs: null_mut(),
+                    res_mat: null_mut(),
+                    mat,
+                }
+            }
+        };
+        plans.insert(id, eval_plan);
+    });
+    let (_id, plan) = plans.iter_mut().last().unwrap();
+    unsafe {
+        LAGraph_RPQMatrix(plan as *mut RpqMatrixPlan, null_mut());
+    }
+}
diff --git a/src/graph.rs b/src/graph.rs
@@ -1,18 +1,26 @@
-use std::{collections::HashMap, io, path::Path};
+use std::{
+    collections::HashMap,
+    ffi::CString,
+    io,
+    path::{Path, PathBuf},
+};
 
 use egg::{Id, RecExpr};
 
 use crate::{
-    plan::Plan,
+    eval::LAGraph_MMRead,
+    plan::{LabelMeta, Plan},
     query::{Pattern, Query, Vertex},
 };
 
 pub struct Graph {
     nvals: HashMap<String, usize>,
+    pub mats: HashMap<String, *mut libc::c_void>,
+    pub verts: HashMap<String, usize>,
 }
 
 impl Graph {
-    fn plan_aux(&self, expr: &mut RecExpr<Plan>, pattern: Pattern) -> Id {
+    fn plan_aux(&self, expr: &mut RecExpr<Plan>, pattern: Pattern) -> Result<Id, String> {
         match pattern {
             Pattern::Uri(uri) => Ok(expr.add(Plan::Label(LabelMeta {
                 nvals: *self
@@ -22,50 +30,65 @@ impl Graph {
                 name: uri,
             }))),
             Pattern::Seq(lhs, rhs) => {
-                let lhs = self.plan_aux(expr, *lhs);
-                let rhs = self.plan_aux(expr, *rhs);
-                expr.add(Plan::Seq([lhs, rhs]))
+                let lhs = self.plan_aux(expr, *lhs)?;
+                let rhs = self.plan_aux(expr, *rhs)?;
+                Ok(expr.add(Plan::Seq([lhs, rhs])))
             }
             Pattern::Alt(lhs, rhs) => {
-                let lhs = self.plan_aux(expr, *lhs);
-                let rhs = self.plan_aux(expr, *rhs);
-                expr.add(Plan::Alt([lhs, rhs]))
+                let lhs = self.plan_aux(expr, *lhs)?;
+                let rhs = self.plan_aux(expr, *rhs)?;
+                Ok(expr.add(Plan::Alt([lhs, rhs])))
             }
             Pattern::Star(lhs) => {
-                let lhs = self.plan_aux(expr, *lhs);
-                expr.add(Plan::Star([lhs]))
+                let lhs = self.plan_aux(expr, *lhs)?;
+                Ok(expr.add(Plan::Star([lhs])))
             }
             Pattern::Plus(lhs) => {
-                let lhs = self.plan_aux(expr, *lhs);
+                let lhs = self.plan_aux(expr, *lhs)?;
                 let aux = expr.add(Plan::Star([lhs]));
-                expr.add(Plan::Seq([lhs, aux]))
+                Ok(expr.add(Plan::Seq([lhs, aux])))
+            }
+            Pattern::Opt(_lhs) => {
+                todo!("opt (?) queries are not supported yet")
             }
-            _ => todo!("TBD"),
         }
     }
 
-    pub fn run(&self, query: Query) -> RecExpr<Plan> {
+    pub fn run(&self, query: Query) -> Result<RecExpr<Plan>, String> {
         let mut expr: RecExpr<Plan> = RecExpr::default();
         match query {
             Query {
-                src: Vertex::Con(_v),
+                src: Vertex::Any,
+                pattern,
+                dest: Vertex::Any,
+            } => self.plan_aux(&mut expr, pattern)?,
+            Query {
+                src: Vertex::Con(name),
                 pattern,
                 dest: Vertex::Any,
             } => {
-                // TODO: add src vertex knowledge.
-                self.plan_aux(&mut expr, pattern)
+                let lhs = expr.add(Plan::Label(LabelMeta { name, nvals: 1 }));
+                let rhs = self.plan_aux(&mut expr, pattern)?;
+                expr.add(Plan::Seq([lhs, rhs]))
             }
             Query {
                 src: Vertex::Any,
                 pattern,
-                dest: Vertex::Con(_v),
+                dest: Vertex::Con(name),
+            } => {
+                let lhs = self.plan_aux(&mut expr, pattern)?;
+                let rhs = expr.add(Plan::Label(LabelMeta { name, nvals: 1 }));
+                expr.add(Plan::Seq([lhs, rhs]))
+            }
+            Query {
+                src: Vertex::Con(_v1),
+                pattern: _,
+                dest: Vertex::Con(_v2),
             } => {
-                // TODO: add dest vertex knowledge.
-                self.plan_aux(&mut expr, pattern)
+                todo!("con to con queries are not supported yet")
             }
-            _ => todo!("TBD"),
         };
-        expr
+        Ok(expr)
     }
 }
 
@@ -84,16 +107,36 @@ pub fn load_dir(path: &Path) -> io::Result<Graph> {
         })
         .collect();
 
-    let nvals: HashMap<String, usize> = dirs
+    let verts_file = path.join("vertices.txt");
+    let verts: HashMap<String, usize> = std::fs::read_to_string(verts_file)?
+        .lines()
+        .filter_map(|line| {
+            let mut splits = line.split_whitespace();
+            let vert = splits.next()?;
+            let vert = vert[1..vert.len() - 1].to_string();
+            let num = splits.next()?.parse::<usize>().ok()?;
+            Some((vert, num))
+        })
+        .collect();
+
+    let mat_files: Vec<(String, PathBuf)> = dirs
         .flatten()
         .map(|entry| entry.path())
         .filter_map(|entry| Some(entry.file_stem()?.to_str()?.to_string()))
         .filter_map(|entry| entry.parse::<usize>().ok())
         .filter_map(|entry| {
-            let edge = edges.get(&entry)?;
-            let edge_file = path.join(format!("{}.txt", entry));
+            Some((
+                edges.get(&entry)?.clone(),
+                path.join(format!("{}.txt", entry)),
+            ))
+        })
+        .collect();
+
+    let nvals: HashMap<String, usize> = mat_files
+        .iter()
+        .filter_map(|(edge, file)| {
             // TODO: read only first 3 lines :/.
-            let edge_nvals = std::fs::read_to_string(edge_file)
+            let edge_nvals = std::fs::read_to_string(file)
                 .ok()?
                 .lines()
                 .nth(2)?
@@ -106,5 +149,28 @@ pub fn load_dir(path: &Path) -> io::Result<Graph> {
         })
         .collect();
 
-    Ok(Graph { nvals })
+    let mats: HashMap<String, *mut libc::c_void> = mat_files
+        .iter()
+        .map(|(edge, file)| {
+            let mut mat: *mut libc::c_void = std::ptr::null_mut();
+            unsafe {
+                let c_file = CString::new(file.to_str().unwrap()).unwrap();
+                let mode = CString::new("r").unwrap();
+                let f = libc::fopen(c_file.as_ptr(), mode.as_ptr());
+                let code =
+                    LAGraph_MMRead(&mut mat as *mut *mut libc::c_void, f, std::ptr::null_mut());
+                assert_eq!(
+                    code,
+                    0,
+                    "unable to load matrix for {} in {} (error {})",
+                    edge,
+                    file.display(),
+                    code
+                );
+            };
+            (edge.clone(), mat)
+        })
+        .collect();
+
+    Ok(Graph { nvals, mats, verts })
 }
diff --git a/src/main.rs b/src/main.rs
diff --git a/vendor/LAGraph b/vendor/LAGraph

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+[submodule "vendor/LAGraph"]`
	`2`	`+ path = vendor/LAGraph`
	`3`	`+ url = https://github.com/SparseLinearAlgebra/LAGraph.git`