Method schedule_op

src/runtime/OMP/OMPScheduler.cpp:77–122

}

void OMPScheduler::schedule_op(ICPPKernel *kernel, const Hints &hints, const Window &window, ITensorPack &tensors)
{
    // The rest of the logic in this function does not handle the
    // split_dimensions_all case so we defer to IScheduler::schedule_common()
    if (hints.split_dimension() == IScheduler::split_dimensions_all)
    {
        return schedule_common(kernel, hints, window, tensors);
    }

    ARM_COMPUTE_ERROR_ON_MSG(!kernel, "The child class didn't set the kernel");
    ARM_COMPUTE_ERROR_ON_MSG(hints.strategy() == StrategyHint::DYNAMIC,
                             "Dynamic scheduling is not supported in OMPScheduler");

    const Window      &max_window     = window;
    const unsigned int num_iterations = max_window.num_iterations(hints.split_dimension());
    const unsigned int mws            = kernel->get_mws(CPUInfo::get(), _num_threads);

    // Ensure each thread has mws amount of work to do (i.e. ceil(num_iterations / mws) threads)
    const unsigned int candidate_num_threads = (num_iterations + mws - 1) / mws;

    // Cap the number of threads to be spawn with the size of the thread pool
    const unsigned int num_threads = std::min(candidate_num_threads, _num_threads);

    if (!kernel->is_parallelisable() || num_threads == 1)
    {
        ThreadInfo info;
        info.cpu_info = &cpu_info();
        kernel->run_op(tensors, max_window, info);
    }
    else
    {
        const unsigned int                num_windows = num_threads;
        std::vector<IScheduler::Workload> workloads(num_windows);
        for (unsigned int t = 0; t < num_windows; t++)
        {
            //Capture 't' by copy, all the other variables by reference:
            workloads[t] = [t, &hints, &max_window, &num_windows, &kernel, &tensors](const ThreadInfo &info)
            {
                Window win = max_window.split_window(hints.split_dimension(), t, num_windows);
                win.validate();
                kernel->run_op(tensors, win, info);
            };
        }
        run_workloads(workloads);
    }
}
#ifndef DOXYGEN_SKIP_THIS
void OMPScheduler::run_workloads(std::vector<arm_compute::IScheduler::Workload> &workloads)
{