layers: Implement submit time tracker

This implements the first version of submit time tracker. Track timeline
signals so postponed wait-before-signal submissions can be validated
directly during QueueSubmit and SignalSemaphore calls.

As a first step, move submit time image layout validation out of the
queue thread and integrate it with this system

Author: artem-lunarg

layers/core_checks/cc_queue.cpp

@@ -290,7 +290,9 @@ bool CoreChecks::PreCallValidateQueueSubmit(VkQueue queue, uint32_t submitCount,
                                  chained_device_group_struct->commandBufferCount, submit.commandBufferCount);
             }
         }
-        skip |= submit_time_tracker.ProcessSubmissionBatch(submit);
+        // Perform submit time validation at the end.
+        // If submit API is used incorrectly, we want those errors to be reported first
+        skip |= submit_time_tracker.ProcessSubmitInfo(submit, queue, submit_loc);
     }
 
     return skip;
@@ -450,6 +452,9 @@ bool CoreChecks::ValidateQueueSubmit2(VkQueue queue, uint32_t submitCount, const
             skip |= LogError("VUID-VkSubmitInfo2-commandBuffer-06010", queue, submit_loc,
                              "has a suspended render pass instance that was not resumed.");
         }
+        // Perform submit time validation at the end.
+        // If submit API is used incorrectly, we want those errors to be reported first
+        skip |= submit_time_tracker.ProcessSubmitInfo(submit, queue, submit_loc);
     }
 
     return skip;
@@ -778,3 +783,30 @@ bool CoreChecks::PreCallValidateQueueBindSparse(VkQueue queue, uint32_t bindInfo
     }
     return skip;
 }
+
+bool CoreChecks::ProcessSubmissionBatch(const std::vector<std::shared_ptr<vvl::CommandBuffer>>& command_buffers,
+                                        const Location& submit_loc) {
+    bool skip = false;
+    // Validate image layouts on the command buffer boundaries
+    {
+        vvl::unordered_map<const vvl::Image*, ImageLayoutMap> local_image_layout_map;
+        for (const auto& cb : command_buffers) {
+            if (cb) {
+                auto cb_guard = cb->ReadLock();
+                skip |= ValidateCmdBufImageLayouts(submit_loc, *cb, local_image_layout_map);
+            }
+        }
+    }
+    if (!skip) {
+        for (const auto& cb : command_buffers) {
+            if (cb) {
+                auto cb_guard = cb->WriteLock();
+                for (const vvl::CommandBuffer* secondary : cb->linked_command_buffers) {
+                    UpdateCmdBufImageLayouts(*secondary);
+                }
+                UpdateCmdBufImageLayouts(*cb);
+            }
+        }
+    }
+    return skip;
+}

layers/core_checks/cc_state_tracker.cpp

