Forwards messages in priority order. More...

#include <flow_graph.h>

Inheritance diagram for tbb::flow::interface10::priority_queue_node< T, Compare, A >:

Collaboration diagram for tbb::flow::interface10::priority_queue_node< T, Compare, A >:

Public Types
typedef T	input_type

typedef T	output_type

typedef buffer_node< T, A >	base_type

typedef priority_queue_node	class_type

typedef receiver< input_type >::predecessor_type	predecessor_type

typedef sender< output_type >::successor_type	successor_type

Public Types inherited from tbb::flow::interface10::buffer_node< T, A >
typedef T	input_type

typedef T	output_type

typedef receiver< input_type >::predecessor_type	predecessor_type

typedef sender< output_type >::successor_type	successor_type

typedef buffer_node< T, A >	class_type

Public Types inherited from tbb::flow::interface10::internal::item_buffer< T, A >
enum	buffer_item_state { no_item =0, has_item =1, reserved_item =2 }

typedef T	item_type

Public Types inherited from tbb::flow::interface10::receiver< T >
typedef T	input_type
	The input type of this receiver. More...

typedef internal::async_helpers< T >::filtered_type	filtered_type

Public Types inherited from tbb::flow::interface10::internal::untyped_receiver
typedef untyped_sender	predecessor_type
	The predecessor type for this node. More...

Public Types inherited from tbb::flow::interface10::sender< T >
typedef T	output_type
	The output type of this sender. More...

typedef internal::async_helpers< T >::filtered_type	filtered_type

Public Types inherited from tbb::flow::interface10::internal::untyped_sender
typedef untyped_receiver	successor_type
	The successor type for this node. More...

Public Member Functions
	priority_queue_node (graph &g)
	Constructor. More...

	priority_queue_node (const priority_queue_node &src)
	Copy constructor. More...

Public Member Functions inherited from tbb::flow::interface10::buffer_node< T, A >
	buffer_node (graph &g)
	Constructor. More...

	buffer_node (const buffer_node &src)
	Copy constructor. More...

bool	register_successor (successor_type &r) __TBB_override
	Adds a new successor. More...

bool	remove_successor (successor_type &r) __TBB_override
	Removes a successor. More...

bool	try_get (T &v) __TBB_override
	Request an item from the buffer_node. More...

bool	try_reserve (T &v) __TBB_override
	Reserves an item. More...

bool	try_release () __TBB_override
	Release a reserved item. More...

bool	try_consume () __TBB_override
	Consumes a reserved item. More...

Public Member Functions inherited from tbb::flow::interface10::graph_node
	graph_node (graph &g)

virtual	~graph_node ()

Public Member Functions inherited from tbb::flow::interface10::internal::reservable_item_buffer< T, A >
	reservable_item_buffer ()

void	reset ()

Public Member Functions inherited from tbb::flow::interface10::internal::item_buffer< T, A >
	item_buffer ()
	Constructor. More...

	~item_buffer ()

void	reset ()

Public Member Functions inherited from tbb::flow::interface10::receiver< T >
bool	try_put (const typename internal::async_helpers< T >::filtered_type &t)
	Put an item to the receiver. More...

bool	try_put (const typename internal::async_helpers< T >::async_type &t)

Public Member Functions inherited from tbb::flow::interface10::internal::untyped_receiver
virtual	~untyped_receiver ()
	Destructor. More...

template<typename X >
bool	try_put (const X &t)
	Put an item to the receiver. More...

virtual bool	register_predecessor (predecessor_type &)
	Add a predecessor to the node. More...

virtual bool	remove_predecessor (predecessor_type &)
	Remove a predecessor from the node. More...

Public Member Functions inherited from tbb::flow::interface10::internal::untyped_sender
virtual	~untyped_sender ()

Protected Types
typedef buffer_node< T, A >::size_type	size_type

typedef buffer_node< T, A >::item_type	item_type

typedef buffer_node< T, A >::buffer_operation	prio_operation

Protected Types inherited from tbb::flow::interface10::buffer_node< T, A >
enum	op_type { reg_succ, rem_succ, req_item, res_item, rel_res, con_res, put_item, try_fwd_task }

typedef size_t	size_type

typedef internal::aggregating_functor< class_type, buffer_operation >	handler_type

Protected Types inherited from tbb::flow::interface10::internal::item_buffer< T, A >
typedef size_t	size_type

typedef aligned_pair< item_type, buffer_item_state >::type	buffer_item_type

typedef A::template rebind< buffer_item_type >::other	allocator_type

Protected Member Functions
void	reset_node (reset_flags f) __TBB_override

