prestazioni matematica Haskell su multiply-add operazione
-
29-09-2019 - |
Domanda
Sto scrivendo un gioco in Haskell, e il mio attuale passaggio presso l'interfaccia utente comporta un sacco di generazione procedurale della geometria. Attualmente sto concentrato sull'identificazione delle prestazioni di una particolare operazione (C-ish pseudocodice):
Vec4f multiplier, addend;
Vec4f vecList[];
for (int i = 0; i < count; i++)
vecList[i] = vecList[i] * multiplier + addend;
Cioè, una palude-standard di multiply-add di quattro carri allegorici, il tipo di cosa matura per l'ottimizzazione SIMD.
Il risultato sta per un vertex buffer OpenGL, quindi deve ottenere scaricati in una matrice C piatta casualmente. Per lo stesso motivo, i calcoli dovrebbero probabilmente essere fatto su C tipi 'float'.
Ho cercato sia una libreria o una soluzione nativa idiomatica per fare questo genere di cose in fretta in Haskell, ma ogni soluzione che è venuta in mente sembra oscillare intorno al 2% delle prestazioni (cioè, più lento 50x ) rispetto a C da GCC con le bandiere giuste. Certo, ho iniziato con Haskell un paio di settimane fa, quindi la mia esperienza è limitata, è per questo che vengo a voi ragazzi. Chi di voi offrire suggerimenti per una più rapida attuazione Haskell, o puntatori a documentazione su come scrivere ad alte prestazioni codice Haskell?
In primo luogo, la soluzione più recente Haskell (orologi di circa 12 secondi). Ho cercato il colpaccio-patterns roba da questo SO messaggio , ma non ho fatto un AFAICT differenza. Sostituzione 'MoltSomma' con '(\ iv -> v * 4)'. Tempo di esecuzione portato giù a 1,9 secondi, quindi la roba bit a bit (e conseguenti sfide per l'ottimizzazione automatica) non sembra essere troppo in colpa
{-# 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)
Ecco quello che ho in C. Il codice qui ha alcuni #ifdefs che impedisce che venga compilato straight-up; scorrere verso il basso per il test driver.
#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);
}
Questo script compilare ed eseguire i test con un numero di combinazioni gcc bandiera. La migliore prestazione è stata da cmath-64-native-O3-limitare-vector-NOCOPY sul mio sistema, prendendo 0,22 secondi.
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
Soluzione
risponde romana Leschinkskiy:
In realtà, il nucleo guarda soprattutto ok per me. Utilizzando unsafeIndex invece di (!) rende il programma più di due volte veloce ( vedi la mia risposta sopra ). Il il programma di seguito è molto più veloce, anche se (E più pulita, IMO). Ho il sospetto che la restante differenza tra questo e il programma C è dovuto al generale di GHC suckiness quando si tratta di galleggiamento punto. Il HEAD produce la i migliori risultati con la NCG e -msse2
In primo luogo, definire un nuovo tipo di dati 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
assicurarci di poter memorizzare in un array
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
I valori e metodi su questo tipo:
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
Con GHC 6.12.1, -O2 -fasm:
- 1.752
Con TESTA GHC (26 giugno), -O2 -fasm -msse2
- 1.708
Questo appare come il modo più idiomatico per scrivere un array di Vec4, e ottiene la migliore performance (11x più veloce rispetto l'originale). (E questo potrebbe diventare un punto di riferimento per backend LLVM del GHC)
Altri suggerimenti
Bene, questo è meglio. 3.5s invece di 14s.
{-# 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 []
Che è meglio di quanto non fosse:
$ 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
MoltSomma compila bene:
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)
Tuttavia, si sta facendo a 4 elemento alla volta si moltiplica nel codice C, in modo da abbiamo bisogno di farlo direttamente, piuttosto che fingendo dal loop e mascheramento. GCC è probabilmente srotolando il ciclo, anche.
Quindi, per ottenere prestazioni identiche, avremmo bisogno il vettore si moltiplicano (un po 'difficile, eventualmente tramite il backend LLVM) e srotolare il loop (possibilmente fusione di esso). Mi rimetto alla romana qui per vedere se ci sono altre cose ovvie.
Un'idea potrebbe essere di utilizzare effettivamente un vettore Vec4, invece di appiattimento esso.