Method LaunchHwCommand

preempt/src/xqueue/launch_worker.cpp:164–263

}

void LaunchWorker::LaunchHwCommand(std::shared_ptr<HwCommand> hw_cmd)
{
    XDEBG("launch hw_cmd (%p) idx " FMT_64D, hw_cmd.get(), hw_cmd->GetIdx());
    // If a HwCommand is deactivated, all non-idempotent HwCommands launched after it should also
    // be deactivated. Otherwise the XPU will become inconsist. So, if a HwCommand is not
    // deactivatable, it should wait until all in-flight deactivatable HwCommands are completed.
    // This is unnecessary under kPreemptLevelBlock.
    bool wait_deactivatable = level_ >= kPreemptLevelDeactivate &&
        (kCommandPropertyNone == hw_cmd->GetProps(
            kCommandPropertyDeactivatable | kCommandPropertyIdempotent));

    hw_cmd->BeforeLaunch();
    std::unique_lock<MutexLock> lock(*mtx_);

    // If the HwCommand is not deactivatable and non-idempoent,
    // wait until all previous in-flight deactivatable HwCommand are completed.
    if (wait_deactivatable) {
        // Find the last synchronizable HwCommand after the last deactivatable HwCommand.
        bool has_deactivatable = false;
        std::shared_ptr<HwCommand> command_to_sync = nullptr;
        for (auto it = cmd_log_.rbegin(); it != cmd_log_.rend(); ++it) {
            if ((*it)->Synchronizable()) command_to_sync = *it;
            if ((*it)->GetProps(kCommandPropertyDeactivatable)) {
                has_deactivatable = true;
                break;
            }
        }

        if (has_deactivatable) {
            // If there is a synchronizable HwCommand, sync it. Otherwise, sync the HwQueue.
            lock = (command_to_sync == nullptr)
                 ? SyncAllWithLock(std::move(lock))
                 : SyncCmdWithLock(std::move(lock), command_to_sync);
        }
    }

    if (cmd_log_.size() >= (size_t)threshold_) {
        // The command log is full (in-flight HwCommand reaches threshold), wait for a empty slot.
        std::shared_ptr<HwCommand> command_to_sync = nullptr;
        int64_t front_command_idx = cmd_log_.front()->GetIdx();

        for (auto cmd : sync_cmd_log_) {
            // Make sure after syncing the HwCommand, there will be at least one empty slot.
            if (cmd->GetIdx() >= front_command_idx) {
                command_to_sync = cmd;
                break;
            }
        }

        // If there is a synchronizable HwCommand, sync it. Otherwise, sync the HwQueue.
        lock = (command_to_sync == nullptr)
             ? SyncAllWithLock(std::move(lock))
             : SyncCmdWithLock(std::move(lock), command_to_sync);

    } else {
        // Wait if the worker is paused.
        while (true) {
            if (state_ == kWorkerStateRunning) {