void	internal_forward_task (prio_operation *op) __TBB_override
	Tries to forward valid items to successors. More...

void	handle_operations (prio_operation *op_list) __TBB_override

bool	internal_push (prio_operation *op) __TBB_override

void	internal_pop (prio_operation *op) __TBB_override

void	internal_reserve (prio_operation *op) __TBB_override

void	internal_consume (prio_operation *op) __TBB_override

void	internal_release (prio_operation *op) __TBB_override

Protected Member Functions inherited from tbb::flow::interface10::buffer_node< T, A >
template<typename derived_type >
void	handle_operations_impl (buffer_operation op_list, derived_type derived)

task *	grab_forwarding_task (buffer_operation &op_data)

bool	enqueue_forwarding_task (buffer_operation &op_data)

virtual task *	forward_task ()
	This is executed by an enqueued task, the "forwarder". More...

virtual void	internal_reg_succ (buffer_operation *op)
	Register successor. More...

virtual void	internal_rem_succ (buffer_operation *op)
	Remove successor. More...

template<typename derived_type >
void	internal_forward_task_impl (buffer_operation op, derived_type derived)

task *	try_put_task (const T &t) __TBB_override
	receive an item, return a task *if possible More...

graph &	graph_reference () __TBB_override

void	reset_receiver (reset_flags) __TBB_override
	put receiver back in initial state More...

Protected Member Functions inherited from tbb::flow::interface10::internal::reservable_item_buffer< T, A >
bool	reserve_front (T &v)

void	consume_front ()

void	release_front ()

Protected Member Functions inherited from tbb::flow::interface10::internal::item_buffer< T, A >
bool	buffer_empty () const

buffer_item_type &	item (size_type i)

const buffer_item_type &	item (size_type i) const

bool	my_item_valid (size_type i) const

bool	my_item_reserved (size_type i) const

const item_type &	get_my_item (size_t i) const

void	set_my_item (size_t i, const item_type &o)

void	fetch_item (size_t i, item_type &o)

void	move_item (size_t to, size_t from)

bool	place_item (size_t here, const item_type &me)

void	swap_items (size_t i, size_t j)

void	destroy_item (size_type i)

const item_type &	front () const

const item_type &	back () const

void	reserve_item (size_type i)

void	release_item (size_type i)

void	destroy_front ()

void	destroy_back ()

size_type	size (size_t new_tail=0)

size_type	capacity ()

bool	buffer_full ()

void	grow_my_array (size_t minimum_size)
	Grows the internal array. More...

bool	push_back (item_type &v)

bool	pop_back (item_type &v)

bool	pop_front (item_type &v)

void	clean_up_buffer (bool reset_pointers)

Protected Member Functions inherited from tbb::flow::interface10::receiver< T >
virtual task *	try_put_task_wrapper (const void *p, bool is_async) __TBB_override

Protected Member Functions inherited from tbb::flow::interface10::internal::untyped_receiver
template<typename X >
task *	try_put_task (const X &t)

virtual bool	is_continue_receiver ()

Protected Member Functions inherited from tbb::flow::interface10::sender< T >
virtual bool	try_get_wrapper (void *p, bool is_async) __TBB_override

virtual bool	try_reserve_wrapper (void *p, bool is_async) __TBB_override

Protected Member Functions inherited from tbb::flow::interface10::internal::untyped_sender
template<typename X >
bool	try_get (X &t)
	Request an item from the sender. More...

template<typename X >
bool	try_reserve (X &t)
	Reserves an item in the sender. More...

Private Member Functions
void	order ()

bool	is_item_valid ()

void	try_put_and_add_task (task *&last_task)

bool	prio_use_tail ()

void	prio_push (const T &src)

void	prio_pop ()

const T &	prio ()

void	heapify ()

void	reheap ()

Private Attributes
Compare	compare

size_type	mark

input_type	reserved_item

Friends
template<typename , typename >
class	buffer_node

Additional Inherited Members
Protected Attributes inherited from tbb::flow::interface10::buffer_node< T, A >
internal::round_robin_cache< T, null_rw_mutex >	my_successors

bool	forwarder_busy

internal::aggregator< handler_type, buffer_operation >	my_aggregator

Protected Attributes inherited from tbb::flow::interface10::graph_node
graph &	my_graph

graph_node *	next

graph_node *	prev

Protected Attributes inherited from tbb::flow::interface10::internal::reservable_item_buffer< T, A >
bool	my_reserved

Protected Attributes inherited from tbb::flow::interface10::internal::item_buffer< T, A >
buffer_item_type *	my_array

