Method PreSubmit

layers/state_tracker/queue_state.cpp:66–114

}

uint64_t vvl::Queue::PreSubmit(std::vector<vvl::QueueSubmission>&& submissions) {
    if (!submissions.empty()) {
        submissions.back().is_last_submission = true;
    }
    uint64_t last_batch_seq = 0;
    for (QueueSubmission& submission : submissions) {
        for (CommandBufferSubmission& cb_submission : submission.cb_submissions) {
            auto cb_guard = cb_submission.cb->WriteLock();
            for (CommandBuffer* secondary_cmd_buffer : cb_submission.cb->linked_command_buffers) {
                auto secondary_guard = secondary_cmd_buffer->WriteLock();
                secondary_cmd_buffer->submit_count++;
            }
            cb_submission.cb->submit_count++;
            cb_submission.cb->SubmitTimeValidate(*this, submission.perf_submit_pass, submission.loc.Get());
        }
        // seq_ is atomic so we don't need a lock until updating the deque below.
        // Note that this relies on the external synchonization requirements for the
        // VkQueue
        submission.seq = ++seq_;
        last_batch_seq = submission.seq;
        submission.BeginUse();
        for (SemaphoreInfo& wait : submission.wait_semaphores) {
            wait.semaphore->EnqueueWait(SubmissionReference(this, submission.seq), wait.payload);
            timeline_wait_count_.fetch_add((wait.semaphore->type == VK_SEMAPHORE_TYPE_TIMELINE) ? 1 : 0);
        }

        for (SemaphoreInfo& signal : submission.signal_semaphores) {
            signal.semaphore->EnqueueSignal(SubmissionReference(this, submission.seq), signal.payload);
        }

        if (submission.fence) {
            if (submission.fence->EnqueueSignal(this, submission.seq)) {
                submission.has_external_fence = true;
            }
        }
    }
    for (auto& item : sub_states_) {
        item.second->PreSubmit(submissions);
    }
    {
        auto guard = Lock();
        submissions_.insert(submissions_.end(), std::make_move_iterator(submissions.begin()),
                            std::make_move_iterator(submissions.end()));
        if (!thread_) {
            thread_ = std::make_unique<std::thread>(&Queue::ThreadFunc, this);
        }
    }
    return last_batch_seq;
}

void vvl::Queue::Notify(uint64_t until_seq) {
    auto guard = Lock();