Returns information about all devices in the pool

Launches given `DeviceFnMut` with given arguments on the space of threads built so far You can provide the arguments using [`ArgsBuilder`](../device/

Uploads the given data `T` to self (a `DeviceBox<T>`) This function - as are most other functions in the Emu API - doesn't block. So the data transfe

TODO say what is blocking and what isn't in the comments Uploads data from the given borrow to `T` to the given `DeviceBox<T>` that lives on this (mea

Creates a shared variable using the given code ``` # use {emu_core::prelude::*, emu_glsl::*, zerocopy::*}; # fn main() -> Result<(), Box<dyn std::err

Constructs a [`Spawner`](struct.Spawner.html) with the given number of threads spawned Each `spawn(n)` will spawn a new dimension of threads of size

Adds a new dimension to the space of threads with size determined by the given number of threads

this tests that bad usage of launch (like launching things that can't be launched) is detected

this tests that bad usage of load and read macro are detected

this tests that we can detect when the #[gpu_use] macro is used incorrectly

this is currently only invoked once for each kernel to be launched so it basically just generates much of the kernel function signature and then goes

Appends a constant definition using the give left hand and right hand sides ``` # use {emu_core::prelude::*, emu_glsl::*, zerocopy::*}; # fn main() -

Adds the given helper code This helper code may include additional type or function definitions. ``` # use {emu_core::prelude::*, emu_glsl::*, zeroco

Adds the body code for the kernel This body code is simply wrapped in a `void main` function.

Declares an additional parameter - that is constant - to the compute kernel in this GLSL

Appends a new constant parameter to the kernel in this SPIR-V

Declares an additional parameter - that is mutable - to the compute kernel in this GLSL

Appends a new mutable parameter to the kernel in this SPIR-V

Gets all detected devices This is asynchronous because it may take a long time for all the devices that are detected to actually be available. Howeve

Declare a new arguments by passing in a `DeviceBox`

Finish building

Compiles the given source to `SpirvOrFinished` There are 4 things this function is generic over. 1. The source language which must be `Hash`able for

Compiles a `DeviceFnMut` using the given parameters, entry point name, and SPIR-V program The entry point is where in the SPIR-V program the compiled

Converts a slice of bytes to a slice of 4-byte words Just as a quick example... ``` # use {emu_core::prelude::*, emu_glsl::*, zerocopy::*}; # fn main

The devie ID (e.g. - 22807)

The device type (e.g. - Cpu)

don't fold on substructures of items closures can't contain return statements that return from this function

don't fold on substructures of items items can't use GPU argument to the function the item is in

don't fold on substructures of items items can't contain return statements that will return from this function

Create a constant `DeviceBox<T>` from a reference to `T`

Create a mutable `DeviceBox<T>` from a reference to `T`

Get a mutable reference to the code stored here This is useful when inspecting or linting the bytecode somehow before finishing compilation. If you d

looks at AttributeArgs in an invocation of #[gpu_use] to see what helper functions are declared for example, #[gpu_use] should return at empty Vec bu

gets information about the function this is always called only for functions that are tagged with #[gpu_use] if there is anything about the signature

Mutate the entry point name

Mutate the parameters

Returns information about the currently selected device