Resolve conflicts
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Wed, 22 Apr 2009 03:39:22 +0000 (03:39 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Wed, 22 Apr 2009 03:39:22 +0000 (03:39 +0000)
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/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/Segmented.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Segmented/Combinators.hs

index 5be5775..516c22d 100644 (file)
@@ -15,9 +15,8 @@
 #include "fusion-phases.h"
 
 module Data.Array.Parallel.Stream.Segmented (
-  SStream(..),
-  segmentS, foldValuesSS, foldValuesSS', fold1ValuesSS,
-  combineSS, (^+++^)
+  foldSS, fold1SS, combineSS, appendSS,
+  foldValuesR
 ) where
 
 import Data.Array.Parallel.Base (
index 2391cc1..f08df32 100644 (file)
@@ -94,55 +94,14 @@ append_s xd xs yd ys = P.concat (P.zipWith (P.++) (nest xd xs) (nest yd ys))
 
 fold_s  f z segd xs = P.map (P.foldr f z) (nest segd xs)
 fold1_s f   segd xs = P.map (P.foldr1 f)  (nest segd xs)
-
-{-
-concat = P.concat
-(ns, is) >: xs = go ns xs
-  where
-    go [] [] = []
-    go (n : ns) xs = let (ys, zs) = P.splitAt n xs
-                     in ys : go ns zs
-
-(^+:+^) = P.zipWith (+:+)
-
-length_s = P.length
-lengths_s = map length
-replicate_s (lens, _) = zipWith replicate lens
-{-
-repeat_c _ ns segd xs = concat
-                      . concat
-                      . zipWith replicate ns
-                      $ segd >: xs
--}
-
-indices_s = scan (+) 0 . lengths_s
-
-fst_s = map (map fstS)
-snd_s = map (map sndS)
-zip_s = zipWith zip
-
-bpermute_s' = P.error "Not implemented: dph-prim-interface:Data.Array.Parallel.Unlifted.update"
-
-map_s f = map (map f)
-filter_s p = map (filter p)
-pack_c = P.error "Not implemented: dph-prim-interface:Data.Array.Parallel.Unlifted.pack_c"
-combine_c = P.error "Not implemented: dph-prim-interface:Data.Array.Parallel.Unlifted.combine_c"
-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
-
-enumFromThenTo_s = zipWith3 enumFromThenTo
-indexed_s = map indexed
--}
-
-lengthsSegd = P.error "Not implemented: dph-prim-interface:Data.Array.Parallel.Unlifted.lengthsSegd"
-lengthsToSegd  = P.error "Not implemented: dph-prim-interface:Data.Array.Parallel.Unlifted.lengthsToSegd"
-toSegd = unpairS . unzip
-fromSegd = P.error "Not implemented: dph-prim-interface:Data.Array.Parallel.Unlifted.fromSegd"
-
+sum_r _ segSize xs = P.error "FIXME GABI PLEASE PLEASE PLEASE" 
+
+lengthSegd = length . lengthsSegd
+lengthsSegd = segd_lengths
+indicesSegd = segd_indices
+elementsSegd = segd_elements
+lengthsToSegd lens = Segd lens (scan (+) 0 lens) (sum lens)
+mkSegd = Segd
 
 class Elt a => IOElt a
 hPut = P.error "Not implemented: dph-prim-interface:Data.Array.Parallel.Unlifted.hPut"
index 3013687..dcb1e49 100644 (file)
@@ -19,18 +19,8 @@ module Data.Array.Parallel.Unlifted (
 
   repeat_c,
 
-  fold_s, fold1_s, sum_s,
-  indices_s,
-  {-
-  (>:), concat, (^+:+^), length_s, lengths_s, replicate_s,
-  repeat_c, indices_s,
-  fst_s, snd_s, zip_s,
-  bpermute_s', map_s, filter_s, pack_c, combine_c, zipWith_s,
-  indexed_s,
-  fold_s, fold_s', fold1_s, sum_s,
-  enumFromThenTo_s,
-  -}
-  lengthsSegd, lengthsToSegd, toSegd, fromSegd,
+  fold_s, fold1_s, sum_s, indices_s, sum_r,
+  lengthSegd, lengthsSegd, indicesSegd, elementsSegd, lengthsToSegd, mkSegd,
 
   randoms, randomRs, IOElt, hGet, hPut,
 
index 6c46dfb..680c129 100644 (file)
@@ -152,23 +152,8 @@ sum_s :: (Num a, Elt a) => Segd -> Array a -> Array a
 {-# INLINE sum_s #-}
 sum_s = fold_s (Prelude.+) 0
 
-{-
-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 #-}
-
-sum_s :: (Num a, Elt a) => SArray a -> Array a
-{-# INLINE_BACKEND sum_s #-}
-
-
-enumFromThenTo_s :: Array Int -> Array Int -> Array Int -> SArray Int
-{-# INLINE_BACKEND enumFromThenTo_s #-}
--}
+sum_r :: (Num a, Elt a) => Int -> Int ->Array a -> Array a
+{-# INLINE_BACKEND sum_r #-}
 
 indices_s :: Int    -- ^ number of segments
           -> Segd   -- ^ segment descriptor
index 1d62652..2b97eea 100644 (file)
@@ -54,10 +54,9 @@ replicate_s = replicateSUP
 append_s = U.appendSU
 fold_s = foldSUP
 fold1_s = fold1SU
-sum_s = sumSUP
-enumFromThenTo_s = enumFromThenToSUP
-indexed_s = indexedSUP
--}
+sum_r = sumRUP
+
+lengthSegd = lengthUSegd
 lengthsSegd = lengthsUSegd
 indicesSegd = indicesUSegd
 elementsSegd = elementsUSegd
index 831fd73..d642f93 100644 (file)
@@ -22,10 +22,11 @@ module Data.Array.Parallel.Unlifted.Parallel (
 
   andUP, sumUP,
   
-  replicateSUP, foldSUP, sumSUP,
+  replicateSUP, foldSUP, sumSUP, sumRUP,
 
-  indexedUP, replicateUP, replicateEachUP, replicateEachUnbalancedUP, repeatUP,
+  indexedUP, replicateUP, repeatUP,
 
+  dropUP
 ) where
 
 import Data.Array.Parallel.Unlifted.Parallel.Permute
index 23c3e86..213804c 100644 (file)
@@ -18,9 +18,7 @@
 #include "fusion-phases.h"
 
 module Data.Array.Parallel.Unlifted.Parallel.Segmented (
-  mapSUP, filterSUP, packCUP, combineCUP,
-  zipWithSUP, foldlSUP, foldlSUP', foldSUP, foldSUP', sumSUP, bpermuteSUP',
-  enumFromThenToSUP, replicateSUP, replicateCUP, repeatCUP, indexedSUP, jsTest
+  replicateSUP, foldlSUP, foldSUP, sumSUP, sumRUP
 ) where
 
 import Data.Array.Parallel.Unlifted.Sequential
@@ -98,4 +96,4 @@ foldRUP f z  noOfSegs segSize xs =
       (splitLenD theGang noOfSegs)
       (splitAsD theGang 
                 (mapD theGang (*segSize) (splitLenD theGang noOfSegs))
-                xs))
\ No newline at end of file
+                xs))
index 4185018..6af756e 100644 (file)
@@ -52,10 +52,9 @@ replicate_s = replicateSU
 append_s = appendSU
 fold_s = foldSU
 fold1_s = fold1SU
-sum_s = sumSU
-enumFromThenTo_s = enumFromThenToSU
-indexed_s = indexedSU
--}
+sum_r = sumRU
+
+lengthSegd = lengthUSegd
 lengthsSegd = lengthsUSegd
 indicesSegd = indicesUSegd
 elementsSegd = elementsUSegd
index 444d108..7b2f8f2 100644 (file)
@@ -21,36 +21,9 @@ module Data.Array.Parallel.Unlifted.Sequential.Segmented (
   replicateSU, appendSU,
 
   foldlSU, foldSU, fold1SU,
+  foldlRU,
+  combineSU,
 
-  -- * Basic operations
-  lengthSU, singletonSU, singletonsSU, replicateSU,
-  sliceIndexSU, extractIndexSU,
-  replicateCU, repeatCU, (!:^),
-  indexedSU, appendSU,
-
-  -- * Basic operations lifted
-  lengthsSU, indicesSU,
-
-  -- * Subarrays
-  sliceSU, extractSU, takeCU, dropCU,
-
-  -- * Zipping
-  fstSU, sndSU, zipSU,
-
-  -- * Permutations
-  bpermuteSU, bpermuteSU',
-
-  -- * Higher-order operations
-  mapSU, zipWithSU,
-  {-concatMapU,-}
-  foldlSU, foldlSU', foldSU, foldSU',
-  fold1SU, fold1SU',
-  {-scanSU, scan1SU,-}
-
-  -- filter and combines
-  filterSU, packCU, 
-
-  combineSU, combineCU,
   -- * Logical operations
   andSU, orSU,
 
index 4d777a8..bf0d4e2 100644 (file)
 #include "fusion-phases.h"
 
 module Data.Array.Parallel.Unlifted.Sequential.Segmented.Combinators (
-  mapSU, zipWithSU,
-  foldlSU, foldlSU', foldSU, foldSU', foldl1SU, fold1SU, {-scanSU,-} {-scan1SU,-}
-  combineSU, combineCU,
-  filterSU, packCU
+  foldlSU, foldSU, foldl1SU, fold1SU, {-scanSU,-} {-scan1SU,-}
+  foldlRU,
+  combineSU
 ) where
 
 import Data.Array.Parallel.Base (
   sndS)
 import Data.Array.Parallel.Stream (
-  foldSS, fold1SS, combineSS )
+  foldSS, fold1SS, combineSS, foldValuesR )
 import Data.Array.Parallel.Unlifted.Sequential.Flat (
   UA, UArr, mapU, zipWithU,
   unstreamU, streamU)
@@ -100,3 +99,4 @@ packCU flags xssArr = segmentArrU newLengths flatData
 foldlRU :: (UA a, UA b) => (b -> a -> b) -> b -> Int -> Int -> UArr a -> UArr b
 {-# INLINE_U foldlRU #-}
 foldlRU f z noOfSegs segSize = unstreamU . foldValuesR f z noOfSegs segSize . streamU
+