vyre 0.3.0

GPU bytecode condition engine
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

use crate::error::Result;
use crate::index::CompiledRuleIndex;
use crate::pattern::RuleMatch;

impl CompiledRuleIndex {
    /// Evaluate pre-computed pattern matches on GPU.
    ///
    /// The caller runs warpstate pattern matching and passes the matches here.
    /// vyre evaluates all rule conditions on GPU in a single dispatch.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Gpu`] if no GPU adapter is available.
    #[cfg(feature = "gpu")]
    pub fn evaluate_matches(
        &self,
        file_bytes: &[u8],
        matches: &[matchkit::Match],
    ) -> Result<Vec<RuleMatch>> {
        let (device, queue) = crate::gpu::gpu_pipeline::cached_device()?;
        self.evaluate_matches_with_device(file_bytes, matches, device, queue)
    }

    /// Evaluate with an externally managed GPU device.
    #[cfg(feature = "gpu")]
    pub fn evaluate_matches_with_device(
        &self,
        file_bytes: &[u8],
        matches: &[matchkit::Match],
        device: &wgpu::Device,
        queue: &wgpu::Queue,
    ) -> Result<Vec<RuleMatch>> {
        let file_ctx = crate::file_context::FileContext::from_bytes(file_bytes);
        let rule_string_counts: Vec<usize> = self.rules.iter().map(|r| r.strings.len()).collect();
        let plan = crate::gpu::gpu_pipeline::GpuEvaluationPlan {
            rule_string_counts: &rule_string_counts,
            pattern_to_rules: &self.mapping.pattern_to_rules,
            rule_list: &self.mapping.rule_list,
            string_local_ids: &self.mapping.string_local_ids,
            sentinel_pattern_ids: &[],
            max_cached_positions: self.max_cached_positions,
        };
        let hit_bits = crate::gpu::gpu_pipeline::execute_gpu(
            device, queue, &self.programs, plan, matches, file_bytes, file_ctx,
        )?;
        Ok(self.materialize_matches(&hit_bits))
    }
}