114 lines
3.2 KiB
Rust
114 lines
3.2 KiB
Rust
mod vk;
|
|
|
|
use wgpu::*;
|
|
|
|
fn iris_features() -> Features {
|
|
Features::empty()
|
|
}
|
|
|
|
const IRIS_MAX_BUFFER_SIZE: u64 = 1 << 30;
|
|
|
|
fn iris_limits() -> Limits {
|
|
Limits {
|
|
max_buffer_size: IRIS_MAX_BUFFER_SIZE,
|
|
max_compute_workgroup_storage_size: 0,
|
|
max_compute_invocations_per_workgroup: 0,
|
|
max_compute_workgroup_size_x: 0,
|
|
max_compute_workgroup_size_y: 0,
|
|
max_compute_workgroup_size_z: 0,
|
|
max_compute_workgroups_per_dimension: 0,
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
vk::report();
|
|
|
|
let instance = Instance::new(InstanceDescriptor {
|
|
backends: Backends::from_env().unwrap_or(Backends::PRIMARY),
|
|
..InstanceDescriptor::new_without_display_handle()
|
|
});
|
|
|
|
let adapters = pollster::block_on(instance.enumerate_adapters(Backends::all()));
|
|
println!("adapters: {}", adapters.len());
|
|
for adapter in &adapters {
|
|
let info = adapter.get_info();
|
|
println!(
|
|
" {:?} {} ({:?})",
|
|
info.backend, info.name, info.device_type
|
|
);
|
|
let down = adapter.get_downlevel_capabilities();
|
|
let limits = adapter.limits();
|
|
println!(
|
|
" compute shaders: {} (shader model {:?})",
|
|
down.flags.contains(DownlevelFlags::COMPUTE_SHADERS),
|
|
down.shader_model
|
|
);
|
|
println!(
|
|
" max compute invocations/workgroup: {}, workgroup storage: {} bytes",
|
|
limits.max_compute_invocations_per_workgroup, limits.max_compute_workgroup_storage_size
|
|
);
|
|
}
|
|
|
|
let Some(adapter) = pollster::block_on(instance.request_adapter(&RequestAdapterOptions {
|
|
power_preference: PowerPreference::default(),
|
|
compatible_surface: None,
|
|
force_fallback_adapter: false,
|
|
..Default::default()
|
|
}))
|
|
.ok() else {
|
|
println!("\nNO ADAPTER");
|
|
std::process::exit(1);
|
|
};
|
|
|
|
let info = adapter.get_info();
|
|
println!(
|
|
"\nchosen: {:?} {} ({:?})",
|
|
info.backend, info.name, info.device_type
|
|
);
|
|
println!("driver: {} {}", info.driver, info.driver_info);
|
|
|
|
let have = adapter.features();
|
|
println!("\nfeatures iris requires:");
|
|
let mut missing = Features::empty();
|
|
for f in iris_features().iter() {
|
|
let ok = have.contains(f);
|
|
println!(
|
|
" {:60} {}",
|
|
format!("{f:?}"),
|
|
if ok { "yes" } else { "NO" }
|
|
);
|
|
if !ok {
|
|
missing |= f;
|
|
}
|
|
}
|
|
|
|
let limits = adapter.limits();
|
|
println!("\nlimits iris requires:");
|
|
println!(
|
|
" {:52} want {:>7} have {:>7} {}",
|
|
"max_buffer_size",
|
|
IRIS_MAX_BUFFER_SIZE,
|
|
limits.max_buffer_size,
|
|
if limits.max_buffer_size >= IRIS_MAX_BUFFER_SIZE {
|
|
"ok"
|
|
} else {
|
|
"TOO SMALL"
|
|
}
|
|
);
|
|
|
|
let wanted = iris_limits();
|
|
match pollster::block_on(adapter.request_device(&DeviceDescriptor {
|
|
required_features: iris_features(),
|
|
required_limits: wanted,
|
|
..Default::default()
|
|
})) {
|
|
Ok(_) => println!("\nIRIS DEVICE: ok"),
|
|
Err(e) => println!("\nIRIS DEVICE: FAILED -- {e}"),
|
|
}
|
|
|
|
if !missing.is_empty() {
|
|
println!("\nmissing features: {missing:?}");
|
|
}
|
|
}
|