size_type	my_array_size

size_type	my_head

size_type	my_tail

Static Protected Attributes inherited from tbb::flow::interface10::internal::item_buffer< T, A >
static const size_type	initial_buffer_size = 4

Detailed Description

template<typename T, typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>
class tbb::flow::interface10::priority_queue_node< T, Compare, A >

Forwards messages in priority order.

Definition at line 2188 of file flow_graph.h.

Member Typedef Documentation

◆ base_type

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

typedef buffer_node<T,A> tbb::flow::interface10::priority_queue_node< T, Compare, A >::base_type

Definition at line 2192 of file flow_graph.h.

◆ class_type

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

typedef priority_queue_node tbb::flow::interface10::priority_queue_node< T, Compare, A >::class_type

Definition at line 2193 of file flow_graph.h.

◆ input_type

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

typedef T tbb::flow::interface10::priority_queue_node< T, Compare, A >::input_type

Definition at line 2190 of file flow_graph.h.

◆ item_type

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

typedef buffer_node<T, A>::item_type tbb::flow::interface10::priority_queue_node< T, Compare, A >::item_type

protected

Definition at line 2225 of file flow_graph.h.

◆ output_type

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

typedef T tbb::flow::interface10::priority_queue_node< T, Compare, A >::output_type

Definition at line 2191 of file flow_graph.h.

◆ predecessor_type

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

typedef receiver<input_type>::predecessor_type tbb::flow::interface10::priority_queue_node< T, Compare, A >::predecessor_type

Definition at line 2194 of file flow_graph.h.

◆ prio_operation

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

typedef buffer_node<T, A>::buffer_operation tbb::flow::interface10::priority_queue_node< T, Compare, A >::prio_operation

protected

Definition at line 2226 of file flow_graph.h.

◆ size_type

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

typedef buffer_node<T, A>::size_type tbb::flow::interface10::priority_queue_node< T, Compare, A >::size_type

protected

Definition at line 2224 of file flow_graph.h.

◆ successor_type

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

typedef sender<output_type>::successor_type tbb::flow::interface10::priority_queue_node< T, Compare, A >::successor_type

Definition at line 2195 of file flow_graph.h.

Constructor & Destructor Documentation

◆ priority_queue_node() [1/2]

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

tbb::flow::interface10::priority_queue_node< T, Compare, A >::priority_queue_node ( graph & g )

inlineexplicit

Constructor.

Definition at line 2198 of file flow_graph.h.

