sync: Remove UnresolvedQueue struct

UnresolvedQueue was needed in the past because we collected data from two
sources: regular batches and pending batches. We don't have pending batch
functionality anymore.

Use QueueState directly instead of intermediate UnresolvedQueue

Author: artem-lunarg

layers/state_tracker/submit_time_tracker.cpp

@@ -154,7 +154,7 @@ bool SubmitTimeTracker::PropagateTimelineSignals() {
     // The caller ensures we just registered new timeline signals
     bool new_timeline_signals = true;
 
-    // Each iteration attempts to resolve pending batches using current timeline value.
+    // Each iteration uses registered timeline signals to resolve batches.
     // If a resolved batch generates new timeline signals, the loop runs again
     while (new_timeline_signals) {
         new_timeline_signals = false;

layers/sync/sync_submit.cpp

@@ -802,10 +802,6 @@ void QueueState::SetLastBatch(BatchContextPtr&& last) {
     }
 }
 
-void QueueState::SetUnresolvedBatches(std::vector<UnresolvedBatch>&& unresolved_batches) {
-    unresolved_batches_ = std::move(unresolved_batches);
-}
-
 void BatchAccessLog::Import(const BatchRecord& batch, const CommandBufferAccessContext& cb_access,
                             const std::vector<std::string>& initial_label_stack) {
     ResourceUsageRange import_range = {batch.base_tag, batch.base_tag + cb_access.GetTagCount()};

layers/sync/sync_submit.h

@@ -263,14 +263,6 @@ struct UnresolvedBatch {
     std::vector<std::string> label_stack;
 };
 
-// Helper struct to resolve wait-before-signal
-struct UnresolvedQueue {
-    QueueState* queue_state = nullptr;
-    std::vector<UnresolvedBatch> unresolved_batches;
-    // whether unresolved state should be updated for this queue
-    bool update_unresolved = false;
-};
-
 // Track the last synchronized presentation operation for each swapchain.
 // "Presentation is synchronized" means that we re-acquired previously
 // presented image and this batch context directly or indirectly waits for
@@ -298,8 +290,7 @@ class QueueState {
     BatchContextPtr LastBatch() const { return last_batch_; }
     void SetLastBatch(BatchContextPtr&& last);
 
-    const std::vector<UnresolvedBatch>& UnresolvedBatches() const { return unresolved_batches_; }
-    void SetUnresolvedBatches(std::vector<UnresolvedBatch>&& unresolved_batches);
+    std::vector<UnresolvedBatch>& UnresolvedBatches() { return unresolved_batches_; }
 
   private:
     std::shared_ptr<vvl::Queue> queue_;

layers/sync/sync_validation.cpp

@@ -2523,9 +2523,7 @@ bool SyncValidator::ProcessQueueSubmit(VkQueue queue, uint32_t submitCount, cons
         queue_state.SetLastBatch(std::move(new_last_batch));
     }
     if (!new_unresolved_batches.empty() && !skip) {
-        auto unresolved_batches = queue_state.UnresolvedBatches();
-        vvl::Append(unresolved_batches, new_unresolved_batches);
-        queue_state.SetUnresolvedBatches(std::move(unresolved_batches));
+        vvl::Append(queue_state.UnresolvedBatches(), new_unresolved_batches);
     }
 
     // Check if timeline signals resolve existing wait-before-signal dependencies
@@ -2549,94 +2547,73 @@ bool SyncValidator::ProcessQueueSubmit(VkQueue queue, uint32_t submitCount, cons
 
 bool SyncValidator::PropagateTimelineSignals(SignalsUpdate& signals_update, const ErrorObject& error_obj) {
     bool skip = false;
-    // Initialize per-queue unresolved batches state.
-    std::vector<UnresolvedQueue> queues;
-    for (QueueState& queue_state : queue_states_) {
-        if (!queue_state.UnresolvedBatches().empty()) {
-            queues.emplace_back(UnresolvedQueue{&queue_state, queue_state.UnresolvedBatches()});
-        }
-    }
 
-    // Each iteration uses registered timeline signals to resolve existing unresolved batches.
-    // Each resolved batch can generate new timeline signals which can resolve more unresolved batches on the next iteration.
-    // This finishes when all unresolved batches are resolved or when iteration does not generate new timeline signals.
-    while (ProcessUnresolvedBatches(queues, signals_update, skip, error_obj)) {
-        ;
-    }
+    // The caller ensures we just registered new timeline signals
+    bool new_timeline_signals = true;
 
-    // Update unresolved state
-    for (UnresolvedQueue& queue : queues) {
-        if (queue.update_unresolved) {
-            queue.queue_state->SetUnresolvedBatches(std::move(queue.unresolved_batches));
-        }
-    }
-    return skip;
-}
+    // Each iteration uses registered timeline signals to resolve batches.
+    // If a resolved batch generates new timeline signals, the loop runs again
+    while (new_timeline_signals) {
+        new_timeline_signals = false;
 
-bool SyncValidator::ProcessUnresolvedBatches(std::vector<UnresolvedQueue>& queues, SignalsUpdate& signals_update, bool& skip,
-                                             const ErrorObject& error_obj) const {
-    bool has_new_timeline_signals = false;
-    for (auto& queue : queues) {
-        if (queue.unresolved_batches.empty()) {
-            continue;  // all batches for this queue were resolved by previous iterations
-        }
-        // Resolve waits that have matching signal
-        for (UnresolvedBatch& unresolved_batch : queue.unresolved_batches) {
-            auto it = unresolved_batch.unresolved_waits.begin();
-            while (it != unresolved_batch.unresolved_waits.end()) {
-                const VkSemaphoreSubmitInfo& wait_info = *it;
-                auto resolving_signal = signals_update.OnTimelineWait(wait_info.semaphore, wait_info.value);
-                if (!resolving_signal.has_value()) {
-                    ++it;
-                    continue;  // resolving signal not found, the wait stays unresolved
-                }
-                if (resolving_signal->batch) {  // null for host signals
-                    unresolved_batch.batch->ResolveSubmitSemaphoreWait(*resolving_signal, wait_info.stageMask);
-                    unresolved_batch.batch->ImportTags(*resolving_signal->batch);
-                    unresolved_batch.resolved_dependencies.emplace_back(resolving_signal->batch);
+        for (QueueState& queue_state : queue_states_) {
+            auto& unresolved_batches = queue_state.UnresolvedBatches();
+            if (unresolved_batches.empty()) {
+                continue;
+            }
+            // Resolve waits that have matching signal
+            for (UnresolvedBatch& unresolved_batch : unresolved_batches) {
+                auto it = unresolved_batch.unresolved_waits.begin();
+                while (it != unresolved_batch.unresolved_waits.end()) {
+                    const VkSemaphoreSubmitInfo& wait_info = *it;
+                    auto resolving_signal = signals_update.OnTimelineWait(wait_info.semaphore, wait_info.value);
+                    if (!resolving_signal.has_value()) {
+                        ++it;
+                        continue;  // resolving signal not found, the wait stays unresolved
+                    }
+                    if (resolving_signal->batch) {  // null for host signals
+                        unresolved_batch.batch->ResolveSubmitSemaphoreWait(*resolving_signal, wait_info.stageMask);
+                        unresolved_batch.batch->ImportTags(*resolving_signal->batch);
+                        unresolved_batch.resolved_dependencies.emplace_back(resolving_signal->batch);
+                    }
+                    it = unresolved_batch.unresolved_waits.erase(it);
                 }
-                it = unresolved_batch.unresolved_waits.erase(it);
             }
-        }
-
-        BatchContextPtr last_batch = queue.queue_state->LastBatch();
-        const BatchContextPtr initial_last_batch = last_batch;
 
-        // Process batches that do not have unresolved waits anymore.
-        // Stop when find a batch with unresolved waits or when all the batches are processed.
-        while (!queue.unresolved_batches.empty() && queue.unresolved_batches.front().unresolved_waits.empty()) {
-            UnresolvedBatch& ready_batch = queue.unresolved_batches.front();
-
-            // Import the previous batch information
-            if (last_batch && !vvl::Contains(ready_batch.resolved_dependencies, last_batch)) {
-                ready_batch.batch->ResolveLastBatch(last_batch);
-                ready_batch.resolved_dependencies.emplace_back(std::move(last_batch));
-            }
-            last_batch = ready_batch.batch;
+            BatchContextPtr last_batch = queue_state.LastBatch();
+            const BatchContextPtr initial_last_batch = last_batch;
 
-            const auto async_batches = ready_batch.batch->RegisterAsyncContexts(ready_batch.resolved_dependencies);
+            // Process batches that do not have unresolved waits anymore.
+            // Stop when find a batch with unresolved waits or when all the batches are processed.
+            while (!unresolved_batches.empty() && unresolved_batches.front().unresolved_waits.empty()) {
+                UnresolvedBatch& ready_batch = unresolved_batches.front();
 
-            skip |= ready_batch.batch->ValidateSubmit(ready_batch.command_buffers, ready_batch.submit_index,
-                                                      ready_batch.batch_index, ready_batch.label_stack, error_obj);
+                // Import the previous batch information
+                if (last_batch && !vvl::Contains(ready_batch.resolved_dependencies, last_batch)) {
+                    ready_batch.batch->ResolveLastBatch(last_batch);
+                    ready_batch.resolved_dependencies.emplace_back(std::move(last_batch));
+                }
 
-            // Process signals. New timeline signals can resolve more batches on the next iteration
-            const auto submit_signals = vvl::make_span(ready_batch.signals.data(), ready_batch.signals.size());
-            has_new_timeline_signals |= signals_update.RegisterSignals(ready_batch.batch, submit_signals);
+                const auto async_batches = ready_batch.batch->RegisterAsyncContexts(ready_batch.resolved_dependencies);
 
-            // Remove processed batch from the (local) unresolved list
-            queue.unresolved_batches.erase(queue.unresolved_batches.begin());
+                skip |= ready_batch.batch->ValidateSubmit(ready_batch.command_buffers, ready_batch.submit_index,
+                                                          ready_batch.batch_index, ready_batch.label_stack, error_obj);
 
-            // Propagate change into the queue's (global) unresolved state
-            queue.update_unresolved = true;
+                // Process signals. New timeline signals can resolve more batches on the next iteration
+                const auto submit_signals = vvl::make_span(ready_batch.signals.data(), ready_batch.signals.size());
+                new_timeline_signals |= signals_update.RegisterSignals(ready_batch.batch, submit_signals);
 
-            stats.RemoveUnresolvedBatch();
-        }
+                last_batch = ready_batch.batch;
+                unresolved_batches.erase(unresolved_batches.begin());
+                stats.RemoveUnresolvedBatch();
+            }
 
-        if (last_batch != initial_last_batch) {
-            queue.queue_state->SetLastBatch(std::move(last_batch));
+            if (last_batch != initial_last_batch) {
+                queue_state.SetLastBatch(std::move(last_batch));
+            }
         }
     }
-    return has_new_timeline_signals;
+    return skip;
 }
 
 void SyncValidator::PostCallRecordGetFenceStatus(VkDevice device, VkFence fence, const RecordObject& record_obj) {

layers/sync/sync_validation.h

@@ -96,10 +96,6 @@ class SyncValidator : public vvl::DeviceProxy {
 
     bool PropagateTimelineSignals(SignalsUpdate& signals_update, const ErrorObject& error_obj);
 
-    // Return true if new timeline signals were generated by resolved batches
-    bool ProcessUnresolvedBatches(std::vector<UnresolvedQueue>& queues, SignalsUpdate& signals_update, bool& skip,
-                                  const ErrorObject& error_ob) const;
-
     void ApplyTaggedWait(QueueId queue_id, ResourceUsageTag tag, const LastSynchronizedPresent &last_synchronized_present,
                          const std::vector<ResourceUsageTag> &queue_sync_tags);
     void ApplyAcquireWait(const AcquiredImage &acquired);