Multiply-ADD操作のHaskell Math Performance
https://stackoverflow.com/questions/3115540
-
29-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian質問
私はHaskellでゲームを書いています。UIでの現在のパスには、多くの手続き的な生成のジオメトリが含まれます。私は現在、1つの特定の操作（C-Ish Pseudocode）のパフォーマンスを特定することに焦点を当てています。
Vec4f multiplier, addend;
Vec4f vecList[];
for (int i = 0; i < count; i++)
vecList[i] = vecList[i] * multiplier + addend;
つまり、4つのフロートの沼地標準の増加が、SIMDの最適化に熟したものです。
その結果、OpenGL Vertexバッファーになるため、最終的にはフラットCアレイに投棄する必要があります。同じ理由で、計算はおそらくc 'float'型で行う必要があります。
ハスケルでこの種のことをすばやく行うために、ライブラリまたはネイティブの慣用的なソリューションのいずれかを探しましたが、私が思いついたすべての解決策は、パフォーマンスの約2％（つまり、50倍遅い）と比較してホバリングしているようです。 c右フラグを持つGCCからのc。確かに、私は数週間前にHaskellから始めたので、私の経験は限られています。それが私があなたたちのところに来る理由です。より高速なHaskellの実装や、高性能のHaskellコードの作成方法に関するドキュメントのポインターのための提案を提供できますか？
まず、最新のHaskellソリューション（約12秒時計）。 Bang-Patternsのものを試しました これは投稿です, 、しかし、それは違いを生み出しませんでした。 「MultADD」を「 IV - > V * 4）に置き換えると、実行時間が1.9秒になりました。したがって、ビットワイズのもの（および自動最適化に対する結果の課題）は、過大なことではないようです。
{-# LANGUAGE BangPatterns #-}
{-# OPTIONS_GHC -O2 -fvia-C -optc-O3 -fexcess-precision -optc-march=native #-}
import Data.Vector.Storable
import qualified Data.Vector.Storable as V
import Foreign.C.Types
import Data.Bits
repCount = 10000
arraySize = 20000
a = fromList $ [0.2::CFloat, 0.1, 0.6, 1.0]
m = fromList $ [0.99::CFloat, 0.7, 0.8, 0.6]
multAdd :: Int -> CFloat -> CFloat
multAdd !i !v = v * (m ! (i .&. 3)) + (a ! (i .&. 3))
multList :: Int -> Vector CFloat -> Vector CFloat
multList !count !src
| count <= 0 = src
| otherwise = multList (count-1) $ V.imap multAdd src
main = do
print $ Data.Vector.Storable.sum $ multList repCount $
Data.Vector.Storable.replicate (arraySize*4) (0::CFloat)
Cにあるものは次のとおりです。ここのコードには、まっすぐにコンパイルされないようにする#ifdefsがいくつかあります。テストドライバーのスクロールを下にスクロールします。
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
typedef float v4fs __attribute__ ((vector_size (16)));
typedef struct { float x, y, z, w; } Vector4;
void setv4(v4fs *v, float x, float y, float z, float w) {
float *a = (float*) v;
a[0] = x;
a[1] = y;
a[2] = z;
a[3] = w;
}
float sumv4(v4fs *v) {
float *a = (float*) v;
return a[0] + a[1] + a[2] + a[3];
}
void vecmult(v4fs *MAYBE_RESTRICT s, v4fs *MAYBE_RESTRICT d, v4fs a, v4fs m) {
for (int j = 0; j < N; j++) {
d[j] = s[j] * m + a;
}
}
void scamult(float *MAYBE_RESTRICT s, float *MAYBE_RESTRICT d,
Vector4 a, Vector4 m) {
for (int j = 0; j < (N*4); j+=4) {
d[j+0] = s[j+0] * m.x + a.x;
d[j+1] = s[j+1] * m.y + a.y;
d[j+2] = s[j+2] * m.z + a.z;
d[j+3] = s[j+3] * m.w + a.w;
}
}
int main () {
v4fs a, m;
v4fs *s, *d;
setv4(&a, 0.2, 0.1, 0.6, 1.0);
setv4(&m, 0.99, 0.7, 0.8, 0.6);
s = calloc(N, sizeof(v4fs));
d = s;
double start = clock();
for (int i = 0; i < M; i++) {
#ifdef COPY
d = malloc(N * sizeof(v4fs));
#endif
#ifdef VECTOR
vecmult(s, d, a, m);
#else
Vector4 aa = *(Vector4*)(&a);
Vector4 mm = *(Vector4*)(&m);
scamult((float*)s, (float*)d, aa, mm);
#endif
#ifdef COPY
free(s);
s = d;
#endif
}
double end = clock();
float sum = 0;
for (int j = 0; j < N; j++) {
sum += sumv4(s+j);
}
printf("%-50s %2.5f %f\n\n", NAME,
(end - start) / (double) CLOCKS_PER_SEC, sum);
}
このスクリプトは、多くのGCCフラグの組み合わせでテストをコンパイルして実行します。最高のパフォーマンスは、私のシステムでCMATH-64-NATINA-O3-RESTRICT-VECTOR-NOCOPYによって、0.22秒かかりました。
import System.Process
import GHC.IOBase
cBase = ("cmath", "gcc mult.c -ggdb --std=c99 -DM=10000 -DN=20000")
cOptions = [
[("32", "-m32"), ("64", "-m64")],
[("generic", ""), ("native", "-march=native -msse4")],
[("O1", "-O1"), ("O2", "-O2"), ("O3", "-O3")],
[("restrict", "-DMAYBE_RESTRICT=__restrict__"),
("norestrict", "-DMAYBE_RESTRICT=")],
[("vector", "-DVECTOR"), ("scalar", "")],
[("copy", "-DCOPY"), ("nocopy", "")]
]
-- Fold over the Cartesian product of the double list. Probably a Prelude function
-- or two that does this, but hey. The 'perm' referred to permutations until I realized
-- that this wasn't actually doing permutations. '
permfold :: (a -> a -> a) -> a -> [[a]] -> [a]
permfold f z [] = [z]
permfold f z (x:xs) = concat $ map (\a -> (permfold f (f z a) xs)) x
prepCmd :: (String, String) -> (String, String) -> (String, String)
prepCmd (name, cmd) (namea, cmda) =
(name ++ "-" ++ namea, cmd ++ " " ++ cmda)
runCCmd name compileCmd = do
res <- system (compileCmd ++ " -DNAME=\\\"" ++ name ++ "\\\" -o " ++ name)
if res == ExitSuccess
then do system ("./" ++ name)
return ()
else putStrLn $ name ++ " did not compile"
main = do
mapM_ (uncurry runCCmd) $ permfold prepCmd cBase cOptions
解決
Roman Leschinkskiyは答えます：
実際、コアは私にはほとんど大丈夫に見えます。 （！）の代わりにunsafeindexを使用すると、プログラムは2倍以上速くなります（上記の私の答えを参照してください）。以下のプログラムは、はるかに高速です（そして、よりクリーン、IMO）。このプログラムとCプログラムの残りの違いは、変動点に関してはGHCの一般的な吸血によるものだと思います。頭はNCGで最高の結果をもたらし、 -msse2
まず、新しいVEC4データ型を定義します。
{-# LANGUAGE BangPatterns #-}
import Data.Vector.Storable
import qualified Data.Vector.Storable as V
import Foreign
import Foreign.C.Types
-- Define a 4 element vector type
data Vec4 = Vec4 {-# UNPACK #-} !CFloat
{-# UNPACK #-} !CFloat
{-# UNPACK #-} !CFloat
{-# UNPACK #-} !CFloat
アレイに保存できることを確認してください
instance Storable Vec4 where
sizeOf _ = sizeOf (undefined :: CFloat) * 4
alignment _ = alignment (undefined :: CFloat)
{-# INLINE peek #-}
peek p = do
a <- peekElemOff q 0
b <- peekElemOff q 1
c <- peekElemOff q 2
d <- peekElemOff q 3
return (Vec4 a b c d)
where
q = castPtr p
{-# INLINE poke #-}
poke p (Vec4 a b c d) = do
pokeElemOff q 0 a
pokeElemOff q 1 b
pokeElemOff q 2 c
pokeElemOff q 3 d
where
q = castPtr p
このタイプの値と方法：
a = Vec4 0.2 0.1 0.6 1.0
m = Vec4 0.99 0.7 0.8 0.6
add :: Vec4 -> Vec4 -> Vec4
{-# INLINE add #-}
add (Vec4 a b c d) (Vec4 a' b' c' d') = Vec4 (a+a') (b+b') (c+c') (d+d')
mult :: Vec4 -> Vec4 -> Vec4
{-# INLINE mult #-}
mult (Vec4 a b c d) (Vec4 a' b' c' d') = Vec4 (a*a') (b*b') (c*c') (d*d')
vsum :: Vec4 -> CFloat
{-# INLINE vsum #-}
vsum (Vec4 a b c d) = a+b+c+d
multList :: Int -> Vector Vec4 -> Vector Vec4
multList !count !src
| count <= 0 = src
| otherwise = multList (count-1) $ V.map (\v -> add (mult v m) a) src
main = do
print $ Data.Vector.Storable.sum
$ Data.Vector.Storable.map vsum
$ multList repCount
$ Data.Vector.Storable.replicate arraySize (Vec4 0 0 0 0)
repCount, arraySize :: Int
repCount = 10000
arraySize = 20000
GHC 6.12.1、-O2 -FASM：
- 1.752
GHCヘッド（6月26日）、-O2 -FASM -msse2
- 1.708
これは、VEC4アレイを書くための最も慣用的な方法のように見え、最高のパフォーマンスを取得します（オリジナルより11倍高速）。 （そして、これはGHCのLLVMバックエンドのベンチマークになる可能性があります）
他のヒント
まあ、これはより良いです。 14秒ではなく3.5秒。
{-# LANGUAGE BangPatterns #-}
{-
-- multiply-add of four floats,
Vec4f multiplier, addend;
Vec4f vecList[];
for (int i = 0; i < count; i++)
vecList[i] = vecList[i] * multiplier + addend;
-}
import qualified Data.Vector.Storable as V
import Data.Vector.Storable (Vector)
import Data.Bits
repCount, arraySize :: Int
repCount = 10000
arraySize = 20000
a, m :: Vector Float
a = V.fromList [0.2, 0.1, 0.6, 1.0]
m = V.fromList [0.99, 0.7, 0.8, 0.6]
multAdd :: Int -> Float -> Float
multAdd i v = v * (m `V.unsafeIndex` (i .&. 3)) + (a `V.unsafeIndex` (i .&. 3))
go :: Int -> Vector Float -> Vector Float
go n s
| n <= 0 = s
| otherwise = go (n-1) (f s)
where
f = V.imap multAdd
main = print . V.sum $ go repCount v
where
v :: Vector Float
v = V.replicate (arraySize * 4) 0
-- ^ a flattened Vec4f []
これは以下よりも優れています。
$ ghc -O2 --make A.hs
[1 of 1] Compiling Main ( A.hs, A.o )
Linking A ...
$ time ./A
516748.13
./A 3.58s user 0.01s system 99% cpu 3.593 total
MultADDコンパイルはうまくコンパイルされています：
case readFloatOffAddr#
rb_aVn
(word2Int#
(and# (int2Word# sc1_s1Yx) __word 3))
realWorld#
of _ { (# s25_X1Tb, x4_X1Te #) ->
case readFloatOffAddr#
rb11_X118
(word2Int#
(and# (int2Word# sc1_s1Yx) __word 3))
realWorld#
of _ { (# s26_X1WO, x5_X20B #) ->
case writeFloatOffAddr#
@ RealWorld
a17_s1Oe
sc3_s1Yz
(plusFloat#
(timesFloat# x3_X1Qz x4_X1Te) x5_X20B)
ただし、Cコードでは一度に4要素を掛けているので、ループとマスキングでそれを偽造するのではなく、直接それを行う必要があります。 GCCはおそらくループを展開しています。
そのため、同一のパフォーマンスを取得するには、ベクトルの乗算（LLVMバックエンドを介して少し硬く）が必要になり、ループを展開します（おそらく融合）。ここでローマに延期して、他の明らかなことがあるかどうかを確認します。
1つのアイデアは、ベクトルVEC4を実際に平らにするのではなく、実際に使用することです。
