join_node テンプレート・クラス

概要

入力ポートで受け取ったメッセージのセットから tuple<T0,T1, ... > を作成して、タプルをすべてのサクセサーにブロードキャストするノード。join_node クラスは、入力ポートで 3 つのバッファーポリシー (reserving、queueing、key_matching) をサポートします。 デフォルトでは、join_node の入力ポートは queueing ポリシーを使用します。

構文

struct queueing;
struct reserving;
template<typename K, typename KHash=tbb_hash_compare<K> > struct key_matching;
typedef key_matching<tag_value> tag_matching;

template<typename OutputTuple, class JP = queueing>
class join_node;

ヘッダー

#include "tbb/flow_graph.h"

説明

join_node は、graph_node および sender< flow::tuple< T0, T1, ... > > です。OutputTuple の T0 .. TN に対応する receiver<Ti> である入力ポートのタプルが含まれます。異なる型の複数の入力レシーバーをサポートしており、受け取ったメッセージのタプルをすべてのサクセサーにブロードキャストします。join_node の入力ポートはすべて、同じバッファーポリシーを使用しなければなりません。バッファーポリシーに基づく join_node の動作は、下記の表に示されています。

                                           const K' &(const Ti&)
                                         

                                           K (const Ti&)
                                         

join_node のサクセサーがメッセージを拒否した場合、および入力ポートのプレデセッサーからのメッセージの取得に失敗した場合、メッセージ・パッシング・プロトコルを使用して処理されます。

input_port テンプレート関数は、特定の入力ポートへの参照を取得するための構文を単純化します。

OutputTuple は、各要素がコピー構築および代入可能な flow::tuple<T0,T1, ... > でなければなりません。

サンプル

#include<cstdio>
#include "tbb/flow_graph.h"

using namespace tbb::flow;

int main() {
   graph g;
   function_node<int,int>
       f1( g, unlimited, [](const int &i) { return 2*i; } );
   function_node<float,float>
       f2( g, unlimited, [](const float &f) { return f/2; } );

   join_node< tbb::flow::tuple<int,float> > j(g);

   function_node< flow::tuple<int,float> >
       f3( g, unlimited,
           []( const flow::tuple<int,float> &t ) {
               printf( "Result is %f\n",
                       std::get<0>(t) + std::get<1>(t));
           } );

   make_edge( f1, input_port<0>( j ) );
   make_edge( f2, input_port<1>( j ) );
   make_edge( j, f3 );

   f1.try_put( 3 );
   f2.try_put( 3 );
   g.wait_for_all( );
   return 0;
}

上記のサンプルでは、3 つの function_node オブジェクトが作成されます。f1 は int i に 2 を掛けて、f2 は float f を 2 で割って、f3 は flow::tuple<int,float> t を受け取り、要素を互いに追加して結果を出力します。join_node j は、f1 と f2 の出力を組み合わせて、生成されたタプルを f3 に送ります。このサンプルは構文を示すことを目的としているため、ノードでほとんど作業を行っていません。

メンバー

namespace tbb {
namespace flow {

struct reserving;
struct queueing;
template<typename K, class KHash=tbb_hash_compare<K> >
struct key_matching;
typedef key_matching<tag_value> tag_matching;

template<typename OutputTuple, class JP = queueing>
class join_node :
    public graph_node, public sender< OutputTuple > {

public:
    typedef OutputTuple output_type;
    typedef receiver<output_type> successor_type;
    typedef implementation-dependent-tuple input_ports_type;

    join_node( graph &g );
    join_node( const join_node &src );
    input_ports_type &input_ports( );
    bool register_successor( successor_type &r );
    bool remove_successor( successor_type &r );
    bool try_get( output_type &v );
    bool try_reserve( output_type &v );
    bool try_release( );
    bool try_consume( );

};

//
// key_matching の特殊化
//

template<typename OutputTuple, typename K, class KHash=tbb_hash_compare<K> >
class join_node<OutputTuple, key_matching<K,KHash> > :
    public graph_node, public sender< OutputTuple > {

public:

    // 以前の join_node と同じメソッドで、
    // key_matching 関数オブジェクトを指定する
    // コンストラクターを持つ

    template<typename B0, typename B1>
    join_node( graph &g, B0 b0, B1 b1 );

    // 3 ～ 10 要素に対するコンストラクターも
    // 同様に定義される ...
};

}
}