pathrex 0.1.0

Library and CLI for benchmarking RPQ/CFL queries on edge-labeled graphs via SuiteSparse:GraphBLAS and LAGraph.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! Typed dispatch from CLI algorithm choices to concrete evaluators.

use crate::cli::args::{Algo, BenchArgs, QueryArgs};
use crate::cli::bench::error::BenchError;
use crate::cli::bench::runner::run_bench_for_evaluator;
use crate::cli::checkpoint::Checkpointer;
use crate::cli::loader::LoadedQuery;
use crate::cli::output::QueryResult;
use crate::cli::query::run_query_for_evaluator;
use crate::graph::InMemoryGraph;
use crate::rpq::nfarpq::NfaRpqEvaluator;
use crate::rpq::rpqmatrix::RpqMatrixEvaluator;

fn merge_results(all: &mut Vec<QueryResult>, per_algo: Vec<QueryResult>) {
    for result in per_algo {
        if let Some(existing) = all
            .iter_mut()
            .find(|existing| existing.query_index == result.query_index)
        {
            existing.algorithms.extend(result.algorithms);
        } else {
            all.push(result);
        }
    }
}

pub fn dispatch_query(
    args: &QueryArgs,
    graph: &InMemoryGraph,
    queries: &[LoadedQuery],
) -> Vec<QueryResult> {
    let mut all = Vec::new();

    for algo in &args.common.algo {
        let name = algo.to_string();
        let per_algo = match algo {
            Algo::NfaRpq => run_query_for_evaluator(&name, NfaRpqEvaluator, graph, queries),
            Algo::Rpqmatrix => run_query_for_evaluator(&name, RpqMatrixEvaluator, graph, queries),
        };
        merge_results(&mut all, per_algo);
    }

    all
}

pub fn dispatch_bench(
    args: &BenchArgs,
    graph: &InMemoryGraph,
    queries: &[LoadedQuery],
    checkpointer: &mut Checkpointer,
) -> Result<Vec<QueryResult>, BenchError> {
    let mut all = Vec::new();

    for algo in &args.common.algo {
        let name = algo.to_string();
        let per_algo = match algo {
            Algo::NfaRpq => run_bench_for_evaluator(
                args,
                algo,
                &name,
                NfaRpqEvaluator,
                graph,
                queries,
                checkpointer,
            )?,
            Algo::Rpqmatrix => run_bench_for_evaluator(
                args,
                algo,
                &name,
                RpqMatrixEvaluator,
                graph,
                queries,
                checkpointer,
            )?,
        };
        merge_results(&mut all, per_algo);
    }

    Ok(all)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::cli::output::AlgoResult;
    use std::collections::HashMap;

    #[test]
    fn merge_results_combines_algorithms_by_query_index() {
        let mut all = vec![QueryResult {
            query_index: 0,
            query_id: "q0".into(),
            query_text: "query".into(),
            algorithms: HashMap::from([("nfarpq".into(), AlgoResult::ok(Some(1), None))]),
        }];
        let per_algo = vec![QueryResult {
            query_index: 0,
            query_id: "q0".into(),
            query_text: "query".into(),
            algorithms: HashMap::from([("rpqmatrix".into(), AlgoResult::ok(Some(1), None))]),
        }];

        merge_results(&mut all, per_algo);

        assert_eq!(all.len(), 1);
        assert_eq!(all[0].algorithms.len(), 2);
    }
}