Add locked zipwith code
authorBen Lippmeier <benl@ouroborus.net>
Mon, 29 Oct 2012 03:40:30 +0000 (14:40 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Thu, 1 Nov 2012 00:39:49 +0000 (11:39 +1100)
dph-prim-interface/interface/DPH_Header.h
dph-prim-interface/interface/DPH_Interface.h
dph-prim-par/Data/Array/Parallel/Unlifted/Distributed.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Locked.hs [new file with mode: 0644]
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Locked.hs

index 417a656..059744f 100644 (file)
@@ -46,7 +46,14 @@ module Data.Array.Parallel.Unlifted (
   fsts,  snds,  
 
   -- * Map and ZipWith
-  map, zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zipWith7,  zipWith8, 
+  map,
+  zipWith,      lockedZipWith,
+  zipWith3,     lockedZipWith3,
+  zipWith4,     lockedZipWith4,
+  zipWith5,     lockedZipWith5,
+  zipWith6,     lockedZipWith6,
+  zipWith7,     lockedZipWith7,
+  zipWith8,     lockedZipWith8,
 
   -- * Scans and Folds
   scan,
index eb7bd7c..dbdab25 100644 (file)
@@ -511,8 +511,57 @@ zipWith8 fn as bs cs ds es fs gs hs
   #-}
 
 
--- Folds and Scans ============================================================
+-- == Locked ZipWiths =========================================================
+-- | Apply a worker function to correponding elements of two arrays.
+lockedZipWith :: (Elt a, Elt b, Elt c)
+        => (a -> b -> c) -> Array a -> Array b -> Array c
+{-# INLINE_BACKEND lockedZipWith #-}
+
+
+-- | Apply a worker function to corresponding elements of three arrays.
+lockedZipWith3 :: (Elt a, Elt b, Elt c, Elt d)
+          => (a -> b -> c -> d) -> Array a -> Array b -> Array c -> Array d
+{-# INLINE_BACKEND lockedZipWith3 #-}
+
+
+-- | Apply a worker function to corresponding elements of four arrays.
+lockedZipWith4 :: (Elt a, Elt b, Elt c, Elt d, Elt e)
+         => (a -> b -> c -> d -> e)
+         -> Array a -> Array b -> Array c -> Array d -> Array e
+{-# INLINE_BACKEND lockedZipWith4 #-}
+
+
+-- | Apply a worker function to corresponding elements of five arrays.
+lockedZipWith5 :: (Elt a, Elt b, Elt c, Elt d, Elt e, Elt f)
+         => (a -> b -> c -> d -> e -> f)
+         -> Array a -> Array b -> Array c -> Array d -> Array e -> Array f
+{-# INLINE_BACKEND lockedZipWith5 #-}
+
 
+-- | Apply a worker function to corresponding elements of six arrays.
+lockedZipWith6 :: (Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g)
+         => (a -> b -> c -> d -> e -> f ->g)
+         -> Array a -> Array b -> Array c -> Array d -> Array e -> Array f -> Array g
+{-# INLINE_BACKEND lockedZipWith6 #-}
+
+
+-- | Apply a worker function to corresponding elements of seven arrays.
+lockedZipWith7 :: (Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h)
+         => (a -> b -> c -> d -> e -> f -> g ->h)
+         -> Array a -> Array b -> Array c -> Array d -> Array e -> Array f -> Array g 
+         -> Array h
+{-# INLINE_BACKEND lockedZipWith7 #-}
+
+
+-- | Apply a worker function to corresponding elements of six arrays.
+lockedZipWith8 :: (Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i)
+         => (a -> b -> c -> d -> e -> f -> g ->h -> i)
+         -> Array a -> Array b -> Array c -> Array d -> Array e -> Array f -> Array g 
+         -> Array h -> Array i
+{-# INLINE_BACKEND lockedZipWith8 #-}
+
+
+-- Folds and Scans ============================================================
 -- Scans ------------------------------
 -- | Similar to `foldl` but return an array of the intermediate states, including
 --   the final state that is computed by `foldl`.
index e8b7aa9..a0b107d 100644 (file)
@@ -29,6 +29,7 @@ module Data.Array.Parallel.Unlifted.Distributed
           -- * Distributed pairs
         , zipD, unzipD
         , fstD, sndD
+        , zip3D
 
           -- * Distributed arrays
         , lengthD
@@ -57,6 +58,7 @@ module Data.Array.Parallel.Unlifted.Distributed
 where
 import Data.Array.Parallel.Unlifted.Distributed.Combinators
 import Data.Array.Parallel.Unlifted.Distributed.Data.Bool
+import Data.Array.Parallel.Unlifted.Distributed.Data.Tuple
 import Data.Array.Parallel.Unlifted.Distributed.Data.Scalar
 import Data.Array.Parallel.Unlifted.Distributed.Data.Ordering   ()
 import Data.Array.Parallel.Unlifted.Distributed.Arrays
diff --git a/dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Locked.hs b/dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Locked.hs
new file mode 100644 (file)
index 0000000..66d9bb6
--- /dev/null
@@ -0,0 +1,150 @@
+{-# LANGUAGE CPP #-}
+#include "fusion-phases.h"
+
+-- | Locked zips and zipWiths
+module Data.Array.Parallel.Unlifted.Parallel.Locked
+        ( lockedZipWithUP
+        , lockedZipWith3UP
+        , lockedZipWith4UP
+        , lockedZipWith5UP
+        , lockedZipWith6UP
+        , lockedZipWith7UP
+        , lockedZipWith8UP)
+where
+import Data.Array.Parallel.Unlifted.Sequential
+import Data.Array.Parallel.Unlifted.Distributed
+import Data.Array.Parallel.Unlifted.Distributed.What
+import Data.Array.Parallel.Unlifted.Sequential.Vector as Seq
+
+
+-- Locked ZipWiths ------------------------------------------------------------
+lockedZipWithUP 
+        :: (Unbox a, Unbox b, Unbox c)
+        => (a -> b -> c)
+        -> Vector a -> Vector b 
+        -> Vector c
+
+lockedZipWithUP f as bs
+        = joinD theGang balanced
+        $ mapD  (What "lockedZipWithP") theGang
+                (\(a, b) -> lockedZipWithSU f a b)
+        $ zipD  (splitD theGang balanced as)
+                (splitD theGang balanced bs)
+{-# INLINE_UP lockedZipWithUP #-}
+
+
+lockedZipWith3UP 
+        :: (Unbox a, Unbox b, Unbox c, Unbox d)
+        => (a -> b -> c -> d)
+        -> Vector a -> Vector b -> Vector c
+        -> Vector d
+
+lockedZipWith3UP f as bs cs
+        = joinD theGang balanced
+        $ mapD  (What "lockedWith3P") theGang
+                (\(a, b, c) -> lockedZipWith3SU f a b c)
+        $ zip3D (splitD theGang balanced as)
+                (splitD theGang balanced bs)
+                (splitD theGang balanced cs)
+{-# INLINE_UP lockedZipWith3UP #-}
+
+
+lockedZipWith4UP 
+        :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e)
+        => (a -> b -> c -> d -> e)
+        -> Vector a -> Vector b -> Vector c -> Vector d
+        -> Vector e
+
+lockedZipWith4UP f as bs cs ds
+        = joinD theGang balanced
+        $ mapD  (What "lockedWith4P") theGang
+                (\((a, b), c, d) -> lockedZipWith4SU f a b c d)
+        $ zip3D (zipD   (splitD theGang balanced as)
+                        (splitD theGang balanced bs))
+                (splitD theGang balanced cs)
+                (splitD theGang balanced ds)
+{-# INLINE_UP lockedZipWith4UP #-}
+
+
+lockedZipWith5UP 
+        :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f)
+        => (a -> b -> c -> d -> e -> f)
+        -> Vector a -> Vector b -> Vector c -> Vector d
+        -> Vector e
+        -> Vector f
+
+lockedZipWith5UP fn as bs cs ds es
+        = joinD theGang balanced
+        $ mapD  (What "lockedWith5P") theGang
+                (\((a, b), (c, d), e) -> lockedZipWith5SU fn a b c d e)
+        $ zip3D (zipD   (splitD theGang balanced as)
+                        (splitD theGang balanced bs))
+                (zipD   (splitD theGang balanced cs)
+                        (splitD theGang balanced ds))
+                (splitD theGang balanced es)
+{-# INLINE_UP lockedZipWith5UP #-}
+
+
+lockedZipWith6UP 
+        :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g)
+        => (a -> b -> c -> d -> e -> f -> g)
+        -> Vector a -> Vector b -> Vector c -> Vector d
+        -> Vector e -> Vector f
+        -> Vector g
+
+lockedZipWith6UP fn as bs cs ds es fs
+        = joinD theGang balanced
+        $ mapD  (What "lockedWith6P") theGang
+                (\as bs cs ds es fs -> lockedZip6SU fn)
+        $ splitD theGang balanced
+                (lockedZip6SU as bs cs ds es fs)
+{-# INLINE_UP lockedZipWith6UP #-}
+
+zipWith6D
+
+
+
+lockedZipWith7UP 
+        :: ( Unbox a, Unbox b, Unbox c, Unbox d
+           , Unbox e, Unbox f, Unbox g, Unbox h)
+        => (a -> b -> c -> d -> e -> f -> g -> h)
+        -> Vector a -> Vector b -> Vector c -> Vector d
+        -> Vector e -> Vector f -> Vector g
+        -> Vector h
+
+lockedZipWith7UP fn as bs cs ds es fs gs
+        = joinD theGang balanced
+        $ mapD  (What "lockedWith7P") theGang
+                (\((a, b, c), (d, e), (f, g)) -> lockedZipWith7SU fn a b c d e f g)
+        $ zip3D (zip3D  (splitD theGang balanced as)
+                        (splitD theGang balanced bs)
+                        (splitD theGang balanced cs))
+                (zipD   (splitD theGang balanced ds)
+                        (splitD theGang balanced es))
+                (zipD   (splitD theGang balanced fs)
+                        (splitD theGang balanced gs))
+{-# INLINE_UP lockedZipWith7UP #-}
+
+
+lockedZipWith8UP 
+        :: ( Unbox a, Unbox b, Unbox c, Unbox d
+           , Unbox e, Unbox f, Unbox g, Unbox h, Unbox i)
+        => (a -> b -> c -> d -> e -> f -> g -> h -> i)
+        -> Vector a -> Vector b -> Vector c -> Vector d
+        -> Vector e -> Vector f -> Vector g -> Vector h
+        -> Vector i
+
+lockedZipWith8UP fn as bs cs ds es fs gs hs
+        = joinD theGang balanced
+        $ mapD  (What "lockedWith8P") theGang
+                (\((a, b, c), (d, e), (f, g, h)) -> lockedZipWith8SU fn a b c d e f g h)
+        $ zip3D (zip3D  (splitD theGang balanced as)
+                        (splitD theGang balanced bs)
+                        (splitD theGang balanced cs))
+                (zipD   (splitD theGang balanced ds)
+                        (splitD theGang balanced es))
+                (zip3D  (splitD theGang balanced fs)
+                        (splitD theGang balanced gs)
+                        (splitD theGang balanced hs))
+{-# INLINE_UP lockedZipWith8UP #-}
+
index 2e51001..f5f2d74 100644 (file)
@@ -2,13 +2,13 @@
 #include "fusion-phases.h"
 
 module Data.Array.Parallel.Unlifted.Sequential.Locked
-        ( lockedZip,    lockedZipWith
-        , lockedZip3,   lockedZipWith3
-        , lockedZip4,   lockedZipWith4
-        , lockedZip5,   lockedZipWith5
-        , lockedZip6,   lockedZipWith6
-        , lockedZip7,   lockedZipWith7
-        , lockedZip8,   lockedZipWith8)
+        ( lockedZipSU,    lockedZipWithSU
+        , lockedZip3SU,   lockedZipWith3SU
+        , lockedZip4SU,   lockedZipWith4SU
+        , lockedZip5SU,   lockedZipWith5SU
+        , lockedZip6SU,   lockedZipWith6SU
+        , lockedZip7SU,   lockedZipWith7SU
+        , lockedZip8SU,   lockedZipWith8SU)
 where
 import Data.Array.Parallel.Unlifted.Stream.Locked
 import Data.Vector.Generic               as G
@@ -17,171 +17,171 @@ import Data.Vector.Generic               as G
 -- Locked Zips ----------------------------------------------------------------
 -- | Zip two vectors of the same length.
 --   If they do not have the same length then the result is undefined.
-lockedZip
+lockedZipSU
         :: ( Vector v a, Vector v b
            , Vector v (a, b))
         => v a -> v b
         -> v (a, b)
 
-lockedZip aa bb
+lockedZipSU aa bb
         = unstream $ stream2 aa bb 
-{-# INLINE_U lockedZip #-}
+{-# INLINE_U lockedZipSU #-}
 
 
 -- | Zip three vectors of the same length.
-lockedZip3
+lockedZip3SU
         :: ( Vector v a, Vector v b, Vector v c
            , Vector v (a, b, c))
         => v a -> v b -> v c
         -> v (a, b, c)
 
-lockedZip3 aa bb cc
+lockedZip3SU aa bb cc
         = unstream $ stream3 aa bb cc
-{-# INLINE_U lockedZip3 #-}
+{-# INLINE_U lockedZip3SU #-}
 
 
 -- | Zip four vectors of the same length.
-lockedZip4
+lockedZip4SU
         :: ( Vector v a, Vector v b, Vector v c, Vector v d
            , Vector v (a, b, c, d))
         => v a -> v b -> v c -> v d
         -> v (a, b, c, d)
 
-lockedZip4 aa bb cc dd
+lockedZip4SU aa bb cc dd
         = unstream $ stream4 aa bb cc dd
-{-# INLINE_U lockedZip4 #-}
+{-# INLINE_U lockedZip4SU #-}
 
 
 -- | Zip five vectors of the same length.
-lockedZip5
+lockedZip5SU
         :: ( Vector v a, Vector v b, Vector v c, Vector v d
            , Vector v e
            , Vector v (a, b, c, d, e))
         => v a -> v b -> v c -> v d -> v e
         -> v (a, b, c, d, e)
 
-lockedZip5 aa bb cc dd ee
+lockedZip5SU aa bb cc dd ee
         = unstream $ stream5 aa bb cc dd ee
-{-# INLINE_U lockedZip5 #-}
+{-# INLINE_U lockedZip5SU #-}
 
 
 -- | Zip six vectors of the same length.
-lockedZip6
+lockedZip6SU
         :: ( Vector v a, Vector v b, Vector v c, Vector v d
            , Vector v e, Vector v f
            , Vector v (a, b, c, d, e, f))
         => v a -> v b -> v c -> v d -> v e -> v f
         -> v (a, b, c, d, e, f)
 
-lockedZip6 aa bb cc dd ee ff
+lockedZip6SU aa bb cc dd ee ff
         = unstream $ stream6 aa bb cc dd ee ff
-{-# INLINE_U lockedZip6 #-}
+{-# INLINE_U lockedZip6SU #-}
 
 
 -- | Zip seven vectors of the same length.
-lockedZip7
+lockedZip7SU
         :: ( Vector v a, Vector v b, Vector v c, Vector v d
            , Vector v e, Vector v f, Vector v g
            , Vector v (a, b, c, d, e, f, g))
         => v a -> v b -> v c -> v d -> v e -> v f -> v g
         -> v (a, b, c, d, e, f, g)
 
-lockedZip7 aa bb cc dd ee ff gg
+lockedZip7SU aa bb cc dd ee ff gg
         = unstream $ stream7 aa bb cc dd ee ff gg
-{-# INLINE_U lockedZip7 #-}
+{-# INLINE_U lockedZip7SU #-}
 
 
 -- | Zip eight vectors of the same length.
-lockedZip8
+lockedZip8SU
         :: ( Vector v a, Vector v b, Vector v c, Vector v d
            , Vector v e, Vector v f, Vector v g, Vector v h
            , Vector v (a, b, c, d, e, f, g, h))
         => v a -> v b -> v c -> v d -> v e -> v f -> v g -> v h
         -> v (a, b, c, d, e, f, g, h)
 
-lockedZip8 aa bb cc dd ee ff gg hh
+lockedZip8SU aa bb cc dd ee ff gg hh
         = unstream $ stream8 aa bb cc dd ee ff gg hh
-{-# INLINE_U lockedZip8 #-}
+{-# INLINE_U lockedZip8SU #-}
 
 
 -- Locked ZipWiths ------------------------------------------------------------
-lockedZipWith
+lockedZipWithSU
         :: ( Vector v a, Vector v b, Vector v c
            , Vector v (a, b))
         => (a -> b -> c)
         -> v a -> v b -> v c
 
-lockedZipWith f aa bb
+lockedZipWithSU f aa bb
         = G.map (\(a, b) -> f a b)
-        $ lockedZip aa bb
-{-# INLINE lockedZipWith #-}
+        $ lockedZipSU aa bb
+{-# INLINE lockedZipWithSU #-}
 
 
-lockedZipWith3  
+lockedZipWith3SU  
         :: ( Vector v a, Vector v b, Vector v c, Vector v d
            , Vector v (a, b, c))
         => (a -> b -> c -> d)
         -> v a -> v b -> v c -> v d
 
-lockedZipWith3 f aa bb cc
+lockedZipWith3SU f aa bb cc
         = G.map (\(a, b, c) -> f a b c)
-        $ lockedZip3 aa bb cc
-{-# INLINE lockedZipWith3 #-}
+        $ lockedZip3SU aa bb cc
+{-# INLINE lockedZipWith3SU #-}
 
 
-lockedZipWith4
+lockedZipWith4SU
         :: ( Vector v a, Vector v b, Vector v c, Vector v d
            , Vector v e
            , Vector v (a, b, c, d))
         => (a -> b -> c -> d -> e)
         -> v a -> v b -> v c -> v d -> v e
 
-lockedZipWith4 f aa bb cc dd
+lockedZipWith4SU f aa bb cc dd
         = G.map (\(a, b, c, d) -> f a b c d)
-        $ lockedZip4 aa bb cc dd
-{-# INLINE lockedZipWith4 #-}
+        $ lockedZip4SU aa bb cc dd
+{-# INLINE lockedZipWith4SU #-}
 
 
-lockedZipWith5
+lockedZipWith5SU
         :: ( Vector v a, Vector v b, Vector v c, Vector v d
            , Vector v e, Vector v f
            , Vector v (a, b, c, d, e))
         => (a -> b -> c -> d -> e -> f)
         -> v a -> v b -> v c -> v d -> v e -> v f
 
-lockedZipWith5 f aa bb cc dd ee
+lockedZipWith5SU f aa bb cc dd ee
         = G.map (\(a, b, c, d, e) -> f a b c d e)
-        $ lockedZip5 aa bb cc dd ee
-{-# INLINE lockedZipWith5 #-}
+        $ lockedZip5SU aa bb cc dd ee
+{-# INLINE lockedZipWith5SU #-}
 
 
-lockedZipWith6
+lockedZipWith6SU
         :: ( Vector v a, Vector v b, Vector v c, Vector v d
            , Vector v e, Vector v f, Vector v g
            , Vector v (a, b, c, d, e, f))
         => (a -> b -> c -> d -> e -> f -> g)
         -> v a -> v b -> v c -> v d -> v e -> v f -> v g
 
-lockedZipWith6 fn aa bb cc dd ee ff
+lockedZipWith6SU fn aa bb cc dd ee ff
         = G.map (\(a, b, c, d, e, f) -> fn a b c d e f)
-        $ lockedZip6 aa bb cc dd ee ff
-{-# INLINE lockedZipWith6 #-}
+        $ lockedZip6SU aa bb cc dd ee ff
+{-# INLINE lockedZipWith6SU #-}
 
 
-lockedZipWith7
+lockedZipWith7SU
         :: ( Vector v a, Vector v b, Vector v c, Vector v d
            , Vector v e, Vector v f, Vector v g, Vector v h
            , Vector v (a, b, c, d, e, f, g))
         => (a -> b -> c -> d -> e -> f -> g -> h)
         -> v a -> v b -> v c -> v d -> v e -> v f -> v g -> v h
 
-lockedZipWith7 fn aa bb cc dd ee ff gg
+lockedZipWith7SU fn aa bb cc dd ee ff gg
         = G.map (\(a, b, c, d, e, f, g) -> fn a b c d e f g)
-        $ lockedZip7 aa bb cc dd ee ff gg
-{-# INLINE lockedZipWith7 #-}
+        $ unstream $ stream7 aa bb cc dd ee ff gg
+{-# INLINE lockedZipWith7SU #-}
 
 
-lockedZipWith8
+lockedZipWith8SU
         :: ( Vector v a, Vector v b, Vector v c, Vector v d
            , Vector v e, Vector v f, Vector v g, Vector v h
            , Vector v i
@@ -189,9 +189,9 @@ lockedZipWith8
         => (a -> b -> c -> d -> e -> f -> g -> h -> i)
         -> v a -> v b -> v c -> v d -> v e -> v f -> v g -> v h -> v i
 
-lockedZipWith8 fn aa bb cc dd ee ff gg hh
+lockedZipWith8SU fn aa bb cc dd ee ff gg hh
         = G.map (\(a, b, c, d, e, f, g, h) -> fn a b c d e f g h)
-        $ lockedZip8 aa bb cc dd ee ff gg hh
-{-# INLINE lockedZipWith8 #-}
+        $ lockedZip8SU aa bb cc dd ee ff gg hh
+{-# INLINE lockedZipWith8SU #-}