@@ -1229,7 +1229,6 @@ void QueueSubState::PreSubmit(std::vector<vvl::QueueSubmission>& submissions) {
 
 void QueueSubState::Retire(vvl::QueueSubmission& submission) {
     queue_submission_validator_.Validate(submission);
-    queue_submission_validator_.Update(submission);
 
     auto is_query_updated_after = [this](const QueryObject& query_object) {
         auto guard = base.Lock();

layers/core_checks/cc_submit.cpp

@@ -34,24 +34,6 @@ static Location GetSignaledSemaphoreLocation(const Location& submit_loc, uint32_
     return submit_loc.dot(field, index);
 }
 
-static bool FindLayouts(const vvl::Image& image_state, std::vector<VkImageLayout>& layouts) {
-    if (!image_state.layout_map) {
-        return false;
-    }
-    const auto& layout_map = *image_state.layout_map;
-    auto guard = image_state.LayoutMapReadLock();
-
-    // TODO: Make this robust for >1 aspect mask. Now it will just say ignore potential errors in this case.
-    if (layout_map.size() > image_state.GetArrayLayers() * image_state.GetMipLevels()) {
-        return false;
-    }
-
-    for (const auto& entry : layout_map) {
-        layouts.emplace_back(entry.second);
-    }
-    return true;
-}
-
 void QueueSubmissionValidator::Validate(const vvl::QueueSubmission& submission) const {
     // Ensure that timeline signals are monotonically increasing values
     for (uint32_t i = 0; i < (uint32_t)submission.signal_semaphores.size(); ++i) {
@@ -74,39 +56,4 @@ void QueueSubmissionValidator::Validate(const vvl::QueueSubmission& submission)
                                  core_checks.FormatHandle(signal.semaphore->VkHandle()).c_str(), signal.payload, current_payload);
         }
     }
-
-    // Validate image layouts on the command buffer boundaries
-    {
-        vvl::unordered_map<const vvl::Image*, ImageLayoutMap> local_image_layout_map;
-        for (const vvl::CommandBufferSubmission& cb_submission : submission.cb_submissions) {
-            auto cb_guard = cb_submission.cb->ReadLock();
-            core_checks.ValidateCmdBufImageLayouts(submission.loc.Get(), *cb_submission.cb, local_image_layout_map);
-        }
-    }
-
-    // Check that image being presented has correct layout
-    if (submission.swapchain) {
-        std::vector<VkImageLayout> layouts;
-        if (submission.swapchain_image && FindLayouts(*submission.swapchain_image, layouts)) {
-            for (auto layout : layouts) {
-                if (layout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR && layout != VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR) {
-                    core_checks.LogError(
-                        "VUID-VkPresentInfoKHR-pImageIndices-01430", submission.swapchain_image->Handle(), submission.loc.Get(),
-                        "images passed to present must be in layout VK_IMAGE_LAYOUT_PRESENT_SRC_KHR or "
-                        "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR but %s is in %s.",
-                        core_checks.FormatHandle(submission.swapchain_image->Handle()).c_str(), string_VkImageLayout(layout));
-                }
-            }
-        }
-    }
-}
-
-void QueueSubmissionValidator::Update(vvl::QueueSubmission& submission) {
-    for (vvl::CommandBufferSubmission& cb_submission : submission.cb_submissions) {
-        auto cb_guard = cb_submission.cb->WriteLock();
-        for (const vvl::CommandBuffer* secondary : cb_submission.cb->linked_command_buffers) {
-            core_checks.UpdateCmdBufImageLayouts(*secondary);
-        }
-        core_checks.UpdateCmdBufImageLayouts(*cb_submission.cb);
-    }
 }

layers/core_checks/cc_submit.h

@@ -1,6 +1,6 @@
-/* Copyright (c) 2025 The Khronos Group Inc.
- * Copyright (c) 2025 Valve Corporation
- * Copyright (c) 2025 LunarG, Inc.
+/* Copyright (c) 2026 The Khronos Group Inc.
+ * Copyright (c) 2026 Valve Corporation
+ * Copyright (c) 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.
@@ -36,5 +36,4 @@ struct QueueSubmissionValidator {
 
     QueueSubmissionValidator(CoreChecks &core_checks) : core_checks(core_checks) {}
     void Validate(const vvl::QueueSubmission &submission) const;
-    void Update(vvl::QueueSubmission &submission);
 };

layers/core_checks/cc_synchronization.cpp

@@ -719,6 +719,26 @@ bool CoreChecks::PreCallValidateCreateSemaphore(VkDevice device, const VkSemapho
     return skip;
 }
 
+void CoreChecks::PostCallRecordCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
+                                               const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore,
+                                               const RecordObject& record_obj) {
+    if (record_obj.result != VK_SUCCESS) {
+        return;
+    }
+    auto semaphore_state = Get<vvl::Semaphore>(*pSemaphore);
+    if (semaphore_state && semaphore_state->type == VK_SEMAPHORE_TYPE_TIMELINE) {
+        submit_time_tracker.OnCreateTimelineSemaphore(*pSemaphore, semaphore_state->initial_value);
+    }
+}
+
+void CoreChecks::PreCallRecordDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator,
+                                               const RecordObject& record_obj) {
+    auto semaphore_state = Get<vvl::Semaphore>(semaphore);
+    if (semaphore_state && semaphore_state->type == VK_SEMAPHORE_TYPE_TIMELINE) {
+        submit_time_tracker.OnDestroyTimelineSemaphore(semaphore);
+    }
+}
+
 bool CoreChecks::PreCallValidateWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout,
                                                   const ErrorObject& error_obj) const {
     return PreCallValidateWaitSemaphores(device, pWaitInfo, timeout, error_obj);
@@ -1627,6 +1647,10 @@ bool CoreChecks::PreCallValidateSignalSemaphore(VkDevice device, const VkSemapho
                          "(%" PRIu64 ") exceeds limit regarding %s semaphore %s payload (%" PRIu64 ").", pSignalInfo->value,
                          FormatHandle(*semaphore_state).c_str(), payload_type, *far_away_payload);
     }
+
+    // Perform submit time validation at the end.
+    // If signal semaphore API is used incorrectly, we want those errors to be reported first
+    skip |= submit_time_tracker.ProcessSignalSemaphore(*pSignalInfo);
     return skip;
 }
 

layers/core_checks/cc_wsi.cpp

@@ -1257,6 +1257,10 @@ bool CoreChecks::PreCallValidateQueuePresentKHR(VkQueue queue, const VkPresentIn
         skip |= ValidateSwapchainPresentFenceInfo(queue, *pPresentInfo, *swapchain_present_fence_info, present_info_loc);
     }
 
+    // Perform submit time validation at the end.
+    // If present API is used incorrectly, we want those errors to be reported first
+    skip |= submit_time_tracker.ProcessPresent(*pPresentInfo, present_info_loc);
+
     return skip;
 }
 
@@ -1542,6 +1546,41 @@ bool CoreChecks::PreCallValidateWaitForPresent2KHR(VkDevice device, VkSwapchainK
     return skip;
 }
 
+static bool FindLayouts(const vvl::Image& image_state, std::vector<VkImageLayout>& layouts) {
+    if (!image_state.layout_map) {
+        return false;
+    }
+    const auto& layout_map = *image_state.layout_map;
+    auto guard = image_state.LayoutMapReadLock();
+
+    // TODO: Make this robust for >1 aspect mask. Now it will just say ignore potential errors in this case.
+    if (layout_map.size() > image_state.GetArrayLayers() * image_state.GetMipLevels()) {
+        return false;
+    }
+
+    for (const auto& entry : layout_map) {
+        layouts.emplace_back(entry.second);
+    }
+    return true;
+}
+
+bool CoreChecks::ProcessPresentBatch(const vvl::Image& swapchain_image, const Location& present_info_loc) {
+    bool skip = false;
+    // Check that image being presented has correct layout
+    std::vector<VkImageLayout> layouts;
+    if (FindLayouts(swapchain_image, layouts)) {
+        for (auto layout : layouts) {
+            if (layout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR && layout != VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR) {
+                skip |= LogError("VUID-VkPresentInfoKHR-pImageIndices-01430", swapchain_image.Handle(), present_info_loc,
+                                 "images passed to present must be in layout VK_IMAGE_LAYOUT_PRESENT_SRC_KHR or "
+                                 "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR but %s is in %s.",
+                                 FormatHandle(swapchain_image.Handle()).c_str(), string_VkImageLayout(layout));
+            }
+        }
+    }
+    return skip;
+}
+
 bool core::Instance::PreCallValidateDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
                                                       const VkAllocationCallbacks* pAllocator, const ErrorObject& error_obj) const {
     bool skip = false;

layers/core_checks/core_validation.h

@@ -1107,7 +1107,6 @@ class CoreChecks : public vvl::DeviceProxy {
                                                 VkDataGraphPipelineSessionARM session,
                                                 const VkDataGraphPipelineDispatchInfoARM *pInfo,
                                                 const ErrorObject& error_obj) const override;
-
     void PostCallRecordCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
                                    VkImage* pImage, const RecordObject& record_obj) override;
 
@@ -1580,6 +1579,9 @@ class CoreChecks : public vvl::DeviceProxy {
                                        const RecordObject& record_obj) override;
     void PostCallRecordQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence,
                                     const RecordObject& record_obj) override;
+    bool ProcessSubmissionBatch(const std::vector<std::shared_ptr<vvl::CommandBuffer>>& command_buffers,
+                                const Location& submit_loc) override;
+    bool ProcessPresentBatch(const vvl::Image& swapchain_image, const Location& present_info_loc) override;
     bool IgnoreAllocationSize(const VkMemoryAllocateInfo& allocate_info) const;
     bool HasExternalMemoryImportSupport(const vvl::Buffer& buffer, VkExternalMemoryHandleTypeFlagBits handle_type) const;
     bool HasExternalMemoryImportSupport(const vvl::Image& image, VkExternalMemoryHandleTypeFlagBits handle_type) const;
@@ -1594,6 +1596,11 @@ class CoreChecks : public vvl::DeviceProxy {
     bool PreCallValidateCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
                                         const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore,
                                         const ErrorObject& error_obj) const override;
+    void PostCallRecordCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
+                                       const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore,
+                                       const RecordObject& record_obj) override;
+    void PreCallRecordDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator,
+                                       const RecordObject& record_obj) override;
     bool PreCallValidateWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout,
                                        const ErrorObject& error_obj) const override;
     bool PreCallValidateWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout,

layers/state_tracker/state_tracker.h

@@ -43,7 +43,6 @@
 
 namespace vvl {
 struct AllocateDescriptorSetsData;
-struct SubmissionBatch;
 class Fence;
 class DescriptorPool;
 class DescriptorSet;
@@ -2352,14 +2351,21 @@ class DeviceProxy : public vvl::BaseDevice {
     virtual void Created(vvl::ShaderObject& state) {}
     virtual void Created(vvl::Pipeline& state){};
 
-    // Validate submission batch and update state if necessary.
-    // Called by SubmitTimeTracker and protected by the mutex. Only one batch is processed at a time.
+    // Validate a submission batch and update state if needed.
+    // This call is protected by the global submit-time mutex.
     //
-    // NOTE: Classic Validate/Record split made it a challenge to synchronize threaded queues,
-    // especialy when timeline signal resolves pending work on another queue.
-    // This became increasingly important after the spec allowed internally synchronized queues,
-    // meaning the same queue can be used from multiple threads.
-    virtual bool ProcessSubmissionBatch(SubmissionBatch& batch) { return false; }
+    // NOTE: The classic Validate/Record split made threaded queues difficult to synchronize,
+    // especially when a timeline signal resolves pending work on another queue.
+    // This became even more important after the spec allowed internally synchronized queues,
+    // which means the same queue can be used from multiple threads
+    virtual bool ProcessSubmissionBatch(const std::vector<std::shared_ptr<vvl::CommandBuffer>>& command_buffers,
+                                        const Location& submit_loc) {
+        return false;
+    }
+
+    // Validate a submission batch and update state if needed.
+    // This call is protected by the global submit-time mutex
+    virtual bool ProcessPresentBatch(const vvl::Image& swapchain_image, const Location& present_info_loc) { return false; }
 
     // callbacks for image layout validation, which is implemented in both core validation and gpu-av
     // TODO - It would be nice to have a way to not need a duplicate copy in both CoreChecks and GPU-AV code