References tbb::internal::fgt_node().

                                              : buffer_node<T, A>(g), mark(0) {
         tbb::internal::fgt_node( tbb::internal::FLOW_PRIORITY_QUEUE_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }

Here is the call graph for this function:

◆ priority_queue_node() [2/2]

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

tbb::flow::interface10::priority_queue_node< T, Compare, A >::priority_queue_node ( const priority_queue_node< T, Compare, A > & src )

inline

Copy constructor.

Definition at line 2205 of file flow_graph.h.

References __TBB_override, tbb::internal::fgt_node(), and tbb::internal::fgt_node_desc().

                                                           : buffer_node<T, A>(src), mark(0) {
         tbb::internal::fgt_node( tbb::internal::FLOW_PRIORITY_QUEUE_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }

Here is the call graph for this function:

Member Function Documentation

◆ handle_operations()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::handle_operations ( prio_operation * op_list )

inlineprotectedvirtual

Reimplemented from tbb::flow::interface10::buffer_node< T, A >.

Definition at line 2233 of file flow_graph.h.

                                                                    {
         this->handle_operations_impl(op_list, this);
     }

◆ heapify()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::heapify ( )

inlineprivate

Definition at line 2355 of file flow_graph.h.

References parent, and void.

                    {
         if(this->my_tail == 0) {
             mark = 0;
             return;
         }
         if (!mark) mark = 1;
         for (; mark<this->my_tail; ++mark) { // for each unheaped element
             size_type cur_pos = mark;
             input_type to_place;
             this->fetch_item(mark,to_place);
             do { // push to_place up the heap
                 size_type parent = (cur_pos-1)>>1;
                 if (!compare(this->get_my_item(parent), to_place))
                     break;
                 this->move_item(cur_pos, parent);
                 cur_pos = parent;
             } while( cur_pos );
             (void) this->place_item(cur_pos, to_place);
         }
     }

◆ internal_consume()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::internal_consume ( prio_operation * op )

inlineprotectedvirtual

Reimplemented from tbb::flow::interface10::buffer_node< T, A >.

Definition at line 2269 of file flow_graph.h.

References tbb::internal::__TBB_store_with_release(), and tbb::flow::interface10::internal::SUCCEEDED.

                                                              {
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
         this->my_reserved = false;
         reserved_item = input_type();
     }

Here is the call graph for this function:

◆ internal_forward_task()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::internal_forward_task ( prio_operation * op )

inlineprotectedvirtual

Tries to forward valid items to successors.

Reimplemented from tbb::flow::interface10::buffer_node< T, A >.

Definition at line 2229 of file flow_graph.h.

                                                                   {
         this->internal_forward_task_impl(op, this);
     }

◆ internal_pop()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::internal_pop ( prio_operation * op )

inlineprotectedvirtual

Reimplemented from tbb::flow::interface10::buffer_node< T, A >.

Definition at line 2243 of file flow_graph.h.

References tbb::internal::__TBB_store_with_release(), tbb::flow::interface10::internal::FAILED, and tbb::flow::interface10::internal::SUCCEEDED.

                                                          {
         // if empty or already reserved, don't pop
         if ( this->my_reserved == true || this->my_tail == 0 ) {
             __TBB_store_with_release(op->status, internal::FAILED);
             return;
         }
 
         *(op->elem) = prio();
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
         prio_pop();
 
     }

Here is the call graph for this function:

◆ internal_push()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

bool tbb::flow::interface10::priority_queue_node< T, Compare, A >::internal_push ( prio_operation * op )

inlineprotectedvirtual

Reimplemented from tbb::flow::interface10::buffer_node< T, A >.

Definition at line 2237 of file flow_graph.h.

References tbb::internal::__TBB_store_with_release(), and tbb::flow::interface10::internal::SUCCEEDED.

                                                           {
         prio_push(*(op->elem));
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
         return true;
     }

Here is the call graph for this function:

◆ internal_release()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::internal_release ( prio_operation * op )

inlineprotectedvirtual

Reimplemented from tbb::flow::interface10::buffer_node< T, A >.

Definition at line 2275 of file flow_graph.h.

References tbb::internal::__TBB_store_with_release(), and tbb::flow::interface10::internal::SUCCEEDED.

                                                              {
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
         prio_push(reserved_item);
         this->my_reserved = false;
         reserved_item = input_type();
     }

Here is the call graph for this function:

◆ internal_reserve()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::internal_reserve ( prio_operation * op )

inlineprotectedvirtual

Reimplemented from tbb::flow::interface10::buffer_node< T, A >.

Definition at line 2257 of file flow_graph.h.

References tbb::internal::__TBB_store_with_release(), tbb::flow::interface10::internal::FAILED, and tbb::flow::interface10::internal::SUCCEEDED.

                                                              {
         if (this->my_reserved == true || this->my_tail == 0) {
             __TBB_store_with_release(op->status, internal::FAILED);
             return;
         }
         this->my_reserved = true;
         *(op->elem) = prio();
         reserved_item = *(op->elem);
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
         prio_pop();
     }

Here is the call graph for this function:

◆ is_item_valid()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

bool tbb::flow::interface10::priority_queue_node< T, Compare, A >::is_item_valid ( )

inlineprivate

Definition at line 2290 of file flow_graph.h.

                          {
         return this->my_tail > 0;
     }

◆ order()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::order ( )

inlineprivate

Definition at line 2285 of file flow_graph.h.

References __TBB_ASSERT.

                  {
         if (mark < this->my_tail) heapify();
         __TBB_ASSERT(mark == this->my_tail, "mark unequal after heapify");
     }

◆ prio()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

const T& tbb::flow::interface10::priority_queue_node< T, Compare, A >::prio ( )

inlineprivate

Definition at line 2350 of file flow_graph.h.

                     {
         return this->get_my_item(prio_use_tail() ? this->my_tail-1 : 0);
     }

◆ prio_pop()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::prio_pop ( )

inlineprivate

Definition at line 2328 of file flow_graph.h.

References __TBB_ASSERT.

                      {
         if (prio_use_tail()) {
             // there are newly pushed elements; last one higher than top
             // copy the data
             this->destroy_item(this->my_tail-1);
             --(this->my_tail);
             __TBB_ASSERT(mark <= this->my_tail, "mark outside bounds after pop");
             return;
         }
         this->destroy_item(0);
         if(this->my_tail > 1) {
             // push the last element down heap
             __TBB_ASSERT(this->my_item_valid(this->my_tail - 1), NULL);
             this->move_item(0,this->my_tail - 1);
         }
         --(this->my_tail);
         if(mark > this->my_tail) --mark;
         if (this->my_tail > 1) // don't reheap for heap of size 1
             reheap();
         __TBB_ASSERT(mark <= this->my_tail, "mark outside bounds after pop");
     }

◆ prio_push()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::prio_push ( const T & src )

inlineprivate

Definition at line 2317 of file flow_graph.h.

References __TBB_ASSERT, and void.

                                  {
         if ( this->my_tail >= this->my_array_size )
             this->grow_my_array( this->my_tail + 1 );
         (void) this->place_item(this->my_tail, src);
         ++(this->my_tail);
         __TBB_ASSERT(mark < this->my_tail, "mark outside bounds after push");
     }

◆ prio_use_tail()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

bool tbb::flow::interface10::priority_queue_node< T, Compare, A >::prio_use_tail ( )

inlineprivate

Definition at line 2311 of file flow_graph.h.

References __TBB_ASSERT.

                          {
         __TBB_ASSERT(mark <= this->my_tail, "mark outside bounds before test");
         return mark < this->my_tail && compare(this->get_my_item(0), this->get_my_item(this->my_tail - 1));
     }

◆ reheap()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::reheap ( )

inlineprivate

Definition at line 2377 of file flow_graph.h.

                   {
         size_type cur_pos=0, child=1;
         while (child < mark) {
             size_type target = child;
             if (child+1<mark &&
                 compare(this->get_my_item(child),
                         this->get_my_item(child+1)))
                 ++target;
             // target now has the higher priority child
             if (compare(this->get_my_item(target),
                         this->get_my_item(cur_pos)))
                 break;
             // swap
             this->swap_items(cur_pos, target);
             cur_pos = target;
             child = (cur_pos<<1)+1;
         }
     }

◆ reset_node()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::reset_node ( reset_flags f )

inlineprotectedvirtual

Reimplemented from tbb::flow::interface10::buffer_node< T, A >.

Definition at line 2219 of file flow_graph.h.

                                                    {
         mark = 0;
         base_type::reset_node(f);
     }

◆ try_put_and_add_task()

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::priority_queue_node< T, Compare, A >::try_put_and_add_task ( task *& last_task )

inlineprivate

Definition at line 2294 of file flow_graph.h.

References tbb::flow::interface10::combine_tasks(), tbb::flow::interface10::internal::key_matching_port< TraitsType >::graph_reference(), and tbb::flow::interface10::internal::round_robin_cache< T, M >::try_put_task().

                                                 {
         task * new_task = this->my_successors.try_put_task(this->prio());
         if (new_task) {
             // workaround for icc bug
             graph& graph_ref = this->graph_reference();
             last_task = combine_tasks(graph_ref, last_task, new_task);
             prio_pop();
         }
     }

Here is the call graph for this function:

Friends And Related Function Documentation

◆ buffer_node

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

template<typename , typename >

friend class buffer_node

friend

Definition at line 2283 of file flow_graph.h.

Member Data Documentation

◆ compare

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

Compare tbb::flow::interface10::priority_queue_node< T, Compare, A >::compare

private

Definition at line 2305 of file flow_graph.h.

◆ mark

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

size_type tbb::flow::interface10::priority_queue_node< T, Compare, A >::mark

private

Definition at line 2306 of file flow_graph.h.

◆ reserved_item

template<typename T , typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>

input_type tbb::flow::interface10::priority_queue_node< T, Compare, A >::reserved_item

private

Definition at line 2308 of file flow_graph.h.

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

flow_graph.h

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

template<typename T, typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>> class tbb::flow::interface10::priority_queue_node< T, Compare, A >

Member Typedef Documentation

◆ base_type

◆ class_type

◆ input_type

◆ item_type

◆ output_type

◆ predecessor_type

◆ prio_operation

◆ size_type

◆ successor_type

Constructor & Destructor Documentation

◆ priority_queue_node() [1/2]

◆ priority_queue_node() [2/2]

Member Function Documentation

◆ handle_operations()

◆ heapify()

◆ internal_consume()

◆ internal_forward_task()

◆ internal_pop()

◆ internal_push()

◆ internal_release()

◆ internal_reserve()

◆ is_item_valid()

◆ order()

◆ prio()

◆ prio_pop()

◆ prio_push()

◆ prio_use_tail()

◆ reheap()

◆ reset_node()

◆ try_put_and_add_task()

Friends And Related Function Documentation

◆ buffer_node

Member Data Documentation

◆ compare

◆ mark

◆ reserved_item

template<typename T, typename Compare = std::less<T>, typename A = cache_aligned_allocator<T>>
class tbb::flow::interface10::priority_queue_node< T, Compare, A >