_flow_graph_cache_impl.h
Go to the documentation of this file.
/*
Copyright (c) 2005-2020 Intel Corporation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#ifndef __TBB__flow_graph_cache_impl_H
#define __TBB__flow_graph_cache_impl_H
#ifndef __TBB_flow_graph_H
#error Do not #include this internal file directly; use public TBB headers instead.
#endif
// included in namespace tbb::flow::interfaceX (in flow_graph.h)
namespace internal {
template< typename T, typename M=spin_mutex >
class node_cache {
public:
typedef size_t size_type;
bool empty() {
typename mutex_type::scoped_lock lock( my_mutex );
return internal_empty();
}
void add( T &n ) {
typename mutex_type::scoped_lock lock( my_mutex );
internal_push(n);
}
void remove( T &n ) {
typename mutex_type::scoped_lock lock( my_mutex );
for ( size_t i = internal_size(); i != 0; --i ) {
T &s = internal_pop();
if ( &s == &n ) return; // only remove one predecessor per request
internal_push(s);
}
}
void clear() {
while( !my_q.empty()) (void)my_q.pop();
#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
my_built_predecessors.clear();
#endif
}
#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
typedef edge_container<T> built_predecessors_type;
built_predecessors_type &built_predecessors() { return my_built_predecessors; }
typedef typename edge_container<T>::edge_list_type predecessor_list_type;
void internal_add_built_predecessor( T &n ) {
typename mutex_type::scoped_lock lock( my_mutex );
my_built_predecessors.add_edge(n);
}
void internal_delete_built_predecessor( T &n ) {
typename mutex_type::scoped_lock lock( my_mutex );
my_built_predecessors.delete_edge(n);
}
void copy_predecessors( predecessor_list_type &v) {
typename mutex_type::scoped_lock lock( my_mutex );
my_built_predecessors.copy_edges(v);
}
size_t predecessor_count() {
typename mutex_type::scoped_lock lock(my_mutex);
return (size_t)(my_built_predecessors.edge_count());
}
#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
protected:
typedef M mutex_type;
mutex_type my_mutex;
std::queue< T * > my_q;
#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
built_predecessors_type my_built_predecessors;
#endif
// Assumes lock is held
inline bool internal_empty( ) {
return my_q.empty();
}
// Assumes lock is held
inline size_type internal_size( ) {
return my_q.size();
}
// Assumes lock is held
inline void internal_push( T &n ) {
my_q.push(&n);
}
// Assumes lock is held
inline T &internal_pop() {
T *v = my_q.front();
my_q.pop();
return *v;
}
};
template< typename T, typename M=spin_mutex >
#if __TBB_PREVIEW_ASYNC_MSG
// TODO: make predecessor_cache type T-independent when async_msg becomes regular feature
class predecessor_cache : public node_cache< untyped_sender, M > {
#else
class predecessor_cache : public node_cache< sender<T>, M > {
#endif // __TBB_PREVIEW_ASYNC_MSG
public:
typedef M mutex_type;
typedef T output_type;
#if __TBB_PREVIEW_ASYNC_MSG
typedef untyped_sender predecessor_type;
typedef untyped_receiver successor_type;
#else
typedef sender<output_type> predecessor_type;
typedef receiver<output_type> successor_type;
#endif // __TBB_PREVIEW_ASYNC_MSG
predecessor_cache( ) : my_owner( NULL ) { }
void set_owner( successor_type *owner ) { my_owner = owner; }
bool get_item( output_type &v ) {
bool msg = false;
do {
predecessor_type *src;
{
typename mutex_type::scoped_lock lock(this->my_mutex);
if ( this->internal_empty() ) {
break;
}
src = &this->internal_pop();
}
// Try to get from this sender
msg = src->try_get( v );
if (msg == false) {
// Relinquish ownership of the edge
if (my_owner)
src->register_successor( *my_owner );
} else {
// Retain ownership of the edge
this->add(*src);
}
} while ( msg == false );
return msg;
}
// If we are removing arcs (rf_clear_edges), call clear() rather than reset().
void reset() {
if (my_owner) {
for(;;) {
predecessor_type *src;
{
if (this->internal_empty()) break;
src = &this->internal_pop();
}
src->register_successor( *my_owner );
}
}
}
protected:
#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
using node_cache< predecessor_type, M >::my_built_predecessors;
#endif
successor_type *my_owner;
};
// TODO: make reservable_predecessor_cache type T-independent when async_msg becomes regular feature
template< typename T, typename M=spin_mutex >
class reservable_predecessor_cache : public predecessor_cache< T, M > {
public:
typedef M mutex_type;
typedef T output_type;
#if __TBB_PREVIEW_ASYNC_MSG
typedef untyped_sender predecessor_type;
typedef untyped_receiver successor_type;
#else
typedef sender<T> predecessor_type;
typedef receiver<T> successor_type;
#endif // __TBB_PREVIEW_ASYNC_MSG
reservable_predecessor_cache( ) : reserved_src(NULL) { }
bool
try_reserve( output_type &v ) {
bool msg = false;
do {
{
typename mutex_type::scoped_lock lock(this->my_mutex);
if ( reserved_src || this->internal_empty() )
return false;
reserved_src = &this->internal_pop();
}
// Try to get from this sender
msg = reserved_src->try_reserve( v );
if (msg == false) {
typename mutex_type::scoped_lock lock(this->my_mutex);
// Relinquish ownership of the edge
reserved_src->register_successor( *this->my_owner );
reserved_src = NULL;
} else {
// Retain ownership of the edge
this->add( *reserved_src );
}
} while ( msg == false );
return msg;
}
bool
try_release( ) {
reserved_src->try_release( );
reserved_src = NULL;
return true;
}
bool
try_consume( ) {
reserved_src->try_consume( );
reserved_src = NULL;
return true;
}
void reset( ) {
reserved_src = NULL;
predecessor_cache<T,M>::reset( );
}
void clear() {
reserved_src = NULL;
predecessor_cache<T,M>::clear();
}
private:
predecessor_type *reserved_src;
};
// TODO: make successor_cache type T-independent when async_msg becomes regular feature
template<typename T, typename M=spin_rw_mutex >
class successor_cache : tbb::internal::no_copy {
protected:
typedef M mutex_type;
mutex_type my_mutex;
#if __TBB_PREVIEW_ASYNC_MSG
typedef untyped_receiver successor_type;
typedef untyped_receiver *pointer_type;
typedef untyped_sender owner_type;
#else
typedef receiver<T> successor_type;
typedef receiver<T> *pointer_type;
typedef sender<T> owner_type;
#endif // __TBB_PREVIEW_ASYNC_MSG
typedef std::list< pointer_type > successors_type;
#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
edge_container<successor_type> my_built_successors;
#endif
successors_type my_successors;
owner_type *my_owner;
public:
#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
typedef typename edge_container<successor_type>::edge_list_type successor_list_type;
edge_container<successor_type> &built_successors() { return my_built_successors; }
void internal_add_built_successor( successor_type &r) {
typename mutex_type::scoped_lock l(my_mutex, true);
my_built_successors.add_edge( r );
}
void internal_delete_built_successor( successor_type &r) {
typename mutex_type::scoped_lock l(my_mutex, true);
my_built_successors.delete_edge(r);
}
void copy_successors( successor_list_type &v) {
typename mutex_type::scoped_lock l(my_mutex, false);
my_built_successors.copy_edges(v);
}
size_t successor_count() {
typename mutex_type::scoped_lock l(my_mutex,false);
return my_built_successors.edge_count();
}
#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
successor_cache( ) : my_owner(NULL) {}
void set_owner( owner_type *owner ) { my_owner = owner; }
virtual ~successor_cache() {}
void register_successor( successor_type &r ) {
typename mutex_type::scoped_lock l(my_mutex, true);
my_successors.push_back( &r );
}
void remove_successor( successor_type &r ) {
typename mutex_type::scoped_lock l(my_mutex, true);
for ( typename successors_type::iterator i = my_successors.begin();
i != my_successors.end(); ++i ) {
if ( *i == & r ) {
my_successors.erase(i);
break;
}
}
}
bool empty() {
typename mutex_type::scoped_lock l(my_mutex, false);
return my_successors.empty();
}
void clear() {
my_successors.clear();
#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
my_built_successors.clear();
#endif
}
#if !__TBB_PREVIEW_ASYNC_MSG
virtual task * try_put_task( const T &t ) = 0;
#endif // __TBB_PREVIEW_ASYNC_MSG
}; // successor_cache<T>
template<typename M>
class successor_cache< continue_msg, M > : tbb::internal::no_copy {
protected:
typedef M mutex_type;
mutex_type my_mutex;
#if __TBB_PREVIEW_ASYNC_MSG
typedef untyped_receiver successor_type;
typedef untyped_receiver *pointer_type;
#else
typedef receiver<continue_msg> successor_type;
typedef receiver<continue_msg> *pointer_type;
#endif // __TBB_PREVIEW_ASYNC_MSG
typedef std::list< pointer_type > successors_type;
successors_type my_successors;
#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
edge_container<successor_type> my_built_successors;
typedef edge_container<successor_type>::edge_list_type successor_list_type;
#endif
sender<continue_msg> *my_owner;
public:
#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
edge_container<successor_type> &built_successors() { return my_built_successors; }
void internal_add_built_successor( successor_type &r) {
typename mutex_type::scoped_lock l(my_mutex, true);
my_built_successors.add_edge( r );
}
void internal_delete_built_successor( successor_type &r) {
typename mutex_type::scoped_lock l(my_mutex, true);
my_built_successors.delete_edge(r);
}
void copy_successors( successor_list_type &v) {
typename mutex_type::scoped_lock l(my_mutex, false);
my_built_successors.copy_edges(v);
}
size_t successor_count() {
typename mutex_type::scoped_lock l(my_mutex,false);
return my_built_successors.edge_count();
}
#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
successor_cache( ) : my_owner(NULL) {}
void set_owner( sender<continue_msg> *owner ) { my_owner = owner; }
virtual ~successor_cache() {}
void register_successor( successor_type &r ) {
typename mutex_type::scoped_lock l(my_mutex, true);
my_successors.push_back( &r );
if ( my_owner && r.is_continue_receiver() ) {
r.register_predecessor( *my_owner );
}
}
void remove_successor( successor_type &r ) {
typename mutex_type::scoped_lock l(my_mutex, true);
for ( successors_type::iterator i = my_successors.begin();
i != my_successors.end(); ++i ) {
if ( *i == & r ) {
// TODO: Check if we need to test for continue_receiver before
// removing from r.
if ( my_owner )
r.remove_predecessor( *my_owner );
my_successors.erase(i);
break;
}
}
}
bool empty() {
typename mutex_type::scoped_lock l(my_mutex, false);
return my_successors.empty();
}
void clear() {
my_successors.clear();
#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
my_built_successors.clear();
#endif
}
#if !__TBB_PREVIEW_ASYNC_MSG
virtual task * try_put_task( const continue_msg &t ) = 0;
#endif // __TBB_PREVIEW_ASYNC_MSG
}; // successor_cache< continue_msg >
// TODO: make broadcast_cache type T-independent when async_msg becomes regular feature
template<typename T, typename M=spin_rw_mutex>
class broadcast_cache : public successor_cache<T, M> {
typedef M mutex_type;
typedef typename successor_cache<T,M>::successors_type successors_type;
public:
broadcast_cache( ) {}
// as above, but call try_put_task instead, and return the last task we received (if any)
#if __TBB_PREVIEW_ASYNC_MSG
template<typename X>
task * try_put_task( const X &t ) {
#else
task * try_put_task( const T &t ) __TBB_override {
#endif // __TBB_PREVIEW_ASYNC_MSG
task * last_task = NULL;
bool upgraded = true;
typename mutex_type::scoped_lock l(this->my_mutex, upgraded);
typename successors_type::iterator i = this->my_successors.begin();
while ( i != this->my_successors.end() ) {
task *new_task = (*i)->try_put_task(t);
// workaround for icc bug
graph& graph_ref = (*i)->graph_reference();
last_task = combine_tasks(graph_ref, last_task, new_task); // enqueue if necessary
if(new_task) {
++i;
}
else { // failed
if ( (*i)->register_predecessor(*this->my_owner) ) {
if (!upgraded) {
l.upgrade_to_writer();
upgraded = true;
}
i = this->my_successors.erase(i);
} else {
++i;
}
}
}
return last_task;
}
// call try_put_task and return list of received tasks
#if __TBB_PREVIEW_ASYNC_MSG
template<typename X>
bool gather_successful_try_puts( const X &t, task_list &tasks ) {
#else
bool gather_successful_try_puts( const T &t, task_list &tasks ) {
#endif // __TBB_PREVIEW_ASYNC_MSG
bool upgraded = true;
bool is_at_least_one_put_successful = false;
typename mutex_type::scoped_lock l(this->my_mutex, upgraded);
typename successors_type::iterator i = this->my_successors.begin();
while ( i != this->my_successors.end() ) {
task * new_task = (*i)->try_put_task(t);
if(new_task) {
++i;
if(new_task != SUCCESSFULLY_ENQUEUED) {
tasks.push_back(*new_task);
}
is_at_least_one_put_successful = true;
}
else { // failed
if ( (*i)->register_predecessor(*this->my_owner) ) {
if (!upgraded) {
l.upgrade_to_writer();
upgraded = true;
}
i = this->my_successors.erase(i);
} else {
++i;
}
}
}
return is_at_least_one_put_successful;
}
};
// TODO: make round_robin_cache type T-independent when async_msg becomes regular feature
template<typename T, typename M=spin_rw_mutex >
class round_robin_cache : public successor_cache<T, M> {
typedef size_t size_type;
typedef M mutex_type;
typedef typename successor_cache<T,M>::successors_type successors_type;
public:
round_robin_cache( ) {}
size_type size() {
typename mutex_type::scoped_lock l(this->my_mutex, false);
return this->my_successors.size();
}
#if __TBB_PREVIEW_ASYNC_MSG
template<typename X>
task * try_put_task( const X &t ) {
#else
task *try_put_task( const T &t ) __TBB_override {
#endif // __TBB_PREVIEW_ASYNC_MSG
bool upgraded = true;
typename mutex_type::scoped_lock l(this->my_mutex, upgraded);
typename successors_type::iterator i = this->my_successors.begin();
while ( i != this->my_successors.end() ) {
task *new_task = (*i)->try_put_task(t);
if ( new_task ) {
return new_task;
} else {
if ( (*i)->register_predecessor(*this->my_owner) ) {
if (!upgraded) {
l.upgrade_to_writer();
upgraded = true;
}
i = this->my_successors.erase(i);
}
else {
++i;
}
}
}
return NULL;
}
};
} // namespace internal
#endif // __TBB__flow_graph_cache_impl_H
internal::reservable_predecessor_cache::try_release
bool try_release()
Definition: _flow_graph_cache_impl.h:242
internal::node_cache::add
void add(T &n)
Definition: _flow_graph_cache_impl.h:40
internal::node_cache::mutex_type
M mutex_type
Definition: _flow_graph_cache_impl.h:89
internal::reservable_predecessor_cache::predecessor_type
sender< T > predecessor_type
Definition: _flow_graph_cache_impl.h:205
internal::successor_cache< continue_msg, M >::empty
bool empty()
Definition: _flow_graph_cache_impl.h:444
internal::successor_cache< continue_msg, M >::successor_type
receiver< continue_msg > successor_type
Definition: _flow_graph_cache_impl.h:375
internal::successor_cache< continue_msg, M >::my_owner
sender< continue_msg > * my_owner
Definition: _flow_graph_cache_impl.h:385
internal::successor_cache::mutex_type
M mutex_type
Definition: _flow_graph_cache_impl.h:276
internal
Definition: _flow_graph_async_msg_impl.h:24
internal::broadcast_cache::successors_type
successor_cache< T, M >::successors_type successors_type
Definition: _flow_graph_cache_impl.h:467
internal::successor_cache::my_mutex
mutex_type my_mutex
Definition: _flow_graph_cache_impl.h:277
internal::successor_cache::set_owner
void set_owner(owner_type *owner)
Definition: _flow_graph_cache_impl.h:326
internal::successor_cache::remove_successor
void remove_successor(successor_type &r)
Definition: _flow_graph_cache_impl.h:335
internal::successor_cache::owner_type
sender< T > owner_type
Definition: _flow_graph_cache_impl.h:286
tbb::internal::no_copy
Base class for types that should not be copied or assigned.
Definition: tbb_stddef.h:330
internal::reservable_predecessor_cache::mutex_type
M mutex_type
Definition: _flow_graph_cache_impl.h:199
internal::broadcast_cache::broadcast_cache
broadcast_cache()
Definition: _flow_graph_cache_impl.h:471
internal::successor_cache::successors_type
std::list< pointer_type > successors_type
Definition: _flow_graph_cache_impl.h:288
internal::successor_cache::register_successor
void register_successor(successor_type &r)
Definition: _flow_graph_cache_impl.h:330
internal::reservable_predecessor_cache::successor_type
receiver< T > successor_type
Definition: _flow_graph_cache_impl.h:206
internal::broadcast_cache
A cache of successors that are broadcast to.
Definition: _flow_graph_cache_impl.h:465
internal::node_cache::my_q
std::queue< T * > my_q
Definition: _flow_graph_cache_impl.h:91
internal::predecessor_cache
A cache of predecessors that only supports try_get.
Definition: _flow_graph_cache_impl.h:126
tbb::flow::interface11::combine_tasks
static tbb::task * combine_tasks(graph &g, tbb::task *left, tbb::task *right)
Definition: flow_graph.h:191
internal::node_cache::internal_size
size_type internal_size()
Definition: _flow_graph_cache_impl.h:102
internal::successor_cache< continue_msg, M >::successor_cache
successor_cache()
Definition: _flow_graph_cache_impl.h:415
internal::reservable_predecessor_cache::clear
void clear()
Definition: _flow_graph_cache_impl.h:260
internal::successor_cache::~successor_cache
virtual ~successor_cache()
Definition: _flow_graph_cache_impl.h:328
internal::node_cache::internal_empty
bool internal_empty()
Definition: _flow_graph_cache_impl.h:97
internal::node_cache::internal_pop
T & internal_pop()
Definition: _flow_graph_cache_impl.h:112
internal::successor_cache::successor_type
receiver< T > successor_type
Definition: _flow_graph_cache_impl.h:284
internal::successor_cache< continue_msg, M >::pointer_type
receiver< continue_msg > * pointer_type
Definition: _flow_graph_cache_impl.h:376
internal::reservable_predecessor_cache::reservable_predecessor_cache
reservable_predecessor_cache()
Definition: _flow_graph_cache_impl.h:209
tbb::flow::internal::SUCCESSFULLY_ENQUEUED
static tbb::task *const SUCCESSFULLY_ENQUEUED
Definition: _flow_graph_impl.h:61
internal::node_cache::my_mutex
mutex_type my_mutex
Definition: _flow_graph_cache_impl.h:90
internal::broadcast_cache::gather_successful_try_puts
bool gather_successful_try_puts(const T &t, task_list &tasks)
Definition: _flow_graph_cache_impl.h:512
internal::successor_cache::successor_cache
successor_cache()
Definition: _flow_graph_cache_impl.h:324
internal::round_robin_cache::successors_type
successor_cache< T, M >::successors_type successors_type
Definition: _flow_graph_cache_impl.h:549
internal::successor_cache< continue_msg, M >::set_owner
void set_owner(sender< continue_msg > *owner)
Definition: _flow_graph_cache_impl.h:417
internal::predecessor_cache::predecessor_cache
predecessor_cache()
Definition: _flow_graph_cache_impl.h:139
internal::round_robin_cache::size
size_type size()
Definition: _flow_graph_cache_impl.h:555
internal::round_robin_cache::mutex_type
M mutex_type
Definition: _flow_graph_cache_impl.h:548
internal::successor_cache< continue_msg, M >::successors_type
std::list< pointer_type > successors_type
Definition: _flow_graph_cache_impl.h:378
internal::round_robin_cache::round_robin_cache
round_robin_cache()
Definition: _flow_graph_cache_impl.h:553
internal::successor_cache< continue_msg, M >::mutex_type
M mutex_type
Definition: _flow_graph_cache_impl.h:368
internal::node_cache::clear
void clear()
Definition: _flow_graph_cache_impl.h:54
internal::reservable_predecessor_cache::reset
void reset()
Definition: _flow_graph_cache_impl.h:255
internal::node_cache
A node_cache maintains a std::queue of elements of type T. Each operation is protected by a lock.
Definition: _flow_graph_cache_impl.h:30
internal::successor_cache< output_type, null_rw_mutex >::pointer_type
receiver< output_type > * pointer_type
Definition: _flow_graph_cache_impl.h:285
internal::predecessor_cache::get_item
bool get_item(output_type &v)
Definition: _flow_graph_cache_impl.h:143
internal::reservable_predecessor_cache::reserved_src
predecessor_type * reserved_src
Definition: _flow_graph_cache_impl.h:266
lock
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void * lock
Definition: ittnotify_static.h:121
internal::predecessor_cache::reset
void reset()
Definition: _flow_graph_cache_impl.h:173
internal::node_cache::empty
bool empty()
Definition: _flow_graph_cache_impl.h:35
internal::successor_cache< continue_msg, M >::remove_successor
void remove_successor(successor_type &r)
Definition: _flow_graph_cache_impl.h:429
internal::reservable_predecessor_cache
An cache of predecessors that supports requests and reservations.
Definition: _flow_graph_cache_impl.h:197
internal::predecessor_cache::mutex_type
M mutex_type
Definition: _flow_graph_cache_impl.h:129
internal::node_cache::size_type
size_t size_type
Definition: _flow_graph_cache_impl.h:33
internal::successor_cache< continue_msg, M >::register_successor
void register_successor(successor_type &r)
Definition: _flow_graph_cache_impl.h:421
__TBB_override
#define __TBB_override
Definition: tbb_stddef.h:240
internal::successor_cache< continue_msg, M >::my_successors
successors_type my_successors
Definition: _flow_graph_cache_impl.h:379
internal::broadcast_cache::try_put_task
task * try_put_task(const T &t) __TBB_override
Definition: _flow_graph_cache_impl.h:478
internal::successor_cache::my_owner
owner_type * my_owner
Definition: _flow_graph_cache_impl.h:294
s
void const char const char int ITT_FORMAT __itt_group_sync s
Definition: ittnotify_static.h:91
internal::successor_cache< continue_msg, M >::~successor_cache
virtual ~successor_cache()
Definition: _flow_graph_cache_impl.h:419
internal::round_robin_cache::size_type
size_t size_type
Definition: _flow_graph_cache_impl.h:547
internal::predecessor_cache::output_type
T output_type
Definition: _flow_graph_cache_impl.h:130
task
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task * task
Definition: ittnotify_static.h:119
internal::predecessor_cache::set_owner
void set_owner(successor_type *owner)
Definition: _flow_graph_cache_impl.h:141
internal::successor_cache::clear
void clear()
Definition: _flow_graph_cache_impl.h:351
internal::broadcast_cache::mutex_type
M mutex_type
Definition: _flow_graph_cache_impl.h:466
internal::predecessor_cache::my_owner
successor_type * my_owner
Definition: _flow_graph_cache_impl.h:191
internal::reservable_predecessor_cache::output_type
T output_type
Definition: _flow_graph_cache_impl.h:200
internal::reservable_predecessor_cache::try_reserve
bool try_reserve(output_type &v)
Definition: _flow_graph_cache_impl.h:212
internal::successor_cache< continue_msg, M >::clear
void clear()
Definition: _flow_graph_cache_impl.h:449
internal::successor_cache::empty
bool empty()
Definition: _flow_graph_cache_impl.h:346
internal::round_robin_cache
A cache of successors that are put in a round-robin fashion.
Definition: _flow_graph_cache_impl.h:546
internal::predecessor_cache::successor_type
receiver< output_type > successor_type
Definition: _flow_graph_cache_impl.h:136
internal::node_cache::remove
void remove(T &n)
Definition: _flow_graph_cache_impl.h:45
internal::round_robin_cache::try_put_task
task * try_put_task(const T &t) __TBB_override
Definition: _flow_graph_cache_impl.h:564
internal::successor_cache
An abstract cache of successors.
Definition: _flow_graph_cache_impl.h:273
internal::node_cache::internal_push
void internal_push(T &n)
Definition: _flow_graph_cache_impl.h:107
internal::reservable_predecessor_cache::try_consume
bool try_consume()
Definition: _flow_graph_cache_impl.h:249
internal::predecessor_cache::predecessor_type
sender< output_type > predecessor_type
Definition: _flow_graph_cache_impl.h:135
internal::successor_cache< continue_msg, M >::my_mutex
mutex_type my_mutex
Definition: _flow_graph_cache_impl.h:369
internal::successor_cache::my_successors
successors_type my_successors
Definition: _flow_graph_cache_impl.h:292

Copyright © 2005-2020 Intel Corporation. All Rights Reserved.

Intel, Pentium, Intel Xeon, Itanium, Intel XScale and VTune are registered trademarks or trademarks of Intel Corporation or its subsidiaries in the United States and other countries.

* Other names and brands may be claimed as the property of others.