bitdag 0.1.4

A crate to deconstruct the hierrachie of a DAG into a Bitmatrix for fast child-parent-queries.
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

#![cfg(feature = "json_ontology")]
use bitdag::bitdag::BitDag;
use criterion::{Criterion, black_box, criterion_group, criterion_main};
use ontolius::TermId;
use ontolius::io::OntologyLoaderBuilder;
use ontolius::ontology::HierarchyWalks;
use ontolius::ontology::csr::FullCsrOntology;
use ontology_registry::{
    BioRegistryMetadataProvider, FileSystemOntologyRegistry, FileType, OboLibraryProvider,
    OntologyRegistration, RegistryKey, SupportedOntology, Version,
};
use std::path::PathBuf;
use std::str::FromStr;

static ROOT_NODE: &str = "HP:0000118";
static TARGET_NODE: &str = "HP:0032708";
fn load_test_data() -> FullCsrOntology {
    let manifest_dir = PathBuf::from_str(env!("CARGO_MANIFEST_DIR")).unwrap();
    let registry_dir = manifest_dir.join("tests/assets/");
    let registry = FileSystemOntologyRegistry::new(
        registry_dir,
        BioRegistryMetadataProvider::default(),
        OboLibraryProvider::default(),
    );

    let reg_key = RegistryKey::new(SupportedOntology::HP, Version::Latest, FileType::Json);

    let reader = registry.register(reg_key).unwrap();

    OntologyLoaderBuilder::new()
        .obographs_parser()
        .build()
        .load_from_read(reader)
        .expect("Failed to load test ontology")
}

fn bench_queries(c: &mut Criterion) {
    let mut group = c.benchmark_group("Descendant Queries");

    let ontology = load_test_data();
    let target_node_ontolius = TermId::from_str(TARGET_NODE).unwrap();

    let bitdag = BitDag::from_graph(&ontology, ROOT_NODE).unwrap();

    group.bench_function("BitDag::get_descendants", |b| {
        b.iter(|| {
            let descendants = bitdag.get_ancestors(black_box(TARGET_NODE)).unwrap();
            black_box(descendants);
        })
    });

    group.bench_function("Ontolius::native_descendants", |b| {
        b.iter(|| {
            let mut all_descendants = Vec::new();
            for child in ontology.iter_ancestor_ids(black_box(&target_node_ontolius)) {
                all_descendants.push(child);
            }
            black_box(all_descendants);
        })
    });

    group.finish();
}

fn bench_construction(c: &mut Criterion) {
    let mut group = c.benchmark_group("Graph Construction");
    let ontology = load_test_data();

    group.bench_function("BitDag::from_graph", |b| {
        b.iter(|| {
            let dag = BitDag::from_graph(black_box(&ontology), black_box(ROOT_NODE)).unwrap();
            black_box(dag);
        })
    });

    group.finish();
}

criterion_group!(benches, bench_queries, bench_construction);
criterion_main!(benches);