Rename unsafe stream ops, now that safety depends on config flag in dph-base
authorBen Lippmeier <benl@ouroborus.net>
Mon, 12 Dec 2011 02:04:19 +0000 (13:04 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Mon, 12 Dec 2011 02:04:19 +0000 (13:04 +1100)
18 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/Word8.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.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Combinators.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Elems.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Ixs.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Segments.hs

index 1da30c0..b141a9a 100644 (file)
@@ -95,7 +95,7 @@ instance PR Double where
 
   {-# INLINE_PDATA extractssPR #-}
   extractssPR (PDoubles arrs) ssegd
-        = PDouble (U.unsafeExtracts_ass ssegd arrs)
+        = PDouble (U.extracts_ass ssegd arrs)
 
   -- {-# INLINE_PDATA extractvsPR #-}
   -- extractvsPR (PDoubles arrs) vsegd
index 566910f..1be96ab 100644 (file)
@@ -84,7 +84,7 @@ instance PR Int where
 
   {-# INLINE_PDATA extractssPR #-}
   extractssPR (PInts arrs) ssegd
-        = PInt $ U.unsafeExtracts_ass ssegd arrs
+        = PInt $ U.extracts_ass ssegd arrs
 
   -- {-# INLINE_PDATA extractvsPR #-}
   -- extractvsPR (PInts arrs) vsegd
index bcf74cb..f59c365 100644 (file)
@@ -391,7 +391,7 @@ instance PR a => PR (PArray a) where
    = let segsrcs        = U.sourcesOfSSegd ussegd
          seglens        = U.lengthsOfSSegd ussegd
 
-         vsegids_src    = U.unsafeExtracts_nss ussegd (V.map pnested_vsegids arrs)
+         vsegids_src    = U.extracts_nss ussegd (V.map pnested_vsegids arrs)
          srcids'        = U.replicate_s (U.lengthsToSegd seglens) segsrcs
 
          -- See Note: psrcoffset
index 8110f6a..37be694 100644 (file)
@@ -257,7 +257,7 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
          --  and rebuild the result selector indices based on these tags.
          -- tags'       = [1     1     0     0     1     1     0      0     1]
          -- sel'        = [0     1     0     1     2     3     2      3     4]   
-         tags'          = U.unsafeExtracts_nss ssegd tagss
+         tags'          = U.extracts_nss ssegd tagss
          sel'           = U.tagsToSel2 tags'
 
          -- Extract the indices of the data elements we want.
@@ -265,7 +265,7 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
          -- (result)      [R 60, R 70, L 80, L 20, R 30, R 90, L 100, L 40, R 50]
          --                ----------------0 ----------1 -----------2 ----3 ----4
          -- indices'    = [  1     2     0     0     0     3     1      1     0 ]
-         indices'       = U.unsafeExtracts_nss ssegd (V.map U.indicesSel2 sels)
+         indices'       = U.extracts_nss ssegd (V.map U.indicesSel2 sels)
 
          -- Count the number of L and R elements for each segment,
          --  then scan them to produce the starting index of each segment in the
index de312fa..db3b20a 100644 (file)
@@ -92,7 +92,7 @@ instance PR Word8 where
 
   {-# INLINE_PDATA extractssPR #-}
   extractssPR (PWord8s arrs) ssegd
-        = PWord8 $ U.unsafeExtracts_ass ssegd arrs
+        = PWord8 $ U.extracts_ass ssegd arrs
 
   -- {-# INLINE_PDATA extractvsPR #-}
   -- extractvsPR (PWord8s arrs) vsegd
index 9c06819..95f6d6f 100644 (file)
@@ -85,20 +85,20 @@ enumFromStepLenEach size starts steps lens
 
 
 -- Projections ----------------------------------------------------------------
-length                  = P.length
-index _                 = (P.!!)
-unsafeIndexs_avs        = notImplemented "unsafeIndexs_avs"
+length          = P.length
+index _         = (P.!!)
+indexs_avs      = notImplemented "indexs_avs"
 
-extract xs i n          = P.take n (P.drop i xs)
-unsafeExtracts_nss      = notImplemented "unsafeExtract_nss"
-unsafeExtracts_ass      = notImplemented "unsafeExtract_ass"
-unsafeExtracts_avs      = notImplemented "unsafeExtract_avs"
+extract xs i n  = P.take n (P.drop i xs)
+extracts_nss    = notImplemented "extract_nss"
+extracts_ass    = notImplemented "extract_ass"
+extracts_avs    = notImplemented "extract_avs"
 
 drop            = P.drop
 
 
 -- Update ---------------------------------------------------------------------
-update           = notImplemented "update"
+update          = notImplemented "update"
 
 
 -- Permutation ----------------------------------------------------------------
index 35f7ab0..1deeed0 100644 (file)
@@ -21,12 +21,12 @@ module Data.Array.Parallel.Unlifted (
   -- * Projections
   length,
   index,
-  unsafeIndexs_avs,
+  indexs_avs,
 
   extract,
-  unsafeExtracts_nss,
-  unsafeExtracts_ass,
-  unsafeExtracts_avs,
+  extracts_nss,
+  extracts_ass,
+  extracts_avs,
   drop,
   
   -- * Update
index 8003728..2449546 100644 (file)
@@ -201,13 +201,13 @@ index :: Elt a => Prelude.String -> Array a -> Int -> a
 
 
 -- | O(n). Scattered indexing through a `VSegd`.
-unsafeIndexs_avs
+indexs_avs
         :: (Elt a, Elts a)
         => Arrays a
         -> VSegd
         -> Array (Int, Int)
         -> Array a
-{-# INLINE_BACKEND unsafeIndexs_avs #-}
+{-# INLINE_BACKEND indexs_avs #-}
 
 
 -- | O(n). Extract a subrange of elements from an array.
@@ -223,31 +223,31 @@ extract :: Elt a
 
 -- | O(n). Segmented extract, from a vector of arrays.
 --   TODO: This is a transitory interface, we are refactoring code to always
---         use the previous form.
-unsafeExtracts_nss
+--         use the `Arrays` form.
+extracts_nss
         :: Elt a
         => SSegd
         -> VV.Vector (Array a)
         -> Array a
-{-# INLINE_BACKEND unsafeExtracts_nss #-}
+{-# INLINE_BACKEND extracts_nss #-}
 
 
 -- | O(n). Segmented extract.
-unsafeExtracts_ass
+extracts_ass
         :: (Elt a, Elts a)
         => SSegd        -- ^ `SSegd` defining the slices to extract.
         -> Arrays a     -- ^ Source arrays.
         -> Array a
-{-# INLINE_BACKEND unsafeExtracts_ass #-}
+{-# INLINE_BACKEND extracts_ass #-}
 
 
 -- | O(n). Segmented extract.
-unsafeExtracts_avs
+extracts_avs
         :: (Elt a, Elts a)
         => VSegd        -- ^ `VSegd` defining the slices to extract.
         -> Arrays a     -- ^ Source arrays.
         -> Array a
-{-# INLINE_BACKEND unsafeExtracts_avs #-}
+{-# INLINE_BACKEND extracts_avs #-}
 
 
 -- | O(n). Drop some elements from the front of an array, 
index c7620d1..c00f03c 100644 (file)
@@ -105,17 +105,17 @@ enumFromStepLenEach n starts steps lens
 
 
 -- Projections ----------------------------------------------------------------
-length                  = Seq.length
-index                   = Seq.index
-unsafeIndexs_avs        = unsafeIndexsFromVectorsWithUPVSegd
+length          = Seq.length
+index           = Seq.index
+indexs_avs      = indexsFromVectorsWithUPVSegd
 
 extract arr i n
         =  tracePrim (TraceExtract (Seq.length arr) i n)
         $! Seq.extract arr i n
 
-unsafeExtracts_nss      = unsafeExtractsFromNestedWithUPSSegd
-unsafeExtracts_ass      = unsafeExtractsFromVectorsWithUPSSegd
-unsafeExtracts_avs      = unsafeExtractsFromVectorsWithUPVSegd
+extracts_nss    = extractsFromNestedWithUPSSegd
+extracts_ass    = extractsFromVectorsWithUPSSegd
+extracts_avs    = extractsFromVectorsWithUPVSegd
 
 drop n arr
         =  tracePrim (TraceDrop n (Seq.length arr))
index 465bd63..d342c51 100644 (file)
@@ -45,10 +45,10 @@ module Data.Array.Parallel.Unlifted.Parallel
         , appendSUP
         , foldRUP
         , sumRUP
-        , unsafeIndexsFromVectorsWithUPVSegd
-        , unsafeExtractsFromNestedWithUPSSegd
-        , unsafeExtractsFromVectorsWithUPSSegd
-        , unsafeExtractsFromVectorsWithUPVSegd
+        , indexsFromVectorsWithUPVSegd
+        , extractsFromNestedWithUPSSegd
+        , extractsFromVectorsWithUPSSegd
+        , extractsFromVectorsWithUPVSegd
 
           -- * Subarrays
         , dropUP
index a04eff3..f4f2cee 100644 (file)
@@ -9,12 +9,12 @@ module Data.Array.Parallel.Unlifted.Parallel.Segmented
         , sumRUP
 
         -- * Scattered indexing.
-        , unsafeIndexsFromVectorsWithUPVSegd
+        , indexsFromVectorsWithUPVSegd
 
         -- * Scattered extracts.
-        , unsafeExtractsFromNestedWithUPSSegd
-        , unsafeExtractsFromVectorsWithUPSSegd
-        , unsafeExtractsFromVectorsWithUPVSegd)
+        , extractsFromNestedWithUPSSegd
+        , extractsFromVectorsWithUPSSegd
+        , extractsFromVectorsWithUPVSegd)
 where
 import Data.Array.Parallel.Unlifted.Distributed
 import Data.Array.Parallel.Unlifted.Parallel.Basics
@@ -161,63 +161,63 @@ sumRUP = foldRUP (+) 0
 --
 --   TODO: make this parallel.
 --
-unsafeIndexsFromVectorsWithUPVSegd 
+indexsFromVectorsWithUPVSegd 
         :: (Unbox a, US.Unboxes a)
         => Vectors a -> UPVSegd -> Vector (Int, Int) -> Vector a
 
-unsafeIndexsFromVectorsWithUPVSegd vectors upvsegd vsrcixs
+indexsFromVectorsWithUPVSegd vectors upvsegd vsrcixs
  = let  -- Because we're just doing indexing here, we don't need the culled
         -- vsegids or ussegd, and can just use the redundant version.
         !vsegids  = UPVSegd.takeVSegidsRedundant upvsegd
         !upssegd  = UPVSegd.takeUPSSegdRedundant upvsegd
         !ussegd   = UPSSegd.takeUSSegd upssegd
    in   Seq.unstream
-         $ US.unsafeStreamElemsFromVectors        vectors
-         $ US.unsafeStreamSrcIxsThroughUSSegd  ussegd
-         $ US.unsafeStreamSrcIxsThroughVSegids vsegids
+         $ US.streamElemsFromVectors        vectors
+         $ US.streamSrcIxsThroughUSSegd  ussegd
+         $ US.streamSrcIxsThroughVSegids vsegids
          $ Seq.stream vsrcixs
-{-# INLINE_U unsafeIndexsFromVectorsWithUPVSegd #-}
+{-# INLINE_U indexsFromVectorsWithUPVSegd #-}
 
 
 -- Extracts -------------------------------------------------------------------
 -- | Copy segments from a nested vectors and concatenate them into a new array.
-unsafeExtractsFromNestedWithUPSSegd
+extractsFromNestedWithUPSSegd
         :: Unbox a
         => UPSSegd -> V.Vector (Vector a) -> Vector a
 
-unsafeExtractsFromNestedWithUPSSegd upssegd vectors
+extractsFromNestedWithUPSSegd upssegd vectors
         = Seq.unstream 
-        $ US.unsafeStreamSegsFromNestedUSSegd
+        $ US.streamSegsFromNestedUSSegd
                 vectors
                 (UPSSegd.takeUSSegd upssegd)
-{-# INLINE_U unsafeExtractsFromNestedWithUPSSegd #-}
+{-# INLINE_U extractsFromNestedWithUPSSegd #-}
 
 
 -- | TODO: make this parallel.
-unsafeExtractsFromVectorsWithUPSSegd
+extractsFromVectorsWithUPSSegd
         :: (Unbox a, US.Unboxes a)
         => UPSSegd
         -> Vectors a
         -> Vector a
 
-unsafeExtractsFromVectorsWithUPSSegd upssegd vectors
-        = Seq.unsafeExtractsFromVectorsUSSegd
+extractsFromVectorsWithUPSSegd upssegd vectors
+        = Seq.extractsFromVectorsUSSegd
                 (UPSSegd.takeUSSegd upssegd) 
                 vectors
-{-# INLINE_UP unsafeExtractsFromVectorsWithUPSSegd #-}
+{-# INLINE_UP extractsFromVectorsWithUPSSegd #-}
 
 
 -- | TODO: make this parallel.
-unsafeExtractsFromVectorsWithUPVSegd
+extractsFromVectorsWithUPVSegd
         :: (Unbox a, US.Unboxes a)
         => UPVSegd
         -> Vectors a
         -> Vector a
 
-unsafeExtractsFromVectorsWithUPVSegd upvsegd vectors
+extractsFromVectorsWithUPVSegd upvsegd vectors
         = Seq.unstream 
-        $ US.unsafeStreamSegsFromVectorsUSSegd
+        $ US.streamSegsFromVectorsUSSegd
                 vectors         -- TODD: avoid demote, use the vsegd directly.
                 (UPSSegd.takeUSSegd $ UPVSegd.demoteToUPSSegd upvsegd)
-{-# INLINE_UP unsafeExtractsFromVectorsWithUPVSegd #-}
+{-# INLINE_UP extractsFromVectorsWithUPVSegd #-}
 
index e250ddb..4b925b7 100644 (file)
@@ -48,12 +48,12 @@ enumFromStepLenEach     = U.enumFromStepLenEach
 -- Projections ----------------------------------------------------------------
 length                  = U.length
 index                   = U.index
-unsafeIndexs_avs        = Prelude.error "dph-prim-seq: unsafeIndex_avs wrapper not defined"
+indexs_avs              = Prelude.error "dph-prim-seq: indexs_avs wrapper not defined"
 
 extract                 = U.extract
-unsafeExtracts_nss      = unsafeExtractsFromNestedUSSegd
-unsafeExtracts_ass      = unsafeExtractsFromVectorsUSSegd
-unsafeExtracts_avs      = Prelude.error "dph-prim-seq: unsafeExtracts_avs: not done"
+extracts_nss            = extractsFromNestedUSSegd
+extracts_ass            = extractsFromVectorsUSSegd
+extracts_avs            = Prelude.error "dph-prim-seq: extracts_avs: not done"
 drop                    = U.drop
 
 
index 33ef421..da2da4d 100644 (file)
@@ -30,8 +30,8 @@ module Data.Array.Parallel.Unlifted.Sequential
         -- * Pack and Combine
         , combineSU
         
-        , unsafeExtractsFromNestedUSSegd
-        , unsafeExtractsFromVectorsUSSegd)
+        , extractsFromNestedUSSegd
+        , extractsFromVectorsUSSegd)
 where
 import Data.Array.Parallel.Unlifted.Sequential.Basics
 import Data.Array.Parallel.Unlifted.Sequential.Combinators
index 5326907..1acd24d 100644 (file)
@@ -2,17 +2,16 @@
 #include "fusion-phases.h"
 
 -- | Standard combinators for segmented unlifted arrays.
-module Data.Array.Parallel.Unlifted.Sequential.Combinators (
-  foldlSU,      foldlSSU,
-  foldSU,       foldSSU,
-  foldl1SU,     foldl1SSU,
-  fold1SU,      fold1SSU,
-  foldlRU,
-  combineSU,
-  
-  unsafeExtractsFromNestedUSSegd,
-  unsafeExtractsFromVectorsUSSegd
-) where
+module Data.Array.Parallel.Unlifted.Sequential.Combinators 
+        ( foldlSU,      foldlSSU
+        , foldSU,       foldSSU
+        , foldl1SU,     foldl1SSU
+        , fold1SU,      fold1SSU
+        , foldlRU
+        , combineSU
+        , extractsFromNestedUSSegd
+        , extractsFromVectorsUSSegd)
+where
 import Data.Array.Parallel.Stream
 import Data.Array.Parallel.Unlifted.Stream
 import Data.Array.Parallel.Unlifted.Vectors                     as US
@@ -43,7 +42,7 @@ foldlSSU :: (Unbox a, Unboxes a, Unbox b)
 foldlSSU f z ssegd xss
         = unstream
         $ foldSS f z    (stream (USSegd.takeLengths ssegd))
-                        (unsafeStreamSegsFromVectorsUSSegd xss ssegd)
+                        (streamSegsFromVectorsUSSegd xss ssegd)
 
 
 -- fold -----------------------------------------------------------------------
@@ -82,7 +81,7 @@ foldl1SSU :: (Unbox a, Unboxes a)
 foldl1SSU f ssegd xxs
         = unstream
         $ fold1SS f     (stream (USSegd.takeLengths ssegd))
-                        (unsafeStreamSegsFromVectorsUSSegd xxs ssegd)
+                        (streamSegsFromVectorsUSSegd xxs ssegd)
 
 
 -- fold1 ----------------------------------------------------------------------
@@ -124,21 +123,21 @@ combineSU bs xd xs yd ys
 
 -- Extracts wrappers ---------------------------------------------------------
 -- | Copy segments from a `Vectors` and concatenate them into a new array.
-unsafeExtractsFromNestedUSSegd
+extractsFromNestedUSSegd
         :: (U.Unbox a)
         => USSegd -> V.Vector (Vector a) -> U.Vector a
 
-unsafeExtractsFromNestedUSSegd ussegd vectors
-        = G.unstream $ unsafeStreamSegsFromNestedUSSegd vectors ussegd
-{-# INLINE_U unsafeExtractsFromNestedUSSegd #-}
+extractsFromNestedUSSegd ussegd vectors
+        = G.unstream $ streamSegsFromNestedUSSegd vectors ussegd
+{-# INLINE_U extractsFromNestedUSSegd #-}
 
 
 -- | Copy segments from a `Vectors` and concatenate them into a new array.
-unsafeExtractsFromVectorsUSSegd
+extractsFromVectorsUSSegd
         :: (Unboxes a, U.Unbox a)
         => USSegd -> Vectors a -> U.Vector a
 
-unsafeExtractsFromVectorsUSSegd ussegd vectors
-        = G.unstream $ unsafeStreamSegsFromVectorsUSSegd vectors ussegd
-{-# INLINE_U unsafeExtractsFromVectorsUSSegd #-}
+extractsFromVectorsUSSegd ussegd vectors
+        = G.unstream $ streamSegsFromVectorsUSSegd vectors ussegd
+{-# INLINE_U extractsFromVectorsUSSegd #-}
 
index 830f963..b21df1f 100644 (file)
@@ -1,16 +1,16 @@
 
 module Data.Array.Parallel.Unlifted.Stream
         ( -- * Index streamers.
-          unsafeStreamSrcIxsThroughVSegids
-        , unsafeStreamSrcIxsThroughUSSegd
+          streamSrcIxsThroughVSegids
+        , streamSrcIxsThroughUSSegd
 
           -- * Element streamers.
-        , unsafeStreamElemsFromVectors
-        , unsafeStreamElemsFromVectorsVSegd
+        , streamElemsFromVectors
+        , streamElemsFromVectorsVSegd
 
           -- * Segment streamers.
-        , unsafeStreamSegsFromNestedUSSegd
-        , unsafeStreamSegsFromVectorsUSSegd)
+        , streamSegsFromNestedUSSegd
+        , streamSegsFromVectorsUSSegd)
 where
 import Data.Array.Parallel.Unlifted.Stream.Ixs
 import Data.Array.Parallel.Unlifted.Stream.Elems
index ab8bb42..089b3fe 100644 (file)
@@ -1,8 +1,8 @@
 {-# LANGUAGE CPP, NoMonomorphismRestriction #-}
 #include "fusion-phases.h"
 module Data.Array.Parallel.Unlifted.Stream.Elems
-        ( unsafeStreamElemsFromVectors
-        , unsafeStreamElemsFromVectorsVSegd)
+        ( streamElemsFromVectors
+        , streamElemsFromVectorsVSegd)
 where
 import Data.Array.Parallel.Unlifted.Stream.Ixs
 import Data.Vector.Fusion.Stream.Monadic
@@ -14,11 +14,11 @@ import qualified Data.Array.Parallel.Unlifted.Sequential.UVSegd  as UVSegd
 
 -- | Take a stream of chunk and chunk element indices, look them up from
 --   some vectors, and produce a stream of elements.
-unsafeStreamElemsFromVectors 
+streamElemsFromVectors 
         :: (Monad m, Unboxes a) 
         => Vectors a -> Stream m (Int, Int) -> Stream m a
 
-unsafeStreamElemsFromVectors vectors (Stream mkStep s0 size0)
+streamElemsFromVectors vectors (Stream mkStep s0 size0)
  = vectors `seq` Stream mkStep' s0 size0
   where
         {-# INLINE_INNER mkStep' #-}
@@ -28,21 +28,21 @@ unsafeStreamElemsFromVectors vectors (Stream mkStep s0 size0)
                  Yield (ix1, ix2) s' -> return $ Yield (US.unsafeIndex2 vectors ix1 ix2) s'
                  Skip s'             -> return $ Skip s'
                  Done                -> return Done
-{-# INLINE_STREAM unsafeStreamElemsFromVectors #-}
+{-# INLINE_STREAM streamElemsFromVectors #-}
 
 
 -- | Take a stream of virtual segment ids and element indices, 
 --   pass them through a `UVSegd` to get physical segment and element indices, 
 --   and produce a stream of elements.
-unsafeStreamElemsFromVectorsVSegd
+streamElemsFromVectorsVSegd
         :: (Monad m, Unboxes a)
         => Vectors a -> UVSegd -> Stream m (Int, Int) -> Stream m a
 
-unsafeStreamElemsFromVectorsVSegd vectors vsegd vsrcixs
+streamElemsFromVectorsVSegd vectors vsegd vsrcixs
  = let  !vsegids = UVSegd.takeVSegids vsegd
         !ussegd  = UVSegd.takeUSSegd  vsegd
-   in   unsafeStreamElemsFromVectors        vectors
-         $ unsafeStreamSrcIxsThroughUSSegd  ussegd
-         $ unsafeStreamSrcIxsThroughVSegids vsegids
+   in   streamElemsFromVectors        vectors
+         $ streamSrcIxsThroughUSSegd  ussegd
+         $ streamSrcIxsThroughVSegids vsegids
          $ vsrcixs
-{-# INLINE_STREAM unsafeStreamElemsFromVectorsVSegd #-}
+{-# INLINE_STREAM streamElemsFromVectorsVSegd #-}
index 99691d3..5ef7182 100644 (file)
@@ -1,8 +1,8 @@
 {-# LANGUAGE CPP, NoMonomorphismRestriction #-}
 #include "fusion-phases.h"
 module Data.Array.Parallel.Unlifted.Stream.Ixs
-        ( unsafeStreamSrcIxsThroughVSegids
-        , unsafeStreamSrcIxsThroughUSSegd)
+        ( streamSrcIxsThroughVSegids
+        , streamSrcIxsThroughUSSegd)
 where
 import Data.Vector.Fusion.Stream.Monadic
 import Data.Array.Parallel.Unlifted.Sequential.USSegd            (USSegd(..))
@@ -13,11 +13,11 @@ import qualified Data.Vector.Unboxed                             as U
 -- VSegd Streamers ------------------------------------------------------------
 -- | Take a stream of virtual segment and segment element indices,
 --   and convert it to a stream of physical segment and segment element indices.
-unsafeStreamSrcIxsThroughVSegids
+streamSrcIxsThroughVSegids
         :: Monad m
         => U.Vector Int -> Stream m (Int, Int) -> Stream m (Int, Int)
 
-unsafeStreamSrcIxsThroughVSegids vsegids (Stream mkStep s0 size0)
+streamSrcIxsThroughVSegids vsegids (Stream mkStep s0 size0)
  = vsegids `seq` Stream mkStep' s0 size0
  where
         {-# INLINE_INNER mkStep' #-}
@@ -30,17 +30,17 @@ unsafeStreamSrcIxsThroughVSegids vsegids (Stream mkStep s0 size0)
                  
                  Skip s' -> return $ Skip s'
                  Done    -> return Done
-{-# INLINE_STREAM unsafeStreamSrcIxsThroughVSegids #-}
+{-# INLINE_STREAM streamSrcIxsThroughVSegids #-}
 
 
 -- SSegd Streamers ------------------------------------------------------------
 -- | Take a stream of segment and segment element indices,
 --   and convert it to a stream of chunk and chunk element indices.
-unsafeStreamSrcIxsThroughUSSegd 
+streamSrcIxsThroughUSSegd 
         :: Monad m
         => USSegd -> Stream m (Int, Int) -> Stream m (Int, Int)
         
-unsafeStreamSrcIxsThroughUSSegd ussegd (Stream mkStep s0 size0)
+streamSrcIxsThroughUSSegd ussegd (Stream mkStep s0 size0)
  = ussegd `seq` Stream mkStep' s0 size0
  where
         !sources = USSegd.takeSources ussegd
@@ -57,5 +57,5 @@ unsafeStreamSrcIxsThroughUSSegd ussegd (Stream mkStep s0 size0)
                  
                  Skip s' -> return $ Skip s'
                  Done    -> return Done
-{-# INLINE_STREAM unsafeStreamSrcIxsThroughUSSegd #-}
+{-# INLINE_STREAM streamSrcIxsThroughUSSegd #-}
 
index b7bc155..cda5adf 100644 (file)
@@ -1,8 +1,8 @@
 {-# LANGUAGE CPP, NoMonomorphismRestriction #-}
 #include "fusion-phases.h"
 module Data.Array.Parallel.Unlifted.Stream.Segments
-        ( unsafeStreamSegsFromNestedUSSegd
-        , unsafeStreamSegsFromVectorsUSSegd)
+        ( streamSegsFromNestedUSSegd
+        , streamSegsFromVectorsUSSegd)
 where
 import Data.Vector.Fusion.Stream.Size
 import Data.Vector.Fusion.Stream.Monadic
@@ -29,13 +29,13 @@ import System.IO.Unsafe
 --           statically visible else streamSegs won't fuse, so we can't have an 
 --           ifThenElse checking the manifest flag.
 
-unsafeStreamSegsFromNestedUSSegd
+streamSegsFromNestedUSSegd
         :: (Unbox a, Monad m)
         => V.Vector (Vector a)  -- ^ Source arrays.
         -> USSegd               -- ^ Segment descriptor defining segments base on source vectors.
         -> Stream m a
 
-unsafeStreamSegsFromNestedUSSegd
+streamSegsFromNestedUSSegd
         pdatas
         ussegd@(USSegd _ starts sources usegd)
  = let  
@@ -62,7 +62,7 @@ unsafeStreamSegsFromNestedUSSegd
            in   return $ Yield result (pseg, ix + 1)
 
    in   Stream fn (0, 0) Unknown
-{-# INLINE_STREAM unsafeStreamSegsFromNestedUSSegd #-}
+{-# INLINE_STREAM streamSegsFromNestedUSSegd #-}
 
 
 -- Vectors ----------------------------------------------------------------------------------------
@@ -72,13 +72,13 @@ unsafeStreamSegsFromNestedUSSegd
 -- 
 --   * No bounds checking is done for the `USSegd`.
 --
-unsafeStreamSegsFromVectorsUSSegd
+streamSegsFromVectorsUSSegd
         :: (Unboxes a, Monad m)
         => Vectors a            -- ^ Vectors holding source data.
         -> USSegd               -- ^ Scattered segment descriptor
         -> Stream m a
 
-unsafeStreamSegsFromVectorsUSSegd
+streamSegsFromVectorsUSSegd
         vectors
         ussegd@(USSegd _ segStarts segSources usegd) 
  = segStarts `seq` segSources `seq` usegd `seq` vectors `seq`
@@ -138,5 +138,5 @@ unsafeStreamSegsFromVectorsUSSegd
         -- It's important that we set the result stream size, so Data.Vector
         -- doesn't need to add code to grow the result when it overflows.
    in   Stream fnSeg initState (Exact elements) 
-{-# INLINE_STREAM unsafeStreamSegsFromVectorsUSSegd #-}
+{-# INLINE_STREAM streamSegsFromVectorsUSSegd #-}