dph-lifted-vseg: follow name changes and reinstate some INLINEs
authorBen Lippmeier <benl@ouroborus.net>
Mon, 21 Nov 2011 07:00:58 +0000 (18:00 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Mon, 21 Nov 2011 07:00:58 +0000 (18:00 +1100)
12 files changed:
dph-lifted-base/Data/Array/Parallel/PArray.hs
dph-lifted-vseg/Data/Array/Parallel/Lifted/Closure.hs
dph-lifted-vseg/Data/Array/Parallel/PArray.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-lifted-vseg/Data/Array/Parallel/PArray/PRepr.hs
dph-lifted-vseg/Data/Array/Parallel/Prim.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPSSegd.hs

index 314efaf..b49beb7 100644 (file)
@@ -237,9 +237,9 @@ extracts arrs ssegd
         = join
         $ V.zipWith3
                 (\src start len -> extract (arrs V.! src) start len)
-                (V.convert $ U.sourcesSSegd ssegd)
-                (V.convert $ U.startsSSegd  ssegd)
-                (V.convert $ U.lengthsSSegd ssegd)
+                (V.convert $ U.sourcesOfSSegd ssegd)
+                (V.convert $ U.startsOfSSegd  ssegd)
+                (V.convert $ U.lengthsOfSSegd ssegd)
 
 
 -- | Wrapper for `extracts` that takes arrays of sources, starts and lengths of
index 81c51e0..b833c38 100644 (file)
@@ -297,25 +297,28 @@ closure5' fv fl
 -- PData instance for closures ------------------------------------------------
 -- This needs to be here instead of in a module D.A.P.PArray.PData.Closure
 -- to break an import loop.
+-- We use INLINE_CLOSURE for these bindings instead of INLINE_PDATA because
+-- most of the functions return closure constructors, and we want to eliminate
+-- these early in the compilation.
 --
 instance PR (a :-> b) where
 
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR (AClo _ _ env)
         = validPA env
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR (AClo fv fl envs)
         = fv `seq` fl `seq` nfPA envs `seq` ()
 
   -- We can't test functions for equality.
   -- We can't test the environments either, because they're existentially quantified.
   -- Provided the closures have the same type, we just call them similar.
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR _ _
         = True
 
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR weak (AClo _ _ envs) ix
         = coversPA weak envs ix
 
@@ -333,68 +336,74 @@ instance PR (a :-> b) where
 
 
   -- Constructors -------------------------------
-  {-# INLINE_PDATA emptyPR #-}
+  {-# INLINE_CLOSURE emptyPR #-}
   emptyPR
    = let  die    = error "emptydPR[:->]: no function in empty closure array"
       in  AClo die die (emptyPA :: PData ())
 
-  {-# INLINE_PDATA replicatePR #-}
+  {-# INLINE_CLOSURE replicatePR #-}
   replicatePR n (Clo fv fl envs)
         = AClo fv fl (replicatePA n envs)
 
-  {-# INLINE_PDATA replicatesPR #-}
+  {-# INLINE_CLOSURE replicatesPR #-}
   replicatesPR lens (AClo fv fl envs)
         = AClo fv fl (replicatesPA lens envs)
 
 
   -- Projections --------------------------------
-  {-# INLINE_PDATA lengthPR #-}
+  {-# INLINE_CLOSURE lengthPR #-}
   lengthPR (AClo _ _ envs)
         = lengthPA envs
 
-  {-# INLINE_PDATA indexPR #-}
+  {-# INLINE_CLOSURE indexPR #-}
   indexPR (AClo fv fl envs) ix
         = Clo fv fl  $ indexPA envs ix
 
-  {-# INLINE_PDATA indexsPR #-}
+  {-# INLINE_CLOSURE indexsPR #-}
   indexsPR (AClos fv fl envs) srcs ixs
         = AClo fv fl $ indexsPA envs srcs ixs
 
-  {-# INLINE_PDATA extractPR #-}
+  {-# INLINE_CLOSURE extractPR #-}
   extractPR (AClo fv fl envs) start len
         = AClo fv fl $ extractPA envs start len
 
-  {-# INLINE_PDATA extractsPR #-}
+  {-# INLINE_CLOSURE extractsPR #-}
   extractsPR (AClos fv fl envs) ssegd
         = AClo fv fl $ extractsPA envs ssegd
 
 
   -- Pack and Combine ---------------------------
-  {-# INLINE_PDATA packByTagPR #-}
+  {-# INLINE_CLOSURE packByTagPR #-}
   packByTagPR (AClo fv fl envs) tags tag
         = AClo fv fl $ packByTagPA envs tags tag
 
 
   -- Conversions --------------------------------
+  {-# NOINLINE toVectorPR #-}
   toVectorPR (AClo fv fl envs)
         = V.map (Clo fv fl) $ toVectorPA envs
 
 
   -- PDatas -------------------------------------
   -- When constructing an empty array of closures, we don't know what 
+  {-# INLINE_CLOSURE emptydPR #-}
   emptydPR 
    = let die    = error "emptydPR[:->]: no function in empty closure array"
      in  AClos  die die (emptydPA :: PDatas ())
 
+  {-# INLINE_CLOSURE singletondPR #-}
   singletondPR (AClo fv fl env)
         = AClos fv fl $ singletondPA env
         
+  {-# INLINE_CLOSURE lengthdPR #-}
   lengthdPR (AClos _ _ env)
         = lengthdPA env
         
+  {-# INLINE_CLOSURE indexdPR #-}
   indexdPR (AClos fv fl envs) ix
         = AClo fv fl $ indexdPA envs ix
 
+  {-# NOINLINE toVectordPR #-}
   toVectordPR (AClos fv fl envs)
         = V.map (AClo fv fl) $ toVectordPA envs
 
index 3296baa..27df6db 100644 (file)
@@ -318,7 +318,7 @@ extract (PArray _ arr) start len@(I# len#)
 extracts :: PA a => Vector (PArray a) -> U.SSegd -> PArray a
 extracts arrs ssegd
  = let  pdatas          = fromVectordPA $ V.map (\(PArray _ vec) -> vec) arrs
-        !(I# n#)        = (U.sum $ U.lengthsSSegd ssegd)
+        !(I# n#)        = (U.sum $ U.lengthsOfSSegd ssegd)
    in   PArray   n#
                 (extractsPA pdatas ssegd)
 {-# INLINE_PA extracts #-}
@@ -390,9 +390,8 @@ packl xss@(PArray n# xdata@(PNested vsegd _))
       fss@(PArray _  fdata)
  = withRef2 "packl" (R.packl (toRef2 xss) (toRef2 fss))
  $ let  
-        -- Demote the vsegd to get the virtual segmentation of the two arrays.
-        -- The virtual segmentation of both must be the same, but this is not checked.
-        segd            = U.demoteToSegdOfVSegd vsegd
+        -- Demote the vsegd to eliminate the virtual segmentation in the two arrays.
+        segd            = U.unsafeDemoteToSegdOfVSegd vsegd
         
         -- Concatenate both arrays to get the flat data.
         --   Although the virtual segmentation should be the same,
index 5c5557c..cfeb180 100644 (file)
@@ -93,9 +93,9 @@ instance PR Double where
 
   {-# NOINLINE extractsPR #-}
   extractsPR (PDoubles vecpdatas) ussegd
-   = let segsrcs        = U.sourcesSSegd ussegd
-         segstarts      = U.startsSSegd  ussegd
-         seglens        = U.lengthsSSegd ussegd
+   = let segsrcs        = U.sourcesOfSSegd ussegd
+         segstarts      = U.startsOfSSegd  ussegd
+         seglens        = U.lengthsOfSSegd ussegd
      in  PDouble (U.extract_ss vecpdatas segsrcs segstarts seglens)
                 
 
index 8b05fc9..9d008a5 100644 (file)
@@ -82,9 +82,9 @@ instance PR Int where
 
   {-# NOINLINE extractsPR #-}
   extractsPR (PInts vecpdatas) ussegd
-   = let segsrcs        = U.sourcesSSegd ussegd
-         segstarts      = U.startsSSegd  ussegd
-         seglens        = U.lengthsSSegd ussegd
+   = let segsrcs        = U.sourcesOfSSegd ussegd
+         segstarts      = U.startsOfSSegd  ussegd
+         seglens        = U.lengthsOfSSegd ussegd
      in  PInt $ U.extract_ss vecpdatas segsrcs segstarts seglens
 
 
index b88b5ec..5cbbb1a 100644 (file)
@@ -71,13 +71,13 @@ pnested_vsegids    :: PData (PArray a) -> U.Array Int
 pnested_vsegids    =  U.takeVSegidsOfVSegd . pnested_uvsegd
 
 pnested_pseglens   :: PData (PArray a) -> U.Array Int
-pnested_pseglens   =  U.lengthsSSegd . U.takeSSegdOfVSegd . pnested_uvsegd
+pnested_pseglens   =  U.lengthsOfSSegd . U.takeSSegdOfVSegd . pnested_uvsegd
 
 pnested_psegstarts :: PData (PArray a) -> U.Array Int
-pnested_psegstarts  = U.startsSSegd  . U.takeSSegdOfVSegd . pnested_uvsegd
+pnested_psegstarts  = U.startsOfSSegd  . U.takeSSegdOfVSegd . pnested_uvsegd
 
 pnested_psegsrcids :: PData (PArray a) -> U.Array Int
-pnested_psegsrcids  = U.sourcesSSegd . U.takeSSegdOfVSegd . pnested_uvsegd
+pnested_psegsrcids  = U.sourcesOfSSegd . U.takeSSegdOfVSegd . pnested_uvsegd
 
 
 
@@ -355,9 +355,9 @@ instance PR a => PR (PArray a) where
   {-# NOINLINE extractsPR #-}
   extractsPR (PNesteds arrs) ussegd
    = {-# SCC "extractsPR" #-}
-     let segsrcs        = U.sourcesSSegd ussegd
-         segstarts      = U.startsSSegd  ussegd
-         seglens        = U.lengthsSSegd ussegd
+     let segsrcs        = U.sourcesOfSSegd ussegd
+         segstarts      = U.startsOfSSegd  ussegd
+         seglens        = U.lengthsOfSSegd ussegd
 
          vsegids_src    = U.extract_ss (V.map pnested_vsegids  arrs)
                                         segsrcs segstarts seglens
@@ -608,13 +608,16 @@ concatlPR arr
 --   for every segment. Because of this we need flatten out the virtual
 --   segmentation of the template array.
 --
+--   WARNING:
+--   This can cause index space overflow, see the note in `concatPR`.
+--
 unconcatPR :: PR b => PData (PArray a) -> PData b -> PData (PArray b)
 unconcatPR (PNested vsegd _) pdata
  = {-# SCC "unconcatPD" #-}
    let  
         -- Demote the vsegd to a manifest vsegd so it contains all the segment
         -- lengths individually without going through the vsegids.
-        !segd           = U.demoteToSegdOfVSegd vsegd
+        !segd           = U.unsafeDemoteToSegdOfVSegd vsegd
 
         -- Rebuild the vsegd based on the manifest vsegd. 
         -- The vsegids will be just [0..len-1], but this field is constructed
@@ -638,7 +641,7 @@ unconcatPR (PNested vsegd _) pdata
 flattenPR :: PR a => PData (PArray a) -> (U.Segd, PData a)
 {-# INLINE flattenPR #-}
 flattenPR arr@(PNested uvsegd _)
- =      ( U.demoteToSegdOfVSegd uvsegd
+ =      ( U.unsafeDemoteToSegdOfVSegd uvsegd
         , concatPR arr)
 
 
@@ -670,7 +673,7 @@ appendlPR  arr1 arr2
 --
 takeSegdPD :: PData (PArray a) -> U.Segd
 takeSegdPD (PNested vsegd _) 
-        = U.demoteToSegdOfVSegd vsegd
+        = U.unsafeDemoteToSegdOfVSegd vsegd
 {-# NOINLINE takeSegdPD #-}
 
 
index 92b2362..a8aae87 100644 (file)
@@ -252,9 +252,9 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
   extractsPR (PSum2s sels pdatas0 pdatas1) ssegd
    = let                
          tagss          = V.map U.tagsSel2 sels
-         sources        = U.sourcesSSegd ssegd
-         starts         = U.startsSSegd  ssegd
-         lengths        = U.lengthsSSegd  ssegd
+         sources        = U.sourcesOfSSegd ssegd
+         starts         = U.startsOfSSegd  ssegd
+         lengths        = U.lengthsOfSSegd  ssegd
 
          -- Extract the tags of the result elements,
          --  and rebuild the result selector indices based on these tags.
index 357174a..5e9d2f0 100644 (file)
@@ -93,7 +93,7 @@ instance PR () where
         
   {-# INLINE_PDATA extractsPR #-}
   extractsPR _ ussegd
-        = PUnit (U.sum $ U.lengthsSSegd ussegd)
+        = PUnit (U.sum $ U.lengthsOfSSegd ussegd)
 
 
   -- Pack and Combine ---------------------------        
index c68d0f7..d2dec3d 100644 (file)
@@ -91,9 +91,9 @@ instance PR Word8 where
 
   {-# NOINLINE extractsPR #-}
   extractsPR (PWord8s vecpdatas) ussegd
-   = let segsrcs        = U.sourcesSSegd ussegd
-         segstarts      = U.startsSSegd  ussegd
-         seglens        = U.lengthsSSegd ussegd
+   = let segsrcs        = U.sourcesOfSSegd ussegd
+         segstarts      = U.startsOfSSegd  ussegd
+         seglens        = U.lengthsOfSSegd ussegd
      in  PWord8 $ U.extract_ss vecpdatas segsrcs segstarts seglens
 
 
index cb081f8..7e6b175 100644 (file)
@@ -48,6 +48,7 @@ instance  (PprVirtual a, PA a)
 
 -- Unpack ----------------------------------------------------------------------
 -- | Unpack an array to reveal its representation.
+{-# INLINE_PA unpackPA #-}
 unpackPA :: PA a => PArray a -> PData (PRepr a)
 unpackPA (PArray _ pdata)
         = toArrPRepr pdata
index c4f73ad..eb50632 100644 (file)
@@ -86,20 +86,21 @@ import qualified Data.Array.Parallel.Lifted.Closure     as C
 import GHC.Exts
 
 -- Array functions ------------------------------------------------------------
+{-# INLINE_PA emptyPD #-}
 emptyPD :: PA a => PData a
 emptyPD = emptyPA
 
-
+{-# INLINE_PA replicatePD #-}
 replicatePD :: PA a => Int# -> a -> PData a
 replicatePD i# x 
         = replicatePA (I# i#) x
         
-
+{-# INLINE_PA packByTagPD #-}
 packByTagPD :: PA a => PData a -> Int# -> U.Array Tag -> Int# -> PData a
 packByTagPD xs _ tags tag#
         = packByTagPA xs tags (I# tag#)
 
-
+{-# INLINE_PA combine2PD #-}
 combine2PD :: PA a => Int# -> U.Sel2 -> PData a -> PData a -> PData a
 combine2PD _ sel xs ys
         = combine2PA sel xs ys
@@ -110,7 +111,7 @@ combine2PD _ sel xs ys
 -- integers for the first argument of the lifted function.
 
 -- | Construct a closure.
-{-# INLINE closure #-}
+{-# INLINE_CLOSURE closure #-}
 closure :: forall a b e
         .  PA e
         => (e -> a -> b)
@@ -125,13 +126,13 @@ closure fv fl e
 
 
 -- | Apply a closure.
-{-# INLINE ($:) #-}
+{-# INLINE_CLOSURE ($:) #-}
 ($:) :: forall a b. (a :-> b) -> a -> b
 ($:)    = (C.$:)
 
 
 -- | Construct a lifted closure.
-{-# INLINE liftedClosure #-}
+{-# INLINE_CLOSURE liftedClosure #-}
 liftedClosure
         :: forall a b e
         .  PA e
@@ -145,14 +146,15 @@ liftedClosure fv fl es
         (\(I# c) v x -> fl c v x)
         es
         
+
 -- | Apply a lifted closure.
-{-# INLINE liftedApply #-}
+{-# INLINE_CLOSURE liftedApply #-}
 liftedApply :: Int# -> PData (a :-> b) -> PData a -> PData b
 liftedApply n# arr xs
         = C.liftedApply (I# n#) arr xs
 
 
-{-# INLINE closure1 #-}
+{-# INLINE_CLOSURE closure1 #-}
 closure1 :: forall a b
          .  (a -> b)
          -> (PArray a -> PArray b)
@@ -166,7 +168,7 @@ closure1 fv fl
    in   C.closure1 fv fl'
 
 
-{-# INLINE closure2 #-}
+{-# INLINE_CLOSURE closure2 #-}
 closure2 :: forall a b c. PA a
          => (a -> b -> c)
          -> (PArray a -> PArray b -> PArray c)
@@ -180,7 +182,7 @@ closure2 fv fl
    in   C.closure2 fv fl'
 
 
-{-# INLINE closure3 #-}
+{-# INLINE_CLOSURE closure3 #-}
 closure3 :: forall a b c d.  (PA a, PA b)
          => (a -> b -> c -> d)
          -> (PArray a -> PArray b -> PArray c -> PArray d)
@@ -200,7 +202,7 @@ closure3 fv fl
 type Sel2       = U.Sel2
 
 
-{-# INLINE replicateSel2# #-}
+{-# INLINE_PA replicateSel2# #-}
 replicateSel2# :: Int# -> Int# -> Sel2
 replicateSel2# n# tag#
   = U.mkSel2
@@ -214,24 +216,24 @@ replicateSel2# n# tag#
     tag = I# tag#
 
 
-{-# INLINE pickSel2# #-}
+{-# INLINE_PA pickSel2# #-}
 pickSel2# :: Sel2 -> Int# -> U.Array Bool
 pickSel2# sel tag#
         = U.pick (U.tagsSel2 sel) (intToTag (I# tag#))
 
 
-{-# INLINE tagsSel2 #-}
+{-# INLINE_PA tagsSel2 #-}
 tagsSel2 :: Sel2 -> U.Array Tag
 tagsSel2 = U.tagsSel2
 
 
-{-# INLINE elementsSel2_0# #-}
+{-# INLINE_PA elementsSel2_0# #-}
 elementsSel2_0# :: Sel2 -> Int#
 elementsSel2_0# sel
         = case U.elementsSel2_0 sel of { I# n# -> n# }
 
 
-{-# INLINE elementsSel2_1# #-}
+{-# INLINE_PA elementsSel2_1# #-}
 elementsSel2_1# :: Sel2 -> Int#
 elementsSel2_1# sel
         = case U.elementsSel2_1 sel of { I# n# -> n# }
@@ -266,14 +268,14 @@ scalar_zipWith3 = Scalar.zipWith3
 type PArray_Int# = U.Array Int
 
 
+{-# INLINE_PA replicatePA_Int# #-}
 replicatePA_Int# :: Int# -> Int# -> PArray_Int#
 replicatePA_Int# n# i# = U.replicate (I# n#) (I# i#)
-{-# INLINE_PA replicatePA_Int# #-}
 
 
+{-# INLINE_PA emptyPA_Int# #-}
 emptyPA_Int# :: PArray_Int#
 emptyPA_Int# = U.empty
-{-# INLINE_PA emptyPA_Int# #-}
 
 
 {-# RULES
@@ -284,52 +286,52 @@ emptyPA_Int# = U.empty
  #-}
 
 
+{-# NOINLINE packByTagPA_Int# #-}
 packByTagPA_Int# :: a
 packByTagPA_Int#    = error "Data.Array.Parallel.Prim: 'packByTagPA_Int#' not implemented"
 
 
+{-# INLINE_PA combine2'PA_Int# #-}
 combine2'PA_Int# :: PArray_Int# -> PArray_Int# -> PArray_Int# -> PArray_Int#
 combine2'PA_Int# sel xs ys = U.combine (U.map (== 0) sel) xs ys
-{-# INLINE_PA combine2'PA_Int# #-}
 
 
+{-# INLINE_PA combine2PA_Int# #-}
 combine2PA_Int#
         :: Int#
         -> PArray_Int# -> PArray_Int#
         -> PArray_Int# -> PArray_Int# -> PArray_Int#
 combine2PA_Int# _ sel _ xs ys = combine2'PA_Int# sel xs ys
-{-# INLINE_PA combine2PA_Int# #-}
 
 
 -- Double functions -----------------------------------------------------------
 type PArray_Double# = U.Array Double
 
 
+{-# INLINE_PA replicatePA_Double# #-}
 replicatePA_Double# :: Int# -> Double# -> PArray_Double#
 replicatePA_Double# n# d# = U.replicate (I# n#) (D# d#)
-{-# INLINE_PA replicatePA_Double# #-}
 
 
+{-# INLINE_PA emptyPA_Double# #-}
 emptyPA_Double# :: PArray_Double#
 emptyPA_Double# = U.empty
-{-# INLINE_PA emptyPA_Double# #-}
-
 
+{-# NOINLINE packByTagPA_Double# #-}
 packByTagPA_Double# :: a
 packByTagPA_Double# = error "Data.Array.Parallel.Prim: 'packByTagPA_Double#' not implemented"
 
 
+{-# INLINE_PA combine2'PA_Double# #-}
 combine2'PA_Double#
         :: PArray_Int#
         -> PArray_Double# -> PArray_Double# -> PArray_Double#
 combine2'PA_Double# sel xs ys = U.combine (U.map (== 0) sel) xs ys
-{-# INLINE_PA combine2'PA_Double# #-}
 
 
+{-# INLINE_PA combine2PA_Double# #-}
 combine2PA_Double#
         :: Int#
         -> PArray_Int# -> PArray_Int#
         -> PArray_Double# -> PArray_Double# -> PArray_Double#
 combine2PA_Double# _ sel _ xs ys = combine2'PA_Double# sel xs ys
-{-# INLINE_PA combine2PA_Double# #-}
-
index 1d09db8..4a7ca74 100644 (file)
@@ -244,8 +244,9 @@ appendWith
 appendWith upssegd1 pdatas1
            upssegd2 pdatas2
  = fromUSSegd 
- $ USSegd.append (upssegd_ussegd upssegd1) pdatas1
-                 (upssegd_ussegd upssegd2) pdatas2
+ $ USSegd.appendWith
+        (upssegd_ussegd upssegd1) pdatas1
+        (upssegd_ussegd upssegd2) pdatas2
 {-# NOINLINE appendWith #-}
 --  NOINLINE because we're not using it yet.