vyre 0.4.0

GPU compute intermediate representation with a standard operation library
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

// Raw RFC 1951 DEFLATE decompression.

use crate::ir::{BufferDecl, DataType, Expr, Node, Program};
use crate::ops::compression::deflate_core;
use crate::ops::{AlgebraicLaw, OpSpec, BYTES_TO_BYTES_INPUTS, BYTES_TO_BYTES_OUTPUTS};

pub const LAWS: &[AlgebraicLaw] = &[AlgebraicLaw::Bounded { lo: 0, hi: 255 }];

/// Maximum decompressed bytes accepted per compressed input byte.
pub const MAX_OUTPUT_RATIO: usize = 1024;

/// Raw DEFLATE decompression operation.
#[derive(Debug, Clone, Copy, Default)]
pub struct DeflateDecompress;

impl DeflateDecompress {
    /// Declarative operation specification.
    pub const SPEC: OpSpec = OpSpec::composition(
        "compression.deflate_decompress",
        BYTES_TO_BYTES_INPUTS,
        BYTES_TO_BYTES_OUTPUTS,
        LAWS,
        Self::program,
    );

    /// Build the canonical dispatch guard program.
    #[must_use]
    pub fn program() -> Program {
        Program::new(
            vec![
                BufferDecl::read("input", 0, DataType::Bytes),
                BufferDecl::output("out", 1, DataType::Bytes),
            ],
            [1, 1, 1],
            vec![Node::if_then(
                Expr::gt(max_output_len(), max_allowed_len()),
                vec![Node::Return],
            )],
        )
    }
}

/// Decompress a raw DEFLATE byte stream with the Wave A bomb cap.
///
/// # Errors
///
/// Returns an actionable `Fix: ...` message when the stream is malformed or
/// would expand beyond [`MAX_OUTPUT_RATIO`].
pub fn decompress_bytes(input: &[u8]) -> Result<Vec<u8>, String> {
    let max_output = max_output_for_input(input.len())?;
    deflate_core::decompress(input, max_output)
}

pub fn max_output_for_input(input_len: usize) -> Result<usize, String> {
    input_len.checked_mul(MAX_OUTPUT_RATIO).ok_or_else(|| {
        "Fix: reject DEFLATE input whose max_output_ratio multiplication overflows.".to_string()
    })
}

pub fn max_output_len() -> Expr {
    Expr::buf_len("out")
}

pub fn max_allowed_len() -> Expr {
    Expr::mul(Expr::buf_len("input"), Expr::u32(MAX_OUTPUT_RATIO as u32))
}