Fix fusion for sumPA
authorBen Lippmeier <benl@ouroborus.net>
Tue, 11 Oct 2011 09:23:46 +0000 (20:23 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Tue, 11 Oct 2011 09:23:46 +0000 (20:23 +1100)
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Double.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Nested.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/Sums.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPSegd.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPVSegd.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/USSegd.hs

index e00fc00..8e2e435 100644 (file)
@@ -18,7 +18,7 @@ import qualified Data.Vector.Unboxed            as VU
 import Text.PrettyPrint
 
 data instance PData Double
-        = PDouble (U.Array Double)
+        = PDouble !(U.Array Double)
 
 deriving instance Show (PData Double)
 
@@ -70,14 +70,15 @@ instance PR Double where
          -- Unbox these vectors outside the get loop.
          !psegsrcids    = U.takeVSegidsOfVSegd vsegd
          !psegstarts    = U.startsSSegd $ U.takeSSegdOfVSegd vsegd
+         !psegvecs      = V.map (\(PDouble vec) -> vec) psegdatas
 
          -- Lookup a single element from a virtual segment.
          get !vsegid !ix
           = let !psegsrcid       = psegsrcids `VU.unsafeIndex` vsegid
-                !psegdata        = psegdatas  `V.unsafeIndex`  psegsrcid
+                !psegvec         = psegvecs   `V.unsafeIndex`  psegsrcid
                 !psegstart       = psegstarts `VU.unsafeIndex` vsegid
                 !elemIx          = psegstart + ix
-                !elemVal         = psegdata `indexPR` elemIx
+                !elemVal         = psegvec `VU.unsafeIndex` elemIx
             in  elemVal
 
   {-# INLINE_PDATA extractPR #-}
index ac03aee..3963efb 100644 (file)
@@ -500,8 +500,8 @@ instance PR a => PR (PArray a) where
 --   of the total number of elements within it.
 --
 concatPR :: PR a => PData (PArray a) -> PData a
-{-# NOINLINE concatPR #-}
-concatPR (PNested vsegd pdatas)
+concatPR arr = {-# SCC "concatPR" #-} concatPR' arr
+concatPR' (PNested vsegd pdatas)
         -- If we know that the segments are in a single contiguous array, 
         -- and there is no sharing between them, then we can just return
         -- that array directly.
@@ -521,6 +521,8 @@ concatPR (PNested vsegd pdatas)
                 -- Copy these segments into a new array.
           in   extractsPR pdatas ussegd
 
+{-# NOINLINE concatPR  #-}
+
 
 -- | Build a nested array given a single flat data vector, 
 --   and a template nested array that defines the segmentation.
@@ -530,10 +532,9 @@ concatPR (PNested vsegd pdatas)
 --   for every segment. Because of this we need flatten out the virtual
 --   segmentation of the template array.
 --
-
 unconcatPR :: PR a => PData (PArray a) -> PData b -> PData (PArray b)
-{-# NOINLINE unconcatPR #-}
-unconcatPR (PNested vsegd pdatas) arr
+unconcatPR arr1 arr2 = {-# SCC "unconcatPR" #-} unconcatPR' arr1 arr2
+unconcatPR' (PNested vsegd pdatas) arr
  = let  
         -- Get the lengths of all the vsegs individually.
         !vseglens       = U.takeLengthsOfVSegd vsegd
@@ -545,11 +546,12 @@ unconcatPR (PNested vsegd pdatas) arr
 
    in   PNested vsegd' (V.singleton arr)
 
+{-# NOINLINE unconcatPR #-}
+
 
 -- | Lifted concat.
 --   Both arrays must contain the same number of elements.
 concatlPR :: PR a => PData (PArray (PArray a)) -> PData (PArray a)
-{-# INLINE concatlPR #-}
 concatlPR arr
  = let  (segd1, darr1)  = unsafeFlattenPR arr
         (segd2, darr2)  = unsafeFlattenPR darr1
@@ -561,6 +563,7 @@ concatlPR arr
    in   PNested (U.promoteSegdToVSegd segd') 
                 (V.singleton darr2)
 
+{-# INLINE concatlPR #-}
 
 -- | Lifted append.
 --   Both arrays must contain the same number of elements.
index 3baaea3..e4bd6b3 100644 (file)
@@ -24,14 +24,15 @@ sumPA_l_double
         -> PData Double
 {-# NOINLINE sumPA_l_double #-}        
 sumPA_l_double _ (PNested vsegd datas)
- = let  -- Grab all the flat source vectors.
-        pdatas          = V.map toUArrayPR datas
+ = {-# SCC "sumPA_l_double" #-}
+   let  -- Grab all the flat source vectors.
+        !pdatas          = V.map toUArrayPR datas
 
         -- Sum up each physical segment individually.
-        psegResults     = U.fold_ss (+) 0 (U.takeSSegdOfVSegd vsegd) pdatas
+        !psegResults     = U.fold_ss (+) 0 (U.takeSSegdOfVSegd vsegd) pdatas
 
         -- Replicate the physical results according to the vsegids.
-        vsegResults     = U.bpermute psegResults (U.takeVSegidsOfVSegd vsegd) 
+        !vsegResults     = U.bpermute psegResults (U.takeVSegidsOfVSegd vsegd) 
 
    in   PDouble vsegResults
 
@@ -50,7 +51,8 @@ sumPA_l_int
         -> PData Int
 {-# NOINLINE sumPA_l_int #-}
 sumPA_l_int _ (PNested vsegd datas)
- = let  -- Grab all the flat source vectors.
+ = {-# SCC "sumPA_l_int" #-}
+   let  -- Grab all the flat source vectors.
         pdatas          = V.map toUArrayPR datas
 
         -- Sum up each physical segment individually.
index de50365..9d9b521 100644 (file)
@@ -189,7 +189,7 @@ replicateWithP segd !xs
   where
     rep ((dsegd,di),_)
       = Seq.replicateSU dsegd (Seq.slice xs di (USegd.length dsegd))
-{-# NOINLINE replicateWithP #-}
+{-# INLINE_UP replicateWithP #-}
 
 
 -- Fold -----------------------------------------------------------------------
index 44c42b1..b7c44f9 100644 (file)
@@ -270,13 +270,14 @@ unsafeDemoteToUPSegd (UPVSegd _ vsegids upssegd)
 --     the UPSSegd.
 -- 
 updateVSegs :: (Vector Int -> Vector Int) -> UPVSegd -> UPVSegd
-updateVSegs f (UPVSegd _ vsegids upssegd)
+updateVSegs fUpdate (UPVSegd _ vsegids upssegd)
  = let  (vsegids', ussegd') 
-                = USSegd.cullOnVSegids (f vsegids) 
+                = USSegd.cullOnVSegids (fUpdate vsegids) 
                 $ UPSSegd.takeUSSegd upssegd
 
    in   UPVSegd False vsegids' (UPSSegd.fromUSSegd ussegd')
-{-# NOINLINE updateVSegs #-}
+{-# INLINE_UP updateVSegs #-}
+--  INLINE_UP because we want to inline the parameter function fUpdate.
 
 
 -- Append ---------------------------------------------------------------------
index 821638a..aa7b34e 100644 (file)
@@ -44,6 +44,7 @@ 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 ---------------------------------------------------------------------
@@ -314,24 +315,23 @@ streamSegs ussegd@(USSegd _ starts sources usegd) pdatas
         pseglens        = USegd.takeLengths usegd
  
         -- We've finished streaming this pseg
-        {-# INLINE fn #-}
+        {-# INLINE_INNER fn #-}
         fn (pseg, ix)
          -- All psegs are done.
          | pseg >= length ussegd
          = return $ S.Done
          
          -- Current pseg is done
-         | ix   >= pseglens U.! pseg 
-         = fn (pseg + 1, 0)
+         | ix   >= pseglens `VU.unsafeIndex` pseg 
+         = return $ S.Skip (pseg + 1, 0)
 
          -- Stream an element from this pseg
          | otherwise
-         = let  srcid   = sources    U.! pseg
-                pdata   = pdatas     V.!  srcid
-                start   = starts     U.! pseg
-                result  = pdata U.! (start + ix)
-           in   return $ S.Yield result 
-                                (pseg, ix + 1)
+         = let  !srcid   = sources `VU.unsafeIndex` pseg
+                !pdata   = pdatas   `V.unsafeIndex` srcid
+                !start   = starts  `VU.unsafeIndex` pseg
+                !result  = pdata   `VU.unsafeIndex` (start + ix)
+           in   return $ S.Yield result (pseg, ix + 1)
 
    in   M.Stream fn (0, 0) S.Unknown