dph-lifted-vseg: banish unchecked indexing and fix bug in indexvsPR
authorBen Lippmeier <benl@ouroborus.net>
Mon, 12 Dec 2011 01:29:59 +0000 (12:29 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Mon, 12 Dec 2011 01:29:59 +0000 (12:29 +1100)
14 files changed:
dph-lifted-base/Data/Array/Parallel/PArray.hs
dph-lifted-vseg/Data/Array/Parallel/PArray.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Base.hs
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/Unit.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-seq/Data/Array/Parallel/Unlifted.hs

index b49beb7..f7795a1 100644 (file)
@@ -64,9 +64,11 @@ import Prelude hiding
         , zip, unzip)
 
 -------------------------------------------------------------------------------
-die :: String -> String -> a
-die fn str = error $ "Data.Array.Parallel.PArray: " ++ fn ++ " " ++ str
+here :: String -> String
+here str   = "Data.Array.Parallel.PArray." ++ str
 
+die :: String -> String -> a
+die fn str = error (here $ fn ++ " " ++ str)
 
 -- Array Type -----------------------------------------------------------------
 type PArray a
@@ -312,7 +314,7 @@ packByTag xs tags tag
                 , "  flags length = " ++ (show $ U.length tags) ]
 
         | otherwise
-        = V.ifilter (\i _ -> tags U.!: i == tag) xs
+        = V.ifilter (\i _ -> U.index (here "packByTag") tags i == tag) xs
 
 
 -- | Combine two arrays based on a selector.
index 7e76892..794fdf5 100644 (file)
@@ -77,7 +77,7 @@ import qualified Data.Array.Parallel.Unlifted   as U
 import qualified Data.Vector                    as V
 import qualified "dph-lifted-base" Data.Array.Parallel.PArray           as R
 import qualified "dph-lifted-base" Data.Array.Parallel.PArray.Reference as R
-
+-- import qualified Debug.Trace
 
 import qualified Prelude                        as P
 import Prelude hiding 
@@ -100,6 +100,10 @@ instance PA a => R.PprPhysical1 a where
  pprp1          = pprpPA
 
 
+trace :: String -> a -> a
+trace _str x
+        = x -- Debug.Trace.trace ("! " ++ str) x
+
 -- Array -----------------------------------------------------------------------
 --  Generic interface to PArrays.
 --
