sgpu-compute 0.1.0

Simple GPU-Compute using WebGPU
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

use crate::*;
use std::ops::{Deref, DerefMut};

/// This is a blocking version of `GpuComputeAsync`. It is enabled by the `blocking` feature. This feature is enabled by default.
pub struct GpuCompute(GpuComputeAsync);

impl GpuCompute {
    /// Blocking version of `GpuComputeAsync::new`.
    #[inline]
    pub fn new() -> Self {
        Self(pollster::block_on(GpuComputeAsync::new()))
    }

    /// Blocking version of `GpuComputeAsync::gen_pipeline`.
    #[inline]
    pub fn gen_pipeline<
        Input: bytemuck::Pod,
        Uniform: bytemuck::Pod,
        Output: bytemuck::Pod,
        const N: usize,
    >(
        &self,
        scratchpad_size: Option<NonZeroUsize>,
        stages: [StageDesc; N],
    ) -> Pipeline<Input, Uniform, Output, N> {
        Pipeline(pollster::block_on(
            self.0.gen_pipeline(scratchpad_size, stages),
        ))
    }
}

impl Deref for GpuCompute {
    type Target = GpuComputeAsync;

    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for GpuCompute {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

pub struct Pipeline<
    'a,
    Input: bytemuck::Pod,
    Uniform: bytemuck::Pod,
    Output: bytemuck::Pod,
    const N: usize,
>(PipelineAsync<'a, Input, Uniform, Output, N>);

impl<'a, Input: bytemuck::Pod, Uniform: bytemuck::Pod, Output: bytemuck::Pod, const N: usize>
    Pipeline<'a, Input, Uniform, Output, N>
{
    /// Blocking version of `PipelineAsync::run`.
    #[inline]
    pub fn run<T: Send + 'static>(
        &mut self,
        input: &Input,
        workgroups: [(u32, u32, u32); N],
        callback: impl FnOnce(&Output) -> T + Send,
    ) -> T {
        pollster::block_on(self.0.run(input, workgroups, callback))
    }
}

impl<'a, Input: bytemuck::Pod, Uniform: bytemuck::Pod, Output: bytemuck::Pod, const N: usize> Deref
    for Pipeline<'a, Input, Uniform, Output, N>
{
    type Target = PipelineAsync<'a, Input, Uniform, Output, N>;

    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<'a, Input: bytemuck::Pod, Uniform: bytemuck::Pod, Output: bytemuck::Pod, const N: usize>
    DerefMut for Pipeline<'a, Input, Uniform, Output, N>
{
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}