Merge branch 'trunk' into web_dependencies

Author: raphaelhetzel

naga/Cargo.toml

@@ -58,13 +58,7 @@ arbitrary = [
 ]
 spv-in = ["dep:petgraph", "dep:spirv"]
 spv-out = ["dep:spirv"]
-wgsl-in = [
-    "dep:hexf-parse",
-    "dep:strum",
-    "dep:unicode-ident",
-    "indexmap/std",
-    "compact",
-]
+wgsl-in = ["dep:hexf-parse", "dep:strum", "dep:unicode-ident", "compact"]
 wgsl-out = []
 
 ## Enables outputting to HLSL (Microsoft's High-Level Shader Language).

naga/src/diagnostic_filter.rs

@@ -4,12 +4,12 @@ use alloc::boxed::Box;
 
 use crate::{Arena, Handle};
 
+#[cfg(feature = "wgsl-in")]
+use crate::FastIndexMap;
 #[cfg(feature = "wgsl-in")]
 use crate::Span;
 #[cfg(feature = "arbitrary")]
 use arbitrary::Arbitrary;
-#[cfg(feature = "wgsl-in")]
-use indexmap::IndexMap;
 #[cfg(feature = "deserialize")]
 use serde::Deserialize;
 #[cfg(feature = "serialize")]
