Add basic LAGraph expression evaluation

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

Author: georgiy-belyanin

.github/workflows/ci.yml

@@ -15,9 +15,22 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          submodules: recursive
       - uses: crate-ci/typos@master
       - run: rustup update stable && rustup default stable
       - run: cargo fmt --check
       - run: cargo clippy
+      - run: |
+          git clone --depth 1 https://github.com/DrTimothyAldenDavis/GraphBLAS.git
+          cd GraphBLAS
+          make compact
+          sudo make install
+          cd ..
+      - run: |
+          cd vendor/LAGraph
+          make
+          sudo make install
+          cd ../..
       - run: cargo build --verbose
       - run: cargo test --verbose

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/LAGraph"]
+	path = vendor/LAGraph
+	url = https://github.com/SparseLinearAlgebra/LAGraph.git

Cargo.lock

@@ -10,3 +10,4 @@ egg = "0.10.0"
 nom = "7.1"
 expect-test = "1.5.1"
 libc = "0.2.0"
+rand = "0.8"

Cargo.toml

@@ -0,0 +1,2 @@
+[files]
+extend-exclude = ["vendor/"]

_typos.toml

@@ -0,0 +1,7 @@
+fn main() {
+    println!("cargo:rustc-link-lib=dylib=lagraphx");
+    println!("cargo:rustc-link-search=native=vendor/LAGraph/build/experimental");
+
+    println!("cargo:rustc-link-lib=dylib=lagraph");
+    println!("cargo:rustc-link-search=native=vendor/LAGraph/build/src");
+}

build.rs

@@ -0,0 +1,140 @@
+use std::ptr::null_mut;
+
+use crate::graph::Graph;
+use crate::grb;
+use crate::plan::Plan;
+
+#[repr(C)]
+#[derive(Clone)]
+pub enum RpqMatrixOp {
+    Label,
+    Lor,
+    Concat,
+    Kleene,
+    KleeneL,
+    KleeneR,
+}
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct RpqMatrixPlan {
+    pub op: RpqMatrixOp,
+    pub lhs: *mut RpqMatrixPlan,
+    pub rhs: *mut RpqMatrixPlan,
+    pub mat: grb::Matrix,
+    pub res_mat: grb::Matrix,
+}
+
+#[link(name = "lagraphx")]
+extern "C" {
+    pub fn LAGraph_Init(msg: *mut libc::c_char) -> libc::c_int;
+    pub fn LAGraph_DestroyRpqMatrixPlan(plan: *mut RpqMatrixPlan);
+    pub fn LAGraph_RPQMatrix(
+        ans: *mut usize,
+        plan: *mut RpqMatrixPlan,
+        msg: *mut libc::c_char,
+    ) -> libc::c_longlong;
+    pub fn LAGraph_RPQMatrix_label(
+        mat: *mut grb::Matrix,
+        x: usize,
+        i: usize,
+        j: usize,
+    ) -> libc::c_longlong;
+}
+
+#[link(name = "lagraph")]
+extern "C" {
+    pub fn LAGraph_MMRead(
+        mat: *mut grb::Matrix,
+        f: *mut libc::FILE,
+        msg: *mut libc::c_char,
+    ) -> libc::c_int;
+}
+
+pub fn eval(graph: &Graph, expr: egg::RecExpr<Plan>) -> Result<usize, String> {
+    let mut plans: Vec<RpqMatrixPlan> = vec![
+        RpqMatrixPlan {
+            op: RpqMatrixOp::Label,
+            lhs: null_mut(),
+            rhs: null_mut(),
+            mat: grb::Matrix::null(),
+            res_mat: grb::Matrix::null()
+        };
+        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::<usize>(lhs.into()).unwrap() as *mut RpqMatrixPlan,
+                rhs: plans.get_mut::<usize>(rhs.into()).unwrap() as *mut RpqMatrixPlan,
+                res_mat: grb::Matrix::null(),
+                mat: grb::Matrix::null(),
+            },
+            &Plan::Alt([lhs, rhs]) => RpqMatrixPlan {
+                op: RpqMatrixOp::Lor,
+                lhs: plans.get_mut::<usize>(lhs.into()).unwrap() as *mut RpqMatrixPlan,
+                rhs: plans.get_mut::<usize>(rhs.into()).unwrap() as *mut RpqMatrixPlan,
+                res_mat: grb::Matrix::null(),
+                mat: grb::Matrix::null(),
+            },
+            &Plan::Star([lhs]) => RpqMatrixPlan {
+                op: RpqMatrixOp::Kleene,
+                lhs: null_mut(),
+                rhs: plans.get_mut::<usize>(lhs.into()).unwrap() as *mut RpqMatrixPlan,
+                res_mat: grb::Matrix::null(),
+                mat: grb::Matrix::null(),
+            },
+            &Plan::LStar([lhs, rhs]) => RpqMatrixPlan {
+                op: RpqMatrixOp::KleeneL,
+                lhs: plans.get_mut::<usize>(lhs.into()).unwrap() as *mut RpqMatrixPlan,
+                rhs: plans.get_mut::<usize>(rhs.into()).unwrap() as *mut RpqMatrixPlan,
+                res_mat: grb::Matrix::null(),
+                mat: grb::Matrix::null(),
+            },
+            &Plan::RStar([lhs, rhs]) => RpqMatrixPlan {
+                op: RpqMatrixOp::KleeneR,
+                lhs: plans.get_mut::<usize>(lhs.into()).unwrap() as *mut RpqMatrixPlan,
+                rhs: plans.get_mut::<usize>(rhs.into()).unwrap() as *mut RpqMatrixPlan,
+                res_mat: grb::Matrix::null(),
+                mat: grb::Matrix::null(),
+            },
+            Plan::Label(meta) => {
+                let mut mat: grb::Matrix = grb::Matrix(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 grb::Matrix,
+                                    *vert_idx,
+                                    graph.verts.len(),
+                                    graph.verts.len(),
+                                );
+                            }
+                            &mat
+                        })
+                    })
+                    .unwrap()
+                    .clone();
+                RpqMatrixPlan {
+                    op: RpqMatrixOp::Label,
+                    lhs: null_mut(),
+                    rhs: null_mut(),
+                    res_mat: grb::Matrix::null(),
+                    mat,
+                }
+            }
+        };
+        plans[std::convert::Into::<usize>::into(id)] = eval_plan;
+    });
+    let plan = plans.iter_mut().last().unwrap();
+    let mut ans: usize = 0;
+    unsafe {
+        LAGraph_RPQMatrix(&mut ans, plan as *mut RpqMatrixPlan, null_mut());
+        LAGraph_DestroyRpqMatrixPlan(plan);
+    }
+    Ok(ans)
+}