vyre 0.1.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
49
50
51
52
53

mod support;
#[path = "gpu/cases.rs"]
mod gpu;

#[test]
fn test_eval_shader_compiles() {
    let _ = pollster::block_on(async {
        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());
        let adapter = instance.request_adapter(&wgpu::RequestAdapterOptions::default()).await.unwrap();
        let (device, _) = adapter.request_device(&wgpu::DeviceDescriptor::default(), None).await.unwrap();
        
        let shader_src = rulefire::shaders::eval_shader::build_eval_shader(64);
        
        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("test eval shader"),
            source: wgpu::ShaderSource::Wgsl(shader_src.into()),
        });
        
        let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
            label: Some("test eval pipeline"),
            layout: None,
            module: &shader,
            entry_point: Some("main"),
            compilation_options: Default::default(),
            cache: None,
        });
        
        let _ = pipeline.get_bind_group_layout(0);
    });
}

use rulefire::index::CompiledRuleIndex;
use rulefire::vm::bytecode::{Opcode, Program};

#[test]
fn test_execute_gpu_direct() {
    let program = Program {
        instructions: vec![
            rulefire::vm::bytecode::Instruction::new(Opcode::PushTrue, 0),
            rulefire::vm::bytecode::Instruction::new(Opcode::Halt, 0),
        ],
    };
    let index = CompiledRuleIndex::from_programs(vec![("rule1".to_string(), program)], &[]).unwrap();
    let (device, queue) = pollster::block_on(async {
        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());
        let adapter = instance.request_adapter(&wgpu::RequestAdapterOptions::default()).await.unwrap();
        adapter.request_device(&wgpu::DeviceDescriptor::default(), None).await.unwrap()
    });
    let file_ctx = rulefire::FileContext::from_bytes(b"test");
    let hits = rulefire::gpu::gpu_pipeline::execute_gpu(&device, &queue, &index, &[], b"test", file_ctx).unwrap();
    assert_eq!(hits.len(), 1);
    assert!(hits[0]);
}