sync: Cleanup ApplyWait functionality

Author: artem-lunarg

layers/sync/sync_access_state.cpp

@@ -873,38 +873,6 @@ void AccessState::ApplySemaphore(const SemaphoreScope &signal, const SemaphoreSc
     if (last_write.has_value()) last_write->dependency_chain = read_execution_barriers;
 }
 
-// Read access predicate for queue wait
-bool AccessState::WaitQueueTagPredicate::operator()(const ReadState &read_access) const {
-    return (read_access.queue == queue) && (read_access.tag <= tag) &&
-           (read_access.stage != VK_PIPELINE_STAGE_2_PRESENT_ENGINE_BIT_SYNCVAL);
-}
-bool AccessState::WaitQueueTagPredicate::operator()(const AccessState &access) const {
-    if (!access.last_write.has_value()) return false;
-    const auto &write_state = *access.last_write;
-    return write_state.queue == queue && (write_state.tag <= tag) &&
-           write_state.access_index != SYNC_PRESENT_ENGINE_SYNCVAL_PRESENT_PRESENTED_SYNCVAL;
-}
-
-// Read access predicate for queue wait
-bool AccessState::WaitTagPredicate::operator()(const ReadState &read_access) const {
-    return (read_access.tag <= tag) && (read_access.stage != VK_PIPELINE_STAGE_2_PRESENT_ENGINE_BIT_SYNCVAL);
-}
-bool AccessState::WaitTagPredicate::operator()(const AccessState &access) const {
-    if (!access.last_write.has_value()) return false;
-    const auto &write_state = *access.last_write;
-    return (write_state.tag <= tag) && write_state.access_index != SYNC_PRESENT_ENGINE_SYNCVAL_PRESENT_PRESENTED_SYNCVAL;
-}
-
-// Present operations only matching only the *exactly* tagged present and acquire operations
-bool AccessState::WaitAcquirePredicate::operator()(const ReadState &read_access) const {
-    return (read_access.tag == acquire_tag) && (read_access.stage == VK_PIPELINE_STAGE_2_PRESENT_ENGINE_BIT_SYNCVAL);
-}
-bool AccessState::WaitAcquirePredicate::operator()(const AccessState &access) const {
-    if (!access.last_write.has_value()) return false;
-    const auto &write_state = *access.last_write;
-    return (write_state.tag == present_tag) && write_state.access_index == SYNC_PRESENT_ENGINE_SYNCVAL_PRESENT_PRESENTED_SYNCVAL;
-}
-
 ResourceUsageRange AccessState::GetFirstAccessRange() const {
     if (first_accesses_.empty()) {
         return {};

layers/sync/sync_access_state.h

@@ -366,29 +366,6 @@ class AccessState {
 
     void ApplySemaphore(const SemaphoreScope &signal, const SemaphoreScope &wait);
 
-    struct WaitQueueTagPredicate {
-        QueueId queue;
-        ResourceUsageTag tag;
-        bool operator()(const ReadState &read_access) const;       // Read access predicate
-        bool operator()(const AccessState &access) const;  // Write access predicate
-    };
-    friend WaitQueueTagPredicate;
-
-    struct WaitTagPredicate {
-        ResourceUsageTag tag;
-        bool operator()(const ReadState &read_access) const;       // Read access predicate
-        bool operator()(const AccessState &access) const;  // Write access predicate
-    };
-    friend WaitTagPredicate;
-
-    struct WaitAcquirePredicate {
-        ResourceUsageTag present_tag;
-        ResourceUsageTag acquire_tag;
-        bool operator()(const ReadState &read_access) const;       // Read access predicate
-        bool operator()(const AccessState &access) const;  // Write access predicate
-    };
-    friend WaitAcquirePredicate;
-
     // Clear read/write accesses that satisfy the predicate
     // (predicate says which accesses should be considered synchronized).
     // Return true if all accesses were cleared and access state is empty

layers/sync/sync_common.h

@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2019-2025 Valve Corporation
- * Copyright (c) 2019-2025 LunarG, Inc.
+ * Copyright (c) 2019-2026 Valve Corporation
+ * Copyright (c) 2019-2026 LunarG, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -32,7 +32,6 @@ using ImageRangeGen = subresource_adapter::ImageRangeGenerator;
 // The resource tag index is relative to the command buffer or queue in which it's found
 using QueueId = uint32_t;
 constexpr static QueueId kQueueIdInvalid = QueueId(vvl::kNoIndex32);
-constexpr static QueueId kQueueAny = kQueueIdInvalid - 1;
 
 using ResourceUsageTag = size_t;
 

layers/sync/sync_submit.cpp

@@ -335,29 +335,76 @@ void QueueBatchContext::ApplyPredicatedWait(Predicate& predicate, const LastSync
     });
 }
 
+struct WaitQueueTagPredicate {
+    QueueId queue;
+    ResourceUsageTag tag;
+
+    bool operator()(const ReadState& read_access) const {
+        return read_access.queue == queue && read_access.tag <= tag &&
+               read_access.stage != VK_PIPELINE_STAGE_2_PRESENT_ENGINE_BIT_SYNCVAL;
+    }
+    bool operator()(const AccessState& access) const {
+        if (!access.HasWriteOp()) {
+            return false;
+        }
+        const WriteState& write_state = access.LastWrite();
+        return write_state.queue == queue && write_state.tag <= tag &&
+               write_state.access_index != SYNC_PRESENT_ENGINE_SYNCVAL_PRESENT_PRESENTED_SYNCVAL;
+    }
+};
+
+struct DeviceWaitPredicate {
+    bool operator()(const ReadState& read_access) const {
+        return read_access.stage != VK_PIPELINE_STAGE_2_PRESENT_ENGINE_BIT_SYNCVAL;
+    }
+    bool operator()(const AccessState& access) const {
+        if (!access.HasWriteOp()) {
+            return false;
+        }
+        return access.LastWrite().access_index != SYNC_PRESENT_ENGINE_SYNCVAL_PRESENT_PRESENTED_SYNCVAL;
+    }
+};
+
+// Present operations matching only the *exactly* tagged present and acquire operations
+struct WaitAcquirePredicate {
+    ResourceUsageTag present_tag;
+    ResourceUsageTag acquire_tag;
+
+    bool operator()(const ReadState& read_access) const {
+        return read_access.tag == acquire_tag && read_access.stage == VK_PIPELINE_STAGE_2_PRESENT_ENGINE_BIT_SYNCVAL;
+    }
+    bool operator()(const AccessState& access) const {
+        if (!access.HasWriteOp()) {
+            return false;
+        }
+        const WriteState& write_state = access.LastWrite();
+        return write_state.tag == present_tag && write_state.access_index == SYNC_PRESENT_ENGINE_SYNCVAL_PRESENT_PRESENTED_SYNCVAL;
+    }
+};
+
 void QueueBatchContext::ApplyTaggedWait(QueueId queue_id, ResourceUsageTag tag,
                                         const LastSynchronizedPresent& last_synchronized_present) {
-    const bool any_queue = (queue_id == kQueueAny);
-
-    if (any_queue) {
-        // This isn't just avoid an unneeded test, but to allow *all* queues to to be waited in a single pass
-        // (and it does avoid doing the same test for every access, as well as avoiding the need for the predicate
-        // to grok Queue/Device/Wait differences.
-        AccessState::WaitTagPredicate predicate{tag};
-        ApplyPredicatedWait(predicate, last_synchronized_present);
-    } else {
-        AccessState::WaitQueueTagPredicate predicate{queue_id, tag};
-        ApplyPredicatedWait(predicate, last_synchronized_present);
-    }
+    WaitQueueTagPredicate predicate{queue_id, tag};
+    ApplyPredicatedWait(predicate, last_synchronized_present);
 
-    // SwapChain acquire QBC's have no queue, but also, events are always empty.
-    if (queue_state_ && (queue_id == GetQueueId() || any_queue)) {
+    // SwapChain acquire batch contexts have no queue
+    if (queue_state_ && queue_id == GetQueueId()) {
         events_context_.ApplyTaggedWait(queue_state_->GetQueueFlags(), tag);
     }
 }
 
+void QueueBatchContext::ApplyDeviceWait(const LastSynchronizedPresent& last_synchronized_present) {
+    DeviceWaitPredicate predicate;
+    ApplyPredicatedWait(predicate, last_synchronized_present);
+
+    // SwapChain acquire batch contexts have no queue
+    if (queue_state_) {
+        events_context_.ApplyTaggedWait(queue_state_->GetQueueFlags(), ResourceUsageRecord::kMaxIndex);
+    }
+}
+
 void QueueBatchContext::ApplyAcquireWait(const AcquiredImage& acquired) {
-    AccessState::WaitAcquirePredicate predicate{acquired.present_tag, acquired.acquire_tag};
+    WaitAcquirePredicate predicate{acquired.present_tag, acquired.acquire_tag};
     ApplyPredicatedWait(predicate, {});
 }
 

layers/sync/sync_submit.h

@@ -360,6 +360,7 @@ class QueueBatchContext : public CommandExecutionContext, public std::enable_sha
     template <typename Predicate>
     void ApplyPredicatedWait(Predicate &predicate, const LastSynchronizedPresent &last_synchronized_present);
     void ApplyTaggedWait(QueueId queue_id, ResourceUsageTag tag, const LastSynchronizedPresent &last_synchronized_present);
+    void ApplyDeviceWait(const LastSynchronizedPresent &last_synchronized_present);
     void ApplyAcquireWait(const AcquiredImage &acquired);
     void OnResourceDestroyed(const AccessRange &resource_range);
 

layers/sync/sync_validation.cpp

@@ -2394,10 +2394,9 @@ void SyncValidator::PostCallRecordDeviceWaitIdle(VkDevice device, const RecordOb
         global_last_synchronized_present.Merge(batch->last_synchronized_present);
     }
 
-    // DeviceWaitIdle is equivalent to waiting on the fence on all queues.
-    // Tagged wait will preserve unsynchronized present operations.
+    // Device wait will preserve unsynchronized present operations.
     for (const auto &batch : batches) {
-        batch->ApplyTaggedWait(kQueueAny, ResourceUsageRecord::kMaxIndex, global_last_synchronized_present);
+        batch->ApplyDeviceWait(global_last_synchronized_present);
     }
 
     // For each timeline keep only the last signal per queue.