UT_ParallelPipeline.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * COMMENTS: Wrapper around tbb::parallel_pipeline
 */

#ifndef __UT_ParallelPipeline__
#define __UT_ParallelPipeline__

#include <tbb/pipeline.h>

namespace UT_ParallelPipeline
{
    /// @brief  A filter (task) that will make up part of the pipeline.
    /// @tparam Receives The type that this filter receives for an upstream
    ///         filter. void if it is the first filter in a pipeline.
    /// @tparam Provides The type that this filter provides to a downstream
    ///         filter. void if it is the last filter in a pipeline.
    template<typename Receives, typename Provides>
    using Filter = tbb::filter_t<Receives, Provides>;

    /// @brief The execution mode of a filter.
    enum Mode
    {
        Parallel         = tbb::filter::mode::parallel,
        SerialInOrder    = tbb::filter::mode::serial_in_order,
        SerialOutOfOrder = tbb::filter::mode::serial_out_of_order,
        Serial           = tbb::filter::mode::serial
    };

    /// @brief The control to signal end-of-input for the pipeline.
    using FlowControl = tbb::flow_control;
};

/// @brief Create a filter (task) that will make up part of the pipeline.
/// @param mode The execution mode of this filter.
/// @param body The function or lambda that should be executed.
template<typename Receives, typename Provides, typename Body>
UT_ParallelPipeline::Filter<Receives, Provides> UTmakeParallelPipelineFilter(
    UT_ParallelPipeline::Mode mode, const Body& body)
{
    return tbb::make_filter<Receives, Provides>(
        static_cast<tbb::filter::mode>(mode), body);
}

/// @brief Run the pipeline
///
/// The pipeline is defined by providing a number of filters to \p filter_chain
/// The pipeline will run with at most \p max_number_of_live_tokens items
/// simultaneously.
///
/// @param max_number_of_live_tokens The maximum number of items to run simultaneously.
/// @param filter_chain The filters that make up the pipeline.
inline void UTrunParallelPipeline(size_t max_number_of_live_tokens,
    const UT_ParallelPipeline::Filter<void,void>& filter_chain)
{
    return tbb::parallel_pipeline(max_number_of_live_tokens, filter_chain);
}

#endif // __UT_ParallelPipeline__