Make USSegd contain a whole USegd because we need the indices field to distribute it.
authorBen Lippmeier <benl@ouroborus.net>
Fri, 2 Sep 2011 04:00:47 +0000 (14:00 +1000)
committerBen Lippmeier <benl@ouroborus.net>
Fri, 2 Sep 2011 04:00:47 +0000 (14:00 +1000)
dph-common-vseg/Data/Array/Parallel/PArray/PData/Nested.hs
dph-prim-interface/Data/Array/Parallel/Unlifted.hs
dph-prim-interface/interface/DPH_Header.h
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/Text.hs [deleted file]
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Segmented/USSegd.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Segmented/USegd.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Segmented/UVSegd.hs
dph-prim-seq/dph-prim-seq.cabal

index 8cae4de..e305875 100644 (file)
@@ -60,12 +60,14 @@ data instance PData (PArray a)
 -- TODO: we shouldn't be using these directly.
 pnested_vsegids    = U.vsegidsVSegd . pnested_uvsegd
 pnested_pseglens   = U.lengthsSSegd . U.ssegdVSegd . pnested_uvsegd
-pnested_psegstarts = U.indicesSSegd . U.ssegdVSegd . pnested_uvsegd
+pnested_psegstarts = U.startsSSegd  . U.ssegdVSegd . pnested_uvsegd
 pnested_psegsrcids = U.sourcesSSegd . U.ssegdVSegd . pnested_uvsegd
 
 mkPNested vsegids pseglens psegstarts psegsrcids psegdata
         = PNested
-                (U.mkVSegd vsegids (U.mkSSegd pseglens psegstarts psegsrcids))
+                (U.mkVSegd vsegids 
+                        $ U.mkSSegd psegstarts psegsrcids
+                        $ U.lengthsToSegd pseglens)
                 psegdata
 
 -- | Pretty print the physical representation of a nested array
@@ -216,10 +218,8 @@ instance PR a => PR (PArray a) where
   replicatePR c (PArray n darr)
    = checkNotEmpty "replicatePR[PArray]" c
    $ let -- Physical segment descriptor contains a single segment.
-         ussegd  = U.mkSSegd (U.replicate 1 n)
-                            (U.replicate 1 0)
-                            (U.replicate 1 0)
-
+         ussegd  = U.singletonSSegd n
+         
          -- All virtual segments point to the same physical segment.
          uvsegd  = U.mkVSegd (U.replicate c 0) ussegd
 
@@ -296,9 +296,11 @@ instance PR a => PR (PArray a) where
 
          (pseglens', psegstarts', psegsrcs')    
                         = U.unzip3 seginfo
-
+                
+         -- TODO: check that doing lengthsToSegd won't cause overflow
          uvsegd'        = U.promoteSSegdToVSegd
-                        $ U.mkSSegd pseglens' psegstarts' psegsrcs'
+                        $ U.mkSSegd psegstarts' psegsrcs'
+                        $ U.lengthsToSegd pseglens'
                                  
          -- All flat data arrays in the sources go into the result.
          psegdata'      = V.concat $ V.toList $ V.map pnested_psegdata pdata
@@ -491,7 +493,7 @@ concatPR (PNested uvsegd psegdata)
         -- Copy these segments into a new array.
    in   extractsPR psegdata 
                    (U.sourcesSSegd ussegd)
-                   (U.indicesSSegd ussegd)
+                   (U.startsSSegd  ussegd)
                    (U.lengthsSSegd ussegd)
 
 
index 9d41bb2..ed5ee4a 100644 (file)
@@ -159,28 +159,32 @@ data Segd
         , segd_indices  :: [Int]
         , segd_elements :: Int }
 
-mkSegd          = Segd
-lengthSegd      = length . lengthsSegd
-lengthsSegd     = segd_lengths
-indicesSegd     = segd_indices
-elementsSegd    = segd_elements
+mkSegd                  = Segd
+emptySegd               = Segd [] [] 0
+singletonSegd           = notImplemented "singletonSegd"
+validSegd               = notImplemented "validSegd"
+lengthSegd              = length . lengthsSegd
+lengthsSegd             = segd_lengths
+indicesSegd             = segd_indices
+elementsSegd            = segd_elements
 
 
 -- Slice Segment Descriptors --------------------------------------------------
 data SSegd
         = SSegd
