Method universalTaskScheduler

quantum/util/impl/quantum_sequencer_impl.h:453–494

template <class SequenceKey, class Hash, class KeyEqual, class Allocator>
template <class FUNC, class ... ARGS>
int
Sequencer<SequenceKey, Hash, KeyEqual, Allocator>::universalTaskScheduler(
    VoidContextPtr ctx,
    void* opaque,
    int queueId,
    bool isHighPriority,
    Sequencer& sequencer,
    FUNC&& func,
    ARGS&&... args)
{
    // construct the dependent collection
    std::vector<SequenceKeyData> dependents;
    dependents.reserve(sequencer._contexts.size());
    for (auto ctxIt = sequencer._contexts.begin(); ctxIt != sequencer._contexts.end(); ++ctxIt)
    {
        // check if the context still has a pending task
        if (isPendingContext(ctx, ctxIt->second._context))
        {
            // we will need to wait on this context to finish its current running task
            dependents.emplace_back(ctxIt->second);
        }
    }
    // update the universal stats only
    sequencer._universalContext._stats->incrementPostedTaskCount();
    sequencer._universalContext._stats->incrementPendingTaskCount();
    // update task stats
    sequencer._taskStats->incrementPostedTaskCount();
    sequencer._taskStats->incrementPendingTaskCount();

    // post the task and save the context as the last for the universal sequenceKey
    sequencer._universalContext._context = ctx->post(
            std::move(queueId),
            std::move(isHighPriority),
            waitForUniversalDependent<FUNC, ARGS...>,
            std::move(opaque),
            sequencer,
            std::move(dependents),
            SequenceKeyData(sequencer._universalContext),
            std::forward<FUNC>(func),
            std::forward<ARGS>(args)...);
    return 0;
}

template <class SequenceKey, class Hash, class KeyEqual, class Allocator>
template <class FUNC, class ... ARGS>