Crate hac

HAC

Hardware Accelerated Computing API via the GPU, built on top of wgpu for achieving great portability.

Example: Add arrays

use rand::Rng;

// wgpu's default `max_workgroups_per_dimension`
// can be changed using `hac::Limits` on Context creation
const N: usize = 1 << 16 - 1;

const KERNEL_SOURCE: &'static str = r#"
struct ComputeInput {
    // wgsl builtin variables can be found in the following link
    // https://www.w3.org/TR/WGSL/#builtin-values
    @builtin(global_invocation_id) id: vec3<u32>,
}

@group(0) @binding(0)
var<storage, read> a: array<f32>;
@group(0) @binding(1)
var<storage, read> b: array<f32>;
@group(0) @binding(2)
var<storage, read_write> c: array<f32>;

@compute @workgroup_size(1)
fn main(input: ComputeInput) {
    let i = input.id.x;
    c[i] = a[i] + b[i];
}"#;


fn main() {
    let context = hac::Context::new(&hac::ContextInfo::default());

    let mut rng = rand::thread_rng();

    let mut a = vec![0.0f32; N];
    rng.fill(&mut a[..]);

    let mut b = vec![0.0f32; N];
    rng.fill(&mut b[..]);

    let buf_a = context.buffer_from_slice(&a);    // input
    let buf_b = context.buffer_from_slice(&b);    // input
    let buf_c = context.buffer::<f32>(N as u64);  // output

    let bind_group = context
        .bind_group_descriptor()
        .push_buffer(&buf_a, hac::BufferAccess::ReadOnly)  // @binding(0)
        .push_buffer(&buf_b, hac::BufferAccess::ReadOnly)  // @binding(1)
        .push_buffer(&buf_c, hac::BufferAccess::ReadWrite) // @binding(2)
        .into_bind_group();

    let program = context.program_from_wgsl(KERNEL_SOURCE);

    let kernel = context.kernel(&hac::KernelInfo {
        program: &program,
        entry_point: "main",
        bind_groups: &[&bind_group], // each index corresponds to the group
                                     // each binding of `bind_group` is in @group(0)
        push_constants_range: None,  // requires the `PUSH_CONSTANTS` feature
    });

    kernel.dispatch(hac::Range::d1(N as u32));

    let c = buf_c.read_to_vec(); // read result

    // check if the sums were performed correctly and print some results
    (0..N).for_each(|i| assert!((a[i] + b[i] - c[i]).abs() <= f32::EPSILON));
    (0..8).for_each(|i| println!("{:<11} + {:<11} = {}", a[i], b[i], c[i]));
}

Structs

Backends

Represents the backends that wgpu will use.

BindGroup

Hold the data necesary to set bind groups (a.k.a. descriptor sets) in the Kernel.

BindGroupDescriptor

Contains the information to create BindGroups.

Buffer

Buffer on the GPU that stores homogeneous data.

CommandQueue

Queue that holds Commands and executes them in FIFO order.

Context

Manager used to create resources

ContextInfo

Information to create a context.

Extent3d

Extent of a texture related operation.

Features

Features that are not guaranteed to be supported.

Image

Handle of an image stored in the GPU.

ImageDataLayout

Layout of a texture in a buffer’s memory.

ImageInfo

Information to create an Image.

Kernel

Program that executes on the device.

KernelInfo

Provides the info required to execute a kernel.

Limits

Represents the sets of limits an adapter/device supports.

Program

Wrapper of a wgpu::ShaderModule.

Range

3 dimensional range used to specify workgroup sizes when dispatching a kernel.

Sampler

Encodes information to determine the appropiate color that should be returned when sampling an image.

SamplerInfo

Information to create a sampler.

Enums

AddressMode

How edges should be handled in texture addressing.

BufferAccess

Specifies the storage access of the buffer in the kernel.

Command

Avaiable commands to execute in a CommandQueue.

FilterMode

Texel mixing mode when sampling between texels.

ImageSampleType

SamplerBindingType

Specific type of a sampler binding.

SamplerBorderColor

Color variation to use when sampler addressing mode is AddressMode::ClampToBorder

Functions

cast_slice

Cast &[A] into &[B].

Type Aliases

ImageDimension

ImageFormat

StorageImageAccess