-        { ssegd_lengths :: [Int]
-        , ssegd_indices :: [Int]
-        , ssegd_sources :: [Int] }
+        { ssegd_starts  :: [Int]
+        , ssegd_sources :: [Int]
+        , ssegd_segd    :: Segd }
 
 mkSSegd                 = SSegd
-emptySSegd              = SSegd [] [] []
+emptySSegd              = SSegd [] [] emptySegd
 singletonSSegd          = notImplemented "singletonSSegd"
 validSSegd              = notImplemented "validSSegd"
 promoteSegdToSSegd      = notImplemented "promoteSegdToSSegd"
-lengthSSegd             = length . ssegd_lengths
-lengthsSSegd            = ssegd_lengths
-indicesSSegd            = ssegd_indices
+lengthSSegd             = lengthSegd  . ssegd_segd
+lengthsSSegd            = lengthsSegd . ssegd_segd
+indicesSSegd            = indicesSegd . ssegd_segd
+startsSSegd             = ssegd_starts
 sourcesSSegd            = ssegd_sources
 getSegOfSSegd           = notImplemented "getSegOfSSegd"
 appendSSegd             = notImplemented "appendSSegd"
index 832226f..fb18a6d 100644 (file)
@@ -54,15 +54,18 @@ module Data.Array.Parallel.Unlifted (
   fold_s, fold1_s, fold_r, sum_s,  sum_r,
   
   -- * Segment Descriptors
-  Segd, mkSegd,
-  emptySSegd, singletonSSegd,
-  lengthSegd, lengthsSegd, indicesSegd, elementsSegd, lengthsToSegd,
+  Segd, mkSegd, validSegd,
+  emptySegd, singletonSegd,
+  lengthsToSegd,
+  lengthSegd, lengthsSegd, indicesSegd, elementsSegd,
   plusSegd, 
 
-  -- * Slice Segment Descriptors
+  -- * Scattered Segment Descriptors
   SSegd, mkSSegd, validSSegd,
+  emptySSegd, singletonSSegd,
   promoteSegdToSSegd,
-  lengthSSegd, lengthsSSegd, indicesSSegd, sourcesSSegd, 
+  lengthSSegd, lengthsSSegd, indicesSSegd,
+  startsSSegd, sourcesSSegd,
   getSegOfSSegd,
   appendSSegd,
   
index 436a9fc..7d1bc2f 100644 (file)
@@ -105,6 +105,9 @@ sum_r                   = sumRU
 -- Segment Descriptors --------------------------------------------------------
 type Segd               = USegd
 mkSegd                  = mkUSegd
+validSegd               = validUSegd
+emptySegd               = emptyUSegd
+singletonSegd           = singletonUSegd
 lengthSegd              = lengthUSegd
 lengthsSegd             = lengthsUSegd
 indicesSegd             = indicesUSegd
@@ -121,6 +124,7 @@ promoteSegdToSSegd      = promoteUSegdToUSSegd
 lengthSSegd             = lengthUSSegd
 lengthsSSegd            = lengthsUSSegd
 indicesSSegd            = indicesUSSegd
+startsSSegd             = startsUSSegd
 sourcesSSegd            = sourcesUSSegd
 getSegOfSSegd           = getSegOfUSSegd
 appendSSegd             = appendUSSegd
index f52903d..57ff220 100644 (file)
@@ -15,7 +15,8 @@ module Data.Array.Parallel.Unlifted.Sequential.Segmented (
   sumRU,
 
   -- * Segment Descriptors
-  USegd, mkUSegd,
+  USegd, mkUSegd, validUSegd,
+  emptyUSegd, singletonUSegd,
   lengthUSegd, lengthsUSegd, indicesUSegd, elementsUSegd,
   lengthsToUSegd,
   
@@ -23,7 +24,8 @@ module Data.Array.Parallel.Unlifted.Sequential.Segmented (
   USSegd, mkUSSegd, validUSSegd,
   emptyUSSegd, singletonUSSegd,
   promoteUSegdToUSSegd,
-  lengthUSSegd, lengthsUSSegd, indicesUSSegd, sourcesUSSegd,
+  lengthUSSegd, lengthsUSSegd, indicesUSSegd,
+  sourcesUSSegd, startsUSSegd,
   getSegOfUSSegd, appendUSSegd,
 
   -- * Virtual Segment Descriptors
@@ -42,5 +44,4 @@ import Data.Array.Parallel.Unlifted.Sequential.Segmented.UVSegd
 import Data.Array.Parallel.Unlifted.Sequential.Segmented.Basics
 import Data.Array.Parallel.Unlifted.Sequential.Segmented.Combinators
 import Data.Array.Parallel.Unlifted.Sequential.Segmented.Sums
-import Data.Array.Parallel.Unlifted.Sequential.Segmented.Text ()
 
diff --git a/dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Segmented/Text.hs b/dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Segmented/Text.hs
deleted file mode 100644 (file)
index 7629a15..0000000
+++ /dev/null
@@ -1,11 +0,0 @@
--- | Read\/Show instances for segmented unlifted arrays.
-module Data.Array.Parallel.Unlifted.Sequential.Segmented.Text ()
-where
-import Data.Array.Parallel.Base (
-  Read(..), showsApp, readApp)
-import Data.Array.Parallel.Unlifted.Sequential.Segmented.USegd (
-  USegd, lengthsUSegd )
-
-instance Show USegd where
-  showsPrec k = showsApp k "toUSegd" . lengthsUSegd
-
index 8d64d30..1e12936 100644 (file)
@@ -1,4 +1,4 @@
--- | Slice Segment Descriptors
+-- | Scatter Segment Descriptors
 module Data.Array.Parallel.Unlifted.Sequential.Segmented.USSegd (
         -- * Types
         USSegd(..),
@@ -14,7 +14,8 @@ module Data.Array.Parallel.Unlifted.Sequential.Segmented.USSegd (
         
         -- * Projections
         lengthUSSegd,
-        lengthsUSSegd, indicesUSSegd, sourcesUSSegd,
+        lengthsUSSegd, indicesUSSegd,
+        sourcesUSSegd, startsUSSegd,
         getSegOfUSSegd,
         
         -- * Operators
@@ -27,51 +28,50 @@ import Data.Array.Parallel.Pretty
 
 
 -- USSegd ---------------------------------------------------------------------
--- | Slice segment descriptors are a generalisation of regular 
+-- | Scatter segment descriptors are a generalisation of regular 
 --   segment descriptors of type (Segd). 
 --   
 --   * SSegd segments may be drawn from multiple physical source arrays.
---
 --   * The segments need not cover the entire flat array.
---
 --   * Different segments may point to the same elements.
 --
---   * As different segments may point to the same elements, we don't export
---     a function to determine how many elements are covered by the descriptor
---     as this value may overflow a machine word. 
+--   * As different segments may point to the same elements, it is possible
+--     for the total number of elements covered by the segment descriptor
+--     to overflow a machine word.
 -- 
 data USSegd
         = USSegd
-        { ussegd_lengths :: !(Vector Int)
-          -- ^ length of each segment
-
-        , ussegd_indices :: !(Vector Int)
+        { ussegd_starts  :: !(Vector Int)
           -- ^ starting index of each segment in its flat array
 
-        , ussegd_srcids  :: !(Vector Int)
+        , ussegd_sources :: !(Vector Int)
           -- ^ which flat array to take each segment from.
+
+        , ussegd_usegd   :: !USegd
+          -- ^ segment descriptor with contiguous index space.
         }
         deriving (Show)
 
 
 -- | Pretty print the physical representation of a `UVSegd`
 instance PprPhysical USSegd where
- pprp (USSegd lengths indices srcids)
-  =   text "USSegd" 
-  $$  (nest 7 $ vcat
-        [ text "lengths:" <+> (text $ show $ V.toList lengths)
-        , text "indices:" <+> (text $ show $ V.toList indices)
-        , text "srcids: " <+> (text $ show $ V.toList srcids)])
+ pprp (USSegd starts srcids ssegd)
+  = vcat
+  [ text "USSegd" 
+        $$ (nest 7 $ vcat
+                [ text "starts:  " <+> (text $ show $ V.toList starts)
+                , text "srcids:  " <+> (text $ show $ V.toList srcids) ])
+  , pprp ssegd ]
 
 
 -- Constructors ---------------------------------------------------------------
 -- | O(1). 
---   Construct a new slice segment descriptor.
+--   Construct a new scattered segment descriptor.
 --   All the provided arrays must have the same lengths.
 mkUSSegd
-        :: Vector Int   -- ^ length of each segment
-        -> Vector Int   -- ^ starting index of each segment in its flat array
-        -> Vector Int   -- ^ which flat array to take each segment from
+        :: Vector Int   -- ^ starting index of each segment in its flat array
+        -> Vector Int   -- ^ which array to take each segment from
+        -> USegd        -- ^ contiguous segment descriptor
         -> USSegd
 
 {-# INLINE mkUSSegd #-}
@@ -79,19 +79,19 @@ mkUSSegd = USSegd
 
 
 -- | O(1).
---   Check the internal consistency of a slice segment descriptor.
+--   Check the internal consistency of a scattered segment descriptor.
 validUSSegd :: USSegd -> Bool
 {-# INLINE validUSSegd #-}
-validUSSegd (USSegd lens starts srcids)
-        =  (V.length lens == V.length starts)
-        && (V.length lens == V.length srcids)
+validUSSegd (USSegd starts srcids usegd)
+        =  (V.length starts == lengthUSegd usegd)
+        && (V.length srcids == lengthUSegd usegd)
 
 
 -- | O(1).
 --  Yield an empty segment descriptor, with no elements or segments.
 emptyUSSegd :: USSegd
 {-# INLINE emptyUSSegd #-}
-emptyUSSegd = USSegd V.empty V.empty V.empty
+emptyUSSegd = USSegd V.empty V.empty emptyUSegd
 
 
 -- | O(1).
@@ -101,7 +101,7 @@ emptyUSSegd = USSegd V.empty V.empty V.empty
 singletonUSSegd :: Int -> USSegd
 {-# INLINE singletonUSSegd #-}
 singletonUSSegd n 
-        = USSegd (V.singleton n) (V.singleton 0) (V.singleton 0)
+        = USSegd (V.singleton 0) (V.singleton 0) (singletonUSegd n)
 
 
 -- | O(segs). 
@@ -110,59 +110,74 @@ singletonUSSegd n
 promoteUSegdToUSSegd :: USegd -> USSegd
 {-# INLINE promoteUSegdToUSSegd #-}
 promoteUSegdToUSSegd usegd
-        = USSegd (lengthsUSegd usegd)
-                 (indicesUSegd usegd)
+        = USSegd (indicesUSegd usegd)
                  (V.replicate (lengthUSegd usegd) 0)
+                 usegd
+                 
 
 
 -- Projections ----------------------------------------------------------------
 -- | O(1). Yield the overall number of segments.
 lengthUSSegd :: USSegd -> Int
 {-# INLINE lengthUSSegd #-}
-lengthUSSegd = V.length . ussegd_lengths
+lengthUSSegd = lengthUSegd . ussegd_usegd 
 
 
 -- | O(1). Yield the lengths of the segments of a `USSegd`
 lengthsUSSegd :: USSegd -> Vector Int
 {-# INLINE lengthsUSSegd #-}
-lengthsUSSegd = ussegd_lengths
+lengthsUSSegd = lengthsUSegd . ussegd_usegd
 
 
 -- | O(1). Yield the segment indices of a `USSegd`
 indicesUSSegd :: USSegd -> Vector Int
 {-# INLINE indicesUSSegd #-}
-indicesUSSegd = ussegd_indices
+indicesUSSegd = indicesUSegd . ussegd_usegd
 
 
--- | O(1). Yield the source ids of a slice segment descriptor.
+-- | O(1). Yield the starting indices of a `USSegd`
+startsUSSegd :: USSegd -> Vector Int
+{-# INLINE startsUSSegd #-}
+startsUSSegd = ussegd_starts
+
+
+-- | O(1). Yield the source ids of a `USSegd`
 sourcesUSSegd :: USSegd -> Vector Int
 {-# INLINE sourcesUSSegd #-}
-sourcesUSSegd = ussegd_srcids
+sourcesUSSegd = ussegd_sources
 
 
--- O(1).
--- Get the length, starting index, and source id of a segment.
-getSegOfUSSegd :: USSegd -> Int -> (Int, Int, Int)
-getSegOfUSSegd (USSegd lengths starts sourceids) ix
- =      ( lengths   V.! ix
-        , starts    V.! ix
-        , sourceids V.! ix)
+-- | O(1). Yield the `USegd` of a `USSegd`
+usegdUSSegd   :: USSegd -> USegd
+{-# INLINE usegdUSSegd #-}
+usegdUSSegd   = ussegd_usegd
+
+
+-- | O(1).
+--   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  (length, index) = getSegOfUSegd usegd ix
+   in   ( length
+        , index
+        , starts  V.! ix
+        , sources V.! ix)
 
 
 -- Operators ------------------------------------------------------------------
 -- | O(n)
---   Produce a segment descriptor describing the result of appending
+--   Produce a segment descriptor that describes the result of appending
 --   two arrays.
 appendUSSegd 
         :: USSegd -> Int        -- ^ ussegd of array, and number of physical data arrays
         -> USSegd -> Int        -- ^ ussegd of array, and number of physical data arrays
         -> USSegd
 
-appendUSSegd (USSegd lens1 starts1 srcs1) pdatas1
-             (USSegd lens2 starts2 srcs2) _
-        = USSegd (lens1    V.++  lens2)
-                 (starts1  V.++  starts2)
+appendUSSegd (USSegd starts1 srcs1 usegd1) pdatas1
+             (USSegd starts2 srcs2 usegd2) _
+        = USSegd (starts1  V.++  starts2)
                  (srcs1    V.++  V.map (+ pdatas1) srcs2)
+                 (appendUSegd usegd1 usegd2)
 
 
 -- | Cull the segments in a SSegd down to only those reachable from an array
@@ -173,7 +188,7 @@ appendUSSegd (USSegd lens1 starts1 srcs1) pdatas1
 --
 cullUSSegdOnVSegids :: Vector Int -> USSegd -> (Vector Int, USSegd)
 {-# INLINE cullUSSegdOnVSegids #-}
-cullUSSegdOnVSegids vsegids (USSegd lengths indices srcids)
+cullUSSegdOnVSegids vsegids (USSegd starts sources usegd)
  = let  -- Determine which of the psegs are still reachable from the vsegs.
         -- This produces an array of flags, 
         --    with reachable   psegs corresponding to 1
@@ -184,7 +199,7 @@ cullUSSegdOnVSegids vsegids (USSegd lengths indices srcids)
         --  
         --  Note that psegids '2' and '4' are not in vsegids_packed.
         psegids_used
-         = V.bpermuteDft (V.length lengths)
+         = V.bpermuteDft (lengthUSegd usegd)
                          (const False)
                          (V.zip vsegids (V.replicate (V.length vsegids) True))
 
@@ -205,7 +220,7 @@ cullUSSegdOnVSegids vsegids (USSegd lengths indices srcids)
         --                      [0 1 2 3 4]
         --      psegids_map:    [0 1 -1 2 -1 3 4]
         psegids_map
-         = V.bpermuteDft (V.length lengths)
+         = V.bpermuteDft (lengthUSegd usegd)
                          (const (-1))
                          (V.zip psegids_packed (V.enumFromTo 0 (V.length psegids_packed - 1)))
 
@@ -219,8 +234,17 @@ cullUSSegdOnVSegids vsegids (USSegd lengths indices srcids)
         --
         vsegids'  = V.map (psegids_map V.!) vsegids
 
-        ussegd'   = USSegd (V.pack lengths psegids_used)
-                           (V.pack indices psegids_used)
-                           (V.pack srcids  psegids_used)
+        -- Rebuild the usegd.
+        starts'   = V.pack starts  psegids_used
+        sources'  = V.pack sources psegids_used
+
+        lengths'  = V.pack (lengthsUSegd usegd) psegids_used
+        usegd'    = lengthsToUSegd lengths'
+        
+        ussegd'   = USSegd starts' sources' usegd'
 
      in  (vsegids', ussegd')
+
+
+
+
index 31c8967..74b0171 100644 (file)
@@ -4,14 +4,15 @@ module Data.Array.Parallel.Unlifted.Sequential.Segmented.USegd (
   USegd,
 
   -- * Constructors
-  mkUSegd,
+  mkUSegd, validUSegd,
   emptyUSegd, singletonUSegd, lengthsToUSegd,
 
   -- * Projections
   lengthUSegd, lengthsUSegd, indicesUSegd, elementsUSegd, 
+  getSegOfUSegd,
 
   -- * Operations
-  sliceUSegd, extractUSegd
+  appendUSegd, sliceUSegd, extractUSegd
 ) where
 import Data.Array.Parallel.Unlifted.Sequential.Vector as V
 import Data.Array.Parallel.Pretty
@@ -22,8 +23,8 @@ import Data.Array.Parallel.Pretty
 --   Example:
 --
 --   @
---    flat array data:  [1, 2, 3, 4, 5, 6, 7, 8]
---      (segmentation)   ----  -------  -  ----
+--    flat array data: [1 2 3 4 5 6 7 8]
+--      (segmentation)  --- ----- - ---
 --      segd  lengths: [2, 3, 1, 2]
 --            indices: [0, 2, 5, 6]
 --           elements: 8 
@@ -31,9 +32,9 @@ import Data.Array.Parallel.Pretty
 data USegd 
         = USegd 
         { usegd_lengths  :: !(Vector Int)  -- ^ length of each segment
-        , usegd_indices  :: !(Vector Int)  -- ^ starting index of each segment in the flat array
+        , usegd_indices  :: !(Vector Int)  -- ^ index of each segment in the flat array
         , usegd_elements :: !Int           -- ^ total number of elements in the flat array
-        }
+        } deriving (Show, Eq)
 
 
 -- | Pretty print the physical representation of a `UVSegd`
@@ -58,6 +59,17 @@ mkUSegd
 mkUSegd = USegd
 
 
+-- | 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 indices elems)
+        = usegd == lengthsToUSegd lengths
+
+
 -- | O(1). Yield an empty segment descriptor, with no elements or segments.
 emptyUSegd :: USegd
 {-# INLINE emptyUSegd #-}
@@ -107,8 +119,26 @@ elementsUSegd :: USegd -> Int
 elementsUSegd = usegd_elements
 
 
+-- | O(1). Get the length and segment index of a segment
+getSegOfUSegd :: USegd -> Int -> (Int, Int)
+getSegOfUSegd (USegd lengths indices _ ) ix
+ =      ( lengths V.! ix
+        , indices V.! ix)
+
+
 -- Operators ------------------------------------------------------------------
--- | O(n). Extract a slice of a segment descriptor, avoiding copying where possible.
+-- | O(segs)
+--   Produce a segment descriptor that describes the result of appending 
+--   two arrays.
+appendUSegd :: USegd -> USegd -> USegd
+appendUSegd (USegd lengths1 indices1 elems1)
+            (USegd lengths2 indices2 elems2)
+ = USegd (lengths1 V.++ lengths2)
+         (indices1 V.++ V.map (+ elems1) indices2)
+         (elems1 + elems2)
+
+
+-- | Extract a slice of a segment descriptor, avoiding copying where possible.
 --
 --   We can share the segment lengths with the original segment descriptor, 
 --   but still need to recompute the starting indices of each. Hence
@@ -127,7 +157,7 @@ sliceUSegd segd i n
         = lengthsToUSegd $ V.slice (lengthsUSegd segd) i n
 
 
--- | O(n). Extract a slice of a segment descriptor, copying everything.
+-- | Extract a slice of a segment descriptor, copying everything.
 --
 --   In contrast to `sliceUSegd`, this function copies the array of 
 --   segment lengths as well as recomputing the starting indices of each.
index eb990ab..bd8a4f0 100644 (file)
@@ -58,9 +58,9 @@ data UVSegd
 -- | Pretty print the physical representation of a `UVSegd`
 instance PprPhysical UVSegd where
  pprp (UVSegd vsegids ussegd)
-  =   vcat
-  [   text "UVSegd" $$ (nest 7 $ text "vsegids:" <+> (text $ show $ V.toList vsegids))
-  ,   pprp ussegd ]
+  = vcat
+  [ text "UVSegd" $$ (nest 7 $ text "vsegids: " <+> (text $ show $ V.toList vsegids))
+  , pprp ussegd ]
 
 
 -- Constructors ---------------------------------------------------------------
@@ -148,17 +148,24 @@ lengthUVSegd (UVSegd vsegids _)
 lengthsUVSegd :: UVSegd -> Vector Int
 {-# INLINE lengthsUVSegd #-}
 lengthsUVSegd (UVSegd vsegids ussegd)
-        = V.map ((ussegd_lengths ussegd) V.!) vsegids
+        = V.map (lengthsUSSegd ussegd V.!) vsegids
 
 
 -- | O(1).
---  Get the length, starting index, and sourceid of a segment.
+--  Get the length, starting index, and source id of a segment.
+--
+--  NOTE: We don't return the segment index field from the USSegd as this refers
+--        to the flat index relative to the SSegd array, rather than 
+--        relative to the UVSegd array. If we tried to promote the USSegd index
+--        to a UVSegd index it could overflow.
+--
 getSegOfUVSegd :: UVSegd -> Int -> (Int, Int, Int)
 {-# INLINE getSegOfUVSegd #-}
 getSegOfUVSegd (UVSegd vsegids ussegd) ix
       = getSegOfUSSegd ussegd (vsegids V.! ix)
-        
= let  (length, _index, start, source) = getSegOfUSSegd ussegd (vsegids V.! ix)
+   in   (length, start, source)
 
+   
 -- Operators ------------------------------------------------------------------
 -- | TODO: automatically force out unreachable psegs here.
 updateVSegsOfUVSegd :: (Vector Int -> Vector Int) -> UVSegd -> UVSegd
@@ -180,9 +187,11 @@ updateVSegsOfUVSegd f (UVSegd vsegids ussegd)
 demoteUVSegdToUSSegd :: UVSegd -> USSegd
 {-# INLINE demoteUVSegdToUSSegd #-}
 demoteUVSegdToUSSegd (UVSegd vsegids ussegd)
-        = mkUSSegd (V.bpermute (lengthsUSSegd ussegd) vsegids)
-                   (V.bpermute (indicesUSSegd ussegd) vsegids)
-                   (V.bpermute (sourcesUSSegd ussegd) vsegids)
+ = let  starts'         = V.bpermute (startsUSSegd ussegd)  vsegids
+        sources'        = V.bpermute (sourcesUSSegd ussegd) vsegids
+        lengths'        = V.bpermute (lengthsUSSegd ussegd) vsegids
+        usegd'          = lengthsToUSegd lengths'
+   in   mkUSSegd starts' sources' usegd'
 
 
 -- | O(segs)
index 4837b61..fc482bc 100644 (file)
@@ -24,7 +24,6 @@ Library
         Data.Array.Parallel.Unlifted.Sequential.Segmented.Basics
         Data.Array.Parallel.Unlifted.Sequential.Segmented.Combinators
         Data.Array.Parallel.Unlifted.Sequential.Segmented.Sums
-        Data.Array.Parallel.Unlifted.Sequential.Segmented.Text
 
   Exposed: False