Add basic LAGraph expression evaluation

.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.toml

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

_typos.toml

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

build.rs

@@ -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");
+}

src/eval.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)
+}