dph-lifted-vseg: add Sum2 skeleton and enough stuff to make the treeIndices example...
authorBen Lippmeier <benl@ouroborus.net>
Mon, 17 Oct 2011 07:17:42 +0000 (18:17 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Mon, 17 Oct 2011 07:17:42 +0000 (18:17 +1100)
12 files changed:
dph-examples/broken/Indices/dph/IndicesVectorised.hs
dph-examples/broken/Indices/dph/Main.hs
dph-lifted-vseg/Data/Array/Parallel.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Sum2.hs [new file with mode: 0644]
dph-lifted-vseg/Data/Array/Parallel/PArray/PRepr/Instances.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/Scalar.hs
dph-lifted-vseg/Data/Array/Parallel/Prelude.hs [new file with mode: 0644]
dph-lifted-vseg/Data/Array/Parallel/Prelude/Bool.hs
dph-lifted-vseg/Data/Array/Parallel/Prelude/Int.hs
dph-lifted-vseg/Data/Array/Parallel/Prim.hs
dph-lifted-vseg/Data/Array/Parallel/VectDepend.hs

index ebc4e57..3fb7dde 100644 (file)
@@ -5,6 +5,7 @@ module IndicesVectorised
 where
 import Data.Array.Parallel
 import Data.Array.Parallel.Prelude.Int
+import Data.Array.Parallel.Prelude.Bool
 import qualified Prelude as P
 
 
index 3a41360..cd4b040 100644 (file)
@@ -18,15 +18,15 @@ main
 
 
 run "vectorised" count
- = do   let arr = P.fromList [0 .. count - 1]
+ = do   let arr = P.fromListPA [0 .. count - 1]
         arr `seq` return ()     
                 
         (arrResult, tElapsed)
          <- time
          $  let  arr'    = ID.indicesPA arr arr
-            in   P.nf arr' `seq` return arr'
+            in   P.nfPA arr' `seq` return arr'
 
-        print   $ P.length arrResult
+        print   $ P.lengthPA arrResult
         putStr  $ prettyTime tElapsed
 
 run _ _
index 3e067c9..13cd124 100644 (file)
@@ -28,8 +28,7 @@
 --  at all!
 --
 module Data.Array.Parallel (
-        -- [::]         -- Built-in syntax
-        PArray,
+        module Data.Array.Parallel.Prelude,
 
         -- * Conversions
         fromPArrayP,
@@ -40,9 +39,13 @@ module Data.Array.Parallel (
         emptyP,
         singletonP,
         replicateP,
+        appendP, (+:+),
+        concatP,
         
         -- * Projections
-        (!:),
+        lengthP,
+        indexP, (!:),
+        sliceP,
         
         -- * Traversals
         mapP,
@@ -57,6 +60,7 @@ import Data.Array.Parallel.VectDepend
 import Data.Array.Parallel.PArr
 import Data.Array.Parallel.Lifted
 import Data.Array.Parallel.PArray
+import Data.Array.Parallel.Prelude
 import Data.Array.Parallel.Prelude.Int   (Int)
 import Data.Array.Parallel.Prelude.Bool  (Bool)
 import qualified Prelude        as P
@@ -126,19 +130,54 @@ replicateP      = replicatePArr
 {-# VECTORISE replicateP = replicatePP #-}
 
 
+-- | Append two arrays.
+appendP, (+:+) :: [:a:] -> [:a:] -> [:a:]
+(+:+) !_ !_     = [::]
+{-# NOINLINE  (+:+) #-}
+{-# VECTORISE (+:+)     = appendPP #-}
+
+appendP !_ !_   = [::]
+{-# NOINLINE  appendP #-}
+{-# VECTORISE appendP   = appendPP #-}
+
+
+-- | Concatenate an array of arrays.
+concatP :: [:[:a:]:] -> [:a:]
+concatP !_      = [::]
+{-# NOINLINE  concatP #-}
+{-# VECTORISE concatP = concatPP #-}
+
+
 -- Projections ----------------------------------------------------------------
+-- | Take the length of an array.
+lengthP :: [:a:] -> Int
+lengthP = lengthPArr
+{-# NOINLINE  lengthP #-}
+{-# VECTORISE lengthP   = lengthPP #-}
+
 -- | Lookup a single element from the source array.
-(!:) :: [:a:] -> Int -> a
+indexP, (!:) :: [:a:] -> Int -> a
 (!:)            = indexPArr
 {-# NOINLINE  (!:) #-}
-{-# VECTORISE (!:) = indexPP #-}
+{-# VECTORISE (!:)      = indexPP #-}
+
+indexP            = indexPArr
+{-# NOINLINE  indexP #-}
+{-# VECTORISE indexP    = indexPP #-}
+
+
+-- | Extract a slice from an array.
+sliceP :: Int -> Int -> [:a:] -> [:a:]
+sliceP !_ !_ !_ = [::]
+{-# NOINLINE sliceP #-}
+{-# VECTORISE sliceP    = slicePP #-}
 
 
 -- Traversals -----------------------------------------------------------------
 mapP :: (a -> b) -> [:a:] -> [:b:]
 mapP !_ !_      = [::]
 {-# NOINLINE  mapP #-}
-{-# VECTORISE mapP = mapPP #-}
+{-# VECTORISE mapP      = mapPP #-}
 
 
 -- Filtering -----------------------------------------------------------------
index c373c39..d80e089 100644 (file)
@@ -14,6 +14,7 @@ import Data.Array.Parallel.PArray.PData.Wrap
 import Data.Array.Parallel.PArray.PData.Int             ()
 import Data.Array.Parallel.PArray.PData.Double
 import Data.Array.Parallel.PArray.PData.Nested
+import Data.Array.Parallel.PArray.PData.Sum2
 import Data.Array.Parallel.PArray.PData.Unit
 import Data.Array.Parallel.PArray.PData.Tuple
 import Data.Array.Parallel.PArray.PData.Void
diff --git a/dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Sum2.hs b/dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Sum2.hs
new file mode 100644 (file)
index 0000000..17aa9b3
--- /dev/null
@@ -0,0 +1,86 @@
+#include "fusion-phases.h"
+module Data.Array.Parallel.PArray.PData.Sum2 where
+
+import Data.Array.Parallel.PArray.PData.Base
+import Data.Array.Parallel.PArray.PData.Nested
+import Data.Array.Parallel.PArray.Types
+import Data.Array.Parallel.PArray.PRepr.Base
+import Data.Array.Parallel.Unlifted             as U
+
+
+-------------------------------------------------------------------------------
+data instance PData (Sum2 a b)
+        = PSum2 U.Sel2 (PData a) (PData b)
+        
+        
+-- PR -------------------------------------------------------------------------
+
+-- This stuff isn't implemented yet.
+nope    = error "Data.Array.Parallel.PData.Void: no PR method for Sum2"
+
+
+instance (PR a, PR b) => PR (Sum2 a b)  where
+  {-# INLINE_PDATA validPR #-}
+  validPR _
+        = True
+
+  {-# INLINE_PDATA emptyPR #-}
+  emptyPR
+        = nope
+
+  {-# INLINE_PDATA nfPR #-}
+  nfPR (PSum2 sel xs ys)
+        = nope
+
+  {-# INLINE_PDATA lengthPR #-}
+  lengthPR _
+        = nope
+
+  {-# INLINE_PDATA replicatePR #-}
+  replicatePR _
+        = nope
+                
+  {-# INLINE_PDATA replicatesPR #-}
+  replicatesPR
+        = nope
+                      
+  {-# INLINE_PDATA indexPR #-}
+  indexPR
+        = nope
+                
+  {-# INLINE_PDATA indexlPR #-}
+  indexlPR 
+        = nope
+  
+  {-# INLINE_PDATA extractPR #-}
+  extractPR 
+        = nope
+  
+  {-# INLINE_PDATA extractsPR #-}
+  extractsPR 
+        = nope
+        
+  {-# INLINE_PDATA appendPR #-}
+  appendPR
+        = nope
+        
+  {-# INLINE_PDATA appendsPR #-}
+  appendsPR
+        = nope
+        
+  {-# INLINE_PDATA packByTagPR #-}
+  packByTagPR
+        = nope
+  
+  {-# INLINE_PDATA combine2PR #-}
+  combine2PR 
+        = nope
+        
+  {-# INLINE_PDATA fromVectorPR #-}
+  fromVectorPR 
+        = nope
+        
+  {-# INLINE_PDATA toVectorPR #-}
+  toVectorPR
+        = nope
+  
\ No newline at end of file
index d1f0c9d..5c25557 100644 (file)
@@ -13,9 +13,11 @@ import Data.Array.Parallel.PArray.PData.Void
 import Data.Array.Parallel.PArray.PData.Wrap
 import Data.Array.Parallel.PArray.PData.Unit
 import Data.Array.Parallel.PArray.PData.Nested
+import Data.Array.Parallel.PArray.PData.Sum2
 import Data.Array.Parallel.PArray.PData.Tuple
 import Data.Array.Parallel.PArray.PData.Int
 import Data.Array.Parallel.PArray.PData.Double
+import qualified Data.Array.Parallel.Unlifted   as U
 
 -- Void -----------------------------------------------------------------------
 type instance PRepr Void = Void
@@ -64,4 +66,28 @@ instance PA Double where
   toArrPReprs           = id
   toNestedArrPRepr      = id
   
+  
+-- Bool -----------------------------------------------------------------------
+data instance PData Bool
+  = PBool U.Sel2
+
+type instance PRepr Bool
+  = Sum2 Void Void
+
+instance PA Bool where
+  {-# INLINE toPRepr #-}
+  toPRepr False          = Alt2_1 void
+  toPRepr True           = Alt2_2 void
+
+  {-# INLINE fromPRepr #-}
+  fromPRepr (Alt2_1 _)   = False
+  fromPRepr (Alt2_2 _)   = True
+
+  {-# INLINE toArrPRepr #-}
+  toArrPRepr (PBool sel) = PSum2 sel pvoid pvoid
+
+  {-# INLINE fromArrPRepr #-}
+  fromArrPRepr (PSum2 sel _ _)
+   = PBool sel
+
   
\ No newline at end of file
index 5345a97..c634331 100644 (file)
@@ -11,6 +11,7 @@ module Data.Array.Parallel.PArray.Scalar
 where
 import Data.Array.Parallel.PArray.PData
 import Data.Array.Parallel.PArray.PRepr
+import Data.Array.Parallel.Base
 import qualified Data.Array.Parallel.Unlifted   as U
 import GHC.Exts
 
@@ -18,7 +19,12 @@ class U.Elt a => Scalar a where
   fromScalarPData :: PData a -> U.Array a
   toScalarPData   :: U.Array a -> PData a
 
+-- Shorthands used in this module only
+from    = fromScalarPData
+to      = toScalarPData
+
 
+-- Instances --------------------------------------------------------------
 instance Scalar Int where
   fromScalarPData (PInt xs)     = xs
   toScalarPData                 = PInt
@@ -27,10 +33,14 @@ instance Scalar Double where
   fromScalarPData (PDouble xs)  = xs
   toScalarPData                 = PDouble
 
+instance Scalar Bool where
+  {-# INLINE toScalarPData #-}
+  toScalarPData bs
+    = PBool (U.tagsToSel2 (U.map fromBool bs))
+
+  {-# INLINE fromScalarPData #-}
+  fromScalarPData (PBool sel) = U.map toBool (U.tagsSel2 sel)
 
--- Shorthands used in this module only
-from    = fromScalarPData
-to      = toScalarPData
 
 
 -- Array Conversions -------------------------------------------------------
diff --git a/dph-lifted-vseg/Data/Array/Parallel/Prelude.hs b/dph-lifted-vseg/Data/Array/Parallel/Prelude.hs
new file mode 100644 (file)
index 0000000..a5597a5
--- /dev/null
@@ -0,0 +1,22 @@
+{-# OPTIONS_GHC -fvectorise #-}
+
+-- | This module (as well as the type-specific modules
+--  'Data.Array.Parallel.Prelude.*') are a temporary kludge needed as DPH
+--  programs cannot directly use the (non-vectorised) functions from the
+--  standard Prelude.  It also exports some conversion helpers.
+--
+--  /This module should not be explicitly imported in user code anymore./
+--   User code should only import 'Data.Array.Parallel' and, until the
+--  vectoriser supports type classes, the type-specific
+--  modules 'Data.Array.Parallel.Prelude.*'.
+module Data.Array.Parallel.Prelude 
+        ( module Data.Array.Parallel.Prelude.Bool
+        , module Data.Array.Parallel.Prelude.Tuple
+        , PArray, Scalar(..))
+where
+import Data.Array.Parallel.Prelude.Bool
+import Data.Array.Parallel.Prelude.Tuple
+import Data.Array.Parallel.PArray        
+import Data.Array.Parallel.PArray.Scalar
+
+{-# VECTORISE type () = () #-}
index ea18d58..96798da 100644 (file)
@@ -3,15 +3,14 @@
 -- NB: Cannot use any parallel array syntax except the type constructor
 
 module Data.Array.Parallel.Prelude.Bool (
-        Bool,
+        Bool(..),
+        otherwise
 )
 where
 import Data.Array.Parallel.VectDepend
 -- IMPORTANT: see Note [Vectoriser dependencies] in the same module
 
 import Data.Array.Parallel.Lifted
-import qualified Prelude as P
-import Prelude (Bool)
         
 {-# VECTORISE type Bool = Bool #-}
 
index 76ab743..7610bbf 100644 (file)
@@ -3,8 +3,16 @@
 
 module Data.Array.Parallel.Prelude.Int (
         Int,
+     
+        -- Ord
+        (==), (/=), (<), (<=), (>), (>=), min, max,
+     
+        -- Num
         (+), (-), (*),
-        sumP
+        sumP,
+        
+        -- Integral
+        div, mod
 )
 where
 import Data.Array.Parallel.VectDepend
@@ -12,12 +20,43 @@ import Data.Array.Parallel.VectDepend
 
 import Data.Array.Parallel.PArr
 import Data.Array.Parallel.Lifted
+import Data.Array.Parallel.Prelude.Bool
 import qualified Prelude as P
 import Prelude (Int)
         
 {-# VECTORISE SCALAR type Int #-}
 
--- Basics ---------------------------------------------------------------------
+-- Ord ------------------------------------------------------------------------
+(==), (/=), (<), (<=), (>), (>=) :: Int -> Int -> Bool
+
+(==) = (P.==)
+{-# VECTORISE SCALAR (==) #-}
+
+(/=) = (P./=)
+{-# VECTORISE SCALAR (/=) #-}
+
+(<=) = (P.<=)
+{-# VECTORISE SCALAR (<=) #-}
+
+(<)  = (P.<)
+{-# VECTORISE SCALAR (<) #-}
+
+(>=) = (P.>=)
+{-# VECTORISE SCALAR (>=) #-}
+
+(>)  = (P.>)
+{-# VECTORISE SCALAR (>) #-}
+
+
+min, max :: Int -> Int -> Int
+min = P.min
+{-# VECTORISE SCALAR min #-}
+
+max = P.max
+{-# VECTORISE SCALAR max #-}
+
+
+-- Num ------------------------------------------------------------------------
 (+), (-), (*) :: Int -> Int -> Int
 
 (+) = (P.+)
@@ -30,10 +69,18 @@ import Prelude (Int)
 {-# VECTORISE SCALAR (*) #-}
 
 
--- Folds ----------------------------------------------------------------------
 sumP    :: [:Int:] -> Int
 sumP !arr       = indexPArr arr 0
 {-# NOINLINE  sumP #-}
 {-# VECTORISE sumP = sumPP_int #-}
 
 
+-- Integral -------------------------------------------------------------------
+div, mod :: Int -> Int -> Int
+
+div = P.div
+{-# VECTORISE SCALAR div #-}
+
+mod = P.mod
+{-# VECTORISE SCALAR mod #-}
+
index 5612523..f980aa5 100644 (file)
@@ -1,30 +1,41 @@
 
 -- | This is the API used by the vectoriser.
+--   The vectoriser wants a slightly different interface to the one used 
+--   natively by the library. This module performs the impedance matching.
 module Data.Array.Parallel.Prim 
         ( emptyPD#
         , replicatePD#
         , packByTagPD#
+        , combine2PD#
 
         -- * Closures
         , closure,              ($:)
         , liftedClosure,        liftedApply
         , closure1
         , closure2
-        , closure3)
+        , closure3
+        
+        -- * Selectors
+        , Sel2
+        , replicateSel2#
+        , pickSel2#
+        , tagsSel2
+        , elementsSel2_0#
+        , elementsSel2_1#)
 where
 import Data.Array.Parallel.PArray.PData.Base
 import Data.Array.Parallel.PArray.PRepr.Base
 import GHC.Exts
-import Data.Array.Parallel.Base                         (Tag)
+import Data.Array.Parallel.Base
 import qualified Data.Array.Parallel.Unlifted           as U
 
 import qualified Data.Array.Parallel.Lifted.Closure     as C
 import Data.Array.Parallel.Lifted.Closure     ((:->)(..))
 
 
-
--- Array Operators ------------------------------------------------------------
--- taking unboxed integers for the arguments.
+-- Constructors ---------------------------------------------------------------
+-- The vectoriser wants versions of these functions that take unboxed integers
+-- for some of the arguments.
 {-# INLINE emptyPD# #-}
 emptyPD# :: PA a => PData a
 emptyPD# = emptyPD
@@ -34,13 +45,11 @@ replicatePD# :: PA a => Int# -> a -> PData a
 replicatePD# r x 
         = replicatePD (I# r) x
 
-{-# INLINE packByTagPD# #-}
-packByTagPD# :: PA a => PData a -> Int# -> U.Array Tag -> Int# -> PData a
-packByTagPD# arr _ tags t
-        = packByTagPD arr tags (I# t)
-
 
 -- Closures -------------------------------------------------------------------
+-- The vectoriser wants versions of these functions that take unboxed
+-- integers for the first argument of the lifted function.
+
 -- | Construct a closure.
 {-# INLINE closure #-}
 closure :: forall a b e
@@ -123,3 +132,62 @@ closure3 fv fl
                  PArray _ pdata' -> pdata'
                 
    in   C.closure3 fv fl'
+
+
+
+-- Packing and Combining ------------------------------------------------------
+-- The vectoriser wants versions of these that take unboxed integers
+-- for some arguments.
+{-# INLINE packByTagPD# #-}
+packByTagPD# :: PA a => PData a -> Int# -> U.Array Tag -> Int# -> PData a
+packByTagPD# arr _ tags t
+        = packByTagPD arr tags (I# t)
+
+
+{-# INLINE combine2PD# #-}
+combine2PD# :: PA a => Int# -> U.Sel2 -> PData a -> PData a -> PData a
+combine2PD# _ sel pdata1 pdata2
+        = combine2PD sel pdata1 pdata2
+
+
+-- Selector functions ---------------------------------------------------------
+-- The vectoriser wants versions of these that take unboxed integers
+-- for some arguments.
+type Sel2       = U.Sel2
+
+
+{-# INLINE replicateSel2# #-}
+replicateSel2# :: Int# -> Int# -> Sel2
+replicateSel2# n# tag#
+  = U.mkSel2
+         (U.replicate n (intToTag tag))
+         (U.enumFromStepLen 0 1 n)
+         (if tag == 0 then n else 0)
+         (if tag == 0 then 0 else n)
+         (U.mkSelRep2 (U.replicate n (intToTag tag)))
+  where
+    n   = I# n#
+    tag = I# tag#
+
+
+{-# INLINE pickSel2# #-}
+pickSel2# :: Sel2 -> Int# -> U.Array Bool
+pickSel2# sel tag#
+        = U.pick (U.tagsSel2 sel) (intToTag (I# tag#))
+
+
+{-# INLINE tagsSel2 #-}
+tagsSel2 :: Sel2 -> U.Array Tag
+tagsSel2 = U.tagsSel2
+
+
+{-# INLINE elementsSel2_0# #-}
+elementsSel2_0# :: Sel2 -> Int#
+elementsSel2_0# sel
+        = case U.elementsSel2_0 sel of { I# n# -> n# }
+
+
+{-# INLINE elementsSel2_1# #-}
+elementsSel2_1# :: Sel2 -> Int#
+elementsSel2_1# sel
+        = case U.elementsSel2_1 sel of { I# n# -> n# }
index 918115e..4dc5282 100644 (file)
 -- #hide
 module Data.Array.Parallel.VectDepend () where
 
+import Data.Array.Parallel.Lifted.Closure               ()
+import Data.Array.Parallel.Lifted.Combinators           ()
 import Data.Array.Parallel.PArray.PData.Base            ()
 import Data.Array.Parallel.PArray.PData.Double          ()
 import Data.Array.Parallel.PArray.PData.Int             ()
 import Data.Array.Parallel.PArray.PData.Nested          ()
+import Data.Array.Parallel.PArray.PData.Sum2            ()
 import Data.Array.Parallel.PArray.PData.Tuple           ()
 import Data.Array.Parallel.PArray.PData.Unit            ()
 import Data.Array.Parallel.PArray.PData.Void            ()
 import Data.Array.Parallel.PArray.PData.Wrap            ()
 import Data.Array.Parallel.PArray.PData                 ()
-import Data.Array.Parallel.PArray.PRepr                 ()
 import Data.Array.Parallel.PArray.PRepr.Base            ()
+import Data.Array.Parallel.PArray.PRepr.Instances       ()
+import Data.Array.Parallel.PArray.PRepr.Nested          ()
+import Data.Array.Parallel.PArray.PRepr.Tuple           ()
+import Data.Array.Parallel.PArray.PRepr                 ()
 import Data.Array.Parallel.PArray.Scalar                ()
-import Data.Array.Parallel.Lifted.Closure               ()
-import Data.Array.Parallel.Lifted.Combinators           ()
 import Data.Array.Parallel.Prelude.Tuple                ()
 import Data.Array.Parallel.Prim                         ()
\ No newline at end of file