example-runner-wgpu: add --force-spirv-passthru and rely on it for debugPrintf.

CHANGELOG.md

@@ -30,6 +30,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added ⭐
+- [PR#1036](https://github.com/EmbarkStudios/rust-gpu/pull/1036) added a `--force-spirv-passthru` flag to `example-runner-wgpu`, to bypass Naga (`wgpu`'s shader translator),
+ used it to test `debugPrintf` for `wgpu`, and updated `ShaderPanicStrategy::DebugPrintfThenExit` docs to reflect what "enabling `debugPrintf`" looks like for `wgpu` 
+ <sub><sup>(e.g. `VK_LOADER_LAYERS_ENABLE=VK_LAYER_KHRONOS_validation VK_LAYER_ENABLES=VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT DEBUG_PRINTF_TO_STDOUT=1`)</sup></sub>
 - [PR#1080](https://github.com/EmbarkStudios/rust-gpu/pull/1080) added `debugPrintf`-based
  panic reporting, with the desired behavior selected via `spirv_builder::ShaderPanicStrategy`
  (see its documentation for more details about each available panic handling strategy)

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -2648,7 +2648,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
  // HACK(eddyb) redirect any possible panic call to an abort, to avoid
  // needing to materialize `&core::panic::Location` or `format_args!`.
  // FIXME(eddyb) find a way to extract the original message.
- self.abort_with_message("panic!(...)".into());
+ self.abort_with_message("panicked: <unknown message>".into());
  self.undef(result_type)
  } else if let Some(mode) = buffer_load_intrinsic {
  self.codegen_buffer_load_intrinsic(result_type, args, mode)

crates/rustc_codegen_spirv/src/builder/intrinsics.rs

@@ -339,7 +339,7 @@ impl<'a, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'tcx> {
  }
 
  fn abort(&mut self) {
- self.abort_with_message("intrinsics::abort()".into());
+ self.abort_with_message("aborted: intrinsics::abort() called".into());
  }
 
  fn assume(&mut self, _val: Self::Value) {

crates/rustc_codegen_spirv/src/linker/spirt_passes/controlflow.rs

@@ -330,12 +330,16 @@ pub fn convert_custom_aborts_to_unstructured_returns_in_entry_points(
  let mut fmt = String::new();
 
  // HACK(eddyb) this improves readability w/ very verbose Vulkan loggers.
- fmt += "\n ";
+ fmt += "\n";
 
+ fmt += "[RUST-GPU] ";
+ fmt += &cx[const_str(message)].replace('%', "%%");
+
+ // FIXME(eddyb) deduplicate with "called at" form below
+ // (not trivial becasue both closures would borrow `fmt`).
  if let Some((file, line, col)) = current_debug_src_loc.take() {
- fmt += &format!("{file}:{line}:{col}: ").replace('%', "%%");
+ fmt += &format!("\n at {file}:{line}:{col}").replace('%', "%%");
  }
- fmt += &cx[const_str(message)].replace('%', "%%");
 
  let mut innermost = true;
  let mut append_call = |callsite_debug_src_loc, callee: &str| {
@@ -360,6 +364,8 @@ pub fn convert_custom_aborts_to_unstructured_returns_in_entry_points(
  }
  append_call(None, &debug_printf_context_fmt_str);
 
+ fmt += "\n";
+
  let abort_inst_def = &mut func_def_body.data_insts[abort_inst];
  abort_inst_def.kind = DataInstKind::SpvExtInst {
  ext_set: cx.intern("NonSemantic.DebugPrintf"),

crates/spirv-builder/src/lib.rs

@@ -193,15 +193,40 @@ pub enum ShaderPanicStrategy {
  /// If you have multiple entry-points, you *may* need to also enable the
  /// `multimodule` node (see <https://github.com/KhronosGroup/SPIRV-Tools/issues/4892>).
  ///
- /// **Note**: actually obtaining the `debugPrintf` output requires enabling:
- /// * `VK_KHR_shader_non_semantic_info` Vulkan *Device* extension
- /// * Vulkan Validation Layers (which contain the `debugPrintf` implementation)
- /// * `VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT` in Validation Layers,
- /// either by using `VkValidationFeaturesEXT` during instance creating,
- /// setting the `VK_LAYER_ENABLES` environment variable to that value,
- /// or adding it to `khronos_validation.enables` in `vk_layer_settings.txt`
- ///
- /// See also: <https://github.com/KhronosGroup/Vulkan-ValidationLayers/blob/main/docs/debug_printf.md>.
+ /// **Note**: actually obtaining the `debugPrintf` output requires:
+ /// * Vulkan Validation Layers (from e.g. the Vulkan SDK)
+ /// * (they contain the `debugPrintf` implementation, a SPIR-V -> SPIR-V translation)
+ /// * **set the `VK_LOADER_LAYERS_ENABLE=VK_LAYER_KHRONOS_validation`
+ /// environment variable** to easily enable them without any code changes
+ /// * alternatively, `"VK_LAYER_KHRONOS_validation"` can be passed during
+ /// instance creation, to enable them programmatically
+ /// * Validation Layers' `debugPrintf` support:
+ /// * **set the `VK_LAYER_ENABLES=VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT`
+ /// environment variable** to easily enable the `debugPrintf` support
+ /// * alternatively, `VkValidationFeaturesEXT` during instance creation,
+ /// or the `khronos_validation.enables` field in `vk_layer_settings.txt`,
+ /// can be used to enable `VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT`
+ /// (see also <https://github.com/KhronosGroup/Vulkan-ValidationLayers/blob/main/docs/debug_printf.md>)
+ /// * for outputting the `debugPrintf` messages sent back from the GPU:
+ /// * **set the `DEBUG_PRINTF_TO_STDOUT=1` environment variable** if you don't
+ /// plan on customizing the reporting (see below for alternatives)
+ /// * for `wgpu`:
+ /// * **required**: `wgpu::Features::SPIRV_SHADER_PASSTHROUGH` (Naga lacks `debugPrintf`)
+ /// * *optional*: building in debug mode (and/or with debug-assertions enabled),
+ /// to enable `wgpu` logging/debug support
+ /// * (the debug assertions requirement may be lifted in future `wgpu` versions)
+ /// * this uses `VK_EXT_debug_utils` internally, and is a better-integrated
+ /// alternative to just setting `DEBUG_PRINTF_TO_STDOUT=1`
+ /// * `RUST_LOG=wgpu_hal::vulkan=info` (or equivalent) will enable said
+ /// output (as `debugPrintf` messages have the "info" level)
+ /// * `RUST_LOG` controls `env_logger`, which isn't itself required,
+ /// but *some* `log`/`tracing` subscriber is needed to get any output
+ /// * for Vulkan (e.g. via `ash`):
+ /// * **required**: enabling the `VK_KHR_shader_non_semantic_info` Vulkan *Device* extension
+ /// * *optional*: as described above, enabling the Validation Layers and
+ /// their `debugPrintf` support can be done during instance creation
+ /// * *optional*: integrating [`VK_EXT_debug_utils`](https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_debug_utils.html)
+ /// allows more reporting flexibility than `DEBUG_PRINTF_TO_STDOUT=1`)
  DebugPrintfThenExit {
  /// Whether to also print the entry-point inputs (excluding buffers/resources),
  /// which should uniquely identify the panicking shader invocation.

examples/runners/ash/src/main.rs

@@ -211,8 +211,6 @@ pub fn compile_shaders() -> Vec<SpvFile> {
 
  SpirvBuilder::new("examples/shaders/sky-shader", "spirv-unknown-vulkan1.1")
  .print_metadata(MetadataPrintout::None)
- // HACK(eddyb) having the `ash` runner do this is the easiest way I found
- // to test this `panic!` feature with actual `debugPrintf` support.
  .shader_panic_strategy(spirv_builder::ShaderPanicStrategy::DebugPrintfThenExit {
  print_inputs: true,
  print_backtrace: true,
@@ -380,10 +378,10 @@ impl RenderBase {
  };
 
  let device: ash::Device = {
- let mut device_extension_names_raw = vec![khr::Swapchain::name().as_ptr()];
- if options.debug_layer {
- device_extension_names_raw.push(vk::KhrShaderNonSemanticInfoFn::name().as_ptr());
- }
+ let device_extension_names_raw = [
+  khr::Swapchain::name().as_ptr(),
+ vk::KhrShaderNonSemanticInfoFn::name().as_ptr(),
+ ];
  let features = vk::PhysicalDeviceFeatures {
  shader_clip_distance: 1,
  ..Default::default()

examples/runners/wgpu/src/compute.rs

@@ -1,20 +1,17 @@
-use wgpu::util::DeviceExt;
+use crate::{maybe_watch, CompiledShaderModules, Options};
 
-use super::Options;
 use std::{convert::TryInto, time::Duration};
+use wgpu::util::DeviceExt;
 
 pub fn start(options: &Options) {
  env_logger::init();
 
- let shader_binary = crate::maybe_watch(options.shader, None);
+ let compiled_shader_modules = maybe_watch(options, None);
 
- futures::executor::block_on(start_internal(options, shader_binary));
+ futures::executor::block_on(start_internal(options, compiled_shader_modules));
 }
 
-pub async fn start_internal(
- _options: &Options,
- shader_binary: wgpu::ShaderModuleDescriptor<'static>,
-) {
+async fn start_internal(options: &Options, compiled_shader_modules: CompiledShaderModules) {
  let backends = wgpu::util::backend_bits_from_env().unwrap_or(wgpu::Backends::PRIMARY);
  let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
  backends,
@@ -24,11 +21,17 @@ pub async fn start_internal(
  .await
  .expect("Failed to find an appropriate adapter");
 
+ let mut features =
+ wgpu::Features::TIMESTAMP_QUERY | wgpu::Features::TIMESTAMP_QUERY_INSIDE_PASSES;
+ if options.force_spirv_passthru {
+ features |= wgpu::Features::SPIRV_SHADER_PASSTHROUGH;
+ }
+
  let (device, queue) = adapter
  .request_device(
  &wgpu::DeviceDescriptor {
  label: None,
- features: wgpu::Features::TIMESTAMP_QUERY,
+ features,
  limits: wgpu::Limits::default(),
  },
  None,
@@ -40,8 +43,19 @@ pub async fn start_internal(
 
  let timestamp_period = queue.get_timestamp_period();
 
- // Load the shaders from disk
- let module = device.create_shader_module(shader_binary);
+ let entry_point = "main_cs";
+
+ // FIXME(eddyb) automate this decision by default.
+ let module = compiled_shader_modules.spv_module_for_entry_point(entry_point);
+ let module = if options.force_spirv_passthru {
+ unsafe { device.create_shader_module_spirv(&module) }
+ } else {
+ let wgpu::ShaderModuleDescriptorSpirV { label, source } = module;
+ device.create_shader_module(wgpu::ShaderModuleDescriptor {
+ label,
+ source: wgpu::ShaderSource::SpirV(source),
+ })
+ };
 
  let top = 2u32.pow(20);
  let src_range = 1..top;
@@ -75,7 +89,7 @@ pub async fn start_internal(
  label: None,
  layout: Some(&pipeline_layout),
  module: &module,
- entry_point: "main_cs",
+ entry_point,
  });
 
  let readback_buffer = device.create_buffer(&wgpu::BufferDescriptor {
@@ -97,10 +111,17 @@ pub async fn start_internal(
  let timestamp_buffer = device.create_buffer(&wgpu::BufferDescriptor {
  label: Some("Timestamps buffer"),
  size: 16,
+ usage: wgpu::BufferUsages::QUERY_RESOLVE | wgpu::BufferUsages::COPY_SRC,
+ mapped_at_creation: false,
+ });
+
+ let timestamp_readback_buffer = device.create_buffer(&wgpu::BufferDescriptor {
+ label: None,
+ size: 16,
  usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
  mapped_at_creation: true,
  });
- timestamp_buffer.unmap();
+ timestamp_readback_buffer.unmap();
 
  let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
  label: None,
@@ -137,10 +158,17 @@ pub async fn start_internal(
  src.len() as wgpu::BufferAddress,
  );
  encoder.resolve_query_set(&queries, 0..2, &timestamp_buffer, 0);
+ encoder.copy_buffer_to_buffer(
+ &timestamp_buffer,
+ 0,
+ &timestamp_readback_buffer,
+ 0,
+ timestamp_buffer.size(),
+ );
 
  queue.submit(Some(encoder.finish()));
  let buffer_slice = readback_buffer.slice(..);
- let timestamp_slice = timestamp_buffer.slice(..);
+ let timestamp_slice = timestamp_readback_buffer.slice(..);
  timestamp_slice.map_async(wgpu::MapMode::Read, |r| r.unwrap());
  buffer_slice.map_async(wgpu::MapMode::Read, |r| r.unwrap());
  // NOTE(eddyb) `poll` should return only after the above callbacks fire
@@ -160,7 +188,7 @@ pub async fn start_internal(
  drop(data);
  readback_buffer.unmap();
  drop(timing_data);
- timestamp_buffer.unmap();
+ timestamp_readback_buffer.unmap();
  let mut max = 0;
  for (src, out) in src_range.zip(result.iter().copied()) {
  if out == u32::MAX {