path_resolver 0.2.9

Provides a trie-based data structure to track and resolve relative path ownership across multiple packages
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use divan::{Bencher, black_box};
use path_resolver::{PackageName, PathResolver};
use std::path::PathBuf;

fn main() {
    divan::main();
}

fn generate_test_paths(size: usize, depth: usize) -> Vec<PathBuf> {
    let mut paths = Vec::with_capacity(size);

    for i in 0..size {
        let mut path = PathBuf::new();

        // Create nested directory structure
        for d in 0..depth {
            path.push(format!("dir_{d}"));
        }

        // Add a file at the end
        path.push(format!("file_{i}.txt"));
        paths.push(path);
    }

    paths
}

/// Generate conflicting paths by just adding duplicates.
fn generate_conflicting_paths(base_size: usize) -> Vec<PathBuf> {
    let mut paths = Vec::with_capacity(base_size);

    for i in 0..base_size / 2 {
        paths.push(PathBuf::from(format!("shared/file_{i}.txt")));
        paths.push(PathBuf::from(format!("shared/file_{i}.txt")));
    }

    paths
}

#[divan::bench(args = [10, 100, 1000, 5000, 10000])]
fn insert_package_no_conflicts(bencher: Bencher<'_, '_>, size: usize) {
    let paths = generate_test_paths(size, 3);
    let package_name: PackageName = "test_package".into();

    bencher.bench_local(|| {
        let mut resolver = black_box(PathResolver::new());
        let conflicts = resolver.insert_package(black_box(package_name.clone()), black_box(&paths));
        black_box(conflicts)
    });
}

#[divan::bench(args = [10, 100, 500, 2000, 5000])]
fn insert_package_with_conflicts(bencher: Bencher<'_, '_>, size: usize) {
    let paths1 = generate_test_paths(size / 2, 2);
    let paths2 = generate_conflicting_paths(size);

    bencher.bench_local(|| {
        let mut resolver = black_box(PathResolver::new());

        // Insert first package
        let _ = resolver.insert_package("package1".into(), black_box(&paths1));

        // Insert second package with conflicts
        let conflicts = resolver.insert_package("package2".into(), black_box(&paths2));
        black_box(conflicts)
    });
}

#[divan::bench(args = [5, 10, 20, 50, 100])]
fn insert_multiple_packages(bencher: Bencher<'_, '_>, num_packages: usize) {
    let paths_per_package = generate_test_paths(50, 2);

    bencher.bench_local(|| {
        let mut resolver = black_box(PathResolver::new());

        for i in 0..num_packages {
            let package_name: PackageName = format!("package_{i}").into();
            let conflicts =
                resolver.insert_package(black_box(package_name), black_box(&paths_per_package));
            black_box(conflicts);
        }

        resolver
    });
}

#[divan::bench(args = [1, 2, 3, 4, 5, 8, 12])]
fn insert_package_varying_depth(bencher: Bencher<'_, '_>, depth: usize) {
    let paths = generate_test_paths(100, depth);
    let package_name: PackageName = "test_package".into();

    bencher.bench_local(|| {
        let mut resolver = black_box(PathResolver::new());
        let conflicts = resolver.insert_package(black_box(package_name.clone()), black_box(&paths));
        black_box(conflicts)
    });
}

#[divan::bench(args = [1000, 5000, 10000, 25000])]
fn insert_package_heavy_stress(bencher: Bencher<'_, '_>, size: usize) {
    let paths = generate_test_paths(size, 5);
    let package_name: PackageName = "heavy_package".into();

    bencher.bench_local(|| {
        let mut resolver = black_box(PathResolver::new());
        let conflicts = resolver.insert_package(black_box(package_name.clone()), black_box(&paths));
        black_box(conflicts)
    });
}

#[divan::bench(args = [100, 500, 1000])]
fn insert_multiple_heavy_packages(bencher: Bencher<'_, '_>, num_packages: usize) {
    let paths_per_package = generate_test_paths(200, 3);

    bencher.bench_local(|| {
        let mut resolver = black_box(PathResolver::new());

        for i in 0..num_packages {
            let package_name: PackageName = format!("heavy_package_{i}").into();
            let conflicts =
                resolver.insert_package(black_box(package_name), black_box(&paths_per_package));
            black_box(conflicts);
        }

        resolver
    });
}

#[divan::bench(args = [1000, 5000, 10000])]
fn insert_package_massive_conflicts(bencher: Bencher<'_, '_>, size: usize) {
    // Create paths where every file will conflict
    let mut conflicting_paths = Vec::with_capacity(size);
    for i in 0..size {
        conflicting_paths.push(PathBuf::from(format!("shared_file_{}.txt", i % 100)));
        // Reuse filenames to force conflicts
    }

    bencher.bench_local(|| {
        let mut resolver = black_box(PathResolver::new());

        let _ = resolver.insert_package(
            "package1".into(),
            black_box(&conflicting_paths[0..size / 2]),
        );

        let conflicts = resolver.insert_package("package2".into(), black_box(&conflicting_paths));
        black_box(conflicts)
    });
}