Method SyncAllWithLock

preempt/src/xqueue/launch_worker.cpp:265–301

}

std::unique_lock<MutexLock> LaunchWorker::SyncAllWithLock(std::unique_lock<MutexLock> lock)
{
    while (true) {
        // Wait if the worker is paused.
        while (true) {
            if (state_ == kWorkerStateRunning) {
                break;
            } else if (state_ == kWorkerStatePaused) {
                cv_.wait(lock);
            } else if (state_ == kWorkerStateTerminated) {
                return lock;
            } else {
                XASSERT(false, "Invalid worker state");
            }
        }

        // If there is no in-flight HwCommands, then no need to sync.
        if (cmd_log_.size() == 0) return lock;

        int64_t current_pause_cnt = pause_count_;

        lock.unlock();
        kHwq->Synchronize();
        lock.lock();

        // Check if preemption happened during kHwq->Synchronize().
        if (current_pause_cnt == pause_count_) break;
    }

    // Pop and delete all in-flight HwCommands.
    sync_cmd_log_.clear();

    for (auto hw_cmd : cmd_log_) hw_cmd->SetState(kCommandStateCompleted);
    cmd_log_.clear();

    return lock;
}

std::unique_lock<MutexLock> LaunchWorker::SyncCmdWithLock(std::unique_lock<utils::MutexLock> lock,
                                                          std::shared_ptr<HwCommand> hw_cmd)