terminate_all_tasks()

void MayaFlux::Vruta::TaskScheduler::terminate_all_tasks

(

)

Terminate and clear all tasks.

Submissions made while this runs, including from completion callbacks, are rejected. Must not be called from the conditional worker thread or from a callback fired during a queue drain; such calls are ignored. New tasks are accepted again once this returns, or if any step throws.

Definition at line 596 of file Scheduler.cpp.

{
    if (m_conditional_thread.joinable() && m_conditional_thread.get_id() == std::this_thread::get_id()) {
        return;
    }
 
    if (t_draining == this) {
        MF_WARN(Journal::Component::Vruta, Journal::Context::CoroutineScheduling,
            "terminate_all_tasks ignored: called from a callback during a queue drain");
        return;
    }
 
    if (m_terminating.exchange(true)) {
        return;
    }
    TerminationScope terminating(m_terminating);
 
    while (m_inflight_submissions.load() != 0) {
        std::this_thread::yield();
    }
 
    if (m_conditional_thread.joinable()) {
        m_conditional_thread.request_stop();
        m_conditional_thread.join();
    }
 
    drain_pending_tasks();
    drain_conditional_pending();
 
    for (auto& entry : m_tasks) {
        if (entry.routine && entry.routine->is_active()) {
            entry.routine->set_should_terminate(true);
        }
    }
 
    for (auto& entry : m_tasks) {
        if (entry.routine && entry.routine->is_active()) {
            entry.routine->force_resume();
        }
    }
 
    constexpr int MAX_ATTEMPTS = 3;
    for (int attempt = 0; attempt < MAX_ATTEMPTS; ++attempt) {
        std::this_thread::sleep_for(std::chrono::milliseconds(5));
 
        bool any_active = false;
        for (auto& entry : m_tasks) {
            if (entry.routine && entry.routine->is_active()) {
                any_active = true;
                entry.routine->force_resume();
            }
        }
 
        if (!any_active) {
            break;
        }
    }
 
    bool all_done = true;
    for (const auto& entry : m_tasks) {
        if (entry.routine && entry.routine->is_active()) {
            all_done = false;
            MF_WARN(Journal::Component::Vruta, Journal::Context::CoroutineScheduling,
                "Coroutine '{}' stuck after {} attempts - forcing destruction",
                entry.name, MAX_ATTEMPTS);
        }
    }
 
    if (!all_done) {
        MF_WARN(Journal::Component::Vruta, Journal::Context::CoroutineScheduling,
            "Some coroutines did not complete - forcing destruction");
    } else {
        MF_INFO(Journal::Component::Vruta, Journal::Context::CoroutineScheduling,
            "All coroutines terminated successfully");
    }
 
    for (auto& entry : m_conditional_tasks) {
        if (entry.routine && entry.routine->is_active())
            entry.routine->set_should_terminate(true);
    }
    for (auto& entry : m_conditional_tasks) {
        if (entry.routine && entry.routine->is_active())
            entry.routine->force_resume();
    }
    m_conditional_tasks.clear();
 
    m_tasks.clear();
}

References MayaFlux::Journal::CoroutineScheduling, drain_conditional_pending(), drain_pending_tasks(), m_conditional_tasks, m_conditional_thread, m_inflight_submissions, m_tasks, m_terminating, MF_INFO, MF_WARN, and MayaFlux::Journal::Vruta.

Here is the call graph for this function: