use crate::device::WgpuDevice;
use crate::device::capabilities::WORKGROUP_SIZE_COMPACT;
use crate::device::compute_pipeline::ComputeDispatch;
use crate::error::{BarracudaError, Result};
use bytemuck::{Pod, Zeroable};
use std::sync::Arc;
#[repr(C)]
#[derive(Copy, Clone, Pod, Zeroable)]
struct BisectionParams {
batch_size: u32,
max_iterations: u32,
n_levels: u32,
use_degeneracy: u32, tolerance_lo: u32, tolerance_hi: u32,
}
impl BisectionParams {
fn new(
batch_size: u32,
max_iterations: u32,
n_levels: u32,
use_degeneracy: bool,
tolerance: f64,
) -> Self {
let tol_bits = tolerance.to_bits();
Self {
batch_size,
max_iterations,
n_levels,
use_degeneracy: u32::from(use_degeneracy),
tolerance_lo: tol_bits as u32,
tolerance_hi: (tol_bits >> 32) as u32,
}
}
}
pub struct BatchedBisectionGpu {
device: Arc<WgpuDevice>,
max_iterations: u32,
tolerance: f64,
}
pub struct BisectionResult {
pub roots: Vec<f64>,
pub iterations: Vec<u32>,
}
impl BatchedBisectionGpu {
pub fn new(device: Arc<WgpuDevice>, max_iterations: u32, tolerance: f64) -> Result<Self> {
if tolerance <= 0.0 {
return Err(BarracudaError::InvalidInput {
message: "Tolerance must be positive".to_string(),
});
}
Ok(Self {
device,
max_iterations,
tolerance,
})
}
fn wgsl_shader() -> &'static str {
include_str!("../shaders/optimizer/batched_bisection_f64.wgsl")
}
pub fn solve_polynomial(
&self,
lower: &[f64],
upper: &[f64],
targets: &[f64],
) -> Result<BisectionResult> {
if lower.len() != upper.len() || lower.len() != targets.len() {
return Err(BarracudaError::InvalidInput {
message: format!(
"Array lengths must match: lower={}, upper={}, targets={}",
lower.len(),
upper.len(),
targets.len()
),
});
}
self.solve_internal(lower, upper, targets, 1, false, "batched_bisection_poly")
}
pub fn solve_bcs(
&self,
lower: &[f64],
upper: &[f64],
eigenvalues: &[f64],
delta: &[f64],
target_n: &[f64],
) -> Result<BisectionResult> {
let batch_size = lower.len();
if upper.len() != batch_size || delta.len() != batch_size || target_n.len() != batch_size {
return Err(BarracudaError::InvalidInput {
message: "Array lengths must match batch_size".to_string(),
});
}
if !eigenvalues.len().is_multiple_of(batch_size) {
return Err(BarracudaError::InvalidInput {
message: format!(
"eigenvalues length {} must be divisible by batch_size {}",
eigenvalues.len(),
batch_size
),
});
}
let n_levels = eigenvalues.len() / batch_size;
let params_per_problem = n_levels + 2;
let mut params = Vec::with_capacity(batch_size * params_per_problem);
for i in 0..batch_size {
for j in 0..n_levels {
params.push(eigenvalues[i * n_levels + j]);
}
params.push(delta[i]);
params.push(target_n[i]);
}
self.solve_internal(
lower,
upper,
¶ms,
n_levels as u32,
false,
"batched_bisection",
)
}
pub fn solve_bcs_with_degeneracy(
&self,
lower: &[f64],
upper: &[f64],
eigenvalues: &[f64],
degeneracies: &[f64],
delta: &[f64],
target_n: &[f64],
) -> Result<BisectionResult> {
let batch_size = lower.len();
if upper.len() != batch_size || delta.len() != batch_size || target_n.len() != batch_size {
return Err(BarracudaError::InvalidInput {
message: "Array lengths must match batch_size".to_string(),
});
}
if !eigenvalues.len().is_multiple_of(batch_size) {
return Err(BarracudaError::InvalidInput {
message: format!(
"eigenvalues length {} must be divisible by batch_size {}",
eigenvalues.len(),
batch_size
),
});
}
let n_levels = eigenvalues.len() / batch_size;
if degeneracies.len() != eigenvalues.len() {
return Err(BarracudaError::InvalidInput {
message: format!(
"degeneracies length {} must match eigenvalues length {}",
degeneracies.len(),
eigenvalues.len()
),
});
}
let params_per_problem = n_levels * 2 + 2;
let mut params = Vec::with_capacity(batch_size * params_per_problem);
for i in 0..batch_size {
for j in 0..n_levels {
params.push(eigenvalues[i * n_levels + j]);
}
for j in 0..n_levels {
params.push(degeneracies[i * n_levels + j]);
}
params.push(delta[i]);
params.push(target_n[i]);
}
self.solve_internal(
lower,
upper,
¶ms,
n_levels as u32,
true,
"batched_bisection",
)
}
fn solve_internal(
&self,
lower: &[f64],
upper: &[f64],
params: &[f64],
n_levels: u32,
use_degeneracy: bool,
entry_point: &str,
) -> Result<BisectionResult> {
let batch_size = lower.len();
if batch_size == 0 {
return Ok(BisectionResult {
roots: vec![],
iterations: vec![],
});
}
let lower_bytes: &[u8] = bytemuck::cast_slice(lower);
let lower_buffer =
self.device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("BatchedBisection lower"),
contents: lower_bytes,
usage: wgpu::BufferUsages::STORAGE,
});
let upper_bytes: &[u8] = bytemuck::cast_slice(upper);
let upper_buffer =
self.device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("BatchedBisection upper"),
contents: upper_bytes,
usage: wgpu::BufferUsages::STORAGE,
});
let params_bytes: &[u8] = bytemuck::cast_slice(params);
let params_buffer =
self.device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("BatchedBisection params"),
contents: params_bytes,
usage: wgpu::BufferUsages::STORAGE,
});
let roots_buffer = self.device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("BatchedBisection roots"),
size: (batch_size * 8) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let iterations_buffer = self.device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("BatchedBisection iterations"),
size: (batch_size * 4) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let config = BisectionParams::new(
batch_size as u32,
self.max_iterations,
n_levels,
use_degeneracy,
self.tolerance,
);
let config_buffer = self
.device
.create_uniform_buffer("BatchedBisection config", &config);
let n_workgroups = batch_size.div_ceil(WORKGROUP_SIZE_COMPACT as usize);
ComputeDispatch::new(self.device.as_ref(), entry_point)
.shader(Self::wgsl_shader(), entry_point)
.f64()
.storage_read(0, &lower_buffer)
.storage_read(1, &upper_buffer)
.storage_read(2, ¶ms_buffer)
.storage_rw(3, &roots_buffer)
.storage_rw(4, &iterations_buffer)
.uniform(5, &config_buffer)
.dispatch(n_workgroups as u32, 1, 1)
.submit()?;
let roots = self.device.read_f64_buffer(&roots_buffer, batch_size)?;
let iterations = self.read_u32_buffer(&iterations_buffer, batch_size)?;
Ok(BisectionResult { roots, iterations })
}
fn read_u32_buffer(&self, buffer: &wgpu::Buffer, count: usize) -> Result<Vec<u32>> {
let staging = self.device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("BatchedBisection u32 staging"),
size: (count * 4) as u64,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut encoder = self
.device
.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("BatchedBisection u32 readback"),
});
encoder.copy_buffer_to_buffer(buffer, 0, &staging, 0, (count * 4) as u64);
self.device.submit_commands(Some(encoder.finish()));
let slice = staging.slice(..);
let (sender, receiver) = std::sync::mpsc::channel();
slice.map_async(wgpu::MapMode::Read, move |result| {
let _ = sender.send(result);
});
self.device.poll_safe()?;
receiver
.recv()
.map_err(|_| BarracudaError::execution_failed("GPU buffer mapping channel closed"))?
.map_err(|e| BarracudaError::execution_failed(e.to_string()))?;
let data = slice.get_mapped_range();
let result: Vec<u32> = data
.chunks_exact(4)
.map(|chunk| {
let arr: [u8; 4] = chunk.try_into().map_err(|_| {
BarracudaError::Internal("chunks_exact(4) invariant violated".to_string())
})?;
Ok(u32::from_le_bytes(arr))
})
.collect::<Result<Vec<_>>>()?;
drop(data);
staging.unmap();
Ok(result)
}
}
#[cfg(test)]
#[path = "batched_bisection_gpu_tests.rs"]
mod tests;