 |
| "The Great Day of His Wrath" by John Martin |
世はまさに大並列時代。火を手にした人類が飛躍的な進化を遂げたように、並列化のパラダイムは、今まで到底不可能と思われていた速さで計算を行うことができるようになりました。
ところが、どんな手法にも欠点は存在するもので、実際に実装しようとすると非常に難しい。何故かというと、並列には並列化特有の問題が存在しており、愚直に実装してしまうとCPUより早くなってしまうどころか遅くなってしまうことだってあり得るのです。これを回避するにはGPUの内部構造についてきちんと理解をした上で、実装したいアルゴリズムそれぞれの場合に特化したコーディングを行う必要がある。
しかしよくよく考えるとおかしな話です。私たちが実装したいのはあくまで手法であり、ハードウェアではありません。なぜこのような詳細について把握する必要があるのでしょう。これはきちんとした抽象化がなされていない結果生み出された、言ってみれば妖です。この妖によって余計な手間が生み出され、コーディング量は増大し、余計なバグが生成され、絶望した開発者はうつになり、自殺者は増え、世界は暗雲に包まれるー
そのような混沌の中、ある一筋の光、Thrustが現れました。ThrustはCUDAを抽象化し、C++のパラダイムを用いることで本質にのみ注力できるよう開発されたライブラリです。ユーザはただIteratorに対してアルゴリズムを適用するかの如くdevice_vector<T>と各種アルゴリズムを駆使することで、流れるようなプログラムを組むことが可能となります。このような抽象を用いることで、ユーザは詳細な内部構造について頭を悩ませる必要が無くなりました。誰が書いているのか分からないから使いたくない？ThrustはNVIDIAに所属している開発者Jared HoberockとNathan Bell氏によって書かれています。2人とも並列化のプロフェッショナルなので、普通の人が愚直に実装するよりも大抵の場合効率的でしょう。
さて、Thrustには並列化を行うための多種多様なアルゴリズムが存在しています。そして、Thrustはオープンソースです。これはつまり、このソースコードを読めば並列化のプロがどのようにして各種アルゴリズムの並列化を実装しているのかが分かるということです。
Reductions
ということで、最近はThrustのソースコードをちょくちょく読んでいるところです。まだ読み始めた最中なのですが、特に感動したのはReductionsの項でした。
数々あるSTLのアルゴリズムを普通に実装しようとすると、一つ一つのアルゴリズムすべてに対して、コアレッシングなどのGPGPU特有の問題を回避したコードを記述しなければならず、非常に面倒です。Thrustはこの問題をreduce関数によって解決しました。この関数は並列化が可能なので、これを用いて書かれた関数は自動的に並列化されます。つまり、Thrustはいわば『全から一を返す』アルゴリズムすべてをreduceを用いて記述することによって、冗長な記述を回避しているのです。
このreduceを用いた並列化の実装について簡単に説明していくことが、今回の記事の目的です。reduceを初めて聞いた方は前回の記事『並列環境におけるreduceとscanアルゴリズム』を参照してください。
ここで、本来のThrustはC++によって記述しているのですが、そのままC++で書くと非常に冗長で解り辛くなってしまうので、今回は本質のみを抽出するためHaskellを用いて説明します。あまりHaskellに慣れていないので不適切な書き方等あるかもしれませんが、そのへんはご指摘頂けると幸いです。また、今回のreduceにはfoldr関数を代わりに用いています。分かると思いますが一応。
実装
- max_element, min_element, minmax_element
*Main> max_element [1,3,2,4,3,1] 4 *Main> min_element [1,3,2,4,3,1] 1 *Main> minmax_element [1,3,2,4,3,1] (1,4)ここらへんはまぁ普通に分かります:
max_element :: Ord a => [a] -> a
max_element list = foldr max (head list) list
min_element :: Ord a => [a] -> a
min_element list = foldr min (head list) list
minmax_element :: Ord a => [a] -> (a, a)
minmax_element list = foldr minmax_func (first, first) $ zip list list where
first = head list
minmax_func (min1, max1) (min2, max2) = (min min1 min2, max max1 max2)
- all_of, any_of, none_of
- すべて当てはまっている
- 一つ以上当てはまっている
- すべて当てはまっていない
*Main> all_of (\x -> x > 3) [1,3,2,4,3,1] False *Main> any_of (\x -> x > 3) [1,3,2,4,3,1] True *Main> none_of (\x -> x > 3) [1,3,2,4,3,1] Falseこれも実装的にはらくちん:
all_of :: (a -> Bool) -> [a] -> Bool all_of binary_pred list = foldr (&&) True $ map binary_pred list any_of :: (a -> Bool) -> [a] -> Bool any_of binary_pred list = foldr (||) False $ map binary_pred list none_of :: (a -> Bool) -> [a] -> Bool none_of binary_pred list = all_of (not . binary_pred) list関数合成を用いてエレガントに解決。
- inner_product, transform_reduce
*Main> inner_product (*) (+) 0 [0,1,2] [3,4,5] 14 -- = 0*3 + 1*4 + 2*5 *Main> transform_reduce (\x -> x*2) (+) 0 [1,2,3] 12 -- = 1*2 + 2*2 + 3*2C++だといろいろ冗長に書かないといけないですけど、Haskellだったら余裕です:
inner_product :: (a -> b -> c) -> (c -> c -> c) -> c -> [a] -> [b] -> c
inner_product binary_op1 binary_op2 init list1 list2 =
foldr binary_op2 init $ map operate $ zip list1 list2 where
operate (x, y) = binary_op1 x y
transform_reduce :: (a -> b) -> (b -> b -> b) -> b -> [a] -> b
transform_reduce unary_op binary_op init list =
foldr binary_op init $ map unary_op list
- count_if, count
*Main> count_if (\x -> x < 3) [1,2,3,4,5] 2 *Main> count 3 [1,3,2,2,3] 2
count_if :: (a -> Bool) -> [a] -> Int
count_if binary_pred list = foldr (+) 0 count_list where
count_list = map transform_func list where
transform_func x = if binary_pred x then 1 else 0
count :: Eq a => a -> [a] -> Int
count value list = count_if (== value) list
ThrustではTrueだったら1, Falseだったら0となるリストを作成して、それを足していく手法をとっていました。countはcount_ifが思いつけば楽勝でしょう。
- find_if, find_if_not
*Main> find_if (\x -> x > 3) [1,3,2,5,4] 3 *Main> find_if (\x -> x > 7) [1,3,2,5,4] 5 *Main> find_if_not (\x -> x > 3) [1,3,2,5,4] 0これは微妙に入り組んでいます:
find_if :: (a -> Bool) -> [a] -> Int
find_if binary_pred list = snd result where
result = foldr find (False, length list) tuple_list where
find (b1, i1) (b2, i2)
| b1 && b2 = (True, min i1 i2)
| b1 = (b1, i1)
| b2 = (b2, i2)
| otherwise = (False, max i1 i2)
tuple_list = zip (map binary_pred list) [0..]
find_if_not :: (a -> Bool) -> [a] -> Int
find_if_not binary_pred list = find_if (not . binary_pred) list
ただ、find_ifはちょっと本家と違います。インデックスが小さい項が常に左の引数となるため省略してるんだとは思いますけど、対称性を満たしていないのがちょっと気持ち悪いので、ここでは交換則を満たすように関数を変形しています。実際の実装と課題
ここではhaskellを用いて実装しましたが、もちろん実際の実装は異なっており、zipはzip_iterator, mapはtransform_iterator, タプルはtupleを用いて実装しています。これらのイテレータの評価は遅延的に行われるので、複数のメモリアクセスが発生せず、アルゴリズムの高速化に貢献します。
これらのfancy iteratorを使用した戦略は非常に賢いとは思いますが、同時に欠点もあります。複数のイテレータを大量に組み合わせるために、通常のSTL algorithmのようにbeginとendを使用してしまうと、両方に対してfancy iteratorを組み合わせなければならないため、2倍の手間がかかってしまうのです。
これらの解決案としてはboost::rangeのようなRange構造を実装することです。これをパイプ演算子で繋げていくような形をとっていけば、明快で分かりやすく、速度も十分保証されたプログラムを記述できることでしょう。
