Haskell parallele Programmierung

Question

import Data.List 

genkstrings :: Int -> [String] -> [String] 
genkstrings k [] = [] 
genkstrings 1 (s:ss) = [ [c] | c <- s ] ++ genkstrings 1 ss 
genkstrings k (s:ss) 
    | length (s:ss) < k = [] 
    | otherwise = concat [kStartWith k c ss | c <- s ] 
       ++ 
       genkstrings k ss 

kStartWith k c ss = 
map (c :) $ genkstringsNogap (k-1) ss 

genkstringsNogap 0 _ = [] 
genkstringsNogap 1 (s:ss) = [ [c] | c <- s ] 
genkstringsNogap k (s:ss) = concat $ [kStartWithNoGap k c ss | c <- s ] 

kStartWithNoGap k c ss = map (c:) (genkstringsNogap (k-1) ss) 

Eingang: genkstrings 2 ["sds","ghghg"]

Ausgang:

["sg","sh","sg","sh","sg","dg","dh","dg","dh","dg","sg","sh","sg","sh","sg"] 

ich Haskell lerne und ich fand ich meinen Code parallel laufen. Ich habe einige Beispiele in den Büchern gefunden, die ich lese, aber ich verstehe nicht, wie ich es parallel programmieren kann.

wenn ich richtig bin, ich sollte es auf dieser Linie gelten

| otherwise = concat [kStartWith k c ss | c <- s ] 
        ++ 
        genkstrings k ss 

Wie kann ich es tun?

Answer 1

Ich habe Ihren Beitrag jetzt gesehen. Es gibt viele Möglichkeiten, ein paralleles Computing zu erstellen.

Sie könnten diese drei Bibliotheken lesen:

Control.Parallel

Control.Parallel.Strategies

Control.Monad.Par (für Monaden)

Dann benutze ich zwei Möglichkeiten zu nutzen:

right `par` 
left `pseq` 
left ++ right 

und

result `using` strategy 
    where 
    result = losort ++ (x:hisort) 
    losort = quicksortP1 [y|y <- xs, y < x] 
    hisort = quicksortP1 [y|y <- xs, y >= x] 
    strategy = parList rseq 

hier einige Ergebnisse:

-- parList rpar  -- 2m42s N=4 
-- parList rseq  -- 38.3s N=4 
-- parList r0  -- 57.3s N=4 
-- parList rdeepseq -- 2m40s N=4 
-- r0    -- 48.5s N=4 

und wenn Sie tief :)

result = losort ++ (x:hisort) 
    (losort,hisort) = 
     (quicksortP2 [y|y <- xs, y < x] 
     , quicksortP2 [y|y <- xs, y >= x] 
    ) `using` strategy 
    strategy = 
      parTuple2 rdeepseq rdeepseq -- 17.9s N=4 
--    parTuple2 rdeepseq rseq -- 18.0s N=4    
--    parTuple2 rdeepseq r0 -- 42s N=4 
--    parTuple2 rseq  rseq -- 23.8s N=4 
--    parTuple2 rpar  rpar -- 26.9s N=4 
--    parTuple2 r0  r0 -- 47.6s N=4 
--    r0      -- 46.2s N=4 

wo N ist die Anzahl der Prozessoren habe ich zu bekommen.

Also, wenn Sie es wissen, könnten Sie es leicht anpassen.

Und zum Kompilieren:

> ghc MyProg.hs -threaded -rtsopts 
> ./MyProg +RTS -N4 -s 

Ich hoffe, dass mir jemand helfen kann.