Wind back INLINEs to make nbody compile
authorBen Lippmeier <benl@ouroborus.net>
Thu, 17 Nov 2011 05:34:52 +0000 (16:34 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Thu, 17 Nov 2011 05:34:52 +0000 (16:34 +1100)
16 files changed:
dph-lifted-base/Data/Array/Parallel/PArray/Reference.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/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/Void.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/UPVSegd.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/USSegd.hs

index 386530d..5ac476c 100644 (file)
@@ -1,4 +1,5 @@
 {-# LANGUAGE UndecidableInstances #-}
+{-# OPTIONS -fno-warn-missing-signatures #-}
 -- | During testing, we compare the output of each invocation of the lifted
 --   combinators in "Data.Array.Parallel.PArray" with the reference implementations. 
 --
@@ -51,7 +52,17 @@ withRef1 :: ( A.Array r a
          -> c a                 -- result using vseg implementation
          -> c a
 
+--  Careful: We don't want to inline the whole body of this function into
+--  every use site, or we'll get code explosion. When debugging is off we
+--  want this wrapper to be inlined and eliminated as cheaply as possible.
+{-# INLINE withRef1 #-}
 withRef1 name arrRef arrImpl
+ = if debugLiftedCompare || debugLiftedTrace
+        then withRef1' name arrRef arrImpl
+        else arrImpl
+        
+{-# NOINLINE withRef1' #-}
+withRef1' name arrRef arrImpl
  = let  trace'
          = if debugLiftedTrace  
             then trace (render $ text " " 
@@ -77,7 +88,6 @@ withRef1 name arrRef arrImpl
    in   trace' (if debugLiftedCompare
                  then (if resultOk then arrImpl else resultFail)
                  else arrImpl)
-{-# INLINE withRef1 #-}
 
 
 -- | Compare the nested result of some array operator against a reference.
@@ -91,7 +101,14 @@ withRef2 :: ( A.Array r (r a)
          -> c (c a)     -- result using vseg implementation.
          -> c (c a)
 
+{-# INLINE withRef2 #-}
 withRef2 name arrRef arrImpl
+ = if debugLiftedCompare || debugLiftedTrace
+         then withRef2' name arrRef arrImpl
+         else arrImpl
+
+{-# NOINLINE withRef2' #-}
+withRef2' name arrRef arrImpl
  = let  trace'
          = if debugLiftedTrace  
             then trace (render $ text " " 
@@ -114,7 +131,6 @@ withRef2 name arrRef arrImpl
    in   trace' (if debugLiftedCompare
                  then (if resultOK then arrImpl else resultFail)
                  else arrImpl)
-{-# INLINE withRef2 #-}
 
 
 -- toRef ----------------------------------------------------------------------
@@ -124,6 +140,8 @@ toRef1  :: ( A.Array c a
         => c a -> r a
 
 toRef1  = A.fromVectors1 . A.toVectors1
+{-# NOINLINE toRef1 #-}
+--  NOINLINE because it's only for debugging.
 
 
 -- | Convert a nested array to the reference version.
@@ -135,6 +153,8 @@ toRef2 :: ( A.Array c (c a)
        -> r (r a)
 
 toRef2  = A.fromVectors2 . A.toVectors2
+{-# NOINLINE toRef2 #-}
+--  NOINLINE because it's only for debugging.
 
 
 -- | Convert a doubly nested array to the reference version.
@@ -148,4 +168,5 @@ toRef3 :: ( A.Array c (c (c a))
        -> r (r (r a))
 
 toRef3  = A.fromVectors3 . A.toVectors3
-
+{-# NOINLINE toRef3 #-}
+--  NOINLINE because it's only for debugging.
index 81fe1a2..9bc7f10 100644 (file)
@@ -61,8 +61,8 @@ takeData (PArray _ d)   = d
 --   An example of an array with no length is PData Void. We can index this
 --   at an arbitrary position, and always get a 'void' element back.
 --
-data family PData a
 {-# ANN type PData NoSpecConstr #-}
+data family PData a
 
 -- | Several chunks of parallel array data.
 --
index e5d5aed..5c5557c 100644 (file)
@@ -24,18 +24,18 @@ data instance PDatas Double
 -- PR -------------------------------------------------------------------------
 instance PR Double where
 
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR _
         = True
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR (PDouble xx)
         = xx `seq` ()
 
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR  = (==)
 
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR weak (PDouble uarr) ix
    | weak       = ix <= U.length uarr
    | otherwise  = ix <  U.length uarr
@@ -87,11 +87,11 @@ instance PR Double where
    where get !src !ix
                 = (pvecs V.! src) VU.! ix
 
-  {-# INLINE_PDATA extractPR #-}
+  {-# NOINLINE extractPR #-}
   extractPR (PDouble arr) start len 
         = PDouble (U.extract arr start len)
 
-  {-# INLINE_PDATA extractsPR #-}
+  {-# NOINLINE extractsPR #-}
   extractsPR (PDoubles vecpdatas) ussegd
    = let segsrcs        = U.sourcesSSegd ussegd
          segstarts      = U.startsSSegd  ussegd
@@ -100,11 +100,11 @@ instance PR Double where
                 
 
   -- Pack and Combine ---------------------------
-  {-# INLINE_PDATA packByTagPR #-}
+  {-# NOINLINE packByTagPR #-}
   packByTagPR (PDouble arr1) arrTags tag
         = PDouble $ U.packByTag arr1 arrTags tag
 
-  {-# INLINE_PDATA combine2PR #-}
+  {-# NOINLINE combine2PR #-}
   combine2PR sel (PDouble arr1) (PDouble arr2)
         = PDouble (U.combine2 (U.tagsSel2 sel)
                            (U.repSel2  sel)
@@ -112,11 +112,11 @@ instance PR Double where
 
 
   -- Conversions --------------------------------
-  {-# INLINE_PDATA fromVectorPR #-}
+  {-# NOINLINE fromVectorPR #-}
   fromVectorPR xx
         = PDouble (U.fromList $ V.toList xx)
 
-  {-# INLINE_PDATA toVectorPR #-}
+  {-# NOINLINE toVectorPR #-}
   toVectorPR (PDouble arr)
         = V.fromList $ U.toList arr
 
@@ -142,11 +142,11 @@ instance PR Double where
   appenddPR (PDoubles xs) (PDoubles ys)
         = PDoubles $ xs V.++ ys
         
-  {-# INLINE_PDATA fromVectordPR #-}
+  {-# NOINLINE fromVectordPR #-}
   fromVectordPR vec
         = PDoubles $ V.map (\(PDouble xs) -> xs) vec
         
-  {-# INLINE_PDATA toVectordPR #-}
+  {-# NOINLINE toVectordPR #-}
   toVectordPR (PDoubles vec)
         = V.map PDouble vec
 
index 3366e85..8b05fc9 100644 (file)
@@ -14,18 +14,18 @@ import Data.Array.Parallel.Pretty
 -- PR -------------------------------------------------------------------------
 instance PR Int where
 
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR _
         = True
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR (PInt xx)
         = xx `seq` ()
 
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR  = (==)
 
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR weak (PInt uarr) ix
    | weak       = ix <= U.length uarr
    | otherwise  = ix <  U.length uarr
@@ -76,11 +76,11 @@ instance PR Int where
    where get !src !ix
                 = (pvecs V.! src) VU.! ix
 
-  {-# INLINE_PDATA extractPR #-}
+  {-# NOINLINE extractPR #-}
   extractPR (PInt arr) start len 
         = PInt (U.extract arr start len)
 
-  {-# INLINE_PDATA extractsPR #-}
+  {-# NOINLINE extractsPR #-}
   extractsPR (PInts vecpdatas) ussegd
    = let segsrcs        = U.sourcesSSegd ussegd
          segstarts      = U.startsSSegd  ussegd
@@ -90,11 +90,11 @@ instance PR Int where
 
 
   -- Pack and Combine ---------------------------
-  {-# INLINE_PDATA packByTagPR #-}
+  {-# NOINLINE packByTagPR #-}
   packByTagPR (PInt arr1) arrTags tag
         = PInt $ U.packByTag arr1 arrTags tag
 
-  {-# INLINE_PDATA combine2PR #-}
+  {-# NOINLINE combine2PR #-}
   combine2PR sel (PInt arr1) (PInt arr2)
         = PInt $ U.combine2 (U.tagsSel2 sel)
                            (U.repSel2  sel)
@@ -102,11 +102,11 @@ instance PR Int where
 
 
   -- Conversions --------------------------------
-  {-# INLINE_PDATA fromVectorPR #-}
+  {-# NOINLINE fromVectorPR #-}
   fromVectorPR xx
         = PInt $U.fromList $ V.toList xx
 
-  {-# INLINE_PDATA toVectorPR #-}
+  {-# NOINLINE toVectorPR #-}
   toVectorPR (PInt arr)
         = V.fromList $ U.toList arr
 
@@ -132,11 +132,11 @@ instance PR Int where
   appenddPR (PInts xs) (PInts ys)
         = PInts $ xs V.++ ys
         
-  {-# INLINE_PDATA fromVectordPR #-}
+  {-# NOINLINE fromVectordPR #-}
   fromVectordPR vec
         = PInts $ V.map (\(PInt xs) -> xs) vec
         
-  {-# INLINE_PDATA toVectordPR #-}
+  {-# NOINLINE toVectordPR #-}
   toVectordPR (PInts vec)
         = V.map PInt vec
 
index 5a68b29..b88b5ec 100644 (file)
@@ -88,7 +88,7 @@ instance PR a => PR (PArray a) where
   -- TODO: make this check all sub arrays as well
   -- TODO: ensure that all psegdata arrays are referenced from some psegsrc.
   -- TODO: shift segd checks into associated modules.
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR arr
    = let 
          vsegids        = pnested_vsegids     arr
@@ -158,18 +158,18 @@ instance PR a => PR (PArray a) where
              , psegsReffedOK ]
 
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR    = error "nfPR[PArray]: not defined yet"
 
 
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR (PArray _ pdata1) (PArray _ pdata2)
         = V.and $ V.zipWith similarPR 
                         (toVectorPR pdata1)
                         (toVectorPR pdata2)
 
 
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR weak (PNested vsegd _ ) ix
    | weak       = ix <= (U.length $ U.takeVSegidsOfVSegd vsegd)
    | otherwise  = ix <  (U.length $ U.takeVSegidsOfVSegd vsegd)
@@ -217,7 +217,7 @@ instance PR a => PR (PArray a) where
   -- TODO: If we know the lens does not contain zeros, then we don't need
   --       to cull down the psegs.
   --
-  {-# INLINE_PDATA replicatesPR #-}
+  {-# NOINLINE replicatesPR #-}
   replicatesPR segd (PNested uvsegd pdata)
    = PNested (U.updateVSegsOfVSegd
                 (\vsegids -> U.replicate_s segd vsegids) uvsegd)
@@ -226,7 +226,7 @@ instance PR a => PR (PArray a) where
 
   -- Append nested arrays by appending the segment descriptors,
   -- and putting all physical arrays in the result.
-  {-# INLINE_PDATA appendPR #-}
+  {-# NOINLINE appendPR #-}
   appendPR (PNested uvsegd1 pdatas1) (PNested uvsegd2 pdatas2)
    = PNested    (U.appendVSegd
                         uvsegd1 (lengthdPR pdatas1) 
@@ -242,7 +242,7 @@ instance PR a => PR (PArray a) where
   -- anyway. Once this is done we use copying segmented append on the flat 
   -- arrays, and then reconstruct the segment descriptor.
   --
-  {-# INLINE_PDATA appendsPR #-}
+  {-# NOINLINE appendsPR #-}
   appendsPR rsegd segd1 xarr segd2 yarr
    = let (xsegd, xs)    = flattenPR xarr
          (ysegd, ys)    = flattenPR yarr
@@ -268,7 +268,7 @@ instance PR a => PR (PArray a) where
   {-# INLINE_PDATA lengthPR #-}
   lengthPR (PNested vsegd _)
         = U.lengthOfVSegd vsegd
-        
+
 
   -- To index into a nested array, first determine what segment the index
   -- corresponds to, and extract that as a slice from that physical array.
@@ -316,7 +316,7 @@ instance PR a => PR (PArray a) where
   -- To extract a range of elements from a nested array, perform the extract
   -- on the vsegids field. The `updateVSegsOfUVSegd` function will then filter
   -- out all of the psegs that are no longer reachable from the new vsegids.
-  {-# INLINE_PDATA extractPR #-}
+  {-# NOINLINE extractPR #-}
   extractPR (PNested uvsegd pdata) start len
    = {-# SCC "extractPR" #-}
      PNested (U.updateVSegsOfVSegd (\vsegids -> U.extract vsegids start len) uvsegd)
@@ -352,7 +352,7 @@ instance PR a => PR (PArray a) where
   --  We encode these offsets in the psrcoffset vector:
   --       psrcoffset :  [0, 2]
   --
-  {-# INLINE_PDATA extractsPR #-}
+  {-# NOINLINE extractsPR #-}
   extractsPR (PNesteds arrs) ussegd
    = {-# SCC "extractsPR" #-}
      let segsrcs        = U.sourcesSSegd ussegd
@@ -405,7 +405,7 @@ instance PR a => PR (PArray a) where
   --      vsegids:        [0 0 1 1 2 2 2 2 3 3 4 4 4 5 5 5 5 6 6]
   --  =>  vsegids_packed: [  0 1 1         3         5   5   6 6]
   --       
-  {-# INLINE_PDATA packByTagPR #-}
+  {-# NOINLINE packByTagPR #-}
   packByTagPR (PNested uvsegd pdata) tags tag
    = PNested (U.updateVSegsOfVSegd (\vsegids -> U.packByTag vsegids tags tag) uvsegd)
              pdata
@@ -413,7 +413,7 @@ instance PR a => PR (PArray a) where
 
   -- Combine nested arrays by combining the segment descriptors, 
   -- and putting all physical arrays in the result.
-  {-# INLINE_PDATA combine2PR #-}
+  {-# NOINLINE combine2PR #-}
   combine2PR sel2 (PNested uvsegd1 pdatas1) (PNested uvsegd2 pdatas2)
    = PNested    (U.combine2VSegd sel2 
                         uvsegd1 (lengthdPR pdatas1)
@@ -422,7 +422,7 @@ instance PR a => PR (PArray a) where
 
 
   -- Conversions ----------------------
-  {-# INLINE_PDATA fromVectorPR #-}
+  {-# NOINLINE fromVectorPR #-}
   fromVectorPR xx
    | V.length xx == 0 = emptyPR
    | otherwise
@@ -435,7 +435,7 @@ instance PR a => PR (PArray a) where
                 (singletondPR (V.foldl1 appendPR $ V.map takeData xx))
 
 
-  {-# INLINE_PDATA toVectorPR #-}
+  {-# NOINLINE toVectorPR #-}
   toVectorPR arr
    = V.generate (U.length (pnested_vsegids arr))
    $ indexPR arr
@@ -492,7 +492,7 @@ indexlPR (PNested vsegd pdatas) (PInt ixs)
                         ixs
                         
    in   indexsPR pdatas (PInt srcids') (PInt ixs')
-
+{-# INLINE_PDATA indexlPR #-}
 
 -------------------------------------------------------------------------------
 -- | O(len result). Concatenate a nested array.
@@ -671,7 +671,7 @@ appendlPR  arr1 arr2
 takeSegdPD :: PData (PArray a) -> U.Segd
 takeSegdPD (PNested vsegd _) 
         = U.demoteToSegdOfVSegd vsegd
-{-# INLINE_PDATA takeSegdPD #-}
+{-# NOINLINE takeSegdPD #-}
 
 
 -- | Extract some slices from some arrays.
index 9b04da4..92b2362 100644 (file)
@@ -36,22 +36,22 @@ type Sels2
 -- PR -------------------------------------------------------------------------
 instance (PR a, PR b) => PR (Sum2 a b)  where
 
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR _
         = True
 
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR x y
    = case (x, y) of
         (Alt2_1 x', Alt2_1 y')  -> similarPR x' y'
         (Alt2_2 x', Alt2_2 y')  -> similarPR x' y'
         _                       -> False
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR (PSum2 sel xs ys)
         = sel `seq` nfPR xs `seq` nfPR ys `seq` ()
 
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR weak (PSum2 sel _ _) ix
    | weak       = ix <= U.length (U.tagsSel2 sel)
    | otherwise  = ix <  U.length (U.tagsSel2 sel)
@@ -182,7 +182,7 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
   --   ALTS0: PInt [40 80]
   --   ALTS1: PInt [50 60 70]
   --  
-  {-# INLINE_PDATA extractPR #-}
+  {-# NOINLINE extractPR #-}
   extractPR  (PSum2 sel as bs) start len
    = let 
          -- Extract the tags of the result elements,
@@ -248,7 +248,7 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
   --   STARTS:  [1 0 4 2 0]
   --  LENGTHS:  [3 2 2 1 1]
   -- 
-  {-# INLINE_PDATA extractsPR #-}
+  {-# NOINLINE extractsPR #-}
   extractsPR (PSum2s sels pdatas0 pdatas1) ssegd
    = let                
          tagss          = V.map U.tagsSel2 sels
@@ -377,7 +377,7 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
   --  as'     = [20 50]
   --  as'     = [30 80]
   --
-  {-# INLINE_PDATA packByTagPR #-}
+  {-# NOINLINE packByTagPR #-}
   packByTagPR (PSum2 sel as bs) tags tag
    = let flags     = U.tagsSel2 sel
 
@@ -401,7 +401,7 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
      in  PSum2 sel' as' bs'
   
   
-  {-# INLINE_PDATA combine2PR #-}
+  {-# NOINLINE combine2PR #-}
   combine2PR sel (PSum2 sel1 as1 bs1) (PSum2 sel2 as2 bs2)
    = let tags     = U.tagsSel2 sel
          tags'    = U.combine2 (U.tagsSel2 sel)  (U.repSel2 sel)
@@ -418,7 +418,7 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
 
   -- Conversions --------------------------------\b
   -- TODO: fix rubbish via-lists filtering.   
-  {-# INLINE_PDATA fromVectorPR #-}
+  {-# NOINLINE fromVectorPR #-}
   fromVectorPR vec
    = let tags   = V.convert $ V.map tagOfSum2 vec
          sel2   = U.tagsToSel2 tags
@@ -428,7 +428,7 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
      in  PSum2 sel2 as' bs'
         
 
-  {-# INLINE_PDATA toVectorPR #-}
+  {-# NOINLINE toVectorPR #-}
   toVectorPR pdata@(PSum2 sel _ _)
    = let len = U.length $ U.tagsSel2 sel
      in  if len == 0
@@ -471,7 +471,7 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
 
 
   -- TODO: fix rubbish via-lists conversion.
-  {-# INLINE_PDATA fromVectordPR #-}
+  {-# NOINLINE fromVectordPR #-}
   fromVectordPR vec
    = let   (sels, pdatas1, pdatas2) 
                    = P.unzip3 
@@ -482,7 +482,7 @@ instance (PR a, PR b) => PR (Sum2 a b)  where
                    (fromVectordPR $ V.fromList pdatas2)
                 
 
-  {-# INLINE_PDATA toVectordPR #-}
+  {-# NOINLINE toVectordPR #-}
   toVectordPR (PSum2s sels pdatas1 pdatas2)
    = let  vecs1 = toVectordPR pdatas1
           vecs2 = toVectordPR pdatas2
index f07d99f..41ff66b 100644 (file)
@@ -29,23 +29,23 @@ data instance PDatas (a, b)
 -- PR -------------------------------------------------------------------------
 instance (PR a, PR b) => PR (a, b) where
 
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR (PTuple2 xs ys)
         = validPR xs && validPR ys
 
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR (PTuple2 arr1 arr2)
         = nfPR arr1 `seq` nfPR arr2 `seq` ()
 
 
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR (x1, y1) (x2, y2)
         =  similarPR x1 x2
         && similarPR y1 y2
 
 
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR weak (PTuple2 arr1 arr2) ix
         =  coversPR weak arr1 ix
         && coversPR weak arr2 ix
@@ -103,37 +103,37 @@ instance (PR a, PR b) => PR (a, b) where
         = PTuple2 (indexsPR xs srcs ixs)
                   (indexsPR ys srcs ixs)
 
-  {-# INLINE_PDATA extractPR #-}
+  {-# NOINLINE extractPR #-}
   extractPR (PTuple2 arr1 arr2) start len
         = PTuple2 (extractPR arr1 start len) 
                   (extractPR arr2 start len)
 
-  {-# INLINE_PDATA extractsPR #-}
+  {-# NOINLINE extractsPR #-}
   extractsPR (PTuple2s xs ys) ussegd
         = PTuple2 (extractsPR xs ussegd)
                   (extractsPR ys ussegd)
 
 
   -- Pack and Combine ---------------------------
-  {-# INLINE_PDATA packByTagPR #-}
+  {-# NOINLINE packByTagPR #-}
   packByTagPR (PTuple2 arr1 arr2) tags tag
         = PTuple2 (packByTagPR arr1 tags tag)
                   (packByTagPR arr2 tags tag)
 
-  {-# INLINE_PDATA combine2PR #-}
+  {-# NOINLINE combine2PR #-}
   combine2PR sel (PTuple2 xs1 ys1) (PTuple2 xs2 ys2)
         = PTuple2 (combine2PR sel xs1 xs2)
                   (combine2PR sel ys1 ys2)
 
 
   -- Conversions --------------------------------
-  {-# INLINE_PDATA fromVectorPR #-}
+  {-# NOINLINE fromVectorPR #-}
   fromVectorPR vec
    = let (xs, ys)       = V.unzip vec
      in  PTuple2  (fromVectorPR xs)
                   (fromVectorPR ys)
 
-  {-# INLINE_PDATA toVectorPR #-}
+  {-# NOINLINE toVectorPR #-}
   toVectorPR (PTuple2 xs ys)
         = V.zip   (toVectorPR xs)
                   (toVectorPR ys)
@@ -169,14 +169,14 @@ instance (PR a, PR b) => PR (a, b) where
                    (appenddPR ys1 ys2)
   
 
-  {-# INLINE_PDATA fromVectordPR #-}
+  {-# NOINLINE fromVectordPR #-}
   fromVectordPR vec
    = let (xss, yss) = V.unzip $ V.map (\(PTuple2 xs ys) -> (xs, ys)) vec
      in  PTuple2s  (fromVectordPR xss)
                    (fromVectordPR yss)
 
 
-  {-# INLINE_PDATA toVectordPR #-}
+  {-# NOINLINE toVectordPR #-}
   toVectordPR (PTuple2s pdatas1 pdatas2)
         = V.zipWith PTuple2
                 (toVectordPR pdatas1)
index c9a6dca..92bf697 100644 (file)
@@ -25,24 +25,24 @@ data instance PDatas (a, b, c)
 -- PR -------------------------------------------------------------------------
 instance (PR a, PR b, PR c) => PR (a, b, c) where
 
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR (PTuple3 xs ys zs)
         = validPR xs && validPR ys && validPR zs
 
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR (PTuple3 arr1 arr2 arr3)
         = nfPR arr1 `seq` nfPR arr2 `seq` nfPR arr3 `seq` ()
 
 
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR (x1, y1, z1) (x2, y2, z2)
         =  similarPR x1 x2
         && similarPR y1 y2
         && similarPR z1 z2
 
 
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR weak (PTuple3 arr1 arr2 arr3) ix
         =  coversPR weak arr1 ix
         && coversPR weak arr2 ix
@@ -113,13 +113,13 @@ instance (PR a, PR b, PR c) => PR (a, b, c) where
                   (indexsPR ys srcs ixs)
                   (indexsPR zs srcs ixs)
 
-  {-# INLINE_PDATA extractPR #-}
+  {-# NOINLINE extractPR #-}
   extractPR (PTuple3 arr1 arr2 arr3) start len
         = PTuple3 (extractPR arr1 start len) 
                   (extractPR arr2 start len)
                   (extractPR arr3 start len)
 
-  {-# INLINE_PDATA extractsPR #-}
+  {-# NOINLINE extractsPR #-}
   extractsPR (PTuple3s xs ys zs) ussegd
         = PTuple3 (extractsPR xs ussegd)
                   (extractsPR ys ussegd)
@@ -127,13 +127,13 @@ instance (PR a, PR b, PR c) => PR (a, b, c) where
 
 
   -- Pack and Combine ---------------------------
-  {-# INLINE_PDATA packByTagPR #-}
+  {-# NOINLINE packByTagPR #-}
   packByTagPR (PTuple3 arr1 arr2 arr3) tags tag
         = PTuple3 (packByTagPR arr1 tags tag)
                   (packByTagPR arr2 tags tag)
                   (packByTagPR arr3 tags tag)
 
-  {-# INLINE_PDATA combine2PR #-}
+  {-# NOINLINE combine2PR #-}
   combine2PR sel (PTuple3 xs1 ys1 zs1) (PTuple3 xs2 ys2 zs2)
         = PTuple3 (combine2PR sel xs1 xs2)
                   (combine2PR sel ys1 ys2)
@@ -141,14 +141,14 @@ instance (PR a, PR b, PR c) => PR (a, b, c) where
 
 
   -- Conversions --------------------------------
-  {-# INLINE_PDATA fromVectorPR #-}
+  {-# NOINLINE fromVectorPR #-}
   fromVectorPR vec
    = let (xs, ys, zs)       = V.unzip3 vec
      in  PTuple3  (fromVectorPR xs)
                   (fromVectorPR ys)
                   (fromVectorPR zs)
 
-  {-# INLINE_PDATA toVectorPR #-}
+  {-# NOINLINE toVectorPR #-}
   toVectorPR (PTuple3 xs ys zs)
         = V.zip3  (toVectorPR xs)
                   (toVectorPR ys)
@@ -189,7 +189,7 @@ instance (PR a, PR b, PR c) => PR (a, b, c) where
                    (appenddPR zs1 zs2)
   
 
-  {-# INLINE_PDATA fromVectordPR #-}
+  {-# NOINLINE fromVectordPR #-}
   fromVectordPR vec
    = let (xss, yss, zss) = V.unzip3 $ V.map (\(PTuple3 xs ys zs) -> (xs, ys, zs)) vec
      in  PTuple3s  (fromVectordPR xss)
@@ -197,7 +197,7 @@ instance (PR a, PR b, PR c) => PR (a, b, c) where
                    (fromVectordPR zss)
 
 
-  {-# INLINE_PDATA toVectordPR #-}
+  {-# NOINLINE toVectordPR #-}
   toVectordPR (PTuple3s pdatas1 pdatas2 pdatas3)
         = V.zipWith3 PTuple3
                    (toVectordPR pdatas1)
index 9bfeb87..2f08902 100644 (file)
@@ -26,17 +26,17 @@ data instance PDatas (a, b, c, d)
 -- PR -------------------------------------------------------------------------
 instance (PR a, PR b, PR c, PR d) => PR (a, b, c, d) where
 
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR (PTuple4 xs ys zs ds)
         = validPR xs && validPR ys && validPR zs && validPR ds
 
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR (PTuple4 arr1 arr2 arr3 arr4)
         = nfPR arr1 `seq` nfPR arr2 `seq` nfPR arr3 `seq` nfPR arr4 `seq` ()
 
 
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR (x1, y1, z1, d1) (x2, y2, z2, d2)
         =  similarPR x1 x2
         && similarPR y1 y2
@@ -44,7 +44,7 @@ instance (PR a, PR b, PR c, PR d) => PR (a, b, c, d) where
         && similarPR d1 d2
 
 
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR weak (PTuple4 arr1 arr2 arr3 arr4) ix
         =  coversPR weak arr1 ix
         && coversPR weak arr2 ix
@@ -130,14 +130,14 @@ instance (PR a, PR b, PR c, PR d) => PR (a, b, c, d) where
                   (indexsPR zs srcs ixs)
                   (indexsPR ds srcs ixs)
 
-  {-# INLINE_PDATA extractPR #-}
+  {-# NOINLINE extractPR #-}
   extractPR (PTuple4 arr1 arr2 arr3 arr4) start len
         = PTuple4 (extractPR arr1 start len) 
                   (extractPR arr2 start len)
                   (extractPR arr3 start len)
                   (extractPR arr4 start len)
 
-  {-# INLINE_PDATA extractsPR #-}
+  {-# NOINLINE extractsPR #-}
   extractsPR (PTuple4s xs ys zs ds) ussegd
         = PTuple4 (extractsPR xs ussegd)
                   (extractsPR ys ussegd)
@@ -146,7 +146,7 @@ instance (PR a, PR b, PR c, PR d) => PR (a, b, c, d) where
 
 
   -- Pack and Combine ---------------------------
-  {-# INLINE_PDATA packByTagPR #-}
+  {-# NOINLINE packByTagPR #-}
   packByTagPR (PTuple4 arr1 arr2 arr3 arr4) tags tag
         = PTuple4 (packByTagPR arr1 tags tag)
                   (packByTagPR arr2 tags tag)
@@ -154,7 +154,7 @@ instance (PR a, PR b, PR c, PR d) => PR (a, b, c, d) where
                   (packByTagPR arr4 tags tag)
 
 
-  {-# INLINE_PDATA combine2PR #-}
+  {-# NOINLINE combine2PR #-}
   combine2PR sel (PTuple4 xs1 ys1 zs1 ds1) (PTuple4 xs2 ys2 zs2 ds2)
         = PTuple4 (combine2PR sel xs1 xs2)
                   (combine2PR sel ys1 ys2)
@@ -163,7 +163,7 @@ instance (PR a, PR b, PR c, PR d) => PR (a, b, c, d) where
 
 
   -- Conversions --------------------------------
-  {-# INLINE_PDATA fromVectorPR #-}
+  {-# NOINLINE fromVectorPR #-}
   fromVectorPR vec
    = let (xs, ys, zs, ds)       = V.unzip4 vec
      in  PTuple4  (fromVectorPR xs)
@@ -171,7 +171,7 @@ instance (PR a, PR b, PR c, PR d) => PR (a, b, c, d) where
                   (fromVectorPR zs)
                   (fromVectorPR ds)
 
-  {-# INLINE_PDATA toVectorPR #-}
+  {-# NOINLINE toVectorPR #-}
   toVectorPR (PTuple4 xs ys zs ds)
         = V.zip4  (toVectorPR xs)
                   (toVectorPR ys)
@@ -217,7 +217,7 @@ instance (PR a, PR b, PR c, PR d) => PR (a, b, c, d) where
                    (appenddPR ds1 ds2)
   
 
-  {-# INLINE_PDATA fromVectordPR #-}
+  {-# NOINLINE fromVectordPR #-}
   fromVectordPR vec
    = let (xss, yss, zss, dss) = V.unzip4 $ V.map (\(PTuple4 xs ys zs ds) -> (xs, ys, zs, ds)) vec
      in  PTuple4s  (fromVectordPR xss)
@@ -226,7 +226,7 @@ instance (PR a, PR b, PR c, PR d) => PR (a, b, c, d) where
                    (fromVectordPR dss)
 
 
-  {-# INLINE_PDATA toVectordPR #-}
+  {-# NOINLINE toVectordPR #-}
   toVectordPR (PTuple4s pdatas1 pdatas2 pdatas3 pdatas4)
         = V.zipWith4 PTuple4
                    (toVectordPR pdatas1)
index d0e9b37..297f909 100644 (file)
@@ -26,17 +26,17 @@ data instance PDatas (a, b, c, d, e)
 -- PR -------------------------------------------------------------------------
 instance (PR a, PR b, PR c, PR d, PR e) => PR (a, b, c, d, e) where
 
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR (PTuple5 xs ys zs ds es)
         = validPR xs && validPR ys && validPR zs && validPR ds && validPR es
 
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR (PTuple5 arr1 arr2 arr3 arr4 arr5)
         = nfPR arr1 `seq` nfPR arr2 `seq` nfPR arr3 `seq` nfPR arr4 `seq` nfPR arr5 `seq` ()
 
 
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR (x1, y1, z1, d1, e1) (x2, y2, z2, d2, e2)
         =  similarPR x1 x2
         && similarPR y1 y2
@@ -45,7 +45,7 @@ instance (PR a, PR b, PR c, PR d, PR e) => PR (a, b, c, d, e) where
         && similarPR e1 e2
 
 
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR weak (PTuple5 arr1 arr2 arr3 arr4 arr5) ix
         =  coversPR weak arr1 ix
         && coversPR weak arr2 ix
@@ -140,7 +140,7 @@ instance (PR a, PR b, PR c, PR d, PR e) => PR (a, b, c, d, e) where
                   (indexsPR ds srcs ixs)
                   (indexsPR es srcs ixs)
 
-  {-# INLINE_PDATA extractPR #-}
+  {-# NOINLINE extractPR #-}
   extractPR (PTuple5 arr1 arr2 arr3 arr4 arr5) start len
         = PTuple5 (extractPR arr1 start len) 
                   (extractPR arr2 start len)
@@ -148,7 +148,7 @@ instance (PR a, PR b, PR c, PR d, PR e) => PR (a, b, c, d, e) where
                   (extractPR arr4 start len)
                   (extractPR arr5 start len)
 
-  {-# INLINE_PDATA extractsPR #-}
+  {-# NOINLINE extractsPR #-}
   extractsPR (PTuple5s xs ys zs ds es) ussegd
         = PTuple5 (extractsPR xs ussegd)
                   (extractsPR ys ussegd)
@@ -158,7 +158,7 @@ instance (PR a, PR b, PR c, PR d, PR e) => PR (a, b, c, d, e) where
 
 
   -- Pack and Combine ---------------------------
-  {-# INLINE_PDATA packByTagPR #-}
+  {-# NOINLINE packByTagPR #-}
   packByTagPR (PTuple5 arr1 arr2 arr3 arr4 arr5) tags tag
         = PTuple5 (packByTagPR arr1 tags tag)
                   (packByTagPR arr2 tags tag)
@@ -167,7 +167,7 @@ instance (PR a, PR b, PR c, PR d, PR e) => PR (a, b, c, d, e) where
                   (packByTagPR arr5 tags tag)
 
 
-  {-# INLINE_PDATA combine2PR #-}
+  {-# NOINLINE combine2PR #-}
   combine2PR sel (PTuple5 xs1 ys1 zs1 ds1 es1) (PTuple5 xs2 ys2 zs2 ds2 es2)
         = PTuple5 (combine2PR sel xs1 xs2)
                   (combine2PR sel ys1 ys2)
@@ -177,7 +177,7 @@ instance (PR a, PR b, PR c, PR d, PR e) => PR (a, b, c, d, e) where
 
 
   -- Conversions --------------------------------
-  {-# INLINE_PDATA fromVectorPR #-}
+  {-# NOINLINE fromVectorPR #-}
   fromVectorPR vec
    = let (xs, ys, zs, ds, es)       = V.unzip5 vec
      in  PTuple5  (fromVectorPR xs)
@@ -186,7 +186,7 @@ instance (PR a, PR b, PR c, PR d, PR e) => PR (a, b, c, d, e) where
                   (fromVectorPR ds)
                   (fromVectorPR es)
 
-  {-# INLINE_PDATA toVectorPR #-}
+  {-# NOINLINE toVectorPR #-}
   toVectorPR (PTuple5 xs ys zs ds es)
         = V.zip5  (toVectorPR xs)
                   (toVectorPR ys)
@@ -237,7 +237,7 @@ instance (PR a, PR b, PR c, PR d, PR e) => PR (a, b, c, d, e) where
                    (appenddPR es1 es2)
   
 
-  {-# INLINE_PDATA fromVectordPR #-}
+  {-# NOINLINE fromVectordPR #-}
   fromVectordPR vec
    = let (xss, yss, zss, dss, ess) = V.unzip5 $ V.map (\(PTuple5 xs ys zs ds es) -> (xs, ys, zs, ds, es)) vec
      in  PTuple5s  (fromVectordPR xss)
@@ -247,7 +247,7 @@ instance (PR a, PR b, PR c, PR d, PR e) => PR (a, b, c, d, e) where
                    (fromVectordPR ess)
 
 
-  {-# INLINE_PDATA toVectordPR #-}
+  {-# NOINLINE toVectordPR #-}
   toVectordPR (PTuple5s pdatas1 pdatas2 pdatas3 pdatas4 pdatas5)
         = V.zipWith5 PTuple5
                    (toVectordPR pdatas1)
index 3815964..357174a 100644 (file)
@@ -26,19 +26,19 @@ punit   = PUnit
 -- PR -------------------------------------------------------------------------
 instance PR () where
 
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR _
         = True
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR xx
         = xx `seq` ()
   
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR _ _
         = True
 
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR weak (PUnit n) i
    | weak       = i <= n
    | otherwise  = i <  n
@@ -108,11 +108,11 @@ instance PR () where
 
 
   -- Conversions --------------------------------
-  {-# INLINE_PDATA fromVectorPR #-}
+  {-# NOINLINE fromVectorPR #-}
   fromVectorPR vec
         = PUnit (V.length vec)
 
-  {-# INLINE_PDATA toVectorPR #-}
+  {-# NOINLINE toVectorPR #-}
   toVectorPR (PUnit len)
         = V.replicate len ()
 
@@ -137,11 +137,11 @@ instance PR () where
   appenddPR (PUnits lens1) (PUnits lens2)
         = PUnits $ lens1 U.+:+ lens2
 
-  {-# INLINE_PDATA fromVectordPR #-}
+  {-# NOINLINE fromVectordPR #-}
   fromVectordPR vec
         = PUnits $ V.convert $ V.map lengthPR vec
         
-  {-# INLINE_PDATA toVectordPR #-}
+  {-# NOINLINE toVectordPR #-}
   toVectordPR (PUnits uvecs)
         = V.map PUnit $ V.convert uvecs
 
index 30b4247..bcd1498 100644 (file)
@@ -44,16 +44,16 @@ nope str    = error $ "Data.Array.Parallel.PData.Void: no PR method for " ++ str
 
 instance PR Void where
 
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR _       = True
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR _          = ()
 
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR _ _   = True
   
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR _ _ _  = True
   
   {-# NOINLINE pprpPR #-}
@@ -109,10 +109,10 @@ instance PR Void where
 
 
   -- Conversions --------------------------------
-  {-# INLINE_PDATA fromVectorPR #-}
+  {-# NOINLINE fromVectorPR #-}
   fromVectorPR  = nope "fromVector"
 
-  {-# INLINE_PDATA toVectorPR #-}
+  {-# NOINLINE toVectorPR #-}
   toVectorPR _  = nope "toVector"
 
 
@@ -136,11 +136,11 @@ instance PR Void where
   appenddPR (PVoids n1) (PVoids n2)
         = PVoids (n1 + n2)
 
-  {-# INLINE_PDATA fromVectordPR #-}
+  {-# NOINLINE fromVectordPR #-}
   fromVectordPR vec
         = PVoids $ V.length vec
 
-  {-# INLINE_PDATA toVectordPR #-}
+  {-# NOINLINE toVectordPR #-}
   toVectordPR (PVoids n)
         = V.replicate n pvoid
 
index 17f4499..c68d0f7 100644 (file)
@@ -23,18 +23,18 @@ data instance PDatas Word8
 -- PR -------------------------------------------------------------------------
 instance PR Word8 where
 
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR _
         = True
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR (PWord8 xx)
         = xx `seq` ()
 
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR  = (==)
 
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR weak (PWord8 uarr) ix
    | weak       = ix <= U.length uarr
    | otherwise  = ix <  U.length uarr
@@ -85,11 +85,11 @@ instance PR Word8 where
    where get !src !ix
                 = (pvecs V.! src) VU.! ix
 
-  {-# INLINE_PDATA extractPR #-}
+  {-# NOINLINE extractPR #-}
   extractPR (PWord8 arr) start len 
         = PWord8 (U.extract arr start len)
 
-  {-# INLINE_PDATA extractsPR #-}
+  {-# NOINLINE extractsPR #-}
   extractsPR (PWord8s vecpdatas) ussegd
    = let segsrcs        = U.sourcesSSegd ussegd
          segstarts      = U.startsSSegd  ussegd
@@ -98,11 +98,11 @@ instance PR Word8 where
 
 
   -- Pack and Combine ---------------------------
-  {-# INLINE_PDATA packByTagPR #-}
+  {-# NOINLINE packByTagPR #-}
   packByTagPR (PWord8 arr1) arrTags tag
         = PWord8 $ U.packByTag arr1 arrTags tag
 
-  {-# INLINE_PDATA combine2PR #-}
+  {-# NOINLINE combine2PR #-}
   combine2PR sel (PWord8 arr1) (PWord8 arr2)
         = PWord8 $ U.combine2 (U.tagsSel2 sel)
                            (U.repSel2  sel)
@@ -110,11 +110,11 @@ instance PR Word8 where
 
 
   -- Conversions --------------------------------
-  {-# INLINE_PDATA fromVectorPR #-}
+  {-# NOINLINE fromVectorPR #-}
   fromVectorPR xx
         = PWord8 $U.fromList $ V.toList xx
 
-  {-# INLINE_PDATA toVectorPR #-}
+  {-# NOINLINE toVectorPR #-}
   toVectorPR (PWord8 arr)
         = V.fromList $ U.toList arr
 
@@ -140,11 +140,11 @@ instance PR Word8 where
   appenddPR (PWord8s xs) (PWord8s ys)
         = PWord8s $ xs V.++ ys
                                 
-  {-# INLINE_PDATA fromVectordPR #-}
+  {-# NOINLINE fromVectordPR #-}
   fromVectordPR vec
         = PWord8s $ V.map (\(PWord8 xs) -> xs) vec
         
-  {-# INLINE_PDATA toVectordPR #-}
+  {-# NOINLINE toVectordPR #-}
   toVectordPR (PWord8s vec)
         = V.map PWord8 vec
 
index ca6aa94..490bd05 100644 (file)
@@ -19,19 +19,19 @@ newtype instance PDatas (Wrap a)
 -- PR -------------------------------------------------------------------------
 instance PA a => PR (Wrap a) where       
 
-  {-# INLINE_PDATA validPR #-}
+  {-# NOINLINE validPR #-}
   validPR (PWrap pdata)  
         = validPA pdata
 
-  {-# INLINE_PDATA nfPR #-}
+  {-# NOINLINE nfPR #-}
   nfPR (PWrap pdata)      
         = nfPA pdata
 
-  {-# INLINE_PDATA similarPR #-}
+  {-# NOINLINE similarPR #-}
   similarPR (Wrap x) (Wrap y)
         = similarPA x y
 
-  {-# INLINE_PDATA coversPR #-}
+  {-# NOINLINE coversPR #-}
   coversPR weak (PWrap pdata) ix
         = coversPA weak pdata ix
 
@@ -79,31 +79,31 @@ instance PA a => PR (Wrap a) where
   indexsPR (PWraps pdatas) srcs ixs
         = PWrap $ indexsPA pdatas srcs ixs
 
-  {-# INLINE_PDATA extractPR #-}
+  {-# NOINLINE extractPR #-}
   extractPR (PWrap xs) ix n
         = PWrap $ extractPA xs ix n
         
-  {-# INLINE_PDATA extractsPR #-}
+  {-# NOINLINE extractsPR #-}
   extractsPR (PWraps pdatas) ssegd
         = PWrap $ extractsPA pdatas ssegd
 
 
   -- Pack and Combine ---------------------------
-  {-# INLINE_PDATA packByTagPR #-}
+  {-# NOINLINE packByTagPR #-}
   packByTagPR (PWrap xs) tags tag
         = PWrap $ packByTagPA xs tags tag
 
-  {-# INLINE_PDATA combine2PR #-}
+  {-# NOINLINE combine2PR #-}
   combine2PR sel (PWrap xs) (PWrap ys)
         = PWrap $ combine2PA sel xs ys
 
 
   -- Conversions --------------------------------
-  {-# INLINE_PDATA fromVectorPR #-}
+  {-# NOINLINE fromVectorPR #-}
   fromVectorPR vec 
         = PWrap $ fromVectorPA $ V.map unWrap vec
         
-  {-# INLINE_PDATA toVectorPR #-}
+  {-# NOINLINE toVectorPR #-}
   toVectorPR (PWrap pdata)
         = V.map Wrap $ toVectorPA pdata
 
@@ -129,11 +129,11 @@ instance PA a => PR (Wrap a) where
   appenddPR (PWraps xs) (PWraps ys)
         = PWraps $ appenddPA xs ys
 
-  {-# INLINE_PDATA fromVectordPR #-}
+  {-# NOINLINE fromVectordPR #-}
   fromVectordPR vec
         = PWraps $ fromVectordPA $ V.map (\(PWrap x) -> x) vec
 
-  {-# INLINE_PDATA toVectordPR #-}
+  {-# NOINLINE toVectordPR #-}
   toVectordPR (PWraps pdatas)
         = V.map PWrap $ toVectordPA pdatas
         
index 17bf65c..fc4abcd 100644 (file)
@@ -350,8 +350,8 @@ updateVSegs fUpdate (UPVSegd _ vsegids _ upssegd _)
    in   UPVSegd False
                 vsegids_redundant vsegids_culled
                 upssegd           upssegd_culled
-{-# INLINE_UP updateVSegs #-}
---  INLINE_UP because we want to inline the parameter function fUpdate.
+{-# NOINLINE updateVSegs #-}
+--  NOINLINE because we want to see this happening in core.
 
 
 -- | Update the virtual segment ids of `UPVSegd`, where the result covers
@@ -370,8 +370,8 @@ updateVSegsReachable :: (Vector Int -> Vector Int) -> UPVSegd -> UPVSegd
 updateVSegsReachable fUpdate (UPVSegd _ _ vsegids _ upssegd)
  = let  vsegids' = fUpdate vsegids
    in   UPVSegd False vsegids' vsegids' upssegd upssegd
-{-# INLINE_UP updateVSegsReachable #-}
---  INLINE_UP because we want to inline the parameter function fUpdate.
+{-# NOINLINE updateVSegsReachable #-}
+--  NOINLINE because we want to see this happening in core.
 
 
 -- Append ---------------------------------------------------------------------
@@ -405,6 +405,8 @@ appendWith
                                  
    in   UPVSegd False vsegids' vsegids' upssegd' upssegd'
 {-# NOINLINE appendWith #-}
+--  NOINLINE because it doesn't need to be specialised
+--           and we're worried about code explosion.
 
 
 -- Combine --------------------------------------------------------------------
@@ -441,4 +443,5 @@ combine2
                                   
    in   UPVSegd False vsegids' vsegids' upssegd' upssegd'
 {-# NOINLINE combine2 #-}
-
+--  NOINLINE because it doesn't need to be specialised
+--           and we're worried about code explosion.
index 25f001c..1c04c76 100644 (file)
@@ -220,8 +220,8 @@ append (USSegd _ starts1 srcs1 usegd1) pdatas1
                  (starts1  U.++  starts2)
                  (srcs1    U.++  U.map (+ pdatas1) srcs2)
                  (USegd.append usegd1 usegd2)
-
-{-# INLINE_U append #-}
+{-# NOINLINE append #-}
+--  NOINLINE because we're worried about code explosion. Might be useful though.
 
 
 -- | Cull the segments in a SSegd down to only those reachable from an array