drain_pending_tasks()

void MayaFlux::Vruta::TaskScheduler::drain_pending_tasks ( )

private

Drain pending task operations (additions/removals) before processing.

This method ensures that any tasks that were added or removed while processing are properly handled before the next processing cycle.

Definition at line 705 of file Scheduler.cpp.

{
    if (m_pending_count.load(std::memory_order_relaxed) == 0)
        return;
 
    DrainScope drain_scope(this);
 
    for (auto& op : m_pending_ops) {
        if (!op.active.load(std::memory_order_acquire))
            continue;
 
        if (op.is_addition) {
            auto existing_it = find_task_by_name(op.entry.name);
            if (existing_it != m_tasks.end()) {
                if (existing_it->routine && existing_it->routine->is_active())
                    existing_it->routine->set_should_terminate(true);
                m_tasks.erase(existing_it);
            }
            m_tasks.push_back(std::move(op.entry));
        } else {
            auto it = (op.entry.name.empty() && op.entry.routine)
                ? find_task_by_routine(op.entry.routine)
                : find_task_by_name(op.entry.name);
            if (it != m_tasks.end()) {
                if (it->routine && it->routine->is_active())
                    it->routine->set_should_terminate(true);
                m_tasks.erase(it);
            }
        }
 
        op.entry = { nullptr, "" };
        op.active.store(false, std::memory_order_release);
        m_pending_count.fetch_sub(1, std::memory_order_relaxed);
    }
}

References find_task_by_name(), find_task_by_routine(), m_pending_count, m_pending_ops, and m_tasks.

Referenced by get_all_tasks(), process_buffer_cycle_tasks(), process_token(), and terminate_all_tasks().

Here is the call graph for this function:

Here is the caller graph for this function: