tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType > Class Template Reference

Input and scheduling for a function node that takes a type Input as input. More...

#include <flow_graph.h>

Inheritance diagram for tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >:

Collaboration diagram for tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >:

Classes
class	operation_type

Public Types
typedef Input	input_type
	The input type of this receiver. More...
typedef receiver< input_type >::predecessor_type	predecessor_type
typedef predecessor_cache< input_type, null_mutex >	predecessor_cache_type
typedef function_input_queue< input_type, A >	input_queue_type
typedef tbb::internal::allocator_rebind< A, input_queue_type >::type	queue_allocator_type
Public Types inherited from tbb::flow::interface11::internal::untyped_receiver
typedef untyped_sender	predecessor_type
	The predecessor type for this node. More...

Public Member Functions
	__TBB_STATIC_ASSERT (!((internal::has_policy< queueing, Policy >::value) &&(internal::has_policy< rejecting, Policy >::value)), "queueing and rejecting policies can't be specified simultaneously")
	function_input_base (graph &g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(size_t max_concurrency, node_priority_t priority))
	Constructor for function_input_base. More...
	function_input_base (const function_input_base &src)
	Copy constructor. More...
virtual	~function_input_base ()
	Destructor. More...
task *	try_put_task (const input_type &t) __TBB_override
	Put item to successor; return task to run the successor if possible. More...
bool	register_predecessor (predecessor_type &src) __TBB_override
	Adds src to the list of cached predecessors. More...
bool	remove_predecessor (predecessor_type &src) __TBB_override
	Removes src from the list of cached predecessors. More...
Public Member Functions inherited from tbb::flow::interface11::receiver< Input >
bool	try_put (const typename internal::async_helpers< Input >::filtered_type &t)
	Put an item to the receiver. More...
bool	try_put (const typename internal::async_helpers< Input >::async_type &t)
Public Member Functions inherited from tbb::flow::interface11::internal::untyped_receiver
virtual	~untyped_receiver ()
	Destructor. More...
template<typename X >
bool	try_put (const X &t)
	Put an item to the receiver. More...

Protected Member Functions
void	reset_function_input_base (reset_flags f)
void	reset_receiver (reset_flags f) __TBB_override
	put receiver back in initial state More...
graph &	graph_reference () const __TBB_override
task *	try_get_postponed_task (const input_type &i)
Protected Member Functions inherited from tbb::flow::interface11::receiver< Input >
virtual task *	try_put_task_wrapper (const void *p, bool is_async) __TBB_override
Protected Member Functions inherited from tbb::flow::interface11::internal::untyped_receiver
template<typename X >
task *	try_put_task (const X &t)
virtual bool	is_continue_receiver ()

Protected Attributes
graph &	my_graph_ref
const size_t	my_max_concurrency
size_t	my_concurrency
input_queue_type *	my_queue
predecessor_cache< input_type, null_mutex >	my_predecessors

Private Types
enum	op_type {   reg_pred, rem_pred, try_fwd, tryput_bypass,   app_body_bypass, occupy_concurrency }
typedef function_input_base< Input, Policy, A, ImplType >	class_type
typedef internal::aggregating_functor< class_type, operation_type >	handler_type

Private Member Functions
task *	perform_queued_requests ()
void	handle_operations (operation_type *op_list)
void	internal_try_put_task (operation_type *op)
	Put to the node, but return the task instead of enqueueing it. More...
void	internal_forward (operation_type *op)
	Creates tasks for postponed messages if available and if concurrency allows. More...
task *	internal_try_put_bypass (const input_type &t)
task *	try_put_task_impl (const input_type &t, tbb::internal::true_type)
task *	try_put_task_impl (const input_type &t, tbb::internal::false_type)
task *	apply_body_bypass (const input_type &i)
	Applies the body to the provided input. More...
task *	create_body_task (const input_type &input)
	allocates a task to apply a body More...
task *	forward_task ()
	This is executed by an enqueued task, the "forwarder". More...
task *	create_forward_task ()
void	spawn_forward_task ()
	Spawns a task that calls forward() More...
Private Member Functions inherited from tbb::internal::no_assign
void	operator= (const no_assign &)=delete
	no_assign (const no_assign &)=default
	no_assign ()=default

Private Attributes
bool	forwarder_busy
aggregator< handler_type, operation_type >	my_aggregator

Friends
class	apply_body_task_bypass< class_type, input_type >
class	forward_task_bypass< class_type >
class	internal::aggregating_functor< class_type, operation_type >

Additional Inherited Members
Public Attributes inherited from tbb::flow::interface11::receiver< Input >
__TBB_DEPRECATED typedef Input	input_type
	The input type of this receiver. More...
__TBB_DEPRECATED typedef internal::async_helpers< Input >::filtered_type	filtered_type

Detailed Description

template<typename Input, typename Policy, typename A, typename ImplType>
class tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >

Input and scheduling for a function node that takes a type Input as input.

Definition at line 61 of file flow_graph.h.

Member Typedef Documentation

class_type

template<typename Input, typename Policy, typename A, typename ImplType>

typedef function_input_base<Input, Policy, A, ImplType> tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::class_type

private

Definition at line 68 of file flow_graph.h.

handler_type

template<typename Input, typename Policy, typename A, typename ImplType>

typedef internal::aggregating_functor<class_type, operation_type> tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::handler_type

private

Definition at line 227 of file flow_graph.h.

input_queue_type

template<typename Input, typename Policy, typename A, typename ImplType>

typedef function_input_queue<input_type, A> tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::input_queue_type

Definition at line 76 of file flow_graph.h.

input_type

template<typename Input, typename Policy, typename A, typename ImplType>

typedef Input tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::input_type

The input type of this receiver.

Definition at line 73 of file flow_graph.h.

predecessor_cache_type

template<typename Input, typename Policy, typename A, typename ImplType>

typedef predecessor_cache<input_type, null_mutex > tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::predecessor_cache_type

Definition at line 75 of file flow_graph.h.

predecessor_type

template<typename Input, typename Policy, typename A, typename ImplType>

typedef receiver<input_type>::predecessor_type tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::predecessor_type

Definition at line 74 of file flow_graph.h.

queue_allocator_type

template<typename Input, typename Policy, typename A, typename ImplType>

typedef tbb::internal::allocator_rebind<A, input_queue_type>::type tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::queue_allocator_type

Definition at line 77 of file flow_graph.h.

Member Enumeration Documentation

op_type

template<typename Input, typename Policy, typename A, typename ImplType>

enum tbb::flow::interface11::internal::function_input_base::op_type

private

Enumerator
reg_pred
rem_pred
try_fwd
tryput_bypass
app_body_bypass
occupy_concurrency

Definition at line 62 of file flow_graph.h.

              {

Constructor & Destructor Documentation

function_input_base() [1/2]

template<typename Input, typename Policy, typename A, typename ImplType>

tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::function_input_base ( graph &  g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(size_t max_concurrency, node_priority_t priority)    )

inline

Constructor for function_input_base.

Definition at line 87 of file flow_graph.h.

              {

function_input_base() [2/2]

template<typename Input, typename Policy, typename A, typename ImplType>

tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::function_input_base ( const function_input_base< Input, Policy, A, ImplType > &  src )

inline

Copy constructor.

Definition at line 99 of file flow_graph.h.

              {
namespace flow {

enum concurrency { unlimited = 0, serial = 1 };

namespace interface11 {

~function_input_base()

template<typename Input, typename Policy, typename A, typename ImplType>

virtual tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::~function_input_base ( )

inlinevirtual

Destructor.

Definition at line 113 of file flow_graph.h.

                   {};

Member Function Documentation

__TBB_STATIC_ASSERT()

template<typename Input, typename Policy, typename A, typename ImplType>

tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::__TBB_STATIC_ASSERT	(	!	(internal::has_policy< queueing, Policy >::value) &&(internal::has_policy< rejecting, Policy >::value),
		"queueing and rejecting policies can't be specified simultaneously"
	)

apply_body_bypass()

template<typename Input, typename Policy, typename A, typename ImplType>

task* tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::apply_body_bypass ( const input_type &  i )

inlineprivate

Applies the body to the provided input.

Definition at line 373 of file flow_graph.h.

                             {

create_body_task()

template<typename Input, typename Policy, typename A, typename ImplType>

task* tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::create_body_task ( const input_type &  input )

inlineprivate

allocates a task to apply a body

Definition at line 378 of file flow_graph.h.

                                                            { return false; }

create_forward_task()

template<typename Input, typename Policy, typename A, typename ImplType>

task* tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::create_forward_task ( )

inlineprivate

Definition at line 402 of file flow_graph.h.

         :
    template<typename X>
    task *try_put_task(const X& t) {
        return try_put_task_wrapper( internal::async_helpers<X>::to_void_ptr(t), internal::async_helpers<X>::is_async_type );
    }

forward_task()

template<typename Input, typename Policy, typename A, typename ImplType>

task* tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::forward_task ( )

inlineprivate

This is executed by an enqueued task, the "forwarder".

Definition at line 387 of file flow_graph.h.

                                                            { return false; }

    virtual bool remove_predecessor( predecessor_type & ) { return false; }

#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
    typedef internal::edge_container<predecessor_type> built_predecessors_type;
    typedef built_predecessors_type::edge_list_type predecessor_list_type;
    virtual built_predecessors_type &built_predecessors()                  = 0;
    virtual void   internal_add_built_predecessor( predecessor_type & )    = 0;
    virtual void   internal_delete_built_predecessor( predecessor_type & ) = 0;
    virtual void   copy_predecessors( predecessor_list_type & )            = 0;
    virtual size_t predecessor_count()                                     = 0;

graph_reference()

template<typename Input, typename Policy, typename A, typename ImplType>

graph& tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::graph_reference ( ) const

inlineprotectedvirtual

Implements tbb::flow::interface11::internal::untyped_receiver.

Definition at line 194 of file flow_graph.h.

               {
namespace interface11 {

handle_operations()

template<typename Input, typename Policy, typename A, typename ImplType>

void tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::handle_operations ( operation_type *  op_list )

inlineprivate

Definition at line 250 of file flow_graph.h.

             {
            // Incoming 't' is NOT async
            return this_recv->try_put_task(from_void_ptr(p));
        }
    }
};

template< typename T >
struct async_helpers< T, typename std::enable_if< std::is_base_of<async_msg<typename T::async_msg_data_type>, T>::value >::type > {
    typedef T async_type;
    typedef typename T::async_msg_data_type filtered_type;

    static const bool is_async_type = true;

    // Receiver-classes use const interfaces
    static const void* to_void_ptr(const T& t) {
        return static_cast<const void*>(&static_cast<const async_msg<filtered_type>&>(t));
    }

    static void* to_void_ptr(T& t) {
        return static_cast<void*>(&static_cast<async_msg<filtered_type>&>(t));
    }

    // Sender-classes use non-const interfaces
    static const T& from_void_ptr(const void* p) {
        return *static_cast<const T*>(static_cast<const async_msg<filtered_type>*>(p));
    }

    static T& from_void_ptr(void* p) {
        return *static_cast<T*>(static_cast<async_msg<filtered_type>*>(p));
    }

    // Used in receiver<T> class
    static task* try_put_task_wrapper_impl(receiver<T>* const this_recv, const void *p, bool is_async) {
        if (is_async) {
            // Both are async
            return this_recv->try_put_task(from_void_ptr(p));
        }
        else {
            // This (T) is async and incoming 'X t' is NOT async
            // Create async_msg for X
            const filtered_type& t = async_helpers<filtered_type>::from_void_ptr(p);
            const T msg(t);
            return this_recv->try_put_task(msg);
        }
    }
};

class untyped_receiver;

class untyped_sender {
    template< typename, typename > friend class internal::predecessor_cache;
    template< typename, typename > friend class internal::reservable_predecessor_cache;
public:

internal_forward()

template<typename Input, typename Policy, typename A, typename ImplType>

void tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::internal_forward ( operation_type *  op )

inlineprivate

Creates tasks for postponed messages if available and if concurrency allows.

Definition at line 329 of file flow_graph.h.

         :

internal_try_put_bypass()

template<typename Input, typename Policy, typename A, typename ImplType>

task* tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::internal_try_put_bypass ( const input_type &  t )

inlineprivate

Definition at line 341 of file flow_graph.h.

                         {
        return try_get_wrapper( internal::async_helpers<X>::to_void_ptr(t), internal::async_helpers<X>::is_async_type );
    }

    template< typename X >

internal_try_put_task()

template<typename Input, typename Policy, typename A, typename ImplType>

void tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::internal_try_put_task ( operation_type *  op )

inlineprivate

Put to the node, but return the task instead of enqueueing it.

Definition at line 312 of file flow_graph.h.

                              {}

    // NOTE: Following part of PUBLIC section is copy-paste from original sender<T> class

    // TODO: Prevent untyped successor registration

    virtual bool register_successor( successor_type &r ) = 0;

    virtual bool remove_successor( successor_type &r ) = 0;

    virtual bool try_release( ) { return false; }

perform_queued_requests()

template<typename Input, typename Policy, typename A, typename ImplType>

task* tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::perform_queued_requests ( )

inlineprivate

Definition at line 231 of file flow_graph.h.

                                   {
        return static_cast<void*>(&t);
    }

    static const T& from_void_ptr(const void* p) {
        return *static_cast<const T*>(p);
    }

    static T& from_void_ptr(void* p) {
        return *static_cast<T*>(p);
    }

    static task* try_put_task_wrapper_impl(receiver<T>* const this_recv, const void *p, bool is_async) {
        if (is_async) {
            // This (T) is NOT async and incoming 'A<X> t' IS async
            // Get data from async_msg
            const async_msg<filtered_type>& msg = async_helpers< async_msg<filtered_type> >::from_void_ptr(p);
            task* const new_task = msg.my_storage->subscribe(*this_recv, this_recv->graph_reference());

register_predecessor()

template<typename Input, typename Policy, typename A, typename ImplType>

bool tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::register_predecessor ( predecessor_type &  src )

inlinevirtual

Adds src to the list of cached predecessors.

Reimplemented from tbb::flow::interface11::internal::untyped_receiver.

Definition at line 122 of file flow_graph.h.

                   {

template<typename T, typename M> class successor_cache;
template<typename T, typename M> class broadcast_cache;

remove_predecessor()

template<typename Input, typename Policy, typename A, typename ImplType>

bool tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::remove_predecessor ( predecessor_type &  src )

inlinevirtual

Removes src from the list of cached predecessors.

Reimplemented from tbb::flow::interface11::internal::untyped_receiver.

Definition at line 130 of file flow_graph.h.

                {
struct following;
struct preceding;

reset_function_input_base()

template<typename Input, typename Policy, typename A, typename ImplType>

void tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::reset_function_input_base ( reset_flags  f )

inlineprotected

Definition at line 171 of file flow_graph.h.

       :
    edge_list_type built_edges;

reset_receiver()

template<typename Input, typename Policy, typename A, typename ImplType>

void tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::reset_receiver ( reset_flags  f )

inlineprotectedvirtual

put receiver back in initial state

Implements tbb::flow::interface11::internal::untyped_receiver.

Definition at line 187 of file flow_graph.h.

              {

spawn_forward_task()

template<typename Input, typename Policy, typename A, typename ImplType>

void tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::spawn_forward_task ( )

inlineprivate

Spawns a task that calls forward()

Definition at line 410 of file flow_graph.h.

                                        { return false; }

try_get_postponed_task()

template<typename Input, typename Policy, typename A, typename ImplType>

task* tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::try_get_postponed_task ( const input_type &  i )

inlineprotected

Definition at line 198 of file flow_graph.h.

                                                                                {
    // if no RHS task, don't change left.
    if (right == NULL) return left;
    // right != NULL
    if (left == NULL) return right;

try_put_task()

template<typename Input, typename Policy, typename A, typename ImplType>

task* tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::try_put_task ( const input_type &  t )

inlinevirtual

Put item to successor; return task to run the successor if possible.

Implements tbb::flow::interface11::receiver< Input >.

Definition at line 117 of file flow_graph.h.

                   {

try_put_task_impl() [1/2]

template<typename Input, typename Policy, typename A, typename ImplType>

task* tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::try_put_task_impl ( const input_type &  t, tbb::internal::true_type    )

inlineprivate

Definition at line 350 of file flow_graph.h.

                        {
    template< typename, typename > friend class run_and_put_task;

    template< typename, typename > friend class internal::broadcast_cache;
    template< typename, typename > friend class internal::round_robin_cache;

try_put_task_impl() [2/2]

template<typename Input, typename Policy, typename A, typename ImplType>

task* tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::try_put_task_impl ( const input_type &  t, tbb::internal::false_type    )

inlineprivate

Definition at line 363 of file flow_graph.h.

      :
    typedef untyped_sender predecessor_type;

Friends And Related Function Documentation

apply_body_task_bypass< class_type, input_type >

template<typename Input, typename Policy, typename A, typename ImplType>

friend class apply_body_task_bypass< class_type, input_type >

friend

Definition at line 206 of file flow_graph.h.

forward_task_bypass< class_type >

template<typename Input, typename Policy, typename A, typename ImplType>

friend class forward_task_bypass< class_type >

friend

Definition at line 207 of file flow_graph.h.

internal::aggregating_functor< class_type, operation_type >

template<typename Input, typename Policy, typename A, typename ImplType>

friend class internal::aggregating_functor< class_type, operation_type >

friend

Definition at line 228 of file flow_graph.h.

Member Data Documentation

forwarder_busy

template<typename Input, typename Policy, typename A, typename ImplType>

bool tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::forwarder_busy

private

Definition at line 226 of file flow_graph.h.

my_aggregator

template<typename Input, typename Policy, typename A, typename ImplType>

aggregator< handler_type, operation_type > tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::my_aggregator

private

Definition at line 229 of file flow_graph.h.

my_concurrency

template<typename Input, typename Policy, typename A, typename ImplType>

size_t tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::my_concurrency

protected

Definition at line 182 of file flow_graph.h.

my_graph_ref

template<typename Input, typename Policy, typename A, typename ImplType>

graph& tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::my_graph_ref

protected

Definition at line 180 of file flow_graph.h.

my_max_concurrency

template<typename Input, typename Policy, typename A, typename ImplType>

const size_t tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::my_max_concurrency

protected

Definition at line 181 of file flow_graph.h.

my_predecessors

template<typename Input, typename Policy, typename A, typename ImplType>

predecessor_cache<input_type, null_mutex > tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::my_predecessors

protected

Definition at line 185 of file flow_graph.h.

my_queue

template<typename Input, typename Policy, typename A, typename ImplType>

input_queue_type* tbb::flow::interface11::internal::function_input_base< Input, Policy, A, ImplType >::my_queue

protected

Definition at line 184 of file flow_graph.h.

---

The documentation for this class was generated from the following file:

• flow_graph.h