Be consistent about what INLINE pragmas are used in each module
authorBen Lippmeier <benl@ouroborus.net>
Fri, 7 Oct 2011 01:00:47 +0000 (12:00 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Tue, 11 Oct 2011 04:11:42 +0000 (15:11 +1100)
28 files changed:
dph-common-vseg/Data/Array/Parallel/Lifted/Closure.hs
dph-common-vseg/Data/Array/Parallel/Lifted/Combinators.hs
dph-common-vseg/Data/Array/Parallel/PArray.hs
dph-common-vseg/Data/Array/Parallel/PArray/PData/Base.hs
dph-common-vseg/Data/Array/Parallel/PArray/PData/Closure.hs
dph-common-vseg/Data/Array/Parallel/PArray/PData/Double.hs
dph-common-vseg/Data/Array/Parallel/PArray/PData/Int.hs
dph-common-vseg/Data/Array/Parallel/PArray/PData/Nested.hs
dph-common-vseg/Data/Array/Parallel/PArray/PData/Tuple.hs
dph-common-vseg/Data/Array/Parallel/PArray/PData/Unit.hs
dph-common-vseg/examples/smvm/SMVMVectorised.hs
dph-common-vseg/include/fusion-phases-vseg.h [deleted file]
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Basics.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Combinators.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Enum.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Permute.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Segmented.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Subarrays.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Sums.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPSSegd.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPSegd.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPSel.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPVSegd.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Sums.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/USSegd.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/USegd.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/USel.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/UVSegd.hs

index a7342f3..6358094 100644 (file)
@@ -4,7 +4,7 @@
         TypeFamilies, Rank2Types, MultiParamTypeClasses, 
         StandaloneDeriving, FlexibleContexts #-}
 
-#include "fusion-phases-vseg.h"
+#include "fusion-phases.h"
 
 module Data.Array.Parallel.Lifted.Closure (
   -- * Closures.
index e5f9412..6ca3a63 100644 (file)
@@ -4,7 +4,7 @@
         FlexibleInstances, FlexibleContexts,
         RankNTypes, ExistentialQuantification,
         StandaloneDeriving, TypeOperators #-}
-#include "fusion-phases-vseg.h"
+#include "fusion-phases.h"
 
 -- | Define closures for each of the combinators the vectoriser uses.
 module Data.Array.Parallel.Lifted.Combinators 
index a18a5cd..8702324 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE CPP #-}
-#include "fusion-phases-vseg.h"
+#include "fusion-phases.h"
 
 -- | Functions that work directly on PArrays.
 
index c07db58..c83e341 100644 (file)
@@ -6,7 +6,7 @@
         UndecidableInstances #-}
         -- Undeciable instances only need for derived Show instance
 
-#include "fusion-phases-vseg.h"
+#include "fusion-phases.h"
 
 module Data.Array.Parallel.PArray.PData.Base 
         ( -- * Parallel Array types.
index f921089..324b8b6 100644 (file)
@@ -3,7 +3,7 @@
         TypeOperators,
         FlexibleInstances,
         MultiParamTypeClasses #-}
-#include "fusion-phases-vseg.h"
+#include "fusion-phases.h"
 
 module Data.Array.Parallel.PArray.PData.Closure where
 import Data.Array.Parallel.PArray.PData.Base
index 68104e1..1b89057 100644 (file)
@@ -6,7 +6,7 @@
         StandaloneDeriving,
         ExistentialQuantification #-}
 
-#include "fusion-phases-vseg.h"
+#include "fusion-phases.h"
 
 module Data.Array.Parallel.PArray.PData.Double where
 import Data.Array.Parallel.PArray.PData.Base
index db041c0..6950069 100644 (file)
@@ -6,7 +6,7 @@
         StandaloneDeriving,
         ExistentialQuantification #-}
 
-#include "fusion-phases-vseg.h"
+#include "fusion-phases.h"
 
 module Data.Array.Parallel.PArray.PData.Int where
 import Data.Array.Parallel.PArray.PData.Base
index 4d803f4..42f05dd 100644 (file)
@@ -8,7 +8,7 @@
         UndecidableInstances,
         ParallelListComp #-}
 
-#include "fusion-phases-vseg.h"
+#include "fusion-phases.h"
 
 module Data.Array.Parallel.PArray.PData.Nested 
         ( PData(..)
@@ -482,6 +482,7 @@ instance PR a => PR (PArray a) where
 --         the flat arrays and not copy each segment individually.
 -- 
 concatPR :: PR a => PData (PArray a) -> PData a
+{-# INLINE_PDATA concatPR #-}
 concatPR (PNested uvsegd psegdata)
  = let  -- Flatten out the virtualization of the uvsegd so that we have
         -- a description of each segment individually.
@@ -498,6 +499,7 @@ concatPR (PNested uvsegd psegdata)
 
 --   TODO: cleanup pnested projections
 unconcatPR :: PR a => PData (PArray a) -> PData b -> PData (PArray b)
+{-# INLINE_PDATA unconcatPR #-}
 unconcatPR arr1 arr
  = let  segs            = U.length vsegids
         vsegids        = pnested_vsegids     arr1
@@ -515,6 +517,7 @@ unconcatPR arr1 arr
 -- | Lifted concat.
 --   Both arrays must contain the same number of elements.
 concatlPR :: PR a => PData (PArray (PArray a)) -> PData (PArray a)
+{-# INLINE_PDATA concatlPR #-}
 concatlPR arr
  = let  (segd1, darr1)  = unsafeFlattenPR arr
         (segd2, darr2)  = unsafeFlattenPR darr1
@@ -530,6 +533,7 @@ concatlPR arr
 -- | Lifted append.
 --   Both arrays must contain the same number of elements.
 appendlPR :: PR a => PData (PArray a) -> PData (PArray a) -> PData (PArray a)
+{-# INLINE_PDATA appendlPR #-}
 appendlPR  arr1 arr2
  = let  (segd1, darr1)  = unsafeFlattenPR arr1
         (segd2, darr2)  = unsafeFlattenPR arr2
@@ -549,7 +553,7 @@ slicelPR
         -> PData Int            -- ^ lengths of slices
         -> PData (PArray a)     -- ^ arrays to slice
         -> PData (PArray a)
-
+{-# INLINE_PDATA slicelPR #-}
 slicelPR (PInt sliceStarts) (PInt sliceLens) arr
 
  = let  segs            = U.length vsegids
index 31e7825..d3f2d1a 100644 (file)
@@ -4,7 +4,7 @@
         FlexibleInstances, FlexibleContexts,
         StandaloneDeriving, ExplicitForAll,
         MultiParamTypeClasses #-}
-#include "fusion-phases-vseg.h"
+#include "fusion-phases.h"
 
 module Data.Array.Parallel.PArray.PData.Tuple 
 where
index c8ab916..db297fa 100644 (file)
@@ -3,7 +3,7 @@
         TypeFamilies, MultiParamTypeClasses,
         FlexibleInstances,
         StandaloneDeriving #-}
-#include "fusion-phases-vseg.h"
+#include "fusion-phases.h"
 
 module Data.Array.Parallel.PArray.PData.Unit where
 import Data.Array.Parallel.PArray.PData.Base
index d490308..60ca0a6 100644 (file)
@@ -3,7 +3,7 @@
         NoMonomorphismRestriction,
         TypeOperators, RankNTypes,
         FlexibleContexts #-}
-#include "fusion-phases-vseg.h"
+#include "fusion-phases.h"
 
 module SMVMVectorised (smvmPA) 
 where
diff --git a/dph-common-vseg/include/fusion-phases-vseg.h b/dph-common-vseg/include/fusion-phases-vseg.h
deleted file mode 100644 (file)
index bdcb7a1..0000000
+++ /dev/null
@@ -1,5 +0,0 @@
-#define INLINE_PDATA   INLINE
-#define INLINE_PA      INLINE
-#define INLINE_CLOSURE INLINE
-#define INLINE_USER    INLINE
-
index 2032830..7b30312 100644 (file)
@@ -19,14 +19,17 @@ import GHC.Base ( remInt )
 
 -- | Test whether the given array is empty
 nullUP :: Unbox e => Vector e -> Bool
+{-# INLINE_UP nullUP #-}
 nullUP  = (== 0) . Seq.length
 
 
 -- | Yield an empty array
 emptyUP :: Unbox e => Vector e
+{-# INLINE_UP emptyUP #-}
 emptyUP = Seq.new 0 (const $ return ())
 
 lengthUP :: Unbox e => Vector e -> Int
+{-# INLINE_UP lengthUP #-}
 lengthUP = Seq.length
 
 
@@ -63,7 +66,7 @@ interleaveUP xs ys
 
 -- | Associate each element of the array with its index
 indexedUP :: (DT e, Unbox e) => Vector e -> Vector (Int,e)
-{-# INLINE_U indexedUP #-}
+{-# INLINE_UP indexedUP #-}
 indexedUP 
  = splitJoinD theGang indexedFn 
  where
@@ -71,4 +74,3 @@ indexedUP
     indexedFn    = \arr -> zipWithD theGang (\o -> Seq.map (\(x,y) -> (x + o, y))) (sizes arr) 
                         $  mapD theGang Seq.indexed arr
 
-
index 5319b18..0550b63 100644 (file)
@@ -15,14 +15,14 @@ import Data.Array.Parallel.Unlifted.Parallel.UPSel
 
 -- | Apply a worker to all elements of a vector.
 mapUP :: (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
-{-# INLINE mapUP #-}
+{-# INLINE_UP mapUP #-}
 mapUP f xs 
         = splitJoinD theGang (mapD theGang (Seq.map f)) xs
 
 
 -- | Keep elements that match the given predicate.
 filterUP :: Unbox a => (a -> Bool) -> Vector a -> Vector a
-{-# INLINE filterUP #-}
+{-# INLINE_UP filterUP #-}
 filterUP f
         = joinD  theGang unbalanced
         . mapD   theGang (Seq.filter f)
@@ -76,7 +76,7 @@ combine2UP tags rep !xs !ys
 -- | Combine two vectors into a third.
 zipWithUP :: (Unbox a, Unbox b, Unbox c) 
           => (a -> b -> c) -> Vector a -> Vector b -> Vector c
-{-# INLINE zipWithUP #-}
+{-# INLINE_UP zipWithUP #-}
 zipWithUP f xs ys
         = splitJoinD theGang 
                 (mapD theGang (Seq.map (uncurry f))) 
@@ -96,7 +96,7 @@ zipWithUP f xs ys
 --   then we fold together all the results in the main thread.
 --
 foldUP  :: (Unbox a, DT a) => (a -> a -> a) -> a -> Vector a -> a
-{-# INLINE foldUP #-}
+{-# INLINE_UP foldUP #-}
 foldUP f !z xs
         = foldD theGang f
                 (mapD   theGang (Seq.fold f z)
@@ -119,7 +119,7 @@ foldlUP f z arr
 
 -- | Alias for `foldl1UP`
 fold1UP :: (DT a, Unbox a) => (a -> a -> a) -> Vector a -> a
-{-# INLINE fold1UP #-}
+{-# INLINE_UP fold1UP #-}
 fold1UP = foldl1UP
 
 
@@ -134,7 +134,7 @@ fold1UP = foldl1UP
 --   TODO: The two type class constraints are in a different order. Does that matter?
 --
 foldl1UP :: (DT a, Unbox a) => (a -> a -> a) -> Vector a -> a
-{-# INLINE_U foldl1UP #-}
+{-# INLINE_UP foldl1UP #-}
 foldl1UP f arr 
         = (maybe z (f z)
         . foldD  theGang combine
index eeced64..03b3bc2 100644 (file)
@@ -18,7 +18,7 @@ delay_inline x = x
 
 
 enumFromToUP :: (Unbox a, Enum a) => a -> a -> Vector a
-{-# INLINE enumFromToUP #-}
+{-# INLINE_UP enumFromToUP #-}
 enumFromToUP start end 
  = mapUP toEnum (enumFromStepLenUP start' 1 len)
  where  start' = fromEnum start
@@ -27,7 +27,7 @@ enumFromToUP start end
 
 
 enumFromThenToUP :: (Unbox a, Enum a) => a -> a -> a -> Vector a
-{-# INLINE enumFromThenToUP #-}
+{-# INLINE_UP enumFromThenToUP #-}
 enumFromThenToUP start next end 
  = mapUP toEnum (enumFromStepLenUP start' delta len)
  where  start' = fromEnum start
@@ -41,7 +41,7 @@ enumFromThenToUP start next end
 
 
 enumFromStepLenUP :: Int -> Int -> Int -> Vector Int
-{-# INLINE enumFromStepLenUP #-}
+{-# INLINE_UP enumFromStepLenUP #-}
 enumFromStepLenUP start delta len =
   joinD theGang balanced
   (mapD theGang gen
@@ -51,7 +51,7 @@ enumFromStepLenUP start delta len =
 
 
 enumFromStepLenEachUP :: Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int
-{-# INLINE enumFromStepLenEachUP #-}
+{-# INLINE_UP enumFromStepLenEachUP #-}
 enumFromStepLenEachUP n starts steps lens
   = joinD theGang unbalanced
   $ mapD theGang enum
index dac0537..d7a23d8 100644 (file)
@@ -1,4 +1,5 @@
-{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE CPP, ScopedTypeVariables #-}
+#include "fusion-phases.h"
 
 -- | Parallel permutations for unlifted arrays
 module Data.Array.Parallel.Unlifted.Parallel.Permute (
@@ -9,7 +10,7 @@ import Data.Array.Parallel.Unlifted.Distributed
 
 
 bpermuteUP :: Unbox a => Vector a -> Vector Int -> Vector a
-{-# INLINE bpermuteUP #-}
+{-# INLINE_UP bpermuteUP #-}
 bpermuteUP as is = splitJoinD theGang (bpermuteD theGang as) is
 
 {-
@@ -30,7 +31,7 @@ bpermuteUP as is = splitJoinD theGang (bpermuteD theGang as) is
 -}
 
 updateUP :: forall a. Unbox a => Vector a -> Vector (Int,a) -> Vector a
-{-# INLINE updateUP #-}
+{-# INLINE_UP updateUP #-}
 updateUP as us
   {- hasAtomicWriteMU (undefined :: a) 
   = atomicUpdateD theGang (splitD theGang unbalanced as)
index 5edc569..20e2dac 100644 (file)
@@ -118,7 +118,7 @@ appendSegS !xd !xs !yd !ys !n seg_off el_off
 
 -- foldR ----------------------------------------------------------------------
 foldRUP :: (Unbox a, Unbox b) => (b -> a -> b) -> b -> Int -> Vector a -> Vector b
-{-# INLINE foldRUP #-}
+{-# INLINE_UP foldRUP #-}
 foldRUP f z !segSize xs = 
    joinD theGang unbalanced
     (mapD theGang 
@@ -131,7 +131,7 @@ foldRUP f z !segSize xs =
 
 -- sumR -----------------------------------------------------------------------
 sumRUP :: (Num e, Unbox e) => Int -> Vector e -> Vector e
-{-# INLINE sumRUP #-}
+{-# INLINE_UP sumRUP #-}
 sumRUP = foldRUP (+) 0
 
 
index cc4c069..757f62c 100644 (file)
@@ -11,7 +11,7 @@ import Data.Array.Parallel.Unlifted.Sequential.Vector as Seq
 
 -- | Drop a the element at the provided index from a vector.
 dropUP :: Unbox e => Int -> Vector e -> Vector e
-{-# INLINE_U dropUP #-}
+{-# INLINE_UP dropUP #-}
 dropUP n xs 
         = Seq.slice xs  (min (max 0 n)       (Seq.length xs))
                         (min (Seq.length xs) (Seq.length xs - n)) 
index 537eff7..1769f02 100644 (file)
@@ -1,3 +1,6 @@
+{-# LANGUAGE CPP #-}
+#include "fusion-phases.h"
+
 -- | Sum-like parallel combinators for unlifted arrays
 module Data.Array.Parallel.Unlifted.Parallel.Sums (
   andUP, orUP, allUP, anyUP, sumUP, productUP,
@@ -12,49 +15,49 @@ import Data.Array.Parallel.Unlifted.Parallel.Basics (
 
 -- | Compute the logical AND of all the elements in a array.
 andUP :: Vector Bool -> Bool
-{-# INLINE andUP #-}
+{-# INLINE_UP andUP #-}
 andUP = foldUP (&&) True
 
 
 -- | Compute the logical OR of all the elements in a array.
 orUP :: Vector Bool -> Bool
-{-# INLINE orUP #-}
+{-# INLINE_UP orUP #-}
 orUP = foldUP (||) False
 
 
 -- | Check whether all the elements in a array meet the given predicate.
 allUP :: Unbox e => (e -> Bool) -> Vector e -> Bool
-{-# INLINE allUP #-}
+{-# INLINE_UP allUP #-}
 allUP p = andUP . mapUP p
 
 
 -- | Check whether any of the elements in a array meet the given predicate.
 anyUP :: Unbox e => (e -> Bool) -> Vector e -> Bool
-{-# INLINE anyUP #-}
+{-# INLINE_UP anyUP #-}
 anyUP p =  orUP . mapUP p
 
 
 -- | Compute the sum all the elements of a array.
 sumUP :: (Unbox a, DT a, Num a) => Vector a -> a
-{-# INLINE sumUP #-}
+{-# INLINE_UP sumUP #-}
 sumUP = foldUP (+) 0
 
 
 -- | Compute the product of all the elements of an array.
 productUP :: (DT e, Num e, Unbox e) => Vector e -> e
-{-# INLINE productUP #-}
+{-# INLINE_UP productUP #-}
 productUP = foldUP (*) 1
 
 
 -- | Determine the maximum element in an array.
 maximumUP :: (DT e, Ord e, Unbox e) => Vector e -> e
-{-# INLINE maximumUP #-}
+{-# INLINE_UP maximumUP #-}
 maximumUP = fold1UP max
 
 
 -- | Determine the maximum element in an array under the given ordering
 maximumByUP :: (DT e, Unbox e) => (e -> e -> Ordering) -> Vector e -> e
-{-# INLINE maximumByUP #-}
+{-# INLINE_UP maximumByUP #-}
 maximumByUP = fold1UP . maxBy
   where
     maxBy compare x y = case x `compare` y of
@@ -63,7 +66,7 @@ maximumByUP = fold1UP . maxBy
 
 -- | Determine the index of the maximum element in an array under the given ordering
 maximumIndexByUP :: (DT e, Unbox e) => (e -> e -> Ordering) -> Vector e -> Int
-{-# INLINE maximumIndexByUP #-}
+{-# INLINE_UP maximumIndexByUP #-}
 maximumIndexByUP cmp = fst . maximumByUP cmp' . indexedUP
   where
     cmp' (_,x) (_,y) = cmp x y
index c909014..ab8826f 100644 (file)
@@ -79,7 +79,7 @@ instance PprPhysical UPSSegd where
 -- 
 --   * TODO: this doesn't do any checks yet
 valid :: UPSSegd -> Bool
-{-# INLINE valid #-}
+{-# INLINE_UP valid #-}
 valid _ = True
 
 
@@ -91,7 +91,7 @@ mkUPSSegd
         -> UPSegd       -- ^ Contiguous (unscattered) segment descriptor.
         -> UPSSegd
 
-{-# INLINE mkUPSSegd #-}
+{-# INLINE_UP mkUPSSegd #-}
 mkUPSSegd starts sources upsegd
         = fromUSSegd (USSegd.mkUSSegd starts sources (UPSegd.takeUSegd upsegd))
 
@@ -99,7 +99,7 @@ mkUPSSegd starts sources upsegd
 -- | Promote a global `USSegd` to a parallel `UPSSegd` by distributing
 --   it across the gang.
 fromUSSegd :: USSegd -> UPSSegd
-{-# INLINE fromUSSegd #-}
+{-# INLINE_UP fromUSSegd #-}
 fromUSSegd ssegd 
         = UPSSegd ssegd (DUSSegd.splitSSegdOnElemsD theGang ssegd)
 
@@ -113,14 +113,14 @@ fromUSSegd ssegd
 --     some of the existing fields and save reconstructing them.
 --
 fromUPSegd :: UPSegd -> UPSSegd
-{-# INLINE fromUPSegd #-}
+{-# INLINE_UP fromUPSegd #-}
 fromUPSegd upsegd
         = fromUSSegd $ USSegd.fromUSegd $ UPSegd.takeUSegd upsegd
 
 
 -- | O(1). Yield an empty segment descriptor, with no elements or segments.
 empty :: UPSSegd
-{-# INLINE empty #-}
+{-# INLINE_UP empty #-}
 empty   = fromUSSegd USSegd.empty
 
 
@@ -128,38 +128,38 @@ empty   = fromUSSegd USSegd.empty
 --   Yield a singleton segment descriptor.
 --   The single segment covers the given number of elements.
 singleton :: Int -> UPSSegd
-{-# INLINE singleton #-}
+{-# INLINE_UP singleton #-}
 singleton n = fromUSSegd $ USSegd.singleton n
 
 
 -- Projections ----------------------------------------------------------------
 -- | O(1). Yield the overall number of segments.
 length :: UPSSegd -> Int
-{-# INLINE length #-}
+{-# INLINE_UP length #-}
 length          = USSegd.length . upssegd_ussegd
 
 
 -- | O(1). Yield the global `USegd` of a `UPSegd`
 takeUSSegd :: UPSSegd -> USSegd
-{-# INLINE takeUSSegd #-}
+{-# INLINE_UP takeUSSegd #-}
 takeUSSegd      = upssegd_ussegd
 
 
 -- | O(1). Yield the distributed `USegd` of a `UPSegd`
 takeDistributed :: UPSSegd -> Dist ((USSegd, Int), Int)
-{-# INLINE takeDistributed #-}
+{-# INLINE_UP takeDistributed #-}
 takeDistributed = upssegd_dssegd
 
 
 -- | O(1). Yield the lengths of the individual segments.
 takeLengths :: UPSSegd -> Vector Int
-{-# INLINE takeLengths #-}
+{-# INLINE_UP takeLengths #-}
 takeLengths     = USSegd.takeLengths . upssegd_ussegd
 
 
 -- | O(1). Yield the segment indices.
 takeIndices :: UPSSegd -> Vector Int
-{-# INLINE takeIndices #-}
+{-# INLINE_UP takeIndices #-}
 takeIndices     = USSegd.takeIndices . upssegd_ussegd
 
 
@@ -168,26 +168,26 @@ takeIndices     = USSegd.takeIndices . upssegd_ussegd
 --  @takeElements upssegd = sum (takeLengths upssegd)@
 --
 takeElements :: UPSSegd -> Int
-{-# INLINE takeElements #-}
+{-# INLINE_UP takeElements #-}
 takeElements    = USSegd.takeElements . upssegd_ussegd
 
 
 -- | O(1). Yield the starting indices.
 takeStarts :: UPSSegd -> Vector Int
-{-# INLINE takeStarts #-}
+{-# INLINE_UP takeStarts #-}
 takeStarts      = USSegd.takeStarts . upssegd_ussegd
 
 
 -- | O(1). Yield the source ids.
 takeSources :: UPSSegd -> Vector Int
-{-# INLINE takeSources #-}
+{-# INLINE_UP takeSources #-}
 takeSources     = USSegd.takeSources . upssegd_ussegd 
 
 
 -- | O(1).
 --   Get the length, segment index, starting index, and source id of a segment.
 getSeg :: UPSSegd -> Int -> (Int, Int, Int, Int)
-{-# INLINE getSeg #-}
+{-# INLINE_UP getSeg #-}
 getSeg upssegd ix
         = USSegd.getSeg (upssegd_ussegd upssegd) ix
 
@@ -210,7 +210,7 @@ appendWith
         -> UPSSegd              -- ^ Segment descriptor of second nested array. 
         -> Int                  -- ^ Number of flat data arrays used to represent second nested array.
         -> UPSSegd
-{-# INLINE appendWith #-}
+{-# INLINE_UP appendWith #-}
 appendWith upssegd1 pdatas1
            upssegd2 pdatas2
  = fromUSSegd 
@@ -222,7 +222,7 @@ appendWith upssegd1 pdatas1
 -- | Fold segments specified by a `UPSSegd`.
 foldWithP :: Unbox a
          => (a -> a -> a) -> a -> UPSSegd -> V.Vector (Vector a) -> Vector a
-{-# INLINE foldWithP #-}
+{-# INLINE_UP foldWithP #-}
 foldWithP f !z
         = foldSegsWithP f (Seq.foldlSSU f z)
 
@@ -230,7 +230,7 @@ foldWithP f !z
 -- | Fold segments specified by a `UPSSegd`, with a non-empty vector.
 fold1WithP :: Unbox a
          => (a -> a -> a) -> UPSSegd -> V.Vector (Vector a) -> Vector a
-{-# INLINE fold1WithP #-}
+{-# INLINE_UP fold1WithP #-}
 fold1WithP f
         = foldSegsWithP f (Seq.fold1SSU f)
 
@@ -238,7 +238,7 @@ fold1WithP f
 -- | Sum up segments specified by a `UPSSegd`.
 sumWithP :: (Num a, Unbox a)
         => UPSSegd -> V.Vector (Vector a) -> Vector a
-{-# INLINE sumWithP #-}
+{-# INLINE_UP sumWithP #-}
 sumWithP = foldWithP (+) 0
 
 
@@ -255,7 +255,7 @@ foldSegsWithP
         -> (USSegd -> V.Vector (Vector a) -> Vector a)
         -> UPSSegd -> V.Vector (Vector a) -> Vector a
 
-{-# INLINE foldSegsWithP #-}
+{-# INLINE_UP foldSegsWithP #-}
 foldSegsWithP fElem fSeg segd xss 
  = dcarry `seq` drs `seq` 
    runST (do
index bbaca1f..c712d0c 100644 (file)
@@ -65,7 +65,7 @@ data UPSegd
 -- 
 --   * TODO: this doesn't do any checks yet
 valid :: UPSegd -> Bool
-{-# INLINE valid #-}
+{-# INLINE_UP valid #-}
 valid _ = True
 
 
@@ -77,7 +77,7 @@ mkUPSegd
         -> Int          -- ^ Total number of elements in the flat array.
         -> UPSegd
 
-{-# INLINE mkUPSegd #-}
+{-# INLINE_UP mkUPSegd #-}
 mkUPSegd lens idxs n
         = fromUSegd (USegd.mkUSegd lens idxs n)
 
@@ -85,13 +85,13 @@ mkUPSegd lens idxs n
 -- | Convert a global `USegd` to a parallel `UPSegd` by distributing 
 --   it across the gang.
 fromUSegd :: USegd -> UPSegd
-{-# INLINE fromUSegd #-}
+{-# INLINE_UP fromUSegd #-}
 fromUSegd segd   = UPSegd segd (USegd.splitSegdOnElemsD theGang segd)
 
 
 -- | O(1). Yield an empty segment descriptor, with no elements or segments.
 empty :: UPSegd
-{-# INLINE empty #-}
+{-# INLINE_UP empty #-}
 empty           = fromUSegd USegd.empty
 
 
@@ -99,7 +99,7 @@ empty           = fromUSegd USegd.empty
 --   Yield a singleton segment descriptor.
 --   The single segment covers the given number of elements.
 singleton :: Int -> UPSegd
-{-# INLINE singleton #-}
+{-# INLINE_UP singleton #-}
 singleton n     = fromUSegd $ USegd.singleton n
 
 
@@ -109,20 +109,20 @@ singleton n     = fromUSegd $ USegd.singleton n
 --   indices from that. Runtime is O(n) in the number of segments.
 --
 fromLengths :: Vector Int -> UPSegd
-{-# INLINE fromLengths #-}
+{-# INLINE_UP fromLengths #-}
 fromLengths     = fromUSegd . USegd.fromLengths
 
 
 -- Projections ----------------------------------------------------------------
 -- | O(1). Yield the overall number of segments.
 length :: UPSegd -> Int
-{-# INLINE length #-}
+{-# INLINE_UP length #-}
 length          = USegd.length . upsegd_usegd
 
 
 -- | O(1). Yield the global `USegd` of a `UPSegd`.
 takeUSegd :: UPSegd -> USegd
-{-# INLINE takeUSegd #-}
+{-# INLINE_UP takeUSegd #-}
 takeUSegd       = upsegd_usegd
 
 
@@ -132,19 +132,19 @@ takeUSegd       = upsegd_usegd
 --  slice in the chunk, and the starting offset of that slice in its segment.
 -- 
 takeDistributed :: UPSegd -> Dist ((USegd,Int),Int)
-{-# INLINE takeDistributed #-}
+{-# INLINE_UP takeDistributed #-}
 takeDistributed = upsegd_dsegd
 
 
 -- | O(1). Yield the lengths of the individual segments.
 takeLengths :: UPSegd -> Vector Int
-{-# INLINE takeLengths #-}
+{-# INLINE_UP takeLengths #-}
 takeLengths     = USegd.takeLengths . upsegd_usegd
 
 
 -- | O(1). Yield the segment indices.
 takeIndices :: UPSegd -> Vector Int
-{-# INLINE takeIndices #-}
+{-# INLINE_UP takeIndices #-}
 takeIndices     = USegd.takeIndices . upsegd_usegd
 
 
@@ -153,12 +153,10 @@ takeIndices     = USegd.takeIndices . upsegd_usegd
 --  @takeElements upsegd = sum (takeLengths upsegd)@
 --
 takeElements :: UPSegd -> Int
-{-# INLINE takeElements #-}
+{-# INLINE_UP takeElements #-}
 takeElements    = USegd.takeElements . upsegd_usegd
 
 
-
-
 -- Indices --------------------------------------------------------------------
 -- | O(n). Yield a vector containing indicies that give the position of each 
 --         member of the flat array in its corresponding segment.
@@ -196,7 +194,7 @@ replicateWithP segd !xs
 -- | Fold segments specified by a `UPSegd`.
 foldWithP :: Unbox a
          => (a -> a -> a) -> a -> UPSegd -> Vector a -> Vector a
-{-# INLINE foldWithP #-}
+{-# INLINE_UP foldWithP #-}
 foldWithP f !z
         = foldSegsWithP f (Seq.foldlSU f z)
 
@@ -204,14 +202,14 @@ foldWithP f !z
 -- | Fold segments specified by a `UPSegd`, with a non-empty vector.
 fold1WithP :: Unbox a
          => (a -> a -> a) -> UPSegd -> Vector a -> Vector a
-{-# INLINE fold1WithP #-}
+{-# INLINE_UP fold1WithP #-}
 fold1WithP f
         = foldSegsWithP f (Seq.fold1SU f)
 
 
 -- | Sum up segments specified by a `UPSegd`.
 sumWithP :: (Num e, Unbox e) => UPSegd -> Vector e -> Vector e
-{-# INLINE sumWithP #-}
+{-# INLINE_UP sumWithP #-}
 sumWithP = foldWithP (+) 0
 
 
@@ -228,7 +226,7 @@ foldSegsWithP
         -> (USegd -> Vector a -> Vector a)
         -> UPSegd -> Vector a -> Vector a
 
-{-# INLINE foldSegsWithP #-}
+{-# INLINE_UP foldSegsWithP #-}
 foldSegsWithP fElem fSeg segd xs 
  = dcarry `seq` drs `seq` 
    runST (do
index 7d0bc18..3206b53 100644 (file)
@@ -85,37 +85,37 @@ type UPSelRep2
 
 -- | O(1). Get the tags of a selector.
 tagsUPSel2 :: UPSel2 -> Vector Tag
-{-# INLINE tagsUPSel2 #-}
+{-# INLINE_UP tagsUPSel2 #-}
 tagsUPSel2 = tagsUSel2 .  upsel2_usel
 
 
 -- | O(1). Get the indices of a selector.
 indicesUPSel2 :: UPSel2 -> Vector Int
-{-# INLINE indicesUPSel2 #-}
+{-# INLINE_UP indicesUPSel2 #-}
 indicesUPSel2 = indicesUSel2 . upsel2_usel
 
 
 -- | O(1). TODO: What is this for?
 elementsUPSel2_0 :: UPSel2 -> Int
-{-# INLINE elementsUPSel2_0 #-}
+{-# INLINE_UP elementsUPSel2_0 #-}
 elementsUPSel2_0 = elementsUSel2_0 . upsel2_usel
 
 
 -- | O(1). TODO: What is this for?
 elementsUPSel2_1 :: UPSel2 -> Int
-{-# INLINE elementsUPSel2_1 #-}
+{-# INLINE_UP elementsUPSel2_1 #-}
 elementsUPSel2_1 = elementsUSel2_1 . upsel2_usel
 
 
 -- | O(1). TODO: What is this for?
 selUPSel2 :: UPSel2 -> USel2
-{-# INLINE selUPSel2 #-}
+{-# INLINE_UP selUPSel2 #-}
 selUPSel2 = upsel2_usel
 
 
 -- | O(1). TODO: What is this for?
 repUPSel2 :: UPSel2 -> UPSelRep2
-{-# INLINE repUPSel2 #-}
+{-# INLINE_UP repUPSel2 #-}
 repUPSel2 = upsel2_rep
 
 
@@ -124,7 +124,7 @@ repUPSel2 = upsel2_rep
 -- | Computes a `UPSelRep2` from an array of tags. This is used when parallelising
 --   a `combine` operation. See the docs for `UPSelRep2` for details.
 mkUPSelRep2 :: Vector Tag -> UPSelRep2
-{-# INLINE mkUPSelRep2 #-}
+{-# INLINE_UP mkUPSelRep2 #-}
 mkUPSelRep2 tags = zipD idxs lens
   where
     lens = mapD   theGang count
@@ -140,7 +140,7 @@ mkUPSelRep2 tags = zipD idxs lens
 
 
 indicesUPSelRep2 :: Vector Tag -> UPSelRep2 -> Vector Int
-{-# INLINE indicesUPSelRep2 #-}
+{-# INLINE_UP indicesUPSelRep2 #-}
 indicesUPSelRep2 tags rep = joinD theGang balanced
                           $ zipWithD theGang indices
                                              (splitD theGang balanced tags)
@@ -153,18 +153,21 @@ indicesUPSelRep2 tags rep = joinD theGang balanced
 
 -- | O(n).
 elementsUPSelRep2_0 :: Vector Tag -> UPSelRep2 -> Int
-{-# INLINE elementsUPSelRep2_0 #-}
-elementsUPSelRep2_0 _ = sumD theGang . fstD . sndD
+{-# INLINE_UP elementsUPSelRep2_0 #-}
+elementsUPSelRep2_0 _
+        = sumD theGang . fstD . sndD
 
 
 -- | O(n).
 elementsUPSelRep2_1 :: Vector Tag -> UPSelRep2 -> Int
-{-# INLINE elementsUPSelRep2_1 #-}
-elementsUPSelRep2_1 _ = sumD theGang . sndD . sndD
+{-# INLINE_UP elementsUPSelRep2_1 #-}
+elementsUPSelRep2_1 _
+        = sumD theGang . sndD . sndD
 
 
 -- | O(1). Construct a selector. Wrapper for `UPSel2`.
 mkUPSel2 :: Vector Tag -> Vector Int -> Int -> Int -> UPSelRep2 -> UPSel2
-{-# INLINE mkUPSel2 #-}
-mkUPSel2 tags is n0 n1 rep = UPSel2 (mkUSel2 tags is n0 n1) rep
+{-# INLINE_UP mkUPSel2 #-}
+mkUPSel2 tags is n0 n1 rep
+        = UPSel2 (mkUSel2 tags is n0 n1) rep
 
index d1f5be6..a8dd8a4 100644 (file)
@@ -76,7 +76,7 @@ instance PprPhysical UPVSegd where
 --   * TODO: this doesn't do any checks yet.
 --\b
 valid :: UPVSegd -> Bool
-{-# INLINE valid #-}
+{-# INLINE_UP valid #-}
 valid (UPVSegd _ _)
         = True
 
@@ -87,7 +87,7 @@ mkUPVSegd
         -> UPSSegd      -- ^ Scattered segment descriptor defining the physical segments.
         -> UPVSegd
 
-{-# INLINE mkUPVSegd #-}
+{-# INLINE_UP mkUPVSegd #-}
 mkUPVSegd = UPVSegd
 
 
@@ -98,7 +98,7 @@ mkUPVSegd = UPVSegd
 --   TODO: make this parallel, use parallel version of enumFromTo.
 --
 fromUPSSegd :: UPSSegd -> UPVSegd
-{-# INLINE fromUPSSegd #-}
+{-# INLINE_UP fromUPSSegd #-}
 fromUPSSegd upssegd
         = UPVSegd 
                 (V.enumFromTo 0 (UPSSegd.length upssegd - 1))
@@ -110,14 +110,14 @@ fromUPSSegd upssegd
 --   the provided `UPSegd`.
 --
 fromUPSegd :: UPSegd -> UPVSegd
-{-# INLINE fromUPSegd #-}
+{-# INLINE_UP fromUPSegd #-}
 fromUPSegd
         = fromUPSSegd . UPSSegd.fromUPSegd
 
 
 -- | O(1). Yield an empty segment descriptor, with no elements or segments.
 empty :: UPVSegd
-{-# INLINE empty #-}
+{-# INLINE_UP empty #-}
 empty   = UPVSegd V.empty UPSSegd.empty
 
 
@@ -125,7 +125,7 @@ empty   = UPVSegd V.empty UPSSegd.empty
 --   The single segment covers the given number of elements in a flat array
 --   with sourceid 0.
 singleton :: Int -> UPVSegd
-{-# INLINE singleton #-}
+{-# INLINE_UP singleton #-}
 singleton n 
         = UPVSegd (V.singleton 0) (UPSSegd.singleton n)
 
@@ -133,28 +133,28 @@ singleton n
 -- Projections ----------------------------------------------------------------
 -- | O(1). Yield the overall number of segments.
 length :: UPVSegd -> Int
-{-# INLINE length #-}
+{-# INLINE_UP length #-}
 length (UPVSegd vsegids _)
         = V.length vsegids
 
 
 -- | O(1). Yield the virtual segment ids of `UPVSegd`.
 takeVSegids :: UPVSegd -> Vector Int
-{-# INLINE takeVSegids #-}
+{-# INLINE_UP takeVSegids #-}
 takeVSegids (UPVSegd vsegids _)
         = vsegids
 
 
 -- | O(1). Yield the `UPSSegd` of `UPVSegd`.
 takeUPSSegd :: UPVSegd -> UPSSegd
-{-# INLINE takeUPSSegd #-}
+{-# INLINE_UP takeUPSSegd #-}
 takeUPSSegd (UPVSegd _ upssegd)
         = upssegd
 
 
 -- | O(segs). Yield the lengths of the segments described by a `UPVSegd`.
 takeLengths :: UPVSegd -> Vector Int
-{-# INLINE takeLengths #-}
+{-# INLINE_UP takeLengths #-}
 takeLengths (UPVSegd vsegids upssegd)
         = V.map (UPSSegd.takeLengths upssegd V.!) vsegids
 
@@ -167,7 +167,7 @@ takeLengths (UPVSegd vsegids upssegd)
 --        to a UVSegd index it could overflow.
 --
 getSeg :: UPVSegd -> Int -> (Int, Int, Int)
-{-# INLINE getSeg #-}
+{-# INLINE_UP getSeg #-}
 getSeg (UPVSegd vsegids upssegd) ix
  = let  (len, _index, start, source) = UPSSegd.getSeg upssegd (vsegids V.! ix)
    in   (len, start, source)
@@ -184,7 +184,7 @@ getSeg (UPVSegd vsegids upssegd) ix
 --     segmentation from a nested array.
 -- 
 demoteToUPSSegd :: UPVSegd -> UPSSegd
-{-# INLINE demoteToUPSSegd #-}
+{-# INLINE_UP demoteToUPSSegd #-}
 demoteToUPSSegd (UPVSegd vsegids upssegd)
  = let  starts'         = bpermuteUP (UPSSegd.takeStarts  upssegd) vsegids
         sources'        = bpermuteUP (UPSSegd.takeSources upssegd) vsegids
@@ -207,7 +207,7 @@ demoteToUPSSegd (UPVSegd vsegids upssegd)
 --   because the program would OOM anyway.
 --
 unsafeDemoteToUPSegd :: UPVSegd -> UPSegd
-{-# INLINE unsafeDemoteToUPSegd #-}
+{-# INLINE_UP unsafeDemoteToUPSegd #-}
 unsafeDemoteToUPSegd (UPVSegd vsegids upssegd)
         = UPSegd.fromLengths
         $ bpermuteUP (UPSSegd.takeLengths upssegd) vsegids
@@ -221,7 +221,7 @@ unsafeDemoteToUPSegd (UPVSegd vsegids upssegd)
 --     the UPSSegd.
 -- 
 updateVSegs :: (Vector Int -> Vector Int) -> UPVSegd -> UPVSegd
-{-# INLINE updateVSegs #-}
+{-# INLINE_UP updateVSegs #-}
 updateVSegs f (UPVSegd vsegids upssegd)
  = let  (vsegids', ussegd') 
                 = USSegd.cullOnVSegids (f vsegids) 
@@ -240,7 +240,7 @@ appendWith
         -> UPVSegd -> Int  -- ^ uvsegd of array, and number of physical data arrays
         -> UPVSegd
 
-{-# INLINE appendWith #-}
+{-# INLINE_UP appendWith #-}
 appendWith
         (UPVSegd vsegids1 upssegd1) pdatas1
         (UPVSegd vsegids2 upssegd2) pdatas2
@@ -271,7 +271,7 @@ combine2
         -> UPVSegd -> Int   -- ^ uvsegd of array, and number of physical data arrays
         -> UPVSegd
         
-{-# INLINE combine2 #-}
+{-# INLINE_UP combine2 #-}
 combine2
         upsel2
         (UPVSegd vsegids1 upssegd1) pdatas1
index 68e01a7..bcdee8a 100644 (file)
@@ -10,39 +10,41 @@ import Data.Array.Parallel.Unlifted.Sequential.Combinators
 
 -- | Compute the boolean AND of all segments in a segmented array.
 andSU :: USegd -> Vector Bool -> Vector Bool
+{-# INLINE_U andSU #-}
 andSU = foldSU (&&) True
 
 
 -- | Compute the boolean OR of all segments in a segmented array.
 orSU :: USegd -> Vector Bool -> Vector Bool
+{-# INLINE_U orSU #-}
 orSU = foldSU (||) False
 
 
 -- | Compute the segmented sum of an array of numerals
 sumSU :: (Num e, Unbox e) => USegd -> Vector e -> Vector e
-{-# INLINE sumSU #-}
+{-# INLINE_U sumSU #-}
 sumSU = foldSU (+) 0
 
 
 -- | Compute the segmented product of an array of numerals
 productSU :: (Num e, Unbox e) => USegd -> Vector e -> Vector e
-{-# INLINE productSU #-}
+{-# INLINE_U productSU #-}
 productSU = foldSU (*) 1
 
 
 -- | Determine the maximum element in each subarray
 maximumSU :: (Ord e, Unbox e) => USegd -> Vector e -> Vector e
-{-# INLINE maximumSU #-}
+{-# INLINE_U maximumSU #-}
 maximumSU = fold1SU max
 
 
 -- | Determine the minimum element in each subarray
 minimumSU :: (Ord e, Unbox e) => USegd -> Vector e -> Vector e
-{-# INLINE minimumSU #-}
+{-# INLINE_U minimumSU #-}
 minimumSU = fold1SU min
 
 
 -- | Compute the segmented sum of an array of numerals
 sumRU :: (Num e, Unbox e) => Int ->Vector e -> Vector e
-{-# INLINE sumRU #-}
+{-# INLINE_U sumRU #-}
 sumRU = foldlRU (+) 0
index 23409dc..a0b5425 100644 (file)
@@ -87,14 +87,14 @@ mkUSSegd
         -> USegd        -- ^ contiguous segment descriptor
         -> USSegd
 
-{-# INLINE mkUSSegd #-}
+{-# INLINE_U mkUSSegd #-}
 mkUSSegd = USSegd
 
 
 -- | O(1).
 --   Check the internal consistency of a scattered segment descriptor.
 valid :: USSegd -> Bool
-{-# INLINE valid #-}
+{-# INLINE_U valid #-}
 valid (USSegd starts srcids usegd)
         =  (U.length starts == USegd.length usegd)
         && (U.length srcids == USegd.length usegd)
@@ -103,7 +103,7 @@ valid (USSegd starts srcids usegd)
 -- | O(1).
 --  Yield an empty segment descriptor, with no elements or segments.
 empty :: USSegd
-{-# INLINE empty #-}
+{-# INLINE_U empty #-}
 empty = USSegd U.empty U.empty USegd.empty
 
 
@@ -112,7 +112,7 @@ empty = USSegd U.empty U.empty USegd.empty
 --   The single segment covers the given number of elements in a flat array
 --   with sourceid 0.
 singleton :: Int -> USSegd
-{-# INLINE singleton #-}
+{-# INLINE_U singleton #-}
 singleton n 
         = USSegd (U.singleton 0) (U.singleton 0) (USegd.singleton n)
 
@@ -121,7 +121,7 @@ singleton n
 --   Promote a plain USegd to a USSegd
 --   All segments are assumed to come from a flat array with sourceid 0.
 fromUSegd :: USegd -> USSegd
-{-# INLINE fromUSegd #-}
+{-# INLINE_U fromUSegd #-}
 fromUSegd usegd
         = USSegd (USegd.takeIndices usegd)
                  (U.replicate (USegd.length usegd) 0)
@@ -132,50 +132,50 @@ fromUSegd usegd
 -- Projections ----------------------------------------------------------------
 -- | O(1). Yield the overall number of segments.
 length :: USSegd -> Int
-{-# INLINE length #-}
+{-# INLINE_U length #-}
 length = USegd.length . ussegd_usegd 
 
 
 -- | O(1). Yield the `USegd` of a `USSegd`
 takeUSegd   :: USSegd -> USegd
-{-# INLINE takeUSegd #-}
+{-# INLINE_U takeUSegd #-}
 takeUSegd   = ussegd_usegd
 
 
 -- | O(1). Yield the lengths of the segments of a `USSegd`
 takeLengths :: USSegd -> Vector Int
-{-# INLINE takeLengths #-}
+{-# INLINE_U takeLengths #-}
 takeLengths = USegd.takeLengths . ussegd_usegd
 
 
 -- | O(1). Yield the segment indices of a `USSegd`
 takeIndices :: USSegd -> Vector Int
-{-# INLINE takeIndices #-}
+{-# INLINE_U takeIndices #-}
 takeIndices = USegd.takeIndices . ussegd_usegd
 
 
 -- | O(1). Yield the total number of elements covered by a `USSegd`
 takeElements :: USSegd -> Int
-{-# INLINE takeElements #-}
+{-# INLINE_U takeElements #-}
 takeElements = USegd.takeElements . ussegd_usegd
 
 
 -- | O(1). Yield the starting indices of a `USSegd`
 takeStarts :: USSegd -> Vector Int
-{-# INLINE takeStarts #-}
+{-# INLINE_U takeStarts #-}
 takeStarts = ussegd_starts
 
 
 -- | O(1). Yield the source ids of a `USSegd`
 takeSources :: USSegd -> Vector Int
-{-# INLINE takeSources #-}
+{-# INLINE_U takeSources #-}
 takeSources = ussegd_sources
 
 
 -- | O(1).
 --   Get the length, segment index, starting index, and source id of a segment.
 getSeg :: USSegd -> Int -> (Int, Int, Int, Int)
-{-# INLINE getSeg #-}
+{-# INLINE_U getSeg #-}
 getSeg (USSegd starts sources usegd) ix
  = let  (len, index) = USegd.getSeg usegd ix
    in   ( len
@@ -192,7 +192,7 @@ append
         :: USSegd -> Int        -- ^ ussegd of array, and number of physical data arrays
         -> USSegd -> Int        -- ^ ussegd of array, and number of physical data arrays
         -> USSegd
-{-# INLINE append #-}
+{-# INLINE_U append #-}
 append (USSegd starts1 srcs1 usegd1) pdatas1
              (USSegd starts2 srcs2 usegd2) _
         = USSegd (starts1  U.++  starts2)
@@ -207,7 +207,7 @@ append (USSegd starts1 srcs1 usegd1) pdatas1
 --   TODO: bpermuteDft isn't parallelised
 --
 cullOnVSegids :: Vector Int -> USSegd -> (Vector Int, USSegd)
-{-# INLINE cullOnVSegids #-}
+{-# INLINE_U cullOnVSegids #-}
 cullOnVSegids vsegids (USSegd starts sources usegd)
  = let  -- Determine which of the psegs are still reachable from the vsegs.
         -- This produces an array of flags, 
@@ -276,7 +276,7 @@ streamSegs
         => USSegd               -- ^ Segment descriptor defining segments based on source vectors.
         -> V.Vector (Vector a)  -- ^ Source vectors.
         -> S.Stream a
-        
+{-# INLINE_U streamSegs #-}
 streamSegs ussegd@(USSegd starts sources usegd) pdatas
  = let  
         -- length of each segment
index 0d3fd99..3b3ccdc 100644 (file)
@@ -62,7 +62,7 @@ mkUSegd
         -> Int          -- ^ total number of elements in the flat array
         -> USegd
 
-{-# INLINE mkUSegd #-}
+{-# INLINE_U mkUSegd #-}
 mkUSegd = USegd
 
 
@@ -71,21 +71,21 @@ mkUSegd = USegd
 --   lengths, we check the consistency by rebuilding these fields and 
 --   comparing the rebuilt ones against the originals.
 valid :: USegd -> Bool
-{-# INLINE valid #-}
+{-# INLINE_U valid #-}
 valid usegd@(USegd lengths _ _)
         = usegd == fromLengths lengths
 
 
 -- | O(1). Yield an empty segment descriptor, with no elements or segments.
 empty :: USegd
-{-# INLINE empty #-}
+{-# INLINE_U empty #-}
 empty = USegd V.empty V.empty 0
 
 
 -- | O(1). Yield a singleton segment descriptor.
 --   The single segment covers the given number of elements.
 singleton :: Int -> USegd
-{-# INLINE singleton #-}
+{-# INLINE_U singleton #-}
 singleton n = USegd (V.singleton n) (V.singleton 0) n
 
 
@@ -95,7 +95,7 @@ singleton n = USegd (V.singleton n) (V.singleton 0) n
 --   indices from that. Runtime is O(n) in the number of segments.
 --
 fromLengths :: Vector Int -> USegd
-{-# INLINE fromLengths #-}
+{-# INLINE_U fromLengths #-}
 fromLengths lens
         = USegd lens (V.scanl (+) 0 lens) (V.sum lens)
 
@@ -103,31 +103,31 @@ fromLengths lens
 -- Projections ----------------------------------------------------------------
 -- | O(1). Yield the overall number of segments.
 length :: USegd -> Int
-{-# INLINE length #-}
+{-# INLINE_U length #-}
 length = V.length . usegd_lengths
 
 
 -- | O(1). Yield the lengths of the individual segments.
 takeLengths :: USegd -> Vector Int
-{-# INLINE takeLengths #-}
+{-# INLINE_U takeLengths #-}
 takeLengths = usegd_lengths
 
 
 -- | O(1). Yield the segment indices of a segment descriptor.
 takeIndices :: USegd -> Vector Int
-{-# INLINE takeIndices #-}
+{-# INLINE_U takeIndices #-}
 takeIndices = usegd_indices
 
 
 -- | O(1). Yield the number of data elements.
 takeElements :: USegd -> Int
-{-# INLINE takeElements #-}
+{-# INLINE_U takeElements #-}
 takeElements = usegd_elements
 
 
 -- | O(1). Get the length and segment index of a segment
 getSeg :: USegd -> Int -> (Int, Int)
-{-# INLINE getSeg #-}
+{-# INLINE_U getSeg #-}
 getSeg (USegd lengths indices _ ) ix
  =      ( lengths V.! ix
         , indices V.! ix)
@@ -137,7 +137,7 @@ getSeg (USegd lengths indices _ ) ix
 -- | O(segs). Produce a segment descriptor that describes the result of appending 
 --   two arrays.
 append :: USegd -> USegd -> USegd
-{-# INLINE append #-}
+{-# INLINE_U append #-}
 append (USegd lengths1 indices1 elems1)
             (USegd lengths2 indices2 elems2)
  = USegd (lengths1 V.++ lengths2)
@@ -159,7 +159,7 @@ slice
         -> Int          -- ^ number of segments to slice out
         -> USegd
         
-{-# INLINE slice #-}
+{-# INLINE_U slice #-}
 slice segd i n
         = fromLengths $ V.slice (takeLengths segd) i n
 
@@ -177,7 +177,7 @@ extract
         -> Int          -- ^ number of segments to extract out
         -> USegd
 
-{-# INLINE extract #-}
+{-# INLINE_U extract #-}
 extract segd i n 
         = fromLengths $ V.extract (takeLengths segd) i n
 
index 72f0e17..cd36ba4 100644 (file)
@@ -62,44 +62,44 @@ mkUSel2 :: Vector Tag           -- ^ tags array
         -> Int                  -- ^ number of elements taken from first array
         -> Int                  -- ^ number of elements taken from second array
         -> USel2
-{-# INLINE mkUSel2 #-}
+{-# INLINE_U mkUSel2 #-}
 mkUSel2 = USel2
 
 
 -- | O(1). Get the number of elements represented by this selector.
 --         This is the length of the array returned by `combine`.
 lengthUSel2 :: USel2 -> Int
-{-# INLINE lengthUSel2 #-}
+{-# INLINE_U lengthUSel2 #-}
 lengthUSel2 = V.length . usel2_tags
 
 
 -- | O(1). Get the tags array of a selector.
 tagsUSel2 :: USel2 -> Vector Tag
-{-# INLINE tagsUSel2 #-}
+{-# INLINE_U tagsUSel2 #-}
 tagsUSel2 = usel2_tags
 
 
 -- | O(1). Get the indices array of a selector.
 indicesUSel2 :: USel2 -> Vector Int
-{-# INLINE indicesUSel2 #-}
+{-# INLINE_U indicesUSel2 #-}
 indicesUSel2 = usel2_indices
 
 
 -- | O(1). Get the number of elements that will be taken from the first array.
 elementsUSel2_0 :: USel2 -> Int
-{-# INLINE elementsUSel2_0 #-}
+{-# INLINE_U elementsUSel2_0 #-}
 elementsUSel2_0 = usel2_elements0
 
 
 -- | O(1). Get the number of elements that will be taken from the second array.
 elementsUSel2_1 :: USel2 -> Int
-{-# INLINE elementsUSel2_1 #-}
+{-# INLINE_U elementsUSel2_1 #-}
 elementsUSel2_1 = usel2_elements1
 
 
 -- | O(n). Compute the source index for each element of the result array.
 tagsToIndices2 :: Vector Tag -> Vector Int
-{-# INLINE tagsToIndices2 #-}
+{-# INLINE_U tagsToIndices2 #-}
 tagsToIndices2 tags 
   = unstream (mapAccumS add (0,0) (stream tags))
   where
index ab32316..7c4c3e2 100644 (file)
@@ -73,7 +73,7 @@ instance PprPhysical UVSegd where
 --   Check the internal consistency of a virutal segmentation descriptor.
 --   TODO: check that all vsegs point to a valid pseg
 valid :: UVSegd -> Bool
-{-# INLINE valid #-}
+{-# INLINE_U valid #-}
 valid (UVSegd vsegids ussegd)
         = V.length vsegids == USSegd.length ussegd
 
@@ -88,7 +88,7 @@ mkUVSegd
         -> USSegd       -- ^ slice segment descriptor describing physical segments.
         -> UVSegd
 
-{-# INLINE mkUVSegd #-}
+{-# INLINE_U mkUVSegd #-}
 mkUVSegd = UVSegd
 
 
@@ -98,7 +98,7 @@ mkUVSegd = UVSegd
 --   the provided USSegd.
 --
 fromUSSegd :: USSegd -> UVSegd
-{-# INLINE fromUSSegd #-}
+{-# INLINE_U fromUSSegd #-}
 fromUSSegd ussegd
         = UVSegd (V.enumFromTo 0 (USSegd.length ussegd - 1))
                  ussegd
@@ -110,7 +110,7 @@ fromUSSegd ussegd
 --   the provided USegd.
 --
 fromUSegd :: USegd -> UVSegd
-{-# INLINE fromUSegd #-}
+{-# INLINE_U fromUSegd #-}
 fromUSegd
         = fromUSSegd . USSegd.fromUSegd
 
@@ -118,7 +118,7 @@ fromUSegd
 -- | O(1).
 --  Yield an empty segment descriptor, with no elements or segments.
 empty :: UVSegd
-{-# INLINE empty #-}
+{-# INLINE_U empty #-}
 empty   = UVSegd V.empty USSegd.empty
 
 
@@ -127,7 +127,7 @@ empty   = UVSegd V.empty USSegd.empty
 --   The single segment covers the given number of elements in a flat array
 --   with sourceid 0.
 singleton :: Int -> UVSegd
-{-# INLINE singleton #-}
+{-# INLINE_U singleton #-}
 singleton n 
         = UVSegd (V.singleton 0) (USSegd.singleton n)
 
@@ -135,25 +135,25 @@ singleton n
 
 -- Projections ----------------------------------------------------------------
 takeVSegids :: UVSegd -> Vector Int
-{-# INLINE takeVSegids #-}
+{-# INLINE_U takeVSegids #-}
 takeVSegids (UVSegd vsegids _)
         = vsegids
 
         
 takeUSSegd :: UVSegd -> USSegd
-{-# INLINE takeUSSegd #-}
+{-# INLINE_U takeUSSegd #-}
 takeUSSegd (UVSegd _ ussegd)
         = ussegd
 
 
 length :: UVSegd -> Int
-{-# INLINE length #-}
+{-# INLINE_U length #-}
 length (UVSegd vsegids _)
         = V.length vsegids
 
 -- | O(segs). Yield the lengths of the segments described by a `UVSegd`.
 takeLengths :: UVSegd -> Vector Int
-{-# INLINE takeLengths #-}
+{-# INLINE_U takeLengths #-}
 takeLengths (UVSegd vsegids ussegd)
         = V.map (USSegd.takeLengths ussegd V.!) vsegids
 
@@ -166,7 +166,7 @@ takeLengths (UVSegd vsegids ussegd)
 --        to a UVSegd index it could overflow.
 --
 getSeg :: UVSegd -> Int -> (Int, Int, Int)
-{-# INLINE getSeg #-}
+{-# INLINE_U getSeg #-}
 getSeg (UVSegd vsegids ussegd) ix
  = let  (len, _index, start, source) = USSegd.getSeg ussegd (vsegids V.! ix)
    in   (len, start, source)
@@ -175,7 +175,7 @@ getSeg (UVSegd vsegids ussegd) ix
 -- Operators ------------------------------------------------------------------
 -- | TODO: automatically force out unreachable psegs here.
 updateVSegs :: (Vector Int -> Vector Int) -> UVSegd -> UVSegd
-{-# INLINE updateVSegs #-}
+{-# INLINE_U updateVSegs #-}
 updateVSegs f (UVSegd vsegids ussegd)
  = let  (vsegids', ussegd') = USSegd.cullOnVSegids (f vsegids) ussegd
    in   UVSegd vsegids' ussegd'
@@ -191,7 +191,7 @@ updateVSegs f (UVSegd vsegids ussegd)
 --     segmentation from a nested array.
 -- 
 toUSSegd :: UVSegd -> USSegd
-{-# INLINE toUSSegd #-}
+{-# INLINE_U toUSSegd #-}
 toUSSegd (UVSegd vsegids ussegd)
  = let  starts'         = V.bpermute (USSegd.takeStarts  ussegd)  vsegids
         sources'        = V.bpermute (USSegd.takeSources ussegd) vsegids
@@ -215,7 +215,7 @@ toUSSegd (UVSegd vsegids ussegd)
 --   because the program would OOM anyway.
 --
 unsafeMaterialize :: UVSegd -> USegd
-{-# INLINE unsafeMaterialize #-}
+{-# INLINE_U unsafeMaterialize #-}
 unsafeMaterialize (UVSegd vsegids ussegd)
         = USegd.fromLengths
         $ V.bpermute (USSegd.takeLengths ussegd) vsegids
@@ -257,7 +257,7 @@ append  :: UVSegd -> Int  -- ^ uvsegd of array, and number of physical data arra
         -> UVSegd -> Int  -- ^ uvsegd of array, and number of physical data arrays
         -> UVSegd
 
-{-# INLINE append #-}
+{-# INLINE_U append #-}
 append  (UVSegd vsegids1 ussegd1) pdatas1
         (UVSegd vsegids2 ussegd2) pdatas2
 
@@ -313,7 +313,7 @@ combine2
         -> UVSegd -> Int   -- ^ uvsegd of array, and number of physical data arrays
         -> UVSegd
         
-{-# INLINE combine2 #-}
+{-# INLINE_U combine2 #-}
 combine2  usel2
         (UVSegd vsegids1 ussegd1) pdatas1
         (UVSegd vsegids2 ussegd2) pdatas2