Struct ComputeDispatcher 

pub struct ComputeDispatcher { /* private fields */ }

Manages GPU buffers and dispatches parallel map/reduce operations.

This is a CPU-side simulation of GPU compute dispatch that uses a thread pool metaphor (sequential execution) for testing without a real GPU.

Implementations

impl ComputeDispatcher

pub fn new() -> Self

Create a new dispatcher with no buffers.

pub fn create_buffer( &mut self, size: usize, initial_data: Option<&[f64]>, ) -> BufferId

Allocate a new buffer of size f64 elements, optionally pre-loaded with initial_data. Returns the new buffer’s BufferId.

pub fn write_buffer( &mut self, id: BufferId, data: &[f64], ) -> Result<(), GpuError>

Write data into the buffer identified by id.

Errors

Returns GpuError::InvalidBuffer if id is not registered.

pub fn read_buffer(&self, id: BufferId) -> Result<Vec<f64>, GpuError>

Read the contents of the buffer identified by id.

Errors

Returns GpuError::InvalidBuffer if id is not registered.

pub fn num_buffers(&self) -> usize

Return the number of buffers currently managed.

pub fn has_buffer(&self, id: BufferId) -> bool

Check if a buffer exists.

pub fn buffer_size(&self, id: BufferId) -> Result<usize, GpuError>

Return the size of a buffer.

pub fn destroy_buffer(&mut self, id: BufferId) -> Result<(), GpuError>

Destroy (remove) a buffer.

pub fn copy_buffer( &mut self, src: BufferId, dst: BufferId, ) -> Result<(), GpuError>

Copy data from one buffer to another.

pub fn dispatch_map( &mut self, buf_in: BufferId, buf_out: BufferId, f: impl Fn(f64) -> f64, ) -> Result<(), GpuError>

Dispatch a parallel map: out[i] = f(in[i]) for every element.

Errors

Returns an error if either buffer is invalid or sizes differ.

pub fn dispatch_map_indexed( &mut self, buf_in: BufferId, buf_out: BufferId, f: impl Fn(usize, f64) -> f64, ) -> Result<(), GpuError>

Dispatch a parallel map with index: out[i] = f(i, in[i]).

pub fn dispatch_zip_map( &mut self, buf_a: BufferId, buf_b: BufferId, buf_out: BufferId, f: impl Fn(f64, f64) -> f64, ) -> Result<(), GpuError>

Dispatch a zip-map: out[i] = f(a[i], b[i]).

pub fn dispatch_reduce( &self, buf: BufferId, f: impl Fn(f64, f64) -> f64, ) -> Result<f64, GpuError>

Dispatch a parallel reduce: folds all elements in buf using f.

Mimics a GPU tree-reduction (sequential here for correctness).

Errors

Returns GpuError::InvalidBuffer or GpuError::EmptyBuffer.

pub fn dispatch_sph_density( &mut self, pos_buf: BufferId, mass_buf: BufferId, h: f64, out_density_buf: BufferId, ) -> Result<(), GpuError>

Dispatch a mock SPH density kernel.

Computes a simplified SPH density estimate for each particle:

rho_i = sum_j m_j * W(|r_i - r_j|, h)

where W(r, h) = max(0, 1 - (r/h)^2) (simplified poly-6 mock).

Buffer layout (flat f64):

• pos_buf — [x0, y0, z0, x1, y1, z1, ...]
• mass_buf — [m0, m1, ...]
• out_density_buf — written with [rho0, rho1, ...]

Errors

Returns an error if any buffer id is invalid.

pub fn dispatch_reduction_tree(&self, buf: BufferId) -> Result<f64, GpuError>

Dispatch a tree-based parallel reduction on a buffer.

Simulates a GPU tree reduction: repeatedly halves the active range, summing adjacent elements until one value remains.

Returns the reduced value (identity 0.0 for an empty buffer).

pub fn dispatch_inclusive_scan( &mut self, buf_in: BufferId, buf_out: BufferId, ) -> Result<(), GpuError>

Dispatch an inclusive prefix scan (cumulative sum) on a buffer.

Writes out[i] = sum(in[0..=i]) into out_buf.

Uses a sequential Hillis-Steele-style scan for correctness.

pub fn dispatch_radix_sort(&self, buf: BufferId) -> Result<Vec<f64>, GpuError>

Dispatch a 2-bit radix sort on a buffer of non-negative f64 values.

Values are cast to u64 (bit-cast) and sorted by their bits using counting sort passes with 2-bit digits. 32 passes cover all 64 bits. For non-negative IEEE 754 doubles the bit pattern order matches numeric order. Returns the sorted data as a new Vecf64` (input unchanged).

Trait Implementations

impl Default for ComputeDispatcher

fn default() -> Self

Returns the “default value” for a type.