Method balance_work

source/executors/thread_pool_executor.cpp:197–263

}

void thread_pool_worker::balance_work() {
    const auto task_count = m_private_queue.size();
    if (task_count < 2) {  // no point in donating tasks
        return;
    }

    // we assume all threads but us are idle, we also save at least one task for ourselves
    const auto max_idle_worker_count = std::min(m_pool_size - 1, task_count - 1);
    if (max_idle_worker_count == 0) {
        return;  // a thread-pool with a single thread
    }

    m_parent_pool.find_idle_workers(m_index, m_idle_worker_list, max_idle_worker_count);
    const auto idle_count = m_idle_worker_list.size();
    if (idle_count == 0) {
        return;
    }

    assert(idle_count <= task_count);
    const auto total_worker_count = (idle_count + 1);  // count ourselves, otherwise we'll donate everything.
    const auto donation_count = task_count / total_worker_count;
    auto extra = task_count - donation_count * total_worker_count;

    size_t begin = 0;
    size_t end = donation_count;

    for (const auto idle_worker_index : m_idle_worker_list) {
        assert(idle_worker_index != m_index);
        assert(idle_worker_index < m_pool_size);
        assert(begin < task_count);

        if (extra != 0) {
            end++;
            extra--;
        }

        assert(end <= task_count);

        auto donation_begin_it = m_private_queue.begin() + begin;
        auto donation_end_it = m_private_queue.begin() + end;

        assert(donation_begin_it < m_private_queue.end());
        assert(donation_end_it <= m_private_queue.end());

        m_parent_pool.worker_at(idle_worker_index).enqueue_foreign(donation_begin_it, donation_end_it);

        begin = end;
        end += donation_count;
    }

    assert(m_private_queue.size() == task_count);

    // clear everything we've donated.
    assert(std::all_of(m_private_queue.begin(), m_private_queue.begin() + begin, [](auto& task) {
        return !static_cast<bool>(task);
    }));

    assert(std::all_of(m_private_queue.begin() + begin, m_private_queue.end(), [](auto& task) {