_flow_graph_streaming_node.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_streaming_H
#define __TBB_flow_graph_streaming_H
#ifndef __TBB_flow_graph_H
#error Do not #include this internal file directly; use public TBB headers instead.
#endif
#if __TBB_PREVIEW_STREAMING_NODE
// Included in namespace tbb::flow::interfaceX (in flow_graph.h)
namespace internal {
template <int N1, int N2>
struct port_ref_impl {
// "+1" since the port_ref range is a closed interval (includes its endpoints).
static const int size = N2 - N1 + 1;
};
} // internal
// The purpose of the port_ref_impl is the pretty syntax: the deduction of a compile-time constant is processed from the return type.
// So it is possible to use this helper without parentheses, e.g. "port_ref<0>".
template <int N1, int N2 = N1>
__TBB_DEPRECATED internal::port_ref_impl<N1,N2> port_ref() {
return internal::port_ref_impl<N1,N2>();
};
namespace internal {
template <typename T>
struct num_arguments {
static const int value = 1;
};
template <int N1, int N2>
struct num_arguments<port_ref_impl<N1,N2>(*)()> {
static const int value = port_ref_impl<N1,N2>::size;
};
template <int N1, int N2>
struct num_arguments<port_ref_impl<N1,N2>> {
static const int value = port_ref_impl<N1,N2>::size;
};
template <typename... Args>
void ignore_return_values( Args&&... ) {}
template <typename T>
T or_return_values( T&& t ) { return t; }
template <typename T, typename... Rest>
T or_return_values( T&& t, Rest&&... rest ) {
return t | or_return_values( std::forward<Rest>(rest)... );
}
template<typename JP>
struct key_from_policy {
typedef size_t type;
typedef std::false_type is_key_matching;
};
template<typename Key>
struct key_from_policy< key_matching<Key> > {
typedef Key type;
typedef std::true_type is_key_matching;
};
template<typename Key>
struct key_from_policy< key_matching<Key&> > {
typedef const Key &type;
typedef std::true_type is_key_matching;
};
template<typename Device, typename Key>
class streaming_device_with_key {
Device my_device;
typename std::decay<Key>::type my_key;
public:
// TODO: investigate why default constructor is required
streaming_device_with_key() {}
streaming_device_with_key( const Device& d, Key k ) : my_device( d ), my_key( k ) {}
Key key() const { return my_key; }
const Device& device() const { return my_device; }
};
// --------- Kernel argument helpers --------- //
template <typename T>
struct is_port_ref_impl {
typedef std::false_type type;
};
template <int N1, int N2>
struct is_port_ref_impl< port_ref_impl<N1, N2> > {
typedef std::true_type type;
};
template <int N1, int N2>
struct is_port_ref_impl< port_ref_impl<N1, N2>( * )() > {
typedef std::true_type type;
};
template <typename T>
struct is_port_ref {
typedef typename is_port_ref_impl< typename tbb::internal::strip<T>::type >::type type;
};
template <typename ...Args1>
struct convert_and_call_impl;
template <typename A1, typename ...Args1>
struct convert_and_call_impl<A1, Args1...> {
static const size_t my_delta = 1; // Index 0 contains device
template <typename F, typename Tuple, typename ...Args2>
static void doit(F& f, Tuple& t, A1& a1, Args1&... args1, Args2&... args2) {
convert_and_call_impl<A1, Args1...>::doit_impl(typename is_port_ref<A1>::type(), f, t, a1, args1..., args2...);
}
template <typename F, typename Tuple, typename ...Args2>
static void doit_impl(std::false_type, F& f, Tuple& t, A1& a1, Args1&... args1, Args2&... args2) {
convert_and_call_impl<Args1...>::doit(f, t, args1..., args2..., a1);
}
template <typename F, typename Tuple, int N1, int N2, typename ...Args2>
static void doit_impl(std::true_type x, F& f, Tuple& t, port_ref_impl<N1, N2>, Args1&... args1, Args2&... args2) {
convert_and_call_impl<port_ref_impl<N1 + 1,N2>, Args1...>::doit_impl(x, f, t, port_ref<N1 + 1, N2>(), args1...,
args2..., std::get<N1 + my_delta>(t));
}
template <typename F, typename Tuple, int N, typename ...Args2>
static void doit_impl(std::true_type, F& f, Tuple& t, port_ref_impl<N, N>, Args1&... args1, Args2&... args2) {
convert_and_call_impl<Args1...>::doit(f, t, args1..., args2..., std::get<N + my_delta>(t));
}
template <typename F, typename Tuple, int N1, int N2, typename ...Args2>
static void doit_impl(std::true_type x, F& f, Tuple& t, port_ref_impl<N1, N2>(* fn)(), Args1&... args1, Args2&... args2) {
doit_impl(x, f, t, fn(), args1..., args2...);
}
template <typename F, typename Tuple, int N, typename ...Args2>
static void doit_impl(std::true_type x, F& f, Tuple& t, port_ref_impl<N, N>(* fn)(), Args1&... args1, Args2&... args2) {
doit_impl(x, f, t, fn(), args1..., args2...);
}
};
template <>
struct convert_and_call_impl<> {
template <typename F, typename Tuple, typename ...Args2>
static void doit(F& f, Tuple&, Args2&... args2) {
f(args2...);
}
};
// ------------------------------------------- //
template<typename JP, typename StreamFactory, typename... Ports>
struct streaming_node_traits {
// Do not use 'using' instead of 'struct' because Microsoft Visual C++ 12.0 fails to compile.
template <typename T>
struct async_msg_type {
typedef typename StreamFactory::template async_msg_type<T> type;
};
typedef tuple< typename async_msg_type<Ports>::type... > input_tuple;
typedef input_tuple output_tuple;
typedef tuple< streaming_device_with_key< typename StreamFactory::device_type, typename key_from_policy<JP>::type >,
typename async_msg_type<Ports>::type... > kernel_input_tuple;
// indexer_node parameters pack expansion workaround for VS2013 for streaming_node
typedef indexer_node< typename async_msg_type<Ports>::type... > indexer_node_type;
};
// Default empty implementation
template<typename StreamFactory, typename KernelInputTuple, typename = void>
class kernel_executor_helper {
typedef typename StreamFactory::device_type device_type;
typedef typename StreamFactory::kernel_type kernel_type;
typedef KernelInputTuple kernel_input_tuple;
protected:
template <typename ...Args>
void enqueue_kernel_impl( kernel_input_tuple&, StreamFactory& factory, device_type device, const kernel_type& kernel, Args&... args ) const {
factory.send_kernel( device, kernel, args... );
}
};
// Implementation for StreamFactory supporting range
template<typename StreamFactory, typename KernelInputTuple>
class kernel_executor_helper<StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type > {
typedef typename StreamFactory::device_type device_type;
typedef typename StreamFactory::kernel_type kernel_type;
typedef KernelInputTuple kernel_input_tuple;
typedef typename StreamFactory::range_type range_type;
// Container for randge. It can contain either port references or real range.
struct range_wrapper {
virtual range_type get_range( const kernel_input_tuple &ip ) const = 0;
virtual range_wrapper *clone() const = 0;
virtual ~range_wrapper() {}
};
struct range_value : public range_wrapper {
range_value( const range_type& value ) : my_value(value) {}
range_value( range_type&& value ) : my_value(std::move(value)) {}
range_type get_range( const kernel_input_tuple & ) const __TBB_override {
return my_value;
}
range_wrapper *clone() const __TBB_override {
return new range_value(my_value);
}
private:
range_type my_value;
};
template <int N>
struct range_mapper : public range_wrapper {
range_mapper() {}
range_type get_range( const kernel_input_tuple &ip ) const __TBB_override {
// "+1" since get<0>(ip) is StreamFactory::device.
return get<N + 1>(ip).data(false);
}
range_wrapper *clone() const __TBB_override {
return new range_mapper<N>;
}
};
protected:
template <typename ...Args>
void enqueue_kernel_impl( kernel_input_tuple& ip, StreamFactory& factory, device_type device, const kernel_type& kernel, Args&... args ) const {
__TBB_ASSERT(my_range_wrapper, "Range is not set. Call set_range() before running streaming_node.");
factory.send_kernel( device, kernel, my_range_wrapper->get_range(ip), args... );
}
public:
kernel_executor_helper() : my_range_wrapper(NULL) {}
kernel_executor_helper(const kernel_executor_helper& executor) : my_range_wrapper(executor.my_range_wrapper ? executor.my_range_wrapper->clone() : NULL) {}
kernel_executor_helper(kernel_executor_helper&& executor) : my_range_wrapper(executor.my_range_wrapper) {
// Set moving holder mappers to NULL to prevent double deallocation
executor.my_range_wrapper = NULL;
}
~kernel_executor_helper() {
if (my_range_wrapper) delete my_range_wrapper;
}
void set_range(const range_type& work_size) {
my_range_wrapper = new range_value(work_size);
}
void set_range(range_type&& work_size) {
my_range_wrapper = new range_value(std::move(work_size));
}
template <int N>
void set_range(port_ref_impl<N, N>) {
my_range_wrapper = new range_mapper<N>;
}
template <int N>
void set_range(port_ref_impl<N, N>(*)()) {
my_range_wrapper = new range_mapper<N>;
}
private:
range_wrapper* my_range_wrapper;
};
} // internal
/*
/---------------------------------------- streaming_node ------------------------------------\
| |
| /--------------\ /----------------------\ /-----------\ /----------------------\ |
| | | | (device_with_key) O---O | | | |
| | | | | | | | | |
O---O indexer_node O---O device_selector_node O---O join_node O---O kernel_node O---O
| | | | (multifunction_node) | | | | (multifunction_node) | |
O---O | | O---O | | O---O
| \--------------/ \----------------------/ \-----------/ \----------------------/ |
| |
\--------------------------------------------------------------------------------------------/
*/
template<typename... Args>
class __TBB_DEPRECATED streaming_node;
template<typename... Ports, typename JP, typename StreamFactory>
class __TBB_DEPRECATED
streaming_node< tuple<Ports...>, JP, StreamFactory >
: public composite_node < typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::input_tuple,
typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::output_tuple >
, public internal::kernel_executor_helper< StreamFactory, typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::kernel_input_tuple >
{
typedef typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::input_tuple input_tuple;
typedef typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::output_tuple output_tuple;
typedef typename internal::key_from_policy<JP>::type key_type;
protected:
typedef typename StreamFactory::device_type device_type;
typedef typename StreamFactory::kernel_type kernel_type;
private:
typedef internal::streaming_device_with_key<device_type, key_type> device_with_key_type;
typedef composite_node<input_tuple, output_tuple> base_type;
static const size_t NUM_INPUTS = tuple_size<input_tuple>::value;
static const size_t NUM_OUTPUTS = tuple_size<output_tuple>::value;
typedef typename internal::make_sequence<NUM_INPUTS>::type input_sequence;
typedef typename internal::make_sequence<NUM_OUTPUTS>::type output_sequence;
typedef typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::indexer_node_type indexer_node_type;
typedef typename indexer_node_type::output_type indexer_node_output_type;
typedef typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::kernel_input_tuple kernel_input_tuple;
typedef multifunction_node<indexer_node_output_type, kernel_input_tuple> device_selector_node;
typedef multifunction_node<kernel_input_tuple, output_tuple> kernel_multifunction_node;
template <int... S>
typename base_type::input_ports_type get_input_ports( internal::sequence<S...> ) {
return std::tie( internal::input_port<S>( my_indexer_node )... );
}
template <int... S>
typename base_type::output_ports_type get_output_ports( internal::sequence<S...> ) {
return std::tie( internal::output_port<S>( my_kernel_node )... );
}
typename base_type::input_ports_type get_input_ports() {
return get_input_ports( input_sequence() );
}
typename base_type::output_ports_type get_output_ports() {
return get_output_ports( output_sequence() );
}
template <int N>
int make_Nth_edge() {
make_edge( internal::output_port<N>( my_device_selector_node ), internal::input_port<N>( my_join_node ) );
return 0;
}
template <int... S>
void make_edges( internal::sequence<S...> ) {
make_edge( my_indexer_node, my_device_selector_node );
make_edge( my_device_selector_node, my_join_node );
internal::ignore_return_values( make_Nth_edge<S + 1>()... );
make_edge( my_join_node, my_kernel_node );
}
void make_edges() {
make_edges( input_sequence() );
}
class device_selector_base {
public:
virtual void operator()( const indexer_node_output_type &v, typename device_selector_node::output_ports_type &op ) = 0;
virtual device_selector_base *clone( streaming_node &n ) const = 0;
virtual ~device_selector_base() {}
};
template <typename UserFunctor>
class device_selector : public device_selector_base, tbb::internal::no_assign {
public:
device_selector( UserFunctor uf, streaming_node &n, StreamFactory &f )
: my_dispatch_funcs( create_dispatch_funcs( input_sequence() ) )
, my_user_functor( uf ), my_node(n), my_factory( f )
{
my_port_epoches.fill( 0 );
}
void operator()( const indexer_node_output_type &v, typename device_selector_node::output_ports_type &op ) __TBB_override {
(this->*my_dispatch_funcs[ v.tag() ])( my_port_epoches[ v.tag() ], v, op );
__TBB_ASSERT( (tbb::internal::is_same_type<typename internal::key_from_policy<JP>::is_key_matching, std::false_type>::value)
|| my_port_epoches[v.tag()] == 0, "Epoch is changed when key matching is requested" );
}
device_selector_base *clone( streaming_node &n ) const __TBB_override {
return new device_selector( my_user_functor, n, my_factory );
}
private:
typedef void(device_selector<UserFunctor>::*send_and_put_fn_type)(size_t &, const indexer_node_output_type &, typename device_selector_node::output_ports_type &);
typedef std::array < send_and_put_fn_type, NUM_INPUTS > dispatch_funcs_type;
template <int... S>
static dispatch_funcs_type create_dispatch_funcs( internal::sequence<S...> ) {
dispatch_funcs_type dispatch = { { &device_selector<UserFunctor>::send_and_put_impl<S>... } };
return dispatch;
}
template <typename T>
key_type get_key( std::false_type, const T &, size_t &epoch ) {
__TBB_STATIC_ASSERT( (tbb::internal::is_same_type<key_type, size_t>::value), "" );
return epoch++;
}
template <typename T>
key_type get_key( std::true_type, const T &t, size_t &/*epoch*/ ) {
using tbb::flow::key_from_message;
return key_from_message<key_type>( t );
}
template <int N>
void send_and_put_impl( size_t &epoch, const indexer_node_output_type &v, typename device_selector_node::output_ports_type &op ) {
typedef typename tuple_element<N + 1, typename device_selector_node::output_ports_type>::type::output_type elem_type;
elem_type e = internal::cast_to<elem_type>( v );
device_type device = get_device( get_key( typename internal::key_from_policy<JP>::is_key_matching(), e, epoch ), get<0>( op ) );
my_factory.send_data( device, e );
get<N + 1>( op ).try_put( e );
}
template< typename DevicePort >
device_type get_device( key_type key, DevicePort& dp ) {
typename std::unordered_map<typename std::decay<key_type>::type, epoch_desc>::iterator it = my_devices.find( key );
if ( it == my_devices.end() ) {
device_type d = my_user_functor( my_factory );
std::tie( it, std::ignore ) = my_devices.insert( std::make_pair( key, d ) );
bool res = dp.try_put( device_with_key_type( d, key ) );
__TBB_ASSERT_EX( res, NULL );
my_node.notify_new_device( d );
}
epoch_desc &e = it->second;
device_type d = e.my_device;
if ( ++e.my_request_number == NUM_INPUTS ) my_devices.erase( it );
return d;
}
struct epoch_desc {
epoch_desc(device_type d ) : my_device( d ), my_request_number( 0 ) {}
device_type my_device;
size_t my_request_number;
};
std::unordered_map<typename std::decay<key_type>::type, epoch_desc> my_devices;
std::array<size_t, NUM_INPUTS> my_port_epoches;
dispatch_funcs_type my_dispatch_funcs;
UserFunctor my_user_functor;
streaming_node &my_node;
StreamFactory &my_factory;
};
class device_selector_body {
public:
device_selector_body( device_selector_base *d ) : my_device_selector( d ) {}
void operator()( const indexer_node_output_type &v, typename device_selector_node::output_ports_type &op ) {
(*my_device_selector)(v, op);
}
private:
device_selector_base *my_device_selector;
};
// TODO: investigate why copy-construction is disallowed
class args_storage_base : tbb::internal::no_copy {
public:
typedef typename kernel_multifunction_node::output_ports_type output_ports_type;
virtual void enqueue( kernel_input_tuple &ip, output_ports_type &op, const streaming_node &n ) = 0;
virtual void send( device_type d ) = 0;
virtual args_storage_base *clone() const = 0;
virtual ~args_storage_base () {}
protected:
args_storage_base( const kernel_type& kernel, StreamFactory &f )
: my_kernel( kernel ), my_factory( f )
{}
args_storage_base( const args_storage_base &k )
: tbb::internal::no_copy(), my_kernel( k.my_kernel ), my_factory( k.my_factory )
{}
const kernel_type my_kernel;
StreamFactory &my_factory;
};
template <typename... Args>
class args_storage : public args_storage_base {
typedef typename args_storage_base::output_ports_type output_ports_type;
// ---------- Update events helpers ---------- //
template <int N>
bool do_try_put( const kernel_input_tuple& ip, output_ports_type &op ) const {
const auto& t = get<N + 1>( ip );
auto &port = get<N>( op );
return port.try_put( t );
}
template <int... S>
bool do_try_put( const kernel_input_tuple& ip, output_ports_type &op, internal::sequence<S...> ) const {
return internal::or_return_values( do_try_put<S>( ip, op )... );
}
// ------------------------------------------- //
class run_kernel_func : tbb::internal::no_assign {
public:
run_kernel_func( kernel_input_tuple &ip, const streaming_node &node, const args_storage& storage )
: my_kernel_func( ip, node, storage, get<0>(ip).device() ) {}
// It is immpossible to use Args... because a function pointer cannot be casted to a function reference implicitly.
// Allow the compiler to deduce types for function pointers automatically.
template <typename... FnArgs>
void operator()( FnArgs&... args ) {
internal::convert_and_call_impl<FnArgs...>::doit( my_kernel_func, my_kernel_func.my_ip, args... );
}
private:
struct kernel_func : tbb::internal::no_copy {
kernel_input_tuple &my_ip;
const streaming_node &my_node;
const args_storage& my_storage;
device_type my_device;
kernel_func( kernel_input_tuple &ip, const streaming_node &node, const args_storage& storage, device_type device )
: my_ip( ip ), my_node( node ), my_storage( storage ), my_device( device )
{}
template <typename... FnArgs>
void operator()( FnArgs&... args ) {
my_node.enqueue_kernel( my_ip, my_storage.my_factory, my_device, my_storage.my_kernel, args... );
}
} my_kernel_func;
};
template<typename FinalizeFn>
class run_finalize_func : tbb::internal::no_assign {
public:
run_finalize_func( kernel_input_tuple &ip, StreamFactory &factory, FinalizeFn fn )
: my_ip( ip ), my_finalize_func( factory, get<0>(ip).device(), fn ) {}
// It is immpossible to use Args... because a function pointer cannot be casted to a function reference implicitly.
// Allow the compiler to deduce types for function pointers automatically.
template <typename... FnArgs>
void operator()( FnArgs&... args ) {
internal::convert_and_call_impl<FnArgs...>::doit( my_finalize_func, my_ip, args... );
}
private:
kernel_input_tuple &my_ip;
struct finalize_func : tbb::internal::no_assign {
StreamFactory &my_factory;
device_type my_device;
FinalizeFn my_fn;
finalize_func( StreamFactory &factory, device_type device, FinalizeFn fn )
: my_factory(factory), my_device(device), my_fn(fn) {}
template <typename... FnArgs>
void operator()( FnArgs&... args ) {
my_factory.finalize( my_device, my_fn, args... );
}
} my_finalize_func;
};
template<typename FinalizeFn>
static run_finalize_func<FinalizeFn> make_run_finalize_func( kernel_input_tuple &ip, StreamFactory &factory, FinalizeFn fn ) {
return run_finalize_func<FinalizeFn>( ip, factory, fn );
}
class send_func : tbb::internal::no_assign {
public:
send_func( StreamFactory &factory, device_type d )
: my_factory(factory), my_device( d ) {}
template <typename... FnArgs>
void operator()( FnArgs&... args ) {
my_factory.send_data( my_device, args... );
}
private:
StreamFactory &my_factory;
device_type my_device;
};
public:
args_storage( const kernel_type& kernel, StreamFactory &f, Args&&... args )
: args_storage_base( kernel, f )
, my_args_pack( std::forward<Args>(args)... )
{}
args_storage( const args_storage &k ) : args_storage_base( k ), my_args_pack( k.my_args_pack ) {}
args_storage( const args_storage_base &k, Args&&... args ) : args_storage_base( k ), my_args_pack( std::forward<Args>(args)... ) {}
void enqueue( kernel_input_tuple &ip, output_ports_type &op, const streaming_node &n ) __TBB_override {
// Make const qualified args_pack (from non-const)
const args_pack_type& const_args_pack = my_args_pack;
// factory.enqure_kernel() gets
// - 'ip' tuple elements by reference and updates it (and 'ip') with dependencies
// - arguments (from my_args_pack) by const-reference via const_args_pack
tbb::internal::call( run_kernel_func( ip, n, *this ), const_args_pack );
if (! do_try_put( ip, op, input_sequence() ) ) {
graph& g = n.my_graph;
// No one message was passed to successors so set a callback to extend the graph lifetime until the kernel completion.
g.increment_wait_count();
// factory.finalize() gets
// - 'ip' tuple elements by reference, so 'ip' might be changed
// - arguments (from my_args_pack) by const-reference via const_args_pack
tbb::internal::call( make_run_finalize_func(ip, this->my_factory, [&g] {
g.decrement_wait_count();
}), const_args_pack );
}
}
void send( device_type d ) __TBB_override {
// factory.send() gets arguments by reference and updates these arguments with dependencies
// (it gets but usually ignores port_ref-s)
tbb::internal::call( send_func( this->my_factory, d ), my_args_pack );
}
args_storage_base *clone() const __TBB_override {
// Create new args_storage with copying constructor.
return new args_storage<Args...>( *this );
}
private:
typedef tbb::internal::stored_pack<Args...> args_pack_type;
args_pack_type my_args_pack;
};
// Body for kernel_multifunction_node.
class kernel_body : tbb::internal::no_assign {
public:
kernel_body( const streaming_node &node ) : my_node( node ) {}
void operator()( kernel_input_tuple ip, typename args_storage_base::output_ports_type &op ) {
__TBB_ASSERT( (my_node.my_args_storage != NULL), "No arguments storage" );
// 'ip' is passed by value to create local copy for updating inside enqueue_kernel()
my_node.my_args_storage->enqueue( ip, op, my_node );
}
private:
const streaming_node &my_node;
};
template <typename T, typename U = typename internal::is_port_ref<T>::type >
struct wrap_to_async {
typedef T type; // Keep port_ref as it is
};
template <typename T>
struct wrap_to_async<T, std::false_type> {
typedef typename StreamFactory::template async_msg_type< typename tbb::internal::strip<T>::type > type;
};
template <typename... Args>
args_storage_base *make_args_storage(const args_storage_base& storage, Args&&... args) const {
// In this variadic template convert all simple types 'T' into 'async_msg_type<T>'
return new args_storage<Args...>(storage, std::forward<Args>(args)...);
}
void notify_new_device( device_type d ) {
my_args_storage->send( d );
}
template <typename ...Args>
void enqueue_kernel( kernel_input_tuple& ip, StreamFactory& factory, device_type device, const kernel_type& kernel, Args&... args ) const {
this->enqueue_kernel_impl( ip, factory, device, kernel, args... );
}
public:
template <typename DeviceSelector>
streaming_node( graph &g, const kernel_type& kernel, DeviceSelector d, StreamFactory &f )
: base_type( g )
, my_indexer_node( g )
, my_device_selector( new device_selector<DeviceSelector>( d, *this, f ) )
, my_device_selector_node( g, serial, device_selector_body( my_device_selector ) )
, my_join_node( g )
, my_kernel_node( g, serial, kernel_body( *this ) )
// By default, streaming_node maps all its ports to the kernel arguments on a one-to-one basis.
, my_args_storage( make_args_storage( args_storage<>(kernel, f), port_ref<0, NUM_INPUTS - 1>() ) )
{
base_type::set_external_ports( get_input_ports(), get_output_ports() );
make_edges();
}
streaming_node( const streaming_node &node )
: base_type( node.my_graph )
, my_indexer_node( node.my_indexer_node )
, my_device_selector( node.my_device_selector->clone( *this ) )
, my_device_selector_node( node.my_graph, serial, device_selector_body( my_device_selector ) )
, my_join_node( node.my_join_node )
, my_kernel_node( node.my_graph, serial, kernel_body( *this ) )
, my_args_storage( node.my_args_storage->clone() )
{
base_type::set_external_ports( get_input_ports(), get_output_ports() );
make_edges();
}
streaming_node( streaming_node &&node )
: base_type( node.my_graph )
, my_indexer_node( std::move( node.my_indexer_node ) )
, my_device_selector( node.my_device_selector->clone(*this) )
, my_device_selector_node( node.my_graph, serial, device_selector_body( my_device_selector ) )
, my_join_node( std::move( node.my_join_node ) )
, my_kernel_node( node.my_graph, serial, kernel_body( *this ) )
, my_args_storage( node.my_args_storage )
{
base_type::set_external_ports( get_input_ports(), get_output_ports() );
make_edges();
// Set moving node mappers to NULL to prevent double deallocation.
node.my_args_storage = NULL;
}
~streaming_node() {
if ( my_args_storage ) delete my_args_storage;
if ( my_device_selector ) delete my_device_selector;
}
template <typename... Args>
void set_args( Args&&... args ) {
// Copy the base class of args_storage and create new storage for "Args...".
args_storage_base * const new_args_storage = make_args_storage( *my_args_storage, typename wrap_to_async<Args>::type(std::forward<Args>(args))...);
delete my_args_storage;
my_args_storage = new_args_storage;
}
protected:
void reset_node( reset_flags = rf_reset_protocol ) __TBB_override { __TBB_ASSERT( false, "Not implemented yet" ); }
private:
indexer_node_type my_indexer_node;
device_selector_base *my_device_selector;
device_selector_node my_device_selector_node;
join_node<kernel_input_tuple, JP> my_join_node;
kernel_multifunction_node my_kernel_node;
args_storage_base *my_args_storage;
};
#endif // __TBB_PREVIEW_STREAMING_NODE
#endif // __TBB_flow_graph_streaming_H
port_ref
__TBB_DEPRECATED internal::port_ref_impl< N1, N2 > port_ref()
Definition: _flow_graph_streaming_node.h:41
streaming_node
class __TBB_DEPRECATED streaming_node
Definition: _flow_graph_streaming_node.h:302
__TBB_DEPRECATED
#define __TBB_DEPRECATED
Definition: tbb_config.h:637
__TBB_ASSERT_EX
#define __TBB_ASSERT_EX(predicate, comment)
"Extended" version is useful to suppress warnings if a variable is only used with an assert
Definition: tbb_stddef.h:167
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
__TBB_override
#define __TBB_override
Definition: tbb_stddef.h:240
__TBB_STATIC_ASSERT
#define __TBB_STATIC_ASSERT(condition, msg)
Definition: tbb_stddef.h:553
d
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
Definition: ittnotify_static.h:109
void
void
Definition: ittnotify_static.h:91
S
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 ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type size_t void ITT_FORMAT p const __itt_domain __itt_id __itt_string_handle const wchar_t size_t ITT_FORMAT lu const __itt_domain __itt_id __itt_relation __itt_id ITT_FORMAT p const wchar_t int ITT_FORMAT __itt_group_mark S
Definition: ittnotify_static.h:212
fn
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 ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type size_t void ITT_FORMAT p const __itt_domain __itt_id __itt_string_handle const wchar_t size_t ITT_FORMAT lu const __itt_domain __itt_id __itt_relation __itt_id ITT_FORMAT p const wchar_t int ITT_FORMAT __itt_group_mark d __itt_event ITT_FORMAT __itt_group_mark d void const wchar_t const wchar_t int ITT_FORMAT __itt_group_sync __itt_group_fsync x void const wchar_t int const wchar_t int int ITT_FORMAT __itt_group_sync __itt_group_fsync x void ITT_FORMAT __itt_group_sync __itt_group_fsync p void ITT_FORMAT __itt_group_sync __itt_group_fsync p void size_t ITT_FORMAT lu no args __itt_obj_prop_t __itt_obj_state_t ITT_FORMAT d const char ITT_FORMAT s const char ITT_FORMAT s __itt_frame ITT_FORMAT p __itt_counter ITT_FORMAT p __itt_counter unsigned long long ITT_FORMAT lu __itt_counter unsigned long long ITT_FORMAT lu __itt_counter __itt_clock_domain unsigned long long void ITT_FORMAT p const wchar_t ITT_FORMAT S __itt_mark_type const wchar_t ITT_FORMAT S __itt_mark_type const char ITT_FORMAT s __itt_mark_type ITT_FORMAT d __itt_caller ITT_FORMAT p __itt_caller ITT_FORMAT p no args const __itt_domain __itt_clock_domain unsigned long long __itt_id ITT_FORMAT lu const __itt_domain __itt_clock_domain unsigned long long __itt_id __itt_id void * fn
Definition: ittnotify_static.h:311
value
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 ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long value
Definition: ittnotify_static.h:192
type
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 ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type type
Definition: ittnotify_static.h:198
key
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 ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle * key
Definition: ittnotify_static.h:198
tbb
The graph class.
Definition: serial/tbb/parallel_for.h:46
tbb::move
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
tbb::internal::call
void call(F &&f, Pack &&p)
Calls the given function with arguments taken from a stored_pack.
Definition: _template_helpers.h:175
tbb::internal::false_type
bool_constant< false > false_type
Definition: tbb_stddef.h:490
tbb::internal::true_type
bool_constant< true > true_type
Definition: tbb_stddef.h:489
tbb::flow::key_from_message
K key_from_message(const T &t)
Definition: flow_graph.h:721
tbb::flow::serial
@ serial
Definition: flow_graph.h:106
tbb::flow::interface11::reset_flags
reset_flags
Definition: _flow_graph_impl.h:158
tbb::flow::interface11::rf_reset_protocol
@ rf_reset_protocol
Definition: _flow_graph_impl.h:159
tbb::flow::interface11::make_edge
void make_edge(sender< T > &p, receiver< T > &s)
Makes an edge between a single predecessor and a single successor.
Definition: flow_graph.h:3838
internal
Definition: _flow_graph_async_msg_impl.h:24
internal::ignore_return_values
void ignore_return_values(Args &&...)
Definition: _flow_graph_streaming_node.h:63
internal::do_try_put
task * do_try_put(const T &v, void *p)
Definition: _flow_graph_indexer_impl.h:34
internal::or_return_values
T or_return_values(T &&t)
Definition: _flow_graph_streaming_node.h:66
internal::graph_policy_namespace::key_matching
field of type K being used for matching.
Definition: _flow_graph_body_impl.h:79
internal::port_ref_impl
Definition: _flow_graph_streaming_node.h:31
internal::port_ref_impl::size
static const int size
Definition: _flow_graph_streaming_node.h:33
internal::num_arguments
Definition: _flow_graph_streaming_node.h:48
internal::num_arguments::value
static const int value
Definition: _flow_graph_streaming_node.h:49
internal::key_from_policy
Definition: _flow_graph_streaming_node.h:73
internal::key_from_policy::is_key_matching
std::false_type is_key_matching
Definition: _flow_graph_streaming_node.h:75
internal::key_from_policy::type
size_t type
Definition: _flow_graph_streaming_node.h:74
internal::key_from_policy< key_matching< Key > >::is_key_matching
std::true_type is_key_matching
Definition: _flow_graph_streaming_node.h:81
internal::key_from_policy< key_matching< Key > >::type
Key type
Definition: _flow_graph_streaming_node.h:80
internal::key_from_policy< key_matching< Key & > >::type
const Key & type
Definition: _flow_graph_streaming_node.h:86
internal::key_from_policy< key_matching< Key & > >::is_key_matching
std::true_type is_key_matching
Definition: _flow_graph_streaming_node.h:87
internal::streaming_device_with_key
Definition: _flow_graph_streaming_node.h:91
internal::streaming_device_with_key::my_device
Device my_device
Definition: _flow_graph_streaming_node.h:92
internal::streaming_device_with_key::streaming_device_with_key
streaming_device_with_key(const Device &d, Key k)
Definition: _flow_graph_streaming_node.h:97
internal::streaming_device_with_key::key
Key key() const
Definition: _flow_graph_streaming_node.h:98
internal::streaming_device_with_key::device
const Device & device() const
Definition: _flow_graph_streaming_node.h:99
internal::streaming_device_with_key::streaming_device_with_key
streaming_device_with_key()
Definition: _flow_graph_streaming_node.h:96
internal::streaming_device_with_key::my_key
std::decay< Key >::type my_key
Definition: _flow_graph_streaming_node.h:93
internal::is_port_ref_impl
Definition: _flow_graph_streaming_node.h:104
internal::is_port_ref_impl::type
std::false_type type
Definition: _flow_graph_streaming_node.h:105
internal::is_port_ref_impl< port_ref_impl< N1, N2 > >::type
std::true_type type
Definition: _flow_graph_streaming_node.h:110
internal::is_port_ref_impl< port_ref_impl< N1, N2 >(*)() >::type
std::true_type type
Definition: _flow_graph_streaming_node.h:115
internal::is_port_ref
Definition: _flow_graph_streaming_node.h:119
internal::is_port_ref::type
is_port_ref_impl< typename tbb::internal::strip< T >::type >::type type
Definition: _flow_graph_streaming_node.h:120
internal::convert_and_call_impl
Definition: _flow_graph_streaming_node.h:124
internal::convert_and_call_impl< A1, Args1... >::doit_impl
static void doit_impl(std::true_type x, F &f, Tuple &t, port_ref_impl< N, N >(*fn)(), Args1 &... args1, Args2 &... args2)
Definition: _flow_graph_streaming_node.h:153
internal::convert_and_call_impl< A1, Args1... >::doit_impl
static void doit_impl(std::true_type x, F &f, Tuple &t, port_ref_impl< N1, N2 >, Args1 &... args1, Args2 &... args2)
Definition: _flow_graph_streaming_node.h:139
internal::convert_and_call_impl< A1, Args1... >::doit_impl
static void doit_impl(std::true_type, F &f, Tuple &t, port_ref_impl< N, N >, Args1 &... args1, Args2 &... args2)
Definition: _flow_graph_streaming_node.h:144
internal::convert_and_call_impl< A1, Args1... >::doit_impl
static void doit_impl(std::true_type x, F &f, Tuple &t, port_ref_impl< N1, N2 >(*fn)(), Args1 &... args1, Args2 &... args2)
Definition: _flow_graph_streaming_node.h:149
internal::convert_and_call_impl< A1, Args1... >::doit_impl
static void doit_impl(std::false_type, F &f, Tuple &t, A1 &a1, Args1 &... args1, Args2 &... args2)
Definition: _flow_graph_streaming_node.h:135
internal::convert_and_call_impl< A1, Args1... >::doit
static void doit(F &f, Tuple &t, A1 &a1, Args1 &... args1, Args2 &... args2)
Definition: _flow_graph_streaming_node.h:131
internal::convert_and_call_impl<>::doit
static void doit(F &f, Tuple &, Args2 &... args2)
Definition: _flow_graph_streaming_node.h:161
internal::streaming_node_traits
Definition: _flow_graph_streaming_node.h:168
internal::streaming_node_traits::kernel_input_tuple
tuple< streaming_device_with_key< typename StreamFactory::device_type, typename key_from_policy< JP >::type >, typename async_msg_type< Ports >::type... > kernel_input_tuple
Definition: _flow_graph_streaming_node.h:178
internal::streaming_node_traits::input_tuple
tuple< typename async_msg_type< Ports >::type... > input_tuple
Definition: _flow_graph_streaming_node.h:175
internal::streaming_node_traits::indexer_node_type
indexer_node< typename async_msg_type< Ports >::type... > indexer_node_type
Definition: _flow_graph_streaming_node.h:181
internal::streaming_node_traits::output_tuple
input_tuple output_tuple
Definition: _flow_graph_streaming_node.h:176
internal::streaming_node_traits::async_msg_type
Definition: _flow_graph_streaming_node.h:171
internal::streaming_node_traits::async_msg_type::type
StreamFactory::template async_msg_type< T > type
Definition: _flow_graph_streaming_node.h:172
internal::kernel_executor_helper
Definition: _flow_graph_streaming_node.h:186
internal::kernel_executor_helper::kernel_input_tuple
KernelInputTuple kernel_input_tuple
Definition: _flow_graph_streaming_node.h:189
internal::kernel_executor_helper::device_type
StreamFactory::device_type device_type
Definition: _flow_graph_streaming_node.h:187
internal::kernel_executor_helper::kernel_type
StreamFactory::kernel_type kernel_type
Definition: _flow_graph_streaming_node.h:188
internal::kernel_executor_helper::enqueue_kernel_impl
void enqueue_kernel_impl(kernel_input_tuple &, StreamFactory &factory, device_type device, const kernel_type &kernel, Args &... args) const
Definition: _flow_graph_streaming_node.h:192
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::kernel_input_tuple
KernelInputTuple kernel_input_tuple
Definition: _flow_graph_streaming_node.h:202
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::set_range
void set_range(port_ref_impl< N, N >(*)())
Definition: _flow_graph_streaming_node.h:278
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::enqueue_kernel_impl
void enqueue_kernel_impl(kernel_input_tuple &ip, StreamFactory &factory, device_type device, const kernel_type &kernel, Args &... args) const
Definition: _flow_graph_streaming_node.h:245
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::kernel_type
StreamFactory::kernel_type kernel_type
Definition: _flow_graph_streaming_node.h:201
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::kernel_executor_helper
kernel_executor_helper(kernel_executor_helper &&executor)
Definition: _flow_graph_streaming_node.h:255
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::kernel_executor_helper
kernel_executor_helper(const kernel_executor_helper &executor)
Definition: _flow_graph_streaming_node.h:253
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_type
StreamFactory::range_type range_type
Definition: _flow_graph_streaming_node.h:204
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::set_range
void set_range(const range_type &work_size)
Definition: _flow_graph_streaming_node.h:264
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::~kernel_executor_helper
~kernel_executor_helper()
Definition: _flow_graph_streaming_node.h:260
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::kernel_executor_helper
kernel_executor_helper()
Definition: _flow_graph_streaming_node.h:251
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::device_type
StreamFactory::device_type device_type
Definition: _flow_graph_streaming_node.h:200
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::set_range
void set_range(range_type &&work_size)
Definition: _flow_graph_streaming_node.h:268
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::set_range
void set_range(port_ref_impl< N, N >)
Definition: _flow_graph_streaming_node.h:273
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::my_range_wrapper
range_wrapper * my_range_wrapper
Definition: _flow_graph_streaming_node.h:283
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_wrapper::clone
virtual range_wrapper * clone() const =0
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_wrapper::~range_wrapper
virtual ~range_wrapper()
Definition: _flow_graph_streaming_node.h:210
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_wrapper::get_range
virtual range_type get_range(const kernel_input_tuple &ip) const =0
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_value::my_value
range_type my_value
Definition: _flow_graph_streaming_node.h:226
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_value::range_value
range_value(range_type &&value)
Definition: _flow_graph_streaming_node.h:216
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_value::range_value
range_value(const range_type &value)
Definition: _flow_graph_streaming_node.h:214
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_value::clone
range_wrapper * clone() const __TBB_override
Definition: _flow_graph_streaming_node.h:222
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_value::get_range
range_type get_range(const kernel_input_tuple &) const __TBB_override
Definition: _flow_graph_streaming_node.h:218
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_mapper::clone
range_wrapper * clone() const __TBB_override
Definition: _flow_graph_streaming_node.h:238
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_mapper::range_mapper
range_mapper()
Definition: _flow_graph_streaming_node.h:231
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_mapper::get_range
range_type get_range(const kernel_input_tuple &ip) const __TBB_override
Definition: _flow_graph_streaming_node.h:233
streaming_node< tuple< Ports... >, JP, StreamFactory >::key_type
internal::key_from_policy< JP >::type key_type
Definition: _flow_graph_streaming_node.h:313
streaming_node< tuple< Ports... >, JP, StreamFactory >::my_args_storage
args_storage_base * my_args_storage
Definition: _flow_graph_streaming_node.h:739
streaming_node< tuple< Ports... >, JP, StreamFactory >::make_Nth_edge
int make_Nth_edge()
Definition: _flow_graph_streaming_node.h:351
streaming_node< tuple< Ports... >, JP, StreamFactory >::get_output_ports
base_type::output_ports_type get_output_ports()
Definition: _flow_graph_streaming_node.h:346
streaming_node< tuple< Ports... >, JP, StreamFactory >::output_sequence
internal::make_sequence< NUM_OUTPUTS >::type output_sequence
Definition: _flow_graph_streaming_node.h:324
streaming_node< tuple< Ports... >, JP, StreamFactory >::kernel_input_tuple
internal::streaming_node_traits< JP, StreamFactory, Ports... >::kernel_input_tuple kernel_input_tuple
Definition: _flow_graph_streaming_node.h:328
streaming_node< tuple< Ports... >, JP, StreamFactory >::notify_new_device
void notify_new_device(device_type d)
Definition: _flow_graph_streaming_node.h:663
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_type
StreamFactory::device_type device_type
Definition: _flow_graph_streaming_node.h:315
streaming_node< tuple< Ports... >, JP, StreamFactory >::my_kernel_node
kernel_multifunction_node my_kernel_node
Definition: _flow_graph_streaming_node.h:737
streaming_node< tuple< Ports... >, JP, StreamFactory >::get_output_ports
base_type::output_ports_type get_output_ports(internal::sequence< S... >)
Definition: _flow_graph_streaming_node.h:338
streaming_node< tuple< Ports... >, JP, StreamFactory >::my_join_node
join_node< kernel_input_tuple, JP > my_join_node
Definition: _flow_graph_streaming_node.h:736
streaming_node< tuple< Ports... >, JP, StreamFactory >::kernel_multifunction_node
multifunction_node< kernel_input_tuple, output_tuple > kernel_multifunction_node
Definition: _flow_graph_streaming_node.h:330
streaming_node< tuple< Ports... >, JP, StreamFactory >::set_args
void set_args(Args &&... args)
Definition: _flow_graph_streaming_node.h:722
streaming_node< tuple< Ports... >, JP, StreamFactory >::my_indexer_node
indexer_node_type my_indexer_node
Definition: _flow_graph_streaming_node.h:733
streaming_node< tuple< Ports... >, JP, StreamFactory >::make_edges
void make_edges()
Definition: _flow_graph_streaming_node.h:364
streaming_node< tuple< Ports... >, JP, StreamFactory >::get_input_ports
base_type::input_ports_type get_input_ports(internal::sequence< S... >)
Definition: _flow_graph_streaming_node.h:333
streaming_node< tuple< Ports... >, JP, StreamFactory >::indexer_node_output_type
indexer_node_type::output_type indexer_node_output_type
Definition: _flow_graph_streaming_node.h:327
streaming_node< tuple< Ports... >, JP, StreamFactory >::streaming_node
streaming_node(const streaming_node &node)
Definition: _flow_graph_streaming_node.h:688
streaming_node< tuple< Ports... >, JP, StreamFactory >::reset_node
void reset_node(reset_flags=rf_reset_protocol) __TBB_override
Definition: _flow_graph_streaming_node.h:730
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_with_key_type
internal::streaming_device_with_key< device_type, key_type > device_with_key_type
Definition: _flow_graph_streaming_node.h:318
streaming_node< tuple< Ports... >, JP, StreamFactory >::output_tuple
internal::streaming_node_traits< JP, StreamFactory, Ports... >::output_tuple output_tuple
Definition: _flow_graph_streaming_node.h:312
streaming_node< tuple< Ports... >, JP, StreamFactory >::indexer_node_type
internal::streaming_node_traits< JP, StreamFactory, Ports... >::indexer_node_type indexer_node_type
Definition: _flow_graph_streaming_node.h:326
streaming_node< tuple< Ports... >, JP, StreamFactory >::input_tuple
internal::streaming_node_traits< JP, StreamFactory, Ports... >::input_tuple input_tuple
Definition: _flow_graph_streaming_node.h:311
streaming_node< tuple< Ports... >, JP, StreamFactory >::get_input_ports
base_type::input_ports_type get_input_ports()
Definition: _flow_graph_streaming_node.h:342
streaming_node< tuple< Ports... >, JP, StreamFactory >::enqueue_kernel
void enqueue_kernel(kernel_input_tuple &ip, StreamFactory &factory, device_type device, const kernel_type &kernel, Args &... args) const
Definition: _flow_graph_streaming_node.h:668
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector_node
multifunction_node< indexer_node_output_type, kernel_input_tuple > device_selector_node
Definition: _flow_graph_streaming_node.h:329
streaming_node< tuple< Ports... >, JP, StreamFactory >::streaming_node
streaming_node(streaming_node &&node)
Definition: _flow_graph_streaming_node.h:701
streaming_node< tuple< Ports... >, JP, StreamFactory >::my_device_selector_node
device_selector_node my_device_selector_node
Definition: _flow_graph_streaming_node.h:735
streaming_node< tuple< Ports... >, JP, StreamFactory >::input_sequence
internal::make_sequence< NUM_INPUTS >::type input_sequence
Definition: _flow_graph_streaming_node.h:323
streaming_node< tuple< Ports... >, JP, StreamFactory >::streaming_node
streaming_node(graph &g, const kernel_type &kernel, DeviceSelector d, StreamFactory &f)
Definition: _flow_graph_streaming_node.h:674
streaming_node< tuple< Ports... >, JP, StreamFactory >::my_device_selector
device_selector_base * my_device_selector
Definition: _flow_graph_streaming_node.h:734
streaming_node< tuple< Ports... >, JP, StreamFactory >::base_type
composite_node< input_tuple, output_tuple > base_type
Definition: _flow_graph_streaming_node.h:319
streaming_node< tuple< Ports... >, JP, StreamFactory >::~streaming_node
~streaming_node()
Definition: _flow_graph_streaming_node.h:716
streaming_node< tuple< Ports... >, JP, StreamFactory >::make_edges
void make_edges(internal::sequence< S... >)
Definition: _flow_graph_streaming_node.h:357
streaming_node< tuple< Ports... >, JP, StreamFactory >::kernel_type
StreamFactory::kernel_type kernel_type
Definition: _flow_graph_streaming_node.h:316
streaming_node< tuple< Ports... >, JP, StreamFactory >::make_args_storage
args_storage_base * make_args_storage(const args_storage_base &storage, Args &&... args) const
Definition: _flow_graph_streaming_node.h:658
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector_base::~device_selector_base
virtual ~device_selector_base()
Definition: _flow_graph_streaming_node.h:372
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector_base::operator()
virtual void operator()(const indexer_node_output_type &v, typename device_selector_node::output_ports_type &op)=0
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector_base::clone
virtual device_selector_base * clone(streaming_node &n) const =0
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::device_selector
device_selector(UserFunctor uf, streaming_node &n, StreamFactory &f)
Definition: _flow_graph_streaming_node.h:378
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::my_port_epoches
std::array< size_t, NUM_INPUTS > my_port_epoches
Definition: _flow_graph_streaming_node.h:448
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::my_dispatch_funcs
dispatch_funcs_type my_dispatch_funcs
Definition: _flow_graph_streaming_node.h:449
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::my_devices
std::unordered_map< typename std::decay< key_type >::type, epoch_desc > my_devices
Definition: _flow_graph_streaming_node.h:447
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::my_user_functor
UserFunctor my_user_functor
Definition: _flow_graph_streaming_node.h:450
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::get_device
device_type get_device(key_type key, DevicePort &dp)
Definition: _flow_graph_streaming_node.h:426
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::send_and_put_impl
void send_and_put_impl(size_t &epoch, const indexer_node_output_type &v, typename device_selector_node::output_ports_type &op)
Definition: _flow_graph_streaming_node.h:417
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::operator()
void operator()(const indexer_node_output_type &v, typename device_selector_node::output_ports_type &op) __TBB_override
Definition: _flow_graph_streaming_node.h:385
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::dispatch_funcs_type
std::array< send_and_put_fn_type, NUM_INPUTS > dispatch_funcs_type
Definition: _flow_graph_streaming_node.h:396
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::my_node
streaming_node & my_node
Definition: _flow_graph_streaming_node.h:451
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::clone
device_selector_base * clone(streaming_node &n) const __TBB_override
Definition: _flow_graph_streaming_node.h:391
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::get_key
key_type get_key(std::false_type, const T &, size_t &epoch)
Definition: _flow_graph_streaming_node.h:405
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::get_key
key_type get_key(std::true_type, const T &t, size_t &)
Definition: _flow_graph_streaming_node.h:411
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::my_factory
StreamFactory & my_factory
Definition: _flow_graph_streaming_node.h:452
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::create_dispatch_funcs
static dispatch_funcs_type create_dispatch_funcs(internal::sequence< S... >)
Definition: _flow_graph_streaming_node.h:399
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::epoch_desc::my_device
device_type my_device
Definition: _flow_graph_streaming_node.h:443
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::epoch_desc::epoch_desc
epoch_desc(device_type d)
Definition: _flow_graph_streaming_node.h:442
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector::epoch_desc::my_request_number
size_t my_request_number
Definition: _flow_graph_streaming_node.h:444
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector_body::my_device_selector
device_selector_base * my_device_selector
Definition: _flow_graph_streaming_node.h:463
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector_body::operator()
void operator()(const indexer_node_output_type &v, typename device_selector_node::output_ports_type &op)
Definition: _flow_graph_streaming_node.h:459
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector_body::device_selector_body
device_selector_body(device_selector_base *d)
Definition: _flow_graph_streaming_node.h:457
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage_base::enqueue
virtual void enqueue(kernel_input_tuple &ip, output_ports_type &op, const streaming_node &n)=0
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage_base::output_ports_type
kernel_multifunction_node::output_ports_type output_ports_type
Definition: _flow_graph_streaming_node.h:469
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage_base::my_kernel
const kernel_type my_kernel
Definition: _flow_graph_streaming_node.h:485
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage_base::clone
virtual args_storage_base * clone() const =0
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage_base::send
virtual void send(device_type d)=0
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage_base::~args_storage_base
virtual ~args_storage_base()
Definition: _flow_graph_streaming_node.h:474
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage_base::args_storage_base
args_storage_base(const args_storage_base &k)
Definition: _flow_graph_streaming_node.h:481
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage_base::args_storage_base
args_storage_base(const kernel_type &kernel, StreamFactory &f)
Definition: _flow_graph_streaming_node.h:477
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage_base::my_factory
StreamFactory & my_factory
Definition: _flow_graph_streaming_node.h:486
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::make_run_finalize_func
static run_finalize_func< FinalizeFn > make_run_finalize_func(kernel_input_tuple &ip, StreamFactory &factory, FinalizeFn fn)
Definition: _flow_graph_streaming_node.h:567
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::args_pack_type
tbb::internal::stored_pack< Args... > args_pack_type
Definition: _flow_graph_streaming_node.h:629
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::args_storage
args_storage(const args_storage &k)
Definition: _flow_graph_streaming_node.h:591
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::do_try_put
bool do_try_put(const kernel_input_tuple &ip, output_ports_type &op, internal::sequence< S... >) const
Definition: _flow_graph_streaming_node.h:502
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::args_storage
args_storage(const kernel_type &kernel, StreamFactory &f, Args &&... args)
Definition: _flow_graph_streaming_node.h:586
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::args_storage
args_storage(const args_storage_base &k, Args &&... args)
Definition: _flow_graph_streaming_node.h:593
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::output_ports_type
args_storage_base::output_ports_type output_ports_type
Definition: _flow_graph_streaming_node.h:491
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::do_try_put
bool do_try_put(const kernel_input_tuple &ip, output_ports_type &op) const
Definition: _flow_graph_streaming_node.h:495
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::send
void send(device_type d) __TBB_override
Definition: _flow_graph_streaming_node.h:617
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::my_args_pack
args_pack_type my_args_pack
Definition: _flow_graph_streaming_node.h:630
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::clone
args_storage_base * clone() const __TBB_override
Definition: _flow_graph_streaming_node.h:623
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::enqueue
void enqueue(kernel_input_tuple &ip, output_ports_type &op, const streaming_node &n) __TBB_override
Definition: _flow_graph_streaming_node.h:595
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_kernel_func::run_kernel_func
run_kernel_func(kernel_input_tuple &ip, const streaming_node &node, const args_storage &storage)
Definition: _flow_graph_streaming_node.h:509
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_kernel_func::operator()
void operator()(FnArgs &... args)
Definition: _flow_graph_streaming_node.h:515
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_kernel_func::kernel_func::my_device
device_type my_device
Definition: _flow_graph_streaming_node.h:523
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_kernel_func::kernel_func::operator()
void operator()(FnArgs &... args)
Definition: _flow_graph_streaming_node.h:530
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_kernel_func::kernel_func::my_storage
const args_storage & my_storage
Definition: _flow_graph_streaming_node.h:522
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_kernel_func::kernel_func::my_ip
kernel_input_tuple & my_ip
Definition: _flow_graph_streaming_node.h:520
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_kernel_func::kernel_func::kernel_func
kernel_func(kernel_input_tuple &ip, const streaming_node &node, const args_storage &storage, device_type device)
Definition: _flow_graph_streaming_node.h:525
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_kernel_func::kernel_func::my_node
const streaming_node & my_node
Definition: _flow_graph_streaming_node.h:521
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_finalize_func::my_ip
kernel_input_tuple & my_ip
Definition: _flow_graph_streaming_node.h:549
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_finalize_func::operator()
void operator()(FnArgs &... args)
Definition: _flow_graph_streaming_node.h:545
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_finalize_func::run_finalize_func
run_finalize_func(kernel_input_tuple &ip, StreamFactory &factory, FinalizeFn fn)
Definition: _flow_graph_streaming_node.h:539
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_finalize_func::finalize_func::my_device
device_type my_device
Definition: _flow_graph_streaming_node.h:553
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_finalize_func::finalize_func::finalize_func
finalize_func(StreamFactory &factory, device_type device, FinalizeFn fn)
Definition: _flow_graph_streaming_node.h:556
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_finalize_func::finalize_func::my_factory
StreamFactory & my_factory
Definition: _flow_graph_streaming_node.h:552
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_finalize_func::finalize_func::my_fn
FinalizeFn my_fn
Definition: _flow_graph_streaming_node.h:554
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::run_finalize_func::finalize_func::operator()
void operator()(FnArgs &... args)
Definition: _flow_graph_streaming_node.h:560
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::send_func::send_func
send_func(StreamFactory &factory, device_type d)
Definition: _flow_graph_streaming_node.h:573
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::send_func::my_factory
StreamFactory & my_factory
Definition: _flow_graph_streaming_node.h:581
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::send_func::my_device
device_type my_device
Definition: _flow_graph_streaming_node.h:582
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage::send_func::operator()
void operator()(FnArgs &... args)
Definition: _flow_graph_streaming_node.h:577
streaming_node< tuple< Ports... >, JP, StreamFactory >::kernel_body::kernel_body
kernel_body(const streaming_node &node)
Definition: _flow_graph_streaming_node.h:636
streaming_node< tuple< Ports... >, JP, StreamFactory >::kernel_body::my_node
const streaming_node & my_node
Definition: _flow_graph_streaming_node.h:644
streaming_node< tuple< Ports... >, JP, StreamFactory >::kernel_body::operator()
void operator()(kernel_input_tuple ip, typename args_storage_base::output_ports_type &op)
Definition: _flow_graph_streaming_node.h:638
streaming_node< tuple< Ports... >, JP, StreamFactory >::wrap_to_async::type
T type
Definition: _flow_graph_streaming_node.h:649
streaming_node< tuple< Ports... >, JP, StreamFactory >::wrap_to_async< T, std::false_type >::type
StreamFactory::template async_msg_type< typename tbb::internal::strip< T >::type > type
Definition: _flow_graph_streaming_node.h:654
internal::sequence
Definition: _flow_graph_types_impl.h:329
internal::make_sequence
Definition: _flow_graph_types_impl.h:332
tbb::internal::is_same_type
Detects whether two given types are the same.
Definition: _template_helpers.h:61
tbb::internal::stored_pack< Args... >
tbb::internal::no_assign
Base class for types that should not be assigned.
Definition: tbb_stddef.h:322
tbb::internal::no_copy
Base class for types that should not be copied or assigned.
Definition: tbb_stddef.h:330

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.