@@ -133,7 +133,7 @@ pub(crate) enum ShouldConflictOnFullDuplicate {
 /// [`add`]: DiagnosticFilterMap::add
 #[derive(Clone, Debug, Default)]
 #[cfg(feature = "wgsl-in")]
-pub(crate) struct DiagnosticFilterMap(IndexMap<FilterableTriggeringRule, (Severity, Span)>);
+pub(crate) struct DiagnosticFilterMap(FastIndexMap<FilterableTriggeringRule, (Severity, Span)>);
 
 #[cfg(feature = "wgsl-in")]
 impl DiagnosticFilterMap {

naga/src/front/wgsl/lower/mod.rs

@@ -2504,15 +2504,16 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                         }
                         "atomicLoad" => {
                             let mut args = ctx.prepare_args(arguments, 1, span);
-                            let pointer = self.atomic_pointer(args.next()?, ctx)?;
+                            let (pointer, _scalar) = self.atomic_pointer(args.next()?, ctx)?;
                             args.finish()?;
 
                             ir::Expression::Load { pointer }
                         }
                         "atomicStore" => {
                             let mut args = ctx.prepare_args(arguments, 2, span);
-                            let pointer = self.atomic_pointer(args.next()?, ctx)?;
-                            let value = self.expression(args.next()?, ctx)?;
+                            let (pointer, scalar) = self.atomic_pointer(args.next()?, ctx)?;
+                            let value =
+                                self.expression_with_leaf_scalar(args.next()?, scalar, ctx)?;
                             args.finish()?;
 
                             let rctx = ctx.runtime_expression_ctx(span)?;
@@ -2526,13 +2527,14 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                         "atomicCompareExchangeWeak" => {
                             let mut args = ctx.prepare_args(arguments, 3, span);
 
-                            let pointer = self.atomic_pointer(args.next()?, ctx)?;
+                            let (pointer, scalar) = self.atomic_pointer(args.next()?, ctx)?;
 
-                            let compare = self.expression(args.next()?, ctx)?;
+                            let compare =
+                                self.expression_with_leaf_scalar(args.next()?, scalar, ctx)?;
 
                             let value = args.next()?;
                             let value_span = ctx.ast_expressions.get_span(value);
-                            let value = self.expression(value, ctx)?;
+                            let value = self.expression_with_leaf_scalar(value, scalar, ctx)?;
 
                             args.finish()?;
 
@@ -3200,13 +3202,13 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
         &mut self,
         expr: Handle<ast::Expression<'source>>,
         ctx: &mut ExpressionContext<'source, '_, '_>,
-    ) -> Result<'source, Handle<ir::Expression>> {
+    ) -> Result<'source, (Handle<ir::Expression>, ir::Scalar)> {
         let span = ctx.ast_expressions.get_span(expr);
         let pointer = self.expression(expr, ctx)?;
 
         match *resolve_inner!(ctx, pointer) {
             ir::TypeInner::Pointer { base, .. } => match ctx.module.types[base].inner {
-                ir::TypeInner::Atomic { .. } => Ok(pointer),
+                ir::TypeInner::Atomic(scalar) => Ok((pointer, scalar)),
                 ref other => {
                     log::error!("Pointer type to {:?} passed to atomic op", other);
                     Err(Box::new(Error::InvalidAtomicPointer(span)))
@@ -3229,8 +3231,8 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
     ) -> Result<'source, Option<Handle<ir::Expression>>> {
         let mut args = ctx.prepare_args(args, 2, span);
 
-        let pointer = self.atomic_pointer(args.next()?, ctx)?;
-        let value = self.expression(args.next()?, ctx)?;
+        let (pointer, scalar) = self.atomic_pointer(args.next()?, ctx)?;
+        let value = self.expression_with_leaf_scalar(args.next()?, scalar, ctx)?;
         let value_inner = resolve_inner!(ctx, value);
         args.finish()?;
 

naga/tests/in/wgsl/abstract-types-atomic.toml

@@ -0,0 +1 @@
+targets = "WGSL"

naga/tests/in/wgsl/abstract-types-atomic.wgsl

@@ -0,0 +1,34 @@
+@group(0) @binding(0)
+var<storage,read_write> atomic_i32: atomic<i32>;
+@group(0) @binding(1)
+var<storage,read_write> atomic_u32: atomic<u32>;
+
+fn test_atomic_i32() {
+  atomicStore(&atomic_i32, 1);
+  _ = atomicCompareExchangeWeak(&atomic_i32, 1, 1i);
+  _ = atomicCompareExchangeWeak(&atomic_i32, 1i, 1);
+
+  _ = atomicAdd(&atomic_i32, 1);
+  _ = atomicSub(&atomic_i32, 1);
+  _ = atomicAnd(&atomic_i32, 1);
+  _ = atomicXor(&atomic_i32, 1);
+  _ = atomicOr(&atomic_i32, 1);
+  _ = atomicMin(&atomic_i32, 1);
+  _ = atomicMax(&atomic_i32, 1);
+  _ = atomicExchange(&atomic_i32, 1);
+}
+
+fn test_atomic_u32() {
+  atomicStore(&atomic_u32, 1);
+  _ = atomicCompareExchangeWeak(&atomic_u32, 1, 1u);
+  _ = atomicCompareExchangeWeak(&atomic_u32, 1u, 1);
+
+  _ = atomicAdd(&atomic_u32, 1);
+  _ = atomicSub(&atomic_u32, 1);
+  _ = atomicAnd(&atomic_u32, 1);
+  _ = atomicXor(&atomic_u32, 1);
+  _ = atomicOr(&atomic_u32, 1);
+  _ = atomicMin(&atomic_u32, 1);
+  _ = atomicMax(&atomic_u32, 1);
+  _ = atomicExchange(&atomic_u32, 1);
+}

naga/tests/out/wgsl/wgsl-abstract-types-atomic.wgsl

@@ -0,0 +1,35 @@
+@group(0) @binding(0) 
+var<storage, read_write> atomic_i32_: atomic<i32>;
+@group(0) @binding(1) 
+var<storage, read_write> atomic_u32_: atomic<u32>;
+
+fn test_atomic_i32_() {
+    atomicStore((&atomic_i32_), 1i);
+    let _e5 = atomicCompareExchangeWeak((&atomic_i32_), 1i, 1i);
+    let _e9 = atomicCompareExchangeWeak((&atomic_i32_), 1i, 1i);
+    let _e12 = atomicAdd((&atomic_i32_), 1i);
+    let _e15 = atomicSub((&atomic_i32_), 1i);
+    let _e18 = atomicAnd((&atomic_i32_), 1i);
+    let _e21 = atomicXor((&atomic_i32_), 1i);
+    let _e24 = atomicOr((&atomic_i32_), 1i);
+    let _e27 = atomicMin((&atomic_i32_), 1i);
+    let _e30 = atomicMax((&atomic_i32_), 1i);
+    let _e33 = atomicExchange((&atomic_i32_), 1i);
+    return;
+}
+
+fn test_atomic_u32_() {
+    atomicStore((&atomic_u32_), 1u);
+    let _e5 = atomicCompareExchangeWeak((&atomic_u32_), 1u, 1u);
+    let _e9 = atomicCompareExchangeWeak((&atomic_u32_), 1u, 1u);
+    let _e12 = atomicAdd((&atomic_u32_), 1u);
+    let _e15 = atomicSub((&atomic_u32_), 1u);
+    let _e18 = atomicAnd((&atomic_u32_), 1u);
+    let _e21 = atomicXor((&atomic_u32_), 1u);
+    let _e24 = atomicOr((&atomic_u32_), 1u);
+    let _e27 = atomicMin((&atomic_u32_), 1u);
+    let _e30 = atomicMax((&atomic_u32_), 1u);
+    let _e33 = atomicExchange((&atomic_u32_), 1u);
+    return;
+}
+

wgpu-core/src/device/queue.rs

@@ -476,6 +476,8 @@ impl Queue {
             return Ok(());
         };
 
+        let snatch_guard = self.device.snatchable_lock.read();
+
         // Platform validation requires that the staging buffer always be
         // freed, even if an error occurs. All paths from here must call
         // `device.pending_writes.consume`.
@@ -489,6 +491,7 @@ impl Queue {
         };
 
         let result = self.write_staging_buffer_impl(
+            &snatch_guard,
             &mut pending_writes,
             &staging_buffer,
             buffer,
@@ -522,6 +525,7 @@ impl Queue {
 
         let buffer = buffer.get()?;
 
+        let snatch_guard = self.device.snatchable_lock.read();
         let mut pending_writes = self.pending_writes.lock();
 
         // At this point, we have taken ownership of the staging_buffer from the
@@ -531,6 +535,7 @@ impl Queue {
         let staging_buffer = staging_buffer.flush();
 
         let result = self.write_staging_buffer_impl(
+            &snatch_guard,
             &mut pending_writes,
             &staging_buffer,
             buffer,
@@ -583,6 +588,7 @@ impl Queue {
 
     fn write_staging_buffer_impl(
         &self,
+        snatch_guard: &SnatchGuard,
         pending_writes: &mut PendingWrites,
         staging_buffer: &FlushedStagingBuffer,
         buffer: Arc<Buffer>,
@@ -595,8 +601,7 @@ impl Queue {
                 .set_single(&buffer, wgt::BufferUses::COPY_DST)
         };
 
-        let snatch_guard = self.device.snatchable_lock.read();
-        let dst_raw = buffer.try_raw(&snatch_guard)?;
+        let dst_raw = buffer.try_raw(snatch_guard)?;
 
         self.same_device_as(buffer.as_ref())?;
 
@@ -614,7 +619,7 @@ impl Queue {
                 to: wgt::BufferUses::COPY_SRC,
             },
         })
-        .chain(transition.map(|pending| pending.into_hal(&buffer, &snatch_guard)))
+        .chain(transition.map(|pending| pending.into_hal(&buffer, snatch_guard)))
         .collect::<Vec<_>>();
         let encoder = pending_writes.activate();
         unsafe {