blocked_range2d テンプレート・クラス

概要

再帰的に分割可能な 2 次元の半開区間を表すテンプレート・クラス。

ヘッダー

#include "tbb/blocked_range2d.h"

構文

template<typename RowValue, typename ColValue> class blocked_range2d;

説明

blocked_range2d<RowValue ,ColValue > は、2 次元の半開区間 [i₀,j₀)×[i₁,j₁) を表します。範囲の各軸には独自の分割しきい値があります。RowValue および ColValue は、「blocked_range テンプレート・クラス」セクションの表の要件を満たしていなければなりません。いずれかの軸が分割可能な場合、blocked_range2d は分割可能です。blocked_range2d は、Range コンセプトをモデル化します。

メンバー

 
namespace tbb {
template<typename RowValue, typename ColValue=RowValue>
    class blocked_range2d {
    public:
        // 型
        typedef blocked_range<RowValue> row_range_type;
        typedef blocked_range<ColValue> col_range_type;

        // コンストラクター
        blocked_range2d( 
            RowValue row_begin, RowValue row_end, 
            typename row_range_type::size_type row_grainsize,
            ColValue col_begin, ColValue col_end, 
            typename col_range_type::size_type col_grainsize);
        blocked_range2d( RowValue row_begin, RowValue row_end, 
                         ColValue col_begin, ColValue col_end);
        // 分割コンストラクター
        blocked_range2d( blocked_range2d& r, split );
        blocked_range2d( blocked_range2d& r, proportional_split proportion );

        // 比例分割が可能
        static const bool is_splittable_in_proportion = true;

        // キャパシティー
        bool empty() const;

        // アクセス
        bool is_divisible() const;
        const row_range_type& rows() const;
        const col_range_type& cols() const;
    };
}

サンプル

次のコードは、シリアル行列乗算と、blocked_range2d を使用して反復空間を指定する、対応する並列行列乗算を示しています。

const size_t L = 150;
const size_t M = 225;
const size_t N = 300;

void SerialMatrixMultiply( float c[M][N], float a[M][L], float b[L][N] ) {
    for( size_t i=0; i<M; ++i ) {
        for( size_t j=0; j<N; ++j ) {
            float sum = 0;
            for( size_t k=0; k<L; ++k )
                sum += a[i][k]*b[k][j];
            c[i][j] = sum;
        }
    }
}

#include "tbb/parallel_for.h"
#include "tbb/blocked_range2d.h"

using namespace tbb;

const size_t L = 150;
const size_t M = 225;
const size_t N = 300;

class MatrixMultiplyBody2D {
    float (*my_a)[L];
    float (*my_b)[N];
    float (*my_c)[N];
public:
    void operator()( const blocked_range2d<size_t>& r ) const {
        float (*a)[L] = my_a;
        float (*b)[N] = my_b;
        float (*c)[N] = my_c;
        for( size_t i=r.rows().begin(); i!=r.rows().end(); ++i ){
            for( size_t j=r.cols().begin(); j!=r.cols().end(); ++j ) {
                float sum = 0;
                for( size_t k=0; k<L; ++k )
                    sum += a[i][k]*b[k][j];
                c[i][j] = sum;
            }
        }
    }
    MatrixMultiplyBody2D( float c[M][N], float a[M][L], float b[L][N] ) :
        my_a(a), my_b(b), my_c(c)
    {}
};

void ParallelMatrixMultiply(float c[M][N], float a[M][L], float b[L][N]){
    parallel_for( blocked_range2d<size_t>(0, M, 16, 0, N, 32),     
                  MatrixMultiplyBody2D(c,a,b) );
}

blocked_range2d は、シリアルバージョンの 2 つの最外ループを並列ループにします。parallel_for は、断片が 16x32 になるまで blocked_range2d を再帰的に分割して、各断片で MatrixMultiplyBody2D::operator() を呼び出します。