Add fold{_s|SU|SUP}' which is strict in the segd and the data array
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 9 Mar 2009 10:22:24 +0000 (10:22 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 9 Mar 2009 10:22:24 +0000 (10:22 +0000)
13 files changed:
dph-base/Data/Array/Parallel/Stream/Segmented.hs
dph-prim-interface/Data/Array/Parallel/Unlifted.hs
dph-prim-interface/interface/DPH_Header.h
dph-prim-interface/interface/DPH_Interface.h
dph-prim-par/Data/Array/Parallel/Unlifted.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Distributed.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Distributed/Arrays.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Segmented.hs
dph-prim-seq/Data/Array/Parallel/Unlifted.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Segmented.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Segmented/Combinators.hs

index 70edb97..5a4e6ae 100644 (file)
@@ -18,7 +18,7 @@
 
 module Data.Array.Parallel.Stream.Segmented (
   SStream(..),
-  segmentS, foldValuesSS, fold1ValuesSS,
+  segmentS, foldValuesSS, foldValuesSS', fold1ValuesSS,
   combineSS, (^+++^)
 ) where
 
index 3d26557..929e8c8 100644 (file)
@@ -106,6 +106,7 @@ combine_c = P.error "Not implemented: dph-prim-interface:Data.Array.Parallel.Unl
 zipWith_s f = zipWith (zipWith f)
 
 fold_s f z = map (fold f z)
+fold_s' f z segd xs = map (fold f z) (segd >: xs)
 fold1_s f = map (fold1 f)
 sum_s = map sum
 
index 1c4fd10..1c4e018 100644 (file)
@@ -20,7 +20,7 @@ module Data.Array.Parallel.Unlifted (
   fst_s, snd_s, zip_s,
   bpermute_s', map_s, filter_s, pack_c, combine_c, zipWith_s,
   indexed_s,
-  fold_s, fold1_s, sum_s,
+  fold_s, fold_s', fold1_s, sum_s,
   enumFromThenTo_s,
   lengthsSegd, lengthsToSegd, toSegd, fromSegd,
 
index 521432c..96dd8ea 100644 (file)
@@ -176,6 +176,9 @@ zipWith_s :: (Elt a, Elt b, Elt c)
 fold_s :: Elt a => (a -> a -> a) -> a -> SArray a -> Array a
 {-# INLINE_BACKEND fold_s #-}
 
+fold_s' :: Elt a => (a -> a -> a) -> a -> Segd -> Array a -> Array a
+{-# INLINE_BACKEND fold_s' #-}
+
 fold1_s :: Elt a => (a -> a -> a) -> SArray a -> Array a
 {-# INLINE_BACKEND fold1_s #-}
 
index dd217aa..ffbaa87 100644 (file)
@@ -67,6 +67,7 @@ pack_c = packCUP
 combine_c = combineCUP
 zipWith_s = zipWithSUP
 fold_s = foldSUP
+fold_s' = foldSUP'
 fold1_s = fold1SU
 sum_s = sumSUP
 enumFromThenTo_s = enumFromThenToSUP
index 3c203cb..509b240 100644 (file)
@@ -43,7 +43,7 @@ module Data.Array.Parallel.Unlifted.Distributed (
   permuteD, bpermuteD, atomicUpdateD, bpermuteSD',
 
   -- * Distributed segmented arrays
-  splitSD, joinSD, splitJoinSD,
+  splitSD, splitSD', joinSD, splitJoinSD,
 
   -- * Debugging
   fromD, toD
index 742f71c..92feb46 100644 (file)
@@ -20,7 +20,7 @@
 module Data.Array.Parallel.Unlifted.Distributed.Arrays (
   lengthD, splitLenD, splitLengthD, splitSegdLengthsD,
   splitAsD, splitD, joinLengthD, joinD, splitJoinD,
-  splitAsSegdD, splitNestedD, splitSD, joinSD, splitJoinSD,
+  splitAsSegdD, splitNestedD, splitSD, splitSD', joinSD, splitJoinSD,
 
   permuteD, bpermuteD, atomicUpdateD, bpermuteSD',
 
index 0f0038b..5bd26b5 100644 (file)
@@ -22,7 +22,7 @@ module Data.Array.Parallel.Unlifted.Parallel (
 
   andUP, sumUP,
   
-  mapSUP, filterSUP, packCUP, combineCUP, zipWithSUP, foldSUP, sumSUP,
+  mapSUP, filterSUP, packCUP, combineCUP, zipWithSUP, foldSUP, foldSUP', sumSUP,
   bpermuteSUP', enumFromThenToSUP, replicateSUP, indexedSUP, jsTest,
 
   indexedUP, replicateUP, replicateEachUP, replicateEachUnbalancedUP, repeatUP,
index fe070a2..bde2206 100644 (file)
@@ -19,7 +19,7 @@
 
 module Data.Array.Parallel.Unlifted.Parallel.Segmented (
   mapSUP, filterSUP, packCUP, combineCUP,
-  zipWithSUP, foldlSUP, foldSUP, sumSUP, bpermuteSUP',
+  zipWithSUP, foldlSUP, foldlSUP', foldSUP, foldSUP', sumSUP, bpermuteSUP',
   enumFromThenToSUP, replicateSUP, replicateCUP, indexedSUP, jsTest
 ) where
 
@@ -92,10 +92,20 @@ foldlSUP f z = joinD   theGang unbalanced
              . mapD    theGang (foldlSU f z)
              . splitSD theGang unbalanced
 
+foldlSUP' :: (UA a, UA b) => (b -> a -> b) -> b -> USegd -> UArr a -> UArr b
+{-# INLINE foldlSUP' #-}
+foldlSUP' f z segd xs = joinD theGang unbalanced
+                       (mapD theGang (foldlSU f z)
+                       (splitSD' theGang unbalanced segd xs))
+
 foldSUP :: (UA a, UA b) => (b -> a -> b) -> b -> SUArr a -> UArr b
 {-# INLINE foldSUP #-}
 foldSUP = foldlSUP
 
+foldSUP' :: (UA a, UA b) => (b -> a -> b) -> b -> USegd -> UArr a -> UArr b
+{-# INLINE foldSUP' #-}
+foldSUP' = foldlSUP'
+
 sumSUP :: (Num e, UA e) => SUArr e -> UArr e
 {-# INLINE sumSUP #-}
 sumSUP = foldSUP (+) 0
index 2377796..2ce131a 100644 (file)
@@ -65,6 +65,7 @@ pack_c = packCU
 combine_c = combineCU
 zipWith_s = zipWithSU
 fold_s = foldSU
+fold_s' = foldSU'
 fold1_s = fold1SU
 sum_s = sumSU
 enumFromThenTo_s = enumFromThenToSU
index edb591e..0caa2f6 100644 (file)
@@ -111,7 +111,7 @@ module Data.Array.Parallel.Unlifted.Sequential (
   -- * Higher-order operations (segmented)
   mapSU, zipWithSU,
   {-concatMapU,-}
-  foldlSU, foldSU,
+  foldlSU, foldlSU', foldSU, foldSU',
   fold1SU,
   {-scanSU, scan1SU,-}
 
index a373858..107f6c5 100644 (file)
@@ -48,7 +48,7 @@ module Data.Array.Parallel.Unlifted.Sequential.Segmented (
   -- * Higher-order operations
   mapSU, zipWithSU,
   {-concatMapU,-}
-  foldlSU, foldSU,
+  foldlSU, foldlSU', foldSU, foldSU',
   fold1SU,
   {-scanSU, scan1SU,-}
 
index 7c486ee..cd1c6dd 100644 (file)
 
 module Data.Array.Parallel.Unlifted.Sequential.Segmented.Combinators (
   mapSU, zipWithSU,
-  foldlSU, foldSU, foldl1SU, fold1SU, {-scanSU,-} {-scan1SU,-}
+  foldlSU, foldlSU', foldSU, foldSU', foldl1SU, fold1SU, {-scanSU,-} {-scan1SU,-}
   combineSU, combineCU,
   filterSU, packCU
 ) where
 
 import Data.Array.Parallel.Base (
   sndS)
-import Data.Array.Parallel.Stream (
-  Stream, SStream, mapS, foldValuesSS, fold1ValuesSS, combineSS)
+import Data.Array.Parallel.Stream
 import Data.Array.Parallel.Unlifted.Sequential.Flat (
   UA, UArr, mapU, zipWithU,
   unstreamU, streamU)
 import Data.Array.Parallel.Unlifted.Sequential.Segmented.SUArr (
-  SUArr, segdSU, concatSU, (>:), lengthsSU, lengthsToUSegd)
+  SUArr, USegd, segdSU, concatSU, (>:), lengthsSU, lengthsUSegd, lengthsToUSegd)
 import Data.Array.Parallel.Unlifted.Sequential.Segmented.Basics (
   concatSU, segmentArrU,segmentU, replicateSU)
 import Data.Array.Parallel.Unlifted.Sequential.Segmented.Stream (
@@ -61,12 +60,21 @@ foldlSU :: (UA a, UA b) => (b -> a -> b) -> b -> SUArr a -> UArr b
 {-# INLINE_U foldlSU #-}
 foldlSU f z = unstreamU . foldValuesSS f z . streamSU
 
+foldlSU' :: (UA a, UA b) => (b -> a -> b) -> b -> USegd -> UArr a -> UArr b
+{-# INLINE_U foldlSU' #-}
+foldlSU' f z segd xs = unstreamU
+                      (foldValuesSS' f z (streamU (lengthsUSegd segd))
+                                         (streamU xs))
+
 -- |Segmented array reduction that requires an associative combination
 -- function with its unit
 --
 foldSU :: UA a => (a -> a -> a) -> a -> SUArr a -> UArr a
 foldSU = foldlSU
 
+foldSU' :: UA a => (a -> a -> a) -> a -> USegd -> UArr a -> UArr a
+foldSU' = foldlSU'
+
 -- |Segmented array reduction from left to right with non-empty subarrays only
 --
 foldl1SU :: UA a => (a -> a -> a) -> SUArr a -> UArr a