yang5 0.1.0

libyang5 bindings for Rust
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
109
110
111
112
113
114
115
116
117
118
119
120

use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use yang5::context::{Context, ContextFlags};
use yang5::data::{Data, DataDiffFlags, DataTree, DataValidationFlags};

static SEARCH_DIR: &str = "./assets/yang/";

fn data_generate(ctx: &Context, interfaces: u32) -> DataTree {
    let mut dtree = DataTree::new(ctx);

    for i in 1..=interfaces {
        let changes = [
            (format!("/ietf-interfaces:interfaces/interface[name='eth{}']", i), None),
            (format!("/ietf-interfaces:interfaces/interface[name='eth{}']/type", i), Some("iana-if-type:ethernetCsmacd")),
            (format!("/ietf-interfaces:interfaces/interface[name='eth{}']/enabled", i), Some("true")),
        ];

        for (xpath, value) in &changes {
            dtree
                .new_path(xpath, *value, false)
                .expect("Failed to edit data tree");
        }
    }

    dtree
}

fn criterion_benchmark(c: &mut Criterion) {
    let tree_sizes = [
        1 * 1024,
        2 * 1024,
        4 * 1024,
        8 * 1024,
        16 * 1024,
        32 * 1024,
        64 * 1024,
    ];

    // Initialize context.
    let mut ctx = Context::new(ContextFlags::NO_YANGLIBRARY)
        .expect("Failed to create context");
    ctx.set_searchdir(SEARCH_DIR)
        .expect("Failed to set YANG search directory");

    // Load YANG modules.
    for module_name in &["ietf-interfaces", "iana-if-type"] {
        ctx.load_module(module_name, None, &[])
            .expect("Failed to load module");
    }

    // Prepare DataTree.diff() benchmark.
    let mut group = c.benchmark_group("DataTree.diff() / tree size");
    for size in &tree_sizes {
        // Create artificial data trees.
        let dtree = data_generate(&ctx, *size);
        let dtree_base = data_generate(&ctx, *size + 1024);

        // Run benchmark.
        group.bench_with_input(
            BenchmarkId::from_parameter(size),
            size,
            |b, _| {
                b.iter(|| {
                    dtree
                        .diff(&dtree_base, DataDiffFlags::empty())
                        .expect("Failed to compare data trees");
                });
            },
        );
    }
    group.finish();

    // Prepare DataTree.find() benchmark.
    let mut group = c.benchmark_group("DataTree.find() / tree size");
    for size in &tree_sizes {
        // Create artificial data tree.
        let dtree = data_generate(&ctx, *size);

        // Run benchmark.
        group.bench_with_input(
            BenchmarkId::from_parameter(size),
            size,
            |b, _| {
                b.iter(|| {
                    for dnode in dtree.traverse() {
                        let path = dnode.path();
                        dtree.find_path(&path).expect("Failed to find data");
                    }
                });
            },
        );
    }
    group.finish();

    // Prepare DataTree.validate() benchmark.
    let mut group = c.benchmark_group("DataTree.validate() / tree size");
    for size in &tree_sizes {
        // Create artificial data tree.
        let mut dtree = data_generate(&ctx, *size);

        // Run benchmark.
        group.bench_with_input(
            BenchmarkId::from_parameter(size),
            size,
            |b, _| {
                b.iter(|| {
                    dtree
                        .validate(
                            DataValidationFlags::NO_STATE
                                | DataValidationFlags::PRESENT,
                        )
                        .expect("Failed to validate data tree")
                })
            },
        );
    }
    group.finish();
}

criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);