dph-prim-seq: cleanup USegd namespace
authorBen Lippmeier <benl@ouroborus.net>
Tue, 4 Oct 2011 08:25:11 +0000 (19:25 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Tue, 4 Oct 2011 08:25:11 +0000 (19:25 +1100)
dph-prim-seq/Data/Array/Parallel/Unlifted.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Basics.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Combinators.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/USSegd.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/USegd.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/UVSegd.hs

index 6a9f42a..488b6bd 100644 (file)
@@ -18,8 +18,8 @@ import Data.Array.Parallel.Unlifted.Sequential.USel
 import Data.Array.Parallel.Unlifted.Sequential.Basics
 import Data.Array.Parallel.Unlifted.Sequential.Combinators
 import Data.Array.Parallel.Unlifted.Sequential.Sums
-import Data.Array.Parallel.Unlifted.Sequential.USegd
 import Data.Array.Parallel.Unlifted.Sequential.USel
+import qualified Data.Array.Parallel.Unlifted.Sequential.USegd  as USegd
 import Data.Array.Parallel.Unlifted.Sequential.USSegd
 import Data.Array.Parallel.Unlifted.Sequential.UVSegd
 
@@ -115,15 +115,15 @@ fold1_ss                = fold1SSU
 
 
 -- Segment Descriptors --------------------------------------------------------
-type Segd               = USegd
-mkSegd                  = mkUSegd
-validSegd               = validUSegd
-emptySegd               = emptyUSegd
-singletonSegd           = singletonUSegd
-lengthSegd              = lengthUSegd
-lengthsSegd             = lengthsUSegd
-indicesSegd             = indicesUSegd
-elementsSegd            = elementsUSegd
+type Segd               = USegd.USegd
+mkSegd                  = USegd.mkUSegd
+validSegd               = USegd.valid
+emptySegd               = USegd.empty
+singletonSegd           = USegd.singleton
+lengthSegd              = USegd.length
+lengthsSegd             = USegd.takeLengths
+indicesSegd             = USegd.takeIndices
+elementsSegd            = USegd.takeElements
 
 
 -- Slice Segment Descriptors --------------------------------------------------
index 7a6da35..2ef2080 100644 (file)
@@ -7,7 +7,8 @@ module Data.Array.Parallel.Unlifted.Sequential.Basics (
 ) where
 import Data.Array.Parallel.Stream
 import Data.Array.Parallel.Unlifted.Sequential.Vector
-import Data.Array.Parallel.Unlifted.Sequential.USegd
+import Data.Array.Parallel.Unlifted.Sequential.USegd            (USegd)
+import qualified Data.Array.Parallel.Unlifted.Sequential.USegd  as USegd
 import qualified Data.Vector.Fusion.Stream as S
 
 
@@ -17,8 +18,8 @@ replicateSU :: Unbox a => USegd -> Vector a -> Vector a
 {-# INLINE_U replicateSU #-}
 replicateSU segd xs 
         = unstream
-             (replicateEachS (elementsUSegd segd)
-             (S.zip (stream (lengthsUSegd segd)) (stream xs)))
+             (replicateEachS (USegd.takeElements segd)
+             (S.zip (stream (USegd.takeLengths segd)) (stream xs)))
 
 
 replicateRSU :: Unbox a => Int -> Vector a -> Vector a
@@ -37,8 +38,8 @@ appendSU :: Unbox a
 {-# INLINE_U appendSU #-}
 appendSU xd xs yd ys
         = unstream
-        $ appendSS (stream (lengthsUSegd xd)) (stream xs)
-                   (stream (lengthsUSegd yd)) (stream ys)
+        $ appendSS (stream (USegd.takeLengths xd)) (stream xs)
+                   (stream (USegd.takeLengths yd)) (stream ys)
 
 
 -- | Segmented indices.
@@ -50,7 +51,7 @@ indicesSU' :: Int -> USegd -> Vector Int
 {-# INLINE_U indicesSU' #-}
 indicesSU' i segd
         = unstream
-        . indicesSS (elementsUSegd segd) i
+        . indicesSS (USegd.takeElements segd) i
         . stream
-        $ lengthsUSegd segd
+        $ USegd.takeLengths segd
 
index bbbb563..0be7a36 100644 (file)
@@ -12,8 +12,9 @@ module Data.Array.Parallel.Unlifted.Sequential.Combinators (
 ) where
 import Data.Array.Parallel.Stream
 import Data.Array.Parallel.Unlifted.Sequential.Vector           as U
-import Data.Array.Parallel.Unlifted.Sequential.USegd
 import Data.Array.Parallel.Unlifted.Sequential.USSegd
+import Data.Array.Parallel.Unlifted.Sequential.USegd            (USegd)
+import qualified Data.Array.Parallel.Unlifted.Sequential.USegd  as USegd
 import qualified Data.Vector                                    as V
 import Debug.Trace
 
@@ -25,7 +26,7 @@ foldlSU  :: (Unbox a, Unbox b)
 {-# INLINE_U foldlSU #-}
 foldlSU f z segd xs 
         = unstream
-        $ foldSS f z    (stream (lengthsUSegd segd))
+        $ foldSS f z    (stream (USegd.takeLengths segd))
                         (stream xs)
 
 -- | Segmented array reduction proceeding from the left.
@@ -63,7 +64,7 @@ foldl1SU :: Unbox a
 {-# INLINE_U foldl1SU #-}
 foldl1SU f segd xs 
         = unstream
-        $ fold1SS f     (stream (lengthsUSegd segd))
+        $ fold1SS f     (stream (USegd.takeLengths segd))
                         (stream xs)
 
 
@@ -110,6 +111,6 @@ combineSU :: Unbox a => Vector Bool -> USegd -> Vector a -> USegd -> Vector a ->
 combineSU bs xd xs yd ys
         = unstream
         $ combineSS (stream bs)
-                    (stream (lengthsUSegd xd)) (stream xs)
-                    (stream (lengthsUSegd yd)) (stream ys)
+                    (stream (USegd.takeLengths xd)) (stream xs)
+                    (stream (USegd.takeLengths yd)) (stream ys)
 
index 3547b60..45b6aae 100644 (file)
@@ -26,8 +26,9 @@ module Data.Array.Parallel.Unlifted.Sequential.USSegd (
         -- * Streams
         streamSegsFromUSSegd
 ) where
-import Data.Array.Parallel.Unlifted.Sequential.USegd
+import Data.Array.Parallel.Unlifted.Sequential.USegd            (USegd)
 import Data.Array.Parallel.Unlifted.Sequential.Vector           as U
+import qualified Data.Array.Parallel.Unlifted.Sequential.USegd  as USegd
 import qualified Data.Vector                                    as V
 import qualified Data.Vector.Fusion.Stream                      as S
 import qualified Data.Vector.Fusion.Stream.Size                 as S
@@ -91,15 +92,15 @@ mkUSSegd = USSegd
 validUSSegd :: USSegd -> Bool
 {-# INLINE validUSSegd #-}
 validUSSegd (USSegd starts srcids usegd)
-        =  (U.length starts == lengthUSegd usegd)
-        && (U.length srcids == lengthUSegd usegd)
+        =  (U.length starts == USegd.length usegd)
+        && (U.length srcids == USegd.length usegd)
 
 
 -- | O(1).
 --  Yield an empty segment descriptor, with no elements or segments.
 emptyUSSegd :: USSegd
 {-# INLINE emptyUSSegd #-}
-emptyUSSegd = USSegd U.empty U.empty emptyUSegd
+emptyUSSegd = USSegd U.empty U.empty USegd.empty
 
 
 -- | O(1).
@@ -109,7 +110,7 @@ emptyUSSegd = USSegd U.empty U.empty emptyUSegd
 singletonUSSegd :: Int -> USSegd
 {-# INLINE singletonUSSegd #-}
 singletonUSSegd n 
-        = USSegd (U.singleton 0) (U.singleton 0) (singletonUSegd n)
+        = USSegd (U.singleton 0) (U.singleton 0) (USegd.singleton n)
 
 
 -- | O(segs). 
@@ -118,8 +119,8 @@ singletonUSSegd n
 promoteUSegdToUSSegd :: USegd -> USSegd
 {-# INLINE promoteUSegdToUSSegd #-}
 promoteUSegdToUSSegd usegd
-        = USSegd (indicesUSegd usegd)
-                 (U.replicate (lengthUSegd usegd) 0)
+        = USSegd (USegd.takeIndices usegd)
+                 (U.replicate (USegd.length usegd) 0)
                  usegd
                  
 
@@ -128,7 +129,7 @@ promoteUSegdToUSSegd usegd
 -- | O(1). Yield the overall number of segments.
 lengthUSSegd :: USSegd -> Int
 {-# INLINE lengthUSSegd #-}
-lengthUSSegd = lengthUSegd . ussegd_usegd 
+lengthUSSegd = USegd.length . ussegd_usegd 
 
 
 -- | O(1). Yield the `USegd` of a `USSegd`
@@ -140,19 +141,19 @@ usegdUSSegd   = ussegd_usegd
 -- | O(1). Yield the lengths of the segments of a `USSegd`
 lengthsUSSegd :: USSegd -> Vector Int
 {-# INLINE lengthsUSSegd #-}
-lengthsUSSegd = lengthsUSegd . ussegd_usegd
+lengthsUSSegd = USegd.takeLengths . ussegd_usegd
 
 
 -- | O(1). Yield the segment indices of a `USSegd`
 indicesUSSegd :: USSegd -> Vector Int
 {-# INLINE indicesUSSegd #-}
-indicesUSSegd = indicesUSegd . ussegd_usegd
+indicesUSSegd = USegd.takeIndices . ussegd_usegd
 
 
 -- | O(1). Yield the total number of elements covered by a `USSegd`
 elementsUSSegd :: USSegd -> Int
 {-# INLINE elementsUSSegd #-}
-elementsUSSegd = elementsUSegd . ussegd_usegd
+elementsUSSegd = USegd.takeElements . ussegd_usegd
 
 
 -- | O(1). Yield the starting indices of a `USSegd`
@@ -171,7 +172,7 @@ sourcesUSSegd = ussegd_sources
 --   Get the length, segment index, starting index, and source id of a segment.
 getSegOfUSSegd :: USSegd -> Int -> (Int, Int, Int, Int)
 getSegOfUSSegd (USSegd starts sources usegd) ix
- = let  (len, index) = getSegOfUSegd usegd ix
+ = let  (len, index) = USegd.getSeg usegd ix
    in   ( len
         , index
         , starts  U.! ix
@@ -191,7 +192,7 @@ appendUSSegd (USSegd starts1 srcs1 usegd1) pdatas1
              (USSegd starts2 srcs2 usegd2) _
         = USSegd (starts1  U.++  starts2)
                  (srcs1    U.++  U.map (+ pdatas1) srcs2)
-                 (appendUSegd usegd1 usegd2)
+                 (USegd.append usegd1 usegd2)
 
 
 -- | Cull the segments in a SSegd down to only those reachable from an array
@@ -213,7 +214,7 @@ cullUSSegdOnVSegids vsegids (USSegd starts sources usegd)
         --  
         --  Note that psegids '2' and '4' are not in vsegids_packed.
         psegids_used
-         = U.bpermuteDft (lengthUSegd usegd)
+         = U.bpermuteDft (USegd.length usegd)
                          (const False)
                          (U.zip vsegids (U.replicate (U.length vsegids) True))
 
@@ -234,7 +235,7 @@ cullUSSegdOnVSegids vsegids (USSegd starts sources usegd)
         --                      [0 1 2 3 4]
         --      psegids_map:    [0 1 -1 2 -1 3 4]
         psegids_map
-         = U.bpermuteDft (lengthUSegd usegd)
+         = U.bpermuteDft (USegd.length usegd)
                          (const (-1))
                          (U.zip psegids_packed (U.enumFromTo 0 (U.length psegids_packed - 1)))
 
@@ -252,8 +253,8 @@ cullUSSegdOnVSegids vsegids (USSegd starts sources usegd)
         starts'   = U.pack starts  psegids_used
         sources'  = U.pack sources psegids_used
 
-        lengths'  = U.pack (lengthsUSegd usegd) psegids_used
-        usegd'    = lengthsToUSegd lengths'
+        lengths'  = U.pack (USegd.takeLengths usegd) psegids_used
+        usegd'    = USegd.fromLengths lengths'
         
         ussegd'   = USSegd starts' sources' usegd'
 
@@ -274,7 +275,7 @@ streamSegsFromUSSegd
 streamSegsFromUSSegd ussegd@(USSegd starts sources usegd) pdatas
  = let  
         -- length of each segment
-        pseglens        = lengthsUSegd usegd
+        pseglens        = USegd.takeLengths usegd
  
         -- We've finished streaming this pseg
         {-# INLINE fn #-}
index 259350c..0d3fd99 100644 (file)
@@ -5,21 +5,27 @@ module Data.Array.Parallel.Unlifted.Sequential.USegd (
   USegd,
 
   -- * Constructors
-  mkUSegd, validUSegd,
-  emptyUSegd, singletonUSegd, lengthsToUSegd,
+  mkUSegd, valid,
+  empty, singleton,
+  fromLengths,
 
   -- * Projections
-  lengthUSegd, lengthsUSegd, indicesUSegd, elementsUSegd, 
-  getSegOfUSegd,
+  length,
+  takeLengths, takeIndices, takeElements, 
+  getSeg,
 
   -- * Operations
-  appendUSegd, sliceUSegd, extractUSegd
+  append, slice, extract
 ) where
-import Data.Array.Parallel.Unlifted.Sequential.Vector as V
-import Data.Array.Parallel.Pretty
+import qualified Data.Array.Parallel.Unlifted.Sequential.Vector as V
+import Data.Array.Parallel.Unlifted.Sequential.Vector           (Vector, MVector)
+import Data.Array.Parallel.Pretty                               hiding (empty)
+import Prelude                                                  hiding (length)
 
--- | Segment descriptors represent the structure of nested arrays.
---  For each segment, it stores the length and the starting index in the flat data array.
+
+-- | Segment descriptors represent an index space transform between the indicies
+--   of a nested array and the indices of a flat array. It stores the lengths and
+--   starting indices of each segment in the flat array.
 --
 --   Example:
 --
@@ -60,29 +66,27 @@ mkUSegd
 mkUSegd = USegd
 
 
--- | O(1).
---   Check the internal consistency of a scattered segment descriptor.
+-- | O(1). Check the internal consistency of a scattered segment descriptor.
 --   As the indices and elemens field can be generated based on the segment
 --   lengths, we check the consistency by rebuilding these fields and 
 --   comparing the rebuilt ones against the originals.
-validUSegd :: USegd -> Bool
-{-# INLINE validUSegd #-}
-validUSegd usegd@(USegd lengths _ _)
-        = usegd == lengthsToUSegd lengths
+valid :: USegd -> Bool
+{-# INLINE valid #-}
+valid usegd@(USegd lengths _ _)
+        = usegd == fromLengths lengths
 
 
 -- | O(1). Yield an empty segment descriptor, with no elements or segments.
-emptyUSegd :: USegd
-{-# INLINE emptyUSegd #-}
-emptyUSegd = USegd V.empty V.empty 0
+empty :: USegd
+{-# INLINE empty #-}
+empty = USegd V.empty V.empty 0
 
 
--- | O(1).
---   Yield a singleton segment descriptor.
+-- | O(1). Yield a singleton segment descriptor.
 --   The single segment covers the given number of elements.
-singletonUSegd :: Int -> USegd
-{-# INLINE singletonUSegd #-}
-singletonUSegd n = USegd (V.singleton n) (V.singleton 0) n
+singleton :: Int -> USegd
+{-# INLINE singleton #-}
+singleton n = USegd (V.singleton n) (V.singleton 0) n
 
 
 -- | O(n). Convert a length array into a segment descriptor.
@@ -90,50 +94,51 @@ singletonUSegd n = USegd (V.singleton n) (V.singleton 0) n
 --   The array contains the length of each segment, and we compute the 
 --   indices from that. Runtime is O(n) in the number of segments.
 --
-lengthsToUSegd :: Vector Int -> USegd
-{-# INLINE lengthsToUSegd #-}
-lengthsToUSegd lens
+fromLengths :: Vector Int -> USegd
+{-# INLINE fromLengths #-}
+fromLengths lens
         = USegd lens (V.scanl (+) 0 lens) (V.sum lens)
 
 
 -- Projections ----------------------------------------------------------------
 -- | O(1). Yield the overall number of segments.
-lengthUSegd :: USegd -> Int
-{-# INLINE lengthUSegd #-}
-lengthUSegd = V.length . usegd_lengths
+length :: USegd -> Int
+{-# INLINE length #-}
+length = V.length . usegd_lengths
 
 
 -- | O(1). Yield the lengths of the individual segments.
-lengthsUSegd :: USegd -> Vector Int
-{-# INLINE lengthsUSegd #-}
-lengthsUSegd = usegd_lengths
+takeLengths :: USegd -> Vector Int
+{-# INLINE takeLengths #-}
+takeLengths = usegd_lengths
 
 
 -- | O(1). Yield the segment indices of a segment descriptor.
-indicesUSegd :: USegd -> Vector Int
-{-# INLINE indicesUSegd #-}
-indicesUSegd = usegd_indices
+takeIndices :: USegd -> Vector Int
+{-# INLINE takeIndices #-}
+takeIndices = usegd_indices
 
 
 -- | O(1). Yield the number of data elements.
-elementsUSegd :: USegd -> Int
-{-# INLINE elementsUSegd #-}
-elementsUSegd = usegd_elements
+takeElements :: USegd -> Int
+{-# INLINE takeElements #-}
+takeElements = usegd_elements
 
 
 -- | O(1). Get the length and segment index of a segment
-getSegOfUSegd :: USegd -> Int -> (Int, Int)
-getSegOfUSegd (USegd lengths indices _ ) ix
+getSeg :: USegd -> Int -> (Int, Int)
+{-# INLINE getSeg #-}
+getSeg (USegd lengths indices _ ) ix
  =      ( lengths V.! ix
         , indices V.! ix)
 
 
 -- Operators ------------------------------------------------------------------
--- | O(segs)
---   Produce a segment descriptor that describes the result of appending 
+-- | O(segs). Produce a segment descriptor that describes the result of appending 
 --   two arrays.
-appendUSegd :: USegd -> USegd -> USegd
-appendUSegd (USegd lengths1 indices1 elems1)
+append :: USegd -> USegd -> USegd
+{-# INLINE append #-}
+append (USegd lengths1 indices1 elems1)
             (USegd lengths2 indices2 elems2)
  = USegd (lengths1 V.++ lengths2)
          (indices1 V.++ V.map (+ elems1) indices2)
@@ -148,15 +153,15 @@ appendUSegd (USegd lengths1 indices1 elems1)
 -- 
 --   NOTE: In the new segment descriptor, the starting index of the first
 --         segment will be 0.
-sliceUSegd 
+slice
         :: USegd        -- ^ source segment descriptor
         -> Int          -- ^ index of first segment
         -> Int          -- ^ number of segments to slice out
         -> USegd
         
-{-# INLINE sliceUSegd #-}
-sliceUSegd segd i n
-        = lengthsToUSegd $ V.slice (lengthsUSegd segd) i n
+{-# INLINE slice #-}
+slice segd i n
+        = fromLengths $ V.slice (takeLengths segd) i n
 
 
 -- | Extract a slice of a segment descriptor, copying everything.
@@ -166,13 +171,13 @@ sliceUSegd segd i n
 --
 --   NOTE: In the new segment descriptor, the starting index of the first
 --         segment will be 0.
-extractUSegd 
+extract
         :: USegd        -- ^ source segment desciptor
         -> Int          -- ^ index of the first segment
         -> Int          -- ^ number of segments to extract out
         -> USegd
 
-{-# INLINE extractUSegd #-}
-extractUSegd segd i n 
-        = lengthsToUSegd $ V.extract (lengthsUSegd segd) i n
+{-# INLINE extract #-}
+extract segd i n 
+        = fromLengths $ V.extract (takeLengths segd) i n
 
index 6bd3c04..17058c4 100644 (file)
@@ -30,9 +30,10 @@ module Data.Array.Parallel.Unlifted.Sequential.UVSegd (
 ) where
 import Data.Array.Parallel.Unlifted.Sequential.USel
 import Data.Array.Parallel.Unlifted.Sequential.USSegd
-import Data.Array.Parallel.Unlifted.Sequential.USegd
 import Data.Array.Parallel.Unlifted.Sequential.Vector as V
+import Data.Array.Parallel.Unlifted.Sequential.USegd  (USegd)
 import Data.Array.Parallel.Pretty
+import qualified Data.Array.Parallel.Unlifted.Sequential.USegd  as USegd
 
 
 -- UVSegd ---------------------------------------------------------------------
@@ -191,7 +192,7 @@ demoteUVSegdToUSSegd (UVSegd vsegids ussegd)
  = let  starts'         = V.bpermute (startsUSSegd ussegd)  vsegids
         sources'        = V.bpermute (sourcesUSSegd ussegd) vsegids
         lengths'        = V.bpermute (lengthsUSSegd ussegd) vsegids
-        usegd'          = lengthsToUSegd lengths'
+        usegd'          = USegd.fromLengths lengths'
    in   mkUSSegd starts' sources' usegd'
 
 
@@ -212,7 +213,7 @@ demoteUVSegdToUSSegd (UVSegd vsegids ussegd)
 unsafeMaterializeUVSegd :: UVSegd -> USegd
 {-# INLINE unsafeMaterializeUVSegd #-}
 unsafeMaterializeUVSegd (UVSegd vsegids ussegd)
-        = lengthsToUSegd 
+        = USegd.fromLengths
         $ V.bpermute (lengthsUSSegd ussegd) vsegids