@@ -139,15 +143,17 @@ instance (Eq a, PA a)  => Eq (PArray a) where
 -- | Check that an array has a valid internal representation.
 valid :: PA a => PArray a -> Bool
 valid (PArray n# darr1)
-        =  validPA  darr1
-        && coversPA True darr1 (I# n#)
+ = trace "valid"
+ $ validPA  darr1
+ && coversPA True darr1 (I# n#)
 {-# INLINE_PA valid #-}
 
 
 -- | Force an array to normal form.
 nf :: PA a => PArray a -> ()
 nf (PArray _ d)
-        = nfPA d
+ = trace "nf"
+ $ nfPA d
 {-# INLINE_PA nf #-}
 
 
@@ -218,7 +224,8 @@ replicatel_ (PArray n# (PInt lens)) (PArray _ pdata)
 -- | O(sum lengths). Segmented replicate.
 replicates :: PA a => U.Segd -> PArray a -> PArray a
 replicates segd arr@(PArray _ pdata)
- = withRef1 "replicates" (R.replicates segd (toRef1 arr))
+ = trace (T.render $ T.text "!!! replicates " T.$+$ T.pprp segd T.$+$ T.pprp arr)
+ $ withRef1 "replicates" (R.replicates segd (toRef1 arr))
  $ let  !(I# n#) = U.elementsSegd segd
    in   PArray n# $ replicatesPA segd pdata
 {-# INLINE_PA replicates #-}
@@ -228,7 +235,8 @@ replicates segd arr@(PArray _ pdata)
 --  and uses them to build the `U.Segd`.
 replicates' :: PA a => PArray Int -> PArray a -> PArray a
 replicates' (PArray _ (PInt reps)) arr
- = replicates (U.lengthsToSegd reps) arr
+ = trace "replicates'"
+ $ replicates (U.lengthsToSegd reps) arr
 {-# INLINE_PA replicates' #-}
  
  
@@ -253,7 +261,7 @@ appendl arr1@(PArray n# pdata1) arr2@(PArray _ pdata2)
 concat :: PA a => PArray (PArray a) -> PArray a
 concat arr@(PArray _ darr)
  = withRef1 "concat" (R.concat (toRef2 arr))
- $ let  darr'    = concatPA darr
+ $ let  darr'           = concatPA darr
         !(I# n#)        = lengthPA darr'
    in   PArray  n# darr'
 {-# INLINE_PA concat #-}
@@ -270,7 +278,8 @@ concatl arr@(PArray n# pdata1)
 -- | Impose a nesting structure on a flat array
 unconcat :: (PA a, PA b) => PArray (PArray a) -> PArray b -> PArray (PArray b)
 unconcat (PArray n# pdata1) (PArray _ pdata2)
- = PArray n# $ unconcatPA pdata1 pdata2
+ = trace "! unconcat"
+ $ PArray n# $ unconcatPA pdata1 pdata2
 {-# INLINE_PA unconcat #-}
 
 
@@ -305,28 +314,32 @@ lengthl arr@(PArray n# (PNested vsegd _ _))
 -- | O(1). Lookup a single element from the source array.
 index    :: PA a => PArray a -> Int -> a
 index (PArray _ arr) ix
-        = indexPA arr ix
+ = trace "index"
+ $ indexPA arr ix
 {-# INLINE_PA index #-}
 
 
 -- | O(len indices). Lookup a several elements from several source arrays
 indexl    :: PA a => PArray (PArray a) -> PArray Int -> PArray a
 indexl (PArray n# darr) (PArray _ ixs)
-        = PArray n# (indexlPA darr ixs)
+ = trace "indexl"
+ $ PArray n# (indexlPA darr ixs)
 {-# INLINE_PA indexl #-}
 
 
 -- | Extract a range of elements from an array.
 extract  :: PA a => PArray a -> Int -> Int -> PArray a
 extract (PArray _ arr) start len@(I# len#)
-        = PArray len# (extractPA arr start len)
+ = trace "extract"
+ $ PArray len# (extractPA arr start len)
 {-# INLINE_PA extract #-}
 
 
 -- | Segmented extract.
 extracts :: PA a => Vector (PArray a) -> U.SSegd -> PArray a
 extracts arrs ssegd
- = let  pdatas          = fromVectordPA $ V.map (\(PArray _ vec) -> vec) arrs
+ = trace "extracts"
+ $ let  pdatas          = fromVectordPA $ V.map (\(PArray _ vec) -> vec) arrs
         !(I# n#)        = (U.sum $ U.lengthsOfSSegd ssegd)
    in   PArray   n#
                 (extractssPA pdatas ssegd)
@@ -347,7 +360,8 @@ extracts'
         -> PArray Int           -- ^ length of each segment.
         -> PArray a
 extracts' arrs (PArray _ (PInt sources)) (PArray _ (PInt starts)) (PArray _ (PInt lengths))
- = let segd    = U.lengthsToSegd lengths
+ = trace "extracts'"
+ $ let segd    = U.lengthsToSegd lengths
        ssegd   = U.mkSSegd starts sources segd
    in  extracts arrs ssegd
 {-# INLINE_PA extracts' #-}
@@ -357,7 +371,8 @@ extracts' arrs (PArray _ (PInt sources)) (PArray _ (PInt starts)) (PArray _ (PIn
 --   Like `extract` but with the parameters in a different order.
 slice :: PA a => Int -> Int -> PArray a -> PArray a
 slice start len@(I# len#) (PArray _ darr)
- = PArray len# (extractPA darr start len)
+ = trace "slice"
+ $ PArray len# (extractPA darr start len)
 {-# INLINE_PA slice #-}
 
 
@@ -366,7 +381,8 @@ slice start len@(I# len#) (PArray _ darr)
 --   have the same length.
 slicel :: PA a => PArray Int -> PArray Int -> PArray (PArray a) -> PArray (PArray a)
 slicel (PArray n# sliceStarts) (PArray _ sliceLens) (PArray _ darr)
- = PArray n# (slicelPA sliceStarts sliceLens darr)
+ = trace "slicel"
+ $ PArray n# (slicelPA sliceStarts sliceLens darr)
 {-# INLINE_PA slicel #-}
 
 
@@ -374,7 +390,8 @@ slicel (PArray n# sliceStarts) (PArray _ sliceLens) (PArray _ darr)
 --   plain Segd. This is unsafe because it can cause index space overflow.
 takeUSegd :: PArray (PArray a) -> U.Segd
 takeUSegd (PArray _ pdata)
-        = takeSegdPD pdata
+ = trace "takeUSegd"
+ $ takeSegdPD pdata
 {-# INLINE_PA takeUSegd #-}
 
 
@@ -447,7 +464,8 @@ combine2 sel arr1@(PArray _ darr1) arr2@(PArray _ darr2)
 --   The two arrays must have the same length, else `error`. 
 zip :: PArray a -> PArray b -> PArray (a, b)
 zip (PArray n# pdata1) (PArray _ pdata2)
-        = PArray n# $ zipPD pdata1 pdata2
+ = trace "zip"
+ $ PArray n# $ zipPD pdata1 pdata2
 {-# INLINE_PA zip #-}
 
 
@@ -455,7 +473,8 @@ zip (PArray n# pdata1) (PArray _ pdata2)
 zipl    :: (PA a, PA b)
         => PArray (PArray a) -> PArray (PArray b) -> PArray (PArray (a, b))
 zipl (PArray n# xs) (PArray _ ys)
- = PArray n# $ ziplPA xs ys
+ = trace "zipl"
+ $ PArray n# $ ziplPA xs ys
 {-# INLINE_PA zipl #-}
 
 
@@ -463,7 +482,8 @@ zipl (PArray n# xs) (PArray _ ys)
 --   All arrays must have the same length, else `error`. 
 zip3 :: PArray a -> PArray b -> PArray c -> PArray (a, b, c)
 zip3 (PArray n# pdata1) (PArray _ pdata2) (PArray _ pdata3)
-        = PArray n# $ zip3PD pdata1 pdata2 pdata3
+ = trace "zip3"
+ $ PArray n# $ zip3PD pdata1 pdata2 pdata3
 {-# INLINE_PA zip3 #-}
 
 
@@ -471,7 +491,8 @@ zip3 (PArray n# pdata1) (PArray _ pdata2) (PArray _ pdata3)
 --   All arrays must have the same length, else `error`. 
 zip4 :: PArray a -> PArray b -> PArray c -> PArray d -> PArray (a, b, c, d)
 zip4 (PArray n# pdata1) (PArray _ pdata2) (PArray _ pdata3) (PArray _ pdata4)
-        = PArray n# $ zip4PD pdata1 pdata2 pdata3 pdata4
+ = trace "zip4"
+ $ PArray n# $ zip4PD pdata1 pdata2 pdata3 pdata4
 {-# INLINE_PA zip4 #-}
 
 
@@ -479,21 +500,24 @@ zip4 (PArray n# pdata1) (PArray _ pdata2) (PArray _ pdata3) (PArray _ pdata4)
 --   All arrays must have the same length, else `error`. 
 zip5 :: PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray (a, b, c, d, e)
 zip5 (PArray n# pdata1) (PArray _ pdata2) (PArray _ pdata3) (PArray _ pdata4) (PArray _ pdata5)
-        = PArray n# $ zip5PD pdata1 pdata2 pdata3 pdata4 pdata5
+ = trace "zip5"
+ $ PArray n# $ zip5PD pdata1 pdata2 pdata3 pdata4 pdata5
 {-# INLINE_PA zip5 #-}
 
 
 -- | O(1). Unzip an array of pairs into a pair of arrays.
 unzip :: PArray (a, b) -> (PArray a, PArray b)
 unzip (PArray n# (PTuple2 xs ys))
-        = (PArray n# xs, PArray n# ys)
+ = trace "unzip"
+ $ (PArray n# xs, PArray n# ys)
 {-# INLINE_PA unzip #-}
 
 
 -- | Lifted unzip
 unzipl :: PArray (PArray (a, b)) -> PArray (PArray a, PArray b)
 unzipl (PArray n# pdata)
-        = PArray n# $ unziplPD pdata
+ = trace "unzipl"
+ $ PArray n# $ unziplPD pdata
 {-# INLINE_PA unzipl #-}
 
 
@@ -501,7 +525,8 @@ unzipl (PArray n# pdata)
 -- | Convert a `Vector` to a `PArray`
 fromVector :: PA a => Vector a -> PArray a
 fromVector vec
- = let !(I# n#) = V.length vec
+ = trace "fromVector"
+ $ let !(I# n#) = V.length vec
    in  PArray n#  (fromVectorPA vec)
 {-# INLINE_PA fromVector #-}
 
@@ -509,14 +534,16 @@ fromVector vec
 -- | Convert a `PArray` to a `Vector`        
 toVector   :: PA a => PArray a -> Vector a
 toVector (PArray _ arr)
-        = toVectorPA arr
+ = trace "toVector"
+ $ toVectorPA arr
 {-# INLINE_PA toVector #-}
 
 
 -- | Convert a list to a `PArray`.
 fromList :: PA a => [a] -> PArray a
 fromList xx
- = let  !(I# n#) = P.length xx
+ = trace "fromList"
+ $ let  !(I# n#) = P.length xx
    in   PArray n# (fromVectorPA $ V.fromList xx)
 {-# INLINE_PA fromList #-}
 
@@ -524,6 +551,7 @@ fromList xx
 -- | Convert a `PArray` to a list.
 toList   :: PA a => PArray a -> [a]
 toList (PArray _ arr)
-        = V.toList $ toVectorPA arr
+ = trace "toList"
+ $ V.toList $ toVectorPA arr
 {-# INLINE_PA toList #-}
 
index 85035c1..adf7d53 100644 (file)
@@ -188,15 +188,15 @@ class PR a where
   indexvsPR pdatas vsegd srcixs
    = let
          !vsegids         = U.takeVSegidsRedundantOfVSegd vsegd
-         !ssegd           = U.takeSSegdOfVSegd vsegd
+         !ssegd           = U.takeSSegdRedundantOfVSegd   vsegd
          !sources         = U.sourcesOfSSegd   ssegd
          !starts          = U.startsOfSSegd    ssegd
 
          !srcixs' 
           = U.map (\(ix1, ix2)
-                   -> let !psegid = U.unsafeIndex vsegids ix1
-                          !source = U.unsafeIndex sources psegid
-                          !start  = U.unsafeIndex starts  psegid
+                   -> let !psegid = U.index "indexvsPR/vsegids" vsegids ix1
+                          !source = U.index "indexvsPR/sources" sources psegid
+                          !start  = U.index "indexvsPR/starts"  starts  psegid
                       in  (source, start + ix2))
                    srcixs
 
@@ -219,7 +219,8 @@ class PR a where
   --  TODO: we're refactoring the library so functions use the VSeg form directly,
   --        instead of going via a SSegd.
   extractvsPR    :: PDatas a -> U.VSegd -> PData a
-
+  extractvsPR pdatas vsegd
+        = extractssPR pdatas (U.demoteToSSegdOfVSegd vsegd)
   
   -- Pack and Combine ---------------------------
   -- | Select elements of an array that have their corresponding tag set to
index 80d42a2..1da30c0 100644 (file)
@@ -79,15 +79,15 @@ instance PR Double where
 
   {-# INLINE_PDATA indexPR #-}
   indexPR (PDouble arr) ix
-        = arr `U.unsafeIndex` ix
+        = U.index "indexPR[Double]" arr ix
 
   {-# INLINE_PDATA indexsPR #-}
   indexsPR (PDoubles pvecs) srcixs
         = PDouble $ U.map (\(src, ix) -> U.unsafeIndex2s pvecs src ix) srcixs
 
-  {-# INLINE_PDATA indexvsPR #-}
-  indexvsPR (PDoubles arrs) vsegd srcixs 
-        = PDouble $ U.unsafeIndexs_avs arrs vsegd srcixs
+  -- {-# INLINE_PDATA indexvsPR #-}
+  -- indexvsPR (PDoubles arrs) vsegd srcixs 
+  --       = PDouble $ U.unsafeIndexs_avs arrs vsegd srcixs
 
   {-# INLINE_PDATA extractPR #-}
   extractPR (PDouble arr) start len 
@@ -97,9 +97,9 @@ instance PR Double where
   extractssPR (PDoubles arrs) ssegd
         = PDouble (U.unsafeExtracts_ass ssegd arrs)
 
-  {-# INLINE_PDATA extractvsPR #-}
-  extractvsPR (PDoubles arrs) vsegd
-        = PDouble (U.unsafeExtracts_avs vsegd arrs)
+  -- {-# INLINE_PDATA extractvsPR #-}
+  -- extractvsPR (PDoubles arrs) vsegd
+  --       = PDouble (U.unsafeExtracts_avs vsegd arrs)
                 
 
   -- Pack and Combine ---------------------------
index 86279ca..f7c4ca4 100644 (file)
@@ -9,6 +9,7 @@ import qualified Data.Vector                    as V
 import Text.PrettyPrint
 import Prelude                                  as P
 import Data.Array.Parallel.Pretty
+import Debug.Trace
 
 -- PR -------------------------------------------------------------------------
 instance PR Int where
@@ -67,15 +68,15 @@ instance PR Int where
 
   {-# INLINE_PDATA indexPR #-}
   indexPR (PInt uarr) ix
-        = uarr `U.unsafeIndex` ix
+        = U.index "indexPR[Int]" uarr ix
 
   {-# INLINE_PDATA indexsPR #-}
   indexsPR (PInts pvecs) srcixs
         = PInt $ U.map (\(src, ix) -> U.unsafeIndex2s pvecs src ix) srcixs
 
-  {-# INLINE_PDATA indexvsPR #-}
-  indexvsPR (PInts arrs) vsegd srcixs 
-        = PInt $ U.unsafeIndexs_avs arrs vsegd srcixs
+  -- {-# INLINE_PDATA indexvsPR #-}
+  -- indexvsPR (PInts arrs) vsegd srcixs 
+  --       = PInt $ U.unsafeIndexs_avs arrs vsegd srcixs
 
   {-# INLINE_PDATA extractPR #-}
   extractPR (PInt arr) start len 
@@ -85,9 +86,9 @@ instance PR Int where
   extractssPR (PInts arrs) ssegd
         = PInt $ U.unsafeExtracts_ass ssegd arrs
 
-  {-# INLINE_PDATA extractvsPR #-}
-  extractvsPR (PInts arrs) vsegd
-        = PInt $ U.unsafeExtracts_avs vsegd arrs
+  -- {-# INLINE_PDATA extractvsPR #-}
+  -- extractvsPR (PInts arrs) vsegd
+  --       = PInt $ U.unsafeExtracts_avs vsegd arrs
 
 
 
index 96f6d78..bcf74cb 100644 (file)
@@ -23,8 +23,7 @@ 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
-
+import System.IO.Unsafe
 
 -- Nested arrays --------------------------------------------------------------
 data instance PData (PArray a)
@@ -103,7 +102,7 @@ instance PR a => PR (PArray a) where
          psegdata       = pnested_psegdata    arr
 
 
-        -- The lengths of the pseglens, psegstarts and psegsrcs fields must all be the same
+         -- The lengths of the pseglens, psegstarts and psegsrcs fields must all be the same
          fieldLensOK
                 = validBool "nested array field lengths not identical"
                 $ and 
@@ -115,8 +114,7 @@ instance PR a => PR (PArray a) where
                 = validBool "nested array vseg doesn't ref pseg"
                 $ U.and
                 $ U.map (\vseg -> vseg < U.length pseglens) vsegids
-                
-         
+                         
          -- Every pseg source id must point to a flat data array
          psegsrcsRefOK
                 = validBool "nested array psegsrc doesn't ref flat array"
@@ -156,12 +154,18 @@ instance PR a => PR (PArray a) where
                 || (U.and $ U.map (flip IS.member vsegs) 
                           $ U.enumFromTo 0 (U.length pseglens - 1))
 
-     in  and [ fieldLensOK
-             , vsegsRefOK
-             , psegsrcsRefOK
-             , psegSlicesOK
-             , psegsReffedOK ]
-
+     in unsafePerformIO
+         $ do {-print fieldLensOK
+              print vsegsRefOK
+              print psegsrcsRefOK
+              print psegSlicesOK
+              print psegsReffedOK-}
+              return $ 
+               and [ fieldLensOK
+                   , vsegsRefOK
+                   , psegsrcsRefOK
+                   , psegSlicesOK
+                   , psegsReffedOK ]
 
   {-# NOINLINE nfPR #-}
   nfPR    = error "nfPR[PArray]: not defined yet"
@@ -186,10 +190,10 @@ instance PR a => PR (PArray a) where
             $ pprpDataPR pdata)
 
   {-# NOINLINE pprpDataPR #-}
-  pprpDataPR (PNested vsegd pdatas flat)
+  pprpDataPR (PNested vsegd pdatas _flat)
         =   text "PNested"
         $+$ ( nest 4
-            $ pprp vsegd $$ pprp pdatas $$ text "FLAT: " <> pprp flat)
+            $ pprp vsegd $$ pprp pdatas)
 
 
   -- Constructors -----------------------------------------
@@ -384,8 +388,7 @@ instance PR a => PR (PArray a) where
   --
   {-# NOINLINE extractssPR #-}
   extractssPR (PNesteds arrs) ussegd
-   = {-# SCC "extractsPR" #-}
-     let segsrcs        = U.sourcesOfSSegd ussegd
+   = let segsrcs        = U.sourcesOfSSegd ussegd
          seglens        = U.lengthsOfSSegd ussegd
 
          vsegids_src    = U.unsafeExtracts_nss ussegd (V.map pnested_vsegids arrs)
@@ -401,20 +404,21 @@ instance PR a => PR (PArray a) where
          !arrs_psegstarts = V.map pnested_psegstarts arrs
          !arrs_psegsrcids = V.map pnested_psegsrcids arrs
 
+         !here'         = "extractssPR[Nested]"
          -- Function to get one element of the result.
          {-# INLINE get #-}
          get srcid vsegid
-          = 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
+          = let !pseglen        =  U.index here' (arrs_pseglens   `V.unsafeIndex` srcid) vsegid
+                !psegstart      =  U.index here' (arrs_psegstarts `V.unsafeIndex` srcid) vsegid
+                !psegsrcid      = (U.index here' (arrs_psegsrcids `V.unsafeIndex` srcid) vsegid)
+                                + (psrcoffset `V.unsafeIndex` srcid)
             in  (pseglen, psegstart, psegsrcid)
             
          (pseglens', psegstarts', psegsrcs')
                 = U.unzip3 $ U.zipWith get srcids' vsegids_src
 
          -- All flat data arrays in the sources go into the result.
-         psegdatas'     = fromVectordPR
+         pdatas'        = fromVectordPR
                         $ V.concat $ V.toList 
                         $ V.map (toVectordPR . pnested_psegdata) arrs
                    
@@ -423,9 +427,9 @@ instance PR a => PR (PArray a) where
                         $ U.mkSSegd psegstarts' psegsrcs'
                         $ U.lengthsToSegd pseglens'
    
-         flat'          = extractvs_delay psegdatas' vsegd'
+         flat'          = extractvs_delay pdatas' vsegd'
    
-     in  PNested vsegd' psegdatas' flat'
+     in  PNested vsegd' pdatas' flat'
 
 
   {-# INLINE_PDATA extractvsPR #-}
@@ -558,7 +562,8 @@ indexlPR (PNested vsegd pdatas _uCantTouchThis) (PInt ixs)
 --   of the total number of elements within it.
 --
 concatPR :: PR a => PData (PArray a) -> PData a
-concatPR (PNested _ _ flat) = flat
+concatPR (PNested vsegd pdatas _flat) 
+ = extractssPR pdatas (U.demoteToSSegdOfVSegd vsegd)
 {-# INLINE concatPR #-}
 
 
@@ -614,7 +619,7 @@ concatlPR arr
 
         ixs'            = U.map (\ix -> if ix >= len2
                                                 then 0
-                                                else ixs2 `U.unsafeIndex` ix)
+                                                else U.index "concatlPR" ixs2 ix)
                         $ ixs1
 
         segd'           = U.mkSegd (U.sum_s segd1 (U.lengthsSegd segd2))
@@ -663,9 +668,9 @@ unconcatPR (PNested vsegd _ _uCantTouchThis) pdata
 --   concatenated data.
 --
 flattenPR :: PR a => PData (PArray a) -> (U.Segd, PData a)
-flattenPR (PNested vsegd _ flat)
+flattenPR arr@(PNested vsegd _ _)
  =      ( U.unsafeDemoteToSegdOfVSegd vsegd
-        , flat)
+        , concatPR arr )
 {-# INLINE_PDATA flattenPR #-}
 
 
index 7f071ce..8110f6a 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.unsafeIndex` i
-     in  case U.tagsSel2    sel `U.unsafeIndex` i of
+   = let !k = U.index "indexPR[Sum2]" (U.indicesSel2 sel) i
+     in  case U.index "indexPR[Sum2]" (U.tagsSel2    sel) i of
              0 -> Alt2_1 (indexPR as k)
              _ -> Alt2_2 (indexPR bs k)
 
@@ -145,9 +145,9 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
    = let (srcids, ixs)  = U.unzip srcixs
    
          getFlagIndex !src !ix
-          = let !sel        = sels                `V.unsafeIndex` src
-                !elemFlag   = (U.tagsSel2    sel) `U.unsafeIndex` ix
-                !elemIndex  = (U.indicesSel2 sel) `U.unsafeIndex` ix
+          = let !sel        = V.unsafeIndex sels src
+                !elemFlag   = U.index "indexPR[Sum2]" (U.tagsSel2 sel)    ix
+                !elemIndex  = U.index "indexPR[Sum2]" (U.indicesSel2 sel) ix
             in  (elemFlag, elemIndex)
             
          (flags', indices')
@@ -307,7 +307,8 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
          sel0_len       = U.length sel0
          starts0        = U.map (\i -> if i >= sel0_len
                                         then 0 
-                                        else sel0 `U.unsafeIndex` i) indices0
+                                        else U.index "extractssPR[Sum2]" sel0 i)
+                                indices0
 
          -- indices1    = [ 0 2 3 3 4 ] (from above)
          -- sel1        = [ 1 2 0 3 0 ]
@@ -317,7 +318,8 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
          sel1_len       = U.length sel1
          starts1        = U.map (\i -> if i >= sel1_len
                                         then 0
-                                        else sel1 `U.unsafeIndex` i) indices1
+                                        else U.index "extractssPR[Sum2]" sel1 i)
+                                indices1
 
          -- Extract the final alts data:
          -- sources     = [ 1 0 1 0 1 ] (from above)
@@ -368,6 +370,10 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
                         , text ""]) $ -}
            PSum2 sel' pdata0 pdata1
 
+  {-# INLINE_PDATA extractvsPR #-}
+  extractvsPR pdatas vsegd
+   = extractssPR pdatas (demoteToSSegdOfVSegd vsegd)
+
 
   -- Pack and Combine ---------------------------
 
index 1c9fa9d..997a37a 100644 (file)
@@ -139,7 +139,7 @@ instance PR () where
         
   {-# INLINE_PDATA indexdPR #-}
   indexdPR (PUnits pdatas) ix
-        = PUnit $ pdatas `U.unsafeIndex` ix
+        = PUnit $ U.index "indexdPR[Unit]" pdatas ix
         
   {-# INLINE_PDATA appenddPR #-}
   appenddPR (PUnits lens1) (PUnits lens2)
index f0d9f7d..de312fa 100644 (file)
@@ -76,15 +76,15 @@ instance PR Word8 where
 
   {-# INLINE_PDATA indexPR #-}
   indexPR (PWord8 uarr) ix
-        = uarr `U.unsafeIndex` ix
+        = U.index "indexPR[Word8]" uarr ix
 
   {-# INLINE_PDATA indexsPR #-}
   indexsPR (PWord8s pvecs) srcixs
    = PWord8 $ U.map (\(src, ix) -> U.unsafeIndex2s pvecs src ix) srcixs
 
-  {-# INLINE_PDATA indexvsPR #-}
-  indexvsPR (PWord8s arrs) vsegd srcixs 
-   = PWord8 $ U.unsafeIndexs_avs arrs vsegd srcixs
+  -- {-# INLINE_PDATA indexvsPR #-}
+  -- indexvsPR (PWord8s arrs) vsegd srcixs 
+  --  = PWord8 $ U.unsafeIndexs_avs arrs vsegd srcixs
 
   {-# INLINE_PDATA extractPR #-}
   extractPR (PWord8 arr) start len 
@@ -94,9 +94,9 @@ instance PR Word8 where
   extractssPR (PWord8s arrs) ssegd
         = PWord8 $ U.unsafeExtracts_ass ssegd arrs
 
-  {-# INLINE_PDATA extractvsPR #-}
-  extractvsPR (PWord8s arrs) vsegd
-        = PWord8 $ U.unsafeExtracts_avs vsegd arrs
+  -- {-# INLINE_PDATA extractvsPR #-}
+  -- extractvsPR (PWord8s arrs) vsegd
+  --       = PWord8 $ U.unsafeExtracts_avs vsegd arrs
 
 
   -- Pack and Combine ---------------------------
index 1ca5fa0..9c06819 100644 (file)
@@ -86,8 +86,7 @@ enumFromStepLenEach size starts steps lens
 
 -- Projections ----------------------------------------------------------------
 length                  = P.length
-(!:)                    = (P.!!)
-unsafeIndex             = (P.!!)
+index _                 = (P.!!)
 unsafeIndexs_avs        = notImplemented "unsafeIndexs_avs"
 
 extract xs i n          = P.take n (P.drop i xs)
@@ -104,7 +103,7 @@ update           = notImplemented "update"
 
 -- Permutation ----------------------------------------------------------------
 permute         = notImplemented "permute"
-bpermute xs ns  = map (xs !:) ns
+bpermute xs ns  = map (xs P.!!) ns
 mbpermute       = notImplemented "mbpermute"
 bpermuteDft     = notImplemented "bpermuteDft"
 
index 423a53a..35f7ab0 100644 (file)
@@ -20,7 +20,7 @@ module Data.Array.Parallel.Unlifted (
 
   -- * Projections
   length,
-  (!:),     unsafeIndex,
+  index,
   unsafeIndexs_avs,
 
   extract,
index b349d31..8003728 100644 (file)
@@ -15,7 +15,7 @@ instance Elts Word8
 instance Elts Float
 instance Elts Double
 
-infixl 9 !:
+infixl 9 `index`
 infixr 5 +:+
 
 -- TRAGIC HACKS ===============================================================
@@ -196,13 +196,8 @@ length :: Elt a => Array a -> Int
 
 
 -- | O(1). Retrieve a numbered element from an array.
-(!:) :: Elt a => Array a -> Int -> a
-{-# INLINE_BACKEND (!:) #-}
-
-
--- | O(1). Retrieve a numbered element from an array, without bounds checks.
-unsafeIndex :: Elt a => Array a -> Int -> a
-{-# INLINE_BACKEND unsafeIndex #-}
+index :: Elt a => Prelude.String -> Array a -> Int -> a
+{-# INLINE_BACKEND index #-}
 
 
 -- | O(n). Scattered indexing through a `VSegd`.
index 32f3958..c7620d1 100644 (file)
@@ -106,8 +106,7 @@ enumFromStepLenEach n starts steps lens
 
 -- Projections ----------------------------------------------------------------
 length                  = Seq.length
-(!:)                    = Seq.index "dph-prim-par:Unlifted index wrapper"
-unsafeIndex             = Seq.index "dph-prim-par:Unlifted index wrapper"
+index                   = Seq.index
 unsafeIndexs_avs        = unsafeIndexsFromVectorsWithUPVSegd
 
 extract arr i n
index 83fc681..e250ddb 100644 (file)
@@ -47,8 +47,7 @@ enumFromStepLenEach     = U.enumFromStepLenEach
 
 -- Projections ----------------------------------------------------------------
 length                  = U.length
-(!:)                    = U.index "dph-prim-seq:Unlifted index wrapper"
-unsafeIndex             = U.index "dph-prim-seq:Unlifted index wrapper" 
+index                   = U.index
 unsafeIndexs_avs        = Prelude.error "dph-prim-seq: unsafeIndex_avs wrapper not defined"
 
 extract                 = U.extract