Use unsafe indexing, and strictify some things
authorBen Lippmeier <benl@ouroborus.net>
Tue, 29 Nov 2011 05:32:22 +0000 (16:32 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Tue, 29 Nov 2011 05:32:39 +0000 (16:32 +1100)
17 files changed:
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Double.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Int.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Nested.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Sum2.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple2.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple3.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple4.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple5.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Unit.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Word8.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Wrap.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPVSegd.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
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Vector.hs

index 2ae6ccb..d947b7f 100644 (file)
@@ -79,12 +79,12 @@ instance PR Double where
 
   {-# INLINE_PDATA indexPR #-}
   indexPR (PDouble arr) ix
-        = arr U.!: ix
+        = arr `U.unsafeIndex` ix
 
   {-# INLINE_PDATA indexsPR #-}
   indexsPR (PDoubles pvecs) (PInt srcs) (PInt ixs)
    = PDouble $ U.zipWith get srcs ixs
-   where get !src !ix   = (pvecs V.! src) U.!: ix     -- SAFE INDEXING SIMPLIFIER BUG WORKAROUND
+   where get !src !ix   = (pvecs `V.unsafeIndex` src) `U.unsafeIndex` ix
 
 
   {-# NOINLINE extractPR #-}
@@ -136,7 +136,7 @@ instance PR Double where
         
   {-# INLINE_PDATA indexdPR #-}
   indexdPR (PDoubles vec) ix
-        = PDouble $ vec V.! ix
+        = PDouble $ vec `V.unsafeIndex` ix
 
   {-# INLINE_PDATA appenddPR #-}
   appenddPR (PDoubles xs) (PDoubles ys)
index 2387040..e65690a 100644 (file)
@@ -67,13 +67,13 @@ instance PR Int where
 
   {-# INLINE_PDATA indexPR #-}
   indexPR (PInt uarr) ix
-        = uarr U.!: ix
+        = uarr `U.unsafeIndex` ix
 
   {-# INLINE_PDATA indexsPR #-}
   indexsPR (PInts pvecs) (PInt srcs) (PInt ixs)
    = PInt $ U.zipWith get srcs ixs
    where get !src !ix
-                = (pvecs V.! src) U.!: ix         -- SAFE INDEXING SIMPLIFIER BUG WORKAROUND
+                = (pvecs `V.unsafeIndex` src) `U.unsafeIndex` ix
 
   {-# NOINLINE extractPR #-}
   extractPR (PInt arr) start len 
@@ -125,7 +125,7 @@ instance PR Int where
         
   {-# INLINE_PDATA indexdPR #-}
   indexdPR (PInts vec) ix
-        = PInt $ vec V.! ix
+        = PInt $ vec `V.unsafeIndex` ix
 
   {-# INLINE_PDATA appenddPR #-}
   appenddPR (PInts xs) (PInts ys)
index f035ac7..cc535a4 100644 (file)
@@ -22,7 +22,6 @@ import qualified Data.IntSet                    as IS
 import qualified Data.Array.Parallel.Unlifted   as U
 import qualified Data.Vector                    as V
 import GHC.Exts
-import Debug.Trace
 
 -- TODO: Using plain V.Vector for the psegdata field means that operations on
 --       this field aren't parallelised. In particular, when we append two
@@ -289,12 +288,13 @@ instance PR a => PR (PArray a) where
 
          -- length, start and srcid of the segments we're returning.
          --   Note that we need to offset the srcid 
+         -- TODO: don't unbox the VSegd for every iteration.
          seginfo :: U.Array (Int, Int, Int)
          seginfo 
           = U.zipWith (\srcid ix -> 
                         let (PNested vsegd _)   = pdatas `indexdPR` srcid
                             (len, start, srcid') = U.getSegOfVSegd vsegd ix
-                        in  (len, start, srcid' + (psrcoffset V.! srcid)))
+                        in  (len, start, srcid' + (psrcoffset `V.unsafeIndex` srcid)))
                 srcids
                 ixs
 
@@ -377,10 +377,10 @@ instance PR a => PR (PArray a) where
          -- Function to get one element of the result.
          {-# INLINE get #-}
          get srcid vsegid
-          = let !pseglen        = (arrs_pseglens   V.! srcid) U.!: vsegid
-                !psegstart      = (arrs_psegstarts V.! srcid) U.!: vsegid
-                !psegsrcid      = (arrs_psegsrcids V.! srcid) U.!: vsegid  
-                                + psrcoffset V.! srcid
+          = let !pseglen        = (arrs_pseglens   `V.unsafeIndex` srcid) `U.unsafeIndex` vsegid
+                !psegstart      = (arrs_psegstarts `V.unsafeIndex` srcid) `U.unsafeIndex` vsegid
+                !psegsrcid      = (arrs_psegsrcids `V.unsafeIndex` srcid) `U.unsafeIndex` vsegid  
+                                + psrcoffset `V.unsafeIndex` srcid
             in  (pseglen, psegstart, psegsrcid)
             
          (pseglens', psegstarts', psegsrcs')
@@ -456,7 +456,7 @@ instance PR a => PR (PArray a) where
         
   {-# INLINE_PDATA indexdPR #-}
   indexdPR (PNesteds vec) ix
-        = vec V.! ix
+        = vec `V.unsafeIndex` ix
 
   {-# INLINE_PDATA appenddPR #-}
   appenddPR (PNesteds xs) (PNesteds ys)
@@ -587,7 +587,7 @@ concatlPR arr
 
         ixs'            = U.map (\ix -> if ix >= len2
                                                 then 0
-                                                else ixs2 U.!: ix)
+                                                else ixs2 `U.unsafeIndex` ix)
                         $ ixs1
 
         segd'           = U.mkSegd (U.sum_s segd1 (U.lengthsSegd segd2))
index b10391e..c803892 100644 (file)
@@ -135,8 +135,8 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
   
   {-# INLINE_PDATA indexPR #-}
   indexPR (PSum2 sel as bs) i
-   = let !k = U.indicesSel2 sel U.!: i
-     in  case U.tagsSel2 sel U.!: i of
+   = let !k = U.indicesSel2 sel `U.unsafeIndex` i
+     in  case U.tagsSel2    sel `U.unsafeIndex` i of
              0 -> Alt2_1 (indexPR as k)
              _ -> Alt2_2 (indexPR bs k)
 
@@ -144,9 +144,9 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
   indexsPR (PSum2s sels ass bss) psrcs@(PInt srcs) (PInt ixs)
    = let 
          getFlagIndex !src !ix
-          = let !sel        = sels                V.!  src
-                !elemFlag   = (U.tagsSel2    sel) U.!: ix
-                !elemIndex  = (U.indicesSel2 sel) U.!: ix
+          = let !sel        = sels                `V.unsafeIndex` src
+                !elemFlag   = (U.tagsSel2    sel) `U.unsafeIndex` ix
+                !elemIndex  = (U.indicesSel2 sel) `U.unsafeIndex` ix
             in  (elemFlag, elemIndex)
             
          (flags', indices')
@@ -307,7 +307,9 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
          -- starts0     = [ 0 0 1 1 0 ]
          sel0           = U.packByTag indices' tags' 0
          sel0_len       = U.length sel0
-         starts0        = U.map (\i -> if i >= sel0_len then 0 else sel0 U.!: i) indices0
+         starts0        = U.map (\i -> if i >= sel0_len
+                                        then 0 
+                                        else sel0 `U.unsafeIndex` i) indices0
 
          -- indices1    = [ 0 2 3 3 4 ] (from above)
          -- sel1        = [ 1 2 0 3 0 ]
@@ -315,7 +317,9 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
          -- starts1     = [ 1 0 3 3 0 ]
          sel1           = U.packByTag indices' tags' 1
          sel1_len       = U.length sel1
-         starts1        = U.map (\i -> if i >= sel1_len then 0 else sel1 U.!: i) indices1
+         starts1        = U.map (\i -> if i >= sel1_len
+                                        then 0
+                                        else sel1 `U.unsafeIndex` i) indices1
 
          -- Extract the final alts data:
          -- sources     = [ 1 0 1 0 1 ] (from above)
@@ -456,7 +460,7 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
 
   {-# INLINE_PDATA indexdPR #-}
   indexdPR  (PSum2s sel2s xss yss) ix
-   = PSum2  (sel2s V.! ix)
+   = PSum2  (sel2s `V.unsafeIndex` ix)
             (indexdPR      xss   ix)
             (indexdPR      yss   ix)
 
index 41ff66b..fc1627c 100644 (file)
@@ -20,10 +20,10 @@ import qualified Data.Array.Parallel.Unlifted   as U
 
 -------------------------------------------------------------------------------
 data instance PData (a, b)
-        = PTuple2  (PData a) (PData b)
+        = PTuple2  !(PData a) !(PData b)
 
 data instance PDatas (a, b)
-        = PTuple2s (PDatas a) (PDatas b)
+        = PTuple2s !(PDatas a) !(PDatas b)
 
 
 -- PR -------------------------------------------------------------------------
index 92bf697..877bb11 100644 (file)
@@ -16,10 +16,10 @@ import qualified Prelude                        as P
 
 -------------------------------------------------------------------------------
 data instance PData (a, b, c)
-        = PTuple3  (PData a) (PData b) (PData c)
+        = PTuple3  !(PData a)  !(PData b)  !(PData c)
 
 data instance PDatas (a, b, c)
-        = PTuple3s (PDatas a) (PDatas b) (PDatas c)
+        = PTuple3s !(PDatas a) !(PDatas b) !(PDatas c)
 
 
 -- PR -------------------------------------------------------------------------
index 2f08902..5d93134 100644 (file)
@@ -17,10 +17,10 @@ import qualified Data.List                      as P
 
 -------------------------------------------------------------------------------
 data instance PData (a, b, c, d)
-        = PTuple4  (PData a) (PData b) (PData c) (PData d)
+        = PTuple4  !(PData a)  !(PData b)  !(PData c)  !(PData d)
 
 data instance PDatas (a, b, c, d)
-        = PTuple4s (PDatas a) (PDatas b) (PDatas c) (PDatas d)
+        = PTuple4s !(PDatas a) !(PDatas b) !(PDatas c) !(PDatas d)
 
 
 -- PR -------------------------------------------------------------------------
index 297f909..68a0f91 100644 (file)
@@ -17,10 +17,10 @@ import qualified Data.List                      as P
 
 -------------------------------------------------------------------------------
 data instance PData (a, b, c, d, e)
-        = PTuple5  (PData a) (PData b) (PData c) (PData d) (PData e)
+        = PTuple5  !(PData a)  !(PData b)  !(PData c)  !(PData d)  !(PData e)
 
 data instance PDatas (a, b, c, d, e)
-        = PTuple5s (PDatas a) (PDatas b) (PDatas c) (PDatas d) (PDatas e)
+        = PTuple5s !(PDatas a) !(PDatas b) !(PDatas c) !(PDatas d) !(PDatas e)
 
 
 -- PR -------------------------------------------------------------------------
index 5e9d2f0..e3dfe97 100644 (file)
@@ -14,10 +14,10 @@ import qualified Data.Vector                    as V
 --   and rely on coversPR to check that indices are in bounds, like we do
 --   with arrays of type PData Void.
 data instance PData ()
-        = PUnit Int
+        = PUnit  !Int
 
 data instance PDatas ()
-        = PUnits (U.Array Int)
+        = PUnits !(U.Array Int)
 
 punit   :: Int -> PData ()
 punit   = PUnit
@@ -131,7 +131,7 @@ instance PR () where
         
   {-# INLINE_PDATA indexdPR #-}
   indexdPR (PUnits pdatas) ix
-        = PUnit $ pdatas U.!: ix
+        = PUnit $ pdatas `U.unsafeIndex` ix
         
   {-# INLINE_PDATA appenddPR #-}
   appenddPR (PUnits lens1) (PUnits lens2)
index c1adfde..6c45aab 100644 (file)
@@ -13,7 +13,7 @@ import Data.Array.Parallel.Pretty
 
 -------------------------------------------------------------------------------
 data instance PData Word8
-        = PWord8 !(U.Array Word8)
+        = PWord8  !(U.Array Word8)
 
 data instance PDatas Word8
         = PWord8s !(V.Vector (U.Array Word8))
@@ -76,13 +76,13 @@ instance PR Word8 where
 
   {-# INLINE_PDATA indexPR #-}
   indexPR (PWord8 uarr) ix
-        = uarr U.!: ix
+        = uarr `U.unsafeIndex` ix
 
   {-# INLINE_PDATA indexsPR #-}
   indexsPR (PWord8s pvecs) (PInt srcs) (PInt ixs)
    = PWord8 $ U.zipWith get srcs ixs
    where get !src !ix
-                = (pvecs V.! src) U.!: ix
+                = (pvecs `V.unsafeIndex` src) `U.unsafeIndex` ix
 
   {-# NOINLINE extractPR #-}
   extractPR (PWord8 arr) start len 
@@ -133,7 +133,7 @@ instance PR Word8 where
         
   {-# INLINE_PDATA indexdPR #-}
   indexdPR (PWord8s vec) ix
-        = PWord8 $ vec V.! ix
+        = PWord8 $ vec `V.unsafeIndex` ix
 
   {-# INLINE_PDATA appenddPR #-}
   appenddPR (PWord8s xs) (PWord8s ys)
index 490bd05..7a91a2c 100644 (file)
@@ -10,7 +10,7 @@ import qualified Data.Vector                    as V
 
 -------------------------------------------------------------------------------
 newtype instance PData (Wrap a)
-        = PWrap (PData a)
+        = PWrap  (PData a)
 
 newtype instance PDatas (Wrap a)
         = PWraps (PDatas a)
index 1ce2592..90f1a8c 100644 (file)
@@ -73,6 +73,8 @@ import qualified Data.Vector                                    as VS
 
 -- | O(n). Segmented extract.
 
+-- TODO: make a uvsegd version that backs off to this one if the uvsegd is manifest.
+--
 -- TODO: zip srcids ixBase and startsix before calling replicate_s
 --       don't want to replicate_s multiple times on same segd.
 --
@@ -90,28 +92,28 @@ extractsUP
         -> Vector Int           -- ^ Length of each segment.
         -> Vector a
 
-extractsUP arrs srcids ixBase lens 
+extractsUP !arrs !srcids !ixBase !lens 
  = let -- total length of the result
-        dstLen    = sumUP lens
-        segd      = UPSegd.fromLengths lens
+        !dstLen    = sumUP lens
+        !segd      = UPSegd.fromLengths lens
     
         -- source array ids to load from
-        srcids'   = UPSegd.replicateWithP segd srcids
+        !srcids'   = UPSegd.replicateWithP segd srcids
 
         -- base indices in the source array to load from
-        baseixs   = UPSegd.replicateWithP segd ixBase
+        !baseixs   = UPSegd.replicateWithP segd ixBase
         
         -- starting indices for each of the segments
-        startixs  = scanUP (+) 0 lens
+        !startixs  = scanUP (+) 0 lens
           
         -- starting indices for each of the segments in the result
-        startixs' = UPSegd.replicateWithP segd startixs
+        !startixs' = UPSegd.replicateWithP segd startixs
 
         {-# INLINE get #-}
         get (ixDst, ixSegDst) (ixSegSrcBase, srcid)
-         = let  !arr    = arrs VS.! srcid                        -- TODO: use unsafeIndex
+         = let  !arr    = arrs `VS.unsafeIndex` srcid
                 !ix     = ixDst - ixSegDst + ixSegSrcBase
-           in   arr US.! ix                                    -- TODO unsafe unsafeIndex
+           in   arr `US.unsafeIndex` ix
          
         result    = zipWithUP get
                         (US.zip (enumFromToUP 0 (dstLen - 1))
index 3a37d5c..0b003a0 100644 (file)
@@ -47,7 +47,6 @@ import Data.Array.Parallel.Unlifted.Parallel.UPSegd             (UPSegd)
 import Data.Array.Parallel.Unlifted.Sequential.Vector           (Vector)
 import Data.Array.Parallel.Pretty                               hiding (empty)
 import Prelude                                                  hiding (length)
-
 import qualified Data.Array.Parallel.Unlifted.Sequential.Vector as US
 import qualified Data.Array.Parallel.Unlifted.Sequential.USSegd as USSegd
 import qualified Data.Array.Parallel.Unlifted.Parallel.UPSel    as UPSel
@@ -258,7 +257,7 @@ takeUPSSegdRedundant    = upvsegd_upssegd_redundant
 takeLengths :: UPVSegd -> Vector Int
 takeLengths (UPVSegd manifest _ vsegids _ upssegd)
  | manifest     = UPSSegd.takeLengths upssegd
- | otherwise    = US.map (UPSSegd.takeLengths upssegd US.!) vsegids
+ | otherwise    = US.map (US.unsafeIndex (UPSSegd.takeLengths upssegd)) vsegids
 {-# NOINLINE takeLengths #-}
 --  NOINLINE because we don't want a case expression due to the test on the 
 --  manifest flag to appear in the core program.
@@ -276,7 +275,7 @@ getSeg upvsegd ix
  = let  vsegids = upvsegd_vsegids_redundant upvsegd
         upssegd = upvsegd_upssegd_redundant upvsegd
         (len, _index, start, source)
-                = UPSSegd.getSeg upssegd (vsegids US.! ix)
+                = UPSSegd.getSeg upssegd (vsegids `US.unsafeIndex` ix)
    in   (len, start, source)
 {-# INLINE_UP getSeg #-}
 
index f5f29d7..e338111 100644 (file)
@@ -42,7 +42,6 @@ import qualified Data.Vector                                    as V
 import qualified Data.Vector.Fusion.Stream                      as S
 import qualified Data.Vector.Fusion.Stream.Size                 as S
 import qualified Data.Vector.Fusion.Stream.Monadic              as M
-import qualified Data.Vector.Unboxed            as VU
 
 
 -- USSegd ---------------------------------------------------------------------
@@ -217,8 +216,8 @@ getSeg (USSegd _ starts sources usegd) ix
  = let  (len, index) = USegd.getSeg usegd ix
    in   ( len
         , index
-        , starts  U.! ix
-        , sources U.! ix)
+        , starts  `U.unsafeIndex` ix
+        , sources `U.unsafeIndex` ix)
 {-# INLINE_U getSeg #-}
 
 
@@ -233,7 +232,7 @@ appendWith
         -> USSegd
 appendWith
         (USSegd _ starts1 srcs1 usegd1) pdatas1
-       (USSegd _ starts2 srcs2 usegd2) _
+        (USSegd _ starts2 srcs2 usegd2) _
         = USSegd False
                  (starts1  U.++  starts2)
                  (srcs1    U.++  U.map (+ pdatas1) srcs2)
@@ -292,7 +291,7 @@ cullOnVSegids vsegids (USSegd _ starts sources usegd)
         -- 
         --      vsegids':       [0 1 1 2 3 3 4 4]
         --
-        vsegids'  = U.map (psegids_map U.!) vsegids
+        vsegids'  = U.map (U.unsafeIndex psegids_map) vsegids
 
         -- Rebuild the usegd.
         starts'   = U.pack starts  psegids_used
@@ -343,15 +342,15 @@ streamSegs ussegd@(USSegd _ starts sources usegd) pdatas
          = return $ S.Done
          
          -- Current pseg is done
-         | ix   >= pseglens `VU.unsafeIndex` pseg 
+         | ix   >= pseglens `U.unsafeIndex` pseg 
          = return $ S.Skip (pseg + 1, 0)
 
          -- Stream an element from this pseg
          | otherwise
-         = let  !srcid   = sources `VU.unsafeIndex` pseg
-                !pdata   = pdatas   `V.unsafeIndex` srcid
-                !start   = starts  `VU.unsafeIndex` pseg
-                !result  = pdata   `VU.unsafeIndex` (start + ix)
+         = let  !srcid   = sources `U.unsafeIndex` pseg
+                !pdata   = pdatas  `V.unsafeIndex` srcid
+                !start   = starts  `U.unsafeIndex` pseg
+                !result  = pdata   `U.unsafeIndex` (start + ix)
            in   return $ S.Yield result (pseg, ix + 1)
 
    in   M.Stream fn (0, 0) S.Unknown
index 015f5ae..d17af47 100644 (file)
@@ -20,7 +20,7 @@ module Data.Array.Parallel.Unlifted.Sequential.USegd (
   -- * Operations
   append, slice, extract
 ) where
-import qualified Data.Array.Parallel.Unlifted.Sequential.Vector as V
+import qualified Data.Array.Parallel.Unlifted.Sequential.Vector as U
 import Data.Array.Parallel.Unlifted.Sequential.Vector           (Vector)
 import Data.Array.Parallel.Pretty                               hiding (empty)
 import Prelude                                                  hiding (length)
@@ -30,7 +30,7 @@ import Prelude                                                  hiding (length)
 --   of elements.
 --  
 --   The defined array is an array of segments, where every segment covers some
---   of the elements from the flat array.
+--   of the elements from the flU.at array.
 --
 --   /INVARIANT:/ The segment starting indices must be monotonically increasing,
 --   and all elements from the flat array must be covered by some segment.
@@ -59,8 +59,8 @@ instance PprPhysical USegd where
  pprp (USegd lengths indices elements)
   =   text "USegd" 
   $$  (nest 7 $ vcat
-        [ text "lengths: " <+> (text $ show $ V.toList lengths)
-        , text "indices: " <+> (text $ show $ V.toList indices)
+        [ text "lengths: " <+> (text $ show $ U.toList lengths)
+        , text "indices: " <+> (text $ show $ U.toList indices)
         , text "elements:" <+> (text $ show elements)])
 
 
@@ -90,7 +90,7 @@ valid usegd@(USegd lengths _ _)
 
 -- | O(1). Construct an empty segment descriptor, with no elements or segments.
 empty :: USegd
-empty   = USegd V.empty V.empty 0
+empty   = USegd U.empty U.empty 0
 {-# INLINE_U empty #-}
 
 
@@ -98,7 +98,7 @@ empty   = USegd V.empty V.empty 0
 --   The single segment covers the given number of elements.
 singleton :: Int -> USegd
 singleton n
-        = USegd (V.singleton n) (V.singleton 0) n
+        = USegd (U.singleton n) (U.singleton 0) n
 {-# INLINE_U singleton #-}
 
 
@@ -108,7 +108,7 @@ singleton n
 --   indices from that.
 fromLengths :: Vector Int -> USegd
 fromLengths lens
-        = USegd lens (V.scanl (+) 0 lens) (V.sum lens)
+        = USegd lens (U.scanl (+) 0 lens) (U.sum lens)
 {-# INLINE_U fromLengths #-}
 
 
@@ -117,7 +117,7 @@ fromLengths lens
 
 -- | O(1). Yield the overall number of segments.
 length :: USegd -> Int
-length          = V.length . usegd_lengths
+length          = U.length . usegd_lengths
 {-# INLINE length #-}
 
 
@@ -142,8 +142,8 @@ takeElements    = usegd_elements
 -- | O(1). Get the length and segment index of a segment
 getSeg :: USegd -> Int -> (Int, Int)
 getSeg (USegd lengths indices _ ) ix
- =      ( lengths V.! ix
-        , indices V.! ix)
+ =      ( lengths `U.unsafeIndex` ix
+        , indices `U.unsafeIndex` ix)
 {-# INLINE_U getSeg #-}
 
 
@@ -153,8 +153,8 @@ getSeg (USegd lengths indices _ ) ix
 append :: USegd -> USegd -> USegd
 append (USegd lengths1 indices1 elems1)
             (USegd lengths2 indices2 elems2)
- = USegd (lengths1 V.++ lengths2)
-         (indices1 V.++ V.map (+ elems1) indices2)
+ = USegd (lengths1 U.++ lengths2)
+         (indices1 U.++ U.map (+ elems1) indices2)
          (elems1 + elems2)
 {-# INLINE_U append #-}
 
@@ -173,7 +173,7 @@ slice
         -> Int          -- ^ Number of segments to slice out.
         -> USegd
 slice segd i n
-        = fromLengths $ V.slice (takeLengths segd) i n
+        = fromLengths $ U.unsafeSlice (takeLengths segd) i n
 {-# INLINE_U slice #-}
 
 
@@ -190,6 +190,6 @@ extract
         -> Int          -- ^ Number of segments to extract out.
         -> USegd
 extract segd i n 
-        = fromLengths $ V.extract (takeLengths segd) i n
+        = fromLengths $ U.extract (takeLengths segd) i n
 {-# INLINE_U extract #-}
 
index f6ae9b1..4ab8a66 100644 (file)
@@ -42,8 +42,7 @@ import Data.Array.Parallel.Unlifted.Sequential.USegd            (USegd)
 import Data.Array.Parallel.Unlifted.Sequential.Vector           (Vector)
 import Data.Array.Parallel.Pretty                               hiding (empty)
 import Prelude                                                  hiding (length)
-
-import qualified Data.Array.Parallel.Unlifted.Sequential.Vector as V
+import qualified Data.Array.Parallel.Unlifted.Sequential.Vector as U
 import qualified Data.Array.Parallel.Unlifted.Sequential.USSegd as USSegd
 import qualified Data.Array.Parallel.Unlifted.Sequential.USegd  as USegd
 
@@ -59,7 +58,7 @@ import qualified Data.Array.Parallel.Unlifted.Sequential.USegd  as USegd
 data UVSegd 
         = UVSegd 
         { uvsegd_manifest       :: !Bool
-          -- ^ When the vsegids field holds a lazy @(V.enumFromTo 0 (len - 1))@
+          -- ^ When the vsegids field holds a lazy @(U.enumFromTo 0 (len - 1))@
           --   then this field is True. This lets us perform some operations like
           --   `demoteToUPSSegd` without actually creating it.
           
@@ -75,7 +74,7 @@ data UVSegd
 instance PprPhysical UVSegd where
  pprp (UVSegd _ vsegids ussegd)
   = vcat
-  [ text "UVSegd" $$ (nest 7 $ text "vsegids: " <+> (text $ show $ V.toList vsegids))
+  [ text "UVSegd" $$ (nest 7 $ text "vsegids: " <+> (text $ show $ U.toList vsegids))
   , pprp ussegd ]
 
 
@@ -85,7 +84,7 @@ instance PprPhysical UVSegd where
 --   * TODO: check that all vsegs point to a valid pseg
 valid :: UVSegd -> Bool
 valid (UVSegd _ vsegids ussegd)
-        = V.length vsegids == USSegd.length ussegd
+        = U.length vsegids == USSegd.length ussegd
 {-# NOINLINE valid #-}
 --  NOINLINE because it's only enabled during debugging anyway.
 
@@ -110,7 +109,7 @@ mkUVSegd = UVSegd False
 fromUSSegd :: USSegd -> UVSegd
 fromUSSegd ussegd
         = UVSegd True
-                 (V.enumFromTo 0 (USSegd.length ussegd - 1))
+                 (U.enumFromTo 0 (USSegd.length ussegd - 1))
                  ussegd
 {-# INLINE_U fromUSSegd #-}
 
@@ -128,7 +127,7 @@ fromUSegd
 
 -- | O(1). Construct an empty segment descriptor, with no elements or segments.
 empty :: UVSegd
-empty   = UVSegd True V.empty USSegd.empty
+empty   = UVSegd True U.empty USSegd.empty
 {-# INLINE_U empty #-}
 
 
@@ -137,7 +136,7 @@ empty   = UVSegd True V.empty USSegd.empty
 --   with sourceid 0.
 singleton :: Int -> UVSegd
 singleton n 
-        = UVSegd True (V.singleton 0) (USSegd.singleton n)
+        = UVSegd True (U.singleton 0) (USSegd.singleton n)
 {-# INLINE_U singleton #-}
 
 
@@ -182,14 +181,14 @@ takeUSSegd      = uvsegd_ussegd
 
 -- | O(1). Yield the overall number of segments described by a `UVSegd`.
 length :: UVSegd -> Int
-length          = V.length . uvsegd_vsegids
+length          = U.length . uvsegd_vsegids
 {-# INLINE length #-}
 
 
 -- | O(segs). Yield the lengths of the segments described by a `UVSegd`.
 takeLengths :: UVSegd -> Vector Int
 takeLengths (UVSegd _ vsegids ussegd)
-        = V.map (USSegd.takeLengths ussegd V.!) vsegids
+        = U.map (U.unsafeIndex (USSegd.takeLengths ussegd)) vsegids
 {-# INLINE_U takeLengths #-}
 
 
@@ -202,7 +201,8 @@ takeLengths (UVSegd _ vsegids ussegd)
 --
 getSeg :: UVSegd -> Int -> (Int, Int, Int)
 getSeg (UVSegd _ vsegids ussegd) ix
- = let  (len, _index, start, source) = USSegd.getSeg ussegd (vsegids V.! ix)
+ = let  (len, _index, start, source) 
+                = USSegd.getSeg ussegd (vsegids `U.unsafeIndex` ix)
    in   (len, start, source)
 {-# INLINE_U getSeg #-}
 
@@ -253,9 +253,9 @@ updateVSegsReachable fUpdate (UVSegd _ vsegids upssegd)
 -- 
 demoteToUSSegd :: UVSegd -> USSegd
 demoteToUSSegd (UVSegd _ vsegids ussegd)
- = let  starts'         = V.bpermute (USSegd.takeStarts  ussegd)  vsegids
-        sources'        = V.bpermute (USSegd.takeSources ussegd) vsegids
-        lengths'        = V.bpermute (USSegd.takeLengths ussegd) vsegids
+ = let  starts'         = U.bpermute (USSegd.takeStarts  ussegd)  vsegids
+        sources'        = U.bpermute (USSegd.takeSources ussegd) vsegids
+        lengths'        = U.bpermute (USSegd.takeLengths ussegd) vsegids
         usegd'          = USegd.fromLengths lengths'
    in   USSegd.mkUSSegd starts' sources' usegd'
 {-# NOINLINE demoteToUSSegd #-}
@@ -276,7 +276,7 @@ demoteToUSSegd (UVSegd _ vsegids ussegd)
 unsafeDemoteToUSegd :: UVSegd -> USegd
 unsafeDemoteToUSegd (UVSegd _ vsegids ussegd)
         = USegd.fromLengths
-        $ V.bpermute (USSegd.takeLengths ussegd) vsegids
+        $ U.bpermute (USSegd.takeLengths ussegd) vsegids
 {-# NOINLINE unsafeDemoteToUSegd #-}
 --  NOINLINE because it won't fuse with anything.
 
@@ -326,10 +326,10 @@ appendWith
 
  = let  -- vsegids releative to appended psegs
         vsegids1' = vsegids1
-        vsegids2' = V.map (+ USSegd.length ussegd1) vsegids2
+        vsegids2' = U.map (+ USSegd.length ussegd1) vsegids2
         
         -- append the vsegids
-        vsegids'  = vsegids1' V.++ vsegids2'
+        vsegids'  = vsegids1' U.++ vsegids2'
 
         -- All data from the source arrays goes into the result
         ussegd'   = USSegd.appendWith
@@ -386,10 +386,10 @@ combine2  usel2
 
  = let  -- vsegids relative to combined psegs
         vsegids1' = vsegids1
-        vsegids2' = V.map (+ (V.length vsegids1)) vsegids2
+        vsegids2' = U.map (+ (U.length vsegids1)) vsegids2
 
         -- combine the vsegids
-        vsegids'  = V.combine2ByTag (tagsUSel2 usel2)
+        vsegids'  = U.combine2ByTag (tagsUSel2 usel2)
                                     vsegids1' vsegids2'
 
          -- All data from the source arrays goes into the result
index 26fc943..a68484a 100644 (file)
@@ -30,13 +30,18 @@ module Data.Array.Parallel.Unlifted.Sequential.Vector (
   interleave, indexed, repeat, repeatS,
 
   -- * Subarrays
-  slice, extract,
+  slice,   unsafeSlice,
+  extract, unsafeExtract,
   tail,
   take, drop, splitAt,
 
   -- * Permutations
-  permute, bpermute, mbpermute, bpermuteDft, reverse, update,
-
+  permute,
+  bpermute,
+  mbpermute,
+  bpermuteDft,
+  reverse,
+  update,
 
   -- * Higher-order operations
   map, zipWith, zipWith3,
@@ -55,10 +60,10 @@ module Data.Array.Parallel.Unlifted.Sequential.Vector (
   and, or, any, all,
 
   -- * Arithmetic operations
-  sum, product,
-  maximum, minimum,
-  maximumBy, minimumBy,
-  maxIndex, minIndex,
+  sum,        product,
+  maximum,    minimum,
+  maximumBy,  minimumBy,
+  maxIndex,   minIndex,
   maxIndexBy, minIndexBy,
 
   -- * Arrays of pairs
@@ -66,7 +71,11 @@ module Data.Array.Parallel.Unlifted.Sequential.Vector (
   zip3, unzip3,
 
   -- * Enumerations
-  enumFromTo, enumFromThenTo, enumFromStepLen, enumFromToEach, enumFromStepLenEach,
+  enumFromTo,
+  enumFromThenTo,
+  enumFromStepLen,
+  enumFromToEach,
+  enumFromStepLenEach,
 
   -- * Searching
   find, findIndex,
@@ -91,22 +100,22 @@ module Data.Array.Parallel.Unlifted.Sequential.Vector (
 
 import Data.Array.Parallel.Stream
 import Data.Array.Parallel.Base ( Tag, checkEq, ST )
+import qualified Data.Vector.Unboxed            as V
+import qualified Data.Vector.Unboxed.Mutable    as M
+import qualified Data.Vector.Unboxed.Base       as VBase
+import qualified Data.Vector.Generic            as G
+import qualified Data.Vector.Generic.Mutable    as MG
+import qualified Data.Vector.Storable           as Storable
+import qualified Data.Vector.Storable.Mutable   as MStorable
+import qualified Data.Vector.Generic.New        as New
+import qualified Data.Vector.Fusion.Stream      as S
+import Data.Vector.Fusion.Stream.Monadic        ( Stream(..), Step(..) )
+import Data.Vector.Fusion.Stream.Size           ( Size(..) )
+import Data.Vector.Generic                      ( stream, unstream )
 
 import Data.Vector.Unboxed 
-        hiding ( slice, zip, unzip, zip3, unzip3, foldl, foldl1, scanl, scanl1 )
-
-import qualified Data.Vector.Unboxed as V
-import qualified Data.Vector.Unboxed.Mutable as M
-import qualified Data.Vector.Unboxed.Base as VBase
-import Data.Vector.Generic ( stream, unstream )
-import qualified Data.Vector.Generic as G
-import qualified Data.Vector.Generic.Mutable as MG
-import qualified Data.Vector.Storable as Storable
-import qualified Data.Vector.Storable.Mutable as MStorable
-import qualified Data.Vector.Generic.New as New
-import qualified Data.Vector.Fusion.Stream as S
-import Data.Vector.Fusion.Stream.Monadic ( Stream(..), Step(..) )
-import Data.Vector.Fusion.Stream.Size ( Size(..) )
+        hiding ( slice, zip, unzip, zip3, unzip3, foldl, foldl1, scanl, scanl1,
+                 unsafeSlice )
 
 import Prelude 
         hiding ( length, null,
@@ -172,16 +181,30 @@ repeatS k !xs = Stream next (0,k) (Exact (k*n))
                | otherwise = return $ Yield (unsafeIndex xs i) (i+1,k)
 
 
+-- Take a sub-range of a vector, avoiding copying.
 slice :: Unbox a => Vector a -> Int -> Int -> Vector a
 {-# INLINE_U slice #-}
 slice xs i n = V.slice i n xs
 
 
+-- Take a sub-range of a vector, avoiding copying, without bounds checks.
+unsafeSlice :: Unbox a => Vector a -> Int -> Int -> Vector a
+{-# INLINE_U unsafeSlice #-}
+unsafeSlice xs i n = V.unsafeSlice i n xs
+
+
+-- Copy out a subrange of a vector.
 extract :: Unbox a => Vector a -> Int -> Int -> Vector a
 {-# INLINE_U extract #-}
 extract xs i n = force (V.slice i n xs)
 
 
+-- Copy out a subrange of a vector, without bounds checks.
+unsafeExtract :: Unbox a => Vector a -> Int -> Int -> Vector a
+{-# INLINE_U unsafeExtract #-}
+unsafeExtract xs i n = force (V.unsafeSlice i n xs)
+
+
 mupdate :: Unbox e => MVector s e -> Vector (Int,e) -> ST s ()
 {-# INLINE_U mupdate #-}
 mupdate marr xs = MG.update marr (stream xs)