Method SyncCmdWithLock

preempt/src/xqueue/launch_worker.cpp:303–368

}

std::unique_lock<MutexLock> LaunchWorker::SyncCmdWithLock(std::unique_lock<utils::MutexLock> lock,
                                                          std::shared_ptr<HwCommand> hw_cmd)
{
    XASSERT(hw_cmd->Synchronizable(), "The HwCommand should be synchronizable");

    while (true) {
        // Wait if the worker is paused.
        while (true) {
            // Check if it is already completed.
            // Here checking every loop is necessary because the lock could have been released
            // in the last inner/outer loop and the HwCommand may have been set to
            // kCommandStateCompleted by other threads.
            // It will cause bugs if not checking in the outer loop when the app is syncing this
            // HwCommand, and the XQueue is suspened in the lock-released period in the last
            // outer loop, i.e., unlock(); cmd->sync(); lock();
            // It will also cause bugs if not checking in the inner loop when:
            // 1. the XQueue is suspended
            // 2. this thread is waiting on cv_.wait(lock);
            // 3. lock is released and the XQueue is resumed 
            // 4. hw_cmd is set to completed by another thread
            // 5. the XQueue is again suspended
            // 6. this thread wakes up and locks, finds the XQueue is suspended
            if (hw_cmd->GetState() >= kCommandStateCompleted) return lock;

            if (state_ == kWorkerStateRunning) {
                break;
            } else if (state_ == kWorkerStatePaused) {
                cv_.wait(lock);
            } else if (state_ == kWorkerStateTerminated) {
                return lock;
            } else {
                XASSERT(false, "Invalid worker state");
            }
        }

        XCommandState state = hw_cmd->GetState();
        XASSERT(state >= kCommandStateInFlight, "The syncing HwCommand is not launched");
        if (state == kCommandStateCompleted) break;

        int64_t current_pause_cnt = pause_count_;

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

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

    // Pop and delete all HwCommands launched in previous.
    const int64_t current_command_idx = hw_cmd->GetIdx();

    while (sync_cmd_log_.size() > 0) {
        if (sync_cmd_log_.front()->GetIdx() > current_command_idx) break;
        sync_cmd_log_.pop_front();
    }

    while (cmd_log_.size() > 0) {