use wgpu::util::DeviceExt;
pub struct GpuEvaluator {
device: wgpu::Device,
queue: wgpu::Queue,
pipeline: wgpu::ComputePipeline,
bind_group_layout: wgpu::BindGroupLayout,
data_buffer: wgpu::Buffer,
adapter: wgpu::AdapterInfo,
evaluated: std::sync::atomic::AtomicUsize,
pub solution_length: usize,
pub num_objectives: usize,
}
unsafe fn as_bytes<T>(data: &[T]) -> &[u8] {
std::slice::from_raw_parts(
data.as_ptr() as *const u8,
data.len() * std::mem::size_of::<T>(),
)
}
unsafe fn as_f32_slice(data: &[u8]) -> &[f32] {
std::slice::from_raw_parts(
data.as_ptr() as *const f32,
data.len() / std::mem::size_of::<f32>(),
)
}
impl GpuEvaluator {
pub fn new_blocking(
shader_wgsl: &str,
solution_length: usize,
num_objectives: usize,
) -> Self {
pollster::block_on(Self::new_async(shader_wgsl, solution_length, num_objectives, &[]))
}
pub fn new_blocking_with_data(
shader_wgsl: &str,
solution_length: usize,
num_objectives: usize,
data: &[f32],
) -> Self {
pollster::block_on(Self::new_async(shader_wgsl, solution_length, num_objectives, data))
}
async fn new_async(
shader_wgsl: &str,
solution_length: usize,
num_objectives: usize,
data: &[f32],
) -> Self {
let instance = wgpu::Instance::default();
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: None,
force_fallback_adapter: false,
})
.await
.expect("No GPU adapter found. Ensure a wgpu-compatible GPU is available.");
let info = adapter.get_info();
eprintln!("puggles: GPU = {} ({:?}, {:?})", info.name, info.device_type, info.backend);
let (device, queue) = adapter
.request_device(&wgpu::DeviceDescriptor::default(), None)
.await
.expect("Failed to create wgpu device");
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("puggles_objective_shader"),
source: wgpu::ShaderSource::Wgsl(shader_wgsl.into()),
});
let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("puggles_bgl"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: true },
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: false },
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 3,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: true },
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
],
});
let data_src: Vec<f32> = if data.is_empty() { vec![0.0] } else { data.to_vec() };
let data_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("puggles_data"),
contents: unsafe { as_bytes(&data_src) },
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("puggles_pipeline_layout"),
bind_group_layouts: &[&bind_group_layout],
push_constant_ranges: &[],
});
let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some("puggles_compute_pipeline"),
layout: Some(&pipeline_layout),
module: &shader,
entry_point: "main",
compilation_options: wgpu::PipelineCompilationOptions::default(),
cache: None,
});
GpuEvaluator {
device,
queue,
pipeline,
bind_group_layout,
data_buffer,
adapter: info,
evaluated: std::sync::atomic::AtomicUsize::new(0),
solution_length,
num_objectives,
}
}
pub fn adapter_info(&self) -> &wgpu::AdapterInfo {
&self.adapter
}
pub fn device_description(&self) -> String {
format!("{} ({:?}, {:?})", self.adapter.name, self.adapter.device_type, self.adapter.backend)
}
pub fn evaluated_count(&self) -> usize {
self.evaluated.load(std::sync::atomic::Ordering::Relaxed)
}
pub fn evaluate_batch(&self, solutions: &[Vec<f64>]) -> Vec<Vec<f64>> {
let pop_size = solutions.len();
if pop_size == 0 {
return Vec::new();
}
self.evaluated.fetch_add(pop_size, std::sync::atomic::Ordering::Relaxed);
let input_data: Vec<f32> = solutions
.iter()
.flat_map(|s| s.iter().map(|&v| v as f32))
.collect();
let output_size = (pop_size * self.num_objectives * std::mem::size_of::<f32>()) as u64;
let solution_buf = self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("solutions"),
contents: unsafe { as_bytes(&input_data) },
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
});
let objectives_buf = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("objectives"),
size: output_size,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let params_data: [u32; 3] = [
self.solution_length as u32,
self.num_objectives as u32,
pop_size as u32,
];
let params_buf = self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("params"),
contents: unsafe { as_bytes(¶ms_data) },
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
let staging_buf = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("staging"),
size: output_size,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("puggles_bg"),
layout: &self.bind_group_layout,
entries: &[
wgpu::BindGroupEntry { binding: 0, resource: solution_buf.as_entire_binding() },
wgpu::BindGroupEntry { binding: 1, resource: objectives_buf.as_entire_binding() },
wgpu::BindGroupEntry { binding: 2, resource: params_buf.as_entire_binding() },
wgpu::BindGroupEntry { binding: 3, resource: self.data_buffer.as_entire_binding() },
],
});
let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("puggles_encoder"),
});
{
let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("puggles_cpass"),
timestamp_writes: None,
});
cpass.set_pipeline(&self.pipeline);
cpass.set_bind_group(0, &bind_group, &[]);
let workgroups = (pop_size as u32 + 63) / 64;
cpass.dispatch_workgroups(workgroups, 1, 1);
}
encoder.copy_buffer_to_buffer(&objectives_buf, 0, &staging_buf, 0, output_size);
self.queue.submit(std::iter::once(encoder.finish()));
let slice = staging_buf.slice(..);
let (sender, receiver) = std::sync::mpsc::channel();
slice.map_async(wgpu::MapMode::Read, move |v| sender.send(v).unwrap());
self.device.poll(wgpu::Maintain::Wait);
receiver.recv().unwrap().expect("GPU buffer map failed");
let results = {
let raw = slice.get_mapped_range();
let floats: &[f32] = unsafe { as_f32_slice(&raw) };
floats
.chunks_exact(self.num_objectives)
.map(|chunk| chunk.iter().map(|&v| v as f64).collect())
.collect()
};
staging_buf.unmap();
results
}
}