vyre-libs 0.6.2

vyre Category A library ecosystem - pure-IR compositions over vyre-ops hardware primitives
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

use super::flush::flush_active_macro_segment_inner;
use super::*;

pub(crate) fn flush_macro_segment_ranges(
    dispatcher: &dyn GpuDispatcher,
    file_path: &std::path::Path,
    include_stack: &[std::path::PathBuf],
    parent_classified: &ClassifiedTokens,
    segment_start: usize,
    macros: &[MacroDef],
    macro_events: &[MacroEvent],
    macro_expansion_cache: &mut MacroExpansionCache,
    segment: &mut Vec<u8>,
    output: &mut Vec<u8>,
    macro_expansion_events: &mut Vec<MacroExpansionEvent>,
    token_provenance_events: &mut Vec<TokenProvenanceEvent>,
    ranges: Vec<(usize, usize)>,
) -> Result<(), String> {
    let mut original = std::mem::take(segment);
    if ranges.len() == 1 {
        let (chunk_start, chunk_end) = ranges[0];
        if chunk_start == 0 && chunk_end == original.len() {
            return flush_active_macro_segment_inner(
                dispatcher,
                file_path,
                include_stack,
                parent_classified,
                segment_start,
                macros,
                macro_events,
                macro_expansion_cache,
                &mut original,
                output,
                macro_expansion_events,
                token_provenance_events,
                0,
            );
        }
    }

    let max_chunk_len = ranges
        .iter()
        .map(|(chunk_start, chunk_end)| chunk_end.saturating_sub(*chunk_start))
        .max()
        .unwrap_or(0);
    let mut chunk = macro_expansion_cache.take_range_chunk_scratch();
    if chunk.capacity() < max_chunk_len {
        let additional = max_chunk_len - chunk.capacity();
        chunk.try_reserve_exact(additional).map_err(|error| {
            format!(
                "vyre-libs::gpu_pipeline: could not reserve {additional} macro segment shard bytes: {error:?}. Fix: shard macro segment ranges before GPU macro expansion."
            )
        })?;
    }
    let result = (|| {
        for (chunk_start, chunk_end) in ranges {
            let chunk_bytes = original
                    .get(chunk_start..chunk_end)
                    .ok_or_else(|| {
                        "vyre-libs::gpu_pipeline: macro segment shard range outside source. Fix: repair shard range generation.".to_string()
                    })?;
            chunk.clear();
            chunk.extend_from_slice(chunk_bytes);
            flush_active_macro_segment_inner(
                dispatcher,
                file_path,
                include_stack,
                parent_classified,
                segment_start + chunk_start,
                macros,
                macro_events,
                macro_expansion_cache,
                &mut chunk,
                output,
                macro_expansion_events,
                token_provenance_events,
                0,
            )?;
        }
        Ok(())
    })();
    macro_expansion_cache.store_range_chunk_scratch(chunk);
    result
}