From e217211c6142960643e6c7e89015fe4814710a01 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Wed, 22 Jul 2020 17:38:23 +0200 Subject: [PATCH 001/813] Add data type for new operation AST --- src/Data/Array/Accelerate/AST.hs | 4 +- src/Data/Array/Accelerate/AST/Operation.hs | 416 ++++++++++++++++++ .../Array/Accelerate/Representation/Array.hs | 8 + .../Array/Accelerate/Representation/Type.hs | 4 + src/Data/Array/Accelerate/Trafo/Desugar.hs | 48 ++ 5 files changed, 477 insertions(+), 3 deletions(-) create mode 100644 src/Data/Array/Accelerate/AST/Operation.hs create mode 100644 src/Data/Array/Accelerate/Trafo/Desugar.hs diff --git a/src/Data/Array/Accelerate/AST.hs b/src/Data/Array/Accelerate/AST.hs index 92d1e0060..4995ba4fa 100644 --- a/src/Data/Array/Accelerate/AST.hs +++ b/src/Data/Array/Accelerate/AST.hs @@ -512,7 +512,7 @@ data OpenExp env aenv t where -> OpenExp env' aenv body_t -> OpenExp env aenv body_t - -- Variable index, ranging only over tuples or scalars + -- Variable index, ranging only over scalars Evar :: ExpVar env t -> OpenExp env aenv t @@ -596,7 +596,6 @@ data OpenExp env aenv t where -> OpenExp env aenv r -- Project a single scalar from an array. - -- The array expression can not contain any free scalar variables. Index :: ArrayVar aenv (Array dim t) -> OpenExp env aenv dim -> OpenExp env aenv t @@ -606,7 +605,6 @@ data OpenExp env aenv t where -> OpenExp env aenv t -- Array shape. - -- The array expression can not contain any free scalar variables. Shape :: ArrayVar aenv (Array dim e) -> OpenExp env aenv dim diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs new file mode 100644 index 000000000..28e32f976 --- /dev/null +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -0,0 +1,416 @@ +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE EmptyCase #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# OPTIONS_HADDOCK hide #-} +-- | +-- Module : Data.Array.Accelerate.AST.Operation +-- Copyright : [2008..2020] The Accelerate Team +-- License : BSD3 +-- +-- Maintainer : Trevor L. McDonell +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- + +module Data.Array.Accelerate.AST.Operation ( + PreOpenAcc(..), PreOpenAfun(..), + OperationAcc, OperationAfun, Execute(..), + + GroundR(..), GroundsR, GroundVar, GroundVars, GLeftHandSide, + + PreArgs(..), Arg(..), Args, Modifier(..), + + Exp', Fun', In, Out, Mut, + + OpenExp(..), OpenFun(..), + + PrimConst, PrimFun, PrimBool, PrimMaybe, ExpVar, ExpVars, +) where + +import Data.Array.Accelerate.AST (PrimConst, PrimFun, PrimBool, PrimMaybe, ExpVar, ExpVars, primFunType, primConstType) +import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.AST.Var +import Data.Array.Accelerate.Representation.Array +import Data.Array.Accelerate.Representation.Shape +import Data.Array.Accelerate.Representation.Slice +import Data.Array.Accelerate.Representation.Tag +import Data.Array.Accelerate.Representation.Type +import Data.Array.Accelerate.Representation.Vec +import Data.Array.Accelerate.Sugar.Foreign +import Data.Array.Accelerate.Type +import Data.Array.Accelerate.Error +import Data.Primitive.Vec + +import GHC.TypeNats + +-- | An intermediate representation consisting parameterized over executable +-- operations. This data type only consists of the control flow structure and +-- bookkeeping (allocating or copying buffers). +-- +-- The data type is parameterized over the type of executable operations. In +-- the compiler pipeline, it is first instantiated with 'Execute op', which +-- means that the Exec constructor will target a single operation. Type +-- argument op is platform dependent, such that we can have different +-- operations for each backend and thus have backend specific optimizations +-- for some combinators. For instance, some backends may have a three kernel +-- scan whereas others have a single pass scan, or we may have different +-- operations based on which atomic instructions are available on the backend. +-- +-- The data type is also parameterized over the environment of the terms, +-- consisting of ground values typed by 'GroundR', and the return type, which +-- is a tuple of ground values, typed by 'GroundsR'. +-- +data PreOpenAcc exe env a where + -- | Executes an executable operation. Such execution does not return a + -- value, the effects of the execution are only visible by the mutation of + -- buffers which were annotated with either 'Mut' or 'Out'. + -- + Exec :: exe env + -> PreOpenAcc exe env () + + -- | Returns the values of the given variables. + -- + Return :: GroundVars env a + -> PreOpenAcc exe env a + + -- | Evaluates the expression and returns its value. + -- + Compute :: OpenExp env t + -> PreOpenAcc exe env t + + -- | Local binding of ground values. + -- As it is common in this intermediate representation to evaluate some program + -- resulting in unit, for instance when execution some operation, and then + -- and then do some other code, we write 'a; b' to denote 'let () = a in b'. + Alet :: GLeftHandSide t env env' + -> PreOpenAcc exe env t + -> PreOpenAcc exe env' b + -> PreOpenAcc exe env b + + -- | Allocates a new buffer of the given size. + -- + Alloc :: ShapeR sh + -> ScalarType e + -> ExpVars env sh + -> PreOpenAcc exe env (Buffer e) + + -- | Buffer inlet. To pass an array constant in this data type, one may need + -- multiple 'Use' constructs because of the explicit Structure-of-Arrays. + -- Triggers (possibly) asynchronous host->device transfer if necessary. + -- + Use :: ScalarType e + -> Buffer e + -> PreOpenAcc exe env (Buffer e) + + -- | Capture a scalar in a singleton buffer + -- + Unit :: ExpVar env e + -> PreOpenAcc exe env (Buffer e) + + -- | Copies a buffer. This is used before passing a buffer to a 'Mut' argument, + -- to make sure it is unique. This may be removed during fusion to facilitate + -- in-place updates + -- + Clone :: ShapeR sh + -> ExpVars env sh + -> GroundVar env (Buffer e) + -> PreOpenAcc exe env (Buffer e) + + -- | If-then-else for array-level computations + -- + Acond :: ExpVar env Bool + -> PreOpenAcc exe env a + -> PreOpenAcc exe env a + -> PreOpenAcc exe env a + + -- Value-recursion for array-level computations + -- + Awhile :: PreOpenAfun exe env (arrs -> Bool) + -> PreOpenAfun exe env (arrs -> arrs) + -> PreOpenAcc exe env arrs + -> PreOpenAcc exe env arrs + +-- | Function abstraction over parametrised array computations +-- +data PreOpenAfun com env t where + Abody :: PreOpenAcc com env t -> PreOpenAfun acc env t + Alam :: GLeftHandSide a env env' -> PreOpenAfun acc env' t -> PreOpenAfun acc env (a -> t) + + +-- | Ground values are buffers or scalars. +-- +data GroundR a where + GroundRbuffer :: ScalarType e -> GroundR (Buffer e) + GroundRscalar :: ScalarType e -> GroundR e + +-- | Tuples of ground values +-- +type GroundsR = TupR GroundR + +-- | Types for local bindings +type GLeftHandSide = LeftHandSide GroundR +type GroundVar = Var GroundR +type GroundVars env = Vars GroundR env + +-- | The arguments to be passed to an operation of type `t`. +-- This type is represented as a cons list, separated by (->) and ending +-- in (). This function type represents the type of the operations. +-- `PreArgs a t` provides the arguments for function type `t`, where `a` +-- provides a single argument. +-- +data PreArgs a t where + ArgsNil :: PreArgs a () + (:>:) :: a s -> PreArgs a t -> PreArgs a (s -> t) + +-- | A single argument to an operation. +-- +data Arg env t where + ArgExp :: ExpVars env e -> Arg env (Exp' e) + + ArgMaybeExp :: Maybe (ExpVars env e) -> Arg env (Maybe (Exp' e)) + + ArgFun :: OpenFun env e -> Arg env (Fun' e) + + -- | An array is represented as scalar variables denoting the size and buffer variables. + -- We assume that all the buffer variables stored in 'ArgBuffers' have the same size, + -- as specified by the scalar variables of the size. + -- + ArgArray :: Modifier m + -> ShapeR sh + -> GroundVars env sh + -> GroundVars env (Buffers e) + -> Arg env (m sh e) + +-- | The arguments to be passed to an operation, in some environment. +-- +type Args env = PreArgs (Arg env) + +-- | Array arguments are annotated with an access modifier +-- +data Modifier m where + -- | The operation only reads from this array + In :: Modifier In + -- | The operation only writes to the array. The initial content of the array is thus irrelevant + Out :: Modifier Out + -- | The operation both reads and writes to the array. + Mut :: Modifier Mut + +-- Empty data types, which are only used for the types of 'Arg'. +data Exp' e where +data Fun' t where +data In sh e where +data Out sh e where +data Mut sh e where + +-- | Executes a single operation. Provides the operation arguments +-- from the environment. +-- +data Execute op env where + Execute :: op args -> Args env args -> Execute op env + +-- | An intermediate representation consisting of operations. This data type +-- only consists of the control flow structure and bookkeeping (allocating or +-- copying buffers). It is parameterized over the actual type of operations. +-- +type OperationAcc op = PreOpenAcc (Execute op) + +-- | Functions on an intermediate representation consisting of operations. +-- This data type only consists of the control flow structure and bookkeeping (allocating or +-- copying buffers). It is parameterized over the actual type of operations. +-- +type OperationAfun op = PreOpenAfun (Execute op) + + +-- | Vanilla open expressions using de Bruijn indices for variables ranging +-- over tuples of scalars and arrays of tuples. All code, except Cond, is +-- evaluated eagerly. N-tuples are represented as nested pairs. +-- +-- The data type is parametrised over the representation type (not the +-- surface types). The environment contains buffers and scalar values, +-- in contrary to earlier stages in the compiler which have separate +-- environments for arrays and for scalars +-- +data OpenExp env t where + + -- Local binding of a scalar expression and buffer variables + Let :: GLeftHandSide bnd_t env env' + -> OpenExp env bnd_t + -> OpenExp env' body_t + -> OpenExp env body_t + + -- Variable index, ranging only over scalars or buffers + ExpVar :: GroundVar env t + -> OpenExp env t + + -- Apply a backend-specific foreign function + Foreign :: Foreign asm + => GroundsR y + -> asm (x -> y) -- foreign function + -> OpenFun env (x -> y) -- alternate implementation (for other backends) + -> OpenExp env x + -> OpenExp env y + + -- Tuples + Pair :: OpenExp env t1 + -> OpenExp env t2 + -> OpenExp env (t1, t2) + + Nil :: OpenExp env () + + -- SIMD vectors + VecPack :: KnownNat n + => VecR n s tup + -> OpenExp env tup + -> OpenExp env (Vec n s) + + VecUnpack :: KnownNat n + => VecR n s tup + -> OpenExp env (Vec n s) + -> OpenExp env tup + + -- Array indices & shapes + IndexSlice :: SliceIndex slix sl co sh + -> OpenExp env slix + -> OpenExp env sh + -> OpenExp env sl + + IndexFull :: SliceIndex slix sl co sh + -> OpenExp env slix + -> OpenExp env sl + -> OpenExp env sh + + -- Shape and index conversion + ToIndex :: ShapeR sh + -> OpenExp env sh -- shape of the array + -> OpenExp env sh -- index into the array + -> OpenExp env Int + + FromIndex :: ShapeR sh + -> OpenExp env sh -- shape of the array + -> OpenExp env Int -- index into linear representation + -> OpenExp env sh + + -- Case statement + Case :: OpenExp env TAG + -> [(TAG, OpenExp env b)] -- list of equations + -> Maybe (OpenExp env b) -- default case + -> OpenExp env b + + -- Conditional expression (non-strict in 2nd and 3rd argument) + Cond :: OpenExp env PrimBool + -> OpenExp env t + -> OpenExp env t + -> OpenExp env t + + -- Value recursion + While :: OpenFun env (a -> PrimBool) -- continue while true + -> OpenFun env (a -> a) -- function to iterate + -> OpenExp env a -- initial value + -> OpenExp env a + + -- Constant values + Const :: ScalarType t + -> t + -> OpenExp env t + + PrimConst :: PrimConst t + -> OpenExp env t + + -- Primitive scalar operations + PrimApp :: PrimFun (a -> r) + -> OpenExp env a + -> OpenExp env r + + -- Project a single scalar from an array. + -- The array expression can not contain any free scalar variables. + LinearIndex :: GroundVar env (Buffer t) + -> OpenExp env Int + -> OpenExp env t + + -- Number of elements of an array given its shape + ShapeSize :: ShapeR dim + -> OpenExp env dim + -> OpenExp env Int + + -- Unsafe operations (may fail or result in undefined behaviour) + -- An unspecified bit pattern + Undef :: ScalarType t + -> OpenExp env t + + -- Reinterpret the bits of a value as a different type + Coerce :: BitSizeEq a b + => ScalarType a + -> ScalarType b + -> OpenExp env a + -> OpenExp env b + +-- | Vanilla open function abstraction +-- +data OpenFun env t where + Body :: OpenExp env t -> OpenFun env t + Lam :: GLeftHandSide a env env' -> OpenFun env' t -> OpenFun env (a -> t) + +class HasGroundsR f where + groundsR :: f a -> GroundsR a + +instance HasGroundsR (PreOpenAcc exe env) where + groundsR (Exec _) = TupRunit + groundsR (Return vars) = groundsR vars + groundsR (Compute e) = groundsR e + groundsR (Alet _ _ a) = groundsR a + groundsR (Alloc _ tp _) = TupRsingle $ GroundRbuffer tp + groundsR (Use tp _) = TupRsingle $ GroundRbuffer tp + groundsR (Unit (Var tp _)) = TupRsingle $ GroundRbuffer tp + groundsR (Clone _ _ var) = groundsR var + groundsR (Acond _ a _) = groundsR a + groundsR (Awhile _ _ a) = groundsR a + +instance HasGroundsR (GroundVar env) where + groundsR (Var repr _) = TupRsingle repr + +instance HasGroundsR (GroundVars env) where + groundsR = varsType + +instance HasGroundsR (OpenExp env) where + groundsR (Let _ _ e) = groundsR e + groundsR (ExpVar (Var tp _)) = TupRsingle tp + groundsR (Foreign tp _ _ _) = tp + groundsR (Pair e1 e2) = groundsR e1 `TupRpair` groundsR e2 + groundsR Nil = TupRunit + groundsR (VecPack vecR _) = TupRsingle $ GroundRscalar $ VectorScalarType $ vecRvector vecR + groundsR (VecUnpack vecR _) = typeRtoGroundsR $ vecRtuple vecR + groundsR (IndexSlice si _ _) = typeRtoGroundsR $ shapeType $ sliceShapeR si + groundsR (IndexFull si _ _) = typeRtoGroundsR $ shapeType $ sliceDomainR si + groundsR ToIndex{} = TupRsingle $ GroundRscalar scalarTypeInt + groundsR (FromIndex shr _ _) = typeRtoGroundsR $ shapeType shr + groundsR (Case _ ((_,e):_) _) = groundsR e + groundsR (Case _ [] (Just e)) = groundsR e + groundsR Case{} = internalError "empty case encountered" + groundsR (Cond _ e _) = groundsR e + groundsR (While _ (Lam lhs _) _) = lhsToTupR lhs + groundsR While{} = error "What's the matter, you're running in the shadows" + groundsR (Const tR _) = TupRsingle $ GroundRscalar tR + groundsR (PrimConst c) = TupRsingle $ GroundRscalar $ SingleScalarType $ primConstType c + groundsR (PrimApp f _) = typeRtoGroundsR $ snd $ primFunType f + groundsR (LinearIndex (Var (GroundRbuffer tp) _) _) + = TupRsingle $ GroundRscalar tp + groundsR (LinearIndex (Var (GroundRscalar tp) _) _) + = bufferImpossible tp + groundsR (ShapeSize{}) = TupRsingle $ GroundRscalar scalarTypeInt + groundsR (Undef tR) = TupRsingle $ GroundRscalar tR + groundsR (Coerce _ tR _) = TupRsingle $ GroundRscalar tR + +typeRtoGroundsR :: TypeR t -> GroundsR t +typeRtoGroundsR = mapTupR GroundRscalar + +bufferImpossible :: ScalarType (Buffer e) -> a +bufferImpossible (SingleScalarType (NumSingleType (IntegralNumType tp))) = case tp of {} +bufferImpossible (SingleScalarType (NumSingleType (FloatingNumType tp))) = case tp of {} diff --git a/src/Data/Array/Accelerate/Representation/Array.hs b/src/Data/Array/Accelerate/Representation/Array.hs index 4b28def23..960eda107 100644 --- a/src/Data/Array/Accelerate/Representation/Array.hs +++ b/src/Data/Array/Accelerate/Representation/Array.hs @@ -4,6 +4,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} {-# OPTIONS_HADDOCK hide #-} -- | -- Module : Data.Array.Accelerate.Representation.Array @@ -41,6 +42,13 @@ data Array sh e where -> ArrayData e -- array payload -> Array sh e +newtype Buffer e = Buffer (ScalarArrayData e) + +type family Buffers e where + Buffers () = () + Buffers (a, b) = (Buffers a, Buffers b) + Buffers t = t + -- | Segment descriptor (vector of segment lengths). -- -- To represent nested one-dimensional arrays, we use a flat array of data diff --git a/src/Data/Array/Accelerate/Representation/Type.hs b/src/Data/Array/Accelerate/Representation/Type.hs index f0d8d974e..11244e71d 100644 --- a/src/Data/Array/Accelerate/Representation/Type.hs +++ b/src/Data/Array/Accelerate/Representation/Type.hs @@ -116,3 +116,7 @@ runQ $ in mapM mkT [2..16] +mapTupR :: (forall s. a s -> b s) -> TupR a t -> TupR b t +mapTupR f (TupRsingle a) = TupRsingle $ f a +mapTupR _ TupRunit = TupRunit +mapTupR f (TupRpair a1 a2) = mapTupR f a1 `TupRpair` mapTupR f a2 diff --git a/src/Data/Array/Accelerate/Trafo/Desugar.hs b/src/Data/Array/Accelerate/Trafo/Desugar.hs new file mode 100644 index 000000000..4753d8226 --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/Desugar.hs @@ -0,0 +1,48 @@ +{-# LANGUAGE GADTs #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +-- | +-- Module : Data.Array.Accelerate.Trafo.Desugar +-- Copyright : [2012..2020] The Accelerate Team +-- License : BSD3 +-- +-- Maintainer : Trevor L. McDonell +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- + +module Data.Array.Accelerate.Trafo.Desugar + where + +import qualified Data.Array.Accelerate.AST as Named +import Data.Array.Accelerate.AST.Operation +import Data.Array.Accelerate.Representation.Array +import Data.Array.Accelerate.Representation.Shape +import Data.Array.Accelerate.Representation.Slice +import Data.Array.Accelerate.Representation.Tag +import Data.Array.Accelerate.Representation.Type +import Data.Array.Accelerate.Representation.Vec +import Data.Array.Accelerate.Sugar.Foreign +import Data.Array.Accelerate.Type +import Data.Array.Accelerate.Error +import Data.Primitive.Vec + +class DesugarAcc op where + +type family DesugaredArrays a where + DesugaredArrays () = () + DesugaredArrays (a, b) = (DesugaredArrays a, DesugaredArrays b) + DesugaredArrays (Array sh e) = (sh, Buffers e) + +type family DesugaredAfun a where + DesugaredAfun (a -> b) = DesugaredArrays a -> DesugaredAfun b + DesugaredAfun a = DesugaredArrays a + +desugar :: Named.Acc a -> OperationAcc (Execute op) () (DesugaredArrays a) +desugar = undefined + +desugarFun :: Named.Afun a -> OperationAcc (Execute op) () (DesugaredAfun a) +desugarFun = undefined From ada416166ad9709b49a6ee9baa74e89c0eff6e30 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Fri, 7 Aug 2020 13:25:13 +0200 Subject: [PATCH 002/813] Reuse exp type in operation AST, some desugaring The expression data type is now parameterized over the type of array instructions, which allows it to be reused in the operation ast. This prevents that we need to duplicate all the utility functions to work with expressions. This commit also adds code to desugar some array computations into the operation representation. --- accelerate.cabal | 8 +- src/Data/Array/Accelerate/AST.hs | 727 ++-------------- src/Data/Array/Accelerate/AST/Environment.hs | 41 +- src/Data/Array/Accelerate/AST/Exp.hs | 795 ++++++++++++++++++ src/Data/Array/Accelerate/AST/Idx.hs | 8 + src/Data/Array/Accelerate/AST/LeftHandSide.hs | 4 + src/Data/Array/Accelerate/AST/Operation.hs | 288 +++---- src/Data/Array/Accelerate/AST/Partitioned.hs | 30 + src/Data/Array/Accelerate/AST/Var.hs | 16 + src/Data/Array/Accelerate/Analysis/Hash.hs | 294 +------ .../Array/Accelerate/Analysis/Hash/Exp.hs | 340 ++++++++ src/Data/Array/Accelerate/Analysis/Match.hs | 61 +- src/Data/Array/Accelerate/Interpreter.hs | 10 +- src/Data/Array/Accelerate/Pretty/Graphviz.hs | 20 +- src/Data/Array/Accelerate/Pretty/Print.hs | 9 +- .../Array/Accelerate/Representation/Array.hs | 5 +- .../Array/Accelerate/Representation/Type.hs | 44 + src/Data/Array/Accelerate/Trafo.hs | 19 +- src/Data/Array/Accelerate/Trafo/Algebra.hs | 45 +- src/Data/Array/Accelerate/Trafo/Desugar.hs | 431 +++++++++- .../Array/Accelerate/Trafo/Environment.hs | 51 +- src/Data/Array/Accelerate/Trafo/Exp/Shrink.hs | 425 ++++++++++ .../Accelerate/Trafo/{ => Exp}/Simplify.hs | 153 ++-- .../Accelerate/Trafo/Exp/Substitution.hs | 522 ++++++++++++ src/Data/Array/Accelerate/Trafo/Fusion.hs | 102 +-- .../Trafo/Operation/Substitution.hs | 69 ++ src/Data/Array/Accelerate/Trafo/Sharing.hs | 19 +- src/Data/Array/Accelerate/Trafo/Shrink.hs | 367 +------- .../Array/Accelerate/Trafo/Substitution.hs | 503 ++--------- src/Data/Array/Accelerate/Trafo/Var.hs | 4 + 30 files changed, 3208 insertions(+), 2202 deletions(-) create mode 100644 src/Data/Array/Accelerate/AST/Exp.hs create mode 100644 src/Data/Array/Accelerate/AST/Partitioned.hs create mode 100644 src/Data/Array/Accelerate/Analysis/Hash/Exp.hs create mode 100644 src/Data/Array/Accelerate/Trafo/Exp/Shrink.hs rename src/Data/Array/Accelerate/Trafo/{ => Exp}/Simplify.hs (86%) create mode 100644 src/Data/Array/Accelerate/Trafo/Exp/Substitution.hs create mode 100644 src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs diff --git a/accelerate.cabal b/accelerate.cabal index ab11b296b..83d0c5908 100644 --- a/accelerate.cabal +++ b/accelerate.cabal @@ -316,10 +316,13 @@ Library -- For backend development (hidden) Data.Array.Accelerate.AST Data.Array.Accelerate.AST.Environment + Data.Array.Accelerate.AST.Exp Data.Array.Accelerate.AST.Idx Data.Array.Accelerate.AST.LeftHandSide + Data.Array.Accelerate.AST.Operation Data.Array.Accelerate.AST.Var Data.Array.Accelerate.Analysis.Hash + Data.Array.Accelerate.Analysis.Hash.Exp Data.Array.Accelerate.Analysis.Match Data.Array.Accelerate.Array.Data Data.Array.Accelerate.Array.Remote @@ -349,6 +352,9 @@ Library Data.Array.Accelerate.Trafo Data.Array.Accelerate.Trafo.Config Data.Array.Accelerate.Trafo.Delayed + Data.Array.Accelerate.Trafo.Desugar + Data.Array.Accelerate.Trafo.Exp.Shrink + Data.Array.Accelerate.Trafo.Exp.Substitution Data.Array.Accelerate.Trafo.Fusion Data.Array.Accelerate.Trafo.Sharing Data.Array.Accelerate.Trafo.Substitution @@ -402,9 +408,9 @@ Library Data.Array.Accelerate.Pretty.Print Data.Array.Accelerate.Trafo.Algebra Data.Array.Accelerate.Trafo.Environment + Data.Array.Accelerate.Trafo.Exp.Simplify Data.Array.Accelerate.Trafo.LetSplit Data.Array.Accelerate.Trafo.Shrink - Data.Array.Accelerate.Trafo.Simplify Data.Array.Accelerate.Trafo.Var Data.Atomic diff --git a/src/Data/Array/Accelerate/AST.hs b/src/Data/Array/Accelerate/AST.hs index 4995ba4fa..7c9645bfe 100644 --- a/src/Data/Array/Accelerate/AST.hs +++ b/src/Data/Array/Accelerate/AST.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} @@ -6,6 +7,7 @@ {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# OPTIONS_HADDOCK hide #-} @@ -82,8 +84,9 @@ module Data.Array.Accelerate.AST ( -- ** Scalar expressions ELeftHandSide, ExpVar, ExpVars, expVars, - Fun, OpenFun(..), - Exp, OpenExp(..), + Fun, OpenFun, PreOpenFun(..), + Exp, OpenExp, PreOpenExp(..), + ArrayInstr(..), IsArrayInstr(..), NoArrayInstr, Boundary(..), PrimConst(..), PrimFun(..), @@ -126,6 +129,7 @@ module Data.Array.Accelerate.AST ( liftPrimFun, -- ** Miscellaneous + encodeArrayVar, showPreAccOp, showExpOp, @@ -134,25 +138,23 @@ module Data.Array.Accelerate.AST ( import Data.Array.Accelerate.AST.Idx import Data.Array.Accelerate.AST.LeftHandSide import Data.Array.Accelerate.AST.Var -import Data.Array.Accelerate.Error +import Data.Array.Accelerate.AST.Exp +import Data.Array.Accelerate.Analysis.Hash.Exp import Data.Array.Accelerate.Representation.Array import Data.Array.Accelerate.Representation.Elt import Data.Array.Accelerate.Representation.Shape import Data.Array.Accelerate.Representation.Slice import Data.Array.Accelerate.Representation.Stencil -import Data.Array.Accelerate.Representation.Tag import Data.Array.Accelerate.Representation.Type -import Data.Array.Accelerate.Representation.Vec import Data.Array.Accelerate.Sugar.Foreign import Data.Array.Accelerate.Type -import Data.Primitive.Vec import Control.DeepSeq import Data.Kind import Language.Haskell.TH ( Q, TExp ) import Prelude - -import GHC.TypeLits +import Data.Typeable ( (:~:)(..) ) +import Data.ByteString.Builder.Extra -- Array expressions @@ -190,11 +192,6 @@ type ALeftHandSide = LeftHandSide ArrayR type ArrayVar = Var ArrayR type ArrayVars aenv = Vars ArrayR aenv --- Bool is not a primitive type -type PrimBool = TAG -type PrimMaybe a = (TAG, ((), a)) - - -- | Collective array computations parametrised over array variables -- represented with de Bruijn indices. -- @@ -468,34 +465,43 @@ data Boundary aenv t where -> Boundary aenv (Array sh e) --- Embedded expressions --- -------------------- +data ArrayInstr aenv f where + -- Array shape. + Shape :: ArrayVar aenv (Array dim t) -> ArrayInstr aenv (() -> dim) --- | Vanilla open function abstraction --- -data OpenFun env aenv t where - Body :: OpenExp env aenv t -> OpenFun env aenv t - Lam :: ELeftHandSide a env env' -> OpenFun env' aenv t -> OpenFun env aenv (a -> t) + -- Project a single scalar from an array. + Index :: ArrayVar aenv (Array dim t) -> ArrayInstr aenv (dim -> t) + LinearIndex :: ArrayVar aenv (Array dim t) -> ArrayInstr aenv (Int -> t) --- | Vanilla function without free scalar variables --- -type Fun = OpenFun () +instance IsArrayInstr (ArrayInstr aenv) where + arrayInstrType (Shape (Var (ArrayR shr _) _)) = shapeType shr + arrayInstrType (Index (Var (ArrayR _ tp) _)) = tp + arrayInstrType (LinearIndex (Var (ArrayR _ tp) _)) = tp --- | Vanilla expression without free scalar variables --- -type Exp = OpenExp () + liftArrayInstr (Shape var) = [|| Shape $$(liftArrayVar var) ||] + liftArrayInstr (Index var) = [|| Index $$(liftArrayVar var) ||] + liftArrayInstr (LinearIndex var) = [|| LinearIndex $$(liftArrayVar var) ||] --- Types for scalar bindings --- -type ELeftHandSide = LeftHandSide ScalarType -type ExpVar = Var ScalarType -type ExpVars env = Vars ScalarType env + rnfArrayInstr (Shape var) = rnfArrayVar var + rnfArrayInstr (Index var) = rnfArrayVar var + rnfArrayInstr (LinearIndex var) = rnfArrayVar var + + showArrayInstrOp Shape{} = "Shape" + showArrayInstrOp Index{} = "Index" + showArrayInstrOp LinearIndex{} = "LinearIndex" -expVars :: ExpVars env t -> OpenExp env aenv t -expVars TupRunit = Nil -expVars (TupRsingle var) = Evar var -expVars (TupRpair v1 v2) = expVars v1 `Pair` expVars v2 + matchArrayInstr (Shape v1) (Shape v2) | Just Refl <- matchVar v1 v2 = Just Refl + matchArrayInstr (Index v1) (Index v2) | Just Refl <- matchVar v1 v2 = Just Refl + matchArrayInstr (LinearIndex v1) (LinearIndex v2) | Just Refl <- matchVar v1 v2 = Just Refl + matchArrayInstr _ _ = Nothing + encodeArrayInstr arr = case arr of + Index a -> intHost $(hashQ "Index") <> encodeArrayVar a + LinearIndex a -> intHost $(hashQ "LinearIndex") <> encodeArrayVar a + Shape a -> intHost $(hashQ "Shape") <> encodeArrayVar a + +encodeArrayVar :: ArrayVar aenv a -> Builder +encodeArrayVar (Var repr v) = encodeArrayType repr <> encodeIdx v -- | Vanilla open expressions using de Bruijn indices for variables ranging -- over tuples of scalars and arrays of tuples. All code, except Cond, is @@ -504,234 +510,19 @@ expVars (TupRpair v1 v2) = expVars v1 `Pair` expVars v2 -- The data type is parametrised over the representation type (not the -- surface types). -- -data OpenExp env aenv t where - - -- Local binding of a scalar expression - Let :: ELeftHandSide bnd_t env env' - -> OpenExp env aenv bnd_t - -> OpenExp env' aenv body_t - -> OpenExp env aenv body_t - - -- Variable index, ranging only over scalars - Evar :: ExpVar env t - -> OpenExp env aenv t - - -- Apply a backend-specific foreign function - Foreign :: Foreign asm - => TypeR y - -> asm (x -> y) -- foreign function - -> Fun () (x -> y) -- alternate implementation (for other backends) - -> OpenExp env aenv x - -> OpenExp env aenv y - - -- Tuples - Pair :: OpenExp env aenv t1 - -> OpenExp env aenv t2 - -> OpenExp env aenv (t1, t2) - - Nil :: OpenExp env aenv () - - -- SIMD vectors - VecPack :: KnownNat n - => VecR n s tup - -> OpenExp env aenv tup - -> OpenExp env aenv (Vec n s) - - VecUnpack :: KnownNat n - => VecR n s tup - -> OpenExp env aenv (Vec n s) - -> OpenExp env aenv tup - - -- Array indices & shapes - IndexSlice :: SliceIndex slix sl co sh - -> OpenExp env aenv slix - -> OpenExp env aenv sh - -> OpenExp env aenv sl - - IndexFull :: SliceIndex slix sl co sh - -> OpenExp env aenv slix - -> OpenExp env aenv sl - -> OpenExp env aenv sh - - -- Shape and index conversion - ToIndex :: ShapeR sh - -> OpenExp env aenv sh -- shape of the array - -> OpenExp env aenv sh -- index into the array - -> OpenExp env aenv Int - - FromIndex :: ShapeR sh - -> OpenExp env aenv sh -- shape of the array - -> OpenExp env aenv Int -- index into linear representation - -> OpenExp env aenv sh - - -- Case statement - Case :: OpenExp env aenv TAG - -> [(TAG, OpenExp env aenv b)] -- list of equations - -> Maybe (OpenExp env aenv b) -- default case - -> OpenExp env aenv b - - -- Conditional expression (non-strict in 2nd and 3rd argument) - Cond :: OpenExp env aenv PrimBool - -> OpenExp env aenv t - -> OpenExp env aenv t - -> OpenExp env aenv t - - -- Value recursion - While :: OpenFun env aenv (a -> PrimBool) -- continue while true - -> OpenFun env aenv (a -> a) -- function to iterate - -> OpenExp env aenv a -- initial value - -> OpenExp env aenv a - - -- Constant values - Const :: ScalarType t - -> t - -> OpenExp env aenv t - - PrimConst :: PrimConst t - -> OpenExp env aenv t - - -- Primitive scalar operations - PrimApp :: PrimFun (a -> r) - -> OpenExp env aenv a - -> OpenExp env aenv r - - -- Project a single scalar from an array. - Index :: ArrayVar aenv (Array dim t) - -> OpenExp env aenv dim - -> OpenExp env aenv t - - LinearIndex :: ArrayVar aenv (Array dim t) - -> OpenExp env aenv Int - -> OpenExp env aenv t +type OpenExp env aenv = PreOpenExp (ArrayInstr aenv) env - -- Array shape. - Shape :: ArrayVar aenv (Array dim e) - -> OpenExp env aenv dim - - -- Number of elements of an array given its shape - ShapeSize :: ShapeR dim - -> OpenExp env aenv dim - -> OpenExp env aenv Int - - -- Unsafe operations (may fail or result in undefined behaviour) - -- An unspecified bit pattern - Undef :: ScalarType t - -> OpenExp env aenv t - - -- Reinterpret the bits of a value as a different type - Coerce :: BitSizeEq a b - => ScalarType a - -> ScalarType b - -> OpenExp env aenv a - -> OpenExp env aenv b - --- |Primitive constant values +-- | Vanilla open function abstraction -- -data PrimConst ty where - - -- constants from Bounded - PrimMinBound :: BoundedType a -> PrimConst a - PrimMaxBound :: BoundedType a -> PrimConst a +type OpenFun env aenv = PreOpenFun (ArrayInstr aenv) env - -- constant from Floating - PrimPi :: FloatingType a -> PrimConst a - - --- |Primitive scalar operations +-- | Vanilla function without free scalar variables -- -data PrimFun sig where - - -- operators from Num - PrimAdd :: NumType a -> PrimFun ((a, a) -> a) - PrimSub :: NumType a -> PrimFun ((a, a) -> a) - PrimMul :: NumType a -> PrimFun ((a, a) -> a) - PrimNeg :: NumType a -> PrimFun (a -> a) - PrimAbs :: NumType a -> PrimFun (a -> a) - PrimSig :: NumType a -> PrimFun (a -> a) - - -- operators from Integral - PrimQuot :: IntegralType a -> PrimFun ((a, a) -> a) - PrimRem :: IntegralType a -> PrimFun ((a, a) -> a) - PrimQuotRem :: IntegralType a -> PrimFun ((a, a) -> (a, a)) - PrimIDiv :: IntegralType a -> PrimFun ((a, a) -> a) - PrimMod :: IntegralType a -> PrimFun ((a, a) -> a) - PrimDivMod :: IntegralType a -> PrimFun ((a, a) -> (a, a)) - - -- operators from Bits & FiniteBits - PrimBAnd :: IntegralType a -> PrimFun ((a, a) -> a) - PrimBOr :: IntegralType a -> PrimFun ((a, a) -> a) - PrimBXor :: IntegralType a -> PrimFun ((a, a) -> a) - PrimBNot :: IntegralType a -> PrimFun (a -> a) - PrimBShiftL :: IntegralType a -> PrimFun ((a, Int) -> a) - PrimBShiftR :: IntegralType a -> PrimFun ((a, Int) -> a) - PrimBRotateL :: IntegralType a -> PrimFun ((a, Int) -> a) - PrimBRotateR :: IntegralType a -> PrimFun ((a, Int) -> a) - PrimPopCount :: IntegralType a -> PrimFun (a -> Int) - PrimCountLeadingZeros :: IntegralType a -> PrimFun (a -> Int) - PrimCountTrailingZeros :: IntegralType a -> PrimFun (a -> Int) - - -- operators from Fractional and Floating - PrimFDiv :: FloatingType a -> PrimFun ((a, a) -> a) - PrimRecip :: FloatingType a -> PrimFun (a -> a) - PrimSin :: FloatingType a -> PrimFun (a -> a) - PrimCos :: FloatingType a -> PrimFun (a -> a) - PrimTan :: FloatingType a -> PrimFun (a -> a) - PrimAsin :: FloatingType a -> PrimFun (a -> a) - PrimAcos :: FloatingType a -> PrimFun (a -> a) - PrimAtan :: FloatingType a -> PrimFun (a -> a) - PrimSinh :: FloatingType a -> PrimFun (a -> a) - PrimCosh :: FloatingType a -> PrimFun (a -> a) - PrimTanh :: FloatingType a -> PrimFun (a -> a) - PrimAsinh :: FloatingType a -> PrimFun (a -> a) - PrimAcosh :: FloatingType a -> PrimFun (a -> a) - PrimAtanh :: FloatingType a -> PrimFun (a -> a) - PrimExpFloating :: FloatingType a -> PrimFun (a -> a) - PrimSqrt :: FloatingType a -> PrimFun (a -> a) - PrimLog :: FloatingType a -> PrimFun (a -> a) - PrimFPow :: FloatingType a -> PrimFun ((a, a) -> a) - PrimLogBase :: FloatingType a -> PrimFun ((a, a) -> a) - - -- FIXME: add missing operations from RealFrac & RealFloat - - -- operators from RealFrac - PrimTruncate :: FloatingType a -> IntegralType b -> PrimFun (a -> b) - PrimRound :: FloatingType a -> IntegralType b -> PrimFun (a -> b) - PrimFloor :: FloatingType a -> IntegralType b -> PrimFun (a -> b) - PrimCeiling :: FloatingType a -> IntegralType b -> PrimFun (a -> b) - -- PrimProperFraction :: FloatingType a -> IntegralType b -> PrimFun (a -> (b, a)) - - -- operators from RealFloat - PrimAtan2 :: FloatingType a -> PrimFun ((a, a) -> a) - PrimIsNaN :: FloatingType a -> PrimFun (a -> PrimBool) - PrimIsInfinite :: FloatingType a -> PrimFun (a -> PrimBool) - - -- relational and equality operators - PrimLt :: SingleType a -> PrimFun ((a, a) -> PrimBool) - PrimGt :: SingleType a -> PrimFun ((a, a) -> PrimBool) - PrimLtEq :: SingleType a -> PrimFun ((a, a) -> PrimBool) - PrimGtEq :: SingleType a -> PrimFun ((a, a) -> PrimBool) - PrimEq :: SingleType a -> PrimFun ((a, a) -> PrimBool) - PrimNEq :: SingleType a -> PrimFun ((a, a) -> PrimBool) - PrimMax :: SingleType a -> PrimFun ((a, a) -> a) - PrimMin :: SingleType a -> PrimFun ((a, a) -> a) - - -- logical operators - -- - -- Note that these operators are strict in both arguments. That is, the - -- second argument of PrimLAnd is always evaluated even when the first - -- argument is false. - -- - -- We define (surface level) (&&) and (||) using if-then-else to enable - -- short-circuiting, while (&&!) and (||!) are strict versions of these - -- operators, which are defined using PrimLAnd and PrimLOr. - -- - PrimLAnd :: PrimFun ((PrimBool, PrimBool) -> PrimBool) - PrimLOr :: PrimFun ((PrimBool, PrimBool) -> PrimBool) - PrimLNot :: PrimFun (PrimBool -> PrimBool) +type Fun aenv = OpenFun () aenv - -- general conversion between types - PrimFromIntegral :: IntegralType a -> NumType b -> PrimFun (a -> b) - PrimToFloating :: NumType a -> FloatingType b -> PrimFun (a -> b) +-- | Vanilla expression without free scalar variables +-- +type Exp aenv = OpenExp () aenv -- Type utilities @@ -785,145 +576,6 @@ instance HasArraysR acc => HasArraysR (PreOpenAcc acc) where arraysR (Stencil2 _ _ tR _ _ a _ _) = let ArrayR sh _ = arrayR a in arraysRarray sh tR -expType :: HasCallStack => OpenExp aenv env t -> TypeR t -expType = \case - Let _ _ body -> expType body - Evar (Var tR _) -> TupRsingle tR - Foreign tR _ _ _ -> tR - Pair e1 e2 -> TupRpair (expType e1) (expType e2) - Nil -> TupRunit - VecPack vecR _ -> TupRsingle $ VectorScalarType $ vecRvector vecR - VecUnpack vecR _ -> vecRtuple vecR - IndexSlice si _ _ -> shapeType $ sliceShapeR si - IndexFull si _ _ -> shapeType $ sliceDomainR si - ToIndex{} -> TupRsingle scalarTypeInt - FromIndex shr _ _ -> shapeType shr - Case _ ((_,e):_) _ -> expType e - Case _ [] (Just e) -> expType e - Case{} -> internalError "empty case encountered" - Cond _ e _ -> expType e - While _ (Lam lhs _) _ -> lhsToTupR lhs - While{} -> error "What's the matter, you're running in the shadows" - Const tR _ -> TupRsingle tR - PrimConst c -> TupRsingle $ SingleScalarType $ primConstType c - PrimApp f _ -> snd $ primFunType f - Index (Var repr _) _ -> arrayRtype repr - LinearIndex (Var repr _) _ -> arrayRtype repr - Shape (Var repr _) -> shapeType $ arrayRshape repr - ShapeSize{} -> TupRsingle scalarTypeInt - Undef tR -> TupRsingle tR - Coerce _ tR _ -> TupRsingle tR - -primConstType :: PrimConst a -> SingleType a -primConstType = \case - PrimMinBound t -> bounded t - PrimMaxBound t -> bounded t - PrimPi t -> floating t - where - bounded :: BoundedType a -> SingleType a - bounded (IntegralBoundedType t) = NumSingleType $ IntegralNumType t - - floating :: FloatingType t -> SingleType t - floating = NumSingleType . FloatingNumType - -primFunType :: PrimFun (a -> b) -> (TypeR a, TypeR b) -primFunType = \case - -- Num - PrimAdd t -> binary' $ num t - PrimSub t -> binary' $ num t - PrimMul t -> binary' $ num t - PrimNeg t -> unary' $ num t - PrimAbs t -> unary' $ num t - PrimSig t -> unary' $ num t - - -- Integral - PrimQuot t -> binary' $ integral t - PrimRem t -> binary' $ integral t - PrimQuotRem t -> unary' $ integral t `TupRpair` integral t - PrimIDiv t -> binary' $ integral t - PrimMod t -> binary' $ integral t - PrimDivMod t -> unary' $ integral t `TupRpair` integral t - - -- Bits & FiniteBits - PrimBAnd t -> binary' $ integral t - PrimBOr t -> binary' $ integral t - PrimBXor t -> binary' $ integral t - PrimBNot t -> unary' $ integral t - PrimBShiftL t -> (integral t `TupRpair` int, integral t) - PrimBShiftR t -> (integral t `TupRpair` int, integral t) - PrimBRotateL t -> (integral t `TupRpair` int, integral t) - PrimBRotateR t -> (integral t `TupRpair` int, integral t) - PrimPopCount t -> unary (integral t) int - PrimCountLeadingZeros t -> unary (integral t) int - PrimCountTrailingZeros t -> unary (integral t) int - - -- Fractional, Floating - PrimFDiv t -> binary' $ floating t - PrimRecip t -> unary' $ floating t - PrimSin t -> unary' $ floating t - PrimCos t -> unary' $ floating t - PrimTan t -> unary' $ floating t - PrimAsin t -> unary' $ floating t - PrimAcos t -> unary' $ floating t - PrimAtan t -> unary' $ floating t - PrimSinh t -> unary' $ floating t - PrimCosh t -> unary' $ floating t - PrimTanh t -> unary' $ floating t - PrimAsinh t -> unary' $ floating t - PrimAcosh t -> unary' $ floating t - PrimAtanh t -> unary' $ floating t - PrimExpFloating t -> unary' $ floating t - PrimSqrt t -> unary' $ floating t - PrimLog t -> unary' $ floating t - PrimFPow t -> binary' $ floating t - PrimLogBase t -> binary' $ floating t - - -- RealFrac - PrimTruncate a b -> unary (floating a) (integral b) - PrimRound a b -> unary (floating a) (integral b) - PrimFloor a b -> unary (floating a) (integral b) - PrimCeiling a b -> unary (floating a) (integral b) - - -- RealFloat - PrimAtan2 t -> binary' $ floating t - PrimIsNaN t -> unary (floating t) bool - PrimIsInfinite t -> unary (floating t) bool - - -- Relational and equality - PrimLt t -> compare' t - PrimGt t -> compare' t - PrimLtEq t -> compare' t - PrimGtEq t -> compare' t - PrimEq t -> compare' t - PrimNEq t -> compare' t - PrimMax t -> binary' $ single t - PrimMin t -> binary' $ single t - - -- Logical - PrimLAnd -> binary' bool - PrimLOr -> binary' bool - PrimLNot -> unary' bool - - -- general conversion between types - PrimFromIntegral a b -> unary (integral a) (num b) - PrimToFloating a b -> unary (num a) (floating b) - - where - unary a b = (a, b) - unary' a = unary a a - binary a b = (a `TupRpair` a, b) - binary' a = binary a a - compare' a = binary (single a) bool - - single = TupRsingle . SingleScalarType - num = TupRsingle . SingleScalarType . NumSingleType - integral = num . IntegralNumType - floating = num . FloatingNumType - - bool = TupRsingle scalarTypeWord8 - int = TupRsingle scalarTypeInt - - -- Normal form data -- ================ @@ -1016,135 +668,6 @@ rnfBoundary _ Wrap = () rnfBoundary (ArrayR _ tR) (Constant c) = rnfConst tR c rnfBoundary _ (Function f) = rnfOpenFun f -rnfMaybe :: (a -> ()) -> Maybe a -> () -rnfMaybe _ Nothing = () -rnfMaybe f (Just x) = f x - -rnfList :: (a -> ()) -> [a] -> () -rnfList r = go - where - go [] = () - go (x:xs) = r x `seq` go xs - -rnfOpenFun :: OpenFun env aenv t -> () -rnfOpenFun (Body b) = rnfOpenExp b -rnfOpenFun (Lam lhs f) = rnfELeftHandSide lhs `seq` rnfOpenFun f - -rnfOpenExp :: forall env aenv t. OpenExp env aenv t -> () -rnfOpenExp topExp = - let - rnfF :: OpenFun env' aenv' t' -> () - rnfF = rnfOpenFun - - rnfE :: OpenExp env' aenv' t' -> () - rnfE = rnfOpenExp - in - case topExp of - Let lhs bnd body -> rnfELeftHandSide lhs `seq` rnfE bnd `seq` rnfE body - Evar v -> rnfExpVar v - Foreign tp asm f x -> rnfTypeR tp `seq` rnf (strForeign asm) `seq` rnfF f `seq` rnfE x - Const tp c -> c `seq` rnfScalarType tp -- scalars should have (nf == whnf) - Undef tp -> rnfScalarType tp - Pair a b -> rnfE a `seq` rnfE b - Nil -> () - VecPack vecr e -> rnfVecR vecr `seq` rnfE e - VecUnpack vecr e -> rnfVecR vecr `seq` rnfE e - IndexSlice slice slix sh -> rnfSliceIndex slice `seq` rnfE slix `seq` rnfE sh - IndexFull slice slix sl -> rnfSliceIndex slice `seq` rnfE slix `seq` rnfE sl - ToIndex shr sh ix -> rnfShapeR shr `seq` rnfE sh `seq` rnfE ix - FromIndex shr sh ix -> rnfShapeR shr `seq` rnfE sh `seq` rnfE ix - Case e rhs def -> rnfE e `seq` rnfList (\(t,c) -> t `seq` rnfE c) rhs `seq` rnfMaybe rnfE def - Cond p e1 e2 -> rnfE p `seq` rnfE e1 `seq` rnfE e2 - While p f x -> rnfF p `seq` rnfF f `seq` rnfE x - PrimConst c -> rnfPrimConst c - PrimApp f x -> rnfPrimFun f `seq` rnfE x - Index a ix -> rnfArrayVar a `seq` rnfE ix - LinearIndex a ix -> rnfArrayVar a `seq` rnfE ix - Shape a -> rnfArrayVar a - ShapeSize shr sh -> rnfShapeR shr `seq` rnfE sh - Coerce t1 t2 e -> rnfScalarType t1 `seq` rnfScalarType t2 `seq` rnfE e - -rnfExpVar :: ExpVar env t -> () -rnfExpVar = rnfVar rnfScalarType - -rnfELeftHandSide :: ELeftHandSide t env env' -> () -rnfELeftHandSide= rnfLeftHandSide rnfScalarType - -rnfConst :: TypeR t -> t -> () -rnfConst TupRunit () = () -rnfConst (TupRsingle t) !_ = rnfScalarType t -- scalars should have (nf == whnf) -rnfConst (TupRpair ta tb) (a,b) = rnfConst ta a `seq` rnfConst tb b - -rnfPrimConst :: PrimConst c -> () -rnfPrimConst (PrimMinBound t) = rnfBoundedType t -rnfPrimConst (PrimMaxBound t) = rnfBoundedType t -rnfPrimConst (PrimPi t) = rnfFloatingType t - -rnfPrimFun :: PrimFun f -> () -rnfPrimFun (PrimAdd t) = rnfNumType t -rnfPrimFun (PrimSub t) = rnfNumType t -rnfPrimFun (PrimMul t) = rnfNumType t -rnfPrimFun (PrimNeg t) = rnfNumType t -rnfPrimFun (PrimAbs t) = rnfNumType t -rnfPrimFun (PrimSig t) = rnfNumType t -rnfPrimFun (PrimQuot t) = rnfIntegralType t -rnfPrimFun (PrimRem t) = rnfIntegralType t -rnfPrimFun (PrimQuotRem t) = rnfIntegralType t -rnfPrimFun (PrimIDiv t) = rnfIntegralType t -rnfPrimFun (PrimMod t) = rnfIntegralType t -rnfPrimFun (PrimDivMod t) = rnfIntegralType t -rnfPrimFun (PrimBAnd t) = rnfIntegralType t -rnfPrimFun (PrimBOr t) = rnfIntegralType t -rnfPrimFun (PrimBXor t) = rnfIntegralType t -rnfPrimFun (PrimBNot t) = rnfIntegralType t -rnfPrimFun (PrimBShiftL t) = rnfIntegralType t -rnfPrimFun (PrimBShiftR t) = rnfIntegralType t -rnfPrimFun (PrimBRotateL t) = rnfIntegralType t -rnfPrimFun (PrimBRotateR t) = rnfIntegralType t -rnfPrimFun (PrimPopCount t) = rnfIntegralType t -rnfPrimFun (PrimCountLeadingZeros t) = rnfIntegralType t -rnfPrimFun (PrimCountTrailingZeros t) = rnfIntegralType t -rnfPrimFun (PrimFDiv t) = rnfFloatingType t -rnfPrimFun (PrimRecip t) = rnfFloatingType t -rnfPrimFun (PrimSin t) = rnfFloatingType t -rnfPrimFun (PrimCos t) = rnfFloatingType t -rnfPrimFun (PrimTan t) = rnfFloatingType t -rnfPrimFun (PrimAsin t) = rnfFloatingType t -rnfPrimFun (PrimAcos t) = rnfFloatingType t -rnfPrimFun (PrimAtan t) = rnfFloatingType t -rnfPrimFun (PrimSinh t) = rnfFloatingType t -rnfPrimFun (PrimCosh t) = rnfFloatingType t -rnfPrimFun (PrimTanh t) = rnfFloatingType t -rnfPrimFun (PrimAsinh t) = rnfFloatingType t -rnfPrimFun (PrimAcosh t) = rnfFloatingType t -rnfPrimFun (PrimAtanh t) = rnfFloatingType t -rnfPrimFun (PrimExpFloating t) = rnfFloatingType t -rnfPrimFun (PrimSqrt t) = rnfFloatingType t -rnfPrimFun (PrimLog t) = rnfFloatingType t -rnfPrimFun (PrimFPow t) = rnfFloatingType t -rnfPrimFun (PrimLogBase t) = rnfFloatingType t -rnfPrimFun (PrimTruncate f i) = rnfFloatingType f `seq` rnfIntegralType i -rnfPrimFun (PrimRound f i) = rnfFloatingType f `seq` rnfIntegralType i -rnfPrimFun (PrimFloor f i) = rnfFloatingType f `seq` rnfIntegralType i -rnfPrimFun (PrimCeiling f i) = rnfFloatingType f `seq` rnfIntegralType i -rnfPrimFun (PrimIsNaN t) = rnfFloatingType t -rnfPrimFun (PrimIsInfinite t) = rnfFloatingType t -rnfPrimFun (PrimAtan2 t) = rnfFloatingType t -rnfPrimFun (PrimLt t) = rnfSingleType t -rnfPrimFun (PrimGt t) = rnfSingleType t -rnfPrimFun (PrimLtEq t) = rnfSingleType t -rnfPrimFun (PrimGtEq t) = rnfSingleType t -rnfPrimFun (PrimEq t) = rnfSingleType t -rnfPrimFun (PrimNEq t) = rnfSingleType t -rnfPrimFun (PrimMax t) = rnfSingleType t -rnfPrimFun (PrimMin t) = rnfSingleType t -rnfPrimFun PrimLAnd = () -rnfPrimFun PrimLOr = () -rnfPrimFun PrimLNot = () -rnfPrimFun (PrimFromIntegral i n) = rnfIntegralType i `seq` rnfNumType n -rnfPrimFun (PrimToFloating n f) = rnfNumType n `seq` rnfFloatingType f - - -- Template Haskell -- ================ @@ -1222,63 +745,6 @@ liftDirection :: Direction -> Q (TExp Direction) liftDirection LeftToRight = [|| LeftToRight ||] liftDirection RightToLeft = [|| RightToLeft ||] -liftMaybe :: (a -> Q (TExp a)) -> Maybe a -> Q (TExp (Maybe a)) -liftMaybe _ Nothing = [|| Nothing ||] -liftMaybe f (Just x) = [|| Just $$(f x) ||] - -liftList :: (a -> Q (TExp a)) -> [a] -> Q (TExp [a]) -liftList _ [] = [|| [] ||] -liftList f (x:xs) = [|| $$(f x) : $$(liftList f xs) ||] - -liftOpenFun - :: OpenFun env aenv t - -> Q (TExp (OpenFun env aenv t)) -liftOpenFun (Lam lhs f) = [|| Lam $$(liftELeftHandSide lhs) $$(liftOpenFun f) ||] -liftOpenFun (Body b) = [|| Body $$(liftOpenExp b) ||] - -liftOpenExp - :: forall env aenv t. - OpenExp env aenv t - -> Q (TExp (OpenExp env aenv t)) -liftOpenExp pexp = - let - liftE :: OpenExp env aenv e -> Q (TExp (OpenExp env aenv e)) - liftE = liftOpenExp - - liftF :: OpenFun env aenv f -> Q (TExp (OpenFun env aenv f)) - liftF = liftOpenFun - in - case pexp of - Let lhs bnd body -> [|| Let $$(liftELeftHandSide lhs) $$(liftOpenExp bnd) $$(liftOpenExp body) ||] - Evar var -> [|| Evar $$(liftExpVar var) ||] - Foreign repr asm f x -> [|| Foreign $$(liftTypeR repr) $$(liftForeign asm) $$(liftOpenFun f) $$(liftE x) ||] - Const tp c -> [|| Const $$(liftScalarType tp) $$(liftElt (TupRsingle tp) c) ||] - Undef tp -> [|| Undef $$(liftScalarType tp) ||] - Pair a b -> [|| Pair $$(liftE a) $$(liftE b) ||] - Nil -> [|| Nil ||] - VecPack vecr e -> [|| VecPack $$(liftVecR vecr) $$(liftE e) ||] - VecUnpack vecr e -> [|| VecUnpack $$(liftVecR vecr) $$(liftE e) ||] - IndexSlice slice slix sh -> [|| IndexSlice $$(liftSliceIndex slice) $$(liftE slix) $$(liftE sh) ||] - IndexFull slice slix sl -> [|| IndexFull $$(liftSliceIndex slice) $$(liftE slix) $$(liftE sl) ||] - ToIndex shr sh ix -> [|| ToIndex $$(liftShapeR shr) $$(liftE sh) $$(liftE ix) ||] - FromIndex shr sh ix -> [|| FromIndex $$(liftShapeR shr) $$(liftE sh) $$(liftE ix) ||] - Case p rhs def -> [|| Case $$(liftE p) $$(liftList (\(t,c) -> [|| (t, $$(liftE c)) ||]) rhs) $$(liftMaybe liftE def) ||] - Cond p t e -> [|| Cond $$(liftE p) $$(liftE t) $$(liftE e) ||] - While p f x -> [|| While $$(liftF p) $$(liftF f) $$(liftE x) ||] - PrimConst t -> [|| PrimConst $$(liftPrimConst t) ||] - PrimApp f x -> [|| PrimApp $$(liftPrimFun f) $$(liftE x) ||] - Index a ix -> [|| Index $$(liftArrayVar a) $$(liftE ix) ||] - LinearIndex a ix -> [|| LinearIndex $$(liftArrayVar a) $$(liftE ix) ||] - Shape a -> [|| Shape $$(liftArrayVar a) ||] - ShapeSize shr ix -> [|| ShapeSize $$(liftShapeR shr) $$(liftE ix) ||] - Coerce t1 t2 e -> [|| Coerce $$(liftScalarType t1) $$(liftScalarType t2) $$(liftE e) ||] - -liftELeftHandSide :: ELeftHandSide t env env' -> Q (TExp (ELeftHandSide t env env')) -liftELeftHandSide = liftLeftHandSide liftScalarType - -liftExpVar :: ExpVar env t -> Q (TExp (ExpVar env t)) -liftExpVar = liftVar liftScalarType - liftBoundary :: forall aenv sh e. ArrayR (Array sh e) @@ -1290,75 +756,6 @@ liftBoundary _ Wrap = [|| Wrap ||] liftBoundary (ArrayR _ tp) (Constant v) = [|| Constant $$(liftElt tp v) ||] liftBoundary _ (Function f) = [|| Function $$(liftOpenFun f) ||] -liftPrimConst :: PrimConst c -> Q (TExp (PrimConst c)) -liftPrimConst (PrimMinBound t) = [|| PrimMinBound $$(liftBoundedType t) ||] -liftPrimConst (PrimMaxBound t) = [|| PrimMaxBound $$(liftBoundedType t) ||] -liftPrimConst (PrimPi t) = [|| PrimPi $$(liftFloatingType t) ||] - -liftPrimFun :: PrimFun f -> Q (TExp (PrimFun f)) -liftPrimFun (PrimAdd t) = [|| PrimAdd $$(liftNumType t) ||] -liftPrimFun (PrimSub t) = [|| PrimSub $$(liftNumType t) ||] -liftPrimFun (PrimMul t) = [|| PrimMul $$(liftNumType t) ||] -liftPrimFun (PrimNeg t) = [|| PrimNeg $$(liftNumType t) ||] -liftPrimFun (PrimAbs t) = [|| PrimAbs $$(liftNumType t) ||] -liftPrimFun (PrimSig t) = [|| PrimSig $$(liftNumType t) ||] -liftPrimFun (PrimQuot t) = [|| PrimQuot $$(liftIntegralType t) ||] -liftPrimFun (PrimRem t) = [|| PrimRem $$(liftIntegralType t) ||] -liftPrimFun (PrimQuotRem t) = [|| PrimQuotRem $$(liftIntegralType t) ||] -liftPrimFun (PrimIDiv t) = [|| PrimIDiv $$(liftIntegralType t) ||] -liftPrimFun (PrimMod t) = [|| PrimMod $$(liftIntegralType t) ||] -liftPrimFun (PrimDivMod t) = [|| PrimDivMod $$(liftIntegralType t) ||] -liftPrimFun (PrimBAnd t) = [|| PrimBAnd $$(liftIntegralType t) ||] -liftPrimFun (PrimBOr t) = [|| PrimBOr $$(liftIntegralType t) ||] -liftPrimFun (PrimBXor t) = [|| PrimBXor $$(liftIntegralType t) ||] -liftPrimFun (PrimBNot t) = [|| PrimBNot $$(liftIntegralType t) ||] -liftPrimFun (PrimBShiftL t) = [|| PrimBShiftL $$(liftIntegralType t) ||] -liftPrimFun (PrimBShiftR t) = [|| PrimBShiftR $$(liftIntegralType t) ||] -liftPrimFun (PrimBRotateL t) = [|| PrimBRotateL $$(liftIntegralType t) ||] -liftPrimFun (PrimBRotateR t) = [|| PrimBRotateR $$(liftIntegralType t) ||] -liftPrimFun (PrimPopCount t) = [|| PrimPopCount $$(liftIntegralType t) ||] -liftPrimFun (PrimCountLeadingZeros t) = [|| PrimCountLeadingZeros $$(liftIntegralType t) ||] -liftPrimFun (PrimCountTrailingZeros t) = [|| PrimCountTrailingZeros $$(liftIntegralType t) ||] -liftPrimFun (PrimFDiv t) = [|| PrimFDiv $$(liftFloatingType t) ||] -liftPrimFun (PrimRecip t) = [|| PrimRecip $$(liftFloatingType t) ||] -liftPrimFun (PrimSin t) = [|| PrimSin $$(liftFloatingType t) ||] -liftPrimFun (PrimCos t) = [|| PrimCos $$(liftFloatingType t) ||] -liftPrimFun (PrimTan t) = [|| PrimTan $$(liftFloatingType t) ||] -liftPrimFun (PrimAsin t) = [|| PrimAsin $$(liftFloatingType t) ||] -liftPrimFun (PrimAcos t) = [|| PrimAcos $$(liftFloatingType t) ||] -liftPrimFun (PrimAtan t) = [|| PrimAtan $$(liftFloatingType t) ||] -liftPrimFun (PrimSinh t) = [|| PrimSinh $$(liftFloatingType t) ||] -liftPrimFun (PrimCosh t) = [|| PrimCosh $$(liftFloatingType t) ||] -liftPrimFun (PrimTanh t) = [|| PrimTanh $$(liftFloatingType t) ||] -liftPrimFun (PrimAsinh t) = [|| PrimAsinh $$(liftFloatingType t) ||] -liftPrimFun (PrimAcosh t) = [|| PrimAcosh $$(liftFloatingType t) ||] -liftPrimFun (PrimAtanh t) = [|| PrimAtanh $$(liftFloatingType t) ||] -liftPrimFun (PrimExpFloating t) = [|| PrimExpFloating $$(liftFloatingType t) ||] -liftPrimFun (PrimSqrt t) = [|| PrimSqrt $$(liftFloatingType t) ||] -liftPrimFun (PrimLog t) = [|| PrimLog $$(liftFloatingType t) ||] -liftPrimFun (PrimFPow t) = [|| PrimFPow $$(liftFloatingType t) ||] -liftPrimFun (PrimLogBase t) = [|| PrimLogBase $$(liftFloatingType t) ||] -liftPrimFun (PrimTruncate ta tb) = [|| PrimTruncate $$(liftFloatingType ta) $$(liftIntegralType tb) ||] -liftPrimFun (PrimRound ta tb) = [|| PrimRound $$(liftFloatingType ta) $$(liftIntegralType tb) ||] -liftPrimFun (PrimFloor ta tb) = [|| PrimFloor $$(liftFloatingType ta) $$(liftIntegralType tb) ||] -liftPrimFun (PrimCeiling ta tb) = [|| PrimCeiling $$(liftFloatingType ta) $$(liftIntegralType tb) ||] -liftPrimFun (PrimIsNaN t) = [|| PrimIsNaN $$(liftFloatingType t) ||] -liftPrimFun (PrimIsInfinite t) = [|| PrimIsInfinite $$(liftFloatingType t) ||] -liftPrimFun (PrimAtan2 t) = [|| PrimAtan2 $$(liftFloatingType t) ||] -liftPrimFun (PrimLt t) = [|| PrimLt $$(liftSingleType t) ||] -liftPrimFun (PrimGt t) = [|| PrimGt $$(liftSingleType t) ||] -liftPrimFun (PrimLtEq t) = [|| PrimLtEq $$(liftSingleType t) ||] -liftPrimFun (PrimGtEq t) = [|| PrimGtEq $$(liftSingleType t) ||] -liftPrimFun (PrimEq t) = [|| PrimEq $$(liftSingleType t) ||] -liftPrimFun (PrimNEq t) = [|| PrimNEq $$(liftSingleType t) ||] -liftPrimFun (PrimMax t) = [|| PrimMax $$(liftSingleType t) ||] -liftPrimFun (PrimMin t) = [|| PrimMin $$(liftSingleType t) ||] -liftPrimFun PrimLAnd = [|| PrimLAnd ||] -liftPrimFun PrimLOr = [|| PrimLOr ||] -liftPrimFun PrimLNot = [|| PrimLNot ||] -liftPrimFun (PrimFromIntegral ta tb) = [|| PrimFromIntegral $$(liftIntegralType ta) $$(liftNumType tb) ||] -liftPrimFun (PrimToFloating ta tb) = [|| PrimToFloating $$(liftNumType ta) $$(liftFloatingType tb) ||] - showPreAccOp :: forall acc aenv arrs. PreOpenAcc acc aenv arrs -> String showPreAccOp Alet{} = "Alet" @@ -1390,29 +787,3 @@ showPreAccOp Stencil2{} = "Stencil2" showsDirection :: Direction -> ShowS showsDirection LeftToRight = ('l':) showsDirection RightToLeft = ('r':) - -showExpOp :: forall aenv env t. OpenExp aenv env t -> String -showExpOp Let{} = "Let" -showExpOp (Evar (Var _ ix)) = "Var x" ++ show (idxToInt ix) -showExpOp (Const tp c) = "Const " ++ showElt (TupRsingle tp) c -showExpOp Undef{} = "Undef" -showExpOp Foreign{} = "Foreign" -showExpOp Pair{} = "Pair" -showExpOp Nil{} = "Nil" -showExpOp VecPack{} = "VecPack" -showExpOp VecUnpack{} = "VecUnpack" -showExpOp IndexSlice{} = "IndexSlice" -showExpOp IndexFull{} = "IndexFull" -showExpOp ToIndex{} = "ToIndex" -showExpOp FromIndex{} = "FromIndex" -showExpOp Case{} = "Case" -showExpOp Cond{} = "Cond" -showExpOp While{} = "While" -showExpOp PrimConst{} = "PrimConst" -showExpOp PrimApp{} = "PrimApp" -showExpOp Index{} = "Index" -showExpOp LinearIndex{} = "LinearIndex" -showExpOp Shape{} = "Shape" -showExpOp ShapeSize{} = "ShapeSize" -showExpOp Coerce{} = "Coerce" - diff --git a/src/Data/Array/Accelerate/AST/Environment.hs b/src/Data/Array/Accelerate/AST/Environment.hs index 78c296d98..009753bc4 100644 --- a/src/Data/Array/Accelerate/AST/Environment.hs +++ b/src/Data/Array/Accelerate/AST/Environment.hs @@ -3,6 +3,7 @@ {-# LANGUAGE LambdaCase #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeOperators #-} {-# OPTIONS_HADDOCK hide #-} -- | @@ -21,27 +22,55 @@ module Data.Array.Accelerate.AST.Environment import Data.Array.Accelerate.AST.Idx import Data.Array.Accelerate.AST.LeftHandSide import Data.Array.Accelerate.Error +import Data.Array.Accelerate.Representation.Type +import Data.Array.Accelerate.Analysis.Match ((:~:)(..)) -- Valuation for an environment -- -data Val env where - Empty :: Val () - Push :: Val env -> t -> Val (env, t) +data Env f env where + Empty :: Env f () + Push :: Env f env -> f t -> Env f (env, t) + +type Val = Env Identity -- Push a set of variables into an environment -- push :: Val env -> (LeftHandSide s t env env', t) -> Val env' push env (LeftHandSideWildcard _, _ ) = env -push env (LeftHandSideSingle _ , a ) = env `Push` a +push env (LeftHandSideSingle _ , a ) = env `Push` Identity a push env (LeftHandSidePair l1 l2, (a, b)) = push env (l1, a) `push` (l2, b) +push' :: forall f s t env env'. Distributes s => Env f env -> (LeftHandSide s t env env', Distribute f t) -> Env f env' +push' env (LeftHandSideWildcard _, _ ) = env +push' env (LeftHandSidePair l1 l2, (a, b)) = push' env (l1, a) `push'` (l2, b) +push' env (LeftHandSideSingle s , a ) + | Refl <- reprIsSingle @s @t @f s = env `Push` a + -- Projection of a value from a valuation using a de Bruijn index -- prj :: Idx env t -> Val env -> t -prj ZeroIdx (Push _ v) = v -prj (SuccIdx idx) (Push val _) = prj idx val +prj ix v = runIdentity $ prj' ix v + +prj' :: Idx env t -> Env f env -> f t +prj' ZeroIdx (Push _ v) = v +prj' (SuccIdx idx) (Push val _) = prj' idx val + +mapEnv :: (forall t. a t -> b t) -> Env a env -> Env b env +mapEnv _ Empty = Empty +mapEnv g (Push env f) = Push (mapEnv g env) (g f) + +data Identity a = Identity { runIdentity :: a } + +instance Functor Identity where + {-# INLINE fmap #-} + fmap f (Identity a) = Identity (f a) +instance Applicative Identity where + {-# INLINE (<*>) #-} + {-# INLINE pure #-} + Identity f <*> Identity a = Identity (f a) + pure a = Identity a -- The type of shifting terms from one context into another -- diff --git a/src/Data/Array/Accelerate/AST/Exp.hs b/src/Data/Array/Accelerate/AST/Exp.hs new file mode 100644 index 000000000..509589902 --- /dev/null +++ b/src/Data/Array/Accelerate/AST/Exp.hs @@ -0,0 +1,795 @@ +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE EmptyCase #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# OPTIONS_HADDOCK hide #-} +-- | +-- Module : Data.Array.Accelerate.AST.Exp +-- Copyright : [2008..2020] The Accelerate Team +-- License : BSD3 +-- +-- Maintainer : Trevor L. McDonell +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- + +module Data.Array.Accelerate.AST.Exp ( + -- ** Scalar expressions + ELeftHandSide, ExpVar, ExpVars, expVars, + PreOpenFun(..), + PreOpenExp(..), + PrimConst(..), + PrimFun(..), + PrimBool, + PrimMaybe, + TAG, + IsArrayInstr(..), + NoArrayInstr, + + -- ** Extracting type information + expType, + primConstType, + primFunType, + + -- ** Normal-form + rnfOpenFun, + rnfOpenExp, + rnfConst, + rnfPrimConst, + rnfPrimFun, + rnfMaybe, + rnfELeftHandSide, + rnfExpVar, + + -- ** Template Haskell + liftOpenFun, + liftOpenExp, + liftMaybe, + liftELeftHandSide, + liftExpVar, + liftPrimConst, + liftPrimFun, + + -- ** Miscellaneous + mkConstant, mkBinary, unBody, + showExpOp, + +) where + +import Data.Array.Accelerate.AST.Idx +import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.AST.Var +import Data.Array.Accelerate.Error +import Data.Array.Accelerate.Representation.Elt +import Data.Array.Accelerate.Representation.Shape +import Data.Array.Accelerate.Representation.Slice +import Data.Array.Accelerate.Representation.Tag +import Data.Array.Accelerate.Representation.Type +import Data.Array.Accelerate.Representation.Vec +import Data.Array.Accelerate.Sugar.Foreign +import Data.Array.Accelerate.Type +import Data.Primitive.Vec +import Data.Typeable ( (:~:) ) +import Data.ByteString.Builder ( Builder ) + +import Control.DeepSeq +import Language.Haskell.TH ( Q, TExp ) +import Prelude + +import GHC.TypeLits + + +-- Bool is not a primitive type +type PrimBool = TAG +type PrimMaybe a = (TAG, ((), a)) + +-- Embedded expressions +-- -------------------- + +-- | Vanilla open function abstraction parameterized over array instructions +-- +data PreOpenFun arr env t where + Body :: PreOpenExp arr env t -> PreOpenFun arr env t + Lam :: ELeftHandSide a env env' -> PreOpenFun arr env' t -> PreOpenFun arr env (a -> t) + +-- | Vanilla open expressions using de Bruijn indices for variables ranging +-- over tuples of scalars and arrays of tuples. All code, except Cond, is +-- evaluated eagerly. N-tuples are represented as nested pairs. +-- +-- It is parametrised over the type of array instructions, 'arr'. +-- +-- The data type is parametrised over the representation type (not the +-- surface types). +-- +data PreOpenExp arr env t where + + -- Local binding of a scalar expression + Let :: ELeftHandSide bnd_t env env' + -> PreOpenExp arr env bnd_t + -> PreOpenExp arr env' body_t + -> PreOpenExp arr env body_t + + -- Variable index, ranging only over scalars + Evar :: ExpVar env t + -> PreOpenExp arr env t + + -- Apply a backend-specific foreign function + Foreign :: Foreign asm + => TypeR y + -> asm (x -> y) -- foreign function + -> PreOpenFun NoArrayInstr () (x -> y) -- alternate implementation (for other backends) + -> PreOpenExp arr env x + -> PreOpenExp arr env y + + -- Tuples + Pair :: PreOpenExp arr env t1 + -> PreOpenExp arr env t2 + -> PreOpenExp arr env (t1, t2) + + Nil :: PreOpenExp arr env () + + -- SIMD vectors + VecPack :: KnownNat n + => VecR n s tup + -> PreOpenExp arr env tup + -> PreOpenExp arr env (Vec n s) + + VecUnpack :: KnownNat n + => VecR n s tup + -> PreOpenExp arr env (Vec n s) + -> PreOpenExp arr env tup + + -- Array indices & shapes + IndexSlice :: SliceIndex slix sl co sh + -> PreOpenExp arr env slix + -> PreOpenExp arr env sh + -> PreOpenExp arr env sl + + IndexFull :: SliceIndex slix sl co sh + -> PreOpenExp arr env slix + -> PreOpenExp arr env sl + -> PreOpenExp arr env sh + + -- Shape and index conversion + ToIndex :: ShapeR sh + -> PreOpenExp arr env sh -- shape of the array + -> PreOpenExp arr env sh -- index into the array + -> PreOpenExp arr env Int + + FromIndex :: ShapeR sh + -> PreOpenExp arr env sh -- shape of the array + -> PreOpenExp arr env Int -- index into linear representation + -> PreOpenExp arr env sh + + -- Case statement + Case :: PreOpenExp arr env TAG + -> [(TAG, PreOpenExp arr env b)] -- list of equations + -> Maybe (PreOpenExp arr env b) -- default case + -> PreOpenExp arr env b + + -- Conditional expression (non-strict in 2nd and 3rd argument) + Cond :: PreOpenExp arr env PrimBool + -> PreOpenExp arr env t + -> PreOpenExp arr env t + -> PreOpenExp arr env t + + -- Value recursion + While :: PreOpenFun arr env (a -> PrimBool) -- continue while true + -> PreOpenFun arr env (a -> a) -- function to iterate + -> PreOpenExp arr env a -- initial value + -> PreOpenExp arr env a + + -- Constant values + Const :: ScalarType t + -> t + -> PreOpenExp arr env t + + PrimConst :: PrimConst t + -> PreOpenExp arr env t + + -- Primitive scalar operations + PrimApp :: PrimFun (a -> r) + -> PreOpenExp arr env a + -> PreOpenExp arr env r + + ArrayInstr :: arr (a -> b) + -> PreOpenExp arr env a + -> PreOpenExp arr env b + + -- Number of elements of an array given its shape + ShapeSize :: ShapeR dim + -> PreOpenExp arr env dim + -> PreOpenExp arr env Int + + -- Unsafe operations (may fail or result in undefined behaviour) + -- An unspecified bit pattern + Undef :: ScalarType t + -> PreOpenExp arr env t + + -- Reinterpret the bits of a value as a different type + Coerce :: BitSizeEq a b + => ScalarType a + -> ScalarType b + -> PreOpenExp arr env a + -> PreOpenExp arr env b + +expVars :: ExpVars env t -> PreOpenExp arr env t +expVars TupRunit = Nil +expVars (TupRsingle var) = Evar var +expVars (TupRpair v1 v2) = expVars v1 `Pair` expVars v2 + +-- Types for scalar bindings +-- +type ELeftHandSide = LeftHandSide ScalarType +type ExpVar = Var ScalarType +type ExpVars env = Vars ScalarType env + +-- | The expressions are parametrised over the type of array instructions. +-- Type class 'IsArrayInstr' should be implemented for that type. +class IsArrayInstr arr where + arrayInstrType :: arr (a -> b) -> TypeR b + liftArrayInstr :: arr t -> Q (TExp (arr t)) + rnfArrayInstr :: arr t -> () + showArrayInstrOp :: arr t -> String + encodeArrayInstr :: arr a -> Builder + matchArrayInstr :: arr t -> arr s -> Maybe (t :~: s) + +-- | Allows no array instructions at all. Used for expressions +-- which cannot perform array operations. The only use case +-- is currently the fallback function of a foreign. +-- +data NoArrayInstr t where + +instance IsArrayInstr NoArrayInstr where + arrayInstrType = \case {} + liftArrayInstr = \case {} + rnfArrayInstr = \case {} + showArrayInstrOp = \case {} + encodeArrayInstr = \case {} + matchArrayInstr = \case{} + + +-- |Primitive constant values +-- +data PrimConst ty where + + -- constants from Bounded + PrimMinBound :: BoundedType a -> PrimConst a + PrimMaxBound :: BoundedType a -> PrimConst a + + -- constant from Floating + PrimPi :: FloatingType a -> PrimConst a + + +-- |Primitive scalar operations +-- +data PrimFun sig where + + -- operators from Num + PrimAdd :: NumType a -> PrimFun ((a, a) -> a) + PrimSub :: NumType a -> PrimFun ((a, a) -> a) + PrimMul :: NumType a -> PrimFun ((a, a) -> a) + PrimNeg :: NumType a -> PrimFun (a -> a) + PrimAbs :: NumType a -> PrimFun (a -> a) + PrimSig :: NumType a -> PrimFun (a -> a) + + -- operators from Integral + PrimQuot :: IntegralType a -> PrimFun ((a, a) -> a) + PrimRem :: IntegralType a -> PrimFun ((a, a) -> a) + PrimQuotRem :: IntegralType a -> PrimFun ((a, a) -> (a, a)) + PrimIDiv :: IntegralType a -> PrimFun ((a, a) -> a) + PrimMod :: IntegralType a -> PrimFun ((a, a) -> a) + PrimDivMod :: IntegralType a -> PrimFun ((a, a) -> (a, a)) + + -- operators from Bits & FiniteBits + PrimBAnd :: IntegralType a -> PrimFun ((a, a) -> a) + PrimBOr :: IntegralType a -> PrimFun ((a, a) -> a) + PrimBXor :: IntegralType a -> PrimFun ((a, a) -> a) + PrimBNot :: IntegralType a -> PrimFun (a -> a) + PrimBShiftL :: IntegralType a -> PrimFun ((a, Int) -> a) + PrimBShiftR :: IntegralType a -> PrimFun ((a, Int) -> a) + PrimBRotateL :: IntegralType a -> PrimFun ((a, Int) -> a) + PrimBRotateR :: IntegralType a -> PrimFun ((a, Int) -> a) + PrimPopCount :: IntegralType a -> PrimFun (a -> Int) + PrimCountLeadingZeros :: IntegralType a -> PrimFun (a -> Int) + PrimCountTrailingZeros :: IntegralType a -> PrimFun (a -> Int) + + -- operators from Fractional and Floating + PrimFDiv :: FloatingType a -> PrimFun ((a, a) -> a) + PrimRecip :: FloatingType a -> PrimFun (a -> a) + PrimSin :: FloatingType a -> PrimFun (a -> a) + PrimCos :: FloatingType a -> PrimFun (a -> a) + PrimTan :: FloatingType a -> PrimFun (a -> a) + PrimAsin :: FloatingType a -> PrimFun (a -> a) + PrimAcos :: FloatingType a -> PrimFun (a -> a) + PrimAtan :: FloatingType a -> PrimFun (a -> a) + PrimSinh :: FloatingType a -> PrimFun (a -> a) + PrimCosh :: FloatingType a -> PrimFun (a -> a) + PrimTanh :: FloatingType a -> PrimFun (a -> a) + PrimAsinh :: FloatingType a -> PrimFun (a -> a) + PrimAcosh :: FloatingType a -> PrimFun (a -> a) + PrimAtanh :: FloatingType a -> PrimFun (a -> a) + PrimExpFloating :: FloatingType a -> PrimFun (a -> a) + PrimSqrt :: FloatingType a -> PrimFun (a -> a) + PrimLog :: FloatingType a -> PrimFun (a -> a) + PrimFPow :: FloatingType a -> PrimFun ((a, a) -> a) + PrimLogBase :: FloatingType a -> PrimFun ((a, a) -> a) + + -- FIXME: add missing operations from RealFrac & RealFloat + + -- operators from RealFrac + PrimTruncate :: FloatingType a -> IntegralType b -> PrimFun (a -> b) + PrimRound :: FloatingType a -> IntegralType b -> PrimFun (a -> b) + PrimFloor :: FloatingType a -> IntegralType b -> PrimFun (a -> b) + PrimCeiling :: FloatingType a -> IntegralType b -> PrimFun (a -> b) + -- PrimProperFraction :: FloatingType a -> IntegralType b -> PrimFun (a -> (b, a)) + + -- operators from RealFloat + PrimAtan2 :: FloatingType a -> PrimFun ((a, a) -> a) + PrimIsNaN :: FloatingType a -> PrimFun (a -> PrimBool) + PrimIsInfinite :: FloatingType a -> PrimFun (a -> PrimBool) + + -- relational and equality operators + PrimLt :: SingleType a -> PrimFun ((a, a) -> PrimBool) + PrimGt :: SingleType a -> PrimFun ((a, a) -> PrimBool) + PrimLtEq :: SingleType a -> PrimFun ((a, a) -> PrimBool) + PrimGtEq :: SingleType a -> PrimFun ((a, a) -> PrimBool) + PrimEq :: SingleType a -> PrimFun ((a, a) -> PrimBool) + PrimNEq :: SingleType a -> PrimFun ((a, a) -> PrimBool) + PrimMax :: SingleType a -> PrimFun ((a, a) -> a) + PrimMin :: SingleType a -> PrimFun ((a, a) -> a) + + -- logical operators + -- + -- Note that these operators are strict in both arguments. That is, the + -- second argument of PrimLAnd is always evaluated even when the first + -- argument is false. + -- + -- We define (surface level) (&&) and (||) using if-then-else to enable + -- short-circuiting, while (&&!) and (||!) are strict versions of these + -- operators, which are defined using PrimLAnd and PrimLOr. + -- + PrimLAnd :: PrimFun ((PrimBool, PrimBool) -> PrimBool) + PrimLOr :: PrimFun ((PrimBool, PrimBool) -> PrimBool) + PrimLNot :: PrimFun (PrimBool -> PrimBool) + + -- general conversion between types + PrimFromIntegral :: IntegralType a -> NumType b -> PrimFun (a -> b) + PrimToFloating :: NumType a -> FloatingType b -> PrimFun (a -> b) + +expType :: (HasCallStack, IsArrayInstr arr) => PreOpenExp arr env t -> TypeR t +expType = \case + Let _ _ body -> expType body + Evar (Var tR _) -> TupRsingle tR + Foreign tR _ _ _ -> tR + Pair e1 e2 -> TupRpair (expType e1) (expType e2) + Nil -> TupRunit + VecPack vecR _ -> TupRsingle $ VectorScalarType $ vecRvector vecR + VecUnpack vecR _ -> vecRtuple vecR + IndexSlice si _ _ -> shapeType $ sliceShapeR si + IndexFull si _ _ -> shapeType $ sliceDomainR si + ToIndex{} -> TupRsingle scalarTypeInt + FromIndex shr _ _ -> shapeType shr + Case _ ((_,e):_) _ -> expType e + Case _ [] (Just e) -> expType e + Case{} -> internalError "empty case encountered" + Cond _ e _ -> expType e + While _ (Lam lhs _) _ -> lhsToTupR lhs + While{} -> error "What's the matter, you're running in the shadows" + Const tR _ -> TupRsingle tR + PrimConst c -> TupRsingle $ SingleScalarType $ primConstType c + PrimApp f _ -> snd $ primFunType f + ArrayInstr arr _ -> arrayInstrType arr + ShapeSize{} -> TupRsingle scalarTypeInt + Undef tR -> TupRsingle tR + Coerce _ tR _ -> TupRsingle tR + +primConstType :: PrimConst a -> SingleType a +primConstType = \case + PrimMinBound t -> bounded t + PrimMaxBound t -> bounded t + PrimPi t -> floating t + where + bounded :: BoundedType a -> SingleType a + bounded (IntegralBoundedType t) = NumSingleType $ IntegralNumType t + + floating :: FloatingType t -> SingleType t + floating = NumSingleType . FloatingNumType + +primFunType :: PrimFun (a -> b) -> (TypeR a, TypeR b) +primFunType = \case + -- Num + PrimAdd t -> binary' $ num t + PrimSub t -> binary' $ num t + PrimMul t -> binary' $ num t + PrimNeg t -> unary' $ num t + PrimAbs t -> unary' $ num t + PrimSig t -> unary' $ num t + + -- Integral + PrimQuot t -> binary' $ integral t + PrimRem t -> binary' $ integral t + PrimQuotRem t -> unary' $ integral t `TupRpair` integral t + PrimIDiv t -> binary' $ integral t + PrimMod t -> binary' $ integral t + PrimDivMod t -> unary' $ integral t `TupRpair` integral t + + -- Bits & FiniteBits + PrimBAnd t -> binary' $ integral t + PrimBOr t -> binary' $ integral t + PrimBXor t -> binary' $ integral t + PrimBNot t -> unary' $ integral t + PrimBShiftL t -> (integral t `TupRpair` int, integral t) + PrimBShiftR t -> (integral t `TupRpair` int, integral t) + PrimBRotateL t -> (integral t `TupRpair` int, integral t) + PrimBRotateR t -> (integral t `TupRpair` int, integral t) + PrimPopCount t -> unary (integral t) int + PrimCountLeadingZeros t -> unary (integral t) int + PrimCountTrailingZeros t -> unary (integral t) int + + -- Fractional, Floating + PrimFDiv t -> binary' $ floating t + PrimRecip t -> unary' $ floating t + PrimSin t -> unary' $ floating t + PrimCos t -> unary' $ floating t + PrimTan t -> unary' $ floating t + PrimAsin t -> unary' $ floating t + PrimAcos t -> unary' $ floating t + PrimAtan t -> unary' $ floating t + PrimSinh t -> unary' $ floating t + PrimCosh t -> unary' $ floating t + PrimTanh t -> unary' $ floating t + PrimAsinh t -> unary' $ floating t + PrimAcosh t -> unary' $ floating t + PrimAtanh t -> unary' $ floating t + PrimExpFloating t -> unary' $ floating t + PrimSqrt t -> unary' $ floating t + PrimLog t -> unary' $ floating t + PrimFPow t -> binary' $ floating t + PrimLogBase t -> binary' $ floating t + + -- RealFrac + PrimTruncate a b -> unary (floating a) (integral b) + PrimRound a b -> unary (floating a) (integral b) + PrimFloor a b -> unary (floating a) (integral b) + PrimCeiling a b -> unary (floating a) (integral b) + + -- RealFloat + PrimAtan2 t -> binary' $ floating t + PrimIsNaN t -> unary (floating t) bool + PrimIsInfinite t -> unary (floating t) bool + + -- Relational and equality + PrimLt t -> compare' t + PrimGt t -> compare' t + PrimLtEq t -> compare' t + PrimGtEq t -> compare' t + PrimEq t -> compare' t + PrimNEq t -> compare' t + PrimMax t -> binary' $ single t + PrimMin t -> binary' $ single t + + -- Logical + PrimLAnd -> binary' bool + PrimLOr -> binary' bool + PrimLNot -> unary' bool + + -- general conversion between types + PrimFromIntegral a b -> unary (integral a) (num b) + PrimToFloating a b -> unary (num a) (floating b) + + where + unary a b = (a, b) + unary' a = unary a a + binary a b = (a `TupRpair` a, b) + binary' a = binary a a + compare' a = binary (single a) bool + + single = TupRsingle . SingleScalarType + num = TupRsingle . SingleScalarType . NumSingleType + integral = num . IntegralNumType + floating = num . FloatingNumType + + bool = TupRsingle scalarTypeWord8 + int = TupRsingle scalarTypeInt + +rnfOpenFun :: forall arr env t. IsArrayInstr arr => PreOpenFun arr env t -> () +rnfOpenFun (Body b) = rnfOpenExp b +rnfOpenFun (Lam lhs f) = rnfELeftHandSide lhs `seq` rnfOpenFun f + +rnfOpenExp :: forall arr env t. IsArrayInstr arr => PreOpenExp arr env t -> () +rnfOpenExp topExp = + let + rnfF :: PreOpenFun arr env' t' -> () + rnfF = rnfOpenFun + + rnfE :: PreOpenExp arr env' t' -> () + rnfE = rnfOpenExp + in + case topExp of + Let lhs bnd body -> rnfELeftHandSide lhs `seq` rnfE bnd `seq` rnfE body + Evar v -> rnfExpVar v + Foreign tp asm f x -> rnfTypeR tp `seq` rnf (strForeign asm) `seq` rnfOpenFun f `seq` rnfE x + Const tp c -> c `seq` rnfScalarType tp -- scalars should have (nf == whnf) + Undef tp -> rnfScalarType tp + Pair a b -> rnfE a `seq` rnfE b + Nil -> () + VecPack vecr e -> rnfVecR vecr `seq` rnfE e + VecUnpack vecr e -> rnfVecR vecr `seq` rnfE e + IndexSlice slice slix sh -> rnfSliceIndex slice `seq` rnfE slix `seq` rnfE sh + IndexFull slice slix sl -> rnfSliceIndex slice `seq` rnfE slix `seq` rnfE sl + ToIndex shr sh ix -> rnfShapeR shr `seq` rnfE sh `seq` rnfE ix + FromIndex shr sh ix -> rnfShapeR shr `seq` rnfE sh `seq` rnfE ix + Case e rhs def -> rnfE e `seq` rnfList (\(t,c) -> t `seq` rnfE c) rhs `seq` rnfMaybe rnfE def + Cond p e1 e2 -> rnfE p `seq` rnfE e1 `seq` rnfE e2 + While p f x -> rnfF p `seq` rnfF f `seq` rnfE x + PrimConst c -> rnfPrimConst c + PrimApp f x -> rnfPrimFun f `seq` rnfE x + ArrayInstr arr e -> rnfArrayInstr arr `seq` rnfE e + ShapeSize shr sh -> rnfShapeR shr `seq` rnfE sh + Coerce t1 t2 e -> rnfScalarType t1 `seq` rnfScalarType t2 `seq` rnfE e + +rnfExpVar :: ExpVar env t -> () +rnfExpVar = rnfVar rnfScalarType + +rnfELeftHandSide :: ELeftHandSide t env env' -> () +rnfELeftHandSide = rnfLeftHandSide rnfScalarType + +rnfConst :: TypeR t -> t -> () +rnfConst TupRunit () = () +rnfConst (TupRsingle t) !_ = rnfScalarType t -- scalars should have (nf == whnf) +rnfConst (TupRpair ta tb) (a,b) = rnfConst ta a `seq` rnfConst tb b + +rnfPrimConst :: PrimConst c -> () +rnfPrimConst (PrimMinBound t) = rnfBoundedType t +rnfPrimConst (PrimMaxBound t) = rnfBoundedType t +rnfPrimConst (PrimPi t) = rnfFloatingType t + +rnfPrimFun :: PrimFun f -> () +rnfPrimFun (PrimAdd t) = rnfNumType t +rnfPrimFun (PrimSub t) = rnfNumType t +rnfPrimFun (PrimMul t) = rnfNumType t +rnfPrimFun (PrimNeg t) = rnfNumType t +rnfPrimFun (PrimAbs t) = rnfNumType t +rnfPrimFun (PrimSig t) = rnfNumType t +rnfPrimFun (PrimQuot t) = rnfIntegralType t +rnfPrimFun (PrimRem t) = rnfIntegralType t +rnfPrimFun (PrimQuotRem t) = rnfIntegralType t +rnfPrimFun (PrimIDiv t) = rnfIntegralType t +rnfPrimFun (PrimMod t) = rnfIntegralType t +rnfPrimFun (PrimDivMod t) = rnfIntegralType t +rnfPrimFun (PrimBAnd t) = rnfIntegralType t +rnfPrimFun (PrimBOr t) = rnfIntegralType t +rnfPrimFun (PrimBXor t) = rnfIntegralType t +rnfPrimFun (PrimBNot t) = rnfIntegralType t +rnfPrimFun (PrimBShiftL t) = rnfIntegralType t +rnfPrimFun (PrimBShiftR t) = rnfIntegralType t +rnfPrimFun (PrimBRotateL t) = rnfIntegralType t +rnfPrimFun (PrimBRotateR t) = rnfIntegralType t +rnfPrimFun (PrimPopCount t) = rnfIntegralType t +rnfPrimFun (PrimCountLeadingZeros t) = rnfIntegralType t +rnfPrimFun (PrimCountTrailingZeros t) = rnfIntegralType t +rnfPrimFun (PrimFDiv t) = rnfFloatingType t +rnfPrimFun (PrimRecip t) = rnfFloatingType t +rnfPrimFun (PrimSin t) = rnfFloatingType t +rnfPrimFun (PrimCos t) = rnfFloatingType t +rnfPrimFun (PrimTan t) = rnfFloatingType t +rnfPrimFun (PrimAsin t) = rnfFloatingType t +rnfPrimFun (PrimAcos t) = rnfFloatingType t +rnfPrimFun (PrimAtan t) = rnfFloatingType t +rnfPrimFun (PrimSinh t) = rnfFloatingType t +rnfPrimFun (PrimCosh t) = rnfFloatingType t +rnfPrimFun (PrimTanh t) = rnfFloatingType t +rnfPrimFun (PrimAsinh t) = rnfFloatingType t +rnfPrimFun (PrimAcosh t) = rnfFloatingType t +rnfPrimFun (PrimAtanh t) = rnfFloatingType t +rnfPrimFun (PrimExpFloating t) = rnfFloatingType t +rnfPrimFun (PrimSqrt t) = rnfFloatingType t +rnfPrimFun (PrimLog t) = rnfFloatingType t +rnfPrimFun (PrimFPow t) = rnfFloatingType t +rnfPrimFun (PrimLogBase t) = rnfFloatingType t +rnfPrimFun (PrimTruncate f i) = rnfFloatingType f `seq` rnfIntegralType i +rnfPrimFun (PrimRound f i) = rnfFloatingType f `seq` rnfIntegralType i +rnfPrimFun (PrimFloor f i) = rnfFloatingType f `seq` rnfIntegralType i +rnfPrimFun (PrimCeiling f i) = rnfFloatingType f `seq` rnfIntegralType i +rnfPrimFun (PrimIsNaN t) = rnfFloatingType t +rnfPrimFun (PrimIsInfinite t) = rnfFloatingType t +rnfPrimFun (PrimAtan2 t) = rnfFloatingType t +rnfPrimFun (PrimLt t) = rnfSingleType t +rnfPrimFun (PrimGt t) = rnfSingleType t +rnfPrimFun (PrimLtEq t) = rnfSingleType t +rnfPrimFun (PrimGtEq t) = rnfSingleType t +rnfPrimFun (PrimEq t) = rnfSingleType t +rnfPrimFun (PrimNEq t) = rnfSingleType t +rnfPrimFun (PrimMax t) = rnfSingleType t +rnfPrimFun (PrimMin t) = rnfSingleType t +rnfPrimFun PrimLAnd = () +rnfPrimFun PrimLOr = () +rnfPrimFun PrimLNot = () +rnfPrimFun (PrimFromIntegral i n) = rnfIntegralType i `seq` rnfNumType n +rnfPrimFun (PrimToFloating n f) = rnfNumType n `seq` rnfFloatingType f + +rnfMaybe :: (a -> ()) -> Maybe a -> () +rnfMaybe _ Nothing = () +rnfMaybe f (Just x) = f x + +rnfList :: (a -> ()) -> [a] -> () +rnfList r = go + where + go [] = () + go (x:xs) = r x `seq` go xs + +-- Template Haskell +-- ================ + +liftOpenFun + :: IsArrayInstr arr + => PreOpenFun arr env t + -> Q (TExp (PreOpenFun arr env t)) +liftOpenFun (Lam lhs f) = [|| Lam $$(liftELeftHandSide lhs) $$(liftOpenFun f) ||] +liftOpenFun (Body b) = [|| Body $$(liftOpenExp b) ||] + +liftOpenExp + :: forall arr env t. IsArrayInstr arr + => PreOpenExp arr env t + -> Q (TExp (PreOpenExp arr env t)) +liftOpenExp pexp = + let + liftE :: PreOpenExp arr env e -> Q (TExp (PreOpenExp arr env e)) + liftE = liftOpenExp + + liftF :: PreOpenFun arr env f -> Q (TExp (PreOpenFun arr env f)) + liftF = liftOpenFun + in + case pexp of + Let lhs bnd body -> [|| Let $$(liftELeftHandSide lhs) $$(liftOpenExp bnd) $$(liftOpenExp body) ||] + Evar var -> [|| Evar $$(liftExpVar var) ||] + Foreign repr asm f x -> [|| Foreign $$(liftTypeR repr) $$(liftForeign asm) $$(liftOpenFun f) $$(liftE x) ||] + Const tp c -> [|| Const $$(liftScalarType tp) $$(liftElt (TupRsingle tp) c) ||] + Undef tp -> [|| Undef $$(liftScalarType tp) ||] + Pair a b -> [|| Pair $$(liftE a) $$(liftE b) ||] + Nil -> [|| Nil ||] + VecPack vecr e -> [|| VecPack $$(liftVecR vecr) $$(liftE e) ||] + VecUnpack vecr e -> [|| VecUnpack $$(liftVecR vecr) $$(liftE e) ||] + IndexSlice slice slix sh -> [|| IndexSlice $$(liftSliceIndex slice) $$(liftE slix) $$(liftE sh) ||] + IndexFull slice slix sl -> [|| IndexFull $$(liftSliceIndex slice) $$(liftE slix) $$(liftE sl) ||] + ToIndex shr sh ix -> [|| ToIndex $$(liftShapeR shr) $$(liftE sh) $$(liftE ix) ||] + FromIndex shr sh ix -> [|| FromIndex $$(liftShapeR shr) $$(liftE sh) $$(liftE ix) ||] + Case p rhs def -> [|| Case $$(liftE p) $$(liftList (\(t,c) -> [|| (t, $$(liftE c)) ||]) rhs) $$(liftMaybe liftE def) ||] + Cond p t e -> [|| Cond $$(liftE p) $$(liftE t) $$(liftE e) ||] + While p f x -> [|| While $$(liftF p) $$(liftF f) $$(liftE x) ||] + PrimConst t -> [|| PrimConst $$(liftPrimConst t) ||] + PrimApp f x -> [|| PrimApp $$(liftPrimFun f) $$(liftE x) ||] + ArrayInstr arr x -> [|| ArrayInstr $$(liftArrayInstr arr) $$(liftE x) ||] + ShapeSize shr ix -> [|| ShapeSize $$(liftShapeR shr) $$(liftE ix) ||] + Coerce t1 t2 e -> [|| Coerce $$(liftScalarType t1) $$(liftScalarType t2) $$(liftE e) ||] + +liftPrimConst :: PrimConst c -> Q (TExp (PrimConst c)) +liftPrimConst (PrimMinBound t) = [|| PrimMinBound $$(liftBoundedType t) ||] +liftPrimConst (PrimMaxBound t) = [|| PrimMaxBound $$(liftBoundedType t) ||] +liftPrimConst (PrimPi t) = [|| PrimPi $$(liftFloatingType t) ||] + +liftPrimFun :: PrimFun f -> Q (TExp (PrimFun f)) +liftPrimFun (PrimAdd t) = [|| PrimAdd $$(liftNumType t) ||] +liftPrimFun (PrimSub t) = [|| PrimSub $$(liftNumType t) ||] +liftPrimFun (PrimMul t) = [|| PrimMul $$(liftNumType t) ||] +liftPrimFun (PrimNeg t) = [|| PrimNeg $$(liftNumType t) ||] +liftPrimFun (PrimAbs t) = [|| PrimAbs $$(liftNumType t) ||] +liftPrimFun (PrimSig t) = [|| PrimSig $$(liftNumType t) ||] +liftPrimFun (PrimQuot t) = [|| PrimQuot $$(liftIntegralType t) ||] +liftPrimFun (PrimRem t) = [|| PrimRem $$(liftIntegralType t) ||] +liftPrimFun (PrimQuotRem t) = [|| PrimQuotRem $$(liftIntegralType t) ||] +liftPrimFun (PrimIDiv t) = [|| PrimIDiv $$(liftIntegralType t) ||] +liftPrimFun (PrimMod t) = [|| PrimMod $$(liftIntegralType t) ||] +liftPrimFun (PrimDivMod t) = [|| PrimDivMod $$(liftIntegralType t) ||] +liftPrimFun (PrimBAnd t) = [|| PrimBAnd $$(liftIntegralType t) ||] +liftPrimFun (PrimBOr t) = [|| PrimBOr $$(liftIntegralType t) ||] +liftPrimFun (PrimBXor t) = [|| PrimBXor $$(liftIntegralType t) ||] +liftPrimFun (PrimBNot t) = [|| PrimBNot $$(liftIntegralType t) ||] +liftPrimFun (PrimBShiftL t) = [|| PrimBShiftL $$(liftIntegralType t) ||] +liftPrimFun (PrimBShiftR t) = [|| PrimBShiftR $$(liftIntegralType t) ||] +liftPrimFun (PrimBRotateL t) = [|| PrimBRotateL $$(liftIntegralType t) ||] +liftPrimFun (PrimBRotateR t) = [|| PrimBRotateR $$(liftIntegralType t) ||] +liftPrimFun (PrimPopCount t) = [|| PrimPopCount $$(liftIntegralType t) ||] +liftPrimFun (PrimCountLeadingZeros t) = [|| PrimCountLeadingZeros $$(liftIntegralType t) ||] +liftPrimFun (PrimCountTrailingZeros t) = [|| PrimCountTrailingZeros $$(liftIntegralType t) ||] +liftPrimFun (PrimFDiv t) = [|| PrimFDiv $$(liftFloatingType t) ||] +liftPrimFun (PrimRecip t) = [|| PrimRecip $$(liftFloatingType t) ||] +liftPrimFun (PrimSin t) = [|| PrimSin $$(liftFloatingType t) ||] +liftPrimFun (PrimCos t) = [|| PrimCos $$(liftFloatingType t) ||] +liftPrimFun (PrimTan t) = [|| PrimTan $$(liftFloatingType t) ||] +liftPrimFun (PrimAsin t) = [|| PrimAsin $$(liftFloatingType t) ||] +liftPrimFun (PrimAcos t) = [|| PrimAcos $$(liftFloatingType t) ||] +liftPrimFun (PrimAtan t) = [|| PrimAtan $$(liftFloatingType t) ||] +liftPrimFun (PrimSinh t) = [|| PrimSinh $$(liftFloatingType t) ||] +liftPrimFun (PrimCosh t) = [|| PrimCosh $$(liftFloatingType t) ||] +liftPrimFun (PrimTanh t) = [|| PrimTanh $$(liftFloatingType t) ||] +liftPrimFun (PrimAsinh t) = [|| PrimAsinh $$(liftFloatingType t) ||] +liftPrimFun (PrimAcosh t) = [|| PrimAcosh $$(liftFloatingType t) ||] +liftPrimFun (PrimAtanh t) = [|| PrimAtanh $$(liftFloatingType t) ||] +liftPrimFun (PrimExpFloating t) = [|| PrimExpFloating $$(liftFloatingType t) ||] +liftPrimFun (PrimSqrt t) = [|| PrimSqrt $$(liftFloatingType t) ||] +liftPrimFun (PrimLog t) = [|| PrimLog $$(liftFloatingType t) ||] +liftPrimFun (PrimFPow t) = [|| PrimFPow $$(liftFloatingType t) ||] +liftPrimFun (PrimLogBase t) = [|| PrimLogBase $$(liftFloatingType t) ||] +liftPrimFun (PrimTruncate ta tb) = [|| PrimTruncate $$(liftFloatingType ta) $$(liftIntegralType tb) ||] +liftPrimFun (PrimRound ta tb) = [|| PrimRound $$(liftFloatingType ta) $$(liftIntegralType tb) ||] +liftPrimFun (PrimFloor ta tb) = [|| PrimFloor $$(liftFloatingType ta) $$(liftIntegralType tb) ||] +liftPrimFun (PrimCeiling ta tb) = [|| PrimCeiling $$(liftFloatingType ta) $$(liftIntegralType tb) ||] +liftPrimFun (PrimIsNaN t) = [|| PrimIsNaN $$(liftFloatingType t) ||] +liftPrimFun (PrimIsInfinite t) = [|| PrimIsInfinite $$(liftFloatingType t) ||] +liftPrimFun (PrimAtan2 t) = [|| PrimAtan2 $$(liftFloatingType t) ||] +liftPrimFun (PrimLt t) = [|| PrimLt $$(liftSingleType t) ||] +liftPrimFun (PrimGt t) = [|| PrimGt $$(liftSingleType t) ||] +liftPrimFun (PrimLtEq t) = [|| PrimLtEq $$(liftSingleType t) ||] +liftPrimFun (PrimGtEq t) = [|| PrimGtEq $$(liftSingleType t) ||] +liftPrimFun (PrimEq t) = [|| PrimEq $$(liftSingleType t) ||] +liftPrimFun (PrimNEq t) = [|| PrimNEq $$(liftSingleType t) ||] +liftPrimFun (PrimMax t) = [|| PrimMax $$(liftSingleType t) ||] +liftPrimFun (PrimMin t) = [|| PrimMin $$(liftSingleType t) ||] +liftPrimFun PrimLAnd = [|| PrimLAnd ||] +liftPrimFun PrimLOr = [|| PrimLOr ||] +liftPrimFun PrimLNot = [|| PrimLNot ||] +liftPrimFun (PrimFromIntegral ta tb) = [|| PrimFromIntegral $$(liftIntegralType ta) $$(liftNumType tb) ||] +liftPrimFun (PrimToFloating ta tb) = [|| PrimToFloating $$(liftNumType ta) $$(liftFloatingType tb) ||] + +liftMaybe :: (a -> Q (TExp a)) -> Maybe a -> Q (TExp (Maybe a)) +liftMaybe _ Nothing = [|| Nothing ||] +liftMaybe f (Just x) = [|| Just $$(f x) ||] + +liftList :: (a -> Q (TExp a)) -> [a] -> Q (TExp [a]) +liftList _ [] = [|| [] ||] +liftList f (x:xs) = [|| $$(f x) : $$(liftList f xs) ||] + +liftELeftHandSide :: ELeftHandSide t env env' -> Q (TExp (ELeftHandSide t env env')) +liftELeftHandSide = liftLeftHandSide liftScalarType + +liftExpVar :: ExpVar env t -> Q (TExp (ExpVar env t)) +liftExpVar = liftVar liftScalarType + +mkConstant :: TypeR t -> t -> PreOpenExp arr env t +mkConstant (TupRsingle tp) c = Const tp c +mkConstant (TupRpair t1 t2) (c1, c2) = mkConstant t1 c1 `Pair` mkConstant t2 c2 +mkConstant TupRunit () = Nil + +mkBinary :: PrimFun ((a, b) -> c) -> PreOpenExp arr env a -> PreOpenExp arr env b -> PreOpenExp arr env c +mkBinary fun a b = PrimApp fun $ Pair a b + +-- Extracts the body from a PreOpenFun. The type gives evidence +-- that 't' is not a function type and the PreOpenFun thus must +-- be a Body. +-- +unBody :: TypeR t -> PreOpenFun arr env t -> PreOpenExp arr env t +unBody _ (Body e) = e +unBody tp (Lam _ _) = functionImpossible tp + +showExpOp :: IsArrayInstr arr => PreOpenExp arr env t -> String +showExpOp Let{} = "Let" +showExpOp (Evar (Var _ ix)) = "Var x" ++ show (idxToInt ix) +showExpOp (Const tp c) = "Const " ++ showElt (TupRsingle tp) c +showExpOp Undef{} = "Undef" +showExpOp Foreign{} = "Foreign" +showExpOp Pair{} = "Pair" +showExpOp Nil{} = "Nil" +showExpOp VecPack{} = "VecPack" +showExpOp VecUnpack{} = "VecUnpack" +showExpOp IndexSlice{} = "IndexSlice" +showExpOp IndexFull{} = "IndexFull" +showExpOp ToIndex{} = "ToIndex" +showExpOp FromIndex{} = "FromIndex" +showExpOp Case{} = "Case" +showExpOp Cond{} = "Cond" +showExpOp While{} = "While" +showExpOp PrimConst{} = "PrimConst" +showExpOp PrimApp{} = "PrimApp" +showExpOp (ArrayInstr ar _) = showArrayInstrOp ar +showExpOp ShapeSize{} = "ShapeSize" +showExpOp Coerce{} = "Coerce" diff --git a/src/Data/Array/Accelerate/AST/Idx.hs b/src/Data/Array/Accelerate/AST/Idx.hs index 494bc057a..12362dce2 100644 --- a/src/Data/Array/Accelerate/AST/Idx.hs +++ b/src/Data/Array/Accelerate/AST/Idx.hs @@ -1,5 +1,6 @@ {-# LANGUAGE GADTs #-} {-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeOperators #-} {-# OPTIONS_HADDOCK hide #-} -- | -- Module : Data.Array.Accelerate.AST.Idx @@ -17,6 +18,7 @@ module Data.Array.Accelerate.AST.Idx where import Language.Haskell.TH +import Data.Typeable ( (:~:)(..) ) -- De Bruijn variable index projecting a specific type from a type -- environment. Type environments are nested pairs (..((), t1), t2, ..., tn). @@ -42,3 +44,9 @@ liftIdx :: Idx env t -> Q (TExp (Idx env t)) liftIdx ZeroIdx = [|| ZeroIdx ||] liftIdx (SuccIdx ix) = [|| SuccIdx $$(liftIdx ix) ||] +{-# INLINEABLE matchIdx #-} +matchIdx :: Idx env s -> Idx env t -> Maybe (s :~: t) +matchIdx ZeroIdx ZeroIdx = Just Refl +matchIdx (SuccIdx u) (SuccIdx v) = matchIdx u v +matchIdx _ _ = Nothing + diff --git a/src/Data/Array/Accelerate/AST/LeftHandSide.hs b/src/Data/Array/Accelerate/AST/LeftHandSide.hs index f92b3024a..00f094008 100644 --- a/src/Data/Array/Accelerate/AST/LeftHandSide.hs +++ b/src/Data/Array/Accelerate/AST/LeftHandSide.hs @@ -60,3 +60,7 @@ liftLeftHandSide f (LeftHandSideSingle s) = [|| LeftHandSideSingle $$(f s) ||] liftLeftHandSide f (LeftHandSideWildcard r) = [|| LeftHandSideWildcard $$(liftTupR f r) ||] liftLeftHandSide f (LeftHandSidePair as bs) = [|| LeftHandSidePair $$(liftLeftHandSide f as) $$(liftLeftHandSide f bs) ||] +mapLeftHandSide :: (forall v. s v -> u v) -> LeftHandSide s t env env' -> LeftHandSide u t env env' +mapLeftHandSide f (LeftHandSideSingle s) = LeftHandSideSingle $ f s +mapLeftHandSide f (LeftHandSideWildcard r) = LeftHandSideWildcard $ mapTupR f r +mapLeftHandSide f (LeftHandSidePair as bs) = LeftHandSidePair (mapLeftHandSide f as) (mapLeftHandSide f bs) diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index 28e32f976..8cbcef452 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -7,6 +7,7 @@ {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# OPTIONS_HADDOCK hide #-} @@ -24,35 +25,39 @@ module Data.Array.Accelerate.AST.Operation ( PreOpenAcc(..), PreOpenAfun(..), OperationAcc, OperationAfun, Execute(..), - GroundR(..), GroundsR, GroundVar, GroundVars, GLeftHandSide, + GroundR(..), GroundsR, GroundVar, GroundVars, GLeftHandSide, Var(..), Vars, - PreArgs(..), Arg(..), Args, Modifier(..), + PreArgs(..), Arg(..), Args, Modifier(..), argArrayR, argExpType, Exp', Fun', In, Out, Mut, - OpenExp(..), OpenFun(..), + OpenExp, OpenFun, Exp, Fun, ArrayInstr(..), - PrimConst, PrimFun, PrimBool, PrimMaybe, ExpVar, ExpVars, + encodeGroundR, encodeGroundsR, encodeGroundVar, encodeGroundVars, + rnfGroundR, rnfGroundsR, rnfGroundVar, rnfGroundVars, + liftGroundR, liftGroundsR, liftGroundVar, liftGroundVars, + + paramIn, paramsIn, + + module Data.Array.Accelerate.AST.Exp ) where -import Data.Array.Accelerate.AST (PrimConst, PrimFun, PrimBool, PrimMaybe, ExpVar, ExpVars, primFunType, primConstType) +import Data.Array.Accelerate.AST.Exp import Data.Array.Accelerate.AST.LeftHandSide import Data.Array.Accelerate.AST.Var +import Data.Array.Accelerate.Analysis.Hash.Exp import Data.Array.Accelerate.Representation.Array import Data.Array.Accelerate.Representation.Shape -import Data.Array.Accelerate.Representation.Slice -import Data.Array.Accelerate.Representation.Tag import Data.Array.Accelerate.Representation.Type -import Data.Array.Accelerate.Representation.Vec -import Data.Array.Accelerate.Sugar.Foreign import Data.Array.Accelerate.Type import Data.Array.Accelerate.Error -import Data.Primitive.Vec +import Data.Typeable ( (:~:)(..) ) -import GHC.TypeNats +import Data.ByteString.Builder.Extra +import Language.Haskell.TH ( Q, TExp ) --- | An intermediate representation consisting parameterized over executable --- operations. This data type only consists of the control flow structure and +-- | An intermediate representation parameterized over executable operations. +-- This data type only consists of the control flow structure and -- bookkeeping (allocating or copying buffers). -- -- The data type is parameterized over the type of executable operations. In @@ -83,7 +88,7 @@ data PreOpenAcc exe env a where -- | Evaluates the expression and returns its value. -- - Compute :: OpenExp env t + Compute :: Exp env t -> PreOpenAcc exe env t -- | Local binding of ground values. @@ -140,9 +145,9 @@ data PreOpenAcc exe env a where -- | Function abstraction over parametrised array computations -- -data PreOpenAfun com env t where - Abody :: PreOpenAcc com env t -> PreOpenAfun acc env t - Alam :: GLeftHandSide a env env' -> PreOpenAfun acc env' t -> PreOpenAfun acc env (a -> t) +data PreOpenAfun op env t where + Abody :: PreOpenAcc op env t -> PreOpenAfun op env t + Alam :: GLeftHandSide a env env' -> PreOpenAfun op env' t -> PreOpenAfun op env (a -> t) -- | Ground values are buffers or scalars. @@ -177,14 +182,14 @@ data Arg env t where ArgMaybeExp :: Maybe (ExpVars env e) -> Arg env (Maybe (Exp' e)) - ArgFun :: OpenFun env e -> Arg env (Fun' e) + ArgFun :: Fun env e -> Arg env (Fun' e) -- | An array is represented as scalar variables denoting the size and buffer variables. -- We assume that all the buffer variables stored in 'ArgBuffers' have the same size, -- as specified by the scalar variables of the size. -- ArgArray :: Modifier m - -> ShapeR sh + -> ArrayR (Array sh e) -> GroundVars env sh -> GroundVars env (Buffers e) -> Arg env (m sh e) @@ -210,6 +215,12 @@ data In sh e where data Out sh e where data Mut sh e where +argExpType :: Arg env (Exp' e) -> TypeR e +argExpType (ArgExp vars) = varsType vars + +argArrayR :: Arg env (m sh e) -> ArrayR (Array sh e) +argArrayR (ArgArray _ repr _ _) = repr + -- | Executes a single operation. Provides the operation arguments -- from the environment. -- @@ -228,136 +239,6 @@ type OperationAcc op = PreOpenAcc (Execute op) -- type OperationAfun op = PreOpenAfun (Execute op) - --- | Vanilla open expressions using de Bruijn indices for variables ranging --- over tuples of scalars and arrays of tuples. All code, except Cond, is --- evaluated eagerly. N-tuples are represented as nested pairs. --- --- The data type is parametrised over the representation type (not the --- surface types). The environment contains buffers and scalar values, --- in contrary to earlier stages in the compiler which have separate --- environments for arrays and for scalars --- -data OpenExp env t where - - -- Local binding of a scalar expression and buffer variables - Let :: GLeftHandSide bnd_t env env' - -> OpenExp env bnd_t - -> OpenExp env' body_t - -> OpenExp env body_t - - -- Variable index, ranging only over scalars or buffers - ExpVar :: GroundVar env t - -> OpenExp env t - - -- Apply a backend-specific foreign function - Foreign :: Foreign asm - => GroundsR y - -> asm (x -> y) -- foreign function - -> OpenFun env (x -> y) -- alternate implementation (for other backends) - -> OpenExp env x - -> OpenExp env y - - -- Tuples - Pair :: OpenExp env t1 - -> OpenExp env t2 - -> OpenExp env (t1, t2) - - Nil :: OpenExp env () - - -- SIMD vectors - VecPack :: KnownNat n - => VecR n s tup - -> OpenExp env tup - -> OpenExp env (Vec n s) - - VecUnpack :: KnownNat n - => VecR n s tup - -> OpenExp env (Vec n s) - -> OpenExp env tup - - -- Array indices & shapes - IndexSlice :: SliceIndex slix sl co sh - -> OpenExp env slix - -> OpenExp env sh - -> OpenExp env sl - - IndexFull :: SliceIndex slix sl co sh - -> OpenExp env slix - -> OpenExp env sl - -> OpenExp env sh - - -- Shape and index conversion - ToIndex :: ShapeR sh - -> OpenExp env sh -- shape of the array - -> OpenExp env sh -- index into the array - -> OpenExp env Int - - FromIndex :: ShapeR sh - -> OpenExp env sh -- shape of the array - -> OpenExp env Int -- index into linear representation - -> OpenExp env sh - - -- Case statement - Case :: OpenExp env TAG - -> [(TAG, OpenExp env b)] -- list of equations - -> Maybe (OpenExp env b) -- default case - -> OpenExp env b - - -- Conditional expression (non-strict in 2nd and 3rd argument) - Cond :: OpenExp env PrimBool - -> OpenExp env t - -> OpenExp env t - -> OpenExp env t - - -- Value recursion - While :: OpenFun env (a -> PrimBool) -- continue while true - -> OpenFun env (a -> a) -- function to iterate - -> OpenExp env a -- initial value - -> OpenExp env a - - -- Constant values - Const :: ScalarType t - -> t - -> OpenExp env t - - PrimConst :: PrimConst t - -> OpenExp env t - - -- Primitive scalar operations - PrimApp :: PrimFun (a -> r) - -> OpenExp env a - -> OpenExp env r - - -- Project a single scalar from an array. - -- The array expression can not contain any free scalar variables. - LinearIndex :: GroundVar env (Buffer t) - -> OpenExp env Int - -> OpenExp env t - - -- Number of elements of an array given its shape - ShapeSize :: ShapeR dim - -> OpenExp env dim - -> OpenExp env Int - - -- Unsafe operations (may fail or result in undefined behaviour) - -- An unspecified bit pattern - Undef :: ScalarType t - -> OpenExp env t - - -- Reinterpret the bits of a value as a different type - Coerce :: BitSizeEq a b - => ScalarType a - -> ScalarType b - -> OpenExp env a - -> OpenExp env b - --- | Vanilla open function abstraction --- -data OpenFun env t where - Body :: OpenExp env t -> OpenFun env t - Lam :: GLeftHandSide a env env' -> OpenFun env' t -> OpenFun env (a -> t) - class HasGroundsR f where groundsR :: f a -> GroundsR a @@ -379,34 +260,8 @@ instance HasGroundsR (GroundVar env) where instance HasGroundsR (GroundVars env) where groundsR = varsType -instance HasGroundsR (OpenExp env) where - groundsR (Let _ _ e) = groundsR e - groundsR (ExpVar (Var tp _)) = TupRsingle tp - groundsR (Foreign tp _ _ _) = tp - groundsR (Pair e1 e2) = groundsR e1 `TupRpair` groundsR e2 - groundsR Nil = TupRunit - groundsR (VecPack vecR _) = TupRsingle $ GroundRscalar $ VectorScalarType $ vecRvector vecR - groundsR (VecUnpack vecR _) = typeRtoGroundsR $ vecRtuple vecR - groundsR (IndexSlice si _ _) = typeRtoGroundsR $ shapeType $ sliceShapeR si - groundsR (IndexFull si _ _) = typeRtoGroundsR $ shapeType $ sliceDomainR si - groundsR ToIndex{} = TupRsingle $ GroundRscalar scalarTypeInt - groundsR (FromIndex shr _ _) = typeRtoGroundsR $ shapeType shr - groundsR (Case _ ((_,e):_) _) = groundsR e - groundsR (Case _ [] (Just e)) = groundsR e - groundsR Case{} = internalError "empty case encountered" - groundsR (Cond _ e _) = groundsR e - groundsR (While _ (Lam lhs _) _) = lhsToTupR lhs - groundsR While{} = error "What's the matter, you're running in the shadows" - groundsR (Const tR _) = TupRsingle $ GroundRscalar tR - groundsR (PrimConst c) = TupRsingle $ GroundRscalar $ SingleScalarType $ primConstType c - groundsR (PrimApp f _) = typeRtoGroundsR $ snd $ primFunType f - groundsR (LinearIndex (Var (GroundRbuffer tp) _) _) - = TupRsingle $ GroundRscalar tp - groundsR (LinearIndex (Var (GroundRscalar tp) _) _) - = bufferImpossible tp - groundsR (ShapeSize{}) = TupRsingle $ GroundRscalar scalarTypeInt - groundsR (Undef tR) = TupRsingle $ GroundRscalar tR - groundsR (Coerce _ tR _) = TupRsingle $ GroundRscalar tR +instance HasGroundsR (OpenExp env benv) where + groundsR = typeRtoGroundsR . expType typeRtoGroundsR :: TypeR t -> GroundsR t typeRtoGroundsR = mapTupR GroundRscalar @@ -414,3 +269,82 @@ typeRtoGroundsR = mapTupR GroundRscalar bufferImpossible :: ScalarType (Buffer e) -> a bufferImpossible (SingleScalarType (NumSingleType (IntegralNumType tp))) = case tp of {} bufferImpossible (SingleScalarType (NumSingleType (FloatingNumType tp))) = case tp of {} + +type OpenExp env benv = PreOpenExp (ArrayInstr benv) env +type OpenFun env benv = PreOpenFun (ArrayInstr benv) env +type Fun benv = OpenFun () benv +type Exp benv = OpenExp () benv + +data ArrayInstr benv t where + Index :: GroundVar benv (Buffer e) -> ArrayInstr benv (Int -> e) + Parameter :: ExpVar benv e -> ArrayInstr benv (() -> e) + +instance IsArrayInstr (ArrayInstr benv) where + arrayInstrType arr = TupRsingle $ case arr of + Index (Var (GroundRbuffer tp) _) -> tp + Index (Var (GroundRscalar tp) _) -> bufferImpossible tp + Parameter (Var tp _) -> tp + + liftArrayInstr (Index var) = [|| Index $$(liftGroundVar var) ||] + liftArrayInstr (Parameter var) = [|| Parameter $$(liftExpVar var) ||] + + rnfArrayInstr (Index var) = rnfGroundVar var + rnfArrayInstr (Parameter var) = rnfExpVar var + + showArrayInstrOp Index{} = "Index" + showArrayInstrOp Parameter{} = "Parameter" + + matchArrayInstr (Index v1) (Index v2) | Just Refl <- matchVar v1 v2 = Just Refl + matchArrayInstr (Parameter v1) (Parameter v2) | Just Refl <- matchVar v1 v2 = Just Refl + matchArrayInstr _ _ = Nothing + + encodeArrayInstr (Index v) = intHost $(hashQ "Index") <> encodeGroundVar v + encodeArrayInstr (Parameter v) = intHost $(hashQ "Parameter") <> encodeExpVar v + +encodeGroundR :: GroundR t -> Builder +encodeGroundR (GroundRscalar tp) = intHost $(hashQ "Scalar") <> encodeScalarType tp +encodeGroundR (GroundRbuffer tp) = intHost $(hashQ "Buffer") <> encodeScalarType tp + +encodeGroundsR :: GroundsR t -> Builder +encodeGroundsR = encodeTupR encodeGroundR + +encodeGroundVar :: GroundVar env t -> Builder +encodeGroundVar (Var repr ix) = encodeGroundR repr <> encodeIdx ix + +encodeGroundVars :: GroundVars env t -> Builder +encodeGroundVars = encodeTupR encodeGroundVar + +rnfGroundR :: GroundR t -> () +rnfGroundR (GroundRscalar tp) = rnfScalarType tp +rnfGroundR (GroundRbuffer tp) = rnfScalarType tp + +rnfGroundsR :: GroundsR t -> () +rnfGroundsR = rnfTupR rnfGroundR + +rnfGroundVar :: GroundVar env t -> () +rnfGroundVar = rnfVar rnfGroundR + +rnfGroundVars :: GroundVars env t -> () +rnfGroundVars = rnfTupR rnfGroundVar + +liftGroundR :: GroundR t -> Q (TExp (GroundR t)) +liftGroundR (GroundRscalar tp) = [|| GroundRscalar $$(liftScalarType tp) ||] +liftGroundR (GroundRbuffer tp) = [|| GroundRbuffer $$(liftScalarType tp) ||] + +liftGroundsR :: GroundsR t -> Q (TExp (GroundsR t)) +liftGroundsR = liftTupR liftGroundR + +liftGroundVar :: GroundVar env t -> Q (TExp (GroundVar env t)) +liftGroundVar = liftVar liftGroundR + +liftGroundVars :: GroundVars env t -> Q (TExp (GroundVars env t)) +liftGroundVars = liftTupR liftGroundVar + +paramIn :: ScalarType e -> GroundVar benv e -> OpenExp env benv e +paramIn t (Var _ ix) = ArrayInstr (Parameter $ Var t ix) Nil + +paramsIn :: HasCallStack => TypeR e -> GroundVars benv e -> OpenExp env benv e +paramsIn TupRunit TupRunit = Nil +paramsIn (TupRpair t1 t2) (TupRpair v1 v2) = paramsIn t1 v1 `Pair` paramsIn t2 v2 +paramsIn (TupRsingle t) (TupRsingle (Var _ ix)) = ArrayInstr (Parameter $ Var t ix) Nil +paramsIn _ _ = internalError "Tuple mismatch" diff --git a/src/Data/Array/Accelerate/AST/Partitioned.hs b/src/Data/Array/Accelerate/AST/Partitioned.hs new file mode 100644 index 000000000..4f9b18dbe --- /dev/null +++ b/src/Data/Array/Accelerate/AST/Partitioned.hs @@ -0,0 +1,30 @@ +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# OPTIONS_HADDOCK hide #-} +-- | +-- Module : Data.Array.Accelerate.AST.Partitioned +-- Copyright : [2008..2020] The Accelerate Team +-- License : BSD3 +-- +-- Maintainer : Trevor L. McDonell +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- + +module Data.Array.Accelerate.AST.Partitioned ( ) where + +import Data.Array.Accelerate.AST.Partitioned + +data Cluster op env where + Base :: op args -> Args env args -> Command op env + -- TODO: Vertical, Horizontal, Diagonal + +type PartitionedAcc op = PreOpenAcc (Cluster op) diff --git a/src/Data/Array/Accelerate/AST/Var.hs b/src/Data/Array/Accelerate/AST/Var.hs index a0e0d705f..c3abc95d4 100644 --- a/src/Data/Array/Accelerate/AST/Var.hs +++ b/src/Data/Array/Accelerate/AST/Var.hs @@ -1,6 +1,7 @@ {-# LANGUAGE GADTs #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeOperators #-} {-# OPTIONS_HADDOCK hide #-} -- | -- Module : Data.Array.Accelerate.AST.Var @@ -19,6 +20,7 @@ import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.AST.Idx import Language.Haskell.TH +import Data.Typeable ( (:~:)(..) ) data Var s env t = Var (s t) (Idx env t) @@ -42,3 +44,17 @@ liftVar f (Var s idx) = [|| Var $$(f s) $$(liftIdx idx) ||] liftVars :: (forall b. s b -> Q (TExp (s b))) -> Vars s env t -> Q (TExp (Vars s env t)) liftVars f = liftTupR (liftVar f) +{-# INLINEABLE matchVar #-} +matchVar :: Var s env t1 -> Var s env t2 -> Maybe (t1 :~: t2) +matchVar (Var _ v1) (Var _ v2) = matchIdx v1 v2 + +{-# INLINEABLE matchVars #-} +matchVars :: Vars s env t1 -> Vars s env t2 -> Maybe (t1 :~: t2) +matchVars TupRunit TupRunit = Just Refl +matchVars (TupRsingle v1) (TupRsingle v2) + | Just Refl <- matchVar v1 v2 = Just Refl +matchVars (TupRpair v w) (TupRpair x y) + | Just Refl <- matchVars v x + , Just Refl <- matchVars w y = Just Refl +matchVars _ _ = Nothing + diff --git a/src/Data/Array/Accelerate/Analysis/Hash.hs b/src/Data/Array/Accelerate/Analysis/Hash.hs index 2c8a38dab..607454263 100644 --- a/src/Data/Array/Accelerate/Analysis/Hash.hs +++ b/src/Data/Array/Accelerate/Analysis/Hash.hs @@ -36,68 +36,21 @@ module Data.Array.Accelerate.Analysis.Hash ( ) where import Data.Array.Accelerate.AST -import Data.Array.Accelerate.AST.Idx -import Data.Array.Accelerate.AST.LeftHandSide import Data.Array.Accelerate.AST.Var import Data.Array.Accelerate.Analysis.Hash.TH +import Data.Array.Accelerate.Analysis.Hash.Exp import Data.Array.Accelerate.Representation.Array -import Data.Array.Accelerate.Representation.Shape -import Data.Array.Accelerate.Representation.Slice import Data.Array.Accelerate.Representation.Stencil import Data.Array.Accelerate.Representation.Type -import Data.Array.Accelerate.Type -import Data.Primitive.Vec import Crypto.Hash import Data.ByteString.Builder import Data.ByteString.Builder.Extra -import Data.ByteString.Short.Internal ( ShortByteString(..) ) import Data.Monoid import System.IO.Unsafe ( unsafePerformIO ) import System.Mem.StableName ( hashStableName, makeStableName ) import Prelude hiding ( exp ) - --- Hashing --- ------- - -type Hash = Digest SHA3_256 - -data HashOptions = HashOptions - { perfect :: Bool - -- ^ Should the hash function include _all_ substructure, recursively? - -- - -- Set to true (the default) if you want a truly unique fingerprint for - -- the entire expression: - -- - -- Example: - -- - -- xs, ys :: Acc (Vector Float) - -- xs = fill (constant (Z:.10)) 1.0 - -- ys = fill (constant (Z:.20)) 1.0 - -- - -- with perfect=True: - -- - -- hash xs = 2e1f91aca4c476d13b36f22462e73c15bbdd9fcacb0d4996280f6004058e9732 - -- hash ys = 2fce5c849b6c652192b09aaeafdc8029e57b9f006c1ecd79ccf9114f349aaf9e - -- - -- However, for a code generating backend the object code used to - -- evaluate both of these expressions is likely to be identical. - -- - -- Setting perfect=False results in: - -- - -- hash xs = hash ys = f97944b0ec64ab8aa989fd60c8b50e7ec3eff759d22d2b340039d837d74dfc3c - -- - -- Note that to be useful the provided 'EncodeAcc' function must also - -- understand this option, and the consumer of the hash value must be - -- agnostic to the elided details. - } - deriving Show - -defaultHashOptions :: HashOptions -defaultHashOptions = HashOptions True - - {-# INLINEABLE hashPreOpenAcc #-} hashPreOpenAcc :: HasArraysR acc => EncodeAcc acc -> PreOpenAcc acc aenv a -> Hash hashPreOpenAcc = hashPreOpenAccWith defaultHashOptions @@ -109,20 +62,6 @@ hashPreOpenAccWith options encodeAcc . toLazyByteString . encodePreOpenAcc options encodeAcc -{-# INLINEABLE hashOpenFun #-} -hashOpenFun :: OpenFun env aenv f -> Hash -hashOpenFun - = hashlazy - . toLazyByteString - . encodeOpenFun - -{-# INLINEABLE hashOpenExp #-} -hashOpenExp :: OpenExp env aenv t -> Hash -hashOpenExp - = hashlazy - . toLazyByteString - . encodeOpenExp - -- Array computations -- ------------------ @@ -238,31 +177,9 @@ encodePreOpenSeq encodeAcc s = Reify ix -> intHost $(hashQ "Reify") <> travV ix --} -encodeIdx :: Idx env t -> Builder -encodeIdx = intHost . idxToInt - encodeArray :: Array sh e -> Builder encodeArray ad = intHost . unsafePerformIO $! hashStableName <$> makeStableName ad -encodeTupR :: (forall b. s b -> Builder) -> TupR s a -> Builder -encodeTupR _ TupRunit = intHost $(hashQ "TupRunit") -encodeTupR f (TupRpair r1 r2) = intHost $(hashQ "TupRpair") <> encodeTupR f r1 <> encodeTupR f r2 -encodeTupR f (TupRsingle s) = intHost $(hashQ "TupRsingle") <> f s - -encodeLeftHandSide :: (forall b. s b -> Builder) -> LeftHandSide s a env env' -> Builder -encodeLeftHandSide f (LeftHandSideWildcard r) = intHost $(hashQ "LeftHandSideWildcard") <> encodeTupR f r -encodeLeftHandSide f (LeftHandSidePair r1 r2) = intHost $(hashQ "LeftHandSidePair") <> encodeLeftHandSide f r1 <> encodeLeftHandSide f r2 -encodeLeftHandSide f (LeftHandSideSingle s) = intHost $(hashQ "LeftHandSideArray") <> f s - -encodeArrayType :: ArrayR a -> Builder -encodeArrayType (ArrayR shr tp) = encodeShapeR shr <> encodeTypeR tp - -encodeArraysType :: ArraysR arrs -> Builder -encodeArraysType = encodeTupR encodeArrayType - -encodeShapeR :: ShapeR sh -> Builder -encodeShapeR = intHost . rank - encodePreOpenAfun :: forall acc aenv f. HashOptions @@ -289,216 +206,7 @@ encodeBoundary _ Mirror = intHost $(hashQ "Mirror") encodeBoundary tp (Constant c) = intHost $(hashQ "Constant") <> encodeConst tp c encodeBoundary _ (Function f) = intHost $(hashQ "Function") <> encodeOpenFun f -encodeSliceIndex :: SliceIndex slix sl co sh -> Builder -encodeSliceIndex SliceNil = intHost $(hashQ "SliceNil") -encodeSliceIndex (SliceAll r) = intHost $(hashQ "SliceAll") <> encodeSliceIndex r -encodeSliceIndex (SliceFixed r) = intHost $(hashQ "sliceFixed") <> encodeSliceIndex r - - --- Scalar expressions --- ------------------ - -{-# INLINEABLE encodeOpenExp #-} -encodeOpenExp - :: forall env aenv exp. - OpenExp env aenv exp - -> Builder -encodeOpenExp exp = - let - travE :: forall env' aenv' e. OpenExp env' aenv' e -> Builder - travE e = encodeOpenExp e - - travF :: OpenFun env' aenv' f -> Builder - travF = encodeOpenFun - in - case exp of - Let lhs bnd body -> intHost $(hashQ "Let") <> encodeLeftHandSide encodeScalarType lhs <> travE bnd <> travE body - Evar (Var tp ix) -> intHost $(hashQ "Evar") <> encodeScalarType tp <> encodeIdx ix - Nil -> intHost $(hashQ "Nil") - Pair e1 e2 -> intHost $(hashQ "Pair") <> travE e1 <> travE e2 - VecPack _ e -> intHost $(hashQ "VecPack") <> travE e - VecUnpack _ e -> intHost $(hashQ "VecUnpack") <> travE e - Const tp c -> intHost $(hashQ "Const") <> encodeScalarConst tp c - Undef tp -> intHost $(hashQ "Undef") <> encodeScalarType tp - IndexSlice spec ix sh -> intHost $(hashQ "IndexSlice") <> travE ix <> travE sh <> encodeSliceIndex spec - IndexFull spec ix sl -> intHost $(hashQ "IndexFull") <> travE ix <> travE sl <> encodeSliceIndex spec - ToIndex _ sh i -> intHost $(hashQ "ToIndex") <> travE sh <> travE i - FromIndex _ sh i -> intHost $(hashQ "FromIndex") <> travE sh <> travE i - Case e rhs def -> intHost $(hashQ "Case") <> travE e <> mconcat [ word8 t <> travE c | (t,c) <- rhs ] <> encodeMaybe travE def - Cond c t e -> intHost $(hashQ "Cond") <> travE c <> travE t <> travE e - While p f x -> intHost $(hashQ "While") <> travF p <> travF f <> travE x - PrimApp f x -> intHost $(hashQ "PrimApp") <> encodePrimFun f <> travE x - PrimConst c -> intHost $(hashQ "PrimConst") <> encodePrimConst c - Index a ix -> intHost $(hashQ "Index") <> encodeArrayVar a <> travE ix - LinearIndex a ix -> intHost $(hashQ "LinearIndex") <> encodeArrayVar a <> travE ix - Shape a -> intHost $(hashQ "Shape") <> encodeArrayVar a - ShapeSize _ sh -> intHost $(hashQ "ShapeSize") <> travE sh - Foreign _ _ f e -> intHost $(hashQ "Foreign") <> travF f <> travE e - Coerce _ tp e -> intHost $(hashQ "Coerce") <> encodeScalarType tp <> travE e - -encodeArrayVar :: ArrayVar aenv a -> Builder -encodeArrayVar (Var repr v) = encodeArrayType repr <> encodeIdx v - -{-# INLINEABLE encodeOpenFun #-} -encodeOpenFun - :: OpenFun env aenv f - -> Builder -encodeOpenFun (Body b) = intHost $(hashQ "Body") <> encodeOpenExp b -encodeOpenFun (Lam lhs l) = intHost $(hashQ "Lam") <> encodeLeftHandSide encodeScalarType lhs <> encodeOpenFun l - - encodeConst :: TypeR t -> t -> Builder encodeConst TupRunit () = intHost $(hashQ "nil") encodeConst (TupRsingle t) c = encodeScalarConst t c encodeConst (TupRpair ta tb) (a,b) = intHost $(hashQ "pair") <> encodeConst ta a <> encodeConst tb b - -encodeScalarConst :: ScalarType t -> t -> Builder -encodeScalarConst (SingleScalarType t) = encodeSingleConst t -encodeScalarConst (VectorScalarType t) = encodeVectorConst t - -encodeSingleConst :: SingleType t -> t -> Builder -encodeSingleConst (NumSingleType t) = encodeNumConst t - -encodeVectorConst :: VectorType (Vec n t) -> Vec n t -> Builder -encodeVectorConst (VectorType n t) (Vec ba#) = intHost $(hashQ "Vec") <> intHost n <> encodeSingleType t <> shortByteString (SBS ba#) - -encodeNumConst :: NumType t -> t -> Builder -encodeNumConst (IntegralNumType t) = encodeIntegralConst t -encodeNumConst (FloatingNumType t) = encodeFloatingConst t - -encodeIntegralConst :: IntegralType t -> t -> Builder -encodeIntegralConst TypeInt{} x = intHost $(hashQ "Int") <> intHost x -encodeIntegralConst TypeInt8{} x = intHost $(hashQ "Int8") <> int8 x -encodeIntegralConst TypeInt16{} x = intHost $(hashQ "Int16") <> int16Host x -encodeIntegralConst TypeInt32{} x = intHost $(hashQ "Int32") <> int32Host x -encodeIntegralConst TypeInt64{} x = intHost $(hashQ "Int64") <> int64Host x -encodeIntegralConst TypeWord{} x = intHost $(hashQ "Word") <> wordHost x -encodeIntegralConst TypeWord8{} x = intHost $(hashQ "Word8") <> word8 x -encodeIntegralConst TypeWord16{} x = intHost $(hashQ "Word16") <> word16Host x -encodeIntegralConst TypeWord32{} x = intHost $(hashQ "Word32") <> word32Host x -encodeIntegralConst TypeWord64{} x = intHost $(hashQ "Word64") <> word64Host x - -encodeFloatingConst :: FloatingType t -> t -> Builder -encodeFloatingConst TypeHalf{} (Half (CUShort x)) = intHost $(hashQ "Half") <> word16Host x -encodeFloatingConst TypeFloat{} x = intHost $(hashQ "Float") <> floatHost x -encodeFloatingConst TypeDouble{} x = intHost $(hashQ "Double") <> doubleHost x - -encodePrimConst :: PrimConst c -> Builder -encodePrimConst (PrimMinBound t) = intHost $(hashQ "PrimMinBound") <> encodeBoundedType t -encodePrimConst (PrimMaxBound t) = intHost $(hashQ "PrimMaxBound") <> encodeBoundedType t -encodePrimConst (PrimPi t) = intHost $(hashQ "PrimPi") <> encodeFloatingType t - -encodePrimFun :: PrimFun f -> Builder -encodePrimFun (PrimAdd a) = intHost $(hashQ "PrimAdd") <> encodeNumType a -encodePrimFun (PrimSub a) = intHost $(hashQ "PrimSub") <> encodeNumType a -encodePrimFun (PrimMul a) = intHost $(hashQ "PrimMul") <> encodeNumType a -encodePrimFun (PrimNeg a) = intHost $(hashQ "PrimNeg") <> encodeNumType a -encodePrimFun (PrimAbs a) = intHost $(hashQ "PrimAbs") <> encodeNumType a -encodePrimFun (PrimSig a) = intHost $(hashQ "PrimSig") <> encodeNumType a -encodePrimFun (PrimQuot a) = intHost $(hashQ "PrimQuot") <> encodeIntegralType a -encodePrimFun (PrimRem a) = intHost $(hashQ "PrimRem") <> encodeIntegralType a -encodePrimFun (PrimQuotRem a) = intHost $(hashQ "PrimQuotRem") <> encodeIntegralType a -encodePrimFun (PrimIDiv a) = intHost $(hashQ "PrimIDiv") <> encodeIntegralType a -encodePrimFun (PrimMod a) = intHost $(hashQ "PrimMod") <> encodeIntegralType a -encodePrimFun (PrimDivMod a) = intHost $(hashQ "PrimDivMod") <> encodeIntegralType a -encodePrimFun (PrimBAnd a) = intHost $(hashQ "PrimBAnd") <> encodeIntegralType a -encodePrimFun (PrimBOr a) = intHost $(hashQ "PrimBOr") <> encodeIntegralType a -encodePrimFun (PrimBXor a) = intHost $(hashQ "PrimBXor") <> encodeIntegralType a -encodePrimFun (PrimBNot a) = intHost $(hashQ "PrimBNot") <> encodeIntegralType a -encodePrimFun (PrimBShiftL a) = intHost $(hashQ "PrimBShiftL") <> encodeIntegralType a -encodePrimFun (PrimBShiftR a) = intHost $(hashQ "PrimBShiftR") <> encodeIntegralType a -encodePrimFun (PrimBRotateL a) = intHost $(hashQ "PrimBRotateL") <> encodeIntegralType a -encodePrimFun (PrimBRotateR a) = intHost $(hashQ "PrimBRotateR") <> encodeIntegralType a -encodePrimFun (PrimPopCount a) = intHost $(hashQ "PrimPopCount") <> encodeIntegralType a -encodePrimFun (PrimCountLeadingZeros a) = intHost $(hashQ "PrimCountLeadingZeros") <> encodeIntegralType a -encodePrimFun (PrimCountTrailingZeros a) = intHost $(hashQ "PrimCountTrailingZeros") <> encodeIntegralType a -encodePrimFun (PrimFDiv a) = intHost $(hashQ "PrimFDiv") <> encodeFloatingType a -encodePrimFun (PrimRecip a) = intHost $(hashQ "PrimRecip") <> encodeFloatingType a -encodePrimFun (PrimSin a) = intHost $(hashQ "PrimSin") <> encodeFloatingType a -encodePrimFun (PrimCos a) = intHost $(hashQ "PrimCos") <> encodeFloatingType a -encodePrimFun (PrimTan a) = intHost $(hashQ "PrimTan") <> encodeFloatingType a -encodePrimFun (PrimAsin a) = intHost $(hashQ "PrimAsin") <> encodeFloatingType a -encodePrimFun (PrimAcos a) = intHost $(hashQ "PrimAcos") <> encodeFloatingType a -encodePrimFun (PrimAtan a) = intHost $(hashQ "PrimAtan") <> encodeFloatingType a -encodePrimFun (PrimSinh a) = intHost $(hashQ "PrimSinh") <> encodeFloatingType a -encodePrimFun (PrimCosh a) = intHost $(hashQ "PrimCosh") <> encodeFloatingType a -encodePrimFun (PrimTanh a) = intHost $(hashQ "PrimTanh") <> encodeFloatingType a -encodePrimFun (PrimAsinh a) = intHost $(hashQ "PrimAsinh") <> encodeFloatingType a -encodePrimFun (PrimAcosh a) = intHost $(hashQ "PrimAcosh") <> encodeFloatingType a -encodePrimFun (PrimAtanh a) = intHost $(hashQ "PrimAtanh") <> encodeFloatingType a -encodePrimFun (PrimExpFloating a) = intHost $(hashQ "PrimExpFloating") <> encodeFloatingType a -encodePrimFun (PrimSqrt a) = intHost $(hashQ "PrimSqrt") <> encodeFloatingType a -encodePrimFun (PrimLog a) = intHost $(hashQ "PrimLog") <> encodeFloatingType a -encodePrimFun (PrimFPow a) = intHost $(hashQ "PrimFPow") <> encodeFloatingType a -encodePrimFun (PrimLogBase a) = intHost $(hashQ "PrimLogBase") <> encodeFloatingType a -encodePrimFun (PrimAtan2 a) = intHost $(hashQ "PrimAtan2") <> encodeFloatingType a -encodePrimFun (PrimTruncate a b) = intHost $(hashQ "PrimTruncate") <> encodeFloatingType a <> encodeIntegralType b -encodePrimFun (PrimRound a b) = intHost $(hashQ "PrimRound") <> encodeFloatingType a <> encodeIntegralType b -encodePrimFun (PrimFloor a b) = intHost $(hashQ "PrimFloor") <> encodeFloatingType a <> encodeIntegralType b -encodePrimFun (PrimCeiling a b) = intHost $(hashQ "PrimCeiling") <> encodeFloatingType a <> encodeIntegralType b -encodePrimFun (PrimIsNaN a) = intHost $(hashQ "PrimIsNaN") <> encodeFloatingType a -encodePrimFun (PrimIsInfinite a) = intHost $(hashQ "PrimIsInfinite") <> encodeFloatingType a -encodePrimFun (PrimLt a) = intHost $(hashQ "PrimLt") <> encodeSingleType a -encodePrimFun (PrimGt a) = intHost $(hashQ "PrimGt") <> encodeSingleType a -encodePrimFun (PrimLtEq a) = intHost $(hashQ "PrimLtEq") <> encodeSingleType a -encodePrimFun (PrimGtEq a) = intHost $(hashQ "PrimGtEq") <> encodeSingleType a -encodePrimFun (PrimEq a) = intHost $(hashQ "PrimEq") <> encodeSingleType a -encodePrimFun (PrimNEq a) = intHost $(hashQ "PrimNEq") <> encodeSingleType a -encodePrimFun (PrimMax a) = intHost $(hashQ "PrimMax") <> encodeSingleType a -encodePrimFun (PrimMin a) = intHost $(hashQ "PrimMin") <> encodeSingleType a -encodePrimFun (PrimFromIntegral a b) = intHost $(hashQ "PrimFromIntegral") <> encodeIntegralType a <> encodeNumType b -encodePrimFun (PrimToFloating a b) = intHost $(hashQ "PrimToFloating") <> encodeNumType a <> encodeFloatingType b -encodePrimFun PrimLAnd = intHost $(hashQ "PrimLAnd") -encodePrimFun PrimLOr = intHost $(hashQ "PrimLOr") -encodePrimFun PrimLNot = intHost $(hashQ "PrimLNot") - - -encodeTypeR :: TypeR t -> Builder -encodeTypeR TupRunit = intHost $(hashQ "TupRunit") -encodeTypeR (TupRsingle t) = intHost $(hashQ "TupRsingle") <> encodeScalarType t -encodeTypeR (TupRpair a b) = intHost $(hashQ "TupRpair") <> encodeTypeR a <> intHost (depthTypeR a) - <> encodeTypeR b <> intHost (depthTypeR b) - -depthTypeR :: TypeR t -> Int -depthTypeR TupRunit = 0 -depthTypeR TupRsingle{} = 1 -depthTypeR (TupRpair a b) = depthTypeR a + depthTypeR b - -encodeScalarType :: ScalarType t -> Builder -encodeScalarType (SingleScalarType t) = intHost $(hashQ "SingleScalarType") <> encodeSingleType t -encodeScalarType (VectorScalarType t) = intHost $(hashQ "VectorScalarType") <> encodeVectorType t - -encodeSingleType :: SingleType t -> Builder -encodeSingleType (NumSingleType t) = intHost $(hashQ "NumSingleType") <> encodeNumType t - -encodeVectorType :: VectorType (Vec n t) -> Builder -encodeVectorType (VectorType n t) = intHost $(hashQ "VectorType") <> intHost n <> encodeSingleType t - -encodeBoundedType :: BoundedType t -> Builder -encodeBoundedType (IntegralBoundedType t) = intHost $(hashQ "IntegralBoundedType") <> encodeIntegralType t - -encodeNumType :: NumType t -> Builder -encodeNumType (IntegralNumType t) = intHost $(hashQ "IntegralNumType") <> encodeIntegralType t -encodeNumType (FloatingNumType t) = intHost $(hashQ "FloatingNumType") <> encodeFloatingType t - -encodeIntegralType :: IntegralType t -> Builder -encodeIntegralType TypeInt{} = intHost $(hashQ "Int") -encodeIntegralType TypeInt8{} = intHost $(hashQ "Int8") -encodeIntegralType TypeInt16{} = intHost $(hashQ "Int16") -encodeIntegralType TypeInt32{} = intHost $(hashQ "Int32") -encodeIntegralType TypeInt64{} = intHost $(hashQ "Int64") -encodeIntegralType TypeWord{} = intHost $(hashQ "Word") -encodeIntegralType TypeWord8{} = intHost $(hashQ "Word8") -encodeIntegralType TypeWord16{} = intHost $(hashQ "Word16") -encodeIntegralType TypeWord32{} = intHost $(hashQ "Word32") -encodeIntegralType TypeWord64{} = intHost $(hashQ "Word64") - -encodeFloatingType :: FloatingType t -> Builder -encodeFloatingType TypeHalf{} = intHost $(hashQ "Half") -encodeFloatingType TypeFloat{} = intHost $(hashQ "Float") -encodeFloatingType TypeDouble{} = intHost $(hashQ "Double") - -encodeMaybe :: (a -> Builder) -> Maybe a -> Builder -encodeMaybe _ Nothing = intHost $(hashQ "Nothing") -encodeMaybe f (Just x) = intHost $(hashQ "Just") <> f x - diff --git a/src/Data/Array/Accelerate/Analysis/Hash/Exp.hs b/src/Data/Array/Accelerate/Analysis/Hash/Exp.hs new file mode 100644 index 000000000..d752f8516 --- /dev/null +++ b/src/Data/Array/Accelerate/Analysis/Hash/Exp.hs @@ -0,0 +1,340 @@ +{-# LANGUAGE AllowAmbiguousTypes #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternGuards #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} +{-# OPTIONS_HADDOCK hide #-} +-- | +-- Module : Data.Array.Accelerate.Analysis.Hash.Exp +-- Copyright : [2017..2020] The Accelerate Team +-- License : BSD3 +-- +-- Maintainer : Trevor L. McDonell +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- + +module Data.Array.Accelerate.Analysis.Hash.Exp ( + Hash, + HashOptions(..), defaultHashOptions, + hashOpenFun, hashOpenExp, + encodeOpenExp, + encodeOpenFun, + + encodeExpVar, + encodeLeftHandSide, + encodeTupR, + encodeArraysType, + encodeArrayType, + encodeIdx, + encodeScalarType, + encodeScalarConst, + encodeTypeR, + encodeSliceIndex, + encodeMaybe, + encodeIntegralType, + hashQ, + Builder, + +) where + +import Data.Array.Accelerate.AST.Exp +import Data.Array.Accelerate.AST.Idx +import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.AST.Var +import Data.Array.Accelerate.Analysis.Hash.TH +import Data.Array.Accelerate.Representation.Array +import Data.Array.Accelerate.Representation.Shape +import Data.Array.Accelerate.Representation.Slice +import Data.Array.Accelerate.Representation.Type +import Data.Array.Accelerate.Type +import Data.Primitive.Vec + +import Crypto.Hash +import Data.ByteString.Builder +import Data.ByteString.Builder.Extra +import Data.ByteString.Short.Internal ( ShortByteString(..) ) +import Data.Monoid +import Prelude hiding ( exp ) + +-- Hashing +-- ------- + +type Hash = Digest SHA3_256 + +data HashOptions = HashOptions + { perfect :: Bool + -- ^ Should the hash function include _all_ substructure, recursively? + -- + -- Set to true (the default) if you want a truly unique fingerprint for + -- the entire expression: + -- + -- Example: + -- + -- xs, ys :: Acc (Vector Float) + -- xs = fill (constant (Z:.10)) 1.0 + -- ys = fill (constant (Z:.20)) 1.0 + -- + -- with perfect=True: + -- + -- hash xs = 2e1f91aca4c476d13b36f22462e73c15bbdd9fcacb0d4996280f6004058e9732 + -- hash ys = 2fce5c849b6c652192b09aaeafdc8029e57b9f006c1ecd79ccf9114f349aaf9e + -- + -- However, for a code generating backend the object code used to + -- evaluate both of these expressions is likely to be identical. + -- + -- Setting perfect=False results in: + -- + -- hash xs = hash ys = f97944b0ec64ab8aa989fd60c8b50e7ec3eff759d22d2b340039d837d74dfc3c + -- + -- Note that to be useful the provided 'EncodeAcc' function must also + -- understand this option, and the consumer of the hash value must be + -- agnostic to the elided details. + } + deriving Show + +defaultHashOptions :: HashOptions +defaultHashOptions = HashOptions True + + +{-# INLINEABLE hashOpenFun #-} +hashOpenFun :: IsArrayInstr arr => PreOpenFun arr env f -> Hash +hashOpenFun + = hashlazy + . toLazyByteString + . encodeOpenFun + +{-# INLINEABLE hashOpenExp #-} +hashOpenExp :: IsArrayInstr arr => PreOpenExp arr env t -> Hash +hashOpenExp + = hashlazy + . toLazyByteString + . encodeOpenExp + +encodeIdx :: Idx env t -> Builder +encodeIdx = intHost . idxToInt + +encodeTupR :: (forall b. s b -> Builder) -> TupR s a -> Builder +encodeTupR _ TupRunit = intHost $(hashQ "TupRunit") +encodeTupR f (TupRpair r1 r2) = intHost $(hashQ "TupRpair") <> encodeTupR f r1 <> encodeTupR f r2 +encodeTupR f (TupRsingle s) = intHost $(hashQ "TupRsingle") <> f s + +encodeLeftHandSide :: (forall b. s b -> Builder) -> LeftHandSide s a env env' -> Builder +encodeLeftHandSide f (LeftHandSideWildcard r) = intHost $(hashQ "LeftHandSideWildcard") <> encodeTupR f r +encodeLeftHandSide f (LeftHandSidePair r1 r2) = intHost $(hashQ "LeftHandSidePair") <> encodeLeftHandSide f r1 <> encodeLeftHandSide f r2 +encodeLeftHandSide f (LeftHandSideSingle s) = intHost $(hashQ "LeftHandSideArray") <> f s + +encodeArrayType :: ArrayR a -> Builder +encodeArrayType (ArrayR shr tp) = encodeShapeR shr <> encodeTypeR tp + +encodeArraysType :: ArraysR arrs -> Builder +encodeArraysType = encodeTupR encodeArrayType + +encodeShapeR :: ShapeR sh -> Builder +encodeShapeR = intHost . rank + +{-# INLINEABLE encodeOpenExp #-} +encodeOpenExp + :: forall arr env exp. + IsArrayInstr arr + => PreOpenExp arr env exp + -> Builder +encodeOpenExp exp = + let + travE :: forall env' e. PreOpenExp arr env' e -> Builder + travE e = encodeOpenExp e + + travF :: PreOpenFun arr env' f -> Builder + travF = encodeOpenFun + in + case exp of + Let lhs bnd body -> intHost $(hashQ "Let") <> encodeLeftHandSide encodeScalarType lhs <> travE bnd <> travE body + Evar var -> intHost $(hashQ "Evar") <> encodeExpVar var + Nil -> intHost $(hashQ "Nil") + Pair e1 e2 -> intHost $(hashQ "Pair") <> travE e1 <> travE e2 + VecPack _ e -> intHost $(hashQ "VecPack") <> travE e + VecUnpack _ e -> intHost $(hashQ "VecUnpack") <> travE e + Const tp c -> intHost $(hashQ "Const") <> encodeScalarConst tp c + Undef tp -> intHost $(hashQ "Undef") <> encodeScalarType tp + IndexSlice spec ix sh -> intHost $(hashQ "IndexSlice") <> travE ix <> travE sh <> encodeSliceIndex spec + IndexFull spec ix sl -> intHost $(hashQ "IndexFull") <> travE ix <> travE sl <> encodeSliceIndex spec + ToIndex _ sh i -> intHost $(hashQ "ToIndex") <> travE sh <> travE i + FromIndex _ sh i -> intHost $(hashQ "FromIndex") <> travE sh <> travE i + Case e rhs def -> intHost $(hashQ "Case") <> travE e <> mconcat [ word8 t <> travE c | (t,c) <- rhs ] <> encodeMaybe travE def + Cond c t e -> intHost $(hashQ "Cond") <> travE c <> travE t <> travE e + While p f x -> intHost $(hashQ "While") <> travF p <> travF f <> travE x + PrimApp f x -> intHost $(hashQ "PrimApp") <> encodePrimFun f <> travE x + PrimConst c -> intHost $(hashQ "PrimConst") <> encodePrimConst c + ArrayInstr arr e -> intHost $(hashQ "ArrayInstr") <> encodeArrayInstr arr <> travE e + ShapeSize _ sh -> intHost $(hashQ "ShapeSize") <> travE sh + Foreign _ _ f e -> intHost $(hashQ "Foreign") <> encodeOpenFun f <> travE e + Coerce _ tp e -> intHost $(hashQ "Coerce") <> encodeScalarType tp <> travE e + +encodeExpVar :: ExpVar env t -> Builder +encodeExpVar (Var tp ix) = encodeScalarType tp <> encodeIdx ix + +{-# INLINEABLE encodeOpenFun #-} +encodeOpenFun + :: IsArrayInstr arr + => PreOpenFun arr env f + -> Builder +encodeOpenFun (Body b) = intHost $(hashQ "Body") <> encodeOpenExp b +encodeOpenFun (Lam lhs l) = intHost $(hashQ "Lam") <> encodeLeftHandSide encodeScalarType lhs <> encodeOpenFun l + +encodeScalarConst :: ScalarType t -> t -> Builder +encodeScalarConst (SingleScalarType t) = encodeSingleConst t +encodeScalarConst (VectorScalarType t) = encodeVectorConst t + +encodeSingleConst :: SingleType t -> t -> Builder +encodeSingleConst (NumSingleType t) = encodeNumConst t + +encodeVectorConst :: VectorType (Vec n t) -> Vec n t -> Builder +encodeVectorConst (VectorType n t) (Vec ba#) = intHost $(hashQ "Vec") <> intHost n <> encodeSingleType t <> shortByteString (SBS ba#) + +encodeNumConst :: NumType t -> t -> Builder +encodeNumConst (IntegralNumType t) = encodeIntegralConst t +encodeNumConst (FloatingNumType t) = encodeFloatingConst t + +encodeIntegralConst :: IntegralType t -> t -> Builder +encodeIntegralConst TypeInt{} x = intHost $(hashQ "Int") <> intHost x +encodeIntegralConst TypeInt8{} x = intHost $(hashQ "Int8") <> int8 x +encodeIntegralConst TypeInt16{} x = intHost $(hashQ "Int16") <> int16Host x +encodeIntegralConst TypeInt32{} x = intHost $(hashQ "Int32") <> int32Host x +encodeIntegralConst TypeInt64{} x = intHost $(hashQ "Int64") <> int64Host x +encodeIntegralConst TypeWord{} x = intHost $(hashQ "Word") <> wordHost x +encodeIntegralConst TypeWord8{} x = intHost $(hashQ "Word8") <> word8 x +encodeIntegralConst TypeWord16{} x = intHost $(hashQ "Word16") <> word16Host x +encodeIntegralConst TypeWord32{} x = intHost $(hashQ "Word32") <> word32Host x +encodeIntegralConst TypeWord64{} x = intHost $(hashQ "Word64") <> word64Host x + +encodeFloatingConst :: FloatingType t -> t -> Builder +encodeFloatingConst TypeHalf{} (Half (CUShort x)) = intHost $(hashQ "Half") <> word16Host x +encodeFloatingConst TypeFloat{} x = intHost $(hashQ "Float") <> floatHost x +encodeFloatingConst TypeDouble{} x = intHost $(hashQ "Double") <> doubleHost x + +encodePrimConst :: PrimConst c -> Builder +encodePrimConst (PrimMinBound t) = intHost $(hashQ "PrimMinBound") <> encodeBoundedType t +encodePrimConst (PrimMaxBound t) = intHost $(hashQ "PrimMaxBound") <> encodeBoundedType t +encodePrimConst (PrimPi t) = intHost $(hashQ "PrimPi") <> encodeFloatingType t + +encodePrimFun :: PrimFun f -> Builder +encodePrimFun (PrimAdd a) = intHost $(hashQ "PrimAdd") <> encodeNumType a +encodePrimFun (PrimSub a) = intHost $(hashQ "PrimSub") <> encodeNumType a +encodePrimFun (PrimMul a) = intHost $(hashQ "PrimMul") <> encodeNumType a +encodePrimFun (PrimNeg a) = intHost $(hashQ "PrimNeg") <> encodeNumType a +encodePrimFun (PrimAbs a) = intHost $(hashQ "PrimAbs") <> encodeNumType a +encodePrimFun (PrimSig a) = intHost $(hashQ "PrimSig") <> encodeNumType a +encodePrimFun (PrimQuot a) = intHost $(hashQ "PrimQuot") <> encodeIntegralType a +encodePrimFun (PrimRem a) = intHost $(hashQ "PrimRem") <> encodeIntegralType a +encodePrimFun (PrimQuotRem a) = intHost $(hashQ "PrimQuotRem") <> encodeIntegralType a +encodePrimFun (PrimIDiv a) = intHost $(hashQ "PrimIDiv") <> encodeIntegralType a +encodePrimFun (PrimMod a) = intHost $(hashQ "PrimMod") <> encodeIntegralType a +encodePrimFun (PrimDivMod a) = intHost $(hashQ "PrimDivMod") <> encodeIntegralType a +encodePrimFun (PrimBAnd a) = intHost $(hashQ "PrimBAnd") <> encodeIntegralType a +encodePrimFun (PrimBOr a) = intHost $(hashQ "PrimBOr") <> encodeIntegralType a +encodePrimFun (PrimBXor a) = intHost $(hashQ "PrimBXor") <> encodeIntegralType a +encodePrimFun (PrimBNot a) = intHost $(hashQ "PrimBNot") <> encodeIntegralType a +encodePrimFun (PrimBShiftL a) = intHost $(hashQ "PrimBShiftL") <> encodeIntegralType a +encodePrimFun (PrimBShiftR a) = intHost $(hashQ "PrimBShiftR") <> encodeIntegralType a +encodePrimFun (PrimBRotateL a) = intHost $(hashQ "PrimBRotateL") <> encodeIntegralType a +encodePrimFun (PrimBRotateR a) = intHost $(hashQ "PrimBRotateR") <> encodeIntegralType a +encodePrimFun (PrimPopCount a) = intHost $(hashQ "PrimPopCount") <> encodeIntegralType a +encodePrimFun (PrimCountLeadingZeros a) = intHost $(hashQ "PrimCountLeadingZeros") <> encodeIntegralType a +encodePrimFun (PrimCountTrailingZeros a) = intHost $(hashQ "PrimCountTrailingZeros") <> encodeIntegralType a +encodePrimFun (PrimFDiv a) = intHost $(hashQ "PrimFDiv") <> encodeFloatingType a +encodePrimFun (PrimRecip a) = intHost $(hashQ "PrimRecip") <> encodeFloatingType a +encodePrimFun (PrimSin a) = intHost $(hashQ "PrimSin") <> encodeFloatingType a +encodePrimFun (PrimCos a) = intHost $(hashQ "PrimCos") <> encodeFloatingType a +encodePrimFun (PrimTan a) = intHost $(hashQ "PrimTan") <> encodeFloatingType a +encodePrimFun (PrimAsin a) = intHost $(hashQ "PrimAsin") <> encodeFloatingType a +encodePrimFun (PrimAcos a) = intHost $(hashQ "PrimAcos") <> encodeFloatingType a +encodePrimFun (PrimAtan a) = intHost $(hashQ "PrimAtan") <> encodeFloatingType a +encodePrimFun (PrimSinh a) = intHost $(hashQ "PrimSinh") <> encodeFloatingType a +encodePrimFun (PrimCosh a) = intHost $(hashQ "PrimCosh") <> encodeFloatingType a +encodePrimFun (PrimTanh a) = intHost $(hashQ "PrimTanh") <> encodeFloatingType a +encodePrimFun (PrimAsinh a) = intHost $(hashQ "PrimAsinh") <> encodeFloatingType a +encodePrimFun (PrimAcosh a) = intHost $(hashQ "PrimAcosh") <> encodeFloatingType a +encodePrimFun (PrimAtanh a) = intHost $(hashQ "PrimAtanh") <> encodeFloatingType a +encodePrimFun (PrimExpFloating a) = intHost $(hashQ "PrimExpFloating") <> encodeFloatingType a +encodePrimFun (PrimSqrt a) = intHost $(hashQ "PrimSqrt") <> encodeFloatingType a +encodePrimFun (PrimLog a) = intHost $(hashQ "PrimLog") <> encodeFloatingType a +encodePrimFun (PrimFPow a) = intHost $(hashQ "PrimFPow") <> encodeFloatingType a +encodePrimFun (PrimLogBase a) = intHost $(hashQ "PrimLogBase") <> encodeFloatingType a +encodePrimFun (PrimAtan2 a) = intHost $(hashQ "PrimAtan2") <> encodeFloatingType a +encodePrimFun (PrimTruncate a b) = intHost $(hashQ "PrimTruncate") <> encodeFloatingType a <> encodeIntegralType b +encodePrimFun (PrimRound a b) = intHost $(hashQ "PrimRound") <> encodeFloatingType a <> encodeIntegralType b +encodePrimFun (PrimFloor a b) = intHost $(hashQ "PrimFloor") <> encodeFloatingType a <> encodeIntegralType b +encodePrimFun (PrimCeiling a b) = intHost $(hashQ "PrimCeiling") <> encodeFloatingType a <> encodeIntegralType b +encodePrimFun (PrimIsNaN a) = intHost $(hashQ "PrimIsNaN") <> encodeFloatingType a +encodePrimFun (PrimIsInfinite a) = intHost $(hashQ "PrimIsInfinite") <> encodeFloatingType a +encodePrimFun (PrimLt a) = intHost $(hashQ "PrimLt") <> encodeSingleType a +encodePrimFun (PrimGt a) = intHost $(hashQ "PrimGt") <> encodeSingleType a +encodePrimFun (PrimLtEq a) = intHost $(hashQ "PrimLtEq") <> encodeSingleType a +encodePrimFun (PrimGtEq a) = intHost $(hashQ "PrimGtEq") <> encodeSingleType a +encodePrimFun (PrimEq a) = intHost $(hashQ "PrimEq") <> encodeSingleType a +encodePrimFun (PrimNEq a) = intHost $(hashQ "PrimNEq") <> encodeSingleType a +encodePrimFun (PrimMax a) = intHost $(hashQ "PrimMax") <> encodeSingleType a +encodePrimFun (PrimMin a) = intHost $(hashQ "PrimMin") <> encodeSingleType a +encodePrimFun (PrimFromIntegral a b) = intHost $(hashQ "PrimFromIntegral") <> encodeIntegralType a <> encodeNumType b +encodePrimFun (PrimToFloating a b) = intHost $(hashQ "PrimToFloating") <> encodeNumType a <> encodeFloatingType b +encodePrimFun PrimLAnd = intHost $(hashQ "PrimLAnd") +encodePrimFun PrimLOr = intHost $(hashQ "PrimLOr") +encodePrimFun PrimLNot = intHost $(hashQ "PrimLNot") + + +encodeTypeR :: TypeR t -> Builder +encodeTypeR TupRunit = intHost $(hashQ "TupRunit") +encodeTypeR (TupRsingle t) = intHost $(hashQ "TupRsingle") <> encodeScalarType t +encodeTypeR (TupRpair a b) = intHost $(hashQ "TupRpair") <> encodeTypeR a <> intHost (depthTypeR a) + <> encodeTypeR b <> intHost (depthTypeR b) + +depthTypeR :: TypeR t -> Int +depthTypeR TupRunit = 0 +depthTypeR TupRsingle{} = 1 +depthTypeR (TupRpair a b) = depthTypeR a + depthTypeR b + +encodeScalarType :: ScalarType t -> Builder +encodeScalarType (SingleScalarType t) = intHost $(hashQ "SingleScalarType") <> encodeSingleType t +encodeScalarType (VectorScalarType t) = intHost $(hashQ "VectorScalarType") <> encodeVectorType t + +encodeSingleType :: SingleType t -> Builder +encodeSingleType (NumSingleType t) = intHost $(hashQ "NumSingleType") <> encodeNumType t + +encodeVectorType :: VectorType (Vec n t) -> Builder +encodeVectorType (VectorType n t) = intHost $(hashQ "VectorType") <> intHost n <> encodeSingleType t + +encodeBoundedType :: BoundedType t -> Builder +encodeBoundedType (IntegralBoundedType t) = intHost $(hashQ "IntegralBoundedType") <> encodeIntegralType t + +encodeNumType :: NumType t -> Builder +encodeNumType (IntegralNumType t) = intHost $(hashQ "IntegralNumType") <> encodeIntegralType t +encodeNumType (FloatingNumType t) = intHost $(hashQ "FloatingNumType") <> encodeFloatingType t + +encodeIntegralType :: IntegralType t -> Builder +encodeIntegralType TypeInt{} = intHost $(hashQ "Int") +encodeIntegralType TypeInt8{} = intHost $(hashQ "Int8") +encodeIntegralType TypeInt16{} = intHost $(hashQ "Int16") +encodeIntegralType TypeInt32{} = intHost $(hashQ "Int32") +encodeIntegralType TypeInt64{} = intHost $(hashQ "Int64") +encodeIntegralType TypeWord{} = intHost $(hashQ "Word") +encodeIntegralType TypeWord8{} = intHost $(hashQ "Word8") +encodeIntegralType TypeWord16{} = intHost $(hashQ "Word16") +encodeIntegralType TypeWord32{} = intHost $(hashQ "Word32") +encodeIntegralType TypeWord64{} = intHost $(hashQ "Word64") + +encodeFloatingType :: FloatingType t -> Builder +encodeFloatingType TypeHalf{} = intHost $(hashQ "Half") +encodeFloatingType TypeFloat{} = intHost $(hashQ "Float") +encodeFloatingType TypeDouble{} = intHost $(hashQ "Double") + +encodeSliceIndex :: SliceIndex slix sl co sh -> Builder +encodeSliceIndex SliceNil = intHost $(hashQ "SliceNil") +encodeSliceIndex (SliceAll r) = intHost $(hashQ "SliceAll") <> encodeSliceIndex r +encodeSliceIndex (SliceFixed r) = intHost $(hashQ "sliceFixed") <> encodeSliceIndex r + +encodeMaybe :: (a -> Builder) -> Maybe a -> Builder +encodeMaybe _ Nothing = intHost $(hashQ "Nothing") +encodeMaybe f (Just x) = intHost $(hashQ "Just") <> f x diff --git a/src/Data/Array/Accelerate/Analysis/Match.hs b/src/Data/Array/Accelerate/Analysis/Match.hs index 98a0818a4..d15de606c 100644 --- a/src/Data/Array/Accelerate/Analysis/Match.hs +++ b/src/Data/Array/Accelerate/Analysis/Match.hs @@ -432,9 +432,10 @@ matchArrayR _ _ = Nothing -- {-# INLINEABLE matchOpenExp #-} matchOpenExp - :: forall env aenv s t. - OpenExp env aenv s - -> OpenExp env aenv t + :: forall arr env s t. + IsArrayInstr arr + => PreOpenExp arr env s + -> PreOpenExp arr env t -> Maybe (s :~: t) matchOpenExp (Let lhs1 x1 e1) (Let lhs2 x2 e2) @@ -523,18 +524,9 @@ matchOpenExp (PrimApp f1 x1) (PrimApp f2 x2) , Just Refl <- matchPrimFun f1 f2 = Just Refl -matchOpenExp (Index a1 x1) (Index a2 x2) - | Just Refl <- matchVar a1 a2 - , Just Refl <- matchOpenExp x1 x2 - = Just Refl - -matchOpenExp (LinearIndex a1 x1) (LinearIndex a2 x2) - | Just Refl <- matchVar a1 a2 - , Just Refl <- matchOpenExp x1 x2 - = Just Refl - -matchOpenExp (Shape a1) (Shape a2) - | Just Refl <- matchVar a1 a2 +matchOpenExp (ArrayInstr arr1 e1) (ArrayInstr arr2 e2) + | Just Refl <- matchArrayInstr arr1 arr2 + , Just Refl <- matchOpenExp e1 e2 = Just Refl matchOpenExp (ShapeSize _ sh1) (ShapeSize _ sh2) @@ -549,8 +541,9 @@ matchOpenExp _ _ -- {-# INLINEABLE matchOpenFun #-} matchOpenFun - :: OpenFun env aenv s - -> OpenFun env aenv t + :: IsArrayInstr arr + => PreOpenFun arr env s + -> PreOpenFun arr env t -> Maybe (s :~: t) matchOpenFun (Lam lhs1 s) (Lam lhs2 t) | Just Refl <- matchELeftHandSide lhs1 lhs2 @@ -582,29 +575,6 @@ evalEqNum (IntegralNumType t) | IntegralDict <- integralDict t = uncurry (==) evalEqNum (FloatingNumType t) | FloatingDict <- floatingDict t = uncurry (==) --- Environment projection indices --- -{-# INLINEABLE matchIdx #-} -matchIdx :: Idx env s -> Idx env t -> Maybe (s :~: t) -matchIdx ZeroIdx ZeroIdx = Just Refl -matchIdx (SuccIdx u) (SuccIdx v) = matchIdx u v -matchIdx _ _ = Nothing - -{-# INLINEABLE matchVar #-} -matchVar :: Var s env t1 -> Var s env t2 -> Maybe (t1 :~: t2) -matchVar (Var _ v1) (Var _ v2) = matchIdx v1 v2 - -{-# INLINEABLE matchVars #-} -matchVars :: Vars s env t1 -> Vars s env t2 -> Maybe (t1 :~: t2) -matchVars TupRunit TupRunit = Just Refl -matchVars (TupRsingle v1) (TupRsingle v2) - | Just Refl <- matchVar v1 v2 = Just Refl -matchVars (TupRpair v w) (TupRpair x y) - | Just Refl <- matchVars v x - , Just Refl <- matchVars w y = Just Refl -matchVars _ _ = Nothing - - -- Slice specifications -- matchSliceIndex :: SliceIndex slix1 sl1 co1 sh1 -> SliceIndex slix2 sl2 co2 sh2 -> Maybe (SliceIndex slix1 sl1 co1 sh1 :~: SliceIndex slix2 sl2 co2 sh2) @@ -890,10 +860,11 @@ matchFloatingType _ _ = Nothing -- commutativity. -- commutes - :: forall env aenv a r. - PrimFun (a -> r) - -> OpenExp env aenv a - -> Maybe (OpenExp env aenv a) + :: forall arr env a r. + IsArrayInstr arr + => PrimFun (a -> r) + -> PreOpenExp arr env a + -> Maybe (PreOpenExp arr env a) commutes f x = case f of PrimAdd{} -> Just (swizzle x) PrimMul{} -> Just (swizzle x) @@ -908,7 +879,7 @@ commutes f x = case f of PrimLOr -> Just (swizzle x) _ -> Nothing where - swizzle :: OpenExp env aenv (a',a') -> OpenExp env aenv (a',a') + swizzle :: PreOpenExp arr env (a',a') -> PreOpenExp arr env (a',a') swizzle exp | (a `Pair` b) <- exp , hashOpenExp a > hashOpenExp b = b `Pair` a diff --git a/src/Data/Array/Accelerate/Interpreter.hs b/src/Data/Array/Accelerate/Interpreter.hs index eaac9fd8f..d4369fdbf 100644 --- a/src/Data/Array/Accelerate/Interpreter.hs +++ b/src/Data/Array/Accelerate/Interpreter.hs @@ -54,6 +54,7 @@ import Data.Array.Accelerate.Representation.Tag import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Representation.Vec import Data.Array.Accelerate.Trafo +import Data.Array.Accelerate.Trafo.Exp.Substitution import Data.Array.Accelerate.Trafo.Delayed ( DelayedOpenAfun, DelayedOpenAcc ) import Data.Array.Accelerate.Trafo.Sharing ( AfunctionR, AfunctionRepr(..), afunctionRepr ) import Data.Array.Accelerate.Type @@ -976,14 +977,15 @@ evalOpenExp pexp env aenv = | toBool (p x) = go (f x) | otherwise = x - Index acc ix -> let (TupRsingle repr, a) = evalA acc + ArrayInstr (Index acc) ix -> let (TupRsingle repr, a) = evalA acc in (repr, a) ! evalE ix - LinearIndex acc i -> let (TupRsingle repr, a) = evalA acc + ArrayInstr (LinearIndex acc) i + -> let (TupRsingle repr, a) = evalA acc ix = fromIndex (arrayRshape repr) (shape a) (evalE i) in (repr, a) ! ix - Shape acc -> shape $ snd $ evalA acc + ArrayInstr (Shape acc) _ -> shape $ snd $ evalA acc ShapeSize shr sh -> size shr (evalE sh) - Foreign _ _ f e -> evalOpenFun f Empty Empty $ evalE e + Foreign _ _ f e -> evalOpenFun (rebuildNoArrayInstr f) Empty Empty $ evalE e Coerce t1 t2 e -> evalCoerceScalar t1 t2 (evalE e) diff --git a/src/Data/Array/Accelerate/Pretty/Graphviz.hs b/src/Data/Array/Accelerate/Pretty/Graphviz.hs index 8ebe845eb..fa845763d 100644 --- a/src/Data/Array/Accelerate/Pretty/Graphviz.hs +++ b/src/Data/Array/Accelerate/Pretty/Graphviz.hs @@ -213,8 +213,8 @@ prettyDelayedOpenAcc detail ctx aenv atop@(Manifest pacc) = deps = (vt, Just "T") : (ve, Just "F") : map (,port) vs return $ PNode ident doc deps - Apply _ afun acc -> apply <$> prettyDelayedAfun detail aenv afun - <*> prettyDelayedOpenAcc detail ctx aenv acc + Apply _ afun acc -> apply' <$> prettyDelayedAfun detail aenv afun + <*> prettyDelayedOpenAcc detail ctx aenv acc Awhile p f x -> do ident <- mkNodeId atop @@ -303,7 +303,7 @@ prettyDelayedOpenAcc detail ctx aenv atop@(Manifest pacc) = ident <- mkNode acc' (Just v) return $ PDoc (pretty v) [Vertex ident Nothing] ppA (Delayed _ sh f _) - | Shape a <- sh -- identical shape + | (ArrayInstr (Shape a) _) <- sh -- identical shape , Just b <- isIdentityIndexing f -- function is `\ix -> b ! ix` , Just Refl <- matchVar a b -- function thus is `\ix -> a ! ix` = ppA $ Manifest $ Avar a @@ -339,8 +339,8 @@ prettyDelayedOpenAcc detail ctx aenv atop@(Manifest pacc) = ident <- mkNode acc' Nothing return $ Vertex ident Nothing - apply :: Label -> PNode -> PNode - apply f (PNode ident x vs) = + apply' :: Label -> PNode -> PNode + apply' f (PNode ident x vs) = let x' = case x of Leaf (p,d) -> Leaf (p, pretty f <+> d) Forest ts -> Forest (Leaf (Nothing,pretty f) : ts) @@ -516,10 +516,12 @@ fvOpenExp env aenv = fv fvF = fvOpenFun env aenv fv :: OpenExp env aenv e -> [Vertex] - fv (Shape acc) = if cfgIncludeShape then fvAvar aenv acc else [] - fv (Index acc i) = concat [ fvAvar aenv acc, fv i ] - fv (LinearIndex acc i) = concat [ fvAvar aenv acc, fv i ] - -- + fv (ArrayInstr arr e) = concat [ avars, fv e ] + where + avars = case arr of + Shape acc -> if cfgIncludeShape then fvAvar aenv acc else [] + Index acc -> fvAvar aenv acc + LinearIndex acc -> fvAvar aenv acc fv (Let lhs e1 e2) = concat [ fv e1, fvOpenExp env' aenv e2 ] where (env', _) = prettyELhs False env lhs diff --git a/src/Data/Array/Accelerate/Pretty/Print.hs b/src/Data/Array/Accelerate/Pretty/Print.hs index 9874a88ca..7aa7c894b 100644 --- a/src/Data/Array/Accelerate/Pretty/Print.hs +++ b/src/Data/Array/Accelerate/Pretty/Print.hs @@ -399,10 +399,13 @@ prettyOpenExp ctx env aenv exp = FromIndex _ sh ix -> ppF2 "fromIndex" (ppE sh) (ppE ix) While p f x -> ppF3 "while" (ppF p) (ppF f) (ppE x) Foreign _ ff _ e -> ppF2 "foreign" (\_ -> pretty (strForeign ff)) (ppE e) - Shape arr -> ppF1 "shape" (ppA arr) + ArrayInstr (Shape arr) _ + -> ppF1 "shape" (ppA arr) ShapeSize _ sh -> ppF1 "shapeSize" (ppE sh) - Index arr ix -> ppF2 (Operator (pretty '!') Infix L 9) (ppA arr) (ppE ix) - LinearIndex arr ix -> ppF2 (Operator "!!" Infix L 9) (ppA arr) (ppE ix) + ArrayInstr (Index arr) ix + -> ppF2 (Operator (pretty '!') Infix L 9) (ppA arr) (ppE ix) + ArrayInstr (LinearIndex arr) ix + -> ppF2 (Operator "!!" Infix L 9) (ppA arr) (ppE ix) Coerce _ tp x -> ppF1 (Operator (withTypeRep tp "coerce") App L 10) (ppE x) Undef tp -> withTypeRep tp "undef" diff --git a/src/Data/Array/Accelerate/Representation/Array.hs b/src/Data/Array/Accelerate/Representation/Array.hs index 960eda107..79af43816 100644 --- a/src/Data/Array/Accelerate/Representation/Array.hs +++ b/src/Data/Array/Accelerate/Representation/Array.hs @@ -44,10 +44,7 @@ data Array sh e where newtype Buffer e = Buffer (ScalarArrayData e) -type family Buffers e where - Buffers () = () - Buffers (a, b) = (Buffers a, Buffers b) - Buffers t = t +type Buffers e = Distribute Buffer e -- | Segment descriptor (vector of segment lengths). -- diff --git a/src/Data/Array/Accelerate/Representation/Type.hs b/src/Data/Array/Accelerate/Representation/Type.hs index 11244e71d..ca6ca1876 100644 --- a/src/Data/Array/Accelerate/Representation/Type.hs +++ b/src/Data/Array/Accelerate/Representation/Type.hs @@ -1,7 +1,15 @@ +{-# LANGUAGE AllowAmbiguousTypes #-} +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE EmptyCase #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeFamilyDependencies #-} +{-# LANGUAGE QuantifiedConstraints #-} {-# OPTIONS_HADDOCK hide #-} -- | -- Module : Data.Array.Accelerate.Representation.Type @@ -18,6 +26,7 @@ module Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Type import Data.Primitive.Vec +import Data.Type.Equality import Language.Haskell.TH @@ -47,6 +56,36 @@ instance Show (TupR ScalarType a) where type TypeR = TupR ScalarType +-- | Distributes a type constructor over the elements of a tuple. +-- TODO: Could we make this type class injective? Then we wouldn't +-- need the type class Distributes any more. +-- +type family Distribute f a = b where + Distribute f () = () + Distribute f (a, b) = (Distribute f a, Distribute f b) + Distribute f a = f a + +class Distributes s where + -- Shows that a single element isn't unit or a pair + reprIsSingle :: s t -> Distribute f t :~: f t + +instance Distributes ScalarType where + reprIsSingle (VectorScalarType _) = Refl + reprIsSingle (SingleScalarType (NumSingleType tp)) = case tp of + IntegralNumType TypeInt -> Refl + IntegralNumType TypeInt8 -> Refl + IntegralNumType TypeInt16 -> Refl + IntegralNumType TypeInt32 -> Refl + IntegralNumType TypeInt64 -> Refl + IntegralNumType TypeWord -> Refl + IntegralNumType TypeWord8 -> Refl + IntegralNumType TypeWord16 -> Refl + IntegralNumType TypeWord32 -> Refl + IntegralNumType TypeWord64 -> Refl + FloatingNumType TypeHalf -> Refl + FloatingNumType TypeFloat -> Refl + FloatingNumType TypeDouble -> Refl + rnfTupR :: (forall b. s b -> ()) -> TupR s a -> () rnfTupR _ TupRunit = () rnfTupR f (TupRsingle s) = f s @@ -120,3 +159,8 @@ mapTupR :: (forall s. a s -> b s) -> TupR a t -> TupR b t mapTupR f (TupRsingle a) = TupRsingle $ f a mapTupR _ TupRunit = TupRunit mapTupR f (TupRpair a1 a2) = mapTupR f a1 `TupRpair` mapTupR f a2 + +functionImpossible :: TypeR (s -> t) -> a +functionImpossible (TupRsingle (SingleScalarType (NumSingleType tp))) = case tp of + IntegralNumType t -> case t of {} + FloatingNumType t -> case t of {} diff --git a/src/Data/Array/Accelerate/Trafo.hs b/src/Data/Array/Accelerate/Trafo.hs index 7e82abd06..85f6a9dd6 100644 --- a/src/Data/Array/Accelerate/Trafo.hs +++ b/src/Data/Array/Accelerate/Trafo.hs @@ -29,18 +29,19 @@ module Data.Array.Accelerate.Trafo ( ) where -import Data.Array.Accelerate.Sugar.Array ( ArraysR ) -import Data.Array.Accelerate.Sugar.Elt ( EltR ) +import Data.Array.Accelerate.Sugar.Array ( ArraysR ) +import Data.Array.Accelerate.Sugar.Elt ( EltR ) import Data.Array.Accelerate.Smart import Data.Array.Accelerate.Trafo.Config import Data.Array.Accelerate.Trafo.Delayed -import Data.Array.Accelerate.Trafo.Sharing ( Afunction, ArraysFunctionR, Function, EltFunctionR ) -import qualified Data.Array.Accelerate.AST as AST -import qualified Data.Array.Accelerate.Trafo.Fusion as Fusion -import qualified Data.Array.Accelerate.Trafo.LetSplit as LetSplit -import qualified Data.Array.Accelerate.Trafo.Simplify as Rewrite -import qualified Data.Array.Accelerate.Trafo.Sharing as Sharing --- import qualified Data.Array.Accelerate.Trafo.Vectorise as Vectorise +import Data.Array.Accelerate.Trafo.Sharing ( Afunction, ArraysFunctionR, Function, EltFunctionR ) +import qualified Data.Array.Accelerate.AST as AST +import qualified Data.Array.Accelerate.Trafo.Fusion as Fusion +import qualified Data.Array.Accelerate.Trafo.LetSplit as LetSplit +import qualified Data.Array.Accelerate.Trafo.Exp.Simplify as Rewrite +import qualified Data.Array.Accelerate.Trafo.Sharing as Sharing +import qualified Data.Array.Accelerate.Trafo.Desugar as Desugar +-- import qualified Data.Array.Accelerate.Trafo.Vectorise as Vectorise import Control.DeepSeq diff --git a/src/Data/Array/Accelerate/Trafo/Algebra.hs b/src/Data/Array/Accelerate/Trafo/Algebra.hs index 77f242238..6c31769fd 100644 --- a/src/Data/Array/Accelerate/Trafo/Algebra.hs +++ b/src/Data/Array/Accelerate/Trafo/Algebra.hs @@ -27,7 +27,7 @@ module Data.Array.Accelerate.Trafo.Algebra ( ) where -import Data.Array.Accelerate.AST +import Data.Array.Accelerate.AST.Exp import Data.Array.Accelerate.AST.Var import Data.Array.Accelerate.Analysis.Match import Data.Array.Accelerate.Pretty.Print ( primOperator, isInfix, opName ) @@ -50,13 +50,14 @@ import qualified Prelude as P -- or constant let bindings. Be careful not to follow self-cycles. -- propagate - :: forall env aenv exp. - Gamma env env aenv - -> OpenExp env aenv exp + :: forall arr env exp. + IsArrayInstr arr + => Gamma arr env env + -> PreOpenExp arr env exp -> Maybe exp propagate env = cvtE where - cvtE :: OpenExp env aenv e -> Maybe e + cvtE :: PreOpenExp arr env e -> Maybe e cvtE exp = case exp of Const _ c -> Just c PrimConst c -> Just (evalPrimConst c) @@ -71,11 +72,12 @@ propagate env = cvtE -- Attempt to evaluate primitive function applications -- evalPrimApp - :: forall env aenv a r. - Gamma env env aenv + :: forall arr env a r. + IsArrayInstr arr + => Gamma arr env env -> PrimFun (a -> r) - -> OpenExp env aenv a - -> (Any, OpenExp env aenv r) + -> PreOpenExp arr env a + -> (Any, PreOpenExp arr env r) evalPrimApp env f x -- First attempt to move constant values towards the left | Just r <- commutes f x env = evalPrimApp env f r @@ -154,11 +156,12 @@ evalPrimApp env f x -- to the left of the operator. Returning Nothing indicates no change is made. -- commutes - :: forall env aenv a r. - PrimFun (a -> r) - -> OpenExp env aenv a - -> Gamma env env aenv - -> Maybe (OpenExp env aenv a) + :: forall arr env a r. + IsArrayInstr arr + => PrimFun (a -> r) + -> PreOpenExp arr env a + -> Gamma arr env env + -> Maybe (PreOpenExp arr env a) commutes f x env = case f of PrimAdd _ -> swizzle x PrimMul _ -> swizzle x @@ -171,7 +174,7 @@ commutes f x env = case f of PrimMin _ -> swizzle x _ -> Nothing where - swizzle :: OpenExp env aenv (b,b) -> Maybe (OpenExp env aenv (b,b)) + swizzle :: PreOpenExp arr env (b,b) -> Maybe (PreOpenExp arr env (b,b)) swizzle (Pair a b) | Nothing <- propagate env a , Just _ <- propagate env b @@ -208,8 +211,8 @@ commutes f x env = case f of associates :: (Elt a, Elt r) => PrimFun (a -> r) - -> OpenExp env aenv a - -> Maybe (OpenExp env aenv r) + -> PreOpenExp arr env a + -> Maybe (PreOpenExp arr env r) associates fun exp = case fun of PrimAdd _ -> swizzle fun exp [PrimAdd ty, PrimSub ty] PrimSub _ -> swizzle fun exp [PrimAdd ty, PrimSub ty] @@ -221,7 +224,7 @@ associates fun exp = case fun of ty = undefined ops = [ PrimMul ty, PrimFDiv ty, PrimAdd ty, PrimSub ty, PrimBAnd ty, PrimBOr ty, PrimBXor ty ] - swizzle :: (Elt a, Elt r) => PrimFun (a -> r) -> OpenExp env aenv a -> [PrimFun (a -> r)] -> Maybe (OpenExp env aenv r) + swizzle :: (Elt a, Elt r) => PrimFun (a -> r) -> PreOpenExp arr env a -> [PrimFun (a -> r)] -> Maybe (PreOpenExp arr env r) swizzle f x lvl | Just Refl <- matches f ops , Just (a,bc) <- untup2 x @@ -248,7 +251,7 @@ associates fun exp = case fun of -- Helper functions -- ---------------- -type a :-> b = forall env aenv. OpenExp env aenv a -> Gamma env env aenv -> Maybe (OpenExp env aenv b) +type a :-> b = forall arr env. IsArrayInstr arr => PreOpenExp arr env a -> Gamma arr env env -> Maybe (PreOpenExp arr env b) eval1 :: SingleType b -> (a -> b) -> a :-> b eval1 tp f x env @@ -289,10 +292,10 @@ bool2 f (untup2 -> Just (x,y)) env bool2 _ _ _ = Nothing -tup2 :: (OpenExp env aenv a, OpenExp env aenv b) -> OpenExp env aenv (a, b) +tup2 :: (PreOpenExp arr env a, PreOpenExp arr env b) -> PreOpenExp arr env (a, b) tup2 (a,b) = Pair a b -untup2 :: OpenExp env aenv (a, b) -> Maybe (OpenExp env aenv a, OpenExp env aenv b) +untup2 :: PreOpenExp arr env (a, b) -> Maybe (PreOpenExp arr env a, PreOpenExp arr env b) untup2 exp | Pair a b <- exp = Just (a, b) | otherwise = Nothing diff --git a/src/Data/Array/Accelerate/Trafo/Desugar.hs b/src/Data/Array/Accelerate/Trafo/Desugar.hs index 4753d8226..d1b9310a2 100644 --- a/src/Data/Array/Accelerate/Trafo/Desugar.hs +++ b/src/Data/Array/Accelerate/Trafo/Desugar.hs @@ -2,6 +2,7 @@ {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} -- | @@ -18,19 +19,148 @@ module Data.Array.Accelerate.Trafo.Desugar where import qualified Data.Array.Accelerate.AST as Named +import Data.Array.Accelerate.AST.Environment hiding ( Val ) +import Data.Array.Accelerate.AST.Idx import Data.Array.Accelerate.AST.Operation +import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.Analysis.Match ((:~:)(..)) import Data.Array.Accelerate.Representation.Array import Data.Array.Accelerate.Representation.Shape import Data.Array.Accelerate.Representation.Slice +import Data.Array.Accelerate.Representation.Stencil import Data.Array.Accelerate.Representation.Tag import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Representation.Vec import Data.Array.Accelerate.Sugar.Foreign +import Data.Array.Accelerate.Trafo.Exp.Substitution +import Data.Array.Accelerate.Trafo.Var import Data.Array.Accelerate.Type import Data.Array.Accelerate.Error import Data.Primitive.Vec +import Data.Kind +import GHC.Stack + +type a $ b = a b +infixr 0 $ + +-- | Vanilla boundary condition specification for stencil operations +-- Note that this data type is not used in the actual AST, it is just +-- used to pass to 'mkStencil' or 'mkStencil2'. +-- +data Boundary env t where + -- Clamp coordinates to the extent of the array + Clamp :: Boundary env t + + -- Mirror coordinates beyond the array extent + Mirror :: Boundary env t + + -- Wrap coordinates around on each dimension + Wrap :: Boundary env t + + -- Use a constant value for outlying coordinates + Constant :: e + -> Boundary env (Array sh e) + + -- Apply the given function to outlying coordinates + Function :: Fun env (sh -> e) + -> Boundary env (Array sh e) + + +class DesugarAcc (op :: Type -> Type) where + mkMap :: Arg env (Fun' (s -> t)) + -> Arg env (In sh s) + -> Arg env (Out sh t) + -> OperationAcc op env () + mkMap f input output = mkTransform (ArgFun $ identity $ shapeType shr) f input output + where + ArrayR shr _ = argArrayR input + + mkBackpermute :: Arg env (Fun' (sh' -> sh)) + -> Arg env (In sh t) + -> Arg env (Out sh' t) + -> OperationAcc op env () + mkBackpermute f input output = mkTransform f (ArgFun $ identity tp) input output + where + ArrayR _ tp = argArrayR input + + mkTransform :: Arg env (Fun' (sh' -> sh)) + -> Arg env (Fun' (s -> t)) + -> Arg env (In sh s) + -> Arg env (Out sh' t) + -> OperationAcc op env () + mkTransform (ArgFun f) (ArgFun g) (ArgArray _ repr sh buffers) output = mkGenerate (ArgFun h) output + where + h = g `compose` indexFunction repr sh buffers `compose` f + + mkGenerate :: Arg env (Fun' (sh -> t)) + -> Arg env (Out sh t) + -> OperationAcc op env () + + mkPermute :: Arg env (Fun' (e -> e -> e)) + -> Arg env (Mut sh' e) + -> Arg env (Fun' (sh -> sh')) + -> Arg env (In sh e) + -> OperationAcc op env () + + mkStencil :: StencilR sh e stencil + -> Arg env (Fun' (stencil -> e')) + -> Boundary env (Array sh e) + -> Arg env (In sh e) + -> Arg env (Out sh e') + -> OperationAcc op env () + -- Default implementation for mkStencil uses 'generate'. It includes the conditional code for the boundary on all elements, making it less efficient + -- than a specialized implementation. + -- + mkStencil sr (ArgFun f) boundary input output@(ArgArray _ (ArrayR _ tp) _ _) + = mkGenerate (ArgFun $ desugarStencilFun sr tp f (Just boundary) input) output + + mkStencil2 :: StencilR sh a stencil1 + -> StencilR sh b stencil2 + -> Arg env (Fun' (stencil1 -> stencil2 -> c)) + -> Boundary env (Array sh a) + -> Arg env (In sh a) + -> Boundary env (Array sh b) + -> Arg env (In sh b) + -> Arg env (Out sh c) + -> OperationAcc op env () + -- Default implementation for mkStencil uses 'generate'. It includes the conditional code for the boundary on all elements, making it less efficient + -- than a specialized implementation. + -- XXX: Could we define this in terms of mkStencil and a zip? Maybe only if the sizes of the two input arrays are equal? + -- + mkStencil2 sr1 sr2 (ArgFun f) boundary1 input1 boundary2 input2 output@(ArgArray _ (ArrayR _ tp) _ _) + = mkGenerate (ArgFun $ desugarStencil2Fun sr1 sr2 tp f (Just boundary1) input1 (Just boundary2) input2) output + + mkFold :: Arg env (Fun' (e -> e -> e)) + -> Arg env (Maybe (Exp' e)) + -> Arg env (In (sh, Int) e) + -> Arg env (Out sh e) + -> OperationAcc op env () + -- TODO: Default implementation in terms of generate & awhile, or a sequential one in terms of generate + -- Altough it may not be that efficient, it will make it easier to implement new backends + + mkFoldSeg :: IntegralType i + -> Arg env (Fun' (e -> e -> e)) + -> Arg env (Maybe (Exp' e)) + -> Arg env (In (sh, Int) e) + -> Arg env (In DIM1 i) + -> Arg env (Out (sh, Int) e) + -> OperationAcc op env () + + mkScan :: Arg env (Fun' (e -> e -> e)) + -> Arg env (Maybe (Exp' e)) + -> Arg env (In (sh, Int) e) + -> Arg env (Out (sh, Int) e) + -> OperationAcc op env () + -- TODO: Default implementation with awhile & generate + + mkScan' :: Arg env (Fun' (e -> e -> e)) + -> Arg env (Maybe (Exp' e)) + -> Arg env (In (sh, Int) e) + -> Arg env (Out (sh, Int) e) + -> Arg env (Out sh e) + -> OperationAcc op env () + -- TODO: Default implementation with awhile & generate -class DesugarAcc op where type family DesugaredArrays a where DesugaredArrays () = () @@ -41,8 +171,299 @@ type family DesugaredAfun a where DesugaredAfun (a -> b) = DesugaredArrays a -> DesugaredAfun b DesugaredAfun a = DesugaredArrays a -desugar :: Named.Acc a -> OperationAcc (Execute op) () (DesugaredArrays a) -desugar = undefined +desugar :: (HasCallStack, DesugarAcc op) => Named.Acc a -> OperationAcc op () (DesugaredArrays a) +desugar = desugarOpenAcc Empty + +desugarAfun :: (HasCallStack, DesugarAcc op) => Named.Afun a -> OperationAfun op () (DesugaredAfun a) +desugarAfun = desugarOpenAfun Empty + +data ArrayDescriptor env a where + ArrayDescriptor :: ArrayR (Array sh e) + -> GroundVars env sh + -> GroundVars env (Buffers e) + -> ArrayDescriptor env (Array sh e) + +weakenArrayDescriptor :: (env :> env') -> ArrayDescriptor env a -> ArrayDescriptor env' a +weakenArrayDescriptor k (ArrayDescriptor repr sh buffers) = ArrayDescriptor repr (weakenVars k sh) (weakenVars k buffers) + +type BEnv benv = Env (ArrayDescriptor benv) + +desugarOpenAcc :: forall op benv aenv a. + (HasCallStack, DesugarAcc op) + => BEnv benv aenv + -> Named.OpenAcc aenv a + -> OperationAcc op benv (DesugaredArrays a) +desugarOpenAcc env = travA + where + travA :: Named.OpenAcc aenv arr -> OperationAcc op benv (DesugaredArrays arr) + travA = undefined + +desugarOpenAfun :: (HasCallStack, DesugarAcc op) + => BEnv benv aenv + -> Named.OpenAfun aenv a + -> OperationAfun op benv (DesugaredAfun a) +desugarOpenAfun env (Named.Abody a) = case Named.arraysR a of + -- We must pattern match on the arrays representation of the body + -- to inform the type checker that 'a' is not a function, and thus + -- that 'DesugaredAfun a' is equal to 'DesugaredArrays a' + TupRsingle ArrayR{} -> Abody $ desugarOpenAcc env a + TupRunit -> Abody $ desugarOpenAcc env a + TupRpair _ _ -> Abody $ desugarOpenAcc env a +desugarOpenAfun env (Named.Alam lhs f) + | DesugaredLHS env' lhs' <- desugarLHS env lhs = Alam lhs' $ desugarOpenAfun env' f + +data DesugaredLHS b aenv' benv where + DesugaredLHS :: BEnv benv' aenv' -> GLeftHandSide b benv benv' -> DesugaredLHS b aenv' benv + +desugarLHS :: BEnv benv aenv -> Named.ALeftHandSide a aenv aenv' -> DesugaredLHS (DesugaredArrays a) aenv' benv +desugarLHS env (LeftHandSideWildcard repr) = DesugaredLHS env $ LeftHandSideWildcard $ desugarArraysR repr +desugarLHS env (LeftHandSidePair l1 l2) + | DesugaredLHS env1 l1' <- desugarLHS env l1 + , DesugaredLHS env2 l2' <- desugarLHS env1 l2 = DesugaredLHS env2 $ LeftHandSidePair l1' l2' +desugarLHS env (LeftHandSideSingle repr@(ArrayR shr tp)) + | DeclareVars lhsSh kSh valueSh <- declareVars $ mapTupR GroundRscalar $ shapeType shr + , DeclareVars lhsBf kBf valueBf <- declareVars $ buffersR tp + = DesugaredLHS (mapEnv (weakenArrayDescriptor $ kBf .> kSh) env `Push` ArrayDescriptor repr (valueSh kBf) (valueBf weakenId)) $ LeftHandSidePair lhsSh lhsBf + + +desugarArraysR :: ArraysR arr -> GroundsR (DesugaredArrays arr) +desugarArraysR TupRunit = TupRunit +desugarArraysR (TupRsingle repr) = desugarArrayR repr +desugarArraysR (TupRpair r1 r2) = desugarArraysR r1 `TupRpair` desugarArraysR r2 + +desugarArrayR :: ArrayR arr -> GroundsR (DesugaredArrays arr) +desugarArrayR (ArrayR shr tp) = mapTupR GroundRscalar (shapeType shr) `TupRpair` buffersR tp + +buffersR :: forall e. TypeR e -> GroundsR (Buffers e) +buffersR TupRunit = TupRunit +buffersR (TupRsingle tp) + | Refl <- reprIsSingle @ScalarType @e @Buffer tp = TupRsingle (GroundRbuffer tp) +buffersR (TupRpair t1 t2) = buffersR t1 `TupRpair` buffersR t2 + + +desugarExp :: HasCallStack + => BEnv benv aenv + -> Named.OpenExp env aenv e + -> OpenExp env benv e +desugarExp env = rebuildArrayInstr (desugarArrayInstr env) + +desugarFun :: HasCallStack + => BEnv benv aenv + -> Named.Fun aenv e + -> Fun benv e +desugarFun env = rebuildArrayInstr (desugarArrayInstr env) + +desugarArrayInstr :: BEnv benv aenv -> Named.ArrayInstr aenv (s -> t) -> OpenExp env benv s -> OpenExp env benv t +desugarArrayInstr env (Named.Shape (Var _ ix)) _ + | ArrayDescriptor (ArrayR shr _) sh _ <- prj' ix env = paramsIn (shapeType shr) sh +desugarArrayInstr env (Named.LinearIndex (Var (ArrayR _ tp) a)) ix + = Let lhs ix $ linearIndex tp buffers $ Var int ZeroIdx + where + ArrayDescriptor _ _ buffers = prj' a env + int = SingleScalarType $ NumSingleType $ IntegralNumType TypeInt + lhs = LeftHandSideSingle int +desugarArrayInstr env (Named.Index (Var (ArrayR _ tp) a)) ix + = Let lhs (ToIndex shr sh' ix) $ linearIndex tp buffers $ Var int ZeroIdx + where + ArrayDescriptor (ArrayR shr _) sh buffers = prj' a env + sh' = paramsIn (shapeType shr) sh + int = SingleScalarType $ NumSingleType $ IntegralNumType TypeInt + lhs = LeftHandSideSingle int + +weakenBEnv :: forall benv benv' aenv. benv :> benv' -> BEnv benv aenv -> BEnv benv' aenv +weakenBEnv k = mapEnv f + where + f :: ArrayDescriptor benv a -> ArrayDescriptor benv' a + f (ArrayDescriptor shr sh buffers) = ArrayDescriptor shr (weakenVars k sh) (weakenVars k buffers) + +-- Utilities +-- + +index :: ArrayR (Array sh e) -> GroundVars benv sh -> GroundVars benv (Buffers e) -> OpenExp env benv sh -> OpenExp env benv e +index (ArrayR shr tp) sh buffers ix = Let lhs (ToIndex shr (paramsIn (shapeType shr) sh) ix) $ linearIndex tp buffers $ Var int ZeroIdx + where + int = SingleScalarType $ NumSingleType $ IntegralNumType TypeInt + lhs = LeftHandSideSingle int + +indexFunction :: ArrayR (Array sh e) -> GroundVars benv sh -> GroundVars benv (Buffers e) -> OpenFun env benv (sh -> e) +indexFunction repr@(ArrayR shr _) sh buffers + | DeclareVars lhs _ value <- declareVars $ shapeType shr + = Lam lhs $ Body $ index repr sh buffers (expVars $ value weakenId) + +linearIndex :: forall e benv env. HasCallStack => TypeR e -> GroundVars benv (Buffers e) -> ExpVar env Int -> OpenExp env benv e +linearIndex TupRunit TupRunit _ = Nil +linearIndex (TupRpair t1 t2) (TupRpair b1 b2) ix = linearIndex t1 b1 ix `Pair` linearIndex t2 b2 ix +linearIndex (TupRsingle t) (TupRsingle var@(Var (GroundRbuffer _) _)) ix + | Refl <- reprIsSingle @ScalarType @e @Buffer t = ArrayInstr (Index var) (Evar ix) +linearIndex _ _ _ = internalError "Tuple mismatch" + +desugarBoundaryToFunction :: forall benv sh e. Boundary benv (Array sh e) -> Arg benv (In sh e) -> Fun benv (sh -> e) +desugarBoundaryToFunction boundary (ArgArray _ repr@(ArrayR shr tp) sh buffers) = case boundary of + Function f -> f + Constant e -> Lam (LeftHandSideWildcard $ shapeType shr) $ Body $ mkConstant tp e + Clamp -> reindex clamp + Mirror -> reindex mirror + Wrap -> reindex wrap + where + + -- Note: the expressions passed as argument may be duplicated in the resulting code. + -- This doesn't explode the code size as they are always an Evar or a Parameter. + -- + clamp, mirror, wrap :: OpenExp env benv Int -> OpenExp env benv Int -> OpenExp env benv Int + -- clamp ix sz = max(0, min(ix, sz - 1)) + clamp ix sz = mkBinary (PrimMax singleType) (Const scalarTypeInt 0) $ mkBinary (PrimMin singleType) ix $ sub sz $ Const scalarTypeInt 0 + + -- if ix < 0 then -ix + mirror ix sz = Cond (mkBinary (PrimLt singleType) ix (Const scalarTypeInt 0)) (PrimApp (PrimNeg numType) ix) + -- else if ix >= sz then sz - ((ix - sz) + 2) + $ Cond (mkBinary (PrimGtEq singleType) ix sz) (sub sz (add (sub ix sz) $ Const scalarTypeInt 2)) + -- else ix + $ ix + + -- if ix < 0 then sz + ix + wrap ix sz = Cond (mkBinary (PrimLt singleType) ix (Const scalarTypeInt 0)) (add sz ix) + -- else if ix >= sz then ix - sz + $ Cond (mkBinary (PrimGtEq singleType) ix sz) (sub ix sz) + -- else ix + $ ix + + add = mkBinary (PrimAdd numType) + sub = mkBinary (PrimSub numType) + + reindex :: (forall env'. OpenExp env' benv Int -> OpenExp env' benv Int -> OpenExp env' benv Int) -> Fun benv (sh -> e) + reindex f + | DeclareVars lhs _ value <- declareVars $ shapeType shr + = Lam lhs $ Body $ index repr sh buffers $ getIndex f shr (value weakenId) sh + + getIndex :: (OpenExp env benv Int -> OpenExp env benv Int -> OpenExp env benv Int) -> ShapeR sh' -> ExpVars env sh' -> GroundVars benv sh' -> OpenExp env benv sh' + getIndex _ ShapeRz _ _ = Nil + getIndex f (ShapeRsnoc shr') (TupRpair ixs (TupRsingle ix)) (TupRpair szs (TupRsingle sz)) = getIndex f shr' ixs szs `Pair` f (Evar ix) (paramIn scalarTypeInt sz) + getIndex _ _ _ _ = internalError "Illegal tuple for shape" -desugarFun :: Named.Afun a -> OperationAcc (Execute op) () (DesugaredAfun a) -desugarFun = undefined +desugarStencilFun :: StencilR sh e stencil -> TypeR e' -> Fun benv (stencil -> e') -> Maybe (Boundary benv (Array sh e)) -> Arg benv (In sh e) -> Fun benv (sh -> e') +desugarStencilFun sr _ f boundary array = f `compose` stencilAccess sr boundary array + +desugarStencil2Fun :: StencilR sh a stencil1 -> StencilR sh b stencil2 -> TypeR c -> Fun benv (stencil1 -> stencil2 -> c) -> Maybe (Boundary benv (Array sh a)) -> Arg benv (In sh a) -> Maybe (Boundary benv (Array sh b)) -> Arg benv (In sh b) -> Fun benv (sh -> c) +desugarStencil2Fun sr1 sr2 tp f boundary1 array1@(ArgArray _ (ArrayR shr _) _ _) boundary2 array2 + | DeclareVars lhs _ value <- declareVars $ shapeType shr + , vars <- expVars $ value weakenId + = Lam lhs $ Body $ apply2 tp f (apply1 (stencilR sr1) (stencilAccess sr1 boundary1 array1) vars) + (apply1 (stencilR sr2) (stencilAccess sr2 boundary2 array2) vars) + +stencilAccess :: forall sh e stencil benv. StencilR sh e stencil -> Maybe (Boundary benv (Array sh e)) -> Arg benv (In sh e) -> Fun benv (sh -> stencil) +stencilAccess sr boundary array@(ArgArray _ repr@(ArrayR shr tp) sh buffers) + | DeclareVars lhs _ value <- declareVars $ shapeType shr = Lam lhs $ Body $ stencilAccess' shr sr readFunction (value weakenId) + where + readFunction :: env :> env' -> ExpVars env' sh -> OpenExp env' benv e + readFunction _ = readFunction' . expVars + + readFunction' :: OpenExp env' benv sh -> OpenExp env' benv e + readFunction' = apply1 tp $ case boundary of + Just b -> desugarBoundaryToFunction b array + Nothing -> indexFunction repr sh buffers + +stencilAccess' :: forall env benv sh e stencil. ShapeR sh -> StencilR sh e stencil -> (forall env'. env :> env' -> ExpVars env' sh -> OpenExp env' benv e) -> ExpVars env sh -> OpenExp env benv stencil +stencilAccess' shr sr rf ix = case sr of + -- Base cases, nothing interesting to do here since we know the lower + -- dimension is Z. + -- + StencilRunit3 _ -> Nil `Pair` rf' (-1) + `Pair` center + `Pair` rf' 1 + StencilRunit5 _ -> Nil `Pair` rf' (-2) + `Pair` rf' (-1) + `Pair` center + `Pair` rf' 1 + `Pair` rf' 2 + StencilRunit7 _ -> Nil `Pair` rf' (-3) + `Pair` rf' (-2) + `Pair` rf' (-1) + `Pair` center + `Pair` rf' 1 + `Pair` rf' 2 + `Pair` rf' 3 + StencilRunit9 _ -> Nil `Pair` rf' (-4) + `Pair` rf' (-3) + `Pair` rf' (-2) + `Pair` rf' (-1) + `Pair` center + `Pair` rf' 1 + `Pair` rf' 2 + `Pair` rf' 3 + `Pair` rf' 4 + + -- Recursive cases. Note that because the stencil pattern is defined with + -- a cons ordering, whereas shapes (indices) are defined as a snoc list, + -- when we recurse on the stencil structure we must manipulate the + -- _left-most_ index component + -- + StencilRtup3 s1 s2 s3 -> + Nil `Pair` go s1 (-1) + `Pair` go s2 0 + `Pair` go s3 1 + + StencilRtup5 s1 s2 s3 s4 s5 -> + Nil `Pair` go s1 (-2) + `Pair` go s2 (-1) + `Pair` go s3 0 + `Pair` go s4 1 + `Pair` go s5 2 + + StencilRtup7 s1 s2 s3 s4 s5 s6 s7 -> + Nil `Pair` go s1 (-3) + `Pair` go s2 (-2) + `Pair` go s3 (-1) + `Pair` go s4 0 + `Pair` go s5 1 + `Pair` go s6 2 + `Pair` go s7 3 + + StencilRtup9 s1 s2 s3 s4 s5 s6 s7 s8 s9 -> + Nil `Pair` go s1 (-4) + `Pair` go s2 (-3) + `Pair` go s3 (-2) + `Pair` go s4 (-1) + `Pair` go s5 0 + `Pair` go s6 1 + `Pair` go s7 2 + `Pair` go s8 3 + `Pair` go s9 4 + where + center :: sh ~ DIM1 => OpenExp env benv e + center = rf weakenId ix + + -- read function for 1 dimensional cases + rf' :: sh ~ DIM1 => Int -> OpenExp env benv e + rf' d + | TupRpair _ (TupRsingle i) <- ix = Let (LeftHandSideSingle scalarTypeInt) (mkBinary (PrimAdd numType) (Evar i) $ Const scalarTypeInt d) + $ rf (weakenSucc weakenId) $ TupRpair TupRunit $ TupRsingle $ Var scalarTypeInt ZeroIdx + rf' _ = internalError "Shape tuple mismatch" + + go :: forall sh' stencil'. sh ~ (sh', Int) => StencilR sh' e stencil' -> Int -> OpenExp env benv stencil' + go sr' d = stencilAccess' shr' sr' rf'' ix' + where + ShapeRsnoc shr' = shr + (i, ix') = uncons shr' ix + + rf'' :: (env :> env') -> ExpVars env' sh' -> OpenExp env' benv e + rf'' k ds + | d == 0 = rf k (cons shr' (weakenE k i) ds) + | otherwise = Let (LeftHandSideSingle scalarTypeInt) (mkBinary (PrimAdd numType) (Evar $ weakenE k i) $ Const scalarTypeInt d) + $ rf (weakenSucc' k) $ cons shr' (Var scalarTypeInt ZeroIdx) $ weakenVars (weakenSucc weakenId) ds + +-- Add a _left-most_ dimension to a shape +-- +cons :: ShapeR sh -> ExpVar env Int -> ExpVars env sh -> ExpVars env (sh, Int) +cons ShapeRz ix _ = TupRpair TupRunit $ TupRsingle ix +cons (ShapeRsnoc shr) ix (TupRpair sh sz) = TupRpair (cons shr ix sh) sz +cons _ _ _ = internalError "Illegal shape tuple" + + +-- Remove the _left-most_ index to a shape, and return the remainder +-- +uncons :: ShapeR sh -> ExpVars env (sh, Int) -> (ExpVar env Int, ExpVars env sh) +uncons ShapeRz (TupRpair _ (TupRsingle v2)) = (v2, TupRunit) +uncons (ShapeRsnoc shr) (TupRpair v1 v3) + = let (i, v1') = uncons shr v1 + in (i, TupRpair v1' v3) +uncons _ _ = internalError "Illegal shape tuple" diff --git a/src/Data/Array/Accelerate/Trafo/Environment.hs b/src/Data/Array/Accelerate/Trafo/Environment.hs index c08e84599..ce726b189 100644 --- a/src/Data/Array/Accelerate/Trafo/Environment.hs +++ b/src/Data/Array/Accelerate/Trafo/Environment.hs @@ -32,18 +32,18 @@ import Data.Array.Accelerate.Debug.Stats as Stats -- environment variable env' is used to project out the corresponding -- index when looking up in the environment congruent expressions. -- -data Gamma env env' aenv where - EmptyExp :: Gamma env env' aenv +data Gamma arr env env' where + EmptyExp :: Gamma arr env env' - PushExp :: Gamma env env' aenv - -> WeakOpenExp env aenv t - -> Gamma env (env', t) aenv + PushExp :: Gamma arr env env' + -> WeakOpenExp arr env t + -> Gamma arr env (env', t) -data WeakOpenExp env aenv t where +data WeakOpenExp arr env t where Subst :: env :> env' - -> OpenExp env aenv t - -> OpenExp env' aenv t {- LAZY -} - -> WeakOpenExp env' aenv t + -> PreOpenExp arr env t + -> PreOpenExp arr env' t {- LAZY -} + -> WeakOpenExp arr env' t -- XXX: The simplifier calls this function every time it moves under a let -- binding. This means we have a number of calls to 'weakenE' exponential in the @@ -57,45 +57,31 @@ data WeakOpenExp env aenv t where -- -- incExp - :: Gamma env env' aenv - -> Gamma (env,s) env' aenv + :: Gamma arr env env' + -> Gamma arr (env,s) env' incExp EmptyExp = EmptyExp incExp (PushExp env w) = incExp env `PushExp` subs w where - subs :: forall env aenv s t. WeakOpenExp env aenv t -> WeakOpenExp (env,s) aenv t - subs (Subst k (e :: OpenExp env_ aenv t) _) = Subst (weakenSucc' k) e (weakenE (weakenSucc' k) e) + subs :: forall arr env s t. WeakOpenExp arr env t -> WeakOpenExp arr (env,s) t + subs (Subst k (e :: PreOpenExp arr env_ t) _) = Subst (weakenSucc' k) e (weakenE (weakenSucc' k) e) -prjExp :: HasCallStack => Idx env' t -> Gamma env env' aenv -> OpenExp env aenv t +prjExp :: HasCallStack => Idx env' t -> Gamma arr env env' -> PreOpenExp arr env t prjExp ZeroIdx (PushExp _ (Subst _ _ e)) = e prjExp (SuccIdx ix) (PushExp env _) = prjExp ix env prjExp _ _ = internalError "inconsistent valuation" -pushExp :: Gamma env env' aenv -> OpenExp env aenv t -> Gamma env (env',t) aenv +pushExp :: Gamma arr env env' -> PreOpenExp arr env t -> Gamma arr env (env',t) pushExp env e = env `PushExp` Subst weakenId e e {-- lookupExp - :: Gamma env env' aenv - -> OpenExp env aenv t + :: Gamma arr env env' + -> PreOpenExp arr env t -> Maybe (Idx env' t) lookupExp EmptyExp _ = Nothing lookupExp (PushExp env e) x | Just Refl <- match e x = Just ZeroIdx | otherwise = SuccIdx `fmap` lookupExp env x - -weakenGamma1 - :: Gamma env env' aenv - -> Gamma env env' (aenv,t) -weakenGamma1 EmptyExp = EmptyExp -weakenGamma1 (PushExp env e) = PushExp (weakenGamma1 env) (weaken SuccIdx e) - -sinkGamma - :: Kit acc - => Extend acc aenv aenv' - -> Gamma env env' aenv - -> Gamma env env' aenv' -sinkGamma _ EmptyExp = EmptyExp -sinkGamma ext (PushExp env e) = PushExp (sinkGamma ext env) (sinkA ext e) --} -- As part of various transformations we often need to lift out array valued @@ -152,6 +138,9 @@ sinkWeaken (PushEnv e (LeftHandSideSingle _) _) = weakenSucc' $ sinkWeaken e sinkWeaken (PushEnv e (LeftHandSidePair l1 l2) _) = sinkWeaken (PushEnv (PushEnv e l1 undefined) l2 undefined) sinkWeaken BaseEnv = Stats.substitution "sink" weakenId +sinkArrayInstr :: RebuildableExp f => Extend s acc aenv aenv' -> f (ArrayInstr aenv) env t -> f (ArrayInstr aenv') env t +sinkArrayInstr env = weakenArrayInstr (sinkWeaken env) + -- Wrapper around OpenExp, with the order of type arguments env and aenv flipped newtype OpenExp' aenv env e = OpenExp' (OpenExp env aenv e) diff --git a/src/Data/Array/Accelerate/Trafo/Exp/Shrink.hs b/src/Data/Array/Accelerate/Trafo/Exp/Shrink.hs new file mode 100644 index 000000000..4f3b3a8ac --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/Exp/Shrink.hs @@ -0,0 +1,425 @@ +{-# LANGUAGE TupleSections #-} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE CPP #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE PatternGuards #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE ViewPatterns #-} +-- | +-- Module : Data.Array.Accelerate.Trafo.Shrink +-- Copyright : [2012..2020] The Accelerate Team +-- License : BSD3 +-- +-- Maintainer : Trevor L. McDonell +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- +-- The shrinking substitution arises as a restriction of beta-reduction to cases +-- where the bound variable is used zero (dead-code elimination) or one (linear +-- inlining) times. By simplifying terms, the shrinking reduction can expose +-- opportunities for further optimisation. +-- +-- TODO: replace with a linear shrinking algorithm; e.g. +-- +-- * Andrew Appel & Trevor Jim, "Shrinking lambda expressions in linear time". +-- +-- * Nick Benton, Andrew Kennedy, Sam Lindley and Claudio Russo, "Shrinking +-- Reductions in SML.NET" +-- + +module Data.Array.Accelerate.Trafo.Exp.Shrink ( + + -- Shrinking + shrinkExp, + shrinkFun, + + -- Occurrence counting + usesOfExp, usesOfFun, + + arrayInstrsInExp, arrayInstrsInFun, + +) where + +import Data.Array.Accelerate.AST.Exp +import Data.Array.Accelerate.AST.Idx +import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.AST.Var +import Data.Array.Accelerate.Analysis.Match +import Data.Array.Accelerate.Error +import Data.Array.Accelerate.Representation.Type +import Data.Array.Accelerate.Trafo.Substitution + +import qualified Data.Array.Accelerate.Debug.Stats as Stats + +import Control.Applicative hiding ( Const ) +import Data.Maybe ( isJust ) +import Data.Monoid +import Data.Semigroup +import Prelude hiding ( exp, seq ) + +data VarsRange env = + VarsRange !(Exists (Idx env)) -- rightmost variable + {-# UNPACK #-} !Int -- count + !(Maybe RangeTuple) -- tuple + +data RangeTuple + = RTNil + | RTSingle + | RTPair !RangeTuple !RangeTuple + +lhsVarsRange :: LeftHandSide s v env env' -> Either (env :~: env') (VarsRange env') +lhsVarsRange lhs = case rightIx lhs of + Left eq -> Left eq + Right ix -> let (n, rt) = go lhs + in Right $ VarsRange ix n rt + where + rightIx :: LeftHandSide s v env env' -> Either (env :~: env') (Exists (Idx env')) + rightIx (LeftHandSideWildcard _) = Left Refl + rightIx (LeftHandSideSingle _) = Right $ Exists ZeroIdx + rightIx (LeftHandSidePair l1 l2) = case rightIx l2 of + Right ix -> Right ix + Left Refl -> rightIx l1 + + go :: LeftHandSide s v env env' -> (Int, Maybe (RangeTuple)) + go (LeftHandSideWildcard TupRunit) = (0, Just RTNil) + go (LeftHandSideWildcard _) = (0, Nothing) + go (LeftHandSideSingle _) = (1, Just RTSingle) + go (LeftHandSidePair l1 l2) = (n1 + n2, RTPair <$> t1 <*> t2) + where + (n1, t1) = go l1 + (n2, t2) = go l2 + +weakenVarsRange :: LeftHandSide s v env env' -> VarsRange env -> VarsRange env' +weakenVarsRange lhs (VarsRange ix n t) = VarsRange (go lhs ix) n t + where + go :: LeftHandSide s v env env' -> Exists (Idx env) -> Exists (Idx env') + go (LeftHandSideWildcard _) ix' = ix' + go (LeftHandSideSingle _) (Exists ix') = Exists (SuccIdx ix') + go (LeftHandSidePair l1 l2) ix' = go l2 $ go l1 ix' + +matchEVarsRange :: VarsRange env -> PreOpenExp arr env t -> Bool +matchEVarsRange (VarsRange (Exists first) _ (Just rt)) expr = isJust $ go (idxToInt first) rt expr + where + go :: Int -> RangeTuple -> PreOpenExp arr env t -> Maybe Int + go i RTNil Nil = Just i + go i RTSingle (Evar (Var _ ix)) + | checkIdx i ix = Just (i + 1) + go i (RTPair t1 t2) (Pair e1 e2) + | Just i' <- go i t2 e2 = go i' t1 e1 + go _ _ _ = Nothing + + checkIdx :: Int -> Idx env t -> Bool + checkIdx 0 ZeroIdx = True + checkIdx i (SuccIdx ix) = checkIdx (i - 1) ix + checkIdx _ _ = False +matchEVarsRange _ _ = False + +varInRange :: VarsRange env -> Var s env t -> Maybe Usages +varInRange (VarsRange (Exists rangeIx) n _) (Var _ varIx) = case go rangeIx varIx of + Nothing -> Nothing + Just j -> Just $ replicate j False ++ [True] ++ replicate (n - j - 1) False + where + -- `go ix ix'` checks whether ix <= ix' with recursion, and then checks + -- whether ix' < ix + n in go'. Returns a Just if both checks + -- are successful, containing an integer j such that ix + j = ix'. + go :: Idx env u -> Idx env t -> Maybe Int + go (SuccIdx ix) (SuccIdx ix') = go ix ix' + go ZeroIdx ix' = go' ix' 0 + go _ ZeroIdx = Nothing + + go' :: Idx env t -> Int -> Maybe Int + go' _ j | j >= n = Nothing + go' ZeroIdx j = Just j + go' (SuccIdx ix') j = go' ix' (j + 1) + +-- Describes how often the variables defined in a LHS are used together. +data Count + = Impossible !Usages + -- Cannot inline this definition. This happens when the definition + -- declares multiple variables (the right hand side returns a tuple) + -- and the variables are used seperately. + | Infinity + -- The variable is used in a loop. Inlining should only proceed if + -- the computation is cheap. + | Finite {-# UNPACK #-} !Int + +type Usages = [Bool] -- Per variable a Boolean denoting whether that variable is used. + +instance Semigroup Count where + Impossible u1 <> Impossible u2 = Impossible $ zipWith (||) u1 u2 + Impossible u <> Finite 0 = Impossible u + Finite 0 <> Impossible u = Impossible u + Impossible u <> _ = Impossible $ map (const True) u + _ <> Impossible u = Impossible $ map (const True) u + Infinity <> _ = Infinity + _ <> Infinity = Infinity + Finite a <> Finite b = Finite $ a + b + +instance Monoid Count where + mempty = Finite 0 + +loopCount :: Count -> Count +loopCount (Finite n) | n > 0 = Infinity +loopCount c = c + +shrinkLhs + :: HasCallStack + => Count + -> LeftHandSide s t env1 env2 + -> Maybe (Exists (LeftHandSide s t env1)) +shrinkLhs _ (LeftHandSideWildcard _) = Nothing -- We cannot shrink this +shrinkLhs (Finite 0) lhs = Just $ Exists $ LeftHandSideWildcard $ lhsToTupR lhs -- LHS isn't used at all, replace with a wildcard +shrinkLhs (Impossible usages) lhs = case go usages lhs of + (True , [], lhs') -> Just lhs' + (False, [], _ ) -> Nothing -- No variables were dropped. Thus lhs == lhs'. + _ -> internalError "Mismatch in length of usages array and LHS" + where + go :: HasCallStack => Usages -> LeftHandSide s t env1 env2 -> (Bool, Usages, Exists (LeftHandSide s t env1)) + go us (LeftHandSideWildcard tp) = (False, us, Exists $ LeftHandSideWildcard tp) + go (True : us) (LeftHandSideSingle tp) = (False, us, Exists $ LeftHandSideSingle tp) + go (False : us) (LeftHandSideSingle tp) = (True , us, Exists $ LeftHandSideWildcard $ TupRsingle tp) + go us (LeftHandSidePair l1 l2) + | (c2, us' , Exists l2') <- go us l2 + , (c1, us'', Exists l1') <- go us' l1 + , Exists l2'' <- rebuildLHS l2' + = let + lhs' + | LeftHandSideWildcard t1 <- l1' + , LeftHandSideWildcard t2 <- l2'' = LeftHandSideWildcard $ TupRpair t1 t2 + | otherwise = LeftHandSidePair l1' l2'' + in + (c1 || c2, us'', Exists lhs') + go _ _ = internalError "Empty array, mismatch in length of usages array and LHS" +shrinkLhs _ _ = Nothing + +-- The first LHS should be 'larger' than the second, eg the second may have +-- a wildcard if the first LHS does bind variables there, but not the other +-- way around. +-- +strengthenShrunkLHS + :: HasCallStack + => LeftHandSide s t env1 env2 + -> LeftHandSide s t env1' env2' + -> env1 :?> env1' + -> env2 :?> env2' +strengthenShrunkLHS (LeftHandSideWildcard _) (LeftHandSideWildcard _) k = k +strengthenShrunkLHS (LeftHandSideSingle _) (LeftHandSideSingle _) k = \ix -> case ix of + ZeroIdx -> Just ZeroIdx + SuccIdx ix' -> SuccIdx <$> k ix' +strengthenShrunkLHS (LeftHandSidePair lA hA) (LeftHandSidePair lB hB) k = strengthenShrunkLHS hA hB $ strengthenShrunkLHS lA lB k +strengthenShrunkLHS (LeftHandSideSingle _) (LeftHandSideWildcard _) k = \ix -> case ix of + ZeroIdx -> Nothing + SuccIdx ix' -> k ix' +strengthenShrunkLHS (LeftHandSidePair l h) (LeftHandSideWildcard t) k = strengthenShrunkLHS h (LeftHandSideWildcard t2) $ strengthenShrunkLHS l (LeftHandSideWildcard t1) k + where + TupRpair t1 t2 = t +strengthenShrunkLHS (LeftHandSideWildcard _) _ _ = internalError "Second LHS defines more variables" +strengthenShrunkLHS _ _ _ = internalError "Mismatch LHS single with LHS pair" + + +-- Shrinking +-- ========= + +-- The shrinking substitution for scalar expressions. This is a restricted +-- instance of beta-reduction to cases where the bound variable is used zero +-- (dead-code elimination) or one (linear inlining) times. +-- +shrinkExp :: HasCallStack => PreOpenExp arr env t -> (Bool, PreOpenExp arr env t) +shrinkExp = Stats.substitution "shrinkE" . first getAny . shrinkE + where + -- If the bound variable is used at most this many times, it will be inlined + -- into the body. In cases where it is not used at all, this is equivalent + -- to dead-code elimination. + -- + lIMIT :: Int + lIMIT = 1 + + cheap :: PreOpenExp arr env t -> Bool + cheap (Evar _) = True + cheap (Pair e1 e2) = cheap e1 && cheap e2 + cheap Nil = True + cheap Const{} = True + cheap PrimConst{} = True + cheap Undef{} = True + cheap (Coerce _ _ e) = cheap e + cheap _ = False + + shrinkE :: HasCallStack => PreOpenExp arr env t -> (Any, PreOpenExp arr env t) + shrinkE exp = case exp of + Let (LeftHandSideSingle _) bnd@Evar{} body -> Stats.inline "Var" . yes $ shrinkE (inline body bnd) + Let lhs bnd body + | shouldInline -> case inlineVars lhs (snd body') (snd bnd') of + Just inlined -> Stats.betaReduce msg . yes $ shrinkE inlined + _ -> internalError "Unexpected failure while trying to inline some expression." + | Just (Exists lhs') <- shrinkLhs count lhs -> case strengthenE (strengthenShrunkLHS lhs lhs' Just) (snd body') of + Just body'' -> (Any True, Let lhs' (snd bnd') body'') + Nothing -> internalError "Unexpected failure in strenthenE. Variable was analysed to be unused in usesOfExp, but appeared to be used in strenthenE." + | otherwise -> Let lhs <$> bnd' <*> body' + where + shouldInline = case count of + Finite 0 -> False -- Handled by shrinkLhs + Finite n -> n <= lIMIT || cheap (snd bnd') + Infinity -> cheap (snd bnd') + Impossible _ -> False + + bnd' = shrinkE bnd + body' = shrinkE body + + -- If the lhs includes non-trivial wildcards (the last field of range is Nothing), + -- then we cannot inline the binding. We can only check which variables are not used, + -- to detect unused variables. + -- + -- If the lhs does not include non-trivial wildcards (the last field of range is a Just), + -- we can both analyse whether we can inline the binding, and check which variables are + -- not used, to detect unused variables. + -- + count = case lhsVarsRange lhs of + Left _ -> Finite 0 + Right range -> usesOfExp range (snd body') + + msg = case count of + Finite 0 -> "dead exp" + _ -> "inline exp" -- forced inlining when lIMIT > 1 + -- + Evar v -> pure (Evar v) + Const t c -> pure (Const t c) + Undef t -> pure (Undef t) + Nil -> pure Nil + Pair x y -> Pair <$> shrinkE x <*> shrinkE y + VecPack vec e -> VecPack vec <$> shrinkE e + VecUnpack vec e -> VecUnpack vec <$> shrinkE e + IndexSlice x ix sh -> IndexSlice x <$> shrinkE ix <*> shrinkE sh + IndexFull x ix sl -> IndexFull x <$> shrinkE ix <*> shrinkE sl + ToIndex shr sh ix -> ToIndex shr <$> shrinkE sh <*> shrinkE ix + FromIndex shr sh i -> FromIndex shr <$> shrinkE sh <*> shrinkE i + Case e rhs def -> Case <$> shrinkE e <*> sequenceA [ (t,) <$> shrinkE c | (t,c) <- rhs ] <*> shrinkMaybeE def + Cond p t e -> Cond <$> shrinkE p <*> shrinkE t <*> shrinkE e + While p f x -> While <$> shrinkF p <*> shrinkF f <*> shrinkE x + PrimConst c -> pure (PrimConst c) + PrimApp f x -> PrimApp f <$> shrinkE x + ArrayInstr arr e -> ArrayInstr arr <$> shrinkE e + ShapeSize shr sh -> ShapeSize shr <$> shrinkE sh + Foreign repr ff f e -> Foreign repr ff <$> shrinkF f <*> shrinkE e + Coerce t1 t2 e -> Coerce t1 t2 <$> shrinkE e + + shrinkF :: HasCallStack => PreOpenFun arr env t -> (Any, PreOpenFun arr env t) + shrinkF = first Any . shrinkFun + + shrinkMaybeE :: HasCallStack => Maybe (PreOpenExp arr env t) -> (Any, Maybe (PreOpenExp arr env t)) + shrinkMaybeE Nothing = pure Nothing + shrinkMaybeE (Just e) = Just <$> shrinkE e + + first :: (a -> a') -> (a,b) -> (a',b) + first f (x,y) = (f x, y) + + yes :: (Any, x) -> (Any, x) + yes (_, x) = (Any True, x) + +shrinkFun :: HasCallStack => PreOpenFun arr env f -> (Bool, PreOpenFun arr env f) +shrinkFun (Lam lhs f) = case lhsVarsRange lhs of + Left Refl -> + let b' = case lhs of + LeftHandSideWildcard TupRunit -> b + _ -> True + in (b', Lam (LeftHandSideWildcard $ lhsToTupR lhs) f') + Right range -> + let + count = usesOfFun range f + in case shrinkLhs count lhs of + Just (Exists lhs') -> case strengthenE (strengthenShrunkLHS lhs lhs' Just) f' of + Just f'' -> (True, Lam lhs' f'') + Nothing -> internalError "Unexpected failure in strenthenE. Variable was analysed to be unused in usesOfExp, but appeared to be used in strenthenE." + Nothing -> (b, Lam lhs f') + where + (b, f') = shrinkFun f + +shrinkFun (Body b) = Body <$> shrinkExp b + +-- Occurrence Counting +-- =================== + +-- Count the number of occurrences an in-scope scalar expression bound at the +-- given variable index recursively in a term. +-- +usesOfExp :: forall arr env t. VarsRange env -> PreOpenExp arr env t -> Count +usesOfExp range = countE + where + countE :: PreOpenExp arr env e -> Count + countE exp | matchEVarsRange range exp = Finite 1 + countE exp = case exp of + Evar v -> case varInRange range v of + Just cs -> Impossible cs + Nothing -> Finite 0 + -- + Let lhs bnd body -> countE bnd <> usesOfExp (weakenVarsRange lhs range) body + Const _ _ -> Finite 0 + Undef _ -> Finite 0 + Nil -> Finite 0 + Pair e1 e2 -> countE e1 <> countE e2 + VecPack _ e -> countE e + VecUnpack _ e -> countE e + IndexSlice _ ix sh -> countE ix <> countE sh + IndexFull _ ix sl -> countE ix <> countE sl + FromIndex _ sh i -> countE sh <> countE i + ToIndex _ sh e -> countE sh <> countE e + Case e rhs def -> countE e <> mconcat [ countE c | (_,c) <- rhs ] <> maybe (Finite 0) countE def + Cond p t e -> countE p <> countE t <> countE e + While p f x -> countE x <> loopCount (usesOfFun range p) <> loopCount (usesOfFun range f) + PrimConst _ -> Finite 0 + PrimApp _ x -> countE x + ArrayInstr _ e -> countE e + ShapeSize _ sh -> countE sh + Foreign _ _ _ e -> countE e + Coerce _ _ e -> countE e + +usesOfFun :: VarsRange env -> PreOpenFun arr env f -> Count +usesOfFun range (Lam lhs f) = usesOfFun (weakenVarsRange lhs range) f +usesOfFun range (Body b) = usesOfExp range b + +arrayInstrsInExp :: PreOpenExp arr env t -> [Exists arr] +arrayInstrsInExp = (`travE` []) + where + travE :: PreOpenExp arr env e -> [Exists arr] -> [Exists arr] + travE !exp !acc = case exp of + Let _ bnd body -> travE bnd $ travE body acc + Evar _ -> acc + Const _ _ -> acc + Undef _ -> acc + Nil -> acc + Pair x y -> travE x $ travE y acc + VecPack _ e -> travE e acc + VecUnpack _ e -> travE e acc + IndexSlice _ ix sh -> travE ix $ travE sh acc + IndexFull _ ix sl -> travE ix $ travE sl acc + ToIndex _ sh ix -> travE sh $ travE ix acc + FromIndex _ sh i -> travE sh $ travE i acc + Case e rhs def -> travE e $ travAE rhs $ travME def acc + Cond p t e -> travE p $ travE t $ travE e acc + While p f x -> travF p $ travF f $ travE x acc + PrimConst _ -> acc + PrimApp _ x -> travE x acc + ArrayInstr arr e -> Exists arr : travE e acc + ShapeSize _ sh -> travE sh acc + Foreign _ _ _ e -> travE e acc + Coerce _ _ e -> travE e acc + + travME :: Maybe (PreOpenExp arr env e) -> [Exists arr] -> [Exists arr] + travME Nothing acc = acc + travME (Just e) acc = travE e acc + + travAE :: [(TAG, PreOpenExp arr env b)] -> [Exists arr] -> [Exists arr] + travAE [] acc = acc + travAE ((_,e) : as) acc = travE e $ travAE as acc + + travF :: PreOpenFun arr env e -> [Exists arr] -> [Exists arr] + travF (Body e) = travE e + travF (Lam _ f) = travF f + +arrayInstrsInFun :: PreOpenFun arr env t -> [Exists arr] +arrayInstrsInFun (Body e) = arrayInstrsInExp e +arrayInstrsInFun (Lam _ f) = arrayInstrsInFun f diff --git a/src/Data/Array/Accelerate/Trafo/Simplify.hs b/src/Data/Array/Accelerate/Trafo/Exp/Simplify.hs similarity index 86% rename from src/Data/Array/Accelerate/Trafo/Simplify.hs rename to src/Data/Array/Accelerate/Trafo/Exp/Simplify.hs index b97b1aa26..0e737bf4c 100644 --- a/src/Data/Array/Accelerate/Trafo/Simplify.hs +++ b/src/Data/Array/Accelerate/Trafo/Exp/Simplify.hs @@ -13,7 +13,7 @@ {-# LANGUAGE TypeSynonymInstances #-} {-# LANGUAGE ViewPatterns #-} -- | --- Module : Data.Array.Accelerate.Trafo.Simplify +-- Module : Data.Array.Accelerate.Trafo.Exp.Simplify -- Copyright : [2012..2020] The Accelerate Team -- License : BSD3 -- @@ -22,14 +22,14 @@ -- Portability : non-portable (GHC extensions) -- -module Data.Array.Accelerate.Trafo.Simplify ( +module Data.Array.Accelerate.Trafo.Exp.Simplify ( simplifyFun, simplifyExp ) where -import Data.Array.Accelerate.AST +import Data.Array.Accelerate.AST.Exp import Data.Array.Accelerate.AST.Environment import Data.Array.Accelerate.AST.Idx import Data.Array.Accelerate.AST.LeftHandSide @@ -37,9 +37,8 @@ import Data.Array.Accelerate.AST.Var import Data.Array.Accelerate.Analysis.Hash import Data.Array.Accelerate.Analysis.Match import Data.Array.Accelerate.Error -import Data.Array.Accelerate.Representation.Array ( Array, ArrayR(..) ) import Data.Array.Accelerate.Representation.Shape ( ShapeR(..), shapeToList ) -import Data.Array.Accelerate.Representation.Tag +import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Trafo.Algebra import Data.Array.Accelerate.Trafo.Environment import Data.Array.Accelerate.Trafo.Shrink @@ -85,11 +84,11 @@ import qualified Data.Map.Strict as Map -- memory because there are insufficient registers available. We sidestep this -- tricky and target-dependent issue by, for now, simply ignoring it. -- -localCSE :: (Kit acc, Elt a) - => Gamma acc env env aenv - -> OpenExp env aenv a - -> OpenExp (env,a) aenv b - -> Maybe (OpenExp env aenv b) +localCSE :: (Elt a) + => Gamma arr env env + -> PreOpenExp arr env a + -> PreOpenExp arr (env,a) b + -> Maybe (PreOpenExp arr env b) localCSE env bnd body | Just ix <- lookupExp env bnd = Stats.ruleFired "CSE" . Just $ inline body (Var ix) | otherwise = Nothing @@ -101,10 +100,10 @@ localCSE env bnd body -- -- > let x = e in .. e .. -- -globalCSE :: (Kit acc, Elt t) - => Gamma acc env env aenv - -> OpenExp env aenv t - -> Maybe (OpenExp env aenv t) +globalCSE :: (Elt t) + => Gamma arr env env + -> PreOpenExp arr env t + -> Maybe (PreOpenExp arr env t) globalCSE env exp | Just ix <- lookupExp env exp = Stats.ruleFired "CSE" . Just $ Var ix | otherwise = Nothing @@ -139,11 +138,11 @@ globalCSE env exp -- loops in its target language. -- recoverLoops - :: (Kit acc, Elt b) - => Gamma acc env env aenv - -> OpenExp env aenv a - -> OpenExp (env,a) aenv b - -> Maybe (OpenExp env aenv b) + :: (Elt b) + => Gamma arr env env + -> PreOpenExp arr env a + -> PreOpenExp arr (env,a) b + -> Maybe (PreOpenExp arr env b) recoverLoops _ bnd e3 -- To introduce scaler loops, we look for expressions of the form: -- @@ -178,15 +177,15 @@ recoverLoops _ bnd e3 = Nothing where - plus :: OpenExp env aenv Int -> OpenExp env aenv Int -> OpenExp env aenv Int + plus :: PreOpenExp arr env Int -> PreOpenExp arr env Int -> PreOpenExp arr env Int plus x y = PrimApp (PrimAdd numType) $ Tuple $ NilTup `SnocTup` x `SnocTup` y - constant :: Int -> OpenExp env aenv Int + constant :: Int -> PreOpenExp arr env Int constant i = Const ((),i) matchEnvTop :: (Elt s, Elt t) - => OpenExp (env,s) aenv f - -> OpenExp (env,t) aenv g + => PreOpenExp arr (env,s) f + -> PreOpenExp arr (env,t) g -> Maybe (s :=: t) matchEnvTop _ _ = gcast Refl --} @@ -205,13 +204,14 @@ recoverLoops _ bnd e3 -- If we do not want to do inlining, we should remove the environment here. -- simplifyOpenExp - :: forall env aenv e. - Gamma env env aenv - -> OpenExp env aenv e - -> (Bool, OpenExp env aenv e) + :: forall arr env e. + IsArrayInstr arr + => Gamma arr env env + -> PreOpenExp arr env e + -> (Bool, PreOpenExp arr env e) simplifyOpenExp env = first getAny . cvtE where - cvtE :: OpenExp env aenv t -> (Any, OpenExp env aenv t) + cvtE :: PreOpenExp arr env t -> (Any, PreOpenExp arr env t) cvtE exp = case exp of Let lhs bnd body -> (u <> v, exp') where @@ -235,29 +235,27 @@ simplifyOpenExp env = first getAny . cvtE where (u, x') = cvtE x (v, fx) = evalPrimApp env f x' - Index a sh -> Index a <$> cvtE sh - LinearIndex a i -> LinearIndex a <$> cvtE i - Shape a -> shape a + ArrayInstr arr e -> cvtE e >>= arrayInstr arr ShapeSize shr sh -> shapeSize shr (cvtE sh) Foreign tp ff f e -> Foreign tp ff <$> first Any (simplifyOpenFun EmptyExp f) <*> cvtE e While p f x -> While <$> cvtF env p <*> cvtF env f <*> cvtE x Coerce t1 t2 e -> Coerce t1 t2 <$> cvtE e - cvtE' :: Gamma env' env' aenv -> OpenExp env' aenv e' -> (Any, OpenExp env' aenv e') + cvtE' :: Gamma arr env' env' -> PreOpenExp arr env' e' -> (Any, PreOpenExp arr env' e') cvtE' env' = first Any . simplifyOpenExp env' - cvtF :: Gamma env' env' aenv -> OpenFun env' aenv f -> (Any, OpenFun env' aenv f) + cvtF :: Gamma arr env' env' -> PreOpenFun arr env' f -> (Any, PreOpenFun arr env' f) cvtF env' = first Any . simplifyOpenFun env' - cvtMaybeE :: Maybe (OpenExp env aenv e') -> (Any, Maybe (OpenExp env aenv e')) + cvtMaybeE :: Maybe (PreOpenExp arr env e') -> (Any, Maybe (PreOpenExp arr env e')) cvtMaybeE Nothing = pure Nothing cvtMaybeE (Just e) = Just <$> cvtE e - cvtLet :: Gamma env' env' aenv + cvtLet :: Gamma arr env' env' -> ELeftHandSide bnd env' env'' - -> OpenExp env' aenv bnd - -> (Gamma env'' env'' aenv -> (Any, OpenExp env'' aenv t)) - -> (Any, OpenExp env' aenv t) + -> PreOpenExp arr env' bnd + -> (Gamma arr env'' env'' -> (Any, PreOpenExp arr env'' t)) + -> (Any, PreOpenExp arr env' t) cvtLet env' lhs@(LeftHandSideSingle _) bnd body = Let lhs bnd <$> body (incExp $ env' `pushExp` bnd) -- Single variable on the LHS, add binding to the environment cvtLet env' (LeftHandSideWildcard _) _ body = body env' -- Binding not used, remove let binding cvtLet env' (LeftHandSidePair l1 l2) (Pair e1 e2) body -- Split binding to multiple bindings @@ -269,20 +267,20 @@ simplifyOpenExp env = first getAny . cvtE -- Simplify conditional expressions, in particular by eliminating branches -- when the predicate is a known constant. -- - cond :: (Any, OpenExp env aenv PrimBool) - -> (Any, OpenExp env aenv t) - -> (Any, OpenExp env aenv t) - -> (Any, OpenExp env aenv t) + cond :: (Any, PreOpenExp arr env PrimBool) + -> (Any, PreOpenExp arr env t) + -> (Any, PreOpenExp arr env t) + -> (Any, PreOpenExp arr env t) cond p@(_,p') t@(_,t') e@(_,e') | Const _ 1 <- p' = Stats.knownBranch "True" (yes t') | Const _ 0 <- p' = Stats.knownBranch "False" (yes e') | Just Refl <- matchOpenExp t' e' = Stats.knownBranch "redundant" (yes e') | otherwise = Cond <$> p <*> t <*> e - caseof :: (Any, OpenExp env aenv TAG) - -> (Any, [(TAG, OpenExp env aenv b)]) - -> (Any, Maybe (OpenExp env aenv b)) - -> (Any, OpenExp env aenv b) + caseof :: (Any, PreOpenExp arr env TAG) + -> (Any, [(TAG, PreOpenExp arr env b)]) + -> (Any, Maybe (PreOpenExp arr env b)) + -> (Any, PreOpenExp arr env b) caseof x@(_,x') xs@(_,xs') md@(_,md') | Const _ t <- x' = Stats.caseElim "known" (yes (fromJust $ lookup t xs')) @@ -308,20 +306,24 @@ simplifyOpenExp env = first getAny . cvtE . Map.fromListWith merge $ [ (hashOpenExp e, (1,(t, e))) | (t,e) <- xs' ] - merge :: (Int, (TAG, OpenExp env aenv b)) -> (Int, (TAG, OpenExp env aenv b)) -> (Int, (TAG, OpenExp env aenv b)) + merge :: (Int, (TAG, PreOpenExp arr env b)) -> (Int, (TAG, PreOpenExp arr env b)) -> (Int, (TAG, PreOpenExp arr env b)) merge (n,(_,a)) (m,(_,b)) = internalCheck "hashOpenExp/collision" (maybe False (const True) (matchOpenExp a b)) $ (n+m, (0xff, a)) + arrayInstr :: arr (s -> t) -> PreOpenExp arr env s -> (Any, PreOpenExp arr env t) + arrayInstr arr e = case arrayInstrType arr of + -- When an array instruction returns unit, we don't have to evaluate it. + -- This replaces the old rule which converted 'shape a' to Nil, if the array + -- had dimension zero. As we now generalized expressions over the type of + -- array instructions, we extend this rule to any array instructions returning + -- unit. Though it will likely only trigger for zero dimensional arrays. + TupRunit -> Stats.ruleFired "arrayInstr/nil" $ yes Nil + _ -> pure $ ArrayInstr arr e + -- Shape manipulations -- - shape :: ArrayVar aenv (Array sh t) -> (Any, OpenExp env aenv sh) - shape (Var (ArrayR ShapeRz _) _) - = Stats.ruleFired "shape/Z" $ yes Nil - shape a - = pure $ Shape a - - shapeSize :: ShapeR sh -> (Any, OpenExp env aenv sh) -> (Any, OpenExp env aenv Int) + shapeSize :: ShapeR sh -> (Any, PreOpenExp arr env sh) -> (Any, PreOpenExp arr env Int) shapeSize shr (_, sh) | Just c <- extractConstTuple sh = Stats.ruleFired "shapeSize/const" $ yes (Const scalarTypeInt (product (shapeToList shr c))) @@ -329,17 +331,17 @@ simplifyOpenExp env = first getAny . cvtE = ShapeSize shr <$> sh toIndex :: ShapeR sh - -> (Any, OpenExp env aenv sh) - -> (Any, OpenExp env aenv sh) - -> (Any, OpenExp env aenv Int) + -> (Any, PreOpenExp arr env sh) + -> (Any, PreOpenExp arr env sh) + -> (Any, PreOpenExp arr env Int) toIndex _ (_,sh) (_,FromIndex _ sh' ix) | Just Refl <- matchOpenExp sh sh' = Stats.ruleFired "toIndex/fromIndex" $ yes ix toIndex shr sh ix = ToIndex shr <$> sh <*> ix fromIndex :: ShapeR sh - -> (Any, OpenExp env aenv sh) - -> (Any, OpenExp env aenv Int) - -> (Any, OpenExp env aenv sh) + -> (Any, PreOpenExp arr env sh) + -> (Any, PreOpenExp arr env Int) + -> (Any, PreOpenExp arr env sh) fromIndex _ (_,sh) (_,ToIndex _ sh' ix) | Just Refl <- matchOpenExp sh sh' = Stats.ruleFired "fromIndex/toIndex" $ yes ix fromIndex shr sh ix = FromIndex shr <$> sh <*> ix @@ -350,7 +352,7 @@ simplifyOpenExp env = first getAny . cvtE yes :: x -> (Any, x) yes x = (Any True, x) -extractConstTuple :: OpenExp env aenv t -> Maybe t +extractConstTuple :: PreOpenExp arr env t -> Maybe t extractConstTuple Nil = Just () extractConstTuple (Pair e1 e2) = (,) <$> extractConstTuple e1 <*> extractConstTuple e2 extractConstTuple (Const _ c) = Just c @@ -359,15 +361,16 @@ extractConstTuple _ = Nothing -- Simplification for open functions -- simplifyOpenFun - :: Gamma env env aenv - -> OpenFun env aenv f - -> (Bool, OpenFun env aenv f) + :: IsArrayInstr arr + => Gamma arr env env + -> PreOpenFun arr env f + -> (Bool, PreOpenFun arr env f) simplifyOpenFun env (Body e) = Body <$> simplifyOpenExp env e simplifyOpenFun env (Lam lhs f) = Lam lhs <$> simplifyOpenFun env' f where env' = lhsExpr lhs env -lhsExpr :: ELeftHandSide t env env' -> Gamma env env aenv -> Gamma env' env' aenv +lhsExpr :: ELeftHandSide t env env' -> Gamma arr env env -> Gamma arr env' env' lhsExpr (LeftHandSideWildcard _) env = env lhsExpr (LeftHandSideSingle tp) env = incExp env `pushExp` Evar (Var tp ZeroIdx) lhsExpr (LeftHandSidePair l1 l2) env = lhsExpr l2 $ lhsExpr l1 env @@ -375,10 +378,10 @@ lhsExpr (LeftHandSidePair l1 l2) env = lhsExpr l2 $ lhsExpr l1 env -- Simplify closed expressions and functions. The process is applied -- repeatedly until no more changes are made. -- -simplifyExp :: HasCallStack => Exp aenv t -> Exp aenv t +simplifyExp :: (HasCallStack, IsArrayInstr arr) => PreOpenExp arr () t -> PreOpenExp arr () t simplifyExp = iterate summariseOpenExp matchOpenExp shrinkExp (simplifyOpenExp EmptyExp) -simplifyFun :: HasCallStack => Fun aenv f -> Fun aenv f +simplifyFun :: (HasCallStack, IsArrayInstr arr) => PreOpenFun arr () f -> PreOpenFun arr () f simplifyFun = iterate summariseOpenFun matchOpenFun shrinkFun (simplifyOpenFun EmptyExp) @@ -484,22 +487,22 @@ ops = lens _ops (\Stats{..} v -> Stats { _ops = v, ..}) {-# INLINE vars #-} {-# INLINE ops #-} -summariseOpenFun :: OpenFun env aenv f -> Stats +summariseOpenFun :: PreOpenFun arr env f -> Stats summariseOpenFun (Body e) = summariseOpenExp e & terms +~ 1 summariseOpenFun (Lam _ f) = summariseOpenFun f & terms +~ 1 & binders +~ 1 -summariseOpenExp :: OpenExp env aenv t -> Stats +summariseOpenExp :: PreOpenExp arr env t -> Stats summariseOpenExp = (terms +~ 1) . goE where zero = Stats 0 0 0 0 0 - travE :: OpenExp env aenv t -> Stats + travE :: PreOpenExp arr env t -> Stats travE = summariseOpenExp - travF :: OpenFun env aenv t -> Stats + travF :: PreOpenFun arr env t -> Stats travF = summariseOpenFun - travA :: acc aenv a -> Stats + travA :: arr t -> Stats travA _ = zero & vars +~ 1 -- assume an array index, else we should have failed elsewhere travC :: PrimConst c -> Stats @@ -535,7 +538,7 @@ summariseOpenExp = (terms +~ 1) . goE -- travVectorType (Vector16Type t) = travSingleType t & types +~ 1 -- The scrutinee has already been counted - goE :: OpenExp env aenv t -> Stats + goE :: PreOpenExp arr env t -> Stats goE exp = case exp of Let _ bnd body -> travE bnd +++ travE body & binders +~ 1 @@ -555,9 +558,7 @@ summariseOpenExp = (terms +~ 1) . goE Cond p t e -> travE p +++ travE t +++ travE e While p f x -> travF p +++ travF f +++ travE x PrimConst c -> travC c - Index a ix -> travA a +++ travE ix - LinearIndex a ix -> travA a +++ travE ix - Shape a -> travA a + ArrayInstr a e -> travA a +++ travE e ShapeSize _ sh -> travE sh PrimApp f x -> travPrimFun f +++ travE x Coerce _ _ e -> travE e diff --git a/src/Data/Array/Accelerate/Trafo/Exp/Substitution.hs b/src/Data/Array/Accelerate/Trafo/Exp/Substitution.hs new file mode 100644 index 000000000..43c8437f0 --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/Exp/Substitution.hs @@ -0,0 +1,522 @@ +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE EmptyCase #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE PatternGuards #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TupleSections #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE ViewPatterns #-} +{-# OPTIONS_HADDOCK hide #-} +-- | +-- Module : Data.Array.Accelerate.Trafo.Exp.Substitution +-- Copyright : [2012..2020] The Accelerate Team +-- License : BSD3 +-- +-- Maintainer : Trevor L. McDonell +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- + +module Data.Array.Accelerate.Trafo.Exp.Substitution ( + + -- ** Renaming & Substitution + inline, inlineVars, compose, + subTop, apply1, apply2, + + -- ** Weakening + (:>), SinkExp(..), weakenVars, + + -- ** Strengthening + (:?>), strengthenE, + + -- ** Rebuilding terms + RebuildableExp(..), rebuildLHS, + lhsFullVars, + + RebuildArrayInstr, rebuildArrayInstrMap, + rebuildNoArrayInstr, + + -- ** Checks + isIdentity, extractExpVars, + bindingIsTrivial, + +) where + +import Data.Array.Accelerate.AST.Exp +import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.AST.Var +import Data.Array.Accelerate.AST.Idx +import Data.Array.Accelerate.AST.Environment +import Data.Array.Accelerate.Analysis.Match +import Data.Array.Accelerate.Error +import Data.Array.Accelerate.Representation.Type +import qualified Data.Array.Accelerate.Debug.Stats as Stats + +import Data.Kind +import Control.Applicative hiding ( Const ) +import Control.Monad +import Prelude hiding ( exp, seq ) + +infixr `compose` + + +lhsFullVars :: forall s a env1 env2. LeftHandSide s a env1 env2 -> Maybe (Vars s env2 a) +lhsFullVars = fmap snd . go weakenId + where + go :: forall env env' b. (env' :> env2) -> LeftHandSide s b env env' -> Maybe (env :> env2, Vars s env2 b) + go k (LeftHandSideWildcard TupRunit) = Just (k, TupRunit) + go k (LeftHandSideSingle s) = Just $ (weakenSucc $ k, TupRsingle $ Var s $ k >:> ZeroIdx) + go k (LeftHandSidePair l1 l2) + | Just (k', v2) <- go k l2 + , Just (k'', v1) <- go k' l1 = Just (k'', TupRpair v1 v2) + go _ _ = Nothing + +bindingIsTrivial :: LeftHandSide s a env1 env2 -> Vars s env2 b -> Maybe (a :~: b) +bindingIsTrivial lhs vars + | Just lhsVars <- lhsFullVars lhs + , Just Refl <- matchVars vars lhsVars + = Just Refl +bindingIsTrivial _ _ = Nothing + +isIdentity :: PreOpenFun arr env (a -> b) -> Maybe (a :~: b) +isIdentity (Lam lhs (Body (extractExpVars -> Just vars))) = bindingIsTrivial lhs vars +isIdentity _ = Nothing + +-- | Replace the first variable with the given expression. The environment +-- shrinks. +-- +inline :: PreOpenExp arr (env, s) t + -> PreOpenExp arr env s + -> PreOpenExp arr env t +inline f g = Stats.substitution "inline" $ rebuildE (subTop g) f + +inlineVars :: forall arr env env' t1 t2. + ELeftHandSide t1 env env' + -> PreOpenExp arr env' t2 + -> PreOpenExp arr env t1 + -> Maybe (PreOpenExp arr env t2) +inlineVars lhsBound expr bound + | Just vars <- lhsFullVars lhsBound = substitute (strengthenWithLHS lhsBound) weakenId vars expr + where + substitute + :: forall env1 env2 t. + env1 :?> env2 + -> env :> env2 + -> ExpVars env1 t1 + -> PreOpenExp arr env1 t + -> Maybe (PreOpenExp arr env2 t) + substitute _ k2 vars (extractExpVars -> Just vars') + | Just Refl <- matchVars vars vars' = Just $ weakenE k2 bound + substitute k1 k2 vars topExp = case topExp of + Let lhs e1 e2 + | Exists lhs' <- rebuildLHS lhs + -> Let lhs' <$> travE e1 <*> substitute (strengthenAfter lhs lhs' k1) (weakenWithLHS lhs' .> k2) (weakenWithLHS lhs `weakenVars` vars) e2 + Evar (Var t ix) -> Evar . Var t <$> k1 ix + Foreign tp asm f e1 -> Foreign tp asm f <$> travE e1 + Pair e1 e2 -> Pair <$> travE e1 <*> travE e2 + Nil -> Just Nil + VecPack vec e1 -> VecPack vec <$> travE e1 + VecUnpack vec e1 -> VecUnpack vec <$> travE e1 + IndexSlice si e1 e2 -> IndexSlice si <$> travE e1 <*> travE e2 + IndexFull si e1 e2 -> IndexFull si <$> travE e1 <*> travE e2 + ToIndex shr e1 e2 -> ToIndex shr <$> travE e1 <*> travE e2 + FromIndex shr e1 e2 -> FromIndex shr <$> travE e1 <*> travE e2 + Case e1 rhs def -> Case <$> travE e1 <*> mapM (\(t,c) -> (t,) <$> travE c) rhs <*> travMaybeE def + Cond e1 e2 e3 -> Cond <$> travE e1 <*> travE e2 <*> travE e3 + While f1 f2 e1 -> While <$> travF f1 <*> travF f2 <*> travE e1 + Const t c -> Just $ Const t c + PrimConst c -> Just $ PrimConst c + PrimApp p e1 -> PrimApp p <$> travE e1 + ArrayInstr arr e1 -> ArrayInstr arr <$> travE e1 + ShapeSize shr e1 -> ShapeSize shr <$> travE e1 + Undef t -> Just $ Undef t + Coerce t1 t2 e1 -> Coerce t1 t2 <$> travE e1 + + where + travE :: PreOpenExp arr env1 s -> Maybe (PreOpenExp arr env2 s) + travE = substitute k1 k2 vars + + travF :: PreOpenFun arr env1 s -> Maybe (PreOpenFun arr env2 s) + travF = substituteF k1 k2 vars + + travMaybeE :: Maybe (PreOpenExp arr env1 s) -> Maybe (Maybe (PreOpenExp arr env2 s)) + travMaybeE Nothing = pure Nothing + travMaybeE (Just x) = Just <$> travE x + + substituteF :: forall env1 env2 t. + env1 :?> env2 + -> env :> env2 + -> ExpVars env1 t1 + -> PreOpenFun arr env1 t + -> Maybe (PreOpenFun arr env2 t) + substituteF k1 k2 vars (Body e) = Body <$> substitute k1 k2 vars e + substituteF k1 k2 vars (Lam lhs f) + | Exists lhs' <- rebuildLHS lhs = Lam lhs' <$> substituteF (strengthenAfter lhs lhs' k1) (weakenWithLHS lhs' .> k2) (weakenWithLHS lhs `weakenVars` vars) f + +inlineVars _ _ _ = Nothing + + +-- | Composition of unary functions. +-- +compose :: HasCallStack + => PreOpenFun arr env (b -> c) + -> PreOpenFun arr env (a -> b) + -> PreOpenFun arr env (a -> c) +compose f@(Lam lhsB (Body c)) g@(Lam lhsA (Body b)) + | Stats.substitution "compose" False = undefined + | Just Refl <- isIdentity f = g -- don't rebind an identity function + | Just Refl <- isIdentity g = f + + | Exists lhsB' <- rebuildLHS lhsB + = Lam lhsA + $ Body + $ Let lhsB' b + $ weakenE (sinkWithLHS lhsB lhsB' $ weakenWithLHS lhsA) c + -- = Stats.substitution "compose" . Lam lhs2 . Body $ substitute' f g +compose _ + _ = internalError "compose: impossible evaluation" + +subTop :: PreOpenExp arr env s -> ExpVar (env, s) t -> PreOpenExp arr env t +subTop s (Var _ ZeroIdx ) = s +subTop _ (Var tp (SuccIdx ix)) = Evar $ Var tp ix + +-- Applies an argument to a unary function +-- +apply1 :: IsArrayInstr arr => TypeR t -> PreOpenFun arr () (s -> t) -> PreOpenExp arr env s -> PreOpenExp arr env t +apply1 tp fun arg = case weakenE (weakenEmpty) fun of + Body e -> functionImpossible $ expType e + Lam lhs (Body b) -> Let lhs arg b + Lam _ (Lam _ _) -> functionImpossible tp + +-- Applies arguments to a binary function +-- +apply2 :: IsArrayInstr arr => TypeR t -> PreOpenFun arr () (s -> u -> t) -> PreOpenExp arr env s -> PreOpenExp arr env u -> PreOpenExp arr env t +apply2 tp fun a1 a2 = case weakenE (weakenEmpty) fun of + Body e -> functionImpossible $ expType e + Lam _ (Body e) -> functionImpossible $ expType e + Lam l1 (Lam l2 (Body b)) -> Let (LeftHandSidePair l1 l2) (Pair a1 a2) b + Lam _ (Lam _ (Lam _ _)) -> functionImpossible tp + +-- A class for rebuilding scalar terms. +-- +class RebuildableExp f where + {-# MINIMAL rebuildPartialE, rebuildArrayInstrPartial #-} + rebuildPartialE :: (Applicative f', SyntacticExp fe) + => (forall e'. ExpVar env e' -> f' (fe arr env' e')) + -> f arr env e + -> f' (f arr env' e) + + {-# INLINEABLE rebuildE #-} + rebuildE :: SyntacticExp fe + => (forall e'. ExpVar env e' -> fe arr env' e') + -> f arr env e + -> f arr env' e + rebuildE v = runIdentity . rebuildPartialE (Identity . v) + + rebuildArrayInstrPartial :: Applicative f' + => RebuildArrayInstr f' arr arr' + -> f arr env e + -> f' (f arr' env e) + + {-# INLINEABLE rebuildArrayInstr #-} + rebuildArrayInstr :: (forall s t env'. arr (s -> t) -> PreOpenExp arr' env' s -> PreOpenExp arr' env' t) + -> f arr env e + -> f arr' env e + rebuildArrayInstr v = runIdentity . rebuildArrayInstrPartial (Identity . v) + +instance RebuildableExp PreOpenExp where + {-# INLINEABLE rebuildPartialE #-} + rebuildPartialE v x = Stats.substitution "rebuild" $ rebuildOpenExp v x + + {-# INLINEABLE rebuildArrayInstrPartial #-} + rebuildArrayInstrPartial v x = Stats.substitution "rebuildArrayInstr" $ rebuildArrayInstrOpenExp v x + +instance RebuildableExp PreOpenFun where + {-# INLINEABLE rebuildPartialE #-} + rebuildPartialE v x = Stats.substitution "rebuild" $ rebuildFun v x + + {-# INLINEABLE rebuildArrayInstrPartial #-} + rebuildArrayInstrPartial v x = Stats.substitution "rebuildArrayInstr" $ rebuildArrayInstrFun v x + +rebuildNoArrayInstr :: RebuildableExp f => f NoArrayInstr env e -> f arr env e +rebuildNoArrayInstr = rebuildArrayInstr k + where + k :: NoArrayInstr t -> a + k a = case a of {} + +-- NOTE: [Weakening] +-- +-- Weakening is something we usually take for granted: every time you learn a +-- new word, old sentences still make sense. If a conclusion is justified by a +-- hypothesis, it is still justified if you add more hypotheses. Similarly, a +-- term remains in scope if you bind more (fresh) variables. Weakening is the +-- operation of shifting things from one scope to a larger scope in which new +-- things have become meaningful, but no old things have vanished. +-- +-- When we use a named representation (or HOAS) we get weakening for free. But +-- in the de Bruijn representation weakening takes work: you have to shift all +-- variable references to make room for the new bindings. +-- + +-- TODO: Should we merge this type class with Sink? 'weaken' and 'weakenE' now have the same +-- type, because of various refactorings. +-- +class SinkExp (f :: Type -> Type -> Type) where + weakenE :: env :> env' -> f env t -> f env' t + + -- TLM: We can't use this default instance because it doesn't lead to + -- specialised code. Perhaps the INLINEABLE pragma is ignored: GHC bug? + -- + -- {-# INLINEABLE weakenE #-} + -- default weakenE :: RebuildableExp f => env :> env' -> f arr env t -> f arr env' t + -- weakenE v = Stats.substitution "weakenE" . rebuildE (IE . v) + +instance SinkExp Idx where + {-# INLINEABLE weakenE #-} + weakenE = (>:>) + +instance SinkExp (Var s) where + {-# INLINEABLE weakenE #-} + weakenE k (Var s ix) = Var s (k >:> ix) + +instance SinkExp (PreOpenExp arr) where + {-# INLINEABLE weakenE #-} + weakenE v = Stats.substitution "weakenE" . rebuildE (rebuildWeakenEvar v) + +instance SinkExp (PreOpenFun arr) where + {-# INLINEABLE weakenE #-} + weakenE v = Stats.substitution "weakenE" . rebuildE (rebuildWeakenEvar v) + +-- This rewrite rule is disabled because 'weaken' is now part of a type class. +-- As such, we cannot attach a NOINLINE pragma because it has many definitions. +-- {-# RULES +-- "weakenE/weakenE" forall a (v1 :: env' :> env'') (v2 :: env :> env'). +-- weakenE v1 (weakenE v2 a) = weakenE (v1 . v2) a +-- #-} + +weakenVars :: env :> env' -> Vars s env t -> Vars s env' t +weakenVars _ TupRunit = TupRunit +weakenVars k (TupRsingle v) = TupRsingle $ weakenE k v +weakenVars k (TupRpair v w) = TupRpair (weakenVars k v) (weakenVars k w) + +rebuildWeakenEvar :: env :> env' -> ExpVar env t -> PreOpenExp arr env' t +rebuildWeakenEvar k (Var s idx) = Evar $ Var s $ k >:> idx + +-- NOTE: [Strengthening] +-- +-- Strengthening is the dual of weakening. Shifting terms from one scope to a +-- smaller scope. Of course this is not always possible. If the term contains +-- any variables not in the new environment, then it cannot be strengthened. +-- This partial behaviour is captured with 'Maybe'. +-- + +-- The type of partially shifting terms from one context into another. +type env :?> env' = forall t'. Idx env t' -> Maybe (Idx env' t') + +{-# INLINEABLE strengthenE #-} +strengthenE :: forall f arr env env' t. RebuildableExp f => env :?> env' -> f arr env t -> Maybe (f arr env' t) +strengthenE k x = Stats.substitution "strengthenE" $ rebuildPartialE @f @Maybe @IdxE (\(Var tp ix) -> fmap (IE . Var tp) $ k ix) x + +strengthenWithLHS :: LeftHandSide s t env1 env2 -> env2 :?> env1 +strengthenWithLHS (LeftHandSideWildcard _) = Just +strengthenWithLHS (LeftHandSideSingle _) = \ix -> case ix of + ZeroIdx -> Nothing + SuccIdx i -> Just i +strengthenWithLHS (LeftHandSidePair l1 l2) = strengthenWithLHS l2 >=> strengthenWithLHS l1 + +strengthenAfter :: LeftHandSide s t env1 env2 -> LeftHandSide s t env1' env2' -> env1 :?> env1' -> env2 :?> env2' +strengthenAfter (LeftHandSideWildcard _) (LeftHandSideWildcard _) k = k +strengthenAfter (LeftHandSideSingle _) (LeftHandSideSingle _) k = \ix -> case ix of + ZeroIdx -> Just ZeroIdx + SuccIdx i -> SuccIdx <$> k i +strengthenAfter (LeftHandSidePair l1 l2) (LeftHandSidePair l1' l2') k = + strengthenAfter l2 l2' $ strengthenAfter l1 l1' k +strengthenAfter _ _ _ = error "Substitution.strengthenAfter: left hand sides do not match" + + +-- Simultaneous Substitution =================================================== +-- + +-- The scalar environment +-- ------------------ + +-- SEE: [Renaming and Substitution] +-- SEE: [Weakening] +-- +class SyntacticExp f where + varIn :: ExpVar env t -> f arr env t + expOut :: f arr env t -> PreOpenExp arr env t + weakenExp :: f arr env t -> f arr (env, s) t + +newtype IdxE (arr :: Type -> Type) env t = IE { unIE :: ExpVar env t } + +instance SyntacticExp IdxE where + varIn = IE + expOut = Evar . unIE + weakenExp (IE (Var tp ix)) = IE $ Var tp $ SuccIdx ix + +instance SyntacticExp PreOpenExp where + varIn = Evar + expOut = id + weakenExp = runIdentity . rebuildOpenExp (Identity . weakenExp . IE) + +{-# INLINEABLE shiftE #-} +shiftE + :: (Applicative f, SyntacticExp fe) + => RebuildEvar f fe arr env env' + -> RebuildEvar f fe arr (env, s) (env', s) +shiftE _ (Var tp ZeroIdx) = pure $ varIn (Var tp ZeroIdx) +shiftE v (Var tp (SuccIdx ix)) = weakenExp <$> v (Var tp ix) + +{-# INLINEABLE shiftE' #-} +shiftE' + :: (Applicative f, SyntacticExp fe) + => ELeftHandSide t env1 env1' + -> ELeftHandSide t env2 env2' + -> RebuildEvar f fe arr env1 env2 + -> RebuildEvar f fe arr env1' env2' +shiftE' (LeftHandSideWildcard _) (LeftHandSideWildcard _) v = v +shiftE' (LeftHandSideSingle _) (LeftHandSideSingle _) v = shiftE v +shiftE' (LeftHandSidePair a1 b1) (LeftHandSidePair a2 b2) v = shiftE' b1 b2 $ shiftE' a1 a2 v +shiftE' _ _ _ = error "Substitution: left hand sides do not match" + +type RebuildEvar f fe (arr :: Type -> Type) env env' = + forall t'. ExpVar env t' -> f (fe arr env' t') + +{-# INLINEABLE rebuildMaybeExp #-} +rebuildMaybeExp + :: (HasCallStack, Applicative f, SyntacticExp fe) + => RebuildEvar f fe arr env env' + -> Maybe (PreOpenExp arr env t) + -> f (Maybe (PreOpenExp arr env' t)) +rebuildMaybeExp _ Nothing = pure Nothing +rebuildMaybeExp v (Just x) = Just <$> rebuildOpenExp v x + +{-# INLINEABLE rebuildOpenExp #-} +rebuildOpenExp + :: (HasCallStack, Applicative f, SyntacticExp fe) + => RebuildEvar f fe arr env env' + -> PreOpenExp arr env t + -> f (PreOpenExp arr env' t) +rebuildOpenExp v exp = + case exp of + Const t c -> pure $ Const t c + PrimConst c -> pure $ PrimConst c + Undef t -> pure $ Undef t + Evar var -> expOut <$> v var + Let lhs a b + | Exists lhs' <- rebuildLHS lhs + -> Let lhs' <$> rebuildOpenExp v a <*> rebuildOpenExp (shiftE' lhs lhs' v) b + Pair e1 e2 -> Pair <$> rebuildOpenExp v e1 <*> rebuildOpenExp v e2 + Nil -> pure Nil + VecPack vec e -> VecPack vec <$> rebuildOpenExp v e + VecUnpack vec e -> VecUnpack vec <$> rebuildOpenExp v e + IndexSlice x ix sh -> IndexSlice x <$> rebuildOpenExp v ix <*> rebuildOpenExp v sh + IndexFull x ix sl -> IndexFull x <$> rebuildOpenExp v ix <*> rebuildOpenExp v sl + ToIndex shr sh ix -> ToIndex shr <$> rebuildOpenExp v sh <*> rebuildOpenExp v ix + FromIndex shr sh ix -> FromIndex shr <$> rebuildOpenExp v sh <*> rebuildOpenExp v ix + Case e rhs def -> Case <$> rebuildOpenExp v e <*> sequenceA [ (t,) <$> rebuildOpenExp v c | (t,c) <- rhs ] <*> rebuildMaybeExp v def + Cond p t e -> Cond <$> rebuildOpenExp v p <*> rebuildOpenExp v t <*> rebuildOpenExp v e + While p f x -> While <$> rebuildFun v p <*> rebuildFun v f <*> rebuildOpenExp v x + PrimApp f x -> PrimApp f <$> rebuildOpenExp v x + ArrayInstr arr e -> ArrayInstr arr <$> rebuildOpenExp v e + ShapeSize shr sh -> ShapeSize shr <$> rebuildOpenExp v sh + Foreign tp ff f e -> Foreign tp ff f <$> rebuildOpenExp v e + Coerce t1 t2 e -> Coerce t1 t2 <$> rebuildOpenExp v e + +{-# INLINEABLE rebuildFun #-} +rebuildFun + :: (HasCallStack, Applicative f, SyntacticExp fe) + => RebuildEvar f fe arr env env' + -> PreOpenFun arr env t + -> f (PreOpenFun arr env' t) +rebuildFun v fun = + case fun of + Body e -> Body <$> rebuildOpenExp v e + Lam lhs f + | Exists lhs' <- rebuildLHS lhs + -> Lam lhs' <$> rebuildFun (shiftE' lhs lhs' v) f + +{-# INLINEABLE rebuildLHS #-} +rebuildLHS :: LeftHandSide s t aenv1 aenv1' -> Exists (LeftHandSide s t aenv2) +rebuildLHS (LeftHandSideWildcard r) = Exists $ LeftHandSideWildcard r +rebuildLHS (LeftHandSideSingle s) = Exists $ LeftHandSideSingle s +rebuildLHS (LeftHandSidePair as bs) + | Exists as' <- rebuildLHS as + , Exists bs' <- rebuildLHS bs + = Exists $ LeftHandSidePair as' bs' + +type RebuildArrayInstr f arr arr' = forall s t env. arr (s -> t) -> f (PreOpenExp arr' env s -> PreOpenExp arr' env t) + +-- RebuildArrayInstr corresponds to the bind of a monad, meaning that a single array instruction can +-- be transformed to an expressions, possibly containing multiple array instructions. For many cases +-- it may be sufficient to only have the functor (map) interface. This function converts a map-like +-- function to the bind-like function. +-- +rebuildArrayInstrMap + :: Applicative f + => (forall s t. arr (s -> t) -> f (arr' (s -> t))) + -> RebuildArrayInstr f arr arr' +rebuildArrayInstrMap f arr = ArrayInstr <$> f arr + +rebuildArrayInstrOpenExp + :: forall f arr arr' env t. + (HasCallStack, Applicative f) + => RebuildArrayInstr f arr arr' + -> PreOpenExp arr env t + -> f (PreOpenExp arr' env t) +rebuildArrayInstrOpenExp v = \case + Let lhs e1 e2 -> Let lhs <$> travE e1 <*> travE e2 + Evar var -> pure $ Evar var + Foreign t asm f x -> Foreign t asm f <$> travE x + Pair e1 e2 -> Pair <$> travE e1 <*> travE e2 + Nil -> pure Nil + VecPack vecr e -> VecPack vecr <$> travE e + VecUnpack vecr e -> VecUnpack vecr <$> travE e + IndexSlice slice slix sh -> IndexSlice slice <$> travE slix <*> travE sh + IndexFull slice slix sl -> IndexFull slice <$> travE slix <*> travE sl + ToIndex shr sh ix -> ToIndex shr <$> travE sh <*> travE ix + FromIndex shr sh ix -> FromIndex shr <$> travE sh <*> travE ix + Case e rhs def -> Case <$> travE e <*> sequenceA [ (t,) <$> travE c | (t,c) <- rhs ] <*> travME def + Cond e1 e2 e3 -> Cond <$> travE e1 <*> travE e2 <*> travE e3 + While c f x -> While <$> travF c <*> travF f <*> travE x + Const tp c -> pure $ Const tp c + PrimConst prim -> pure $ PrimConst prim + PrimApp f x -> PrimApp f <$> travE x + ArrayInstr arr x -> v arr <*> travE x + ShapeSize shr sh -> ShapeSize shr <$> travE sh + Undef tp -> pure $ Undef tp + Coerce t1 t2 e -> Coerce t1 t2 <$> travE e + where + travE :: PreOpenExp arr env' t' -> f (PreOpenExp arr' env' t') + travE = rebuildArrayInstrOpenExp v + + travF :: PreOpenFun arr env' t' -> f (PreOpenFun arr' env' t') + travF = rebuildArrayInstrFun v + + travME :: Maybe (PreOpenExp arr env' t') -> f (Maybe (PreOpenExp arr' env' t')) + travME Nothing = pure Nothing + travME (Just e) = Just <$> travE e + +rebuildArrayInstrFun + :: (HasCallStack, Applicative f) + => RebuildArrayInstr f arr arr' + -> PreOpenFun arr env t + -> f (PreOpenFun arr' env t) +rebuildArrayInstrFun v (Body e) = Body <$> rebuildArrayInstrOpenExp v e +rebuildArrayInstrFun v (Lam lhs f) = Lam lhs <$> rebuildArrayInstrFun v f + + +extractExpVars :: PreOpenExp arr env a -> Maybe (ExpVars env a) +extractExpVars Nil = Just TupRunit +extractExpVars (Pair e1 e2) = TupRpair <$> extractExpVars e1 <*> extractExpVars e2 +extractExpVars (Evar v) = Just $ TupRsingle v +extractExpVars _ = Nothing diff --git a/src/Data/Array/Accelerate/Trafo/Fusion.hs b/src/Data/Array/Accelerate/Trafo/Fusion.hs index 2ada0a3d3..ad4c357d8 100644 --- a/src/Data/Array/Accelerate/Trafo/Fusion.hs +++ b/src/Data/Array/Accelerate/Trafo/Fusion.hs @@ -52,7 +52,7 @@ import Data.Array.Accelerate.Trafo.Var import Data.Array.Accelerate.Trafo.Delayed import Data.Array.Accelerate.Trafo.Environment import Data.Array.Accelerate.Trafo.Shrink -import Data.Array.Accelerate.Trafo.Simplify +import Data.Array.Accelerate.Trafo.Exp.Simplify import Data.Array.Accelerate.Trafo.Substitution import Data.Array.Accelerate.Representation.Array ( Array, ArrayR(..), ArraysR ) import Data.Array.Accelerate.Representation.Shape ( ShapeR(..), shapeType ) @@ -420,9 +420,9 @@ embedPreOpenAcc config matchAcc embedAcc elimAcc pacc Scan d f z a -> embed aR (into2M (Scan d) (cvtF f) (cvtE <$> z)) a Scan' d f z a -> embed aR (into2 (Scan' d) (cvtF f) (cvtE z)) a Permute f d p a -> embed2 aR (into2 permute (cvtF f) (cvtF p)) d a - Stencil s t f x a -> embed aR (into2 (stencil1 s t) (cvtF f) (cvtB x)) a + Stencil s t f x a -> embed aR (into2B (stencil1 s t) (cvtF f) (cvtB x)) a Stencil2 s1 s2 t f x a y b - -> embed2 aR (into3 (stencil2 s1 s2 t) (cvtF f) (cvtB x) (cvtB y)) a b + -> embed2 aR (into3B (stencil2 s1 s2 t) (cvtF f) (cvtB x) (cvtB y)) a b where aR = arraysR pacc @@ -480,37 +480,45 @@ embedPreOpenAcc config matchAcc embedAcc elimAcc pacc -- Helpers to embed and fuse delayed terms -- - into :: (HasCallStack, Sink f) - => (f env' a -> b) - -> f env a + into :: (HasCallStack, RebuildableExp f) + => (f (ArrayInstr env') () a -> b) + -> f (ArrayInstr env) () a -> Extend ArrayR OpenAcc env env' -> b - into op a env = op (sinkA env a) + into op a env = op (sinkArrayInstr env a) - into2 :: (HasCallStack, Sink f1, Sink f2) - => (f1 env' a -> f2 env' b -> c) - -> f1 env a + into2 :: (HasCallStack, RebuildableExp f1, RebuildableExp f2) + => (f1 (ArrayInstr env') () a -> f2 (ArrayInstr env') () b -> c) + -> f1 (ArrayInstr env) () a + -> f2 (ArrayInstr env) () b + -> Extend ArrayR OpenAcc env env' + -> c + into2 op a b env = op (sinkArrayInstr env a) (sinkArrayInstr env b) + + into2B :: (HasCallStack, RebuildableExp f1, Sink f2) + => (f1 (ArrayInstr env') () a -> f2 env' b -> c) + -> f1 (ArrayInstr env) () a -> f2 env b -> Extend ArrayR OpenAcc env env' -> c - into2 op a b env = op (sinkA env a) (sinkA env b) + into2B op a b env = op (sinkArrayInstr env a) (sinkA env b) - into2M :: (HasCallStack, Sink f1, Sink f2) - => (f1 env' a -> Maybe (f2 env' b) -> c) - -> f1 env a - -> Maybe (f2 env b) + into2M :: (HasCallStack, RebuildableExp f1, RebuildableExp f2) + => (f1 (ArrayInstr env') () a -> Maybe (f2 (ArrayInstr env') () b) -> c) + -> f1 (ArrayInstr env) () a + -> Maybe (f2 (ArrayInstr env) () b) -> Extend ArrayR acc env env' -> c - into2M op a b env = op (sinkA env a) (sinkA env <$> b) + into2M op a b env = op (sinkArrayInstr env a) (sinkArrayInstr env <$> b) - into3 :: (HasCallStack, Sink f1, Sink f2, Sink f3) - => (f1 env' a -> f2 env' b -> f3 env' c -> d) - -> f1 env a + into3B :: (HasCallStack, RebuildableExp f1, Sink f2, Sink f3) + => (f1 (ArrayInstr env') () a -> f2 env' b -> f3 env' c -> d) + -> f1 (ArrayInstr env) () a -> f2 env b -> f3 env c -> Extend ArrayR OpenAcc env env' -> d - into3 op a b c env = op (sinkA env a) (sinkA env b) (sinkA env c) + into3B op a b c env = op (sinkArrayInstr env a) (sinkA env b) (sinkA env c) -- Operations which can be fused into consumers. Move all of the local -- bindings out of the way so that the fusible function operates @@ -807,8 +815,8 @@ instance HasArraysR Cunctation where instance Sink Cunctation where weaken k = \case Done v -> Done (weakenVars k v) - Step repr sh p f v -> Step repr (weaken k sh) (weaken k p) (weaken k f) (weaken k v) - Yield repr sh f -> Yield repr (weaken k sh) (weaken k f) + Step repr sh p f v -> Step repr (weakenArrayInstr k sh) (weakenArrayInstr k p) (weakenArrayInstr k f) (weaken k v) + Yield repr sh f -> Yield repr (weakenArrayInstr k sh) (weakenArrayInstr k f) simplifyCC :: HasCallStack => Cunctation aenv a -> Cunctation aenv a simplifyCC = \case @@ -1032,8 +1040,8 @@ mapD tR f (Embed env cc) = Stats.ruleFired "mapD" $ Embed env (go cc) where - go (step -> Just (Step (ArrayR shR _) sh ix g v)) = Step (ArrayR shR tR) sh ix (sinkA env f `compose` g) v - go (yield -> Yield (ArrayR shR _) sh g) = Yield (ArrayR shR tR) sh (sinkA env f `compose` g) + go (step -> Just (Step (ArrayR shR _) sh ix g v)) = Step (ArrayR shR tR) sh ix (sinkArrayInstr env f `compose` g) v + go (yield -> Yield (ArrayR shR _) sh g) = Yield (ArrayR shR tR) sh (sinkArrayInstr env f `compose` g) -- If we are unzipping a manifest array then force the term to be computed; @@ -1092,13 +1100,12 @@ transformD (ArrayR shR' tR) sh' p f -> Embed OpenAcc aenv bs fuse op (Embed env cc) = Embed env (op env cc) - into2 :: (HasCallStack, Sink f1, Sink f2) - => (f1 env' a -> f2 env' b -> c) - -> f1 env a - -> f2 env b - -> Extend ArrayR OpenAcc env env' + into2 :: (OpenExp env aenv' a -> OpenFun env aenv' b -> c) + -> OpenExp env aenv a + -> OpenFun env aenv b + -> Extend ArrayR OpenAcc aenv aenv' -> c - into2 op a b env = op (sinkA env a) (sinkA env b) + into2 op a b env = op (sinkArrayInstr env a) (sinkArrayInstr env b) -- Replicate as a backwards permutation @@ -1147,7 +1154,7 @@ reshapeD -> Embed OpenAcc aenv (Array sh e) -> Exp aenv sl -> Embed OpenAcc aenv (Array sl e) -reshapeD slr (Embed env cc) (sinkA env -> sl) +reshapeD slr (Embed env cc) (sinkArrayInstr env -> sl) | Done v <- cc = Embed (env `pushArrayEnv` OpenAcc (Reshape slr sl (avarsIn OpenAcc v))) $ doneZeroIdx repr @@ -1412,8 +1419,8 @@ aletD' embedAcc elimAcc (LeftHandSideSingle ArrayR{}) (Embed env1 cc1) (Embed en -> Fun aenv' (sh -> e) -> Embed OpenAcc aenv brrs elim r sh1 f1 - | sh1' <- weaken (weakenSucc' weakenId) sh1 - , f1' <- weaken (weakenSucc' weakenId) f1 + | sh1' <- weakenArrayInstr (weakenSucc' weakenId) sh1 + , f1' <- weakenArrayInstr (weakenSucc' weakenId) f1 , Embed env0' cc0' <- embedAcc $ rebuildA (subAtop bnd) $ kmap (replaceA sh1' f1' $ Var r ZeroIdx) body = Embed (env1 `append` env0') cc0' @@ -1454,23 +1461,23 @@ aletD' embedAcc elimAcc (LeftHandSideSingle ArrayR{}) (Embed env1 cc1) (Embed en While p f x -> While (replaceF sh' f' avar p) (replaceF sh' f' avar f) (cvtE x) Coerce t1 t2 e -> Coerce t1 t2 (cvtE e) - Shape a + ArrayInstr (Shape a) _ | Just Refl <- matchVar a avar -> Stats.substitution "replaceE/shape" sh' | otherwise -> exp - Index a sh + ArrayInstr (Index a) sh | Just Refl <- matchVar a avar , Lam lhs (Body b) <- f' -> Stats.substitution "replaceE/!" . cvtE $ Let lhs sh b - | otherwise -> Index a (cvtE sh) + | otherwise -> ArrayInstr (Index a) (cvtE sh) - LinearIndex a i + ArrayInstr (LinearIndex a) i | Just Refl <- matchVar a avar , Lam lhs (Body b) <- f' -> Stats.substitution "replaceE/!!" . cvtE $ Let lhs (Let (LeftHandSideSingle scalarTypeInt) i $ FromIndex shR (weakenE (weakenSucc' weakenId) sh') $ Evar $ Var scalarTypeInt ZeroIdx) b - | otherwise -> LinearIndex a (cvtE i) + | otherwise -> ArrayInstr (LinearIndex a) (cvtE i) where cvtE :: OpenExp env aenv s -> OpenExp env aenv s @@ -1503,8 +1510,8 @@ aletD' embedAcc elimAcc (LeftHandSideSingle ArrayR{}) (Embed env1 cc1) (Embed en Alet lhs bnd (body :: OpenAcc aenv1 a) -> let w :: aenv :> aenv1 w = weakenWithLHS lhs - sh'' = weaken w sh' - f'' = weaken w f' + sh'' = weakenArrayInstr w sh' + f'' = weakenArrayInstr w f' in Alet lhs (cvtA bnd) (kmap (replaceA sh'' f'' (weaken w avar)) body) @@ -1560,8 +1567,8 @@ aletD' embedAcc elimAcc (LeftHandSideSingle ArrayR{}) (Embed env1 cc1) (Embed en -> PreOpenAfun OpenAcc aenv a cvt sh'' f'' avar' (Abody a) = Abody $ kmap (replaceA sh'' f'' avar') a cvt sh'' f'' avar' (Alam lhs (af :: PreOpenAfun OpenAcc aenv1 b)) = - Alam lhs $ cvt (weaken w sh'') - (weaken w f'') + Alam lhs $ cvt (weakenArrayInstr w sh'') + (weakenArrayInstr w f'') (weaken w avar') af where @@ -1635,11 +1642,6 @@ acondD matchAcc embedAcc p t e -- Scalar expressions -- ------------------ -identity :: TypeR a -> OpenFun env aenv (a -> a) -identity t - | DeclareVars lhs _ value <- declareVars t - = Lam lhs $ Body $ expVars $ value weakenId - toIndex :: ShapeR sh -> OpenExp env aenv sh -> OpenFun env aenv (sh -> Int) toIndex shR sh | DeclareVars lhs k value <- declareVars $ shapeType shR @@ -1704,15 +1706,15 @@ restrict sliceIndex slix = Lam lhs $ Body $ IndexFull sliceIndex (weakenE k slix) $ expVars $ value weakenId arrayShape :: ArrayVar aenv (Array sh e) -> Exp aenv sh -arrayShape = simplifyExp . Shape +arrayShape var = simplifyExp $ ArrayInstr (Shape var) Nil indexArray :: ArrayVar aenv (Array sh e) -> Fun aenv (sh -> e) indexArray v@(Var (ArrayR shR _) _) | DeclareVars lhs _ value <- declareVars $ shapeType shR - = Lam lhs $ Body $ Index v $ expVars $ value weakenId + = Lam lhs $ Body $ ArrayInstr (Index v) $ expVars $ value weakenId linearIndex :: ArrayVar aenv (Array sh e) -> Fun aenv (Int -> e) -linearIndex v = Lam (LeftHandSideSingle scalarTypeInt) $ Body $ LinearIndex v $ Evar $ Var scalarTypeInt ZeroIdx +linearIndex v = Lam (LeftHandSideSingle scalarTypeInt) $ Body $ ArrayInstr (LinearIndex v) $ Evar $ Var scalarTypeInt ZeroIdx extractOpenAcc :: ExtractAcc OpenAcc diff --git a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs new file mode 100644 index 000000000..8bf99a391 --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs @@ -0,0 +1,69 @@ +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE PatternGuards #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TupleSections #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE ViewPatterns #-} +{-# OPTIONS_HADDOCK hide #-} +-- | +-- Module : Data.Array.Accelerate.Trafo.Operation.Substitution +-- Copyright : [2012..2020] The Accelerate Team +-- License : BSD3 +-- +-- Maintainer : Trevor L. McDonell +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- + +module Data.Array.Accelerate.Trafo.Operation.Substitution ( + + -- ** Renaming & Substitution + inline, inlineVars, compose, + subTop, subAtop, + + -- ** Weakening + (:>), Sink(..), SinkExp(..), weakenVars, + + -- ** Strengthening + (:?>), strengthen, strengthenE, + + -- ** Rebuilding terms + RebuildAcc, Rebuildable(..), RebuildableAcc, + RebuildableExp(..), rebuildWeakenVar, rebuildLHS, + OpenAccFun(..), OpenAccExp(..), + + -- ** Checks + isIdentity, isIdentityIndexing, extractExpVars, + bindingIsTrivial, + +) where + +import Data.Array.Accelerate.AST.Operation +import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.AST.Var +import Data.Array.Accelerate.AST.Idx +import Data.Array.Accelerate.AST.Environment +import Data.Array.Accelerate.Analysis.Match +import Data.Array.Accelerate.Error +import Data.Array.Accelerate.Representation.Type +import Data.Array.Accelerate.Representation.Array +import qualified Data.Array.Accelerate.Debug.Stats as Stats +import Data.Array.Accelerate.Trafo.Substitution (lhsFullVars, bindingIsTrivial) + +import Data.Kind +import Control.Applicative hiding ( Const ) +import Control.Monad +import Prelude hiding ( exp, seq ) + + +isIdentity :: OpenFun env aenv (a -> b) -> Maybe (a :~: b) +isIdentity (Lam lhs (Body (extractExpVars -> Just vars))) = bindingIsTrivial lhs vars +isIdentity _ = Nothing diff --git a/src/Data/Array/Accelerate/Trafo/Sharing.hs b/src/Data/Array/Accelerate/Trafo/Sharing.hs index 5d05aab18..098946705 100644 --- a/src/Data/Array/Accelerate/Trafo/Sharing.hs +++ b/src/Data/Array/Accelerate/Trafo/Sharing.hs @@ -1,5 +1,6 @@ {-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE BangPatterns #-} +{-# LANGUAGE EmptyCase #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} @@ -44,7 +45,7 @@ module Data.Array.Accelerate.Trafo.Sharing ( ) where -import Data.Array.Accelerate.AST hiding ( PreOpenAcc(..), OpenAcc(..), Acc, OpenExp(..), Exp, Boundary(..), HasArraysR(..), showPreAccOp ) +import Data.Array.Accelerate.AST hiding ( PreOpenAcc(..), OpenAcc(..), Acc, ArrayInstr(..), PreOpenExp(..), OpenExp, Exp, Boundary(..), HasArraysR(..), showPreAccOp ) import Data.Array.Accelerate.AST.Environment import Data.Array.Accelerate.AST.Idx import Data.Array.Accelerate.AST.LeftHandSide @@ -769,11 +770,11 @@ convertSharingExp config lyt alyt env aenv exp@(ScopedExp lams _) = cvt exp While tp p it i -> AST.While (cvtFun1 tp p) (cvtFun1 tp it) (cvt i) PrimConst c -> AST.PrimConst c PrimApp f e -> cvtPrimFun f (cvt e) - Index _ a e -> AST.Index (cvtAvar a) (cvt e) - LinearIndex _ a i -> AST.LinearIndex (cvtAvar a) (cvt i) - Shape _ a -> AST.Shape (cvtAvar a) + Index _ a e -> AST.ArrayInstr (AST.Index $ cvtAvar a) (cvt e) + LinearIndex _ a i -> AST.ArrayInstr (AST.LinearIndex $ cvtAvar a) (cvt i) + Shape _ a -> AST.ArrayInstr (AST.Shape $ cvtAvar a) AST.Nil ShapeSize shr e -> AST.ShapeSize shr (cvt e) - Foreign repr ff f e -> AST.Foreign repr ff (convertSmartFun config (typeR e) f) (cvt e) + Foreign repr ff f e -> AST.Foreign repr ff (cvtNoArrayInstr $ convertSmartFun config (typeR e) f) (cvt e) Coerce t1 t2 e -> AST.Coerce t1 t2 (cvt e) cvtPrj :: forall a b c env1 aenv1. PairIdx (a, b) c -> AST.OpenExp env1 aenv1 (a, b) -> AST.OpenExp env1 aenv1 c @@ -800,6 +801,14 @@ convertSharingExp config lyt alyt env aenv exp@(ScopedExp lams _) = cvt exp in Lam lhs $ Body $ convertSharingExp config lyt' alyt env' aenv body + cvtNoArrayInstr :: AST.OpenFun env' () f -> AST.PreOpenFun NoArrayInstr env' f + cvtNoArrayInstr = rebuildArrayInstr k + where + k :: AST.ArrayInstr () (s -> u) -> AST.PreOpenExp NoArrayInstr env' s -> AST.PreOpenExp NoArrayInstr env' u + k (AST.Shape (Var _ ix)) = case ix of {} + k (AST.Index (Var _ ix)) = case ix of {} + k (AST.LinearIndex (Var _ ix)) = case ix of {} + -- Push primitive function applications down through let bindings so that -- they are adjacent to their arguments. It looks a bit nicer this way. -- diff --git a/src/Data/Array/Accelerate/Trafo/Shrink.hs b/src/Data/Array/Accelerate/Trafo/Shrink.hs index 8916cc7ee..00b7baae1 100644 --- a/src/Data/Array/Accelerate/Trafo/Shrink.hs +++ b/src/Data/Array/Accelerate/Trafo/Shrink.hs @@ -49,299 +49,11 @@ import Data.Array.Accelerate.AST.Idx import Data.Array.Accelerate.AST.LeftHandSide import Data.Array.Accelerate.AST.Var import Data.Array.Accelerate.Analysis.Match -import Data.Array.Accelerate.Error -import Data.Array.Accelerate.Representation.Type -import Data.Array.Accelerate.Trafo.Substitution +import Data.Array.Accelerate.Trafo.Exp.Shrink -import qualified Data.Array.Accelerate.Debug.Stats as Stats - -import Control.Applicative hiding ( Const ) -import Data.Maybe ( isJust ) -import Data.Monoid -import Data.Semigroup import Prelude hiding ( exp, seq ) -data VarsRange env = - VarsRange !(Exists (Idx env)) -- rightmost variable - {-# UNPACK #-} !Int -- count - !(Maybe RangeTuple) -- tuple - -data RangeTuple - = RTNil - | RTSingle - | RTPair !RangeTuple !RangeTuple - -lhsVarsRange :: LeftHandSide s v env env' -> Either (env :~: env') (VarsRange env') -lhsVarsRange lhs = case rightIx lhs of - Left eq -> Left eq - Right ix -> let (n, rt) = go lhs - in Right $ VarsRange ix n rt - where - rightIx :: LeftHandSide s v env env' -> Either (env :~: env') (Exists (Idx env')) - rightIx (LeftHandSideWildcard _) = Left Refl - rightIx (LeftHandSideSingle _) = Right $ Exists ZeroIdx - rightIx (LeftHandSidePair l1 l2) = case rightIx l2 of - Right ix -> Right ix - Left Refl -> rightIx l1 - - go :: LeftHandSide s v env env' -> (Int, Maybe (RangeTuple)) - go (LeftHandSideWildcard TupRunit) = (0, Just RTNil) - go (LeftHandSideWildcard _) = (0, Nothing) - go (LeftHandSideSingle _) = (1, Just RTSingle) - go (LeftHandSidePair l1 l2) = (n1 + n2, RTPair <$> t1 <*> t2) - where - (n1, t1) = go l1 - (n2, t2) = go l2 - -weakenVarsRange :: LeftHandSide s v env env' -> VarsRange env -> VarsRange env' -weakenVarsRange lhs (VarsRange ix n t) = VarsRange (go lhs ix) n t - where - go :: LeftHandSide s v env env' -> Exists (Idx env) -> Exists (Idx env') - go (LeftHandSideWildcard _) ix' = ix' - go (LeftHandSideSingle _) (Exists ix') = Exists (SuccIdx ix') - go (LeftHandSidePair l1 l2) ix' = go l2 $ go l1 ix' - -matchEVarsRange :: VarsRange env -> OpenExp env aenv t -> Bool -matchEVarsRange (VarsRange (Exists first) _ (Just rt)) expr = isJust $ go (idxToInt first) rt expr - where - go :: Int -> RangeTuple -> OpenExp env aenv t -> Maybe Int - go i RTNil Nil = Just i - go i RTSingle (Evar (Var _ ix)) - | checkIdx i ix = Just (i + 1) - go i (RTPair t1 t2) (Pair e1 e2) - | Just i' <- go i t2 e2 = go i' t1 e1 - go _ _ _ = Nothing - - checkIdx :: Int -> Idx env t -> Bool - checkIdx 0 ZeroIdx = True - checkIdx i (SuccIdx ix) = checkIdx (i - 1) ix - checkIdx _ _ = False -matchEVarsRange _ _ = False - -varInRange :: VarsRange env -> Var s env t -> Maybe Usages -varInRange (VarsRange (Exists rangeIx) n _) (Var _ varIx) = case go rangeIx varIx of - Nothing -> Nothing - Just j -> Just $ replicate j False ++ [True] ++ replicate (n - j - 1) False - where - -- `go ix ix'` checks whether ix <= ix' with recursion, and then checks - -- whether ix' < ix + n in go'. Returns a Just if both checks - -- are successful, containing an integer j such that ix + j = ix'. - go :: Idx env u -> Idx env t -> Maybe Int - go (SuccIdx ix) (SuccIdx ix') = go ix ix' - go ZeroIdx ix' = go' ix' 0 - go _ ZeroIdx = Nothing - - go' :: Idx env t -> Int -> Maybe Int - go' _ j | j >= n = Nothing - go' ZeroIdx j = Just j - go' (SuccIdx ix') j = go' ix' (j + 1) - --- Describes how often the variables defined in a LHS are used together. -data Count - = Impossible !Usages - -- Cannot inline this definition. This happens when the definition - -- declares multiple variables (the right hand side returns a tuple) - -- and the variables are used seperately. - | Infinity - -- The variable is used in a loop. Inlining should only proceed if - -- the computation is cheap. - | Finite {-# UNPACK #-} !Int - -type Usages = [Bool] -- Per variable a Boolean denoting whether that variable is used. - -instance Semigroup Count where - Impossible u1 <> Impossible u2 = Impossible $ zipWith (||) u1 u2 - Impossible u <> Finite 0 = Impossible u - Finite 0 <> Impossible u = Impossible u - Impossible u <> _ = Impossible $ map (const True) u - _ <> Impossible u = Impossible $ map (const True) u - Infinity <> _ = Infinity - _ <> Infinity = Infinity - Finite a <> Finite b = Finite $ a + b - -instance Monoid Count where - mempty = Finite 0 - -loopCount :: Count -> Count -loopCount (Finite n) | n > 0 = Infinity -loopCount c = c - -shrinkLhs - :: HasCallStack - => Count - -> LeftHandSide s t env1 env2 - -> Maybe (Exists (LeftHandSide s t env1)) -shrinkLhs _ (LeftHandSideWildcard _) = Nothing -- We cannot shrink this -shrinkLhs (Finite 0) lhs = Just $ Exists $ LeftHandSideWildcard $ lhsToTupR lhs -- LHS isn't used at all, replace with a wildcard -shrinkLhs (Impossible usages) lhs = case go usages lhs of - (True , [], lhs') -> Just lhs' - (False, [], _ ) -> Nothing -- No variables were dropped. Thus lhs == lhs'. - _ -> internalError "Mismatch in length of usages array and LHS" - where - go :: HasCallStack => Usages -> LeftHandSide s t env1 env2 -> (Bool, Usages, Exists (LeftHandSide s t env1)) - go us (LeftHandSideWildcard tp) = (False, us, Exists $ LeftHandSideWildcard tp) - go (True : us) (LeftHandSideSingle tp) = (False, us, Exists $ LeftHandSideSingle tp) - go (False : us) (LeftHandSideSingle tp) = (True , us, Exists $ LeftHandSideWildcard $ TupRsingle tp) - go us (LeftHandSidePair l1 l2) - | (c2, us' , Exists l2') <- go us l2 - , (c1, us'', Exists l1') <- go us' l1 - , Exists l2'' <- rebuildLHS l2' - = let - lhs' - | LeftHandSideWildcard t1 <- l1' - , LeftHandSideWildcard t2 <- l2'' = LeftHandSideWildcard $ TupRpair t1 t2 - | otherwise = LeftHandSidePair l1' l2'' - in - (c1 || c2, us'', Exists lhs') - go _ _ = internalError "Empty array, mismatch in length of usages array and LHS" -shrinkLhs _ _ = Nothing - --- The first LHS should be 'larger' than the second, eg the second may have --- a wildcard if the first LHS does bind variables there, but not the other --- way around. --- -strengthenShrunkLHS - :: HasCallStack - => LeftHandSide s t env1 env2 - -> LeftHandSide s t env1' env2' - -> env1 :?> env1' - -> env2 :?> env2' -strengthenShrunkLHS (LeftHandSideWildcard _) (LeftHandSideWildcard _) k = k -strengthenShrunkLHS (LeftHandSideSingle _) (LeftHandSideSingle _) k = \ix -> case ix of - ZeroIdx -> Just ZeroIdx - SuccIdx ix' -> SuccIdx <$> k ix' -strengthenShrunkLHS (LeftHandSidePair lA hA) (LeftHandSidePair lB hB) k = strengthenShrunkLHS hA hB $ strengthenShrunkLHS lA lB k -strengthenShrunkLHS (LeftHandSideSingle _) (LeftHandSideWildcard _) k = \ix -> case ix of - ZeroIdx -> Nothing - SuccIdx ix' -> k ix' -strengthenShrunkLHS (LeftHandSidePair l h) (LeftHandSideWildcard t) k = strengthenShrunkLHS h (LeftHandSideWildcard t2) $ strengthenShrunkLHS l (LeftHandSideWildcard t1) k - where - TupRpair t1 t2 = t -strengthenShrunkLHS (LeftHandSideWildcard _) _ _ = internalError "Second LHS defines more variables" -strengthenShrunkLHS _ _ _ = internalError "Mismatch LHS single with LHS pair" - - --- Shrinking --- ========= - --- The shrinking substitution for scalar expressions. This is a restricted --- instance of beta-reduction to cases where the bound variable is used zero --- (dead-code elimination) or one (linear inlining) times. --- -shrinkExp :: HasCallStack => OpenExp env aenv t -> (Bool, OpenExp env aenv t) -shrinkExp = Stats.substitution "shrinkE" . first getAny . shrinkE - where - -- If the bound variable is used at most this many times, it will be inlined - -- into the body. In cases where it is not used at all, this is equivalent - -- to dead-code elimination. - -- - lIMIT :: Int - lIMIT = 1 - - cheap :: OpenExp env aenv t -> Bool - cheap (Evar _) = True - cheap (Pair e1 e2) = cheap e1 && cheap e2 - cheap Nil = True - cheap Const{} = True - cheap PrimConst{} = True - cheap Undef{} = True - cheap (Coerce _ _ e) = cheap e - cheap _ = False - - shrinkE :: HasCallStack => OpenExp env aenv t -> (Any, OpenExp env aenv t) - shrinkE exp = case exp of - Let (LeftHandSideSingle _) bnd@Evar{} body -> Stats.inline "Var" . yes $ shrinkE (inline body bnd) - Let lhs bnd body - | shouldInline -> case inlineVars lhs (snd body') (snd bnd') of - Just inlined -> Stats.betaReduce msg . yes $ shrinkE inlined - _ -> internalError "Unexpected failure while trying to inline some expression." - | Just (Exists lhs') <- shrinkLhs count lhs -> case strengthenE (strengthenShrunkLHS lhs lhs' Just) (snd body') of - Just body'' -> (Any True, Let lhs' (snd bnd') body'') - Nothing -> internalError "Unexpected failure in strenthenE. Variable was analysed to be unused in usesOfExp, but appeared to be used in strenthenE." - | otherwise -> Let lhs <$> bnd' <*> body' - where - shouldInline = case count of - Finite 0 -> False -- Handled by shrinkLhs - Finite n -> n <= lIMIT || cheap (snd bnd') - Infinity -> cheap (snd bnd') - Impossible _ -> False - - bnd' = shrinkE bnd - body' = shrinkE body - - -- If the lhs includes non-trivial wildcards (the last field of range is Nothing), - -- then we cannot inline the binding. We can only check which variables are not used, - -- to detect unused variables. - -- - -- If the lhs does not include non-trivial wildcards (the last field of range is a Just), - -- we can both analyse whether we can inline the binding, and check which variables are - -- not used, to detect unused variables. - -- - count = case lhsVarsRange lhs of - Left _ -> Finite 0 - Right range -> usesOfExp range (snd body') - - msg = case count of - Finite 0 -> "dead exp" - _ -> "inline exp" -- forced inlining when lIMIT > 1 - -- - Evar v -> pure (Evar v) - Const t c -> pure (Const t c) - Undef t -> pure (Undef t) - Nil -> pure Nil - Pair x y -> Pair <$> shrinkE x <*> shrinkE y - VecPack vec e -> VecPack vec <$> shrinkE e - VecUnpack vec e -> VecUnpack vec <$> shrinkE e - IndexSlice x ix sh -> IndexSlice x <$> shrinkE ix <*> shrinkE sh - IndexFull x ix sl -> IndexFull x <$> shrinkE ix <*> shrinkE sl - ToIndex shr sh ix -> ToIndex shr <$> shrinkE sh <*> shrinkE ix - FromIndex shr sh i -> FromIndex shr <$> shrinkE sh <*> shrinkE i - Case e rhs def -> Case <$> shrinkE e <*> sequenceA [ (t,) <$> shrinkE c | (t,c) <- rhs ] <*> shrinkMaybeE def - Cond p t e -> Cond <$> shrinkE p <*> shrinkE t <*> shrinkE e - While p f x -> While <$> shrinkF p <*> shrinkF f <*> shrinkE x - PrimConst c -> pure (PrimConst c) - PrimApp f x -> PrimApp f <$> shrinkE x - Index a sh -> Index a <$> shrinkE sh - LinearIndex a i -> LinearIndex a <$> shrinkE i - Shape a -> pure (Shape a) - ShapeSize shr sh -> ShapeSize shr <$> shrinkE sh - Foreign repr ff f e -> Foreign repr ff <$> shrinkF f <*> shrinkE e - Coerce t1 t2 e -> Coerce t1 t2 <$> shrinkE e - - shrinkF :: HasCallStack => OpenFun env aenv t -> (Any, OpenFun env aenv t) - shrinkF = first Any . shrinkFun - - shrinkMaybeE :: HasCallStack => Maybe (OpenExp env aenv t) -> (Any, Maybe (OpenExp env aenv t)) - shrinkMaybeE Nothing = pure Nothing - shrinkMaybeE (Just e) = Just <$> shrinkE e - - first :: (a -> a') -> (a,b) -> (a',b) - first f (x,y) = (f x, y) - - yes :: (Any, x) -> (Any, x) - yes (_, x) = (Any True, x) - -shrinkFun :: HasCallStack => OpenFun env aenv f -> (Bool, OpenFun env aenv f) -shrinkFun (Lam lhs f) = case lhsVarsRange lhs of - Left Refl -> - let b' = case lhs of - LeftHandSideWildcard TupRunit -> b - _ -> True - in (b', Lam (LeftHandSideWildcard $ lhsToTupR lhs) f') - Right range -> - let - count = usesOfFun range f - in case shrinkLhs count lhs of - Just (Exists lhs') -> case strengthenE (strengthenShrunkLHS lhs lhs' Just) f' of - Just f'' -> (True, Lam lhs' f'') - Nothing -> internalError "Unexpected failure in strenthenE. Variable was analysed to be unused in usesOfExp, but appeared to be used in strenthenE." - Nothing -> (b, Lam lhs f') - where - (b, f') = shrinkFun f - -shrinkFun (Body b) = Body <$> shrinkExp b - -- The shrinking substitution for array computations. This is further limited to -- dead-code elimination only, primarily because linear inlining may inline -- array computations into scalar expressions, which is generally not desirable. @@ -474,46 +186,6 @@ shrinkPreAcc shrinkAcc reduceAcc = Stats.substitution "shrinkA" shrinkA -- Occurrence Counting -- =================== --- Count the number of occurrences an in-scope scalar expression bound at the --- given variable index recursively in a term. --- -usesOfExp :: forall env aenv t. VarsRange env -> OpenExp env aenv t -> Count -usesOfExp range = countE - where - countE :: OpenExp env aenv e -> Count - countE exp | matchEVarsRange range exp = Finite 1 - countE exp = case exp of - Evar v -> case varInRange range v of - Just cs -> Impossible cs - Nothing -> Finite 0 - -- - Let lhs bnd body -> countE bnd <> usesOfExp (weakenVarsRange lhs range) body - Const _ _ -> Finite 0 - Undef _ -> Finite 0 - Nil -> Finite 0 - Pair e1 e2 -> countE e1 <> countE e2 - VecPack _ e -> countE e - VecUnpack _ e -> countE e - IndexSlice _ ix sh -> countE ix <> countE sh - IndexFull _ ix sl -> countE ix <> countE sl - FromIndex _ sh i -> countE sh <> countE i - ToIndex _ sh e -> countE sh <> countE e - Case e rhs def -> countE e <> mconcat [ countE c | (_,c) <- rhs ] <> maybe (Finite 0) countE def - Cond p t e -> countE p <> countE t <> countE e - While p f x -> countE x <> loopCount (usesOfFun range p) <> loopCount (usesOfFun range f) - PrimConst _ -> Finite 0 - PrimApp _ x -> countE x - Index _ sh -> countE sh - LinearIndex _ i -> countE i - Shape _ -> Finite 0 - ShapeSize _ sh -> countE sh - Foreign _ _ _ e -> countE e - Coerce _ _ e -> countE e - -usesOfFun :: VarsRange env -> OpenFun env aenv f -> Count -usesOfFun range (Lam lhs f) = usesOfFun (weakenVarsRange lhs range) f -usesOfFun range (Body b) = usesOfExp range b - -- Count the number of occurrences of the array term bound at the given -- environment index. If the first argument is 'True' then it includes in the -- total uses of the variable for 'Shape' information, otherwise not. @@ -571,32 +243,7 @@ usesOfPreAcc withShape countAcc idx = count -- Collect s -> countS s countE :: OpenExp env aenv e -> Int - countE exp = case exp of - Let _ bnd body -> countE bnd + countE body - Evar _ -> 0 - Const _ _ -> 0 - Undef _ -> 0 - Nil -> 0 - Pair x y -> countE x + countE y - VecPack _ e -> countE e - VecUnpack _ e -> countE e - IndexSlice _ ix sh -> countE ix + countE sh - IndexFull _ ix sl -> countE ix + countE sl - ToIndex _ sh ix -> countE sh + countE ix - FromIndex _ sh i -> countE sh + countE i - Case e rhs def -> countE e + sum [ countE c | (_,c) <- rhs ] + maybe 0 countE def - Cond p t e -> countE p + countE t + countE e - While p f x -> countF p + countF f + countE x - PrimConst _ -> 0 - PrimApp _ x -> countE x - Index a sh -> countAvar a + countE sh - LinearIndex a i -> countAvar a + countE i - ShapeSize _ sh -> countE sh - Shape a - | withShape -> countAvar a - | otherwise -> 0 - Foreign _ _ _ e -> countE e - Coerce _ _ e -> countE e + countE = sum . map countArrayInstr . arrayInstrsInExp countME :: Maybe (OpenExp env aenv e) -> Int countME = maybe 0 countE @@ -613,9 +260,13 @@ usesOfPreAcc withShape countAcc idx = count countAF (Alam lhs f) v = countAF f (weakenWithLHS lhs >:> v) countAF (Abody a) v = countAcc withShape v a - countF :: OpenFun env aenv f -> Int - countF (Lam _ f) = countF f - countF (Body b) = countE b + countArrayInstr :: Exists (ArrayInstr aenv) -> Int + countArrayInstr (Exists (Shape var)) = countAvar var + countArrayInstr (Exists (Index var)) = countAvar var + countArrayInstr (Exists (LinearIndex var)) = countAvar var + + countF :: OpenFun env aenv e -> Int + countF = sum . map countArrayInstr . arrayInstrsInFun {-- countS :: PreOpenSeq acc aenv senv arrs -> Int diff --git a/src/Data/Array/Accelerate/Trafo/Substitution.hs b/src/Data/Array/Accelerate/Trafo/Substitution.hs index 7f39593ff..19a082b57 100644 --- a/src/Data/Array/Accelerate/Trafo/Substitution.hs +++ b/src/Data/Array/Accelerate/Trafo/Substitution.hs @@ -27,10 +27,10 @@ module Data.Array.Accelerate.Trafo.Substitution ( -- ** Renaming & Substitution inline, inlineVars, compose, - subTop, subAtop, + subTop, subAtop, apply1, -- ** Weakening - (:>), Sink(..), SinkExp(..), weakenVars, + (:>), Sink(..), SinkExp(..), weakenVars, weakenArrayInstr, -- ** Strengthening (:?>), strengthen, strengthenE, @@ -53,8 +53,8 @@ import Data.Array.Accelerate.AST.Idx import Data.Array.Accelerate.AST.Environment import Data.Array.Accelerate.Analysis.Match import Data.Array.Accelerate.Error -import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Representation.Array +import Data.Array.Accelerate.Trafo.Exp.Substitution import qualified Data.Array.Accelerate.Debug.Stats as Stats import Data.Kind @@ -87,178 +87,20 @@ import Prelude hiding ( exp, seq ) -- able to rebuildPartial terms. In essence, the crucial functionality is to propagate -- a class of operations on variables that is closed under shifting. -- -infixr `compose` --- infixr `substitute` - -lhsFullVars :: forall s a env1 env2. LeftHandSide s a env1 env2 -> Maybe (Vars s env2 a) -lhsFullVars = fmap snd . go weakenId - where - go :: forall env env' b. (env' :> env2) -> LeftHandSide s b env env' -> Maybe (env :> env2, Vars s env2 b) - go k (LeftHandSideWildcard TupRunit) = Just (k, TupRunit) - go k (LeftHandSideSingle s) = Just $ (weakenSucc $ k, TupRsingle $ Var s $ k >:> ZeroIdx) - go k (LeftHandSidePair l1 l2) - | Just (k', v2) <- go k l2 - , Just (k'', v1) <- go k' l1 = Just (k'', TupRpair v1 v2) - go _ _ = Nothing - -bindingIsTrivial :: LeftHandSide s a env1 env2 -> Vars s env2 b -> Maybe (a :~: b) -bindingIsTrivial lhs vars - | Just lhsVars <- lhsFullVars lhs - , Just Refl <- matchVars vars lhsVars - = Just Refl -bindingIsTrivial _ _ = Nothing - -isIdentity :: OpenFun env aenv (a -> b) -> Maybe (a :~: b) -isIdentity (Lam lhs (Body (extractExpVars -> Just vars))) = bindingIsTrivial lhs vars -isIdentity _ = Nothing -- Detects whether the function is of the form \ix -> a ! ix isIdentityIndexing :: OpenFun env aenv (a -> b) -> Maybe (ArrayVar aenv (Array a b)) isIdentityIndexing (Lam lhs (Body body)) - | Index avar ix <- body + | ArrayInstr (Index avar) ix <- body , Just vars <- extractExpVars ix , Just Refl <- bindingIsTrivial lhs vars = Just avar isIdentityIndexing _ = Nothing --- | Replace the first variable with the given expression. The environment --- shrinks. --- -inline :: OpenExp (env, s) aenv t - -> OpenExp env aenv s - -> OpenExp env aenv t -inline f g = Stats.substitution "inline" $ rebuildE (subTop g) f - -inlineVars :: forall env env' aenv t1 t2. - ELeftHandSide t1 env env' - -> OpenExp env' aenv t2 - -> OpenExp env aenv t1 - -> Maybe (OpenExp env aenv t2) -inlineVars lhsBound expr bound - | Just vars <- lhsFullVars lhsBound = substitute (strengthenWithLHS lhsBound) weakenId vars expr - where - substitute - :: forall env1 env2 t. - env1 :?> env2 - -> env :> env2 - -> ExpVars env1 t1 - -> OpenExp env1 aenv t - -> Maybe (OpenExp env2 aenv t) - substitute _ k2 vars (extractExpVars -> Just vars') - | Just Refl <- matchVars vars vars' = Just $ weakenE k2 bound - substitute k1 k2 vars topExp = case topExp of - Let lhs e1 e2 - | Exists lhs' <- rebuildLHS lhs - -> Let lhs' <$> travE e1 <*> substitute (strengthenAfter lhs lhs' k1) (weakenWithLHS lhs' .> k2) (weakenWithLHS lhs `weakenVars` vars) e2 - Evar (Var t ix) -> Evar . Var t <$> k1 ix - Foreign tp asm f e1 -> Foreign tp asm f <$> travE e1 - Pair e1 e2 -> Pair <$> travE e1 <*> travE e2 - Nil -> Just Nil - VecPack vec e1 -> VecPack vec <$> travE e1 - VecUnpack vec e1 -> VecUnpack vec <$> travE e1 - IndexSlice si e1 e2 -> IndexSlice si <$> travE e1 <*> travE e2 - IndexFull si e1 e2 -> IndexFull si <$> travE e1 <*> travE e2 - ToIndex shr e1 e2 -> ToIndex shr <$> travE e1 <*> travE e2 - FromIndex shr e1 e2 -> FromIndex shr <$> travE e1 <*> travE e2 - Case e1 rhs def -> Case <$> travE e1 <*> mapM (\(t,c) -> (t,) <$> travE c) rhs <*> travMaybeE def - Cond e1 e2 e3 -> Cond <$> travE e1 <*> travE e2 <*> travE e3 - While f1 f2 e1 -> While <$> travF f1 <*> travF f2 <*> travE e1 - Const t c -> Just $ Const t c - PrimConst c -> Just $ PrimConst c - PrimApp p e1 -> PrimApp p <$> travE e1 - Index a e1 -> Index a <$> travE e1 - LinearIndex a e1 -> LinearIndex a <$> travE e1 - Shape a -> Just $ Shape a - ShapeSize shr e1 -> ShapeSize shr <$> travE e1 - Undef t -> Just $ Undef t - Coerce t1 t2 e1 -> Coerce t1 t2 <$> travE e1 - - where - travE :: OpenExp env1 aenv s -> Maybe (OpenExp env2 aenv s) - travE = substitute k1 k2 vars - - travF :: OpenFun env1 aenv s -> Maybe (OpenFun env2 aenv s) - travF = substituteF k1 k2 vars - - travMaybeE :: Maybe (OpenExp env1 aenv s) -> Maybe (Maybe (OpenExp env2 aenv s)) - travMaybeE Nothing = pure Nothing - travMaybeE (Just x) = Just <$> travE x - - substituteF :: forall env1 env2 t. - env1 :?> env2 - -> env :> env2 - -> ExpVars env1 t1 - -> OpenFun env1 aenv t - -> Maybe (OpenFun env2 aenv t) - substituteF k1 k2 vars (Body e) = Body <$> substitute k1 k2 vars e - substituteF k1 k2 vars (Lam lhs f) - | Exists lhs' <- rebuildLHS lhs = Lam lhs' <$> substituteF (strengthenAfter lhs lhs' k1) (weakenWithLHS lhs' .> k2) (weakenWithLHS lhs `weakenVars` vars) f - -inlineVars _ _ _ = Nothing - - --- | Replace an expression that uses the top environment variable with another. --- The result of the first is let bound into the second. --- -{- substitute' :: OpenExp (env, b) aenv c - -> OpenExp (env, a) aenv b - -> OpenExp (env, a) aenv c -substitute' f g - | Stats.substitution "substitute" False = undefined - | isIdentity f = g -- don't rebind an identity function - | isIdentity g = f - | otherwise = Let g $ rebuildE split f - where - split :: Idx (env,b) c -> OpenExp ((env,a),b) aenv c - split ZeroIdx = Var ZeroIdx - split (SuccIdx ix) = Var (SuccIdx (SuccIdx ix)) - -substitute :: LeftHandSide b env envb - -> OpenExp envb c - -> LeftHandSide a env enva - -> OpenExp enva b --} - --- | Composition of unary functions. --- -compose :: HasCallStack - => OpenFun env aenv (b -> c) - -> OpenFun env aenv (a -> b) - -> OpenFun env aenv (a -> c) -compose f@(Lam lhsB (Body c)) g@(Lam lhsA (Body b)) - | Stats.substitution "compose" False = undefined - | Just Refl <- isIdentity f = g -- don't rebind an identity function - | Just Refl <- isIdentity g = f - - | Exists lhsB' <- rebuildLHS lhsB - = Lam lhsA - $ Body - $ Let lhsB' b - $ weakenE (sinkWithLHS lhsB lhsB' $ weakenWithLHS lhsA) c - -- = Stats.substitution "compose" . Lam lhs2 . Body $ substitute' f g -compose _ - _ = error "compose: impossible evaluation" - -subTop :: OpenExp env aenv s -> ExpVar (env, s) t -> OpenExp env aenv t -subTop s (Var _ ZeroIdx ) = s -subTop _ (Var tp (SuccIdx ix)) = Evar $ Var tp ix - subAtop :: PreOpenAcc acc aenv t -> ArrayVar (aenv, t) (Array sh2 e2) -> PreOpenAcc acc aenv (Array sh2 e2) subAtop t (Var _ ZeroIdx ) = t subAtop _ (Var repr (SuccIdx idx)) = Avar $ Var repr idx -data Identity a = Identity { runIdentity :: a } - -instance Functor Identity where - {-# INLINE fmap #-} - fmap f (Identity a) = Identity (f a) - -instance Applicative Identity where - {-# INLINE (<*>) #-} - {-# INLINE pure #-} - Identity f <*> Identity a = Identity (f a) - pure a = Identity a - -- A class for rebuilding terms. -- class Rebuildable f where @@ -277,22 +119,6 @@ class Rebuildable f where -> f aenv' a rebuildA av = runIdentity . rebuildPartial (Identity . av) --- A class for rebuilding scalar terms. --- -class RebuildableExp f where - {-# MINIMAL rebuildPartialE #-} - rebuildPartialE :: (Applicative f', SyntacticExp fe) - => (forall e'. ExpVar env e' -> f' (fe env' aenv e')) - -> f env aenv e - -> f' (f env' aenv e) - - {-# INLINEABLE rebuildE #-} - rebuildE :: SyntacticExp fe - => (forall e'. ExpVar env e' -> fe env' aenv e') - -> f env aenv e - -> f env' aenv e - rebuildE v = runIdentity . rebuildPartialE (Identity . v) - -- Terms that are rebuildable and also recursive closures -- type RebuildableAcc acc = (Rebuildable acc, AccClo acc ~ acc) @@ -310,12 +136,12 @@ data OpenAccFun (acc :: Type -> Type -> Type) env aenv a where instance Rebuildable (OpenAccExp acc env) where type AccClo (OpenAccExp acc env) = acc {-# INLINEABLE rebuildPartial #-} - rebuildPartial v (OpenAccExp e) = OpenAccExp <$> Stats.substitution "rebuild" (rebuildOpenExp (pure . IE) (reindexAvar v) e) + rebuildPartial v (OpenAccExp e) = OpenAccExp <$> Stats.substitution "rebuild" (rebuildArrayInstrPartial (reindexArrayInstr v) e) instance Rebuildable (OpenAccFun acc env) where type AccClo (OpenAccFun acc env) = acc {-# INLINEABLE rebuildPartial #-} - rebuildPartial v (OpenAccFun f) = OpenAccFun <$> Stats.substitution "rebuild" (rebuildFun (pure . IE) (reindexAvar v) f) + rebuildPartial v (OpenAccFun f) = OpenAccFun <$> Stats.substitution "rebuild" (rebuildArrayInstrPartial (reindexArrayInstr v) f) instance RebuildableAcc acc => Rebuildable (PreOpenAcc acc) where type AccClo (PreOpenAcc acc) = acc @@ -332,27 +158,8 @@ instance Rebuildable OpenAcc where {-# INLINEABLE rebuildPartial #-} rebuildPartial x = Stats.substitution "rebuild" $ rebuildOpenAcc x -instance RebuildableExp OpenExp where - {-# INLINEABLE rebuildPartialE #-} - rebuildPartialE v x = Stats.substitution "rebuild" $ rebuildOpenExp v (ReindexAvar pure) x - -instance RebuildableExp OpenFun where - {-# INLINEABLE rebuildPartialE #-} - rebuildPartialE v x = Stats.substitution "rebuild" $ rebuildFun v (ReindexAvar pure) x - --- NOTE: [Weakening] --- --- Weakening is something we usually take for granted: every time you learn a --- new word, old sentences still make sense. If a conclusion is justified by a --- hypothesis, it is still justified if you add more hypotheses. Similarly, a --- term remains in scope if you bind more (fresh) variables. Weakening is the --- operation of shifting things from one scope to a larger scope in which new --- things have become meaningful, but no old things have vanished. --- --- When we use a named representation (or HOAS) we get weakening for free. But --- in the de Bruijn representation weakening takes work: you have to shift all --- variable references to make room for the new bindings. --- +-- | Weakening +-- SEE: [Weakening] class Sink f where weaken :: env :> env' -> f env t -> f env' t @@ -375,17 +182,9 @@ instance Sink (Var s) where {-# INLINEABLE weaken #-} weaken k (Var s ix) = Var s (k >:> ix) -weakenVars :: env :> env' -> Vars s env t -> Vars s env' t -weakenVars _ TupRunit = TupRunit -weakenVars k (TupRsingle v) = TupRsingle $ weaken k v -weakenVars k (TupRpair v w) = TupRpair (weakenVars k v) (weakenVars k w) - rebuildWeakenVar :: env :> env' -> ArrayVar env (Array sh e) -> PreOpenAcc acc env' (Array sh e) rebuildWeakenVar k (Var s idx) = Avar $ Var s $ k >:> idx -rebuildWeakenEvar :: env :> env' -> ExpVar env t -> OpenExp env' aenv t -rebuildWeakenEvar k (Var s idx) = Evar $ Var s $ k >:> idx - instance RebuildableAcc acc => Sink (PreOpenAcc acc) where {-# INLINEABLE weaken #-} weaken k = Stats.substitution "weaken" . rebuildA (rebuildWeakenVar k) @@ -394,13 +193,27 @@ instance RebuildableAcc acc => Sink (PreOpenAfun acc) where {-# INLINEABLE weaken #-} weaken k = Stats.substitution "weaken" . rebuildA (rebuildWeakenVar k) -instance Sink (OpenExp env) where +-- We cannot use 'weaken' to weaken the array environment of an 'OpenExp', +-- as OpenExp is a type synonym for 'PreOpenExp (ArrayInstr aenv) env', +-- and 'weaken' would thus affect the expression environment. Hence we +-- have a separate function for OpenExp and OpenFun. +-- +weakenArrayInstr :: RebuildableExp f => aenv :> aenv' -> f (ArrayInstr aenv) env t -> f (ArrayInstr aenv') env t +weakenArrayInstr k = Stats.substitution "weaken" . rebuildArrayInstr (ArrayInstr . weaken k) + +{- instance Sink (OpenExp env) where {-# INLINEABLE weaken #-} weaken k = Stats.substitution "weaken" . runIdentity . rebuildOpenExp (Identity . Evar) (ReindexAvar (Identity . weaken k)) instance Sink (OpenFun env) where {-# INLINEABLE weaken #-} weaken k = Stats.substitution "weaken" . runIdentity . rebuildFun (Identity . Evar) (ReindexAvar (Identity . weaken k)) +-} + +instance Sink ArrayInstr where + weaken k (Index var) = Index $ weaken k var + weaken k (LinearIndex var) = LinearIndex $ weaken k var + weaken k (Shape var) = Shape $ weaken k var instance Sink Boundary where {-# INLINEABLE weaken #-} @@ -410,7 +223,7 @@ instance Sink Boundary where Mirror -> Mirror Wrap -> Wrap Constant c -> Constant c - Function f -> Function (weaken k f) + Function f -> Function (weakenArrayInstr k f) instance Sink OpenAcc where {-# INLINEABLE weaken #-} @@ -423,171 +236,16 @@ instance Sink OpenAcc where -- weaken v1 (weaken v2 a) = weaken (v1 . v2) a -- #-} -class SinkExp f where - weakenE :: env :> env' -> f env aenv t -> f env' aenv t - - -- See comment in 'weaken' - -- - -- {-# INLINEABLE weakenE #-} - -- default weakenE :: RebuildableExp f => env :> env' -> f env aenv t -> f env' aenv t - -- weakenE v = Stats.substitution "weakenE" . rebuildE (IE . v) - -instance SinkExp OpenExp where - {-# INLINEABLE weakenE #-} - weakenE v = Stats.substitution "weakenE" . rebuildE (rebuildWeakenEvar v) -instance SinkExp OpenFun where - {-# INLINEABLE weakenE #-} - weakenE v = Stats.substitution "weakenE" . rebuildE (rebuildWeakenEvar v) - --- See above for why this is disabled. --- {-# RULES --- "weakenE/weakenE" forall a (v1 :: env' :> env'') (v2 :: env :> env'). --- weakenE v1 (weakenE v2 a) = weakenE (v1 . v2) a --- #-} - --- NOTE: [Strengthening] +-- SEE: [Strengthening] -- --- Strengthening is the dual of weakening. Shifting terms from one scope to a --- smaller scope. Of course this is not always possible. If the term contains --- any variables not in the new environment, then it cannot be strengthened. --- This partial behaviour is captured with 'Maybe'. --- - --- The type of partially shifting terms from one context into another. -type env :?> env' = forall t'. Idx env t' -> Maybe (Idx env' t') {-# INLINEABLE strengthen #-} strengthen :: forall f env env' t. Rebuildable f => env :?> env' -> f env t -> Maybe (f env' t) strengthen k x = Stats.substitution "strengthen" $ rebuildPartial @f @Maybe @IdxA (\(Var s ix) -> fmap (IA . Var s) $ k ix) x -{-# INLINEABLE strengthenE #-} -strengthenE :: forall f env env' aenv t. RebuildableExp f => env :?> env' -> f env aenv t -> Maybe (f env' aenv t) -strengthenE k x = Stats.substitution "strengthenE" $ rebuildPartialE @f @Maybe @IdxE (\(Var tp ix) -> fmap (IE . Var tp) $ k ix) x - -strengthenWithLHS :: LeftHandSide s t env1 env2 -> env2 :?> env1 -strengthenWithLHS (LeftHandSideWildcard _) = Just -strengthenWithLHS (LeftHandSideSingle _) = \ix -> case ix of - ZeroIdx -> Nothing - SuccIdx i -> Just i -strengthenWithLHS (LeftHandSidePair l1 l2) = strengthenWithLHS l2 >=> strengthenWithLHS l1 - -strengthenAfter :: LeftHandSide s t env1 env2 -> LeftHandSide s t env1' env2' -> env1 :?> env1' -> env2 :?> env2' -strengthenAfter (LeftHandSideWildcard _) (LeftHandSideWildcard _) k = k -strengthenAfter (LeftHandSideSingle _) (LeftHandSideSingle _) k = \ix -> case ix of - ZeroIdx -> Just ZeroIdx - SuccIdx i -> SuccIdx <$> k i -strengthenAfter (LeftHandSidePair l1 l2) (LeftHandSidePair l1' l2') k = - strengthenAfter l2 l2' $ strengthenAfter l1 l1' k -strengthenAfter _ _ _ = error "Substitution.strengthenAfter: left hand sides do not match" - --- Simultaneous Substitution =================================================== --- - --- The scalar environment --- ------------------ - --- SEE: [Renaming and Substitution] --- SEE: [Weakening] --- -class SyntacticExp f where - varIn :: ExpVar env t -> f env aenv t - expOut :: f env aenv t -> OpenExp env aenv t - weakenExp :: f env aenv t -> f (env, s) aenv t - -newtype IdxE env aenv t = IE { unIE :: ExpVar env t } - -instance SyntacticExp IdxE where - varIn = IE - expOut = Evar . unIE - weakenExp (IE (Var tp ix)) = IE $ Var tp $ SuccIdx ix - -instance SyntacticExp OpenExp where - varIn = Evar - expOut = id - weakenExp = runIdentity . rebuildOpenExp (Identity . weakenExp . IE) (ReindexAvar Identity) - -{-# INLINEABLE shiftE #-} -shiftE - :: (Applicative f, SyntacticExp fe) - => RebuildEvar f fe env env' aenv - -> RebuildEvar f fe (env, s) (env', s) aenv -shiftE _ (Var tp ZeroIdx) = pure $ varIn (Var tp ZeroIdx) -shiftE v (Var tp (SuccIdx ix)) = weakenExp <$> v (Var tp ix) - -{-# INLINEABLE shiftE' #-} -shiftE' - :: (Applicative f, SyntacticExp fa) - => ELeftHandSide t env1 env1' - -> ELeftHandSide t env2 env2' - -> RebuildEvar f fa env1 env2 aenv - -> RebuildEvar f fa env1' env2' aenv -shiftE' (LeftHandSideWildcard _) (LeftHandSideWildcard _) v = v -shiftE' (LeftHandSideSingle _) (LeftHandSideSingle _) v = shiftE v -shiftE' (LeftHandSidePair a1 b1) (LeftHandSidePair a2 b2) v = shiftE' b1 b2 $ shiftE' a1 a2 v -shiftE' _ _ _ = error "Substitution: left hand sides do not match" - -{-# INLINEABLE rebuildMaybeExp #-} -rebuildMaybeExp - :: (HasCallStack, Applicative f, SyntacticExp fe) - => RebuildEvar f fe env env' aenv' - -> ReindexAvar f aenv aenv' - -> Maybe (OpenExp env aenv t) - -> f (Maybe (OpenExp env' aenv' t)) -rebuildMaybeExp _ _ Nothing = pure Nothing -rebuildMaybeExp v av (Just x) = Just <$> rebuildOpenExp v av x - -{-# INLINEABLE rebuildOpenExp #-} -rebuildOpenExp - :: (HasCallStack, Applicative f, SyntacticExp fe) - => RebuildEvar f fe env env' aenv' - -> ReindexAvar f aenv aenv' - -> OpenExp env aenv t - -> f (OpenExp env' aenv' t) -rebuildOpenExp v av@(ReindexAvar reindex) exp = - case exp of - Const t c -> pure $ Const t c - PrimConst c -> pure $ PrimConst c - Undef t -> pure $ Undef t - Evar var -> expOut <$> v var - Let lhs a b - | Exists lhs' <- rebuildLHS lhs - -> Let lhs' <$> rebuildOpenExp v av a <*> rebuildOpenExp (shiftE' lhs lhs' v) av b - Pair e1 e2 -> Pair <$> rebuildOpenExp v av e1 <*> rebuildOpenExp v av e2 - Nil -> pure Nil - VecPack vec e -> VecPack vec <$> rebuildOpenExp v av e - VecUnpack vec e -> VecUnpack vec <$> rebuildOpenExp v av e - IndexSlice x ix sh -> IndexSlice x <$> rebuildOpenExp v av ix <*> rebuildOpenExp v av sh - IndexFull x ix sl -> IndexFull x <$> rebuildOpenExp v av ix <*> rebuildOpenExp v av sl - ToIndex shr sh ix -> ToIndex shr <$> rebuildOpenExp v av sh <*> rebuildOpenExp v av ix - FromIndex shr sh ix -> FromIndex shr <$> rebuildOpenExp v av sh <*> rebuildOpenExp v av ix - Case e rhs def -> Case <$> rebuildOpenExp v av e <*> sequenceA [ (t,) <$> rebuildOpenExp v av c | (t,c) <- rhs ] <*> rebuildMaybeExp v av def - Cond p t e -> Cond <$> rebuildOpenExp v av p <*> rebuildOpenExp v av t <*> rebuildOpenExp v av e - While p f x -> While <$> rebuildFun v av p <*> rebuildFun v av f <*> rebuildOpenExp v av x - PrimApp f x -> PrimApp f <$> rebuildOpenExp v av x - Index a sh -> Index <$> reindex a <*> rebuildOpenExp v av sh - LinearIndex a i -> LinearIndex <$> reindex a <*> rebuildOpenExp v av i - Shape a -> Shape <$> reindex a - ShapeSize shr sh -> ShapeSize shr <$> rebuildOpenExp v av sh - Foreign tp ff f e -> Foreign tp ff f <$> rebuildOpenExp v av e - Coerce t1 t2 e -> Coerce t1 t2 <$> rebuildOpenExp v av e - -{-# INLINEABLE rebuildFun #-} -rebuildFun - :: (HasCallStack, Applicative f, SyntacticExp fe) - => RebuildEvar f fe env env' aenv' - -> ReindexAvar f aenv aenv' - -> OpenFun env aenv t - -> f (OpenFun env' aenv' t) -rebuildFun v av fun = - case fun of - Body e -> Body <$> rebuildOpenExp v av e - Lam lhs f - | Exists lhs' <- rebuildLHS lhs - -> Lam lhs' <$> rebuildFun (shiftE' lhs lhs' v) av f - --- The array environment --- ----------------- +-- Substitutions in array environment +-- ---------------------------------- type RebuildAcc acc = forall aenv aenv' f fa a. (HasCallStack, Applicative f, SyntacticAcc fa) @@ -615,26 +273,6 @@ instance SyntacticAcc PreOpenAcc where type RebuildAvar f (fa :: (Type -> Type -> Type) -> Type -> Type -> Type) acc aenv aenv' = forall sh e. ArrayVar aenv (Array sh e) -> f (fa acc aenv' (Array sh e)) -type RebuildEvar f fe env env' aenv' = - forall t'. ExpVar env t' -> f (fe env' aenv' t') - -newtype ReindexAvar f aenv aenv' = - ReindexAvar (forall sh e. ArrayVar aenv (Array sh e) -> f (ArrayVar aenv' (Array sh e))) - -reindexAvar - :: forall f fa acc aenv aenv'. - (HasCallStack, Applicative f, SyntacticAcc fa) - => RebuildAvar f fa acc aenv aenv' - -> ReindexAvar f aenv aenv' -reindexAvar v = ReindexAvar f where - f :: forall sh e. ArrayVar aenv (Array sh e) -> f (ArrayVar aenv' (Array sh e)) - f var = g <$> v var - - g :: fa acc aenv' (Array sh e) -> ArrayVar aenv' (Array sh e) - g fa = case accOut fa of - Avar var' -> var' - _ -> internalError "An Avar which was used in an Exp was mapped to an array term other than Avar. This mapping is invalid as an Exp can only contain array variables." - {-# INLINEABLE shiftA #-} shiftA @@ -668,7 +306,8 @@ rebuildOpenAcc av (OpenAcc acc) = OpenAcc <$> rebuildPreOpenAcc rebuildOpenAcc a {-# INLINEABLE rebuildPreOpenAcc #-} rebuildPreOpenAcc - :: (HasCallStack, Applicative f, SyntacticAcc fa) + :: forall f fa acc aenv aenv' t. + (HasCallStack, Applicative f, SyntacticAcc fa) => RebuildAcc acc -> RebuildAvar f fa acc aenv aenv' -> PreOpenAcc acc aenv t @@ -681,29 +320,37 @@ rebuildPreOpenAcc k av acc = Apair as bs -> Apair <$> k av as <*> k av bs Anil -> pure Anil Apply repr f a -> Apply repr <$> rebuildAfun k av f <*> k av a - Acond p t e -> Acond <$> rebuildOpenExp (pure . IE) av' p <*> k av t <*> k av e + Acond p t e -> Acond <$> travE p <*> k av t <*> k av e Awhile p f a -> Awhile <$> rebuildAfun k av p <*> rebuildAfun k av f <*> k av a - Unit tp e -> Unit tp <$> rebuildOpenExp (pure . IE) av' e - Reshape shr e a -> Reshape shr <$> rebuildOpenExp (pure . IE) av' e <*> k av a - Generate repr e f -> Generate repr <$> rebuildOpenExp (pure . IE) av' e <*> rebuildFun (pure . IE) av' f - Transform repr sh ix f a -> Transform repr <$> rebuildOpenExp (pure . IE) av' sh <*> rebuildFun (pure . IE) av' ix <*> rebuildFun (pure . IE) av' f <*> k av a - Replicate sl slix a -> Replicate sl <$> rebuildOpenExp (pure . IE) av' slix <*> k av a - Slice sl a slix -> Slice sl <$> k av a <*> rebuildOpenExp (pure . IE) av' slix - Map tp f a -> Map tp <$> rebuildFun (pure . IE) av' f <*> k av a - ZipWith tp f a1 a2 -> ZipWith tp <$> rebuildFun (pure . IE) av' f <*> k av a1 <*> k av a2 - Fold f z a -> Fold <$> rebuildFun (pure . IE) av' f <*> rebuildMaybeExp (pure . IE) av' z <*> k av a - FoldSeg itp f z a s -> FoldSeg itp <$> rebuildFun (pure . IE) av' f <*> rebuildMaybeExp (pure . IE) av' z <*> k av a <*> k av s - Scan d f z a -> Scan d <$> rebuildFun (pure . IE) av' f <*> rebuildMaybeExp (pure . IE) av' z <*> k av a - Scan' d f z a -> Scan' d <$> rebuildFun (pure . IE) av' f <*> rebuildOpenExp (pure . IE) av' z <*> k av a - Permute f1 a1 f2 a2 -> Permute <$> rebuildFun (pure . IE) av' f1 <*> k av a1 <*> rebuildFun (pure . IE) av' f2 <*> k av a2 - Backpermute shr sh f a -> Backpermute shr <$> rebuildOpenExp (pure . IE) av' sh <*> rebuildFun (pure . IE) av' f <*> k av a - Stencil sr tp f b a -> Stencil sr tp <$> rebuildFun (pure . IE) av' f <*> rebuildBoundary av' b <*> k av a + Unit tp e -> Unit tp <$> travE e + Reshape shr e a -> Reshape shr <$> travE e <*> k av a + Generate repr e f -> Generate repr <$> travE e <*> travF f + Transform repr sh ix f a -> Transform repr <$> travE sh <*> travF ix <*> travF f <*> k av a + Replicate sl slix a -> Replicate sl <$> travE slix <*> k av a + Slice sl a slix -> Slice sl <$> k av a <*> travE slix + Map tp f a -> Map tp <$> travF f <*> k av a + ZipWith tp f a1 a2 -> ZipWith tp <$> travF f <*> k av a1 <*> k av a2 + Fold f z a -> Fold <$> travF f <*> travME z <*> k av a + FoldSeg itp f z a s -> FoldSeg itp <$> travF f <*> travME z <*> k av a <*> k av s + Scan d f z a -> Scan d <$> travF f <*> travME z <*> k av a + Scan' d f z a -> Scan' d <$> travF f <*> travE z <*> k av a + Permute f1 a1 f2 a2 -> Permute <$> travF f1 <*> k av a1 <*> travF f2 <*> k av a2 + Backpermute shr sh f a -> Backpermute shr <$> travE sh <*> travF f <*> k av a + Stencil sr tp f b a -> Stencil sr tp <$> travF f <*> rebuildBoundary av b <*> k av a Stencil2 s1 s2 tp f b1 a1 b2 a2 - -> Stencil2 s1 s2 tp <$> rebuildFun (pure . IE) av' f <*> rebuildBoundary av' b1 <*> k av a1 <*> rebuildBoundary av' b2 <*> k av a2 + -> Stencil2 s1 s2 tp <$> travF f <*> rebuildBoundary av b1 <*> k av a1 <*> rebuildBoundary av b2 <*> k av a2 Aforeign repr ff afun as -> Aforeign repr ff afun <$> k av as -- Collect seq -> Collect <$> rebuildSeq k av seq where - av' = reindexAvar av + travE :: Exp aenv e -> f (Exp aenv' e) + travE = rebuildArrayInstrPartial (reindexArrayInstr av) + + travME :: Maybe (Exp aenv e) -> f (Maybe (Exp aenv' e)) + travME Nothing = pure Nothing + travME (Just e) = Just <$> travE e + + travF :: Fun aenv e -> f (Fun aenv' e) + travF = rebuildArrayInstrPartial (reindexArrayInstr av) {-# INLINEABLE rebuildAfun #-} rebuildAfun @@ -729,19 +376,10 @@ rebuildAlet k av lhs1 bind1 body1 | Exists lhs2 <- rebuildLHS lhs1 = Alet lhs2 <$> k av bind1 <*> k (shiftA' lhs1 lhs2 k av) body1 -{-# INLINEABLE rebuildLHS #-} -rebuildLHS :: LeftHandSide s t aenv1 aenv1' -> Exists (LeftHandSide s t aenv2) -rebuildLHS (LeftHandSideWildcard r) = Exists $ LeftHandSideWildcard r -rebuildLHS (LeftHandSideSingle s) = Exists $ LeftHandSideSingle s -rebuildLHS (LeftHandSidePair as bs) - | Exists as' <- rebuildLHS as - , Exists bs' <- rebuildLHS bs - = Exists $ LeftHandSidePair as' bs' - {-# INLINEABLE rebuildBoundary #-} rebuildBoundary - :: Applicative f - => ReindexAvar f aenv aenv' + :: (HasCallStack, Applicative f, SyntacticAcc fa) + => RebuildAvar f fa acc aenv aenv' -> Boundary aenv t -> f (Boundary aenv' t) rebuildBoundary av bndy = @@ -750,7 +388,25 @@ rebuildBoundary av bndy = Mirror -> pure Mirror Wrap -> pure Wrap Constant v -> pure (Constant v) - Function f -> Function <$> rebuildFun (pure . IE) av f + Function f -> Function <$> rebuildArrayInstrPartial (reindexArrayInstr av) f + +reindexArrayInstr + :: forall f fa acc aenv aenv'. + (HasCallStack, Applicative f, SyntacticAcc fa) + => RebuildAvar f fa acc aenv aenv' + -> RebuildArrayInstr f (ArrayInstr aenv) (ArrayInstr aenv') +reindexArrayInstr av arr = case arr of + Shape var -> ArrayInstr . Shape <$> reindex var + Index var -> ArrayInstr . Index <$> reindex var + LinearIndex var -> ArrayInstr . LinearIndex <$> reindex var + where + reindex :: forall sh e. ArrayVar aenv (Array sh e) -> f (ArrayVar aenv' (Array sh e)) + reindex var = g <$> av var + + g :: fa acc aenv' (Array sh e) -> ArrayVar aenv' (Array sh e) + g fa = case accOut fa of + Avar var' -> var' + _ -> internalError "An Avar which was used in an Exp was mapped to an array term other than Avar. This mapping is invalid as an Exp can only contain array variables." {-- {-# INLINEABLE rebuildSeq #-} @@ -797,10 +453,3 @@ rebuildC k v c = rebuildT NilAtup = pure NilAtup rebuildT (SnocAtup t s) = SnocAtup <$> (rebuildT t) <*> (rebuildC k v s) --} - -extractExpVars :: OpenExp env aenv a -> Maybe (ExpVars env a) -extractExpVars Nil = Just TupRunit -extractExpVars (Pair e1 e2) = TupRpair <$> extractExpVars e1 <*> extractExpVars e2 -extractExpVars (Evar v) = Just $ TupRsingle v -extractExpVars _ = Nothing - diff --git a/src/Data/Array/Accelerate/Trafo/Var.hs b/src/Data/Array/Accelerate/Trafo/Var.hs index 76cb2b741..b12998802 100644 --- a/src/Data/Array/Accelerate/Trafo/Var.hs +++ b/src/Data/Array/Accelerate/Trafo/Var.hs @@ -76,3 +76,7 @@ avarsOut extract = \case -> Just (TupRpair as bs) _ -> Nothing +identity :: TypeR a -> PreOpenFun arr env (a -> a) +identity t + | DeclareVars lhs _ value <- declareVars t + = Lam lhs $ Body $ expVars $ value weakenId From 6e46d0bcf119c80b8174a584e9705ba159f5d3ff Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Tue, 11 Aug 2020 11:17:49 +0200 Subject: [PATCH 003/813] Desugar let, pair, nil and apply --- src/Data/Array/Accelerate/AST/Environment.hs | 16 +++ src/Data/Array/Accelerate/AST/Operation.hs | 48 ++++++- .../Array/Accelerate/Representation/Array.hs | 4 + src/Data/Array/Accelerate/Trafo/Desugar.hs | 44 ++++-- .../Trafo/Operation/Substitution.hs | 133 +++++++++++++----- 5 files changed, 197 insertions(+), 48 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Environment.hs b/src/Data/Array/Accelerate/AST/Environment.hs index 009753bc4..f1468322e 100644 --- a/src/Data/Array/Accelerate/AST/Environment.hs +++ b/src/Data/Array/Accelerate/AST/Environment.hs @@ -20,6 +20,7 @@ module Data.Array.Accelerate.AST.Environment where import Data.Array.Accelerate.AST.Idx +import Data.Array.Accelerate.AST.Var import Data.Array.Accelerate.AST.LeftHandSide import Data.Array.Accelerate.Error import Data.Array.Accelerate.Representation.Type @@ -117,3 +118,18 @@ weakenWithLHS = go weakenId go k (LeftHandSideSingle _) = weakenSucc k go k (LeftHandSidePair l1 l2) = go (go k l2) l1 +substituteLHS :: forall s t env env'. LeftHandSide s t env env' -> Vars s env t -> env' :> env +substituteLHS lhs vars = Weaken f + where + f :: Idx env' a -> Idx env a + f ix = case go lhs vars ix of + Left ix' -> ix' + Right ix' -> ix' + + go :: LeftHandSide s u env1 env2 -> Vars s env u -> Idx env2 a -> Either (Idx env a) (Idx env1 a) + go (LeftHandSideWildcard _) _ idx = Right idx + go (LeftHandSideSingle _) (TupRsingle (Var _ var)) idx = case idx of + ZeroIdx -> Left var + SuccIdx idx' -> Right idx' + go (LeftHandSidePair l1 l2) (TupRpair v1 v2) idx = go l2 v2 idx >>= go l1 v1 + go _ _ _ = error "LHS and tuple mismatch" diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index 8cbcef452..e1ac8a435 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -26,6 +26,7 @@ module Data.Array.Accelerate.AST.Operation ( OperationAcc, OperationAfun, Execute(..), GroundR(..), GroundsR, GroundVar, GroundVars, GLeftHandSide, Var(..), Vars, + HasGroundsR(..), PreArgs(..), Arg(..), Args, Modifier(..), argArrayR, argExpType, @@ -37,18 +38,26 @@ module Data.Array.Accelerate.AST.Operation ( rnfGroundR, rnfGroundsR, rnfGroundVar, rnfGroundVars, liftGroundR, liftGroundsR, liftGroundVar, liftGroundVars, + bufferImpossible, groundFunctionImpossible, + paramIn, paramsIn, + IsExecutableAcc(..), + ReindexPartial, reindexArg, reindexArgs, reindexExp, reindexVar, reindexVars, + module Data.Array.Accelerate.AST.Exp ) where import Data.Array.Accelerate.AST.Exp import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.AST.Idx import Data.Array.Accelerate.AST.Var import Data.Array.Accelerate.Analysis.Hash.Exp import Data.Array.Accelerate.Representation.Array import Data.Array.Accelerate.Representation.Shape +import Data.Array.Accelerate.Representation.Shape import Data.Array.Accelerate.Representation.Type +import Data.Array.Accelerate.Trafo.Exp.Substitution import Data.Array.Accelerate.Type import Data.Array.Accelerate.Error import Data.Typeable ( (:~:)(..) ) @@ -95,7 +104,7 @@ data PreOpenAcc exe env a where -- As it is common in this intermediate representation to evaluate some program -- resulting in unit, for instance when execution some operation, and then -- and then do some other code, we write 'a; b' to denote 'let () = a in b'. - Alet :: GLeftHandSide t env env' + Alet :: GLeftHandSide t env env' -> PreOpenAcc exe env t -> PreOpenAcc exe env' b -> PreOpenAcc exe env b @@ -270,6 +279,9 @@ bufferImpossible :: ScalarType (Buffer e) -> a bufferImpossible (SingleScalarType (NumSingleType (IntegralNumType tp))) = case tp of {} bufferImpossible (SingleScalarType (NumSingleType (FloatingNumType tp))) = case tp of {} +groundFunctionImpossible :: GroundsR (s -> t) -> a +groundFunctionImpossible (TupRsingle (GroundRscalar t)) = functionImpossible (TupRsingle t) + type OpenExp env benv = PreOpenExp (ArrayInstr benv) env type OpenFun env benv = PreOpenFun (ArrayInstr benv) env type Fun benv = OpenFun () benv @@ -348,3 +360,37 @@ paramsIn TupRunit TupRunit = Nil paramsIn (TupRpair t1 t2) (TupRpair v1 v2) = paramsIn t1 v1 `Pair` paramsIn t2 v2 paramsIn (TupRsingle t) (TupRsingle (Var _ ix)) = ArrayInstr (Parameter $ Var t ix) Nil paramsIn _ _ = internalError "Tuple mismatch" + +type ReindexPartial f env env' = forall a. Idx env a -> f (Idx env' a) + +reindexVar :: Applicative f => ReindexPartial f env env' -> Var s env t -> f (Var s env' t) +reindexVar k (Var repr ix) = Var repr <$> k ix + +reindexVars :: Applicative f => ReindexPartial f env env' -> Vars s env t -> f (Vars s env' t) +reindexVars k (TupRsingle var) = TupRsingle <$> reindexVar k var +reindexVars k (TupRpair v1 v2) = TupRpair <$> reindexVars k v1 <*> reindexVars k v2 +reindexVars _ TupRunit = pure TupRunit + +reindexArrayInstr :: Applicative f => ReindexPartial f env env' -> ArrayInstr env (s -> t) -> f (ArrayInstr env' (s -> t)) +reindexArrayInstr k (Index v) = Index <$> reindexVar k v +reindexArrayInstr k (Parameter v) = Parameter <$> reindexVar k v + +reindexExp :: (Applicative f, RebuildableExp e) => ReindexPartial f benv benv' -> e (ArrayInstr benv) env t -> f (e (ArrayInstr benv') env t) +reindexExp k = rebuildArrayInstrPartial (rebuildArrayInstrMap $ reindexArrayInstr k) + +reindexArg :: Applicative f => ReindexPartial f env env' -> Arg env t -> f (Arg env' t) +reindexArg k (ArgExp vars) = ArgExp <$> reindexVars k vars +reindexArg k (ArgMaybeExp (Just vars)) = ArgMaybeExp . Just <$> reindexVars k vars +reindexArg _ (ArgMaybeExp Nothing) = pure $ ArgMaybeExp Nothing +reindexArg k (ArgFun f) = ArgFun <$> reindexExp k f +reindexArg k (ArgArray m repr sh buffers) = ArgArray m repr <$> reindexVars k sh <*> reindexVars k buffers + +reindexArgs :: Applicative f => ReindexPartial f env env' -> Args env t -> f (Args env' t) +reindexArgs _ ArgsNil = pure ArgsNil +reindexArgs k (a :>: as) = (:>:) <$> reindexArg k a <*> reindexArgs k as + +class IsExecutableAcc exe where + reindexExecPartial :: Applicative f => ReindexPartial f env env' -> exe env -> f (exe env') + +instance IsExecutableAcc (Execute op) where + reindexExecPartial k (Execute op args) = Execute op <$> reindexArgs k args diff --git a/src/Data/Array/Accelerate/Representation/Array.hs b/src/Data/Array/Accelerate/Representation/Array.hs index 79af43816..cda484a9e 100644 --- a/src/Data/Array/Accelerate/Representation/Array.hs +++ b/src/Data/Array/Accelerate/Representation/Array.hs @@ -1,4 +1,5 @@ {-# LANGUAGE BangPatterns #-} +{-# LANGUAGE EmptyCase #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE ScopedTypeVariables #-} @@ -85,6 +86,9 @@ arraysRarray shR eR = TupRsingle (ArrayR shR eR) arraysRpair :: ArrayR a -> ArrayR b -> ArraysR (((), a), b) arraysRpair a b = TupRunit `TupRpair` TupRsingle a `TupRpair` TupRsingle b +arraysRFunctionImpossible :: ArraysR (s -> t) -> a +arraysRFunctionImpossible (TupRsingle repr) = case repr of {} + -- | Creates a new, uninitialized Accelerate array. -- allocateArray :: ArrayR (Array sh e) -> sh -> IO (Array sh e) diff --git a/src/Data/Array/Accelerate/Trafo/Desugar.hs b/src/Data/Array/Accelerate/Trafo/Desugar.hs index d1b9310a2..c8914203c 100644 --- a/src/Data/Array/Accelerate/Trafo/Desugar.hs +++ b/src/Data/Array/Accelerate/Trafo/Desugar.hs @@ -33,6 +33,7 @@ import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Representation.Vec import Data.Array.Accelerate.Sugar.Foreign import Data.Array.Accelerate.Trafo.Exp.Substitution +import Data.Array.Accelerate.Trafo.Operation.Substitution import Data.Array.Accelerate.Trafo.Var import Data.Array.Accelerate.Type import Data.Array.Accelerate.Error @@ -161,6 +162,12 @@ class DesugarAcc (op :: Type -> Type) where -> OperationAcc op env () -- TODO: Default implementation with awhile & generate + mkForeign :: Foreign asm + => ArraysR bs + -> asm (as -> bs) + -> GroundVars env (DesugaredArrays as) + -> Maybe (OperationAcc op env (DesugaredArrays bs)) + mkForeign _ _ _ = Nothing type family DesugaredArrays a where DesugaredArrays () = () @@ -178,13 +185,12 @@ desugarAfun :: (HasCallStack, DesugarAcc op) => Named.Afun a -> OperationAfun op desugarAfun = desugarOpenAfun Empty data ArrayDescriptor env a where - ArrayDescriptor :: ArrayR (Array sh e) - -> GroundVars env sh + ArrayDescriptor :: GroundVars env sh -> GroundVars env (Buffers e) -> ArrayDescriptor env (Array sh e) weakenArrayDescriptor :: (env :> env') -> ArrayDescriptor env a -> ArrayDescriptor env' a -weakenArrayDescriptor k (ArrayDescriptor repr sh buffers) = ArrayDescriptor repr (weakenVars k sh) (weakenVars k buffers) +weakenArrayDescriptor k (ArrayDescriptor sh buffers) = ArrayDescriptor (weakenVars k sh) (weakenVars k buffers) type BEnv benv = Env (ArrayDescriptor benv) @@ -196,7 +202,18 @@ desugarOpenAcc :: forall op benv aenv a. desugarOpenAcc env = travA where travA :: Named.OpenAcc aenv arr -> OperationAcc op benv (DesugaredArrays arr) - travA = undefined + travA (Named.OpenAcc acc) = case acc of + Named.Alet lhs bnd a + | DesugaredLHS env' lhs' <- desugarLHS env lhs -> alet lhs' (travA bnd) (desugarOpenAcc env' a) + Named.Avar (Var _ ix) + | ArrayDescriptor sh bf <- prj' ix env -> Return (TupRpair sh bf) + Named.Apair a b -> pair (travA a) (travA b) + Named.Anil -> Return TupRunit + Named.Apply repr f arg -> case f of + Named.Alam lhs (Named.Abody a) -> travA $ Named.OpenAcc $ Named.Alet lhs arg a + Named.Abody a -> arraysRFunctionImpossible $ Named.arraysR a + Named.Alam _ Named.Alam{} -> arraysRFunctionImpossible repr + desugarOpenAfun :: (HasCallStack, DesugarAcc op) => BEnv benv aenv @@ -220,11 +237,10 @@ desugarLHS env (LeftHandSideWildcard repr) = DesugaredLHS env $ LeftHandSid desugarLHS env (LeftHandSidePair l1 l2) | DesugaredLHS env1 l1' <- desugarLHS env l1 , DesugaredLHS env2 l2' <- desugarLHS env1 l2 = DesugaredLHS env2 $ LeftHandSidePair l1' l2' -desugarLHS env (LeftHandSideSingle repr@(ArrayR shr tp)) +desugarLHS env (LeftHandSideSingle (ArrayR shr tp)) | DeclareVars lhsSh kSh valueSh <- declareVars $ mapTupR GroundRscalar $ shapeType shr , DeclareVars lhsBf kBf valueBf <- declareVars $ buffersR tp - = DesugaredLHS (mapEnv (weakenArrayDescriptor $ kBf .> kSh) env `Push` ArrayDescriptor repr (valueSh kBf) (valueBf weakenId)) $ LeftHandSidePair lhsSh lhsBf - + = DesugaredLHS (mapEnv (weakenArrayDescriptor $ kBf .> kSh) env `Push` ArrayDescriptor (valueSh kBf) (valueBf weakenId)) $ LeftHandSidePair lhsSh lhsBf desugarArraysR :: ArraysR arr -> GroundsR (DesugaredArrays arr) desugarArraysR TupRunit = TupRunit @@ -254,18 +270,18 @@ desugarFun :: HasCallStack desugarFun env = rebuildArrayInstr (desugarArrayInstr env) desugarArrayInstr :: BEnv benv aenv -> Named.ArrayInstr aenv (s -> t) -> OpenExp env benv s -> OpenExp env benv t -desugarArrayInstr env (Named.Shape (Var _ ix)) _ - | ArrayDescriptor (ArrayR shr _) sh _ <- prj' ix env = paramsIn (shapeType shr) sh -desugarArrayInstr env (Named.LinearIndex (Var (ArrayR _ tp) a)) ix +desugarArrayInstr env (Named.Shape (Var (ArrayR shr _) array)) _ + | ArrayDescriptor sh _ <- prj' array env = paramsIn (shapeType shr) sh +desugarArrayInstr env (Named.LinearIndex (Var (ArrayR _ tp) array)) ix = Let lhs ix $ linearIndex tp buffers $ Var int ZeroIdx where - ArrayDescriptor _ _ buffers = prj' a env + ArrayDescriptor _ buffers = prj' array env int = SingleScalarType $ NumSingleType $ IntegralNumType TypeInt lhs = LeftHandSideSingle int -desugarArrayInstr env (Named.Index (Var (ArrayR _ tp) a)) ix +desugarArrayInstr env (Named.Index (Var (ArrayR shr tp) array)) ix = Let lhs (ToIndex shr sh' ix) $ linearIndex tp buffers $ Var int ZeroIdx where - ArrayDescriptor (ArrayR shr _) sh buffers = prj' a env + ArrayDescriptor sh buffers = prj' array env sh' = paramsIn (shapeType shr) sh int = SingleScalarType $ NumSingleType $ IntegralNumType TypeInt lhs = LeftHandSideSingle int @@ -274,7 +290,7 @@ weakenBEnv :: forall benv benv' aenv. benv :> benv' -> BEnv benv aenv -> BEnv be weakenBEnv k = mapEnv f where f :: ArrayDescriptor benv a -> ArrayDescriptor benv' a - f (ArrayDescriptor shr sh buffers) = ArrayDescriptor shr (weakenVars k sh) (weakenVars k buffers) + f (ArrayDescriptor sh buffers) = ArrayDescriptor (weakenVars k sh) (weakenVars k buffers) -- Utilities -- diff --git a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs index 8bf99a391..afb6cf034 100644 --- a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs +++ b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs @@ -2,6 +2,7 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE KindSignatures #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE PatternGuards #-} {-# LANGUAGE RankNTypes #-} @@ -12,6 +13,7 @@ {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE ViewPatterns #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} {-# OPTIONS_HADDOCK hide #-} -- | -- Module : Data.Array.Accelerate.Trafo.Operation.Substitution @@ -24,46 +26,111 @@ -- module Data.Array.Accelerate.Trafo.Operation.Substitution ( + Sink(..), + reindexPartial, + reindexPartialAfun, + pair, alet, +) where - -- ** Renaming & Substitution - inline, inlineVars, compose, - subTop, subAtop, +import Data.Array.Accelerate.AST.Idx +import Data.Array.Accelerate.AST.Var +import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.AST.Operation +import Data.Array.Accelerate.AST.Environment +import Data.Array.Accelerate.Representation.Type +import Data.Array.Accelerate.Trafo.Var +import Data.Array.Accelerate.Trafo.Substitution (Sink(..)) +import Data.Array.Accelerate.Trafo.Exp.Substitution - -- ** Weakening - (:>), Sink(..), SinkExp(..), weakenVars, +data SunkReindexPartial f env env' where + Sink :: SunkReindexPartial f env env' -> SunkReindexPartial f (env, s) (env', s) + ReindexF :: ReindexPartial f env env' -> SunkReindexPartial f env env' - -- ** Strengthening - (:?>), strengthen, strengthenE, +reindexPartial :: (IsExecutableAcc exe, Applicative f) => ReindexPartial f env env' -> PreOpenAcc exe env t -> f (PreOpenAcc exe env' t) +reindexPartial k = reindexA' (ReindexF k) - -- ** Rebuilding terms - RebuildAcc, Rebuildable(..), RebuildableAcc, - RebuildableExp(..), rebuildWeakenVar, rebuildLHS, - OpenAccFun(..), OpenAccExp(..), +reindexPartialAfun :: (IsExecutableAcc exe, Applicative f) => ReindexPartial f env env' -> PreOpenAfun exe env t -> f (PreOpenAfun exe env' t) +reindexPartialAfun k = reindexAfun' (ReindexF k) - -- ** Checks - isIdentity, isIdentityIndexing, extractExpVars, - bindingIsTrivial, +instance IsExecutableAcc exe => Sink (PreOpenAcc exe) where + weaken k = runIdentity . reindexPartial (Identity . (k >:>)) -) where +instance IsExecutableAcc exe => Sink (PreOpenAfun exe) where + weaken k = runIdentity . reindexPartialAfun (Identity . (k >:>)) -import Data.Array.Accelerate.AST.Operation -import Data.Array.Accelerate.AST.LeftHandSide -import Data.Array.Accelerate.AST.Var -import Data.Array.Accelerate.AST.Idx -import Data.Array.Accelerate.AST.Environment -import Data.Array.Accelerate.Analysis.Match -import Data.Array.Accelerate.Error -import Data.Array.Accelerate.Representation.Type -import Data.Array.Accelerate.Representation.Array -import qualified Data.Array.Accelerate.Debug.Stats as Stats -import Data.Array.Accelerate.Trafo.Substitution (lhsFullVars, bindingIsTrivial) +sinkReindexWithLHS :: LeftHandSide s t env1 env1' -> LeftHandSide s t env2 env2' -> SunkReindexPartial f env1 env2 -> SunkReindexPartial f env1' env2' +sinkReindexWithLHS (LeftHandSideWildcard _) (LeftHandSideWildcard _) k = k +sinkReindexWithLHS (LeftHandSideSingle _) (LeftHandSideSingle _) k = Sink k +sinkReindexWithLHS (LeftHandSidePair a1 b1) (LeftHandSidePair a2 b2) k = sinkReindexWithLHS b1 b2 $ sinkReindexWithLHS a1 a2 k +sinkReindexWithLHS _ _ _ = error "sinkReindexWithLHS: left hand sides don't match" + +-- All functions ending in a prime work with SunkReindexPartial instead of ReindexPartial. +reindex' :: Applicative f => SunkReindexPartial f env env' -> ReindexPartial f env env' +reindex' (ReindexF f) = f +reindex' (Sink k) = \case + ZeroIdx -> pure ZeroIdx + SuccIdx ix -> SuccIdx <$> reindex' k ix + +reindexVar' :: Applicative f => SunkReindexPartial f env env' -> Var s env t -> f (Var s env' t) +reindexVar' k (Var repr ix) = Var repr <$> reindex' k ix + +reindexVars' :: Applicative f => SunkReindexPartial f env env' -> Vars s env t -> f (Vars s env' t) +reindexVars' _ TupRunit = pure $ TupRunit +reindexVars' k (TupRsingle var) = TupRsingle <$> reindexVar' k var +reindexVars' k (TupRpair v1 v2) = TupRpair <$> reindexVars' k v1 <*> reindexVars' k v2 + +reindexArrayInstr' :: Applicative f => SunkReindexPartial f env env' -> ArrayInstr env (s -> t) -> f (ArrayInstr env' (s -> t)) +reindexArrayInstr' k (Index v) = Index <$> reindexVar' k v +reindexArrayInstr' k (Parameter v) = Parameter <$> reindexVar' k v + +reindexExp' :: (Applicative f, RebuildableExp e) => SunkReindexPartial f benv benv' -> e (ArrayInstr benv) env t -> f (e (ArrayInstr benv') env t) +reindexExp' k = rebuildArrayInstrPartial (rebuildArrayInstrMap $ reindexArrayInstr' k) + +reindexA' :: forall exe f env env' t. (IsExecutableAcc exe, Applicative f) => SunkReindexPartial f env env' -> PreOpenAcc exe env t -> f (PreOpenAcc exe env' t) +reindexA' k = \case + Exec exe -> Exec <$> reindexExecPartial (reindex' k) exe + Return vars -> Return <$> reindexVars' k vars + Compute e -> Compute <$> reindexExp' k e + Alet lhs bnd body + | Exists lhs' <- rebuildLHS lhs -> Alet lhs' <$> travA bnd <*> reindexA' (sinkReindexWithLHS lhs lhs' k) body + Alloc shr tp sh -> Alloc shr tp <$> reindexVars' k sh + Use tp buffer -> pure $ Use tp buffer + Unit var -> Unit <$> reindexVar' k var + Clone shr sh buffer -> Clone shr <$> reindexVars' k sh <*> reindexVar' k buffer + Acond c t f -> Acond <$> reindexVar' k c <*> travA t <*> travA f + Awhile c f i -> Awhile <$> reindexAfun' k c <*> reindexAfun' k f <*> travA i + where + travA :: PreOpenAcc exe env s -> f (PreOpenAcc exe env' s) + travA = reindexA' k + +reindexAfun' :: (IsExecutableAcc exe, Applicative f) => SunkReindexPartial f env env' -> PreOpenAfun exe env t -> f (PreOpenAfun exe env' t) +reindexAfun' k (Alam lhs f) + | Exists lhs' <- rebuildLHS lhs = Alam lhs' <$> reindexAfun' (sinkReindexWithLHS lhs lhs' k) f +reindexAfun' k (Abody a) = Abody <$> reindexA' k a -import Data.Kind -import Control.Applicative hiding ( Const ) -import Control.Monad -import Prelude hiding ( exp, seq ) +pair :: forall exe env a b. IsExecutableAcc exe => PreOpenAcc exe env a -> PreOpenAcc exe env b -> PreOpenAcc exe env (a, b) +pair a b = goA weakenId a + where + -- Traverse 'a' and look for a return. We can jump over let bindings + -- If we don't find a 'return', we must first bind the value in a let, + -- and then use the newly defined variables instead. + -- + goA :: env :> env' -> PreOpenAcc exe env' a -> PreOpenAcc exe env' (a, b) + goA k (Alet lhs bnd x) = Alet lhs bnd $ goA (weakenWithLHS lhs .> k) x + goA k (Return vars) = goB vars $ weaken k b + goA k acc + | DeclareVars lhs k' value <- declareVars $ groundsR acc + = Alet lhs acc $ goB (value weakenId) $ weaken (k' .> k) b + goB :: GroundVars env' a -> PreOpenAcc exe env' b -> PreOpenAcc exe env' (a, b) + goB varsA (Alet lhs bnd x) = Alet lhs bnd $ goB (weakenVars (weakenWithLHS lhs) varsA) x + goB varsA (Return varsB) = Return (TupRpair varsA varsB) + goB varsA acc + | DeclareVars lhs k value <- declareVars $ groundsR b + = Alet lhs acc $ Return (TupRpair (weakenVars k varsA) (value weakenId)) -isIdentity :: OpenFun env aenv (a -> b) -> Maybe (a :~: b) -isIdentity (Lam lhs (Body (extractExpVars -> Just vars))) = bindingIsTrivial lhs vars -isIdentity _ = Nothing +alet :: IsExecutableAcc exe => GLeftHandSide t env env' -> PreOpenAcc exe env t -> PreOpenAcc exe env' s -> PreOpenAcc exe env s +alet lhs1 (Alet lhs2 a1 a2) a3 + | Exists lhs1' <- rebuildLHS lhs1 = Alet lhs2 a1 $ alet lhs1' a2 $ weaken (sinkWithLHS lhs1 lhs1' $ weakenWithLHS lhs2) a3 +alet lhs (Return vars) a = weaken (substituteLHS lhs vars) a +alet lhs bnd a = Alet lhs bnd a From d47f3f7deb2f2c1c02fc66d68e03d9b5345ad229 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Tue, 1 Sep 2020 16:24:40 +0200 Subject: [PATCH 004/813] More desugaring --- src/Data/Array/Accelerate/AST.hs | 5 - src/Data/Array/Accelerate/AST/Environment.hs | 4 +- src/Data/Array/Accelerate/AST/Exp.hs | 4 +- src/Data/Array/Accelerate/AST/Operation.hs | 26 +- src/Data/Array/Accelerate/AST/Var.hs | 5 + src/Data/Array/Accelerate/Trafo/Desugar.hs | 350 +++++++++++++++++- .../Trafo/Operation/Substitution.hs | 15 +- 7 files changed, 379 insertions(+), 30 deletions(-) diff --git a/src/Data/Array/Accelerate/AST.hs b/src/Data/Array/Accelerate/AST.hs index 7c9645bfe..7fe14d589 100644 --- a/src/Data/Array/Accelerate/AST.hs +++ b/src/Data/Array/Accelerate/AST.hs @@ -439,11 +439,6 @@ data PreOpenAcc (acc :: Type -> Type -> Type) aenv a where -> acc aenv (Array sh b) -- source array #2 -> PreOpenAcc acc aenv (Array sh c) - -data Direction = LeftToRight | RightToLeft - deriving Eq - - -- | Vanilla boundary condition specification for stencil operations -- data Boundary aenv t where diff --git a/src/Data/Array/Accelerate/AST/Environment.hs b/src/Data/Array/Accelerate/AST/Environment.hs index f1468322e..7f9b217f9 100644 --- a/src/Data/Array/Accelerate/AST/Environment.hs +++ b/src/Data/Array/Accelerate/AST/Environment.hs @@ -118,7 +118,7 @@ weakenWithLHS = go weakenId go k (LeftHandSideSingle _) = weakenSucc k go k (LeftHandSidePair l1 l2) = go (go k l2) l1 -substituteLHS :: forall s t env env'. LeftHandSide s t env env' -> Vars s env t -> env' :> env +substituteLHS :: forall s s' t env env'. LeftHandSide s t env env' -> Vars s' env t -> env' :> env substituteLHS lhs vars = Weaken f where f :: Idx env' a -> Idx env a @@ -126,7 +126,7 @@ substituteLHS lhs vars = Weaken f Left ix' -> ix' Right ix' -> ix' - go :: LeftHandSide s u env1 env2 -> Vars s env u -> Idx env2 a -> Either (Idx env a) (Idx env1 a) + go :: LeftHandSide s u env1 env2 -> Vars s' env u -> Idx env2 a -> Either (Idx env a) (Idx env1 a) go (LeftHandSideWildcard _) _ idx = Right idx go (LeftHandSideSingle _) (TupRsingle (Var _ var)) idx = case idx of ZeroIdx -> Left var diff --git a/src/Data/Array/Accelerate/AST/Exp.hs b/src/Data/Array/Accelerate/AST/Exp.hs index 509589902..aaaae1489 100644 --- a/src/Data/Array/Accelerate/AST/Exp.hs +++ b/src/Data/Array/Accelerate/AST/Exp.hs @@ -60,7 +60,7 @@ module Data.Array.Accelerate.AST.Exp ( -- ** Miscellaneous mkConstant, mkBinary, unBody, - showExpOp, + showExpOp, Direction(..), ) where @@ -256,6 +256,8 @@ instance IsArrayInstr NoArrayInstr where encodeArrayInstr = \case {} matchArrayInstr = \case{} +data Direction = LeftToRight | RightToLeft + deriving Eq -- |Primitive constant values -- diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index e1ac8a435..49e01dc4d 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -28,9 +28,9 @@ module Data.Array.Accelerate.AST.Operation ( GroundR(..), GroundsR, GroundVar, GroundVars, GLeftHandSide, Var(..), Vars, HasGroundsR(..), - PreArgs(..), Arg(..), Args, Modifier(..), argArrayR, argExpType, + PreArgs(..), Arg(..), Args, Modifier(..), argArrayR, argVarType, - Exp', Fun', In, Out, Mut, + Var', Exp', Fun', In, Out, Mut, OpenExp, OpenFun, Exp, Fun, ArrayInstr(..), @@ -55,7 +55,6 @@ import Data.Array.Accelerate.AST.Var import Data.Array.Accelerate.Analysis.Hash.Exp import Data.Array.Accelerate.Representation.Array import Data.Array.Accelerate.Representation.Shape -import Data.Array.Accelerate.Representation.Shape import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Trafo.Exp.Substitution import Data.Array.Accelerate.Type @@ -140,14 +139,14 @@ data PreOpenAcc exe env a where -- | If-then-else for array-level computations -- - Acond :: ExpVar env Bool + Acond :: ExpVar env PrimBool -> PreOpenAcc exe env a -> PreOpenAcc exe env a -> PreOpenAcc exe env a -- Value-recursion for array-level computations -- - Awhile :: PreOpenAfun exe env (arrs -> Bool) + Awhile :: PreOpenAfun exe env (arrs -> PrimBool) -> PreOpenAfun exe env (arrs -> arrs) -> PreOpenAcc exe env arrs -> PreOpenAcc exe env arrs @@ -187,9 +186,10 @@ data PreArgs a t where -- | A single argument to an operation. -- data Arg env t where - ArgExp :: ExpVars env e -> Arg env (Exp' e) + -- TODO: Do we need this? + ArgVars :: ExpVars env e -> Arg env (Var' e) - ArgMaybeExp :: Maybe (ExpVars env e) -> Arg env (Maybe (Exp' e)) + ArgExp :: Exp env e -> Arg env (Exp' e) ArgFun :: Fun env e -> Arg env (Fun' e) @@ -218,14 +218,15 @@ data Modifier m where Mut :: Modifier Mut -- Empty data types, which are only used for the types of 'Arg'. +data Var' e where data Exp' e where data Fun' t where data In sh e where data Out sh e where data Mut sh e where -argExpType :: Arg env (Exp' e) -> TypeR e -argExpType (ArgExp vars) = varsType vars +argVarType :: Arg env (Var' e) -> TypeR e +argVarType (ArgVars vars) = varsType vars argArrayR :: Arg env (m sh e) -> ArrayR (Array sh e) argArrayR (ArgArray _ repr _ _) = repr @@ -379,10 +380,9 @@ reindexExp :: (Applicative f, RebuildableExp e) => ReindexPartial f benv benv' - reindexExp k = rebuildArrayInstrPartial (rebuildArrayInstrMap $ reindexArrayInstr k) reindexArg :: Applicative f => ReindexPartial f env env' -> Arg env t -> f (Arg env' t) -reindexArg k (ArgExp vars) = ArgExp <$> reindexVars k vars -reindexArg k (ArgMaybeExp (Just vars)) = ArgMaybeExp . Just <$> reindexVars k vars -reindexArg _ (ArgMaybeExp Nothing) = pure $ ArgMaybeExp Nothing -reindexArg k (ArgFun f) = ArgFun <$> reindexExp k f +reindexArg k (ArgVars vars) = ArgVars <$> reindexVars k vars +reindexArg k (ArgExp e) = ArgExp <$> reindexExp k e +reindexArg k (ArgFun f) = ArgFun <$> reindexExp k f reindexArg k (ArgArray m repr sh buffers) = ArgArray m repr <$> reindexVars k sh <*> reindexVars k buffers reindexArgs :: Applicative f => ReindexPartial f env env' -> Args env t -> f (Args env' t) diff --git a/src/Data/Array/Accelerate/AST/Var.hs b/src/Data/Array/Accelerate/AST/Var.hs index c3abc95d4..4b7cec4f0 100644 --- a/src/Data/Array/Accelerate/AST/Var.hs +++ b/src/Data/Array/Accelerate/AST/Var.hs @@ -58,3 +58,8 @@ matchVars (TupRpair v w) (TupRpair x y) , Just Refl <- matchVars w y = Just Refl matchVars _ _ = Nothing +mapVar :: (forall u. s u -> s' u) -> Var s env t -> Var s' env t +mapVar f (Var t ix) = Var (f t) ix + +mapVars :: (forall u. s u -> s' u) -> Vars s env t -> Vars s' env t +mapVars f = mapTupR (mapVar f) diff --git a/src/Data/Array/Accelerate/Trafo/Desugar.hs b/src/Data/Array/Accelerate/Trafo/Desugar.hs index c8914203c..f4c70a4e0 100644 --- a/src/Data/Array/Accelerate/Trafo/Desugar.hs +++ b/src/Data/Array/Accelerate/Trafo/Desugar.hs @@ -21,6 +21,7 @@ module Data.Array.Accelerate.Trafo.Desugar import qualified Data.Array.Accelerate.AST as Named import Data.Array.Accelerate.AST.Environment hiding ( Val ) import Data.Array.Accelerate.AST.Idx +import Data.Array.Accelerate.AST.Var import Data.Array.Accelerate.AST.Operation import Data.Array.Accelerate.AST.LeftHandSide import Data.Array.Accelerate.Analysis.Match ((:~:)(..)) @@ -132,7 +133,7 @@ class DesugarAcc (op :: Type -> Type) where = mkGenerate (ArgFun $ desugarStencil2Fun sr1 sr2 tp f (Just boundary1) input1 (Just boundary2) input2) output mkFold :: Arg env (Fun' (e -> e -> e)) - -> Arg env (Maybe (Exp' e)) + -> Maybe (Arg env (Exp' e)) -> Arg env (In (sh, Int) e) -> Arg env (Out sh e) -> OperationAcc op env () @@ -141,21 +142,23 @@ class DesugarAcc (op :: Type -> Type) where mkFoldSeg :: IntegralType i -> Arg env (Fun' (e -> e -> e)) - -> Arg env (Maybe (Exp' e)) + -> Maybe (Arg env (Exp' e)) -> Arg env (In (sh, Int) e) -> Arg env (In DIM1 i) -> Arg env (Out (sh, Int) e) -> OperationAcc op env () - mkScan :: Arg env (Fun' (e -> e -> e)) - -> Arg env (Maybe (Exp' e)) + mkScan :: Direction + -> Arg env (Fun' (e -> e -> e)) + -> Maybe (Arg env (Exp' e)) -> Arg env (In (sh, Int) e) -> Arg env (Out (sh, Int) e) -> OperationAcc op env () -- TODO: Default implementation with awhile & generate - mkScan' :: Arg env (Fun' (e -> e -> e)) - -> Arg env (Maybe (Exp' e)) + mkScan' :: Direction + -> Arg env (Fun' (e -> e -> e)) + -> Arg env (Exp' e) -> Arg env (In (sh, Int) e) -> Arg env (Out (sh, Int) e) -> Arg env (Out sh e) @@ -178,6 +181,11 @@ type family DesugaredAfun a where DesugaredAfun (a -> b) = DesugaredArrays a -> DesugaredAfun b DesugaredAfun a = DesugaredArrays a +desugaredAfunIsBody :: ArraysR a -> DesugaredAfun a :~: DesugaredArrays a +desugaredAfunIsBody (TupRsingle ArrayR{}) = Refl +desugaredAfunIsBody TupRunit = Refl +desugaredAfunIsBody (TupRpair _ _) = Refl + desugar :: (HasCallStack, DesugarAcc op) => Named.Acc a -> OperationAcc op () (DesugaredArrays a) desugar = desugarOpenAcc Empty @@ -201,6 +209,12 @@ desugarOpenAcc :: forall op benv aenv a. -> OperationAcc op benv (DesugaredArrays a) desugarOpenAcc env = travA where + travE :: Named.Exp aenv t -> Exp benv t + travE = desugarExp env + + travF :: Named.Fun aenv t -> Fun benv t + travF = desugarFun env + travA :: Named.OpenAcc aenv arr -> OperationAcc op benv (DesugaredArrays arr) travA (Named.OpenAcc acc) = case acc of Named.Alet lhs bnd a @@ -213,7 +227,329 @@ desugarOpenAcc env = travA Named.Alam lhs (Named.Abody a) -> travA $ Named.OpenAcc $ Named.Alet lhs arg a Named.Abody a -> arraysRFunctionImpossible $ Named.arraysR a Named.Alam _ Named.Alam{} -> arraysRFunctionImpossible repr - + Named.Aforeign repr asm (Named.Alam lhsA _) arg + | DeclareVars lhs _ value <- declareVars $ desugarArraysR $ lhsToTupR lhsA + , Just a <- mkForeign repr asm $ value weakenId + -> alet lhs (travA arg) a + Named.Aforeign repr _ f arg -> travA $ Named.OpenAcc $ Named.Apply repr (weaken weakenEmpty f) $ arg + Named.Acond c t f -> + let + lhs = LeftHandSideSingle $ GroundRscalar scalarTypeWord8 + env' = weakenBEnv (weakenSucc weakenId) env + var = Var scalarTypeWord8 ZeroIdx + in alet lhs (Compute $ travE c) $ Acond var (desugarOpenAcc env' t) (desugarOpenAcc env' f) + Named.Awhile c f i + | Refl <- desugaredAfunIsBody $ Named.arraysR acc -> + let + bufferType = GroundRbuffer $ scalarTypeWord8 + lhsScalarBool = LeftHandSidePair (LeftHandSideWildcard TupRunit) (LeftHandSideSingle bufferType) + c' = case desugarOpenAfun env c of + Alam lhs (Abody body) -> Alam lhs $ Abody $ Alet lhsScalarBool body $ Compute $ ArrayInstr (Index $ Var bufferType ZeroIdx) $ Const scalarTypeInt 0 + Abody _ -> error "It's a long time since we last met" + f' = desugarOpenAfun env f + i' = travA i + in Awhile c' f' i' + Named.Use repr array -> undefined + Named.Unit tp e + | DeclareVars lhs _ value <- declareVars tp -> + let + go :: forall benv' t. ExpVars benv' t -> OperationAcc op benv' (Buffers t) + go (TupRpair v1 v2) = go v1 `pair` go v2 + go TupRunit = Return TupRunit + go (TupRsingle v@(Var repr _)) + | Refl <- reprIsSingle @ScalarType @t @Buffer repr = Unit v + in + alet (mapLeftHandSide GroundRscalar lhs) (Compute $ travE e) $ pair (Return TupRunit) $ go (value weakenId) + -- XXX: Should we check whether the sizes are equal? We could add an Assert constructor to PreOpenAcc, + -- which we can use to verify the sizes at runtime. + -- + Named.Reshape shr sh a + | ArrayR oldShr tp <- Named.arrayR a + , DeclareVars lhsSh kSh valueSh <- declareVars $ mapTupR GroundRscalar $ shapeType shr + , DeclareVars lhsBf kBf valueBf <- declareVars $ buffersR tp -> + alet lhsSh (Compute $ travE sh) + $ alet (LeftHandSidePair (LeftHandSideWildcard $ mapTupR GroundRscalar $ shapeType oldShr) lhsBf) (desugarOpenAcc (weakenBEnv kSh env) a) + $ Return (TupRpair (valueSh kBf) (valueBf weakenId)) + + -- The remaining constructors of Named.OpenAcc are compiled into operations through the mkXX functions + -- the type class DesugarAcc. We must here allocate the output arrays of the appropriate size and call + -- the corresponding mkXX function. + -- + + Named.Generate (ArrayR shr tp) sh f + | DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr + , DeclareVars lhsBf kBf valueBf <- declareVars $ buffersR tp -> + let + sh' = mapVars GroundRscalar $ valueSh kBf + argF = ArgFun $ desugarFun (weakenBEnv (kBf .> kSh) env) f + argOut = ArgArray Out (ArrayR shr tp) sh' (valueBf weakenId) + in + alet (mapLeftHandSide GroundRscalar lhsSh) (Compute $ travE sh) + $ alet lhsBf (desugarAlloc (ArrayR shr tp) (valueSh weakenId)) + $ alet (LeftHandSideWildcard TupRunit) (mkGenerate argF argOut) + $ Return (sh' `TupRpair` valueBf weakenId) + + Named.Transform (ArrayR shrOut tpOut) shExp idxTransform valueTransform a + | ArrayR shrIn tpIn <- Named.arrayR a + , DeclareVars lhsShIn kShIn valueShIn <- declareVars $ mapTupR GroundRscalar $ shapeType shrIn + , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR tpIn + , DeclareVars lhsShOut kShOut valueShOut <- declareVars $ shapeType shrOut + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tpOut -> + let + shOut = mapVars GroundRscalar $ valueShOut kOut + bfOut = valueOut weakenId + env' = weakenBEnv (kOut .> kShOut .> kIn .> kShIn) env + argIdxF = ArgFun $ desugarFun env' idxTransform + argValF = ArgFun $ desugarFun env' valueTransform + argIn = ArgArray In (ArrayR shrIn tpIn) (valueShIn (kOut .> kShOut .> kIn)) (valueIn (kOut .> kShOut)) + argOut = ArgArray Out (ArrayR shrOut tpOut) shOut bfOut + in + alet (LeftHandSidePair lhsShIn lhsIn) (travA a) + $ alet (mapLeftHandSide GroundRscalar lhsShOut) (Compute $ desugarExp (weakenBEnv (kIn .> kShIn) env) shExp) + $ alet lhsOut (desugarAlloc (ArrayR shrOut tpOut) (valueShOut weakenId)) + $ alet (LeftHandSideWildcard TupRunit) (mkTransform argIdxF argValF argIn argOut) + $ Return (shOut `TupRpair` bfOut) + + Named.Map tp f a + | ArrayR shr oldTp <- Named.arrayR a + , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr + , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR oldTp + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp -> + let + lhs = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh) lhsIn + sh = mapVars GroundRscalar $ valueSh (kOut .> kIn) + argF = ArgFun $ desugarFun (weakenBEnv (kOut .> kIn .> kSh) env) f + argIn = ArgArray In (ArrayR shr oldTp) sh (valueIn kOut) + argOut = ArgArray Out (ArrayR shr tp) sh (valueOut weakenId) + in + alet lhs (travA a) + $ alet lhsOut (desugarAlloc (ArrayR shr tp) (valueSh kIn)) + $ alet (LeftHandSideWildcard TupRunit) (mkMap argF argIn argOut) + $ Return (sh `TupRpair` valueOut weakenId) + + Named.Backpermute shrOut shExp f a + | ArrayR shrIn tp <- Named.arrayR a + , DeclareVars lhsShIn kShIn valueShIn <- declareVars $ mapTupR GroundRscalar $ shapeType shrIn + , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR tp + , DeclareVars lhsShOut kShOut valueShOut <- declareVars $ shapeType shrOut + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp -> + let + shOut = mapVars GroundRscalar $ valueShOut kOut + bfOut = valueOut weakenId + env' = weakenBEnv (kOut .> kShOut .> kIn .> kShIn) env + argF = ArgFun $ desugarFun env' f + argIn = ArgArray In (ArrayR shrIn tp) (valueShIn (kOut .> kShOut .> kIn)) (valueIn (kOut .> kShOut)) + argOut = ArgArray Out (ArrayR shrOut tp) shOut bfOut + in + alet (LeftHandSidePair lhsShIn lhsIn) (travA a) + $ alet (mapLeftHandSide GroundRscalar lhsShOut) (Compute $ desugarExp (weakenBEnv (kIn .> kShIn) env) shExp) + $ alet lhsOut (desugarAlloc (ArrayR shrOut tp) (valueShOut weakenId)) + $ alet (LeftHandSideWildcard TupRunit) (mkBackpermute argF argIn argOut) + $ Return (shOut `TupRpair` bfOut) + + Named.Fold f def a + | ArrayR (ShapeRsnoc shr) tp <- Named.arrayR a + , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType $ ShapeRsnoc shr + , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR tp + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp -> + let + shIn = mapVars GroundRscalar $ valueSh (kOut .> kIn) + shOut' = case valueSh kIn of + TupRpair sh _ -> sh + TupRsingle _ -> error "Impossible pair" + shOut = case shIn of + TupRpair sh _ -> sh + TupRsingle _ -> error "Impossible pair" + k = kOut .> kIn .> kSh + argF = ArgFun $ desugarFun (weakenBEnv k env) f + argDef = fmap (ArgExp . desugarExp (weakenBEnv k env)) def + argIn = ArgArray In (ArrayR (ShapeRsnoc shr) tp) shIn (valueIn kOut) + argOut = ArgArray Out (ArrayR shr tp) shOut (valueOut weakenId) + in + alet (LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh) lhsIn) (travA a) + $ alet lhsOut (desugarAlloc (ArrayR shr tp) shOut') + $ alet (LeftHandSideWildcard TupRunit) (mkFold argF argDef argIn argOut) + $ Return (shOut `TupRpair` valueOut weakenId) + + Named.FoldSeg (i :: IntegralType i) f def a segments + | ArrayR shr tp <- Named.arrayR a + , Refl <- reprIsSingle @ScalarType @i @Buffer (SingleScalarType $ NumSingleType $ IntegralNumType i) + , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr + , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR tp + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp -> + let + itp = SingleScalarType $ NumSingleType $ IntegralNumType i + lhsSeg + = LeftHandSidePair + -- DIM1 = ((), Int) + (LeftHandSidePair (LeftHandSideWildcard TupRunit) (LeftHandSideSingle $ GroundRscalar scalarTypeInt)) + -- Buffer of integral type i + $ LeftHandSideSingle $ GroundRbuffer itp + kSeg = weakenSucc $ weakenSucc weakenId + + sh = mapVars GroundRscalar $ valueSh (kSeg .> kOut .> kIn) + sh' = valueSh kIn + + k = kSeg .> kOut .> kIn .> kSh + argF = ArgFun $ desugarFun (weakenBEnv k env) f + argDef = fmap (ArgExp . desugarExp (weakenBEnv k env)) def + argIn = ArgArray In (ArrayR shr tp) sh (valueIn $ kSeg .> kOut) + argOut = ArgArray Out (ArrayR shr tp) sh (valueOut $ kSeg) + argSeg = ArgArray In (ArrayR dim1 $ TupRsingle itp) (TupRpair TupRunit $ TupRsingle $ Var (GroundRscalar scalarTypeInt) $ SuccIdx ZeroIdx) (TupRsingle $ Var (GroundRbuffer itp) ZeroIdx) + in + alet (LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh) lhsIn) (travA a) + $ alet lhsOut (desugarAlloc (ArrayR shr tp) sh') + $ alet lhsSeg (desugarOpenAcc (weakenBEnv (kOut .> kIn .> kSh) env) segments) + $ alet (LeftHandSideWildcard TupRunit) (mkFoldSeg i argF argDef argIn argSeg argOut) + $ Return (sh `TupRpair` valueOut kSeg) + + -- scan1 + Named.Scan dir f Nothing a + | ArrayR shr tp <- Named.arrayR a + , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr + , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR tp + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp -> + let + sh = mapVars GroundRscalar $ valueSh (kOut .> kIn) + k = kOut .> kIn .> kSh + argF = ArgFun $ desugarFun (weakenBEnv k env) f + argIn = ArgArray In (ArrayR shr tp) sh (valueIn kOut) + argOut = ArgArray Out (ArrayR shr tp) sh (valueOut weakenId) + in + alet (LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh) lhsIn) (travA a) + $ alet lhsOut (desugarAlloc (ArrayR shr tp) $ valueSh kIn) + $ alet (LeftHandSideWildcard TupRunit) (mkScan dir argF Nothing argIn argOut) + $ Return (sh `TupRpair` valueOut weakenId) + + Named.Scan dir f (Just def) a + | ArrayR shr tp <- Named.arrayR a + , DeclareVars lhsShIn kShIn valueShIn <- declareVars $ shapeType shr + , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR tp + -- The rightmost dimension is incremented by 1. This variable only contains the rightmost dimension + , DeclareVars lhsShOut kShOut valueShOut <- declareVars $ TupRsingle $ scalarTypeInt + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp -> + let + shIn = mapVars GroundRscalar $ valueShIn (kOut .> kShOut .> kIn) + shIn1 = case valueShIn kIn of + TupRpair _ (TupRsingle sh) -> sh + _ -> error "Impossible pair" + shOut = case shIn of + TupRpair sh _ -> TupRpair sh $ mapVars GroundRscalar $ valueShOut kOut + _ -> error "Impossible pair" + shOut' = case valueShIn (kShOut .> kIn) of + TupRpair sh _ -> TupRpair sh $ valueShOut weakenId + _ -> error "Impossible pair" + + k = kOut .> kShOut .> kIn .> kShIn + + argF = ArgFun $ desugarFun (weakenBEnv k env) f + argDef = Just $ ArgExp $ desugarExp (weakenBEnv k env) def + argIn = ArgArray In (ArrayR shr tp) shIn (valueIn $ kOut .> kShOut) + argOut = ArgArray Out (ArrayR shr tp) shOut (valueOut weakenId) + in + alet (LeftHandSidePair (mapLeftHandSide GroundRscalar lhsShIn) lhsIn) (travA a) + $ alet (mapLeftHandSide GroundRscalar lhsShOut) (Compute $ mkBinary (PrimAdd numType) (ArrayInstr (Parameter shIn1) Nil) (mkConstant (TupRsingle scalarTypeInt) 1)) + $ alet lhsOut (desugarAlloc (ArrayR shr tp) $ shOut') + $ alet (LeftHandSideWildcard TupRunit) (mkScan dir argF argDef argIn argOut) + $ Return (shOut `TupRpair` valueOut weakenId) + + Named.Scan' dir f def a + | ArrayR (ShapeRsnoc shr) tp <- Named.arrayR a + , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType $ ShapeRsnoc shr + , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR tp + -- The prefix values + , DeclareVars lhsOut1 kOut1 valueOut1 <- declareVars $ buffersR tp + -- The final reduced value + , DeclareVars lhsOut2 kOut2 valueOut2 <- declareVars $ buffersR tp -> + let + sh = mapVars GroundRscalar $ valueSh (kOut2 .> kOut1 .> kIn) + + shOut1' = valueSh kIn + shOut2' = case valueSh (kOut1 .> kIn) of + TupRpair sh' _ -> sh' + _ -> error "Impossible pair" + shOut2 = case sh of + TupRpair sh' _ -> sh' + _ -> error "Impossible pair" + + k = kOut2 .> kOut1 .> kIn .> kSh + + argF = ArgFun $ desugarFun (weakenBEnv k env) f + argDef = ArgExp $ desugarExp (weakenBEnv k env) def + argIn = ArgArray In (ArrayR (ShapeRsnoc shr) tp) sh (valueIn $ kOut2 .> kOut1) + argOut1 = ArgArray Out (ArrayR (ShapeRsnoc shr) tp) sh (valueOut1 kOut2) + argOut2 = ArgArray Out (ArrayR shr tp) shOut2 (valueOut2 weakenId) + in + alet (LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh) lhsIn) (travA a) + $ alet lhsOut1 (desugarAlloc (ArrayR (ShapeRsnoc shr) tp) $ shOut1') + $ alet lhsOut2 (desugarAlloc (ArrayR shr tp) $ shOut2') + $ alet (LeftHandSideWildcard TupRunit) (mkScan' dir argF argDef argIn argOut1 argOut2) + $ Return (TupRpair sh (valueOut1 kOut2) `TupRpair` TupRpair shOut2 (valueOut2 weakenId)) + + Named.Stencil sr tp f boundary a + | shr <- stencilShapeR sr + , oldTp <- stencilEltR sr + , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr + , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR oldTp + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp -> + let + lhs = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh) lhsIn + sh = mapVars GroundRscalar $ valueSh (kOut .> kIn) + env' = weakenBEnv (kOut .> kIn .> kSh) env + argF = ArgFun $ desugarFun env' f + argIn = ArgArray In (ArrayR shr oldTp) sh (valueIn kOut) + argOut = ArgArray Out (ArrayR shr tp) sh (valueOut weakenId) + boundary' = desugarBoundary env' boundary + in + alet lhs (travA a) + $ alet lhsOut (desugarAlloc (ArrayR shr tp) (valueSh kIn)) + $ alet (LeftHandSideWildcard TupRunit) (mkStencil sr argF boundary' argIn argOut) + $ Return (sh `TupRpair` valueOut weakenId) + + Named.Stencil2 sr1 sr2 tp3 f b1 a1 b2 a2 + | shr <- stencilShapeR sr1 + , tp1 <- stencilEltR sr1 + , tp2 <- stencilEltR sr2 + , DeclareVars lhsSh1 kSh1 valueSh1 <- declareVars $ shapeType shr + , DeclareVars lhsIn1 kIn1 valueIn1 <- declareVars $ buffersR tp1 + , DeclareVars lhsSh2 kSh2 valueSh2 <- declareVars $ shapeType shr + , DeclareVars lhsIn2 kIn2 valueIn2 <- declareVars $ buffersR tp2 + , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp3 -> + let + lhs1 = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh1) lhsIn1 + lhs2 = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh2) lhsIn2 + in + alet lhs1 (travA a1) + $ alet lhs2 (desugarOpenAcc (weakenBEnv (kIn1 .> kSh1) env) a2) + $ alet (mapLeftHandSide GroundRscalar lhsSh) (Compute $ undefined) -- intersect valueSh1 valueSh2 + $ alet lhsOut (desugarAlloc (ArrayR shr tp3) (valueSh weakenId)) + undefined + -- $ alet (LeftHandSideWildcard TupRunit) (mkStencil2 sr1 sr2 argB1 argA1 argB2 argA2) + -- TODO: + -- Replicate + -- Slice + -- ZipWith + -- Stencil2 + +data MaybeExpInfo env env' e where + MaybeExpInfo :: GLeftHandSide env env' t -> env :> env' -> OperationAcc op benv t -> Arg benv' (Maybe (Exp' e)) -> MaybeExpInfo env env' e + +desugarAlloc :: forall benv op sh a. ArrayR (Array sh a) -> ExpVars benv sh -> OperationAcc op benv (Buffers a) +desugarAlloc (ArrayR _ TupRunit ) _ = Return TupRunit +desugarAlloc (ArrayR shr (TupRpair t1 t2)) sh = desugarAlloc (ArrayR shr t1) sh `pair` desugarAlloc (ArrayR shr t2) sh +desugarAlloc (ArrayR shr (TupRsingle tp) ) sh + | Refl <- reprIsSingle @ScalarType @a @Buffer tp = Alloc shr tp sh + +desugarBoundary :: HasCallStack + => BEnv benv aenv + -> Named.Boundary aenv (Array sh e) + -> Boundary benv (Array sh e) +desugarBoundary _ Named.Clamp = Clamp +desugarBoundary _ Named.Mirror = Mirror +desugarBoundary _ Named.Wrap = Wrap +desugarBoundary _ (Named.Constant e) = Constant e +desugarBoundary env (Named.Function f) = Function $ desugarFun env f desugarOpenAfun :: (HasCallStack, DesugarAcc op) => BEnv benv aenv diff --git a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs index afb6cf034..0e0af36ce 100644 --- a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs +++ b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs @@ -132,5 +132,16 @@ pair a b = goA weakenId a alet :: IsExecutableAcc exe => GLeftHandSide t env env' -> PreOpenAcc exe env t -> PreOpenAcc exe env' s -> PreOpenAcc exe env s alet lhs1 (Alet lhs2 a1 a2) a3 | Exists lhs1' <- rebuildLHS lhs1 = Alet lhs2 a1 $ alet lhs1' a2 $ weaken (sinkWithLHS lhs1 lhs1' $ weakenWithLHS lhs2) a3 -alet lhs (Return vars) a = weaken (substituteLHS lhs vars) a -alet lhs bnd a = Alet lhs bnd a +alet (LeftHandSideWildcard TupRunit) (Return TupRunit) a = a +alet (LeftHandSideWildcard TupRunit) (Compute Nil) a = a +alet lhs@(LeftHandSideWildcard TupRunit) bnd a = Alet lhs bnd a +alet lhs (Return vars) a = weaken (substituteLHS lhs vars) a +alet lhs (Compute e) a + | Just vars <- extractParams e = weaken (substituteLHS lhs vars) a +alet lhs bnd a = Alet lhs bnd a + +extractParams :: OpenExp env benv t -> Maybe (ExpVars benv t) +extractParams Nil = Just TupRunit +extractParams (Pair e1 e2) = TupRpair <$> extractParams e1 <*> extractParams e2 +extractParams (ArrayInstr (Parameter v) _) = Just $ TupRsingle v +extractParams _ = Nothing From 2389d127f774401e792245678bca11a10a4dfa90 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Wed, 2 Sep 2020 10:42:32 +0200 Subject: [PATCH 005/813] Desugar slice, replicate, unzip --- src/Data/Array/Accelerate/AST/Operation.hs | 20 ++- .../Array/Accelerate/Representation/Slice.hs | 7 + src/Data/Array/Accelerate/Trafo/Desugar.hs | 133 ++++++++++++++++-- 3 files changed, 145 insertions(+), 15 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index 49e01dc4d..75e3e04f9 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -40,7 +40,7 @@ module Data.Array.Accelerate.AST.Operation ( bufferImpossible, groundFunctionImpossible, - paramIn, paramsIn, + paramIn, paramsIn, paramIn', paramsIn', IsExecutableAcc(..), ReindexPartial, reindexArg, reindexArgs, reindexExp, reindexVar, reindexVars, @@ -187,7 +187,7 @@ data PreArgs a t where -- data Arg env t where -- TODO: Do we need this? - ArgVars :: ExpVars env e -> Arg env (Var' e) + ArgVar :: ExpVars env e -> Arg env (Var' e) ArgExp :: Exp env e -> Arg env (Exp' e) @@ -226,7 +226,7 @@ data Out sh e where data Mut sh e where argVarType :: Arg env (Var' e) -> TypeR e -argVarType (ArgVars vars) = varsType vars +argVarType (ArgVar vars) = varsType vars argArrayR :: Arg env (m sh e) -> ArrayR (Array sh e) argArrayR (ArgArray _ repr _ _) = repr @@ -362,6 +362,14 @@ paramsIn (TupRpair t1 t2) (TupRpair v1 v2) = paramsIn t1 v1 `Pair` params paramsIn (TupRsingle t) (TupRsingle (Var _ ix)) = ArrayInstr (Parameter $ Var t ix) Nil paramsIn _ _ = internalError "Tuple mismatch" +paramIn' :: ExpVar benv e -> OpenExp env benv e +paramIn' v = ArrayInstr (Parameter v) Nil + +paramsIn' :: ExpVars benv e -> OpenExp env benv e +paramsIn' TupRunit = Nil +paramsIn' (TupRpair v1 v2) = paramsIn' v1 `Pair` paramsIn' v2 +paramsIn' (TupRsingle v) = ArrayInstr (Parameter v) Nil + type ReindexPartial f env env' = forall a. Idx env a -> f (Idx env' a) reindexVar :: Applicative f => ReindexPartial f env env' -> Var s env t -> f (Var s env' t) @@ -380,9 +388,9 @@ reindexExp :: (Applicative f, RebuildableExp e) => ReindexPartial f benv benv' - reindexExp k = rebuildArrayInstrPartial (rebuildArrayInstrMap $ reindexArrayInstr k) reindexArg :: Applicative f => ReindexPartial f env env' -> Arg env t -> f (Arg env' t) -reindexArg k (ArgVars vars) = ArgVars <$> reindexVars k vars -reindexArg k (ArgExp e) = ArgExp <$> reindexExp k e -reindexArg k (ArgFun f) = ArgFun <$> reindexExp k f +reindexArg k (ArgVar vars) = ArgVar <$> reindexVars k vars +reindexArg k (ArgExp e) = ArgExp <$> reindexExp k e +reindexArg k (ArgFun f) = ArgFun <$> reindexExp k f reindexArg k (ArgArray m repr sh buffers) = ArgArray m repr <$> reindexVars k sh <*> reindexVars k buffers reindexArgs :: Applicative f => ReindexPartial f env env' -> Args env t -> f (Args env' t) diff --git a/src/Data/Array/Accelerate/Representation/Slice.hs b/src/Data/Array/Accelerate/Representation/Slice.hs index 0cad1dc1b..6ee93ee47 100644 --- a/src/Data/Array/Accelerate/Representation/Slice.hs +++ b/src/Data/Array/Accelerate/Representation/Slice.hs @@ -19,6 +19,8 @@ module Data.Array.Accelerate.Representation.Slice where import Data.Array.Accelerate.Representation.Shape +import Data.Array.Accelerate.Representation.Type +import Data.Array.Accelerate.Type import Language.Haskell.TH @@ -72,6 +74,11 @@ sliceShape SliceNil () = () sliceShape (SliceAll sl) (sh, n) = (sliceShape sl sh, n) sliceShape (SliceFixed sl) (sh, _) = sliceShape sl sh +sliceEltR :: SliceIndex slix sl co dim -> TypeR slix +sliceEltR SliceNil = TupRunit +sliceEltR (SliceAll sl) = sliceEltR sl `TupRpair` TupRunit +sliceEltR (SliceFixed sl) = sliceEltR sl `TupRpair` TupRsingle scalarTypeInt + sliceShapeR :: SliceIndex slix sl co dim -> ShapeR sl sliceShapeR SliceNil = ShapeRz sliceShapeR (SliceAll sl) = ShapeRsnoc $ sliceShapeR sl diff --git a/src/Data/Array/Accelerate/Trafo/Desugar.hs b/src/Data/Array/Accelerate/Trafo/Desugar.hs index f4c70a4e0..020d46d99 100644 --- a/src/Data/Array/Accelerate/Trafo/Desugar.hs +++ b/src/Data/Array/Accelerate/Trafo/Desugar.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE EmptyCase #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} @@ -98,6 +99,20 @@ class DesugarAcc (op :: Type -> Type) where -> Arg env (Out sh t) -> OperationAcc op env () + mkReplicate :: SliceIndex slix sl co sh + -> Arg env (Var' slix) + -> Arg env (In sl e) + -> Arg env (Out sh e) + -> OperationAcc op env () + mkReplicate sliceIx slix = mkBackpermute (ArgFun $ extend sliceIx slix) + + mkSlice :: SliceIndex slix sl co sh + -> Arg env (Var' slix) + -> Arg env (In sh e) + -> Arg env (Out sl e) + -> OperationAcc op env () + mkSlice sliceIx slix = mkBackpermute (ArgFun $ restrict sliceIx slix) + mkPermute :: Arg env (Fun' (e -> e -> e)) -> Arg env (Mut sh' e) -> Arg env (Fun' (sh -> sh')) @@ -309,6 +324,14 @@ desugarOpenAcc env = travA $ alet lhsOut (desugarAlloc (ArrayR shrOut tpOut) (valueShOut weakenId)) $ alet (LeftHandSideWildcard TupRunit) (mkTransform argIdxF argValF argIn argOut) $ Return (shOut `TupRpair` bfOut) + + Named.Map _ (Lam lhs (Body e)) a + | Just vars <- extractExpVars e + , ArrayR shr oldTp <- Named.arrayR a + , DeclareVars lhsSh _ valueSh <- declareVars $ mapTupR GroundRscalar $ shapeType shr + , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR oldTp -> + alet (LeftHandSidePair lhsSh lhsIn) (travA a) + $ Return (valueSh kIn `TupRpair` desugarUnzip (valueIn weakenId) lhs vars) Named.Map tp f a | ArrayR shr oldTp <- Named.arrayR a @@ -347,6 +370,54 @@ desugarOpenAcc env = travA $ alet (LeftHandSideWildcard TupRunit) (mkBackpermute argF argIn argOut) $ Return (shOut `TupRpair` bfOut) + Named.Slice sliceIx a slix + | ArrayR shr tp <- Named.arrayR a + , slr <- sliceShapeR sliceIx + , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr + , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR tp + , DeclareVars lhsSlix kSlix valueSlix <- declareVars $ sliceEltR sliceIx + , DeclareVars lhsSl kSl valueSl <- declareVars $ shapeType slr + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp -> + let + lhs = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh) lhsIn + slix' = desugarExp (weakenBEnv (kIn .> kSh) env) slix + sh = mapVars GroundRscalar $ valueSh $ kOut .> kSl .> kSlix .> kIn + sl = mapVars GroundRscalar $ valueSl kOut + argSlix = ArgVar $ valueSlix $ kOut .> kSl + argIn = ArgArray In (ArrayR shr tp) sh (valueIn $ kOut .> kSl .> kSlix) + argOut = ArgArray Out (ArrayR slr tp) sl (valueOut weakenId) + in + alet lhs (travA a) + $ alet (mapLeftHandSide GroundRscalar lhsSlix) (Compute slix') + $ alet (mapLeftHandSide GroundRscalar lhsSl) (Compute $ IndexSlice sliceIx (paramsIn' $ valueSlix weakenId) (paramsIn' $ valueSh $ kSlix .> kIn)) + $ alet lhsOut (desugarAlloc (ArrayR slr tp) (valueSl weakenId)) + $ alet (LeftHandSideWildcard TupRunit) (mkSlice sliceIx argSlix argIn argOut) + $ Return (sl `TupRpair` valueOut weakenId) + + Named.Replicate sliceIx slix a + | ArrayR slr tp <- Named.arrayR a + , shr <- sliceDomainR sliceIx + , DeclareVars lhsSl kSl valueSl <- declareVars $ shapeType slr + , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR tp + , DeclareVars lhsSlix kSlix valueSlix <- declareVars $ sliceEltR sliceIx + , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp -> + let + lhs = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSl) lhsIn + slix' = desugarExp (weakenBEnv (kIn .> kSl) env) slix + sl = mapVars GroundRscalar $ valueSl $ kOut .> kSh .> kSlix .> kIn + sh = mapVars GroundRscalar $ valueSh kOut + argSlix = ArgVar $ valueSlix $ kOut .> kSh + argIn = ArgArray In (ArrayR slr tp) sl (valueIn $ kOut .> kSh .> kSlix) + argOut = ArgArray Out (ArrayR shr tp) sh (valueOut weakenId) + in + alet lhs (travA a) + $ alet (mapLeftHandSide GroundRscalar lhsSlix) (Compute slix') + $ alet (mapLeftHandSide GroundRscalar lhsSh) (Compute $ IndexFull sliceIx (paramsIn' $ valueSlix weakenId) (paramsIn' $ valueSl $ kSlix .> kIn)) + $ alet lhsOut (desugarAlloc (ArrayR shr tp) (valueSh weakenId)) + $ alet (LeftHandSideWildcard TupRunit) (mkReplicate sliceIx argSlix argIn argOut) + $ Return (sh `TupRpair` valueOut weakenId) + Named.Fold f def a | ArrayR (ShapeRsnoc shr) tp <- Named.arrayR a , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType $ ShapeRsnoc shr @@ -519,21 +590,28 @@ desugarOpenAcc env = travA let lhs1 = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh1) lhsIn1 lhs2 = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh2) lhsIn2 + sh = mapVars GroundRscalar $ valueSh kOut + sh1 = mapVars GroundRscalar $ valueSh1 (kOut .> kSh .> kIn2 .> kSh2 .> kIn1) + sh2 = mapVars GroundRscalar $ valueSh2 (kOut .> kSh .> kIn2) + env' = weakenBEnv (kOut .> kSh .> kIn2 .> kSh2 .> kIn1 .> kSh1) env + argF = ArgFun $ desugarFun env' f + b1' = desugarBoundary env' b1 + b2' = desugarBoundary env' b2 + argIn1 = ArgArray In (ArrayR shr tp1) sh1 (valueIn1 $ kOut .> kSh .> kIn2 .> kSh2) + argIn2 = ArgArray In (ArrayR shr tp2) sh2 (valueIn2 $ kOut .> kSh) + argOut = ArgArray Out (ArrayR shr tp3) sh (valueOut weakenId) in alet lhs1 (travA a1) $ alet lhs2 (desugarOpenAcc (weakenBEnv (kIn1 .> kSh1) env) a2) - $ alet (mapLeftHandSide GroundRscalar lhsSh) (Compute $ undefined) -- intersect valueSh1 valueSh2 + $ alet (mapLeftHandSide GroundRscalar lhsSh) (Compute $ mkIntersect shr (valueSh1 $ kIn2 .> kSh2 .> kIn1) (valueSh2 kIn2)) $ alet lhsOut (desugarAlloc (ArrayR shr tp3) (valueSh weakenId)) - undefined - -- $ alet (LeftHandSideWildcard TupRunit) (mkStencil2 sr1 sr2 argB1 argA1 argB2 argA2) + $ alet (LeftHandSideWildcard TupRunit) (mkStencil2 sr1 sr2 argF b1' argIn1 b2' argIn2 argOut) + $ Return (sh `TupRpair` valueOut weakenId) -- TODO: - -- Replicate - -- Slice + -- Use + -- Permute -- ZipWith - -- Stencil2 - -data MaybeExpInfo env env' e where - MaybeExpInfo :: GLeftHandSide env env' t -> env :> env' -> OperationAcc op benv t -> Arg benv' (Maybe (Exp' e)) -> MaybeExpInfo env env' e + -- Zip desugarAlloc :: forall benv op sh a. ArrayR (Array sh a) -> ExpVars benv sh -> OperationAcc op benv (Buffers a) desugarAlloc (ArrayR _ TupRunit ) _ = Return TupRunit @@ -628,6 +706,24 @@ weakenBEnv k = mapEnv f f :: ArrayDescriptor benv a -> ArrayDescriptor benv' a f (ArrayDescriptor sh buffers) = ArrayDescriptor (weakenVars k sh) (weakenVars k buffers) +desugarUnzip :: GroundVars benv (Buffers s) -> ELeftHandSide s () env -> ExpVars env t -> GroundVars benv (Buffers t) +desugarUnzip _ _ TupRunit = TupRunit +desugarUnzip buffers lhs (TupRpair v1 v2) = desugarUnzip buffers lhs v1 `TupRpair` desugarUnzip buffers lhs v2 +desugarUnzip buffers lhs (TupRsingle (Var _ idx)) = case lookupVar buffers lhs idx of + Right u -> u + Left ix' -> case ix' of {} + -- Left branch is unreachable, as `Idx () y` is an empty type + where + lookupVar :: GroundVars benv (Buffers x) -> ELeftHandSide x env1 env2 -> Idx env2 y -> Either (Idx env1 y) (GroundVars benv (Buffers y)) + lookupVar _ (LeftHandSideWildcard _) ix = Left ix + lookupVar buffers' (LeftHandSideSingle _) ix = case ix of + ZeroIdx -> Right buffers' + SuccIdx ix' -> Left ix' + lookupVar (TupRpair b1 b2) (LeftHandSidePair l1 l2) ix = case lookupVar b2 l2 ix of + Right u -> Right u + Left ix' -> lookupVar b1 l1 ix' + lookupVar _ _ _ = error "Impossible pair" + -- Utilities -- @@ -649,6 +745,20 @@ linearIndex (TupRsingle t) (TupRsingle var@(Var (GroundRbuffer _) _)) ix | Refl <- reprIsSingle @ScalarType @e @Buffer t = ArrayInstr (Index var) (Evar ix) linearIndex _ _ _ = internalError "Tuple mismatch" +extend :: SliceIndex slix sl co sh + -> Arg env (Var' slix) + -> Fun env (sh -> sl) +extend sliceIx (ArgVar slix) + | DeclareVars lhs _ value <- declareVars $ shapeType $ sliceDomainR sliceIx + = Lam lhs $ Body $ IndexSlice sliceIx (paramsIn' slix) $ expVars $ value weakenId + +restrict :: SliceIndex slix sl co sh + -> Arg env (Var' slix) + -> Fun env (sl -> sh) +restrict sliceIx (ArgVar slix) + | DeclareVars lhs _ value <- declareVars $ shapeType $ sliceShapeR sliceIx + = Lam lhs $ Body $ IndexFull sliceIx (paramsIn' slix) $ expVars $ value weakenId + desugarBoundaryToFunction :: forall benv sh e. Boundary benv (Array sh e) -> Arg benv (In sh e) -> Fun benv (sh -> e) desugarBoundaryToFunction boundary (ArgArray _ repr@(ArrayR shr tp) sh buffers) = case boundary of Function f -> f @@ -819,3 +929,8 @@ uncons (ShapeRsnoc shr) (TupRpair v1 v3) = let (i, v1') = uncons shr v1 in (i, TupRpair v1' v3) uncons _ _ = internalError "Illegal shape tuple" + +mkIntersect :: ShapeR sh -> ExpVars benv sh -> ExpVars benv sh -> PreOpenExp (ArrayInstr benv) env sh +mkIntersect ShapeRz _ _ = Nil +mkIntersect (ShapeRsnoc shr) (TupRpair s1 x1) (TupRpair s2 x2) = mkIntersect shr s1 s2 `Pair` mkBinary (PrimMin singleType) (paramsIn' x1) (paramsIn' x2) +mkIntersect (ShapeRsnoc _) _ _ = error "Impossible pair" From 63c8f3f421bd62a9103fdf9d6400d14bf9c78b2b Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Wed, 2 Sep 2020 16:50:55 +0200 Subject: [PATCH 006/813] Desugar permute, zip(With) --- src/Data/Array/Accelerate/AST/Operation.hs | 10 -- src/Data/Array/Accelerate/Trafo/Desugar.hs | 140 ++++++++++++++++-- .../Trafo/Operation/Substitution.hs | 1 - 3 files changed, 128 insertions(+), 23 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index 75e3e04f9..b90c6f596 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -128,15 +128,6 @@ data PreOpenAcc exe env a where Unit :: ExpVar env e -> PreOpenAcc exe env (Buffer e) - -- | Copies a buffer. This is used before passing a buffer to a 'Mut' argument, - -- to make sure it is unique. This may be removed during fusion to facilitate - -- in-place updates - -- - Clone :: ShapeR sh - -> ExpVars env sh - -> GroundVar env (Buffer e) - -> PreOpenAcc exe env (Buffer e) - -- | If-then-else for array-level computations -- Acond :: ExpVar env PrimBool @@ -260,7 +251,6 @@ instance HasGroundsR (PreOpenAcc exe env) where groundsR (Alloc _ tp _) = TupRsingle $ GroundRbuffer tp groundsR (Use tp _) = TupRsingle $ GroundRbuffer tp groundsR (Unit (Var tp _)) = TupRsingle $ GroundRbuffer tp - groundsR (Clone _ _ var) = groundsR var groundsR (Acond _ a _) = groundsR a groundsR (Awhile _ _ a) = groundsR a diff --git a/src/Data/Array/Accelerate/Trafo/Desugar.hs b/src/Data/Array/Accelerate/Trafo/Desugar.hs index 020d46d99..4f5b97570 100644 --- a/src/Data/Array/Accelerate/Trafo/Desugar.hs +++ b/src/Data/Array/Accelerate/Trafo/Desugar.hs @@ -3,6 +3,7 @@ {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE ViewPatterns #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} @@ -99,6 +100,34 @@ class DesugarAcc (op :: Type -> Type) where -> Arg env (Out sh t) -> OperationAcc op env () + -- Copies the contents of the (prefix of the) input to the output. + -- The size of the input array is smaller than or equal to the size output. + mkShrink :: Arg env (In sh t) + -> Arg env (Out sh t) + -> OperationAcc op env () + mkShrink input@(ArgArray _ (ArrayR shr _) _ _) output = mkBackpermute (ArgFun $ identity $ shapeType shr) input output + + -- Copies a buffer. This is used before passing a buffer to a 'Mut' argument, + -- to make sure it is unique. This may be removed during fusion to facilitate + -- in-place updates + -- TODO: Perform one map per buffer, instead of one for the whole array? + mkCopy :: Arg env (In sh t) + -> Arg env (Out sh t) + -> OperationAcc op env () + mkCopy input@(ArgArray _ (ArrayR _ tp) _ _) output = mkMap (ArgFun $ identity tp) input output + + mkZipWith :: Arg env (Fun' (e1 -> e2 -> e3)) + -> Arg env (In sh e1) + -> Arg env (In sh e2) + -> Arg env (Out sh e3) + -> OperationAcc op env () + mkZipWith (ArgFun f) (ArgArray _ repr1@(ArrayR shr _) sh1 buffers1) (ArgArray _ repr2 sh2 buffers2) output@(ArgArray _ (ArrayR _ tp) _ _) + | DeclareVars lhs _ value <- declareVars $ shapeType shr = + let + ix = expVars $ value weakenId + g = Lam lhs $ Body $ apply2 tp f (index repr1 sh1 buffers1 ix) (index repr2 sh2 buffers2 ix) + in mkGenerate (ArgFun g) output + mkReplicate :: SliceIndex slix sl co sh -> Arg env (Var' slix) -> Arg env (In sl e) @@ -115,7 +144,7 @@ class DesugarAcc (op :: Type -> Type) where mkPermute :: Arg env (Fun' (e -> e -> e)) -> Arg env (Mut sh' e) - -> Arg env (Fun' (sh -> sh')) + -> Arg env (Fun' (sh -> PrimMaybe sh')) -> Arg env (In sh e) -> OperationAcc op env () @@ -227,9 +256,6 @@ desugarOpenAcc env = travA travE :: Named.Exp aenv t -> Exp benv t travE = desugarExp env - travF :: Named.Fun aenv t -> Fun benv t - travF = desugarFun env - travA :: Named.OpenAcc aenv arr -> OperationAcc op benv (DesugaredArrays arr) travA (Named.OpenAcc acc) = case acc of Named.Alet lhs bnd a @@ -264,7 +290,7 @@ desugarOpenAcc env = travA f' = desugarOpenAfun env f i' = travA i in Awhile c' f' i' - Named.Use repr array -> undefined + Named.Use repr array -> undefined -- TODO: Desugar Use Named.Unit tp e | DeclareVars lhs _ value <- declareVars tp -> let @@ -291,6 +317,36 @@ desugarOpenAcc env = travA -- the corresponding mkXX function. -- + Named.Permute c def f src + | ArrayR shr' tp <- Named.arrayR def + , ArrayR shr _ <- Named.arrayR src + , DeclareVars lhsSh' kSh' valueSh' <- declareVars $ shapeType shr' + , DeclareVars lhsDef kDef valueDef <- declareVars $ buffersR tp + -- Clone defaults array, to make sure that it is unique. The clone may be removed in a later pass. + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp + , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr + , DeclareVars lhsSrc kSrc valueSrc <- declareVars $ buffersR tp -> + let + lhs' = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh') lhsDef + lhs = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh) lhsSrc + sh' = mapVars GroundRscalar $ valueSh' (kSrc .> kSh .> kOut .> kDef) + sh = mapVars GroundRscalar $ valueSh kSrc + env' = weakenBEnv (kSrc .> kSh .> kOut .> kDef .> kSh') env + valOut = valueOut $ kSrc .> kSh + argDef = ArgArray In (ArrayR shr' tp) sh' (valueDef $ kSrc .> kSh .> kOut) + argOut = ArgArray Out (ArrayR shr' tp) sh' valOut + argMut = ArgArray Mut (ArrayR shr' tp) sh' valOut + argSrc = ArgArray In (ArrayR shr tp) sh (valueSrc weakenId) + argC = ArgFun $ desugarFun env' c + argF = ArgFun $ desugarFun env' f + in + alet lhs' (travA def) + $ alet lhsOut (desugarAlloc (ArrayR shr' tp) (valueSh' kDef)) + $ alet lhs (desugarOpenAcc (weakenBEnv (kOut .> kDef .> kSh') env) src) + $ alet (LeftHandSideWildcard TupRunit) (mkCopy argDef argOut) + $ alet (LeftHandSideWildcard TupRunit) (mkPermute argC argMut argF argSrc) + $ Return (sh' `TupRpair` valOut) + Named.Generate (ArrayR shr tp) sh f | DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr , DeclareVars lhsBf kBf valueBf <- declareVars $ buffersR tp -> @@ -370,6 +426,65 @@ desugarOpenAcc env = travA $ alet (LeftHandSideWildcard TupRunit) (mkBackpermute argF argIn argOut) $ Return (shOut `TupRpair` bfOut) + -- Zip (or a combination of unzip & zip) + Named.ZipWith _ (Lam elhs1 (Lam elhs2 (Body e))) a1 a2 + | Just vars <- extractExpVars e + , ArrayR shr t1 <- Named.arrayR a1 + , ArrayR _ t2 <- Named.arrayR a2 + , DeclareVars lhsSh1 kSh1 valueSh1 <- declareVars $ shapeType shr + , DeclareVars lhsIn1 kIn1 valueIn1 <- declareVars $ buffersR t1 + , DeclareVars lhsSh2 kSh2 valueSh2 <- declareVars $ shapeType shr + , DeclareVars lhsIn2 kIn2 valueIn2 <- declareVars $ buffersR t2 + , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr + , DeclareVars lhsOut1 kOut1 valueOut1 <- declareVars $ buffersR t1 + , DeclareVars lhsOut2 kOut2 valueOut2 <- declareVars $ buffersR t2 -> + let + lhs1 = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh1) lhsIn1 + lhs2 = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh2) lhsIn2 + sh1 = mapVars GroundRscalar $ valueSh1 $ kOut2 .> kOut1 .> kSh .> kIn2 .> kSh2 .> kIn1 + sh2 = mapVars GroundRscalar $ valueSh2 $ kOut2 .> kOut1 .> kSh .> kIn2 + sh = mapVars GroundRscalar $ valueSh (kOut2 .> kOut1) + argIn1 = ArgArray In (ArrayR shr t1) sh1 (valueIn1 $ kOut2 .> kOut1 .> kSh .> kIn2 .> kSh2) + argIn2 = ArgArray In (ArrayR shr t2) sh2 (valueIn2 $ kOut2 .> kOut1 .> kSh) + argOut1 = ArgArray Out (ArrayR shr t1) sh (valueOut1 kOut2) + argOut2 = ArgArray Out (ArrayR shr t2) sh (valueOut2 weakenId) + in + alet lhs1 (travA a1) + $ alet lhs2 (desugarOpenAcc (weakenBEnv (kIn1 .> kSh1) env) a2) + $ alet (mapLeftHandSide GroundRscalar lhsSh) (Compute $ mkIntersect shr (valueSh1 $ kIn2 .> kSh2 .> kIn1) (valueSh2 kIn2)) + $ alet lhsOut1 (desugarAlloc (ArrayR shr t1) (valueSh weakenId)) + $ alet lhsOut2 (desugarAlloc (ArrayR shr t2) (valueSh kOut1)) + $ alet (LeftHandSideWildcard TupRunit) (mkShrink argIn1 argOut1) + $ alet (LeftHandSideWildcard TupRunit) (mkShrink argIn2 argOut2) + $ Return (sh `TupRpair` desugarUnzip (valueOut1 kOut2 `TupRpair` valueOut2 weakenId) (LeftHandSidePair elhs1 elhs2) vars) + + Named.ZipWith tp f a1 a2 + | ArrayR shr t1 <- Named.arrayR a1 + , ArrayR _ t2 <- Named.arrayR a2 + , DeclareVars lhsSh1 kSh1 valueSh1 <- declareVars $ shapeType shr + , DeclareVars lhsIn1 kIn1 valueIn1 <- declareVars $ buffersR t1 + , DeclareVars lhsSh2 kSh2 valueSh2 <- declareVars $ shapeType shr + , DeclareVars lhsIn2 kIn2 valueIn2 <- declareVars $ buffersR t2 + , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr + , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp -> + let + lhs1 = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh1) lhsIn1 + lhs2 = LeftHandSidePair (mapLeftHandSide GroundRscalar lhsSh2) lhsIn2 + sh1 = mapVars GroundRscalar $ valueSh1 $ kOut .> kSh .> kIn2 .> kSh2 .> kIn1 + sh2 = mapVars GroundRscalar $ valueSh2 $ kOut .> kSh .> kIn2 + sh = mapVars GroundRscalar $ valueSh kOut + argF = ArgFun $ desugarFun (weakenBEnv (kOut .> kSh .> kIn2 .> kSh2 .> kIn1 .> kSh1) env) f + argIn1 = ArgArray In (ArrayR shr t1) sh1 (valueIn1 $ kOut .> kSh .> kIn2 .> kSh2) + argIn2 = ArgArray In (ArrayR shr t2) sh2 (valueIn2 $ kOut .> kSh) + argOut = ArgArray Out (ArrayR shr tp) sh (valueOut weakenId) + in + alet lhs1 (travA a1) + $ alet lhs2 (desugarOpenAcc (weakenBEnv (kIn1 .> kSh1) env) a2) + $ alet (mapLeftHandSide GroundRscalar lhsSh) (Compute $ mkIntersect shr (valueSh1 $ kIn2 .> kSh2 .> kIn1) (valueSh2 kIn2)) + $ alet lhsOut (desugarAlloc (ArrayR shr tp) (valueSh weakenId)) + $ alet (LeftHandSideWildcard TupRunit) (mkZipWith argF argIn1 argIn2 argOut) + $ Return (sh `TupRpair` valueOut weakenId) + Named.Slice sliceIx a slix | ArrayR shr tp <- Named.arrayR a , slr <- sliceShapeR sliceIx @@ -419,7 +534,7 @@ desugarOpenAcc env = travA $ Return (sh `TupRpair` valueOut weakenId) Named.Fold f def a - | ArrayR (ShapeRsnoc shr) tp <- Named.arrayR a + | ArrayR (shapeInit -> shr) tp <- Named.arrayR a , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType $ ShapeRsnoc shr , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR tp , DeclareVars lhsOut kOut valueOut <- declareVars $ buffersR tp -> @@ -525,7 +640,7 @@ desugarOpenAcc env = travA $ Return (shOut `TupRpair` valueOut weakenId) Named.Scan' dir f def a - | ArrayR (ShapeRsnoc shr) tp <- Named.arrayR a + | ArrayR (shapeInit -> shr) tp <- Named.arrayR a , DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType $ ShapeRsnoc shr , DeclareVars lhsIn kIn valueIn <- declareVars $ buffersR tp -- The prefix values @@ -607,11 +722,6 @@ desugarOpenAcc env = travA $ alet lhsOut (desugarAlloc (ArrayR shr tp3) (valueSh weakenId)) $ alet (LeftHandSideWildcard TupRunit) (mkStencil2 sr1 sr2 argF b1' argIn1 b2' argIn2 argOut) $ Return (sh `TupRpair` valueOut weakenId) - -- TODO: - -- Use - -- Permute - -- ZipWith - -- Zip desugarAlloc :: forall benv op sh a. ArrayR (Array sh a) -> ExpVars benv sh -> OperationAcc op benv (Buffers a) desugarAlloc (ArrayR _ TupRunit ) _ = Return TupRunit @@ -759,6 +869,12 @@ restrict sliceIx (ArgVar slix) | DeclareVars lhs _ value <- declareVars $ shapeType $ sliceShapeR sliceIx = Lam lhs $ Body $ IndexFull sliceIx (paramsIn' slix) $ expVars $ value weakenId +-- Utility function to reduce the dimension by one. Defined as a function, +-- as doing pattern matching in the guards in desugarOpenAcc will cause +-- a false warning "pattern matches are non-exhaustive". +shapeInit :: ShapeR (sh, Int) -> ShapeR sh +shapeInit (ShapeRsnoc shr) = shr + desugarBoundaryToFunction :: forall benv sh e. Boundary benv (Array sh e) -> Arg benv (In sh e) -> Fun benv (sh -> e) desugarBoundaryToFunction boundary (ArgArray _ repr@(ArrayR shr tp) sh buffers) = case boundary of Function f -> f diff --git a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs index 0e0af36ce..ff3779280 100644 --- a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs +++ b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs @@ -96,7 +96,6 @@ reindexA' k = \case Alloc shr tp sh -> Alloc shr tp <$> reindexVars' k sh Use tp buffer -> pure $ Use tp buffer Unit var -> Unit <$> reindexVar' k var - Clone shr sh buffer -> Clone shr <$> reindexVars' k sh <*> reindexVar' k buffer Acond c t f -> Acond <$> reindexVar' k c <*> travA t <*> travA f Awhile c f i -> Awhile <$> reindexAfun' k c <*> reindexAfun' k f <*> travA i where From e8070128303dd8cdef176159d84ee3b723787a2e Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Thu, 3 Sep 2020 19:15:08 +0200 Subject: [PATCH 007/813] Buffers in Array instead of ArrayData, desugar Use --- .../Accelerate/Array/{Data.hs => Buffer.hs} | 290 +++++++++--------- .../Array/Accelerate/Array/Remote/Class.hs | 6 +- src/Data/Array/Accelerate/Array/Remote/LRU.hs | 51 ++- .../Array/Accelerate/Array/Remote/Table.hs | 58 ++-- src/Data/Array/Accelerate/Classes/Bounded.hs | 2 +- src/Data/Array/Accelerate/Data/Bits.hs | 2 +- .../Array/Accelerate/Representation/Array.hs | 70 ++--- .../Array/Accelerate/Representation/Type.hs | 2 + src/Data/Array/Accelerate/Trafo/Desugar.hs | 15 +- 9 files changed, 256 insertions(+), 240 deletions(-) rename src/Data/Array/Accelerate/Array/{Data.hs => Buffer.hs} (53%) diff --git a/src/Data/Array/Accelerate/Array/Data.hs b/src/Data/Array/Accelerate/Array/Buffer.hs similarity index 53% rename from src/Data/Array/Accelerate/Array/Data.hs rename to src/Data/Array/Accelerate/Array/Buffer.hs index 986b637de..cedef1b87 100644 --- a/src/Data/Array/Accelerate/Array/Data.hs +++ b/src/Data/Array/Accelerate/Array/Buffer.hs @@ -3,12 +3,13 @@ {-# LANGUAGE MagicHash #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UnboxedTuples #-} {-# LANGUAGE UndecidableInstances #-} {-# OPTIONS_HADDOCK hide #-} -- | --- Module : Data.Array.Accelerate.Array.Data +-- Module : Data.Array.Accelerate.Array.Buffer -- Copyright : [2008..2020] The Accelerate Team -- License : BSD3 -- @@ -22,16 +23,15 @@ -- pointers to an array's payload to foreign code. -- -module Data.Array.Accelerate.Array.Data ( +module Data.Array.Accelerate.Array.Buffer ( -- * Array operations and representations - ArrayData, MutableArrayData, ScalarArrayData, GArrayDataR, ScalarArrayDataR, - runArrayData, - newArrayData, - indexArrayData, readArrayData, writeArrayData, - unsafeArrayDataPtr, - touchArrayData, - rnfArrayData, + Buffers, Buffer(..), MutableBuffers, MutableBuffer(..), ScalarArrayDataR, + runBuffers, + newBuffers, newBuffer, + indexBuffers, indexBuffer, readBuffers, readBuffer, writeBuffers, writeBuffer, + touchBuffers, touchBuffer, touchMutableBuffers, touchMutableBuffer, + rnfBuffers, rnfBuffer, unsafeFreezeBuffer, unsafeFreezeBuffers, -- * Type macros HTYPE_INT, HTYPE_WORD, HTYPE_CLONG, HTYPE_CULONG, HTYPE_CCHAR, @@ -40,11 +40,10 @@ module Data.Array.Accelerate.Array.Data ( registerForeignPtrAllocator, -- * Utilities for type classes - ScalarArrayDict(..), scalarArrayDict, SingleArrayDict(..), singleArrayDict, -- * TemplateHaskell - liftArrayData, + liftBuffers, liftBuffer, ) where @@ -67,6 +66,7 @@ import Control.Monad ( (<=<) ) import Data.Bits import Data.IORef import Data.Primitive ( sizeOf# ) +import Data.Typeable ( (:~:)(..) ) import Foreign.ForeignPtr import Foreign.Storable import Language.Haskell.TH hiding ( Type ) @@ -78,25 +78,23 @@ import GHC.Base import GHC.ForeignPtr import GHC.Ptr - --- | Immutable array representation +-- | A buffer is a piece of memory representing one of the fields +-- of the SoA of an array. It does not have a multi-dimensional size, +-- e.g. the shape of the array should be stored elsewhere. +-- Replaces the former 'ScalarArrayData' type synonym. -- -type ArrayData e = MutableArrayData e +newtype Buffer e = Buffer (UniqueArray (ScalarArrayDataR e)) --- | Mutable array representation +-- | A structure of buffers represents an array, corresponding to the SoA conversion. +-- NOTE: We use a standard (non-strict) pair to enable lazy device-host data transfers. +-- Replaces the old 'ArrayData' and 'MutableArrayData' type aliasses and the +-- 'GArrayDataR' type family. -- -type MutableArrayData e = GArrayDataR UniqueArray e +type Buffers e = Distribute Buffer e --- | Underlying array representation. --- --- NOTE: We use a standard (non-strict) pair to enable lazy device-host data transfers --- -type family GArrayDataR ba a where - GArrayDataR ba () = () - GArrayDataR ba (a, b) = (GArrayDataR ba a, GArrayDataR ba b) - GArrayDataR ba a = ba (ScalarArrayDataR a) +newtype MutableBuffer e = MutableBuffer (UniqueArray (ScalarArrayDataR e)) -type ScalarArrayData a = UniqueArray (ScalarArrayDataR a) +type MutableBuffers e = Distribute MutableBuffer e -- | Mapping from scalar type to the type as represented in memory in an -- array. @@ -117,17 +115,18 @@ type family ScalarArrayDataR t where ScalarArrayDataR Double = Double ScalarArrayDataR (Vec n t) = ScalarArrayDataR t - +{- data ScalarArrayDict a where ScalarArrayDict :: ( ArrayData a ~ ScalarArrayData a, ScalarArrayDataR a ~ ScalarArrayDataR b ) => {-# UNPACK #-} !Int -- vector width -> SingleType b -- base type - -> ScalarArrayDict a + -> ScalarArrayDict a -} data SingleArrayDict a where - SingleArrayDict :: ( ArrayData a ~ ScalarArrayData a, ScalarArrayDataR a ~ a ) + SingleArrayDict :: ( Buffers a ~ Buffer a, ScalarArrayDataR a ~ a, Storable a ) => SingleArrayDict a +{- scalarArrayDict :: ScalarType a -> ScalarArrayDict a scalarArrayDict = scalar where @@ -140,7 +139,7 @@ scalarArrayDict = scalar vector :: VectorType a -> ScalarArrayDict a vector (VectorType w s) | SingleArrayDict <- singleArrayDict s - = ScalarArrayDict w s + = ScalarArrayDict w s -} singleArrayDict :: SingleType a -> SingleArrayDict a singleArrayDict = single @@ -173,42 +172,47 @@ singleArrayDict = single -- Array operations -- ---------------- -newArrayData :: HasCallStack => TupR ScalarType e -> Int -> IO (MutableArrayData e) -newArrayData TupRunit !_ = return () -newArrayData (TupRpair t1 t2) !size = (,) <$> newArrayData t1 size <*> newArrayData t2 size -newArrayData (TupRsingle t) !size - | SingleScalarType s <- t - , SingleDict <- singleDict s - , SingleArrayDict <- singleArrayDict s - = allocateArray size - -- - | VectorScalarType v <- t - , VectorType w s <- v - , SingleDict <- singleDict s - , SingleArrayDict <- singleArrayDict s - = allocateArray (w * size) - -indexArrayData :: TupR ScalarType e -> ArrayData e -> Int -> e -indexArrayData tR arr ix = unsafePerformIO $ readArrayData tR arr ix - -readArrayData :: forall e. TupR ScalarType e -> MutableArrayData e -> Int -> IO e -readArrayData TupRunit () !_ = return () -readArrayData (TupRpair t1 t2) (a1, a2) !ix = (,) <$> readArrayData t1 a1 ix <*> readArrayData t2 a2 ix -readArrayData (TupRsingle t) arr !ix - | SingleScalarType s <- t - , SingleDict <- singleDict s - , SingleArrayDict <- singleArrayDict s - = unsafeReadArray arr ix - -- - | VectorScalarType v <- t - , VectorType w s <- v - , I# w# <- w - , I# ix# <- ix - , SingleDict <- singleDict s - , SingleArrayDict <- singleArrayDict s +newBuffers :: forall e. HasCallStack => TypeR e -> Int -> IO (MutableBuffers e) +newBuffers TupRunit !_ = return () +newBuffers (TupRpair t1 t2) !size = (,) <$> newBuffers t1 size <*> newBuffers t2 size +newBuffers (TupRsingle t) !size + | Refl <- reprIsSingle @ScalarType @e @MutableBuffer t = newBuffer t size + +newBuffer :: HasCallStack => ScalarType e -> Int -> IO (MutableBuffer e) +newBuffer (SingleScalarType s) !size + | SingleDict <- singleDict s + , SingleArrayDict <- singleArrayDict s + = MutableBuffer <$> allocateArray size +newBuffer (VectorScalarType v) !size + | VectorType w s <- v + , SingleDict <- singleDict s + , SingleArrayDict <- singleArrayDict s + = MutableBuffer <$> allocateArray (w * size) + +indexBuffers :: TypeR e -> Buffers e -> Int -> e +indexBuffers tR arr ix = unsafePerformIO $ readBuffers tR (veryUnsafeUnfreezeBuffers tR arr) ix + +indexBuffer :: ScalarType e -> Buffer e -> Int -> e +indexBuffer tR (Buffer arr) ix = unsafePerformIO $ readBuffer tR (MutableBuffer arr) ix + +readBuffers :: forall e. TypeR e -> MutableBuffers e -> Int -> IO e +readBuffers TupRunit () !_ = return () +readBuffers (TupRpair t1 t2) (a1, a2) !ix = (,) <$> readBuffers t1 a1 ix <*> readBuffers t2 a2 ix +readBuffers (TupRsingle t) !buffer !ix + | Refl <- reprIsSingle @ScalarType @e @MutableBuffer t = readBuffer t buffer ix + +readBuffer :: forall e. ScalarType e -> MutableBuffer e -> Int -> IO e +readBuffer (SingleScalarType s) !(MutableBuffer array) !ix + | SingleDict <- singleDict s + , SingleArrayDict <- singleArrayDict s + = unsafeReadArray array ix +readBuffer (VectorScalarType v) !(MutableBuffer array) (I# ix#) + | VectorType (I# w#) s <- v + , SingleDict <- singleDict s + , SingleArrayDict <- singleArrayDict s = let !bytes# = w# *# sizeOf# (undefined :: ScalarArrayDataR e) - !addr# = unPtr# (unsafeUniqueArrayPtr arr) `plusAddr#` (ix# *# bytes#) + !addr# = unPtr# (unsafeUniqueArrayPtr array) `plusAddr#` (ix# *# bytes#) in IO $ \s0 -> case newByteArray# bytes# s0 of { (# s1, mba# #) -> @@ -217,66 +221,101 @@ readArrayData (TupRsingle t) arr !ix (# s3, Vec ba# #) }}} -writeArrayData :: forall e. TupR ScalarType e -> MutableArrayData e -> Int -> e -> IO () -writeArrayData TupRunit () !_ () = return () -writeArrayData (TupRpair t1 t2) (a1, a2) !ix (v1, v2) = writeArrayData t1 a1 ix v1 >> writeArrayData t2 a2 ix v2 -writeArrayData (TupRsingle t) arr !ix !val - | SingleScalarType s <- t - , SingleDict <- singleDict s - , SingleArrayDict <- singleArrayDict s +writeBuffers :: forall e. TypeR e -> MutableBuffers e -> Int -> e -> IO () +writeBuffers TupRunit () !_ () = return () +writeBuffers (TupRpair t1 t2) (a1, a2) !ix (v1, v2) = writeBuffers t1 a1 ix v1 >> writeBuffers t2 a2 ix v2 +writeBuffers (TupRsingle t) arr !ix !val + | Refl <- reprIsSingle @ScalarType @e @MutableBuffer t = writeBuffer t arr ix val + +writeBuffer :: forall e. ScalarType e -> MutableBuffer e -> Int -> e -> IO () +writeBuffer (SingleScalarType s) (MutableBuffer arr) !ix !val + | SingleDict <- singleDict s + , SingleArrayDict <- singleArrayDict s = unsafeWriteArray arr ix val - -- - | VectorScalarType v <- t - , VectorType w s <- v - , Vec ba# <- val - , I# w# <- w - , I# ix# <- ix - , SingleDict <- singleDict s - , SingleArrayDict <- singleArrayDict s +writeBuffer (VectorScalarType v) (MutableBuffer arr) (I# ix#) (Vec ba#) + | VectorType (I# w#) s <- v + , SingleDict <- singleDict s + , SingleArrayDict <- singleArrayDict s = let !bytes# = w# *# sizeOf# (undefined :: ScalarArrayDataR e) !addr# = unPtr# (unsafeUniqueArrayPtr arr) `plusAddr#` (ix# *# bytes#) in IO $ \s0 -> case copyByteArrayToAddr# ba# 0# addr# bytes# s0 of s1 -> (# s1, () #) - - +{- unsafeArrayDataPtr :: ScalarType e -> ArrayData e -> Ptr (ScalarArrayDataR e) unsafeArrayDataPtr t arr | ScalarArrayDict{} <- scalarArrayDict t - = unsafeUniqueArrayPtr arr + = unsafeUniqueArrayPtr arr-} -touchArrayData :: TupR ScalarType e -> ArrayData e -> IO () -touchArrayData TupRunit () = return () -touchArrayData (TupRpair t1 t2) (a1, a2) = touchArrayData t1 a1 >> touchArrayData t2 a2 -touchArrayData (TupRsingle t) arr - | ScalarArrayDict{} <- scalarArrayDict t - = touchUniqueArray arr +touchBuffers :: forall e. TypeR e -> Buffers e -> IO () +touchBuffers TupRunit () = return() +touchBuffers (TupRpair t1 t2) (b1, b2) = touchBuffers t1 b1 >> touchBuffers t2 b2 +touchBuffers (TupRsingle t) buffer + | Refl <- reprIsSingle @ScalarType @e @Buffer t = touchBuffer buffer + +touchMutableBuffers :: forall e. TypeR e -> MutableBuffers e -> IO () +touchMutableBuffers TupRunit () = return() +touchMutableBuffers (TupRpair t1 t2) (b1, b2) = touchMutableBuffers t1 b1 >> touchMutableBuffers t2 b2 +touchMutableBuffers (TupRsingle t) buffer + | Refl <- reprIsSingle @ScalarType @e @MutableBuffer t = touchMutableBuffer buffer + +touchBuffer :: Buffer e -> IO () +touchBuffer (Buffer arr) = touchUniqueArray arr + +touchMutableBuffer :: MutableBuffer e -> IO () +touchMutableBuffer (MutableBuffer arr) = touchUniqueArray arr -rnfArrayData :: TupR ScalarType e -> ArrayData e -> () -rnfArrayData TupRunit () = () -rnfArrayData (TupRpair t1 t2) (a1, a2) = rnfArrayData t1 a1 `seq` rnfArrayData t2 a2 `seq` () -rnfArrayData (TupRsingle t) arr = rnf (unsafeArrayDataPtr t arr) +rnfBuffers :: forall e. TypeR e -> Buffers e -> () +rnfBuffers TupRunit () = () +rnfBuffers (TupRpair t1 t2) (a1, a2) = rnfBuffers t1 a1 `seq` rnfBuffers t2 a2 +rnfBuffers (TupRsingle t) arr + | Refl <- reprIsSingle @ScalarType @e @Buffer t = rnfBuffer arr + +rnfBuffer :: Buffer e -> () +rnfBuffer (Buffer arr) = rnf (unsafeUniqueArrayPtr arr) unPtr# :: Ptr a -> Addr# unPtr# (Ptr addr#) = addr# -- | Safe combination of creating and fast freezing of array data. -- -runArrayData - :: IO (MutableArrayData e, e) - -> (ArrayData e, e) -runArrayData st = unsafePerformIO $ do - (mad, r) <- st - return (mad, r) - --- Allocate a new array with enough storage to hold the given number of +runBuffers + :: TypeR e + -> IO (MutableBuffers e, e) + -> (Buffers e, e) +runBuffers tp st = unsafePerformIO $ do + (mbuffer, r) <- st + let buffer = unsafeFreezeBuffers tp mbuffer + return (buffer, r) + +unsafeFreezeBuffers :: forall e. TypeR e -> MutableBuffers e -> Buffers e +unsafeFreezeBuffers TupRunit () = () +unsafeFreezeBuffers (TupRpair t1 t2) (b1, b2) = (unsafeFreezeBuffers t1 b1, unsafeFreezeBuffers t2 b2) +unsafeFreezeBuffers (TupRsingle t) buffer + | Refl <- reprIsSingle @ScalarType @e @MutableBuffer t + , Refl <- reprIsSingle @ScalarType @e @Buffer t = unsafeFreezeBuffer buffer + +unsafeFreezeBuffer :: MutableBuffer e -> Buffer e +unsafeFreezeBuffer (MutableBuffer arr) = Buffer arr + +veryUnsafeUnfreezeBuffers :: forall e. TypeR e -> Buffers e -> MutableBuffers e +veryUnsafeUnfreezeBuffers TupRunit () = () +veryUnsafeUnfreezeBuffers (TupRpair t1 t2) (b1, b2) = (veryUnsafeUnfreezeBuffers t1 b1, veryUnsafeUnfreezeBuffers t2 b2) +veryUnsafeUnfreezeBuffers (TupRsingle t) buffer + | Refl <- reprIsSingle @ScalarType @e @MutableBuffer t + , Refl <- reprIsSingle @ScalarType @e @Buffer t = veryUnsafeUnfreezeBuffer buffer + +veryUnsafeUnfreezeBuffer :: Buffer e -> MutableBuffer e +veryUnsafeUnfreezeBuffer (Buffer arr) = MutableBuffer arr + +-- Allocate a new buffer with enough storage to hold the given number of -- elements. -- --- The array is uninitialised and, in particular, allocated lazily. The latter +-- The buffer is uninitialised and, in particular, allocated lazily. The latter -- is important because it means that for backends that have discrete memory -- spaces (e.g. GPUs), we will not increase host memory pressure simply to track --- intermediate arrays that contain meaningful data only on the device. +-- intermediate buffers that contain meaningful data only on the device. -- allocateArray :: forall e. (HasCallStack, Storable e) => Int -> IO (UniqueArray e) allocateArray !size @@ -319,46 +358,17 @@ mallocPlainForeignPtrBytesAligned (I# size) = IO $ \s -> (# s', mbarr# #) -> (# s', ForeignPtr (byteArrayContents# (unsafeCoerce# mbarr#)) (PlainPtr mbarr#) #) -liftArrayData :: Int -> TypeR e -> ArrayData e -> Q (TExp (ArrayData e)) -liftArrayData n = tuple - where - tuple :: TypeR e -> ArrayData e -> Q (TExp (ArrayData e)) - tuple TupRunit () = [|| () ||] - tuple (TupRpair t1 t2) (a1, a2) = [|| ($$(tuple t1 a1), $$(tuple t2 a2)) ||] - tuple (TupRsingle s) adata = scalar s adata - - scalar :: ScalarType e -> ArrayData e -> Q (TExp (ArrayData e)) - scalar (SingleScalarType t) = single t - scalar (VectorScalarType t) = vector t - - vector :: forall n e. VectorType (Vec n e) -> ArrayData (Vec n e) -> Q (TExp (ArrayData (Vec n e))) - vector (VectorType w t) - | SingleArrayDict <- singleArrayDict t - = liftArrayData (w * n) (TupRsingle (SingleScalarType t)) - - single :: SingleType e -> ArrayData e -> Q (TExp (ArrayData e)) - single (NumSingleType t) = num t - - num :: NumType e -> ArrayData e -> Q (TExp (ArrayData e)) - num (IntegralNumType t) = integral t - num (FloatingNumType t) = floating t +liftBuffers :: forall e. Int -> TypeR e -> Buffers e -> Q (TExp (Buffers e)) +liftBuffers _ TupRunit () = [|| () ||] +liftBuffers n (TupRpair t1 t2) (b1, b2) = [|| ($$(liftBuffers n t1 b1), $$(liftBuffers n t2 b2)) ||] +liftBuffers n (TupRsingle s) buffer + | Refl <- reprIsSingle @ScalarType @e @Buffer s = liftBuffer n s buffer - integral :: IntegralType e -> ArrayData e -> Q (TExp (ArrayData e)) - integral TypeInt = liftUniqueArray n - integral TypeInt8 = liftUniqueArray n - integral TypeInt16 = liftUniqueArray n - integral TypeInt32 = liftUniqueArray n - integral TypeInt64 = liftUniqueArray n - integral TypeWord = liftUniqueArray n - integral TypeWord8 = liftUniqueArray n - integral TypeWord16 = liftUniqueArray n - integral TypeWord32 = liftUniqueArray n - integral TypeWord64 = liftUniqueArray n - - floating :: FloatingType e -> ArrayData e -> Q (TExp (ArrayData e)) - floating TypeHalf = liftUniqueArray n - floating TypeFloat = liftUniqueArray n - floating TypeDouble = liftUniqueArray n +liftBuffer :: forall e. Int -> ScalarType e -> Buffer e -> Q (TExp (Buffer e)) +liftBuffer n (VectorScalarType (VectorType w t)) (Buffer arr) + | SingleArrayDict <- singleArrayDict t = [|| Buffer $$(liftUniqueArray (n * w) arr) ||] +liftBuffer n (SingleScalarType t) (Buffer arr) + | SingleArrayDict <- singleArrayDict t = [|| Buffer $$(liftUniqueArray n arr) ||] -- Determine the underlying type of a Haskell CLong or CULong. -- diff --git a/src/Data/Array/Accelerate/Array/Remote/Class.hs b/src/Data/Array/Accelerate/Array/Remote/Class.hs index 7a871bd1a..bc3aed5cb 100644 --- a/src/Data/Array/Accelerate/Array/Remote/Class.hs +++ b/src/Data/Array/Accelerate/Array/Remote/Class.hs @@ -31,7 +31,7 @@ module Data.Array.Accelerate.Array.Remote.Class ( ) where -import Data.Array.Accelerate.Array.Data +import Data.Array.Accelerate.Array.Buffer import Data.Array.Accelerate.Type import Control.Applicative @@ -54,10 +54,10 @@ class (Applicative m, Monad m, MonadCatch m, MonadMask m) => RemoteMemory m wher mallocRemote :: Int -> m (Maybe (RemotePtr m Word8)) -- | Copy the given number of elements from the host array into remote memory. - pokeRemote :: SingleType e -> Int -> RemotePtr m (ScalarArrayDataR e) -> ArrayData e -> m () + pokeRemote :: SingleType e -> Int -> RemotePtr m (ScalarArrayDataR e) -> Buffer e -> m () -- | Copy the given number of elements from remote memory to the host array. - peekRemote :: SingleType e -> Int -> RemotePtr m (ScalarArrayDataR e) -> MutableArrayData e -> m () + peekRemote :: SingleType e -> Int -> RemotePtr m (ScalarArrayDataR e) -> MutableBuffer e -> m () -- | Cast a remote pointer. castRemotePtr :: RemotePtr m a -> RemotePtr m b diff --git a/src/Data/Array/Accelerate/Array/Remote/LRU.hs b/src/Data/Array/Accelerate/Array/Remote/LRU.hs index 633ddc06d..13b716879 100644 --- a/src/Data/Array/Accelerate/Array/Remote/LRU.hs +++ b/src/Data/Array/Accelerate/Array/Remote/LRU.hs @@ -37,10 +37,9 @@ module Data.Array.Accelerate.Array.Remote.LRU ( ) where import Data.Array.Accelerate.Analysis.Match ( matchSingleType, (:~:)(..) ) -import Data.Array.Accelerate.Array.Data +import Data.Array.Accelerate.Array.Buffer import Data.Array.Accelerate.Array.Remote.Class -import Data.Array.Accelerate.Array.Remote.Table ( StableArray, makeWeakArrayData ) -import Data.Array.Accelerate.Array.Unique ( touchUniqueArray ) +import Data.Array.Accelerate.Array.Remote.Table ( StableBuffer, makeWeakArrayData ) import Data.Array.Accelerate.Error ( internalError ) import Data.Array.Accelerate.Representation.Elt import Data.Array.Accelerate.Representation.Type @@ -75,7 +74,7 @@ data MemoryTable p task = MemoryTable {-# UNPACK #-} !(Basic.MemoryTable p) {-# UNPACK #-} !(UseTable task) {-# UNPACK #-} !(Weak (UseTable task)) -type UT task = HT.CuckooHashTable StableArray (Used task) +type UT task = HT.CuckooHashTable StableBuffer (Used task) type UseTable task = MVar (UT task) data Status = Clean -- Array in remote memory matches array in host memory. @@ -88,14 +87,14 @@ data Status = Clean -- Array in remote memory matches array in host memory. type Timestamp = Integer data Used task where - Used :: ArrayData e ~ ScalarArrayData e + Used :: Buffers e ~ Buffer e => !Timestamp -> !Status -> {-# UNPACK #-} !Int -- Use count -> ![task] -- Asynchronous tasks using the array -> {-# UNPACK #-} !Int -- Number of elements -> !(SingleType e) - -> {-# UNPACK #-} !(Weak (ScalarArrayData e)) + -> {-# UNPACK #-} !(Weak (MutableBuffer e)) -> Used task -- | A Task represents a process executing asynchronously that can be polled for @@ -141,11 +140,11 @@ withRemote :: forall task m a c. (HasCallStack, Task task, RemoteMemory m, MonadIO m, Functor m) => MemoryTable (RemotePtr m) task -> SingleType a - -> ArrayData a + -> MutableBuffer a -> (RemotePtr m (ScalarArrayDataR a) -> m (task, c)) -> m (Maybe c) withRemote (MemoryTable !mt !ref _) !tp !arr run | SingleArrayDict <- singleArrayDict tp = do - key <- Basic.makeStableArray tp arr + key <- Basic.makeStableBuffer tp arr mp <- withMVar' ref $ \utbl -> do mu <- liftIO . HT.mutate utbl key $ \case Nothing -> (Nothing, Nothing) @@ -181,7 +180,7 @@ withRemote (MemoryTable !mt !ref _) !tp !arr run | SingleArrayDict <- singleArra | Just Refl <- matchSingleType tp tp' = do message "withRemote/reuploading-evicted-array" p <- mallocWithUsage mt utbl tp arr (Used ts Clean count tasks n tp weak_arr) - pokeRemote tp n p arr + pokeRemote tp n p (unsafeFreezeBuffer arr) return p | otherwise = internalError "Type mismatch" @@ -189,8 +188,8 @@ withRemote (MemoryTable !mt !ref _) !tp !arr run | SingleArrayDict <- singleArra -- because the `permute` operation from the PTX backend requires nested -- calls to `withRemote` in order to copy the defaults array. -- - go :: (HasCallStack, ArrayData a ~ ScalarArrayData a) - => StableArray + go :: (HasCallStack, Buffer a ~ Buffers a) + => StableBuffer -> RemotePtr m (ScalarArrayDataR a) -> m c go key ptr = do @@ -203,7 +202,7 @@ withRemote (MemoryTable !mt !ref _) !tp !arr run | SingleArrayDict <- singleArra u' <- updateTask u task return (Just u', ()) -- - touchUniqueArray arr + touchMutableBuffer arr return c @@ -225,13 +224,13 @@ withRemote (MemoryTable !mt !ref _) !tp !arr run | SingleArrayDict <- singleArra malloc :: forall e m task. (HasCallStack, RemoteMemory m, MonadIO m, Task task) => MemoryTable (RemotePtr m) task -> SingleType e - -> ArrayData e + -> MutableBuffer e -> Bool -- ^ True if host array is frozen. -> Int -- ^ Number of elements -> m Bool -- ^ Was the array allocated successfully? -malloc (MemoryTable mt ref weak_utbl) !tp !ad !frozen !n | SingleArrayDict <- singleArrayDict tp = do -- Required for ArrayData e ~ ScalarArrayData e +malloc (MemoryTable mt ref weak_utbl) !tp !ad !frozen !n | SingleArrayDict <- singleArrayDict tp = do -- Required for Buffer e ~ Buffers e ts <- liftIO $ getCPUTime - key <- Basic.makeStableArray tp ad + key <- Basic.makeStableBuffer tp ad -- let status = if frozen then Clean @@ -248,11 +247,11 @@ malloc (MemoryTable mt ref weak_utbl) !tp !ad !frozen !n | SingleArrayDict <- si return False mallocWithUsage - :: forall e m task. (HasCallStack, RemoteMemory m, MonadIO m, Task task, ArrayData e ~ ScalarArrayData e) + :: forall e m task. (HasCallStack, RemoteMemory m, MonadIO m, Task task, Buffers e ~ Buffer e) => Basic.MemoryTable (RemotePtr m) -> UT task -> SingleType e - -> ArrayData e + -> MutableBuffer e -> Used task -> m (RemotePtr m (ScalarArrayDataR e)) mallocWithUsage !mt !utbl !tp !ad !usage@(Used _ _ _ _ n _ _) = malloc' @@ -266,7 +265,7 @@ mallocWithUsage !mt !utbl !tp !ad !usage@(Used _ _ _ _ n _ _) = malloc' if success then malloc' else internalError "Remote memory exhausted" Just p -> liftIO $ do - key <- Basic.makeStableArray tp ad + key <- Basic.makeStableBuffer tp ad HT.insert utbl key usage return p @@ -303,7 +302,7 @@ evictLRU !utbl !mt = trace "evictLRU/evicting-eldest-array" $ do _ -> trace "evictLRU/All arrays in use, unable to evict" $ return False where -- Find the eldest, not currently in use, array. - eldest :: (Maybe (StableArray, Used task)) -> (StableArray, Used task) -> IO (Maybe (StableArray, Used task)) + eldest :: (Maybe (StableBuffer, Used task)) -> (StableBuffer, Used task) -> IO (Maybe (StableBuffer, Used task)) eldest prev (sa, used@(Used ts status count tasks n tp weak_arr)) | count == 0 , evictable status @@ -326,7 +325,7 @@ evictLRU !utbl !mt = trace "evictLRU/evicting-eldest-array" $ do evictable Unmanaged = False evictable Evicted = False - copyIfNecessary :: Status -> Int -> SingleType e -> ArrayData e -> m () + copyIfNecessary :: Status -> Int -> SingleType e -> MutableBuffer e -> m () copyIfNecessary Clean _ _ _ = return () copyIfNecessary Unmanaged _ _ _ = return () copyIfNecessary Evicted _ _ _ = internalError "Attempting to evict already evicted array" @@ -343,12 +342,12 @@ evictLRU !utbl !mt = trace "evictLRU/evicting-eldest-array" $ do free :: forall m a task. (HasCallStack, RemoteMemory m) => MemoryTable (RemotePtr m) task -> SingleType a - -> ArrayData a + -> MutableBuffer a -> IO () free (MemoryTable !mt !ref _) !tp !arr = withMVar' ref $ \utbl -> do - key <- Basic.makeStableArray tp arr + key <- Basic.makeStableBuffer tp arr delete utbl key Basic.freeStable @m mt key @@ -362,11 +361,11 @@ insertUnmanaged :: (HasCallStack, MonadIO m, RemoteMemory m) => MemoryTable (RemotePtr m) task -> SingleType e - -> ArrayData e + -> MutableBuffer e -> RemotePtr m (ScalarArrayDataR e) -> m () insertUnmanaged (MemoryTable mt ref weak_utbl) !tp !arr !ptr | SingleArrayDict <- singleArrayDict tp = do -- Gives evidence that ArrayData e ~ ScalarArrayData e - key <- Basic.makeStableArray tp arr + key <- Basic.makeStableBuffer tp arr () <- Basic.insertUnmanaged mt tp arr ptr liftIO $ withMVar ref @@ -379,14 +378,14 @@ insertUnmanaged (MemoryTable mt ref weak_utbl) !tp !arr !ptr | SingleArrayDict < -- Removing entries -- ---------------- -finalizer :: StableArray -> Weak (UseTable task) -> IO () +finalizer :: StableBuffer -> Weak (UseTable task) -> IO () finalizer !key !weak_utbl = do mref <- deRefWeak weak_utbl case mref of Nothing -> message "finalize cache/dead table" Just ref -> trace ("finalize cache: " ++ show key) $ withMVar' ref (`delete` key) -delete :: UT task -> StableArray -> IO () +delete :: UT task -> StableBuffer -> IO () delete = HT.delete diff --git a/src/Data/Array/Accelerate/Array/Remote/Table.hs b/src/Data/Array/Accelerate/Array/Remote/Table.hs index 3e95d3222..dccae381c 100644 --- a/src/Data/Array/Accelerate/Array/Remote/Table.hs +++ b/src/Data/Array/Accelerate/Array/Remote/Table.hs @@ -34,7 +34,7 @@ module Data.Array.Accelerate.Array.Remote.Table ( MemoryTable, new, lookup, malloc, free, freeStable, insertUnmanaged, reclaim, -- Internals - StableArray, makeStableArray, + StableBuffer, makeStableBuffer, makeWeakArrayData, ) where @@ -57,7 +57,7 @@ import qualified Data.HashTable.IO as HT import Data.Array.Accelerate.Error ( internalError ) import Data.Array.Accelerate.Type import Data.Array.Accelerate.Array.Unique ( UniqueArray(..) ) -import Data.Array.Accelerate.Array.Data +import Data.Array.Accelerate.Array.Buffer import Data.Array.Accelerate.Array.Remote.Class import Data.Array.Accelerate.Array.Remote.Nursery ( Nursery(..) ) import Data.Array.Accelerate.Lifetime @@ -81,7 +81,7 @@ import GHC.Stack -- semantics of weak pointers in the documentation). -- type HashTable key val = HT.CuckooHashTable key val -type MT p = MVar ( HashTable StableArray (RemoteArray p) ) +type MT p = MVar ( HashTable StableBuffer (RemoteArray p) ) data MemoryTable p = MemoryTable {-# UNPACK #-} !(MT p) {-# UNPACK #-} !(Weak (MT p)) {-# UNPACK #-} !(Nursery p) @@ -93,13 +93,13 @@ data RemoteArray p where -> {-# UNPACK #-} !(Weak ()) -- Keep track of host array liveness -> RemoteArray p --- | An untyped reference to an array, similar to a StableName. +-- | An untyped reference to a buffer, similar to a StableName. -- -newtype StableArray = StableArray Unique +newtype StableBuffer = StableBuffer Unique deriving (Eq, Hashable) -instance Show StableArray where - show (StableArray u) = show (hash u) +instance Show StableBuffer where + show (StableBuffer u) = show (hash u) -- | Create a new memory table from host to remote arrays. -- @@ -123,11 +123,11 @@ new release = do lookup :: forall m a. (HasCallStack, RemoteMemory m) => MemoryTable (RemotePtr m) -> SingleType a - -> ArrayData a + -> MutableBuffer a -> IO (Maybe (RemotePtr m (ScalarArrayDataR a))) lookup (MemoryTable !ref _ _ _) !tp !arr | SingleArrayDict <- singleArrayDict tp = do - sa <- makeStableArray tp arr + sa <- makeStableBuffer tp arr mw <- withMVar ref (`HT.lookup` sa) case mw of Nothing -> trace ("lookup/not found: " ++ show sa) $ return Nothing @@ -149,7 +149,7 @@ lookup (MemoryTable !ref _ _ _) !tp !arr -- above in the error message. -- Nothing -> - makeStableArray tp arr >>= \x -> internalError $ "dead weak pair: " ++ show x + makeStableBuffer tp arr >>= \x -> internalError $ "dead weak pair: " ++ show x -- | Allocate a new device array to be associated with the given host-side array. -- This may not always use the `malloc` provided by the `RemoteMemory` instance. @@ -160,7 +160,7 @@ lookup (MemoryTable !ref _ _ _) !tp !arr malloc :: forall a m. (HasCallStack, RemoteMemory m, MonadIO m) => MemoryTable (RemotePtr m) -> SingleType a - -> ArrayData a + -> MutableBuffer a -> Int -> m (Maybe (RemotePtr m (ScalarArrayDataR a))) malloc mt@(MemoryTable _ _ !nursery _) !tp !ad !n @@ -224,20 +224,20 @@ malloc mt@(MemoryTable _ _ !nursery _) !tp !ad !n free :: forall m a. (RemoteMemory m) => MemoryTable (RemotePtr m) -> SingleType a - -> ArrayData a + -> MutableBuffer a -> IO () free mt tp !arr = do - sa <- makeStableArray tp arr + sa <- makeStableBuffer tp arr freeStable @m mt sa --- | Deallocate the device array associated with the given StableArray. This +-- | Deallocate the device array associated with the given StableBuffer. This -- is useful for other memory managers built on top of the memory table. -- freeStable :: forall m. RemoteMemory m => MemoryTable (RemotePtr m) - -> StableArray + -> StableBuffer -> IO () freeStable (MemoryTable !ref _ !nrs _) !sa = withMVar ref $ \mt -> @@ -262,12 +262,12 @@ insert :: forall m a. (RemoteMemory m, MonadIO m) => MemoryTable (RemotePtr m) -> SingleType a - -> ArrayData a + -> MutableBuffer a -> RemotePtr m (ScalarArrayDataR a) -> Int -> m () insert mt@(MemoryTable !ref _ _ _) !tp !arr !ptr !bytes | SingleArrayDict <- singleArrayDict tp = do - key <- makeStableArray tp arr + key <- makeStableBuffer tp arr weak <- liftIO $ makeWeakArrayData tp arr () (Just $ freeStable @m mt key) message $ "insert: " ++ show key liftIO $ D.increaseCurrentBytesRemote (fromIntegral bytes) @@ -284,11 +284,11 @@ insertUnmanaged :: forall m a. (MonadIO m, RemoteMemory m) => MemoryTable (RemotePtr m) -> SingleType a - -> ArrayData a + -> MutableBuffer a -> RemotePtr m (ScalarArrayDataR a) -> m () insertUnmanaged (MemoryTable !ref !weak_ref _ _) tp !arr !ptr | SingleArrayDict <- singleArrayDict tp = do - key <- makeStableArray tp arr + key <- makeStableBuffer tp arr weak <- liftIO $ makeWeakArrayData tp arr () (Just $ remoteFinalizer weak_ref key) message $ "insertUnmanaged: " ++ show key liftIO $ withMVar ref $ \tbl -> HT.insert tbl key (RemoteArray (castRemotePtr @m ptr) 0 weak) @@ -340,7 +340,7 @@ purge (MemoryTable _ _ nursery@(Nursery nrs _) release) reclaim :: forall m. (RemoteMemory m, MonadIO m) => MemoryTable (RemotePtr m) -> m () reclaim mt = clean mt >> purge mt -remoteFinalizer :: Weak (MT p) -> StableArray -> IO () +remoteFinalizer :: Weak (MT p) -> StableBuffer -> IO () remoteFinalizer !weak_ref !key = do mr <- deRefWeak weak_ref case mr of @@ -351,17 +351,17 @@ remoteFinalizer !weak_ref !key = do -- Miscellaneous -- ------------- --- | Make a new 'StableArray'. +-- | Make a new 'StableBuffer'. -- -{-# INLINE makeStableArray #-} -makeStableArray +{-# INLINE makeStableBuffer #-} +makeStableBuffer :: MonadIO m => SingleType a - -> ArrayData a - -> m StableArray -makeStableArray !tp !ad + -> MutableBuffer a + -> m StableBuffer +makeStableBuffer !tp !(MutableBuffer ad) | SingleArrayDict <- singleArrayDict tp - = return $! StableArray (uniqueArrayId ad) + = return $! StableBuffer (uniqueArrayId ad) -- Weak arrays @@ -373,11 +373,11 @@ makeStableArray !tp !ad makeWeakArrayData :: forall e c. SingleType e - -> ArrayData e + -> MutableBuffer e -> c -> Maybe (IO ()) -> IO (Weak c) -makeWeakArrayData !tp !ad !c !mf | SingleArrayDict <- singleArrayDict tp = do +makeWeakArrayData !tp !(MutableBuffer ad) !c !mf | SingleArrayDict <- singleArrayDict tp = do let !uad = uniqueArrayData ad case mf of Nothing -> return () diff --git a/src/Data/Array/Accelerate/Classes/Bounded.hs b/src/Data/Array/Accelerate/Classes/Bounded.hs index 16b5d6d2a..17a9ab503 100644 --- a/src/Data/Array/Accelerate/Classes/Bounded.hs +++ b/src/Data/Array/Accelerate/Classes/Bounded.hs @@ -21,7 +21,7 @@ module Data.Array.Accelerate.Classes.Bounded ( ) where -import Data.Array.Accelerate.Array.Data +import Data.Array.Accelerate.Array.Buffer import Data.Array.Accelerate.Pattern import Data.Array.Accelerate.Smart import Data.Array.Accelerate.Sugar.Elt diff --git a/src/Data/Array/Accelerate/Data/Bits.hs b/src/Data/Array/Accelerate/Data/Bits.hs index 19a2890ce..5a05ae990 100644 --- a/src/Data/Array/Accelerate/Data/Bits.hs +++ b/src/Data/Array/Accelerate/Data/Bits.hs @@ -24,7 +24,7 @@ module Data.Array.Accelerate.Data.Bits ( ) where -import Data.Array.Accelerate.Array.Data +import Data.Array.Accelerate.Array.Buffer import Data.Array.Accelerate.Language import Data.Array.Accelerate.Smart import Data.Array.Accelerate.Sugar.Elt diff --git a/src/Data/Array/Accelerate/Representation/Array.hs b/src/Data/Array/Accelerate/Representation/Array.hs index cda484a9e..28f3629b2 100644 --- a/src/Data/Array/Accelerate/Representation/Array.hs +++ b/src/Data/Array/Accelerate/Representation/Array.hs @@ -18,9 +18,10 @@ -- module Data.Array.Accelerate.Representation.Array + ( module Data.Array.Accelerate.Representation.Array, Buffer, Buffers ) where -import Data.Array.Accelerate.Array.Data +import Data.Array.Accelerate.Array.Buffer import Data.Array.Accelerate.Error import Data.Array.Accelerate.Type import Data.Array.Accelerate.Representation.Elt @@ -40,12 +41,9 @@ import qualified Data.Vector.Unboxed as U -- data Array sh e where Array :: sh -- extent of dimensions = shape - -> ArrayData e -- array payload + -> Buffers e -- array payload -> Array sh e -newtype Buffer e = Buffer (ScalarArrayData e) - -type Buffers e = Distribute Buffer e -- | Segment descriptor (vector of segment lengths). -- @@ -68,7 +66,7 @@ data ArrayR a where -> ArrayR (Array sh e) instance Show (ArrayR a) where - show (ArrayR shR eR) = "Array DIM" ++ show (rank shR) ++ " " ++ show eR + show (ArrayR shR tp) = "Array DIM" ++ show (rank shR) ++ " " ++ show tp type ArraysR = TupR ArrayR @@ -81,7 +79,7 @@ showArraysR :: ArraysR a -> ShowS showArraysR = shows arraysRarray :: ShapeR sh -> TypeR e -> ArraysR (Array sh e) -arraysRarray shR eR = TupRsingle (ArrayR shR eR) +arraysRarray shR tp = TupRsingle (ArrayR shR tp) arraysRpair :: ArrayR a -> ArrayR b -> ArraysR (((), a), b) arraysRpair a b = TupRunit `TupRpair` TupRsingle a `TupRpair` TupRsingle b @@ -92,9 +90,10 @@ arraysRFunctionImpossible (TupRsingle repr) = case repr of {} -- | Creates a new, uninitialized Accelerate array. -- allocateArray :: ArrayR (Array sh e) -> sh -> IO (Array sh e) -allocateArray (ArrayR shR eR) sh = do - adata <- newArrayData eR (size shR sh) - return $! Array sh adata +allocateArray (ArrayR shR tp) sh = do + mbuffers <- newBuffers tp (size shR sh) + let buffers = unsafeFreezeBuffers tp mbuffers + return $! Array sh buffers -- | Create an array from its representation function, applied at each -- index of the array. @@ -107,63 +106,64 @@ fromFunction repr sh f = unsafePerformIO $! fromFunctionM repr sh (return . f) -- @since 1.2.0.0 -- fromFunctionM :: ArrayR (Array sh e) -> sh -> (sh -> IO e) -> IO (Array sh e) -fromFunctionM (ArrayR shR eR) sh f = do +fromFunctionM (ArrayR shR tp) sh f = do let !n = size shR sh - arr <- newArrayData eR n + mbuffers <- newBuffers tp n -- let write !i | i >= n = return () | otherwise = do v <- f (fromIndex shR sh i) - writeArrayData eR arr i v + writeBuffers tp mbuffers i v write (i+1) -- write 0 - return $! arr `seq` Array sh arr + let buffers = unsafeFreezeBuffers tp mbuffers + return $! buffers `seq` Array sh buffers -- | Convert a list into an Accelerate 'Array' in dense row-major order. -- fromList :: forall sh e. ArrayR (Array sh e) -> sh -> [e] -> Array sh e -fromList (ArrayR shR eR) sh xs = adata `seq` Array sh adata +fromList (ArrayR shR tp) sh xs = buffers `seq` Array sh buffers where -- Assume the array is in dense row-major order. This is safe because -- otherwise backends would not be able to directly memcpy. -- !n = size shR sh - (adata, _) = runArrayData @e $ do - arr <- newArrayData eR n + (buffers, _) = runBuffers tp $ do + mbuffers <- newBuffers tp n let go !i _ | i >= n = return () - go !i (v:vs) = writeArrayData eR arr i v >> go (i+1) vs + go !i (v:vs) = writeBuffers tp mbuffers i v >> go (i+1) vs go _ [] = error "Data.Array.Accelerate.fromList: not enough input data" -- go 0 xs - return (arr, undefined) + return (mbuffers, undefined) -- | Convert an accelerated 'Array' to a list in row-major order. -- toList :: ArrayR (Array sh e) -> Array sh e -> [e] -toList (ArrayR shR eR) (Array sh adata) = go 0 +toList (ArrayR shR tp) (Array sh buffers) = go 0 where -- Assume underling array is in row-major order. This is safe because -- otherwise backends would not be able to directly memcpy. -- !n = size shR sh go !i | i >= n = [] - | otherwise = indexArrayData eR adata i : go (i+1) + | otherwise = indexBuffers tp buffers i : go (i+1) concatVectors :: forall e. TypeR e -> [Vector e] -> Vector e -concatVectors tR vs = adata `seq` Array ((), len) adata +concatVectors tp vs = buffers `seq` Array ((), len) buffers where - offsets = scanl (+) 0 (map (size dim1 . shape) vs) - len = last offsets - (adata, _) = runArrayData @e $ do - arr <- newArrayData tR len - sequence_ [ writeArrayData tR arr (i + k) (indexArrayData tR ad i) + offsets = scanl (+) 0 (map (size dim1 . shape) vs) + len = last offsets + (buffers, _) = runBuffers tp $ do + mbuffers <- newBuffers tp len + sequence_ [ writeBuffers tp mbuffers (i + k) (indexBuffers tp ad i) | (Array ((), n) ad, k) <- vs `zip` offsets , i <- [0 .. n - 1] ] - return (arr, undefined) + return (mbuffers, undefined) shape :: Array sh e -> sh shape (Array sh _) = sh @@ -180,10 +180,10 @@ reshape shR sh shR' (Array sh' adata) (!!) = uncurry linearIndexArray indexArray :: ArrayR (Array sh e) -> Array sh e -> sh -> e -indexArray (ArrayR shR adR) (Array sh adata) ix = indexArrayData adR adata (toIndex shR sh ix) +indexArray (ArrayR shR tp) (Array sh buffers) ix = indexBuffers tp buffers (toIndex shR sh ix) linearIndexArray :: TypeR e -> Array sh e -> Int -> e -linearIndexArray adR (Array _ adata) = indexArrayData adR adata +linearIndexArray tp (Array _ buffers) = indexBuffers tp buffers showArray :: (e -> ShowS) -> ArrayR (Array sh e) -> Array sh e -> String showArray f arrR@(ArrayR shR _) arr@(Array sh _) = case shR of @@ -240,10 +240,10 @@ reduceRank :: ArrayR (Array (sh, Int) e) -> ArrayR (Array sh e) reduceRank (ArrayR (ShapeRsnoc shR) aeR) = ArrayR shR aeR rnfArray :: ArrayR a -> a -> () -rnfArray (ArrayR shR adR) (Array sh ad) = rnfShape shR sh `seq` rnfArrayData adR ad +rnfArray (ArrayR shR tp) (Array sh buffers) = rnfShape shR sh `seq` rnfBuffers tp buffers rnfArrayR :: ArrayR arr -> () -rnfArrayR (ArrayR shR tR) = rnfShapeR shR `seq` rnfTupR rnfScalarType tR +rnfArrayR (ArrayR shR tp) = rnfShapeR shR `seq` rnfTupR rnfScalarType tp rnfArraysR :: ArraysR arrs -> arrs -> () rnfArraysR TupRunit () = () @@ -251,7 +251,7 @@ rnfArraysR (TupRsingle arrR) arr = rnfArray arrR arr rnfArraysR (TupRpair aR1 aR2) (a1,a2) = rnfArraysR aR1 a1 `seq` rnfArraysR aR2 a2 liftArrayR :: ArrayR a -> Q (TExp (ArrayR a)) -liftArrayR (ArrayR shR tR) = [|| ArrayR $$(liftShapeR shR) $$(liftTypeR tR) ||] +liftArrayR (ArrayR shR tp) = [|| ArrayR $$(liftShapeR shR) $$(liftTypeR tp) ||] liftArraysR :: ArraysR arrs -> Q (TExp (ArraysR arrs)) liftArraysR TupRunit = [|| TupRunit ||] @@ -259,8 +259,8 @@ liftArraysR (TupRsingle repr) = [|| TupRsingle $$(liftArrayR repr) ||] liftArraysR (TupRpair a b) = [|| TupRpair $$(liftArraysR a) $$(liftArraysR b) ||] liftArray :: forall sh e. ArrayR (Array sh e) -> Array sh e -> Q (TExp (Array sh e)) -liftArray (ArrayR shR adR) (Array sh adata) = - [|| Array $$(liftElt (shapeType shR) sh) $$(liftArrayData sz adR adata) ||] `at` [t| Array $(liftTypeQ (shapeType shR)) $(liftTypeQ adR) |] +liftArray (ArrayR shR tp) (Array sh buffers) = + [|| Array $$(liftElt (shapeType shR) sh) $$(liftBuffers sz tp buffers) ||] `at` [t| Array $(liftTypeQ (shapeType shR)) $(liftTypeQ tp) |] where sz :: Int sz = size shR sh diff --git a/src/Data/Array/Accelerate/Representation/Type.hs b/src/Data/Array/Accelerate/Representation/Type.hs index ca6ca1876..211fd0c0e 100644 --- a/src/Data/Array/Accelerate/Representation/Type.hs +++ b/src/Data/Array/Accelerate/Representation/Type.hs @@ -59,6 +59,8 @@ type TypeR = TupR ScalarType -- | Distributes a type constructor over the elements of a tuple. -- TODO: Could we make this type class injective? Then we wouldn't -- need the type class Distributes any more. +-- Note that we must use a standard, lazy pair here, as we rely on +-- laziness in type alias Buffers to make host-device copies lazy. -- type family Distribute f a = b where Distribute f () = () diff --git a/src/Data/Array/Accelerate/Trafo/Desugar.hs b/src/Data/Array/Accelerate/Trafo/Desugar.hs index 4f5b97570..bce779d83 100644 --- a/src/Data/Array/Accelerate/Trafo/Desugar.hs +++ b/src/Data/Array/Accelerate/Trafo/Desugar.hs @@ -31,18 +31,14 @@ import Data.Array.Accelerate.Representation.Array import Data.Array.Accelerate.Representation.Shape import Data.Array.Accelerate.Representation.Slice import Data.Array.Accelerate.Representation.Stencil -import Data.Array.Accelerate.Representation.Tag import Data.Array.Accelerate.Representation.Type -import Data.Array.Accelerate.Representation.Vec import Data.Array.Accelerate.Sugar.Foreign import Data.Array.Accelerate.Trafo.Exp.Substitution import Data.Array.Accelerate.Trafo.Operation.Substitution import Data.Array.Accelerate.Trafo.Var import Data.Array.Accelerate.Type import Data.Array.Accelerate.Error -import Data.Primitive.Vec import Data.Kind -import GHC.Stack type a $ b = a b infixr 0 $ @@ -290,7 +286,7 @@ desugarOpenAcc env = travA f' = desugarOpenAfun env f i' = travA i in Awhile c' f' i' - Named.Use repr array -> undefined -- TODO: Desugar Use + Named.Use repr array -> desugarUse repr array Named.Unit tp e | DeclareVars lhs _ value <- declareVars tp -> let @@ -875,6 +871,15 @@ restrict sliceIx (ArgVar slix) shapeInit :: ShapeR (sh, Int) -> ShapeR sh shapeInit (ShapeRsnoc shr) = shr +desugarUse :: ArrayR (Array sh e) -> Array sh e -> OperationAcc op benv (DesugaredArrays (Array sh e)) +desugarUse (ArrayR shr tp) (Array sh buffers) = Compute (mkConstant (shapeType shr) sh) `pair` desugarBuffers tp buffers + +desugarBuffers :: forall e op benv. TypeR e -> Buffers e -> OperationAcc op benv (Buffers e) +desugarBuffers TupRunit () = Return TupRunit +desugarBuffers (TupRpair t1 t2) (b1, b2) = desugarBuffers t1 b1 `pair` desugarBuffers t2 b2 +desugarBuffers (TupRsingle tp) buffer + | Refl <- reprIsSingle @ScalarType @e @Buffer tp = Use tp buffer + desugarBoundaryToFunction :: forall benv sh e. Boundary benv (Array sh e) -> Arg benv (In sh e) -> Fun benv (sh -> e) desugarBoundaryToFunction boundary (ArgArray _ repr@(ArrayR shr tp) sh buffers) = case boundary of Function f -> f From 70ce57048096a59f2f5fe0ab93afc4c79cc826f8 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Tue, 8 Sep 2020 20:23:35 +0200 Subject: [PATCH 008/813] ScalarArrayData -> Buffer, default desugar fold --- accelerate.cabal | 2 +- src/Data/Array/Accelerate/AST/Operation.hs | 34 +++- src/Data/Array/Accelerate/AST/Partitioned.hs | 9 +- .../Accelerate/Test/NoFib/Issues/Issue286.hs | 2 +- .../Accelerate/Test/NoFib/Prelude/Permute.hs | 2 +- src/Data/Array/Accelerate/Trafo.hs | 1 + src/Data/Array/Accelerate/Trafo/Desugar.hs | 158 +++++++++++++++++- .../Array/Accelerate/Trafo/NewNewFusion.hs | 77 +++++++++ .../Trafo/Operation/Substitution.hs | 18 +- 9 files changed, 284 insertions(+), 19 deletions(-) create mode 100644 src/Data/Array/Accelerate/Trafo/NewNewFusion.hs diff --git a/accelerate.cabal b/accelerate.cabal index 83d0c5908..32fda4c46 100644 --- a/accelerate.cabal +++ b/accelerate.cabal @@ -324,7 +324,7 @@ Library Data.Array.Accelerate.Analysis.Hash Data.Array.Accelerate.Analysis.Hash.Exp Data.Array.Accelerate.Analysis.Match - Data.Array.Accelerate.Array.Data + Data.Array.Accelerate.Array.Buffer Data.Array.Accelerate.Array.Remote Data.Array.Accelerate.Array.Remote.Class Data.Array.Accelerate.Array.Remote.LRU diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index b90c6f596..e62f84a82 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -26,7 +26,7 @@ module Data.Array.Accelerate.AST.Operation ( OperationAcc, OperationAfun, Execute(..), GroundR(..), GroundsR, GroundVar, GroundVars, GLeftHandSide, Var(..), Vars, - HasGroundsR(..), + HasGroundsR(..), groundToExpVar, PreArgs(..), Arg(..), Args, Modifier(..), argArrayR, argVarType, @@ -44,10 +44,14 @@ module Data.Array.Accelerate.AST.Operation ( IsExecutableAcc(..), ReindexPartial, reindexArg, reindexArgs, reindexExp, reindexVar, reindexVars, + weakenReindex, + + mapAccExecutable, mapAfunExecutable, module Data.Array.Accelerate.AST.Exp ) where +import Data.Array.Accelerate.AST.Environment import Data.Array.Accelerate.AST.Exp import Data.Array.Accelerate.AST.LeftHandSide import Data.Array.Accelerate.AST.Idx @@ -139,7 +143,7 @@ data PreOpenAcc exe env a where -- Awhile :: PreOpenAfun exe env (arrs -> PrimBool) -> PreOpenAfun exe env (arrs -> arrs) - -> PreOpenAcc exe env arrs + -> GroundVars env arrs -> PreOpenAcc exe env arrs -- | Function abstraction over parametrised array computations @@ -177,7 +181,6 @@ data PreArgs a t where -- | A single argument to an operation. -- data Arg env t where - -- TODO: Do we need this? ArgVar :: ExpVars env e -> Arg env (Var' e) ArgExp :: Exp env e -> Arg env (Exp' e) @@ -387,8 +390,33 @@ reindexArgs :: Applicative f => ReindexPartial f env env' -> Args env t -> f (Ar reindexArgs _ ArgsNil = pure ArgsNil reindexArgs k (a :>: as) = (:>:) <$> reindexArg k a <*> reindexArgs k as +weakenReindex :: benv :> benv' -> ReindexPartial Identity benv benv' +weakenReindex k = Identity . (k >:>) + class IsExecutableAcc exe where reindexExecPartial :: Applicative f => ReindexPartial f env env' -> exe env -> f (exe env') instance IsExecutableAcc (Execute op) where reindexExecPartial k (Execute op args) = Execute op <$> reindexArgs k args + +mapAccExecutable :: (forall benv'. exe benv' -> exe' benv') -> PreOpenAcc exe benv t -> PreOpenAcc exe' benv t +mapAccExecutable f = \case + Exec exe -> Exec $ f exe + Return vars -> Return vars + Compute e -> Compute e + Alet lhs bnd body -> Alet lhs (mapAccExecutable f bnd) (mapAccExecutable f body) + Alloc shr tp sh -> Alloc shr tp sh + Use tp buffer -> Use tp buffer + Unit vars -> Unit vars + Acond var a1 a2 -> Acond var (mapAccExecutable f a1) (mapAccExecutable f a2) + Awhile c g a -> Awhile (mapAfunExecutable f c) (mapAfunExecutable f g) a + +mapAfunExecutable :: (forall benv'. exe benv' -> exe' benv') -> PreOpenAfun exe benv t -> PreOpenAfun exe' benv t +mapAfunExecutable f (Abody a) = Abody $ mapAccExecutable f a +mapAfunExecutable f (Alam lhs a) = Alam lhs $ mapAfunExecutable f a + +groundToExpVar :: TypeR e -> GroundVars benv e -> ExpVars benv e +groundToExpVar (TupRsingle t) (TupRsingle (Var _ ix)) = TupRsingle (Var t ix) +groundToExpVar (TupRpair t1 t2) (TupRpair v1 v2) = groundToExpVar t1 v1 `TupRpair` groundToExpVar t2 v2 +groundToExpVar TupRunit TupRunit = TupRunit +groundToExpVar _ _ = error "Impossible pair" diff --git a/src/Data/Array/Accelerate/AST/Partitioned.hs b/src/Data/Array/Accelerate/AST/Partitioned.hs index 4f9b18dbe..f087b73af 100644 --- a/src/Data/Array/Accelerate/AST/Partitioned.hs +++ b/src/Data/Array/Accelerate/AST/Partitioned.hs @@ -19,12 +19,13 @@ -- Portability : non-portable (GHC extensions) -- -module Data.Array.Accelerate.AST.Partitioned ( ) where +module Data.Array.Accelerate.AST.Partitioned ( module Data.Array.Accelerate.AST.Operation, Cluster(..), PartitionedAcc, PartitionedAfun ) where -import Data.Array.Accelerate.AST.Partitioned +import Data.Array.Accelerate.AST.Operation hiding ( OperationAcc, Execute(..) ) data Cluster op env where - Base :: op args -> Args env args -> Command op env + Base :: op args -> Args env args -> Cluster op env -- TODO: Vertical, Horizontal, Diagonal -type PartitionedAcc op = PreOpenAcc (Cluster op) +type PartitionedAcc op = PreOpenAcc (Cluster op) +type PartitionedAfun op = PreOpenAfun (Cluster op) diff --git a/src/Data/Array/Accelerate/Test/NoFib/Issues/Issue286.hs b/src/Data/Array/Accelerate/Test/NoFib/Issues/Issue286.hs index 5a9feb17b..4230e6e27 100644 --- a/src/Data/Array/Accelerate/Test/NoFib/Issues/Issue286.hs +++ b/src/Data/Array/Accelerate/Test/NoFib/Issues/Issue286.hs @@ -20,7 +20,7 @@ module Data.Array.Accelerate.Test.NoFib.Issues.Issue286 ( ) where import Data.Array.Accelerate as A hiding ( (>->), (==) ) -import Data.Array.Accelerate.Array.Data +import Data.Array.Accelerate.Array.Buffer import Data.Array.Accelerate.Array.Sugar as Sugar import Data.Array.Accelerate.Array.Unique import Data.Array.Accelerate.Error diff --git a/src/Data/Array/Accelerate/Test/NoFib/Prelude/Permute.hs b/src/Data/Array/Accelerate/Test/NoFib/Prelude/Permute.hs index abcc5f705..774c81909 100644 --- a/src/Data/Array/Accelerate/Test/NoFib/Prelude/Permute.hs +++ b/src/Data/Array/Accelerate/Test/NoFib/Prelude/Permute.hs @@ -22,7 +22,7 @@ module Data.Array.Accelerate.Test.NoFib.Prelude.Permute ( ) where import Data.Array.Accelerate as A -import Data.Array.Accelerate.Array.Data +import Data.Array.Accelerate.Array.Buffer import Data.Array.Accelerate.Sugar.Array as S import Data.Array.Accelerate.Sugar.Elt as S import Data.Array.Accelerate.Sugar.Shape as S diff --git a/src/Data/Array/Accelerate/Trafo.hs b/src/Data/Array/Accelerate/Trafo.hs index 85f6a9dd6..31020f4d1 100644 --- a/src/Data/Array/Accelerate/Trafo.hs +++ b/src/Data/Array/Accelerate/Trafo.hs @@ -41,6 +41,7 @@ import qualified Data.Array.Accelerate.Trafo.LetSplit as LetSplit import qualified Data.Array.Accelerate.Trafo.Exp.Simplify as Rewrite import qualified Data.Array.Accelerate.Trafo.Sharing as Sharing import qualified Data.Array.Accelerate.Trafo.Desugar as Desugar +import qualified Data.Array.Accelerate.Trafo.NewNewFusion as NewNewFusion -- import qualified Data.Array.Accelerate.Trafo.Vectorise as Vectorise import Control.DeepSeq diff --git a/src/Data/Array/Accelerate/Trafo/Desugar.hs b/src/Data/Array/Accelerate/Trafo/Desugar.hs index bce779d83..2218ba75e 100644 --- a/src/Data/Array/Accelerate/Trafo/Desugar.hs +++ b/src/Data/Array/Accelerate/Trafo/Desugar.hs @@ -177,8 +177,23 @@ class DesugarAcc (op :: Type -> Type) where -> Arg env (In (sh, Int) e) -> Arg env (Out sh e) -> OperationAcc op env () - -- TODO: Default implementation in terms of generate & awhile, or a sequential one in terms of generate - -- Altough it may not be that efficient, it will make it easier to implement new backends + mkFold f def input@(ArgArray _ repr@(ArrayR shr tp) _ _) output + -- Binding of the result of the first step + | DeclareVars lhs1 k1 value1 <- declareVars $ desugarArrayR repr + -- Binding in the iteration and condition function for the first step + , DeclareVars lhsSh kSh valueSh <- declareVars $ mapTupR GroundRscalar $ shapeType shr + , DeclareVars lhsBf kBf valueBf <- declareVars $ buffersR tp + = let + lhs2 = LeftHandSidePair lhsSh lhsBf + argTmp = ArgArray In (ArrayR shr tp) (valueSh kBf) (valueBf weakenId) + c = Alam lhs2 $ Abody $ case valueSh kBf of + TupRpair _ ix -> Compute $ mkBinary (PrimLtEq singleType) (paramsIn (TupRsingle scalarTypeInt) ix) (mkConstant (TupRsingle scalarTypeInt) 1) + _ -> error "Impossible pair" + g = Alam lhs2 $ Abody $ mkDefaultFoldStep2 (weaken (kBf .> kSh .> k1) f) argTmp (weaken (kBf .> kSh .> k1) output) + in + alet lhs1 (mkDefaultFoldStep1 f def input output) + $ alet (LeftHandSideWildcard $ desugarArrayR repr) (Awhile c g $ value1 weakenId) + $ Return TupRunit mkFoldSeg :: IntegralType i -> Arg env (Fun' (e -> e -> e)) @@ -187,6 +202,11 @@ class DesugarAcc (op :: Type -> Type) where -> Arg env (In DIM1 i) -> Arg env (Out (sh, Int) e) -> OperationAcc op env () + -- TODO: Default implementation. We could do this using: + -- generate: just a simple implementation which is sequential for each segment + -- scan (segmented scan) + -- awhile & generate + -- I think a segmented scan would be the most efficient mkScan :: Direction -> Arg env (Fun' (e -> e -> e)) @@ -203,7 +223,7 @@ class DesugarAcc (op :: Type -> Type) where -> Arg env (Out (sh, Int) e) -> Arg env (Out sh e) -> OperationAcc op env () - -- TODO: Default implementation with awhile & generate + -- TODO: Default implementation in terms of scan mkForeign :: Foreign asm => ArraysR bs @@ -276,16 +296,18 @@ desugarOpenAcc env = travA var = Var scalarTypeWord8 ZeroIdx in alet lhs (Compute $ travE c) $ Acond var (desugarOpenAcc env' t) (desugarOpenAcc env' f) Named.Awhile c f i - | Refl <- desugaredAfunIsBody $ Named.arraysR acc -> + | repr <- Named.arraysR acc + , Refl <- desugaredAfunIsBody repr + , DeclareVars lhs k value <- declareVars $ desugarArraysR repr -> let bufferType = GroundRbuffer $ scalarTypeWord8 lhsScalarBool = LeftHandSidePair (LeftHandSideWildcard TupRunit) (LeftHandSideSingle bufferType) - c' = case desugarOpenAfun env c of + env' = weakenBEnv k env + c' = case desugarOpenAfun env' c of Alam lhs (Abody body) -> Alam lhs $ Abody $ Alet lhsScalarBool body $ Compute $ ArrayInstr (Index $ Var bufferType ZeroIdx) $ Const scalarTypeInt 0 Abody _ -> error "It's a long time since we last met" - f' = desugarOpenAfun env f - i' = travA i - in Awhile c' f' i' + f' = desugarOpenAfun env' f + in alet lhs (travA i) $ Awhile c' f' (value weakenId) Named.Use repr array -> desugarUse repr array Named.Unit tp e | DeclareVars lhs _ value <- declareVars tp -> @@ -1055,3 +1077,123 @@ mkIntersect :: ShapeR sh -> ExpVars benv sh -> ExpVars benv sh -> PreOpenExp (Ar mkIntersect ShapeRz _ _ = Nil mkIntersect (ShapeRsnoc shr) (TupRpair s1 x1) (TupRpair s2 x2) = mkIntersect shr s1 s2 `Pair` mkBinary (PrimMin singleType) (paramsIn' x1) (paramsIn' x2) mkIntersect (ShapeRsnoc _) _ _ = error "Impossible pair" + +-- Default implementation for the first step of a fold. +-- The output of the inner dimension is guaranteed to +-- be a power of two. +mkDefaultFoldStep1 :: forall benv op sh e. DesugarAcc op => Arg benv (Fun' (e -> e -> e)) -> Maybe (Arg benv (Exp' e)) -> Arg benv (In (sh, Int) e) -> Arg benv (Out sh e) -> OperationAcc op benv (DesugaredArrays (Array (sh, Int) e)) +mkDefaultFoldStep1 (ArgFun f) def argIn@(ArgArray _ (ArrayR shr tp) (sh `TupRpair` n) _) argOut + | DeclareVars lhsTmp kTmp valueTmp <- declareVars $ buffersR tp + = let + lhsN1 = LeftHandSideSingle $ GroundRscalar scalarTypeInt + kN1 = weakenSucc weakenId + + -- n-1 in case of fold1. + -- For fold, we have one additional element (the default value), and thus have (n+1)-1 + nMinus1 + | Just _ <- def = paramsIn (TupRsingle scalarType) n + | otherwise = mkBinary (PrimSub numType) (paramsIn (TupRsingle scalarType) n) (mkConstant (TupRsingle scalarTypeInt) 1) + + shBase' = weakenVars (weakenSucc weakenId) sh + shTmp' = shBase' `TupRpair` TupRsingle (Var (GroundRscalar scalarTypeInt) ZeroIdx) + + shTmp = weakenVars kTmp shTmp' + tmp = valueTmp weakenId + k = weakenSucc kTmp + argG = ArgFun $ mkDefaultFoldStep1Function (weakenArrayInstr k f) (weaken k <$> def) (weaken kTmp $ Var (GroundRscalar scalarTypeInt) ZeroIdx) (weaken k argIn) + argTmp = ArgArray Out (ArrayR shr tp) shTmp tmp + in + alet lhsN1 (Compute $ mkBinary (PrimBShiftL integralType) (mkConstant (TupRsingle scalarTypeInt) 1) $ mkLog2 nMinus1) + $ alet lhsTmp (mkDefaultFoldAllocOrOutput (weaken kN1 argOut) $ groundToExpVar (shapeType shr) shTmp') + $ alet (LeftHandSideWildcard TupRunit) (mkGenerate argG argTmp) + $ Return (shTmp `TupRpair` tmp) + +-- log_2(x) = 63 − clz(x) (for 64-bit integers) +mkLog2 :: OpenExp env benv Int -> OpenExp env benv Int +mkLog2 = mkBinary (PrimSub numType) (mkConstant (TupRsingle scalarTypeInt) 63) . PrimApp (PrimCountLeadingZeros integralType) + +mkDefaultFoldStep1Function :: forall benv sh e. HasCallStack => Fun benv (e -> e -> e) -> Maybe (Arg benv (Exp' e)) -> GroundVar benv Int -> Arg benv (In (sh, Int) e) -> Fun benv ((sh, Int) -> e) +mkDefaultFoldStep1Function f def n1' argIn@(ArgArray _ (ArrayR (ShapeRsnoc shr) tp) (sh' `TupRpair` n') buffers) + | DeclareVars lhsX kX valueX <- declareVars $ shapeType shr + = let + x = expVars $ valueX (weakenSucc weakenId) + y = Evar $ Var scalarTypeInt ZeroIdx + y2 = mkBinary (PrimMul numType) y (mkConstant (TupRsingle scalarTypeInt) 2) + n1 = paramIn scalarTypeInt n1' + + -- When a default or initial value is given, we just pretend that the input array is one + -- element larger, i.e., prefixed with that default value. + n + | Just _ <- def = mkBinary (PrimAdd numType) (paramsIn (TupRsingle scalarTypeInt) n') (mkConstant (TupRsingle scalarTypeInt) 1) + | otherwise = paramsIn (TupRsingle scalarTypeInt) n' + + index' :: OpenExp env' benv sh -> OpenExp env' benv Int -> OpenExp env' benv e + index' x' y' + | Just (ArgExp d) <- def = + Cond (mkBinary (PrimEq singleType) y' $ mkConstant (TupRsingle scalarTypeInt) 0) + (weakenE weakenEmpty d) + (index (ArrayR (ShapeRsnoc shr) tp) (sh' `TupRpair` n') buffers $ Pair x' $ mkBinary (PrimSub numType) y' $ mkConstant (TupRsingle scalarTypeInt) 1) + index' x' y' = + (index (ArrayR (ShapeRsnoc shr) tp) (sh' `TupRpair` n') buffers $ Pair x' y') + in + -- \(x, y) -> + Lam (lhsX `LeftHandSidePair` LeftHandSideSingle scalarTypeInt) + $ Body + -- if (y < n-n1) + $ Cond (mkBinary (PrimLt singleType) y $ mkBinary (PrimSub numType) n n1) + -- then {reduce y*2 and y*2+1} + (apply2 tp f (index' x y2) (index' x $ mkBinary (PrimAdd numType) y2 $ mkConstant (TupRsingle scalarTypeInt) 1)) + -- else {just copy the value from index (y+n-n1)} + (index' x $ mkBinary (PrimAdd numType) y $ mkBinary (PrimSub numType) n n1) + +-- Halves the inner dimension of the array +mkDefaultFoldStep2 :: DesugarAcc op => Arg benv (Fun' (e -> e -> e)) -> Arg benv (In (sh, Int) e) -> Arg benv (Out sh e) -> OperationAcc op benv (DesugaredArrays (Array (sh, Int) e)) +mkDefaultFoldStep2 (ArgFun f) argIn@(ArgArray _ (ArrayR shr@(ShapeRsnoc shr') tp) (TupRpair sh n) input) argOut + | DeclareVars lhsSh kSh valueSh <- declareVars $ TupRsingle $ GroundRscalar scalarTypeInt + , DeclareVars lhsTmp kTmp valueTmp <- declareVars $ buffersR tp + = let + shBase' = weakenVars kSh sh + shTmp' = shBase' `TupRpair` valueSh weakenId + + shBase = weakenVars kTmp shBase' + shIn = shBase `TupRpair` weakenVars (kTmp .> kSh) n + shTmp = shBase `TupRpair` valueSh kTmp + + temp = valueTmp weakenId + argG = weaken (kTmp .> kSh) $ ArgFun $ mkDefaultFoldStep2Function f argIn + argTmp = ArgArray Out (ArrayR shr tp) shTmp temp + in + alet lhsSh (Compute $ mkBinary (PrimRem integralType) (paramsIn (TupRsingle scalarTypeInt) n) (Const scalarTypeInt 2)) + $ alet lhsTmp (mkDefaultFoldAllocOrOutput (weaken kSh argOut) $ groundToExpVar (shapeType shr) shTmp') + $ alet (LeftHandSideWildcard TupRunit) (mkGenerate argG argTmp) + $ Return (shTmp `TupRpair` temp) + +-- Allocates a new intermediate array or returns the output array. +-- If the inner dimension is 1, returns the output array, as we are in the last iteration. +-- Otherwise, allocates a new intermediate array. +-- +mkDefaultFoldAllocOrOutput :: Arg benv (Out sh e) -> ExpVars benv (sh, Int) -> OperationAcc op benv (Buffers e) +mkDefaultFoldAllocOrOutput (ArgArray _ (ArrayR shr e) _ output) sh@(TupRpair _ y) + = Alet (LeftHandSideSingle $ GroundRscalar scalarType) (Compute $ mkBinary (PrimEq singleType) (paramsIn' y) $ mkConstant (TupRsingle scalarTypeInt) 1) + $ Acond (Var scalarTypeWord8 ZeroIdx) + (Return $ weakenVars (weakenSucc weakenId) output) + (desugarAlloc (ArrayR (ShapeRsnoc shr) e) $ weakenVars (weakenSucc weakenId) sh) + +-- \(x, y) -> f (a !! (x, 2*y)) (a !! (x, 2*y+1)) +-- ==> \(x, y) -> let z = toIndex (x, 2*y) in f (a ! z) (a ! z+1) +mkDefaultFoldStep2Function :: forall benv sh e. HasCallStack => Fun benv (e -> e -> e) -> Arg benv (In (sh, Int) e) -> Fun benv ((sh, Int) -> e) +mkDefaultFoldStep2Function f (ArgArray _ (ArrayR (ShapeRsnoc shr) tp) sh input) + | DeclareVars lhsX kX valueX <- declareVars $ shapeType shr + , DeclareVars lhsY kY valueY <- declareVars $ TupRsingle scalarTypeInt + -- \(x, y) -> + = Lam (lhsX `LeftHandSidePair` lhsY) + $ Body + -- let z = toIndex (x, 2*y) + $ Let (LeftHandSideSingle scalarTypeInt) (ToIndex (ShapeRsnoc shr) (paramsIn (shapeType $ ShapeRsnoc shr) sh) (expVars (valueX kY) `Pair` mkBinary (PrimMul numType) (expVars $ valueY weakenId) (mkConstant (TupRsingle scalarTypeInt) 2))) + -- f + $ apply2 tp f + -- (a ! z) + (linearIndex tp input $ {- z -} Var scalarTypeInt ZeroIdx) + -- (let w = z + 1 in a ! w) + (Let (LeftHandSideSingle scalarTypeInt) (mkBinary (PrimAdd numType) (Evar $ Var scalarTypeInt ZeroIdx) (mkConstant (TupRsingle scalarTypeInt) 1)) + $ linearIndex tp input $ Var scalarTypeInt ZeroIdx) diff --git a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs new file mode 100644 index 000000000..a1329405f --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs @@ -0,0 +1,77 @@ +{-# LANGUAGE CPP #-} +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE PatternGuards #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE ViewPatterns #-} + +-- | +-- Module : Data.Array.Accelerate.Trafo.NewNewFusion +-- Copyright : [2012..2020] The Accelerate Team +-- License : BSD3 +-- +-- Maintainer : Trevor L. McDonell +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- +-- This module should implement fusion. +-- + +module Data.Array.Accelerate.Trafo.NewNewFusion ( + + convertAcc, convertAccWith, + convertAfun, convertAfunWith, + +) where + +import Data.Array.Accelerate.AST.Operation +import Data.Array.Accelerate.AST.Partitioned +import Data.Array.Accelerate.Trafo.Config +import Data.Array.Accelerate.Error + +import Data.Array.Accelerate.Debug.Flags ( array_fusion ) +import qualified Data.Array.Accelerate.Debug.Stats as Stats +#ifdef ACCELERATE_DEBUG +import System.IO.Unsafe -- for debugging +#endif + +-- Array Fusion +-- ============ + +-- | Apply the fusion transformation to a de Bruijn AST +-- +convertAcc + :: HasCallStack + => Config + -> OperationAcc op benv a + -> PartitionedAcc op benv a +convertAcc _ = withSimplStats $ mapAccExecutable dontFuse + +convertAccWith :: HasCallStack => Config -> OperationAcc op benv a -> PartitionedAcc op benv a +convertAccWith config = convertAcc config + +-- | Apply the fusion transformation to a function of array arguments +-- +convertAfun :: HasCallStack => Config -> OperationAfun op benv f -> PartitionedAfun op benv f +convertAfun _ = withSimplStats $ mapAfunExecutable dontFuse + +convertAfunWith :: HasCallStack => Config -> OperationAfun op benv f -> PartitionedAfun op benv f +convertAfunWith config = convertAfun config + +withSimplStats :: a -> a +#ifdef ACCELERATE_DEBUG +withSimplStats x = unsafePerformIO Stats.resetSimplCount `seq` x +#else +withSimplStats x = x +#endif + +dontFuse :: Execute op benv -> Cluster op benv +dontFuse (Execute op args) = Base op args diff --git a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs index ff3779280..80f60bfb5 100644 --- a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs +++ b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs @@ -30,6 +30,7 @@ module Data.Array.Accelerate.Trafo.Operation.Substitution ( reindexPartial, reindexPartialAfun, pair, alet, + weakenArrayInstr, ) where import Data.Array.Accelerate.AST.Idx @@ -58,6 +59,13 @@ instance IsExecutableAcc exe => Sink (PreOpenAcc exe) where instance IsExecutableAcc exe => Sink (PreOpenAfun exe) where weaken k = runIdentity . reindexPartialAfun (Identity . (k >:>)) +instance Sink Arg where + weaken k = runIdentity . reindexArg (weakenReindex k) + +instance Sink ArrayInstr where + weaken k (Index v) = Index $ weaken k v + weaken k (Parameter v) = Parameter $ weaken k v + sinkReindexWithLHS :: LeftHandSide s t env1 env1' -> LeftHandSide s t env2 env2' -> SunkReindexPartial f env1 env2 -> SunkReindexPartial f env1' env2' sinkReindexWithLHS (LeftHandSideWildcard _) (LeftHandSideWildcard _) k = k sinkReindexWithLHS (LeftHandSideSingle _) (LeftHandSideSingle _) k = Sink k @@ -97,7 +105,7 @@ reindexA' k = \case Use tp buffer -> pure $ Use tp buffer Unit var -> Unit <$> reindexVar' k var Acond c t f -> Acond <$> reindexVar' k c <*> travA t <*> travA f - Awhile c f i -> Awhile <$> reindexAfun' k c <*> reindexAfun' k f <*> travA i + Awhile c f i -> Awhile <$> reindexAfun' k c <*> reindexAfun' k f <*> reindexVars' k i where travA :: PreOpenAcc exe env s -> f (PreOpenAcc exe env' s) travA = reindexA' k @@ -144,3 +152,11 @@ extractParams Nil = Just TupRunit extractParams (Pair e1 e2) = TupRpair <$> extractParams e1 <*> extractParams e2 extractParams (ArrayInstr (Parameter v) _) = Just $ TupRsingle v extractParams _ = Nothing + +-- We cannot use 'weaken' to weaken the array environment of an 'OpenExp', +-- as OpenExp is a type synonym for 'PreOpenExp (ArrayInstr aenv) env', +-- and 'weaken' would thus affect the expression environment. Hence we +-- have a separate function for OpenExp and OpenFun. +-- +weakenArrayInstr :: RebuildableExp f => aenv :> aenv' -> f (ArrayInstr aenv) env t -> f (ArrayInstr aenv') env t +weakenArrayInstr k = rebuildArrayInstr (ArrayInstr . weaken k) From 89afcef68b36e5568ef6741e5246a9a8bc847aac Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Wed, 9 Sep 2020 21:30:01 +0200 Subject: [PATCH 009/813] Desugar scans and foldSeg --- src/Data/Array/Accelerate/Trafo/Desugar.hs | 181 ++++++++++++++++++++- 1 file changed, 172 insertions(+), 9 deletions(-) diff --git a/src/Data/Array/Accelerate/Trafo/Desugar.hs b/src/Data/Array/Accelerate/Trafo/Desugar.hs index 2218ba75e..819ccbf1a 100644 --- a/src/Data/Array/Accelerate/Trafo/Desugar.hs +++ b/src/Data/Array/Accelerate/Trafo/Desugar.hs @@ -202,11 +202,8 @@ class DesugarAcc (op :: Type -> Type) where -> Arg env (In DIM1 i) -> Arg env (Out (sh, Int) e) -> OperationAcc op env () - -- TODO: Default implementation. We could do this using: - -- generate: just a simple implementation which is sequential for each segment - -- scan (segmented scan) - -- awhile & generate - -- I think a segmented scan would be the most efficient + -- Default implementation using generate. It is sequential per segment, which is inefficient for some backends. + mkFoldSeg itp f def input segments output = mkGenerate (ArgFun $ mkDefaultFoldSegFunction itp f def input segments) output mkScan :: Direction -> Arg env (Fun' (e -> e -> e)) @@ -214,7 +211,55 @@ class DesugarAcc (op :: Type -> Type) where -> Arg env (In (sh, Int) e) -> Arg env (Out (sh, Int) e) -> OperationAcc op env () - -- TODO: Default implementation with awhile & generate + mkScan dir f (Just def) argIn@(ArgArray _ (ArrayR shr tp) _ _) argOut@(ArgArray _ _ shOut _) + | DeclareVars lhsTmp kTmp valueTmp <- declareVars $ buffersR tp -- Allocate buffers to prepend the default value + = let + shOut' = weakenVars kTmp shOut + + argG = ArgFun $ mkDefaultScanPrepend dir (weaken kTmp def) (weaken kTmp argIn) + argTmp' = ArgArray Out (ArrayR shr tp) shOut' (valueTmp weakenId) + argTmp = ArgArray In (ArrayR shr tp) shOut' (valueTmp weakenId) + in + alet lhsTmp (desugarAlloc (ArrayR shr tp) $ groundToExpVar (shapeType shr) shOut) + $ alet (LeftHandSideWildcard TupRunit) (mkGenerate argG argTmp') + $ mkScan dir (weaken kTmp f) Nothing argTmp (weaken kTmp argOut) + mkScan dir f Nothing (ArgArray _ (ArrayR shr tp) sh input) argOut + -- (inc, tmp) = awhile (\(inc, _) -> inc <= n / 4) (\(inc, a) -> (inc*2, generate {\i -> reduce i and i +/- inc in a})) input + -- generate {\i -> reduce i and i +/- inc in tmp} + -- + -- Note that the last iteration of the loop is decoupled, as that will output into argOut, + -- instead of a temporary array. + | DeclareVars lhsTmp kTmp valueTmp <- declareVars $ buffersR tp + , DeclareVars lhsAlloc kAlloc valueAlloc <- declareVars $ buffersR tp + = let + lhs = LeftHandSidePair (LeftHandSideSingle $ GroundRscalar scalarTypeInt) lhsTmp + argTmp = ArgArray In (ArrayR shr tp) (weakenVars (weakenSucc $ weakenSucc kTmp) sh) (valueTmp weakenId) + reduce = ArgFun $ mkDefaultScanFunction dir (weaken kTmp (Var (GroundRscalar $ scalarTypeInt) ZeroIdx)) (weaken (weakenSucc $ weakenSucc kTmp) f) argTmp + + n = case sh of + TupRpair _ n' -> paramsIn (TupRsingle scalarTypeInt) $ weakenVars (weakenSucc $ weakenSucc weakenId) n' + _ -> error "Impossible pair" + + -- Awhile condition + c = Alam (LeftHandSidePair (LeftHandSideSingle $ GroundRscalar scalarTypeInt) $ LeftHandSideWildcard $ buffersR tp) + $ Abody + $ Compute + $ mkBinary (PrimLtEq singleType) (paramIn' $ Var scalarTypeInt ZeroIdx) + $ mkBinary (PrimBShiftR integralType) n (mkConstant (TupRsingle scalarTypeInt) 2) -- n/4 + + argAlloc = ArgArray Out (ArrayR shr tp) (weakenVars (weakenSucc $ weakenSucc $ kAlloc .> kTmp) sh) (valueAlloc weakenId) + -- Awhile step function + g = Alam lhs + $ Abody + $ alet lhsAlloc (desugarAlloc (ArrayR shr tp) $ groundToExpVar (shapeType shr) $ weakenVars (weakenSucc $ weakenSucc kTmp) sh) + $ alet (LeftHandSideWildcard TupRunit) (mkGenerate (weaken kAlloc reduce) argAlloc) + $ alet (LeftHandSideSingle $ GroundRscalar scalarTypeInt) + (Compute $ mkBinary (PrimAdd numType) (paramIn' $ weaken (kAlloc .> kTmp) $ Var scalarTypeInt ZeroIdx) (mkConstant (TupRsingle scalarTypeInt) 1)) + $ Return $ TupRsingle (Var (GroundRscalar scalarTypeInt) ZeroIdx) `TupRpair` valueAlloc (weakenSucc weakenId) + in + alet (LeftHandSideSingle $ GroundRscalar scalarTypeInt) (Compute $ mkConstant (TupRsingle scalarTypeInt) 1) + $ alet lhs (Awhile c g (TupRsingle (Var (GroundRscalar scalarTypeInt) ZeroIdx) `TupRpair` weakenVars (weakenSucc weakenId) input)) + $ mkGenerate reduce (weaken (weakenSucc $ weakenSucc kTmp) argOut) mkScan' :: Direction -> Arg env (Fun' (e -> e -> e)) @@ -223,7 +268,42 @@ class DesugarAcc (op :: Type -> Type) where -> Arg env (Out (sh, Int) e) -> Arg env (Out sh e) -> OperationAcc op env () - -- TODO: Default implementation in terms of scan + mkScan' dir f def input@(ArgArray _ (ArrayR shr@(ShapeRsnoc shr') tp) sh _) out1 out2 + | DeclareVars lhsTmp kTmp valueTmp <- declareVars $ buffersR tp -- Allocate buffers for the output of scan + , DeclareVars lhsSh _ valueSh <- declareVars $ shapeType shr' -- Used in the function in backpermute + = let + (x, y) = case sh of + TupRpair x' y' -> (x', y') + _ -> error "Impossible pair" + + shTmp' = weakenVars (weakenSucc weakenId) x `TupRpair` TupRsingle (Var (GroundRscalar scalarTypeInt) ZeroIdx) + shTmp = weakenVars kTmp shTmp' + k = kTmp .> weakenSucc weakenId + argTmp = ArgArray In (ArrayR shr tp) shTmp (valueTmp weakenId) + argTmp' = ArgArray Out (ArrayR shr tp) shTmp (valueTmp weakenId) + + -- Fills 'out2' + argG = ArgFun $ Lam lhsSh $ Body $ Pair (expVars $ valueSh weakenId) $ case dir of + LeftToRight -> paramsIn (TupRsingle scalarTypeInt) $ weakenVars k y + RightToLeft -> mkConstant (TupRsingle scalarTypeInt) 0 + + -- Fills 'out1' in case of a RightToLeft scan + argH = ArgFun + $ Lam (LeftHandSidePair lhsSh $ LeftHandSideSingle scalarTypeInt) + $ Body + $ Pair + (expVars $ valueSh $ weakenSucc weakenId) + (mkBinary (PrimAdd numType) (Evar (Var scalarTypeInt ZeroIdx)) (mkConstant (TupRsingle scalarTypeInt) 0)) + in + alet (LeftHandSideSingle $ GroundRscalar scalarTypeInt) (Compute $ mkBinary (PrimAdd numType) (paramsIn (TupRsingle scalarTypeInt) y) $ mkConstant (TupRsingle scalarTypeInt) 1) + $ alet lhsTmp (desugarAlloc (ArrayR shr tp) $ groundToExpVar (shapeType shr) shTmp') + $ alet (LeftHandSideWildcard TupRunit) (mkScan dir (weaken k f) (Just $ weaken k def) (weaken k input) argTmp') + $ alet (LeftHandSideWildcard TupRunit) (case dir of + LeftToRight -> mkShrink argTmp $ weaken k out1 + RightToLeft -> mkBackpermute argH argTmp $ weaken k out1 + ) + $ alet (LeftHandSideWildcard TupRunit) (mkBackpermute argG argTmp $ weaken k out2) + $ Return TupRunit mkForeign :: Foreign asm => ArraysR bs @@ -304,8 +384,8 @@ desugarOpenAcc env = travA lhsScalarBool = LeftHandSidePair (LeftHandSideWildcard TupRunit) (LeftHandSideSingle bufferType) env' = weakenBEnv k env c' = case desugarOpenAfun env' c of - Alam lhs (Abody body) -> Alam lhs $ Abody $ Alet lhsScalarBool body $ Compute $ ArrayInstr (Index $ Var bufferType ZeroIdx) $ Const scalarTypeInt 0 - Abody _ -> error "It's a long time since we last met" + Alam lhs' (Abody body) -> Alam lhs' $ Abody $ Alet lhsScalarBool body $ Compute $ ArrayInstr (Index $ Var bufferType ZeroIdx) $ Const scalarTypeInt 0 + Abody _ -> error "It's a long time since we last met" f' = desugarOpenAfun env' f in alet lhs (travA i) $ Awhile c' f' (value weakenId) Named.Use repr array -> desugarUse repr array @@ -1197,3 +1277,86 @@ mkDefaultFoldStep2Function f (ArgArray _ (ArrayR (ShapeRsnoc shr) tp) sh input) -- (let w = z + 1 in a ! w) (Let (LeftHandSideSingle scalarTypeInt) (mkBinary (PrimAdd numType) (Evar $ Var scalarTypeInt ZeroIdx) (mkConstant (TupRsingle scalarTypeInt) 1)) $ linearIndex tp input $ Var scalarTypeInt ZeroIdx) + +-- In case of a scan with a default value, prepends the initial value before the other elements +-- The default value is placed as the first value in case of a left-to-right scan, or as the +-- last value for a right-to-left scan. +mkDefaultScanPrepend :: Direction -> Arg benv (Exp' e) -> Arg benv (In (sh, Int) e) -> Fun benv ((sh, Int) -> e) +mkDefaultScanPrepend dir (ArgExp def) (ArgArray _ repr@(ArrayR (ShapeRsnoc shr) tp) sh input) + | DeclareVars lhs k value <- declareVars $ shapeType shr + = let + first = case dir of + LeftToRight -> mkConstant (TupRsingle scalarTypeInt) 0 + RightToLeft -> case sh of + TupRpair _ n -> paramsIn (TupRsingle scalarTypeInt) n + _ -> error "Impossible pair" + x = case dir of + LeftToRight -> mkBinary (PrimAdd numType) (Evar $ Var scalarTypeInt ZeroIdx) (mkConstant (TupRsingle scalarType) 1) + RightToLeft -> Evar $ Var scalarTypeInt ZeroIdx + in + Lam (lhs `LeftHandSidePair` LeftHandSideSingle scalarTypeInt) + $ Body + $ Cond (mkBinary (PrimEq singleType) (Evar $ Var scalarTypeInt ZeroIdx) first) (weakenE (weakenSucc' k) def) + $ index repr sh input + $ Pair (expVars $ value $ weakenSucc weakenId) x + +-- TODO: Is the order of arguments to 'f' correct, in both directions? +mkDefaultScanFunction :: Direction -> GroundVar benv Int -> Arg benv (Fun' (e -> e -> e)) -> Arg benv (In (sh, Int) e) -> Fun benv ((sh, Int) -> e) +mkDefaultScanFunction dir inc (ArgFun f) (ArgArray _ repr@(ArrayR (ShapeRsnoc shr) tp) sh input) + | DeclareVars lhs k value <- declareVars $ shapeType shr + = let + op = case dir of + LeftToRight -> PrimSub + RightToLeft -> PrimAdd + x = Evar $ Var scalarTypeInt ZeroIdx + y = mkBinary (op numType) x (paramIn scalarTypeInt inc) + condition = case dir of + LeftToRight -> mkBinary (PrimGtEq singleType) y (mkConstant (TupRsingle scalarTypeInt) 0) + RightToLeft -> case sh of + TupRpair _ n -> mkBinary (PrimLt singleType) y (paramsIn (TupRsingle scalarTypeInt) n) + _ -> error "Impossible pair" + ix = expVars $ value $ weakenSucc weakenId + index' = index repr sh input . Pair ix + in + Lam (lhs `LeftHandSidePair` LeftHandSideSingle scalarTypeInt) + $ Body + $ Cond condition + (index' x) + (apply2 tp f (index' x) (index' y)) + +mkDefaultFoldSegFunction + :: IntegralType i + -> Arg benv (Fun' (e -> e -> e)) + -> Maybe (Arg benv (Exp' e)) + -> Arg benv (In (sh, Int) e) + -> Arg benv (In DIM1 i) + -> Fun benv ((sh, Int) -> e) +mkDefaultFoldSegFunction itp (ArgFun f) def (ArgArray _ (ArrayR shr tp) sh input) (ArgArray _ reprSeg shSeg segments) + | DeclareVars lhsSh kSh valueSh <- declareVars $ shapeType shr + , DeclareVars lhsE kE valueE <- declareVars tp = + let + x1 = case valueSh weakenId of + TupRpair _ x' -> expVars x' + _ -> error "Impossible pair" + x2 = case valueSh (weakenSucc' kE) of + TupRpair _ x' -> expVars x' + _ -> error "Impossible pair" + start = PrimApp (PrimFromIntegral itp numType) $ index reprSeg shSeg segments $ Pair Nil x1 + end = PrimApp (PrimFromIntegral itp numType) $ index reprSeg shSeg segments $ Pair Nil $ mkBinary (PrimAdd numType) x2 (mkConstant (TupRsingle scalarTypeInt) 1) + index' = index (ArrayR shr tp) sh input + cond = Lam (lhsE `LeftHandSidePair` LeftHandSideSingle scalarTypeInt) $ Body $ mkBinary (PrimLt singleType) (Evar $ Var scalarTypeInt ZeroIdx) end + step = Lam (lhsE `LeftHandSidePair` LeftHandSideSingle scalarTypeInt) $ Body $ Pair + (apply2 tp f (expVars $ valueE $ weakenSucc weakenId) (index' $ Pair (expVars $ fst' $ valueSh (weakenSucc' kE)) $ Evar $ Var scalarTypeInt ZeroIdx)) + (mkBinary (PrimAdd numType) (Evar $ Var scalarTypeInt ZeroIdx) (mkConstant (TupRsingle scalarTypeInt) 1)) + initial = case def of + Just (ArgExp d) -> Pair (weakenE kSh d) start + Nothing -> Pair (index (ArrayR shr tp) sh input $ Pair (expVars $ fst' $ valueSh weakenId) start) (mkBinary (PrimAdd numType) start $ mkConstant (TupRsingle scalarTypeInt) 1) + + fst' :: ExpVars env (a, b) -> ExpVars env a + fst' (TupRpair a _) = a + fst' _ = error "Impossible pair" + in + Lam lhsSh + $ Body + $ Let (lhsE `LeftHandSidePair` LeftHandSideWildcard (TupRsingle scalarTypeInt)) (While cond step initial) + $ expVars $ valueE weakenId From c22b11de6dbc80ac4f414a6f51f6799d35776bdf Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Thu, 1 Oct 2020 21:12:43 +0200 Subject: [PATCH 010/813] Some work on Schedules --- src/Data/Array/Accelerate/AST/Environment.hs | 102 ++- src/Data/Array/Accelerate/AST/Idx.hs | 14 + src/Data/Array/Accelerate/AST/Operation.hs | 53 +- .../Array/Accelerate/AST/Schedule/Uniform.hs | 160 +++++ src/Data/Array/Accelerate/AST/Var.hs | 2 +- src/Data/Array/Accelerate/Schedule.hs | 82 +++ src/Data/Array/Accelerate/Trafo.hs | 3 + src/Data/Array/Accelerate/Trafo/Desugar.hs | 10 +- .../Array/Accelerate/Trafo/NewNewFusion.hs | 4 + .../Trafo/Operation/Substitution.hs | 64 +- .../Accelerate/Trafo/Schedule/Uniform.hs | 633 ++++++++++++++++++ 11 files changed, 1088 insertions(+), 39 deletions(-) create mode 100644 src/Data/Array/Accelerate/AST/Schedule/Uniform.hs create mode 100644 src/Data/Array/Accelerate/Schedule.hs create mode 100644 src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs diff --git a/src/Data/Array/Accelerate/AST/Environment.hs b/src/Data/Array/Accelerate/AST/Environment.hs index 7f9b217f9..8cb663dc1 100644 --- a/src/Data/Array/Accelerate/AST/Environment.hs +++ b/src/Data/Array/Accelerate/AST/Environment.hs @@ -16,8 +16,15 @@ -- Portability : non-portable (GHC extensions) -- -module Data.Array.Accelerate.AST.Environment - where +module Data.Array.Accelerate.AST.Environment ( + Env(..), PartialEnv(..), Val, + push, push', prj, prj', prjPartial, + mergePartialEnv, EnvBinding(..), partialEnvFromList, + + prjUpdate', prjReplace', update', updates', mapEnv, + Identity(..), (:>)(..), weakenId, weakenSucc, weakenSucc', weakenEmpty, + sink, (.>), sinkWithLHS, weakenWithLHS, substituteLHS, +) where import Data.Array.Accelerate.AST.Idx import Data.Array.Accelerate.AST.Var @@ -25,7 +32,8 @@ import Data.Array.Accelerate.AST.LeftHandSide import Data.Array.Accelerate.Error import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Analysis.Match ((:~:)(..)) - +import Data.Either +import Data.List -- Valuation for an environment -- @@ -33,6 +41,11 @@ data Env f env where Empty :: Env f () Push :: Env f env -> f t -> Env f (env, t) +data PartialEnv f env where + PEnd :: PartialEnv f env + PPush :: PartialEnv f env -> f t -> PartialEnv f (env, t) + PNone :: PartialEnv f env -> PartialEnv f (env, t) + type Val = Env Identity -- Push a set of variables into an environment @@ -55,7 +68,88 @@ prj ix v = runIdentity $ prj' ix v prj' :: Idx env t -> Env f env -> f t prj' ZeroIdx (Push _ v) = v -prj' (SuccIdx idx) (Push val _) = prj' idx val +prj' (SuccIdx idx) (Push env _) = prj' idx env + +prjPartial :: Idx env t -> PartialEnv f env -> Maybe (f t) +prjPartial ZeroIdx (PPush _ v) = Just v +prjPartial (SuccIdx idx) (PPush env _) = prjPartial idx env +prjPartial _ _ = Nothing + +mergePartialEnv :: (forall t. f t -> f t -> f t) -> PartialEnv f env -> PartialEnv f env -> PartialEnv f env +mergePartialEnv _ PEnd env = env +mergePartialEnv _ env PEnd = env +mergePartialEnv g (PNone e1 ) (PNone e2 ) = PNone (mergePartialEnv g e1 e2) +mergePartialEnv g (PPush e1 a) (PNone e2 ) = PPush (mergePartialEnv g e1 e2) a +mergePartialEnv g (PNone e1 ) (PPush e2 b) = PPush (mergePartialEnv g e1 e2) b +mergePartialEnv g (PPush e1 a) (PPush e2 b) = PPush (mergePartialEnv g e1 e2) (g a b) + +data EnvBinding f env where + EnvBinding :: Idx env t -> f t -> EnvBinding f env + +partialEnvFromList :: forall f env. (forall t. f t -> f t -> f t) -> [EnvBinding f env] -> PartialEnv f env +-- Pair with ints to make sorting faster. +partialEnvFromList g = go SkipNone . map snd . sortOn fst . map (\b@(EnvBinding ix _) -> (idxToInt ix, b)) + where + go :: Skip env env' -> [EnvBinding f env] -> PartialEnv f env' + go _ [] = PEnd + go skip (EnvBinding idx v : bs) = go' skip (EnvBinding idx' v) bs + where + idx' = case skipIdx skip idx of + Just i -> i + Nothing -> error "List wasn't sorted properly" + + go' :: Skip env env' -> EnvBinding f env' -> [EnvBinding f env] -> PartialEnv f env' + go' skip (EnvBinding (SuccIdx idx) v) bs = PNone $ go' (SkipSucc skip) (EnvBinding idx v) bs + go' skip (EnvBinding ZeroIdx v) bs = go'' skip v bs + + go'' :: Skip env (env', t) -> f t -> [EnvBinding f env] -> PartialEnv f (env', t) + go'' _ v [] = PPush PEnd v + go'' skip v (EnvBinding idx v' : bs) = case skipIdx skip idx of + Nothing -> error "List wasn't sorted properly" + Just ZeroIdx -> go'' skip (g v v') bs + Just (SuccIdx idx') -> PPush (go' (SkipSucc skip) (EnvBinding idx' v') bs) v + +data Skip env env' where + SkipSucc :: Skip env (env', t) -> Skip env env' + SkipNone :: Skip env env + +skipIdx :: Skip env env' -> Idx env t -> Maybe (Idx env' t) +skipIdx SkipNone idx = Just idx +skipIdx (SkipSucc s) idx = case skipIdx s idx of + Just (SuccIdx idx') -> Just idx' + _ -> Nothing + +prjUpdate' :: (f t -> (f t, a)) -> Idx env t -> Env f env -> (Env f env, a) +prjUpdate' f ZeroIdx (Push env v) = (Push env v', a) + where (v', a) = f v +prjUpdate' f (SuccIdx idx) (Push env v) = (Push env' v, a) + where (env', a) = prjUpdate' f idx env + +prjReplace' :: Idx env t -> f t -> Env f env -> (Env f env, f t) +prjReplace' ix val = prjUpdate' (\v -> (val, v)) ix + +update' :: (f t -> f t) -> Idx env t -> Env f env -> Env f env +update' f ZeroIdx (Push env v) = Push env (f v) +update' f (SuccIdx idx) (Push env v) = Push (update' f idx env) v + +-- Updates an environment for a list of indices. This is prefered over +-- calling update' multiple times, as that will create many 'Push' objects +-- as garbage. +-- Duplicate indices are handled only once. +-- +updates' :: forall a f t env. (a -> f t -> f t) -> [(Idx env t, a)] -> Env f env -> Env f env +updates' _ [] env = env +updates' f indices (Push env (v :: f s)) = updates' f succs env `Push` v' + where + g :: (Idx (env', s) t, a) -> Either (f s) (Idx env' t, a) + g (ZeroIdx, a) = Left $ f a v + g (SuccIdx idx, a) = Right (idx, a) + (zeros, succs) = partitionEithers $ map g indices + v' :: f s + v' = case zeros of + v'' : _ -> v'' -- This index is in the list + [] -> v -- The index wasn't found +updates' _ _ Empty = Empty mapEnv :: (forall t. a t -> b t) -> Env a env -> Env b env mapEnv _ Empty = Empty diff --git a/src/Data/Array/Accelerate/AST/Idx.hs b/src/Data/Array/Accelerate/AST/Idx.hs index 12362dce2..5b1e1c274 100644 --- a/src/Data/Array/Accelerate/AST/Idx.hs +++ b/src/Data/Array/Accelerate/AST/Idx.hs @@ -27,6 +27,20 @@ data Idx env t where ZeroIdx :: Idx (env, t) t SuccIdx :: Idx env t -> Idx (env, s) t +instance Eq (Idx env t) where + ZeroIdx == ZeroIdx = True + SuccIdx ix == SuccIdx ix' = ix == ix' + _ == _ = False + +instance Ord (Idx env t) where + ZeroIdx < SuccIdx _ = True + SuccIdx ix < SuccIdx ix' = ix < ix' + _ < _ = False + + ZeroIdx <= _ = True + SuccIdx ix <= SuccIdx ix' = ix <= ix' + _ <= _ = False + data PairIdx p a where PairIdxLeft :: PairIdx (a, b) a PairIdxRight :: PairIdx (a, b) b diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index e62f84a82..a5a35d532 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -24,6 +24,7 @@ module Data.Array.Accelerate.AST.Operation ( PreOpenAcc(..), PreOpenAfun(..), OperationAcc, OperationAfun, Execute(..), + Uniqueness(..), Uniquenesses, shared, GroundR(..), GroundsR, GroundVar, GroundVars, GLeftHandSide, Var(..), Vars, HasGroundsR(..), groundToExpVar, @@ -107,10 +108,11 @@ data PreOpenAcc exe env a where -- As it is common in this intermediate representation to evaluate some program -- resulting in unit, for instance when execution some operation, and then -- and then do some other code, we write 'a; b' to denote 'let () = a in b'. - Alet :: GLeftHandSide t env env' + Alet :: GLeftHandSide bnd env env' + -> Uniquenesses bnd + -> PreOpenAcc exe env bnd + -> PreOpenAcc exe env' t -> PreOpenAcc exe env t - -> PreOpenAcc exe env' b - -> PreOpenAcc exe env b -- | Allocates a new buffer of the given size. -- @@ -140,11 +142,14 @@ data PreOpenAcc exe env a where -> PreOpenAcc exe env a -- Value-recursion for array-level computations + -- The uniqueness guarantees are an invariant of the loop + -- and should hold before and after each iteration. -- - Awhile :: PreOpenAfun exe env (arrs -> PrimBool) - -> PreOpenAfun exe env (arrs -> arrs) - -> GroundVars env arrs - -> PreOpenAcc exe env arrs + Awhile :: Uniquenesses a + -> PreOpenAfun exe env (a -> PrimBool) + -> PreOpenAfun exe env (a -> a) + -> GroundVars env a + -> PreOpenAcc exe env a -- | Function abstraction over parametrised array computations -- @@ -164,10 +169,22 @@ data GroundR a where type GroundsR = TupR GroundR -- | Types for local bindings +-- type GLeftHandSide = LeftHandSide GroundR type GroundVar = Var GroundR type GroundVars env = Vars GroundR env +-- | Uniqueness annotations for buffers +-- +data Uniqueness t where + Unique :: Uniqueness (Buffer t) + Shared :: Uniqueness t + +type Uniquenesses = TupR Uniqueness + +shared :: TupR s t -> Uniquenesses t +shared = mapTupR (\_ -> Shared) + -- | The arguments to be passed to an operation of type `t`. -- This type is represented as a cons list, separated by (->) and ending -- in (). This function type represents the type of the operations. @@ -250,12 +267,12 @@ instance HasGroundsR (PreOpenAcc exe env) where groundsR (Exec _) = TupRunit groundsR (Return vars) = groundsR vars groundsR (Compute e) = groundsR e - groundsR (Alet _ _ a) = groundsR a + groundsR (Alet _ _ _ a) = groundsR a groundsR (Alloc _ tp _) = TupRsingle $ GroundRbuffer tp groundsR (Use tp _) = TupRsingle $ GroundRbuffer tp groundsR (Unit (Var tp _)) = TupRsingle $ GroundRbuffer tp groundsR (Acond _ a _) = groundsR a - groundsR (Awhile _ _ a) = groundsR a + groundsR (Awhile _ _ _ a) = groundsR a instance HasGroundsR (GroundVar env) where groundsR (Var repr _) = TupRsingle repr @@ -401,15 +418,15 @@ instance IsExecutableAcc (Execute op) where mapAccExecutable :: (forall benv'. exe benv' -> exe' benv') -> PreOpenAcc exe benv t -> PreOpenAcc exe' benv t mapAccExecutable f = \case - Exec exe -> Exec $ f exe - Return vars -> Return vars - Compute e -> Compute e - Alet lhs bnd body -> Alet lhs (mapAccExecutable f bnd) (mapAccExecutable f body) - Alloc shr tp sh -> Alloc shr tp sh - Use tp buffer -> Use tp buffer - Unit vars -> Unit vars - Acond var a1 a2 -> Acond var (mapAccExecutable f a1) (mapAccExecutable f a2) - Awhile c g a -> Awhile (mapAfunExecutable f c) (mapAfunExecutable f g) a + Exec exe -> Exec $ f exe + Return vars -> Return vars + Compute e -> Compute e + Alet lhs uniqueness bnd body -> Alet lhs uniqueness (mapAccExecutable f bnd) (mapAccExecutable f body) + Alloc shr tp sh -> Alloc shr tp sh + Use tp buffer -> Use tp buffer + Unit vars -> Unit vars + Acond var a1 a2 -> Acond var (mapAccExecutable f a1) (mapAccExecutable f a2) + Awhile uniqueness c g a -> Awhile uniqueness (mapAfunExecutable f c) (mapAfunExecutable f g) a mapAfunExecutable :: (forall benv'. exe benv' -> exe' benv') -> PreOpenAfun exe benv t -> PreOpenAfun exe' benv t mapAfunExecutable f (Abody a) = Abody $ mapAccExecutable f a diff --git a/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs b/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs new file mode 100644 index 000000000..90660daaf --- /dev/null +++ b/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs @@ -0,0 +1,160 @@ +{-# LANGUAGE GADTs #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE TypeFamilies #-} +{-# OPTIONS_HADDOCK hide #-} +-- | +-- Module : Data.Array.Accelerate.Schedule.Uniform +-- Copyright : [2008..2020] The Accelerate Team +-- License : BSD3 +-- +-- Maintainer : Trevor L. McDonell +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- + +module Data.Array.Accelerate.AST.Schedule.Uniform ( + UniformSchedule(..), UniformScheduleFun(..), + Input, Output, InputOutputR(..), + Binding(..), Effect(..), + BaseR(..), BasesR, BaseVar, BaseVars, BLeftHandSide, + Signal(..), SignalResolver(..), Ref(..), OutputRef(..), + module Partitioned, +) where + +import Data.Array.Accelerate.AST.Environment +import Data.Array.Accelerate.AST.Exp +import Data.Array.Accelerate.AST.Operation (GroundR(..), GroundsR, GroundVar, GroundVars, Exp, OpenExp, Fun, OpenFun, Arg(..), Args, PreArgs(..), ArrayInstr(..)) +import Data.Array.Accelerate.AST.Idx +import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.AST.Var +import Data.Array.Accelerate.Type +import Data.Array.Accelerate.Representation.Array +import Data.Array.Accelerate.Representation.Shape +import Data.Array.Accelerate.Representation.Type +import Data.Array.Accelerate.AST.Partitioned as Partitioned hiding (PartitionedAcc, PartitionedAfun, PreOpenAcc(..), PreOpenAfun(..)) +import Control.Concurrent.MVar +import Data.IORef + +-- Generic schedule for a uniform memory space and uniform scheduling. +-- E.g., we don't have host and device memory or scheduling. +-- The schedule will exploit task parallelism. + +-- The schedule consists of bindings, effects and (parallel) control flow +data UniformSchedule exe env where + Return :: UniformSchedule exe env + + Alet :: BLeftHandSide t env env' + -> Binding env t + -> UniformSchedule exe env' + -> UniformSchedule exe env + + Effect :: Effect exe env + -> UniformSchedule exe env + -> UniformSchedule exe env + + Acond :: ExpVar env PrimBool + -> UniformSchedule exe env + -> UniformSchedule exe env + -> UniformSchedule exe env + + Awhile :: InputOutputR input output + -> UniformScheduleFun exe env (input -> Output PrimBool -> ()) + -> UniformScheduleFun exe env (input -> output -> ()) + -> BaseVars env input + -> UniformSchedule exe env + + Fork :: UniformSchedule exe env + -> UniformSchedule exe env + -> UniformSchedule exe env + +data UniformScheduleFun exe env t where + Slam :: BLeftHandSide s env env' + -> UniformScheduleFun exe env' t + -> UniformScheduleFun exe env (s -> t) + + Sbody :: UniformSchedule exe env' + -> UniformScheduleFun exe env () + +type family Input t where + Input () = () + Input (a, b) = (Input a, Input b) + Input t = (Signal, Ref t) + +type family Output t where + Output () = () + Output (a, b) = (Output a, Output b) + Output t = (SignalResolver, OutputRef t) + +-- Relation between input and output +data InputOutputR input output where + InputOutputRsignal :: InputOutputR Signal SignalResolver + InputOutputRref :: InputOutputR (Ref f) (OutputRef t) + InputOutputRpair :: InputOutputR i1 o1 + -> InputOutputR i2 o2 + -> InputOutputR (i1, i2) (o1, o2) + InputOutputRunit :: InputOutputR () () + +-- Bindings of instructions which have some return value. +-- They cannot perform side effects. +-- +data Binding env t where + Compute :: Exp env t + -> Binding env t + + NewSignal :: Binding env (Signal, SignalResolver) + + NewRef :: GroundR t + -> Binding env (Ref t, OutputRef t) + + Alloc :: ShapeR sh + -> ScalarType e + -> ExpVars env sh + -> Binding env (Buffer e) + + Use :: ScalarType e + -> Buffer e + -> Binding env (Buffer e) + + Unit :: ExpVar env e + -> Binding env (Buffer e) + + -- undefined result if the Ref hasn't been written + RefRead :: BaseVar env (Ref t) -> Binding env t + +-- Effects do not have a return value. +data Effect exe env where + Exec :: exe env + -> Effect exe env + + SignalAwait :: [BaseVar env Signal] -> Effect exe env + + SignalResolve :: [BaseVar env SignalResolver] -> Effect exe env + + RefWrite :: BaseVar env (OutputRef t) -> BaseVar env t -> Effect exe env + +-- A base value in the schedule is a scalar, buffer, a signal (resolver) +-- or a (possibly mutable) reference +-- +data BaseR t where + BaseRground :: GroundR t -> BaseR t + BaseRsignal :: BaseR Signal + BaseRsignalResolver :: BaseR SignalResolver + BaseRref :: GroundR t -> BaseR (Ref t) + BaseRrefWrite :: GroundR t -> BaseR (OutputRef t) + +-- Tuples of base values +type BasesR = TupR BaseR + +type BaseVar = Var BaseR +type BaseVars env = Vars BaseR env + +type BLeftHandSide = LeftHandSide BaseR + +newtype Signal = Signal (MVar ()) +newtype SignalResolver = SignalResolver (MVar ()) + +-- Note: Refs should only be assigned once. They start undefined, and are at some point resolved to a value +newtype Ref t = Ref (IORef t) +newtype OutputRef t = OutputRef (IORef t) diff --git a/src/Data/Array/Accelerate/AST/Var.hs b/src/Data/Array/Accelerate/AST/Var.hs index 4b7cec4f0..f4076a3b7 100644 --- a/src/Data/Array/Accelerate/AST/Var.hs +++ b/src/Data/Array/Accelerate/AST/Var.hs @@ -1,7 +1,7 @@ {-# LANGUAGE GADTs #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE TemplateHaskell #-} -{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE TypeOperators #-} {-# OPTIONS_HADDOCK hide #-} -- | -- Module : Data.Array.Accelerate.AST.Var diff --git a/src/Data/Array/Accelerate/Schedule.hs b/src/Data/Array/Accelerate/Schedule.hs new file mode 100644 index 000000000..edb322f2d --- /dev/null +++ b/src/Data/Array/Accelerate/Schedule.hs @@ -0,0 +1,82 @@ +{-# LANGUAGE AllowAmbiguousTypes #-} +{-# LANGUAGE CPP #-} +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE PatternGuards #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE ViewPatterns #-} + +-- | +-- Module : Data.Array.Accelerate.Schedule +-- Copyright : [2012..2020] The Accelerate Team +-- License : BSD3 +-- +-- Maintainer : Trevor L. McDonell +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- +-- This module should implement fusion. +-- + +module Data.Array.Accelerate.Schedule ( + IsSchedule(..), + convertSchedule, + Scheduled, + reprIsBody, +) where + +import Data.Array.Accelerate.AST.Partitioned +import Data.Array.Accelerate.Error +import Data.Array.Accelerate.Type +import Data.Array.Accelerate.Representation.Type +import Data.Typeable ( (:~:)(..) ) + +import Data.Array.Accelerate.Debug.Flags ( array_fusion ) + +class IsSchedule sched where + -- 'a' is a ground type (ie, can be represented using GroundR) + type ScheduleInput sched a + type ScheduleOutput sched a + + convertScheduleFun :: PartitionedAfun op () t -> sched (Cluster op) (Scheduled sched t) + + mapSchedule :: (forall env'. exe env' -> exe' env') -> sched exe env -> sched exe' env + +convertSchedule :: forall sched op t. IsSchedule sched => PartitionedAcc op () t -> sched (Cluster op) (ScheduleOutput sched t -> ()) +convertSchedule acc + | Refl <- reprIsBody @sched $ groundsR acc = convertScheduleFun (Abody acc) + +type family Scheduled sched a where + Scheduled sched (a -> b) = ScheduleInput sched a -> Scheduled sched b + Scheduled sched a = ScheduleOutput sched a -> () + +reprIsBody :: forall sched t. GroundsR t -> Scheduled sched t :~: (ScheduleOutput sched t -> ()) +reprIsBody TupRunit = Refl +reprIsBody TupRpair{} = Refl +reprIsBody (TupRsingle (GroundRbuffer _)) = Refl +reprIsBody (TupRsingle (GroundRscalar (VectorScalarType _))) = Refl +reprIsBody (TupRsingle (GroundRscalar (SingleScalarType (NumSingleType t)))) = case t of + IntegralNumType TypeInt -> Refl + IntegralNumType TypeInt8 -> Refl + IntegralNumType TypeInt16 -> Refl + IntegralNumType TypeInt32 -> Refl + IntegralNumType TypeInt64 -> Refl + IntegralNumType TypeWord -> Refl + IntegralNumType TypeWord8 -> Refl + IntegralNumType TypeWord16 -> Refl + IntegralNumType TypeWord32 -> Refl + IntegralNumType TypeWord64 -> Refl + FloatingNumType TypeHalf -> Refl + FloatingNumType TypeFloat -> Refl + FloatingNumType TypeDouble -> Refl + diff --git a/src/Data/Array/Accelerate/Trafo.hs b/src/Data/Array/Accelerate/Trafo.hs index 31020f4d1..a3bf00bf6 100644 --- a/src/Data/Array/Accelerate/Trafo.hs +++ b/src/Data/Array/Accelerate/Trafo.hs @@ -42,6 +42,9 @@ import qualified Data.Array.Accelerate.Trafo.Exp.Simplify as Rewrite import qualified Data.Array.Accelerate.Trafo.Sharing as Sharing import qualified Data.Array.Accelerate.Trafo.Desugar as Desugar import qualified Data.Array.Accelerate.Trafo.NewNewFusion as NewNewFusion +import qualified Data.Array.Accelerate.Schedule as Schedule +import qualified Data.Array.Accelerate.AST.Schedule.Uniform as Schedule +import qualified Data.Array.Accelerate.Trafo.Schedule.Uniform as Schedule -- import qualified Data.Array.Accelerate.Trafo.Vectorise as Vectorise import Control.DeepSeq diff --git a/src/Data/Array/Accelerate/Trafo/Desugar.hs b/src/Data/Array/Accelerate/Trafo/Desugar.hs index 819ccbf1a..b85680bba 100644 --- a/src/Data/Array/Accelerate/Trafo/Desugar.hs +++ b/src/Data/Array/Accelerate/Trafo/Desugar.hs @@ -192,7 +192,7 @@ class DesugarAcc (op :: Type -> Type) where g = Alam lhs2 $ Abody $ mkDefaultFoldStep2 (weaken (kBf .> kSh .> k1) f) argTmp (weaken (kBf .> kSh .> k1) output) in alet lhs1 (mkDefaultFoldStep1 f def input output) - $ alet (LeftHandSideWildcard $ desugarArrayR repr) (Awhile c g $ value1 weakenId) + $ alet (LeftHandSideWildcard $ desugarArrayR repr) (Awhile (shared $ desugarArrayR repr) c g $ value1 weakenId) $ Return TupRunit mkFoldSeg :: IntegralType i @@ -258,7 +258,7 @@ class DesugarAcc (op :: Type -> Type) where $ Return $ TupRsingle (Var (GroundRscalar scalarTypeInt) ZeroIdx) `TupRpair` valueAlloc (weakenSucc weakenId) in alet (LeftHandSideSingle $ GroundRscalar scalarTypeInt) (Compute $ mkConstant (TupRsingle scalarTypeInt) 1) - $ alet lhs (Awhile c g (TupRsingle (Var (GroundRscalar scalarTypeInt) ZeroIdx) `TupRpair` weakenVars (weakenSucc weakenId) input)) + $ alet lhs (Awhile (shared $ lhsToTupR lhs) c g (TupRsingle (Var (GroundRscalar scalarTypeInt) ZeroIdx) `TupRpair` weakenVars (weakenSucc weakenId) input)) $ mkGenerate reduce (weaken (weakenSucc $ weakenSucc kTmp) argOut) mkScan' :: Direction @@ -384,10 +384,10 @@ desugarOpenAcc env = travA lhsScalarBool = LeftHandSidePair (LeftHandSideWildcard TupRunit) (LeftHandSideSingle bufferType) env' = weakenBEnv k env c' = case desugarOpenAfun env' c of - Alam lhs' (Abody body) -> Alam lhs' $ Abody $ Alet lhsScalarBool body $ Compute $ ArrayInstr (Index $ Var bufferType ZeroIdx) $ Const scalarTypeInt 0 + Alam lhs' (Abody body) -> Alam lhs' $ Abody $ Alet lhsScalarBool (TupRsingle Shared) body $ Compute $ ArrayInstr (Index $ Var bufferType ZeroIdx) $ Const scalarTypeInt 0 Abody _ -> error "It's a long time since we last met" f' = desugarOpenAfun env' f - in alet lhs (travA i) $ Awhile c' f' (value weakenId) + in alet lhs (travA i) $ Awhile (shared $ desugarArraysR repr) c' f' (value weakenId) Named.Use repr array -> desugarUse repr array Named.Unit tp e | DeclareVars lhs _ value <- declareVars tp -> @@ -1254,7 +1254,7 @@ mkDefaultFoldStep2 (ArgFun f) argIn@(ArgArray _ (ArrayR shr@(ShapeRsnoc shr') tp -- mkDefaultFoldAllocOrOutput :: Arg benv (Out sh e) -> ExpVars benv (sh, Int) -> OperationAcc op benv (Buffers e) mkDefaultFoldAllocOrOutput (ArgArray _ (ArrayR shr e) _ output) sh@(TupRpair _ y) - = Alet (LeftHandSideSingle $ GroundRscalar scalarType) (Compute $ mkBinary (PrimEq singleType) (paramsIn' y) $ mkConstant (TupRsingle scalarTypeInt) 1) + = Alet (LeftHandSideSingle $ GroundRscalar scalarType) (TupRsingle Shared) (Compute $ mkBinary (PrimEq singleType) (paramsIn' y) $ mkConstant (TupRsingle scalarTypeInt) 1) $ Acond (Var scalarTypeWord8 ZeroIdx) (Return $ weakenVars (weakenSucc weakenId) output) (desugarAlloc (ArrayR (ShapeRsnoc shr) e) $ weakenVars (weakenSucc weakenId) sh) diff --git a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs index a1329405f..886a16330 100644 --- a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs +++ b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs @@ -4,6 +4,7 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE KindSignatures #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE PatternGuards #-} @@ -43,9 +44,12 @@ import qualified Data.Array.Accelerate.Debug.Stats as Stats import System.IO.Unsafe -- for debugging #endif + -- Array Fusion -- ============ +class FusibleAcc (op :: * -> *) where + -- | Apply the fusion transformation to a de Bruijn AST -- convertAcc diff --git a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs index 80f60bfb5..099030504 100644 --- a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs +++ b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs @@ -31,6 +31,8 @@ module Data.Array.Accelerate.Trafo.Operation.Substitution ( reindexPartialAfun, pair, alet, weakenArrayInstr, + strengthenArrayInstr, + expGroundVars, funGroundVars, ) where import Data.Array.Accelerate.AST.Idx @@ -42,6 +44,7 @@ import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Trafo.Var import Data.Array.Accelerate.Trafo.Substitution (Sink(..)) import Data.Array.Accelerate.Trafo.Exp.Substitution +import Data.Array.Accelerate.Trafo.Exp.Shrink data SunkReindexPartial f env env' where Sink :: SunkReindexPartial f env env' -> SunkReindexPartial f (env, s) (env', s) @@ -99,13 +102,13 @@ reindexA' k = \case Exec exe -> Exec <$> reindexExecPartial (reindex' k) exe Return vars -> Return <$> reindexVars' k vars Compute e -> Compute <$> reindexExp' k e - Alet lhs bnd body - | Exists lhs' <- rebuildLHS lhs -> Alet lhs' <$> travA bnd <*> reindexA' (sinkReindexWithLHS lhs lhs' k) body + Alet lhs uniqueness bnd body + | Exists lhs' <- rebuildLHS lhs -> Alet lhs' uniqueness <$> travA bnd <*> reindexA' (sinkReindexWithLHS lhs lhs' k) body Alloc shr tp sh -> Alloc shr tp <$> reindexVars' k sh Use tp buffer -> pure $ Use tp buffer Unit var -> Unit <$> reindexVar' k var Acond c t f -> Acond <$> reindexVar' k c <*> travA t <*> travA f - Awhile c f i -> Awhile <$> reindexAfun' k c <*> reindexAfun' k f <*> reindexVars' k i + Awhile uniqueness c f i -> Awhile uniqueness <$> reindexAfun' k c <*> reindexAfun' k f <*> reindexVars' k i where travA :: PreOpenAcc exe env s -> f (PreOpenAcc exe env' s) travA = reindexA' k @@ -123,29 +126,31 @@ pair a b = goA weakenId a -- and then use the newly defined variables instead. -- goA :: env :> env' -> PreOpenAcc exe env' a -> PreOpenAcc exe env' (a, b) - goA k (Alet lhs bnd x) = Alet lhs bnd $ goA (weakenWithLHS lhs .> k) x + goA k (Alet lhs uniqueness bnd x) + = Alet lhs uniqueness bnd $ goA (weakenWithLHS lhs .> k) x goA k (Return vars) = goB vars $ weaken k b goA k acc | DeclareVars lhs k' value <- declareVars $ groundsR acc - = Alet lhs acc $ goB (value weakenId) $ weaken (k' .> k) b + = Alet lhs (shared $ groundsR acc) acc $ goB (value weakenId) $ weaken (k' .> k) b goB :: GroundVars env' a -> PreOpenAcc exe env' b -> PreOpenAcc exe env' (a, b) - goB varsA (Alet lhs bnd x) = Alet lhs bnd $ goB (weakenVars (weakenWithLHS lhs) varsA) x + goB varsA (Alet lhs uniqueness bnd x) + = Alet lhs uniqueness bnd $ goB (weakenVars (weakenWithLHS lhs) varsA) x goB varsA (Return varsB) = Return (TupRpair varsA varsB) goB varsA acc | DeclareVars lhs k value <- declareVars $ groundsR b - = Alet lhs acc $ Return (TupRpair (weakenVars k varsA) (value weakenId)) + = Alet lhs (shared $ groundsR b) acc $ Return (TupRpair (weakenVars k varsA) (value weakenId)) alet :: IsExecutableAcc exe => GLeftHandSide t env env' -> PreOpenAcc exe env t -> PreOpenAcc exe env' s -> PreOpenAcc exe env s -alet lhs1 (Alet lhs2 a1 a2) a3 - | Exists lhs1' <- rebuildLHS lhs1 = Alet lhs2 a1 $ alet lhs1' a2 $ weaken (sinkWithLHS lhs1 lhs1' $ weakenWithLHS lhs2) a3 +alet lhs1 (Alet lhs2 uniqueness a1 a2) a3 + | Exists lhs1' <- rebuildLHS lhs1 = Alet lhs2 uniqueness a1 $ alet lhs1' a2 $ weaken (sinkWithLHS lhs1 lhs1' $ weakenWithLHS lhs2) a3 alet (LeftHandSideWildcard TupRunit) (Return TupRunit) a = a alet (LeftHandSideWildcard TupRunit) (Compute Nil) a = a -alet lhs@(LeftHandSideWildcard TupRunit) bnd a = Alet lhs bnd a +alet lhs@(LeftHandSideWildcard TupRunit) bnd a = Alet lhs TupRunit bnd a alet lhs (Return vars) a = weaken (substituteLHS lhs vars) a alet lhs (Compute e) a | Just vars <- extractParams e = weaken (substituteLHS lhs vars) a -alet lhs bnd a = Alet lhs bnd a +alet lhs bnd a = Alet lhs (shared $ lhsToTupR lhs) bnd a extractParams :: OpenExp env benv t -> Maybe (ExpVars benv t) extractParams Nil = Just TupRunit @@ -160,3 +165,40 @@ extractParams _ = Nothing -- weakenArrayInstr :: RebuildableExp f => aenv :> aenv' -> f (ArrayInstr aenv) env t -> f (ArrayInstr aenv') env t weakenArrayInstr k = rebuildArrayInstr (ArrayInstr . weaken k) + +strengthenArrayInstr :: forall f benv benv' env t. RebuildableExp f => benv :?> benv' -> f (ArrayInstr benv) env t -> Maybe (f (ArrayInstr benv') env t) +strengthenArrayInstr k = rebuildArrayInstrPartial f + where + f :: ArrayInstr benv (u -> s) -> Maybe (OpenExp env' benv' u -> OpenExp env' benv' s) + f (Parameter (Var tp ix)) = ArrayInstr . Parameter . Var tp <$> k ix + f (Index (Var tp ix)) = ArrayInstr . Index . Var tp <$> k ix + +expGroundVars :: OpenExp env benv t -> [Exists (GroundVar benv)] +expGroundVars = map arrayInstrGroundVars . arrayInstrsInExp + +funGroundVars :: OpenFun env benv t -> [Exists (GroundVar benv)] +funGroundVars = map arrayInstrGroundVars . arrayInstrsInFun + +arrayInstrGroundVars :: Exists (ArrayInstr benv) -> Exists (GroundVar benv) +arrayInstrGroundVars (Exists (Parameter (Var tp ix))) = Exists $ Var (GroundRscalar tp) ix +arrayInstrGroundVars (Exists (Index var)) = Exists var + +argVars :: Arg benv t -> [(Exists (GroundVar benv), {- Mutable -} Bool)] +argVars (ArgExp e) = map (, False) $ expGroundVars e +argVars (ArgFun f) = map (, False) $ funGroundVars f +argVars (ArgVar vars) = map (, False) $ flattenTupR $ mapVars GroundRscalar vars +argVars (ArgArray m _ sh buffers) + = map (, False) (flattenTupR sh) + ++ map (, mut) (flattenTupR buffers) + where + mut = case m of + In -> False + _ -> True + +flattenTupR :: TupR s t -> [Exists s] +flattenTupR = (`go` []) + where + go :: TupR s t -> [Exists s] -> [Exists s] + go (TupRsingle s) accum = Exists s : accum + go (TupRpair t1 t2) accum = go t1 $ go t2 accum + go TupRunit accum = accum diff --git a/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs b/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs new file mode 100644 index 000000000..09ea471a3 --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs @@ -0,0 +1,633 @@ +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE PatternGuards #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TupleSections #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE ViewPatterns #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# OPTIONS_HADDOCK hide #-} +-- | +-- Module : Data.Array.Accelerate.Trafo.Operation.Substitution +-- Copyright : [2012..2020] The Accelerate Team +-- License : BSD3 +-- +-- Maintainer : Trevor L. McDonell +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- + +module Data.Array.Accelerate.Trafo.Schedule.Uniform ( +) where + +import Data.Array.Accelerate.AST.Idx +import Data.Array.Accelerate.AST.Var +import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.AST.Schedule.Uniform +import Data.Array.Accelerate.AST.Environment +import qualified Data.Array.Accelerate.AST.Partitioned as C +import Data.Array.Accelerate.Trafo.Substitution +import Data.Array.Accelerate.Trafo.Exp.Substitution +import Data.Array.Accelerate.Trafo.Operation.Substitution (expGroundVars, strengthenArrayInstr) +import Data.Array.Accelerate.Representation.Array +import Data.Array.Accelerate.Representation.Type +import Data.Array.Accelerate.Type +import Data.Maybe +import Data.List +import qualified Data.Set as S + +-- * Compilation from PartitionedAcc to UniformSchedule +data FutureValue senv t + = Future (BaseVar senv (Ref t)) (BaseVar senv Signal) + | Ready (BaseVar senv t) + +weakenFutureValue :: senv :> senv' -> FutureValue senv t -> FutureValue senv' t +weakenFutureValue k (Future ref sig) = Future (weaken k ref) (weaken k sig) +weakenFutureValue k (Ready var) = Ready (weaken k var) + +data SignalInfo senv t where + -- Bool denotes whether the signal was already waited on. + SignalImplies :: Bool -> [Idx senv Signal] -> SignalInfo senv Signal + -- The SignalResolver resolves the given Signal + SignalResolvesTo :: Idx senv Signal -> SignalInfo senv SignalResolver + -- Used for bindings in the environment which are not a signal, or signal which don't have any implications linked to it + SignalNone :: SignalInfo senv t + +type SignalEnv senv = Env (SignalInfo senv) senv + +data Strengthen env env' where + StrengthenId :: Strengthen env env + StrengthenSucc :: Strengthen env env' -> Strengthen (env, t) env' + +strengthenIdx :: Strengthen env env' -> env :?> env' +strengthenIdx StrengthenId idx = Just idx +strengthenIdx (StrengthenSucc k) (SuccIdx idx) = strengthenIdx k idx +strengthenIdx (StrengthenSucc _) ZeroIdx = Nothing + +strengthenSignalInfo :: Strengthen senv senv' -> SignalInfo senv t -> SignalInfo senv' t +strengthenSignalInfo _ SignalNone = SignalNone +strengthenSignalInfo k (SignalImplies r i) = SignalImplies r $ mapMaybe (strengthenIdx k) i + +strengthenSignalEnv :: forall senv senv'. Strengthen senv senv' -> SignalEnv senv -> SignalEnv senv' +strengthenSignalEnv StrengthenId = id +strengthenSignalEnv k = go k + where + go :: forall senv1. Strengthen senv1 senv' -> Env (SignalInfo senv) senv1 -> SignalEnv senv' + go StrengthenId env = mapEnv (strengthenSignalInfo k) env + go (StrengthenSucc k') (Push env _) = go k' env + +weakenSignalInfo :: senv :> senv' -> SignalInfo senv t -> SignalInfo senv' t +weakenSignalInfo _ SignalNone = SignalNone +weakenSignalInfo k (SignalImplies r i) = SignalImplies r $ map (k >:>) i + +weakenSignalEnv :: senv :> senv' -> SignalEnv senv -> Env (SignalInfo senv') senv +weakenSignalEnv k = mapEnv (weakenSignalInfo k) + +-- A list of resolved signals (which we already awaited on), +-- and an environment mapping the ground variables to future values. +data FEnv senv genv = FEnv + -- A list of signals we waited on and the last signal we resolved. This is used to build `SignalImplies` we waiting on a next signal. + -- Note that we only store one last resolved signal, as we create a chain of resolved signals in the SignalEnv. + { fenvAwaitedSignals :: [Idx senv Signal] + -- Set of implications between signal, denoting that some signal will already be resolved when waiting on some other signal. + , fenvSignalInfo :: SignalEnv senv + -- Mapping from the ground environment (as used in PartitionedAcc) to the new environment + , fenvGround :: Env (FutureValue senv) genv + } + +-- Returns a new environment, which contains the information that this signal (and possibly others) +-- are resolved (have been waited on). Also returns a Bool denoting whether we should explicitly wait +-- on this signal. I.e., when it returns False, the signal was already previously waited on (possibly +-- indirectly through some other signal), so we don't have to wait on it again. +awaitSignal :: forall senv genv. Idx senv Signal -> FEnv senv genv -> (FEnv senv genv, Bool) +awaitSignal idx fenv = (fenv', shouldWait) + where + (signalEnv, shouldWait) = go True idx (fenvSignalInfo fenv) + fenv' = fenv{ fenvAwaitedSignals = if shouldWait then idx : fenvAwaitedSignals fenv else fenvAwaitedSignals fenv, fenvSignalInfo = signalEnv } + + go :: Bool -> Idx senv Signal -> Env (SignalInfo senv) senv -> (Env (SignalInfo senv) senv, Bool) + go direct idx' env = (foldr (\ix env' -> fst $ go False ix env') env' implied, shouldWait') + where + (env', (implied, shouldWait')) = prjUpdate' f idx' env + f :: SignalInfo senv Signal -> (SignalInfo senv Signal, ([Idx senv Signal], Bool)) + f SignalNone = (SignalImplies True [], ([], True)) + f (SignalImplies False i) = (SignalImplies True i , (i , True)) + f (SignalImplies True i) = (SignalImplies True i , ([], False)) + +awaitSignals :: [Idx senv Signal] -> FEnv senv genv -> (FEnv senv genv, [Idx senv Signal]) +awaitSignals signals fenv = (foldr (\idx fenv' -> fst $ awaitSignal idx fenv') fenv signals, minimal) + where + minimal = minimalAwaitSignals fenv signals + +-- Computes the transitive closure of the 'implies' relation on signals. +-- Stops the descend at signals in 'stopAt'. +signalTransitiveClosure :: forall senv genv. S.Set (Idx senv Signal) -> Idx senv Signal -> FEnv senv genv -> S.Set (Idx senv Signal) +signalTransitiveClosure stopAt idx fenv = go idx S.empty + where + go :: Idx senv Signal -> S.Set (Idx senv Signal) -> S.Set (Idx senv Signal) + go idx' visited + | idx' `S.member` visited = visited + | idx' `S.member` stopAt = S.insert idx' visited + | otherwise = case prj' idx' $ fenvSignalInfo fenv of + SignalImplies False i -> foldr go (S.insert idx' visited) i + _ -> S.insert idx' visited + +-- Shortens a list of signals, such that awaiting this shorter list implies that all the signals are resolved. +minimalAwaitSignals :: forall senv genv. FEnv senv genv -> [Idx senv Signal] -> [Idx senv Signal] +minimalAwaitSignals fenv signals = map fst $ filter f reachables + where + f :: (Idx senv Signal, S.Set (Idx senv Signal)) -> Bool + f self = any (isImpliedBy self) reachables + + -- 'self' is implied by 'other' if 'self' is in 'otherImplies' and if they do not form a cycle. + -- In case of a cycle, we say that the lowest index implies the other. + isImpliedBy :: (Idx senv Signal, S.Set (Idx senv Signal)) -> (Idx senv Signal, S.Set (Idx senv Signal)) -> Bool + isImpliedBy (self, selfImplies) (other, otherImplies) + | self == other = False + | self `S.member` otherImplies + = if other `S.member` selfImplies then + -- Cycle. We say that the lowest index implies the other. Thus, 'self' is implied by 'other' if other < self. + other < self + else + -- No cycle. 'self' is implied by 'other'. + True + | otherwise = False + + reachables :: [(Idx senv Signal, S.Set (Idx senv Signal))] + reachables = map (\idx -> (idx, signalTransitiveClosure set idx fenv)) signals + + set = S.fromList signals + +resolveSignal :: FEnv senv genv -> Idx senv SignalResolver -> FEnv senv genv +resolveSignal fenv resolver + | SignalResolvesTo signal <- prj' resolver $ fenvSignalInfo fenv = + let + (signalEnv, _) = prjReplace' signal (SignalImplies True (fenvAwaitedSignals fenv)) $ fenvSignalInfo fenv + in + fenv{ fenvSignalInfo = signalEnv, fenvAwaitedSignals = [signal] } +resolveSignal fenv _ = fenv + +resolveSignals :: forall senv genv. FEnv senv genv -> [Idx senv SignalResolver] -> FEnv senv genv +resolveSignals fenv resolvers = case signals of + [] -> fenv + (firstSignal : _) -> fenv{ fenvSignalInfo = signalEnv, fenvAwaitedSignals = [firstSignal] } + where + signals = mapMaybe findSignal $ nub resolvers + + findSignal :: Idx senv SignalResolver -> Maybe (Idx senv Signal) + findSignal idx = case prj' idx $ fenvSignalInfo fenv of + SignalResolvesTo signal -> Just signal + _ -> Nothing + + signalsWithOthers :: [(Idx senv Signal, [Idx senv Signal])] + signalsWithOthers = mapWithRemainder (\ix ixs -> (ix, ixs)) signals + + signalEnv = updates' f signalsWithOthers $ fenvSignalInfo fenv + + f others _ = SignalImplies True (others ++ fenvAwaitedSignals fenv) + +mapWithRemainder :: forall a b. (a -> [a] -> b) -> [a] -> [b] +mapWithRemainder f = go [] + where + go :: [a] -> [a] -> [b] + -- prefix is in reverse order + go prefix (x : xs) = f x (reverseAppend prefix xs) : go (x : prefix) xs + go _ [] = [] + + -- Reverses the first list and appends it to the second + reverseAppend :: [a] -> [a] -> [a] + reverseAppend [] accum = accum + reverseAppend (x:xs) accum = reverseAppend xs (x : accum) + +{- + +awaitFuture :: FEnv senv genv -> GroundVars genv t -> (forall senv'. senv :> senv' -> BaseVars senv' t -> UniformSchedule exe senv') -> UniformSchedule exe senv +awaitFuture env1 vars1 + = let (symbols, res) = go env1 vars1 + where + go :: FEnv senv genv -> GroundVars genv t -> (forall senv'. senv :> senv' -> BaseVars senv' t -> UniformSchedule exe senv') -> ([Var senv Signal], UniformSchedule exe senv) + go env TupRunit f = ([], f weakenId TupRunit) + go env (TupRsingle ) + +prjAwaitFuture :: FEnv senv genv -> GroundVar genv t -> Either (BaseVar env t) (BaseVar env Signal, BaseVar env (Ref t), FEnv (senv, t) genv) +prjAwaitFuture (Push _ (Ready var)) (Var _ ZeroIdx) = Left var +prjAwaitFuture (Push senv (Future signal ref)) (Var _ ZeroIdx) = Right (signal, ref, ) + where + senv' = mapEnv (weakenFutureValue (weakenSucc weakenId)) senv + -} +{- +prj' :: Idx env t -> Env f env -> f t +prj' ZeroIdx (Push _ v) = v +prj' (SuccIdx idx) (Push val _) = prj' idx val +-} + +type SyncEnv = PartialEnv Sync + +data Sync t where + SyncRead :: Int -- Number of SignalResolvers we need to release the read rights on the buffer. + -- We need one SignalResolver per place where we read from the buffer. + -- This is handled by substituting the SignalResolver variable with a tuple + -- of variables. + -> Sync (Buffer e) + + SyncWrite :: Int -- Number of SignalResolvers we need to grant read access to later operations. + -- For now, this will always be 1 as we cannot execute multiple operations writing + -- to the same buffer in parallel. Later on we can extend this to execute for instance + -- the boundary region of a stencil in parallel with the interior (task parallelism). + -> Int -- Number of SignalResolvers we need to grant write access to later operations. + -- Those signals imply that all reads to the array have been finished and that the buffer + -- can thus be overwritten. + -- Note that one should wait on both the read access signals and the write access signals + -- to get write access. + -> Sync (Buffer e) + +data Acquire genv t where + Acquire :: Modifier m + -> GroundVar genv (Buffer e) + -- Returns a signal to wait on before the operation can start. + -- In case of an input buffer (In), this signal refers to + -- the last write to the buffer. + -- In case of a Mut or Out buffer, it refers to all previous + -- usages of the buffer, both reads and writes. The signal + -- variable may thus later on be substituted for multiple + -- variables. + -- Also provides a SignalResolver which should be resolved + -- when the operation is finished. Later reads or writes to + -- this buffer will wait on this signal. + -> Acquire genv (Signal, SignalResolver) + +data ConvertEnv genv fenv fenv' where + ConvertEnvSeq :: ConvertEnv genv fenv1 fenv2 + -> ConvertEnv genv fenv2 fenv3 + -> ConvertEnv genv fenv1 fenv3 + + ConvertEnvAcquire :: Acquire genv (Signal, SignalResolver) + -> ConvertEnv genv fenv ((fenv, Signal), SignalResolver) + + ConvertEnvFuture :: GroundVar genv e + -> ConvertEnv genv fenv ((fenv, Signal), Ref e) + +data OutputEnv fenv fenv' t r where + OutputEnvPair :: OutputEnv fenv1 fenv2 t r + -> OutputEnv fenv2 fenv3 t' r' + -> OutputEnv fenv1 fenv3 (t, t') (r, r') + + OutputEnvUnique :: BLeftHandSide ((SignalResolver, SignalResolver), OutputRef (Buffer t)) fenv fenv' + -> GroundR (Buffer t) + -> OutputEnv fenv fenv' (Buffer t) ((SignalResolver, SignalResolver), OutputRef (Buffer t)) + + -- Scalar values or shared buffers + OutputEnvShared :: BLeftHandSide (SignalResolver, OutputRef t) fenv fenv' + -> GroundR t + -> OutputEnv fenv fenv' t (SignalResolver, OutputRef t) + + OutputEnvUnit :: OutputEnv fenv fenv () () + +data DeclareOutput op fenv t where + DeclareOutput :: OutputEnv fenv fenv' t r + -> fenv :> fenv' + -> (forall fenv'' . fenv' :> fenv'' -> BaseVars fenv'' r) + -> DeclareOutput op fenv t + +declareOutput :: forall op fenv t. + GroundsR t + -> Uniquenesses t + -> DeclareOutput op fenv t +declareOutput (TupRsingle tp) (TupRsingle Unique) = DeclareOutput env subst value + where + env = OutputEnvUnique lhs tp + lhs = LeftHandSidePair lhsSignalResolver lhsSignalResolver `LeftHandSidePair` LeftHandSideSingle (BaseRrefWrite tp) + + subst = weakenSucc $ weakenSucc $ weakenSucc weakenId + + value :: forall fenv''. (((fenv, SignalResolver), SignalResolver), OutputRef t) :> fenv'' -> BaseVars fenv'' ((SignalResolver, SignalResolver), OutputRef t) + value k = (TupRsingle (Var BaseRsignalResolver $ k >:> SuccIdx (SuccIdx ZeroIdx)) `TupRpair` TupRsingle (Var BaseRsignalResolver $ k >:> SuccIdx ZeroIdx)) `TupRpair` TupRsingle (Var (BaseRrefWrite tp) (k >:> ZeroIdx)) +declareOutput (TupRsingle tp) _ = DeclareOutput env subst value + where + env = OutputEnvShared lhs tp + lhs = lhsSignalResolver `LeftHandSidePair` LeftHandSideSingle (BaseRrefWrite tp) + + subst = weakenSucc $ weakenSucc weakenId + + value :: forall fenv''. ((fenv, SignalResolver), OutputRef t) :> fenv'' -> BaseVars fenv'' (SignalResolver, OutputRef t) + value k = TupRsingle (Var BaseRsignalResolver $ k >:> SuccIdx ZeroIdx) `TupRpair` TupRsingle (Var (BaseRrefWrite tp) (k >:> ZeroIdx)) +declareOutput (TupRpair t1 t2) us + | DeclareOutput env1 subst1 value1 <- declareOutput t1 u1 + , DeclareOutput env2 subst2 value2 <- declareOutput t2 u2 = DeclareOutput (OutputEnvPair env1 env2) (subst2 .> subst1) (\k -> value1 (k .> subst2) `TupRpair` value2 k) + where + (u1, u2) = pairUniqueness us +declareOutput TupRunit _ = DeclareOutput OutputEnvUnit weakenId (const TupRunit) + +data ReEnv genv fenv where + ReEnvEnd :: ReEnv genv fenv + ReEnvSkip :: ReEnv genv fenv -> ReEnv (genv, t) fenv + ReEnvKeep :: ReEnv genv fenv -> ReEnv (genv, t) (fenv, t) + +reEnvIdx :: ReEnv genv fenv -> genv :?> fenv +reEnvIdx (ReEnvKeep _) ZeroIdx = Just ZeroIdx +reEnvIdx (ReEnvKeep r) (SuccIdx ix) = SuccIdx <$> reEnvIdx r ix +reEnvIdx (ReEnvSkip r) (SuccIdx ix) = reEnvIdx r ix +reEnvIdx _ _ = Nothing + +data ConvertEnvRead op genv fenv1 where + ConvertEnvRead :: (UniformSchedule (Cluster op) fenv2 -> UniformSchedule (Cluster op) fenv1) + -> (forall fenv3. ReEnv genv fenv2 fenv3 -> ReEnv genv fenv1 fenv3) -- TODO: This doesn't work. We need to assure that genv and fenv are in the same order + -> fenv1 :> fenv2 + -> ConvertEnvRead op genv fenv1 + +convertEnvRead :: ConvertEnv genv fenv fenv1 -> ConvertEnvRead op genv fenv1 +convertEnvRead (ConvertEnvAcquire _) = ConvertEnvRead id id weakenId +convertEnvRead env = undefined + +convertEnvSignals :: forall genv fenv fenv'. ConvertEnv genv fenv fenv' -> [Idx fenv' Signal] +convertEnvSignals = snd . flip (go weakenId) [] + where + go :: fenv2 :> fenv' -> ConvertEnv genv fenv1 fenv2 -> [Idx fenv' Signal] -> (fenv1 :> fenv', [Idx fenv' Signal]) + go k (ConvertEnvAcquire _) accum = (weakenSucc $ weakenSucc k, k >:> SuccIdx ZeroIdx : accum) + go k (ConvertEnvFuture _) accum = (weakenSucc $ weakenSucc k, k >:> SuccIdx ZeroIdx : accum) + go k (ConvertEnvSeq e1 e2) accum = go k' e1 accum' + where + (k', accum') = go k e2 accum + +convertEnvSignalResolvers :: forall genv fenv fenv' fenv''. fenv' :> fenv'' -> ConvertEnv genv fenv fenv' -> [Idx fenv'' SignalResolver] +convertEnvSignalResolvers k1 = snd . flip (go k1) [] + where + go :: fenv2 :> fenv'' -> ConvertEnv genv fenv1 fenv2 -> [Idx fenv'' SignalResolver] -> (fenv1 :> fenv'', [Idx fenv'' SignalResolver]) + go k (ConvertEnvAcquire _) accum = (weakenSucc $ weakenSucc k, k >:> ZeroIdx : accum) + go k (ConvertEnvFuture _) accum = (weakenSucc $ weakenSucc k, accum) + go k (ConvertEnvSeq e1 e2) accum = go k' e1 accum' + where + (k', accum') = go k e2 accum + +lhsSignalResolver :: BLeftHandSide SignalResolver fenv (fenv, SignalResolver) +lhsSignalResolver = LeftHandSideSingle BaseRsignalResolver + +data DeclareFutures genv fenv t where + DeclareFutures :: ConvertEnv genv fenv fenv' + -> (fenv :> fenv') + -> (forall fenv''. fenv' :> fenv'' -> [BaseVar fenv'' Signal]) + -> (forall fenv''. fenv' :> fenv'' -> BaseVars fenv'' t) + -> DeclareFutures genv fenv t + +declareFutures :: GroundVar genv e -> DeclareFutures genv fenv t +declareFutures = undefined + +-- In PartialDeclare, we try to reuse the return address of the computation, +-- if this variable will be returned. +-- +data Destination r t where + DestinationNew :: Destination r t + DestinationReuse :: TupleIdx r t -> Destination r t + +data TupleIdx s t where + TupleIdxLeft :: TupleIdx l t -> TupleIdx (l, r) t + TupleIdxRight :: TupleIdx r t -> TupleIdx (l, r) t + TupleIdxSelf :: TupleIdx t t + +data PartialSchedule op genv t where + PartialDo :: OutputEnv () fenv t r + -> ConvertEnv genv fenv fenv' + -> UniformSchedule (Cluster op) fenv' + -> PartialSchedule op genv () + + -- Returns a tuple of variables. Note that (some of) these + -- variables may already have been resolved, as they may be + -- annotated in PartialDeclare. We allow variables to unify, + -- to prevent additional signals and references to be created. + -- + PartialReturn :: Uniquenesses t + -> GroundVars genv t + -> PartialSchedule op genv t + + -- When both branches use the same buffer variables, the first + -- branch first gets access to it and can release it (using OutputRelease) + -- to the second branch. + -- The ordering in this constructor is thus not symmetric (as opposed to Fork + -- in UniformSchedule, as the dependency is made explicit there by the use of + -- signals). + -- When the left branch has a OutputRelease matching with a InputAcquire from + -- the second branch (or other matching signals), a new signal will be bound + -- here. + -- Note that whereas 'BufferSignals genv' could be derived from the two branches, + -- it is stored here to avoid recomputing it multiple times, which should mean + -- that we only compute buffer signals O(n) times instead of O(n^2), in terms of + -- the number of nodes of the AST. + -- We also try to reuse signal and ref variables for variables which are later + -- on returned. We can reuse their signal and ref variables instead of introducing + -- new ones. Note that, in case of a buffer, we still need to introduce an additional + -- signal, which should be resolved when all operations on the buffer in the bound + -- computation are resolved. + -- + PartialDeclare + :: SyncEnv genv + -> GLeftHandSide bnd genv genv' + -> TupR (Destination t) bnd + -> Uniquenesses bnd + -> PartialSchedule op genv bnd + -> PartialSchedule op genv' t + -> PartialSchedule op genv t + + PartialAcond :: SyncEnv genv -- Stored for efficiency reasons to avoid recomputing it. + -> ExpVar genv PrimBool + -> PartialSchedule op genv t + -> PartialSchedule op genv t + -> PartialSchedule op genv t + + PartialAwhile :: SyncEnv genv + -> Uniquenesses t + -> PartialScheduleFun op genv (t -> PrimBool) + -> PartialScheduleFun op genv (t -> t) + -> GroundVars genv t + -> PartialSchedule op genv t + +partialDeclare :: GLeftHandSide bnd genv genv' + -> TupR (Destination t) bnd + -> Uniquenesses bnd + -> PartialSchedule op genv bnd + -> PartialSchedule op genv' t + -> PartialSchedule op genv t +partialDeclare lhs dest us bnd sched = PartialDeclare sync lhs dest us bnd sched + where + sync = mergePartialEnv combineSync' (syncEnv bnd) (weakenSyncEnv lhs $ syncEnv sched) + +partialAcond :: ExpVar genv PrimBool + -> PartialSchedule op genv t + -> PartialSchedule op genv t + -> PartialSchedule op genv t +partialAcond cond t f = PartialAcond sync cond t f + where + sync = mergePartialEnv maxSync (syncEnv t) (syncEnv f) + +partialAwhile :: Uniquenesses t + -> PartialScheduleFun op genv (t -> PrimBool) + -> PartialScheduleFun op genv (t -> t) + -> GroundVars genv t + -> PartialSchedule op genv t +partialAwhile us cond f vars = PartialAwhile sync us cond f vars + where + sync = mergePartialEnv combineSync' (syncEnvFun cond) $ mergePartialEnv combineSync' (syncEnvFun f) $ variablesToSyncEnv us vars + +data PartialScheduleFun op genv t where + Plam :: GLeftHandSide s genv genv' + -> PartialScheduleFun op genv' t + -> PartialScheduleFun op genv (s -> t) + + Pbody :: PartialSchedule op genv t + -> PartialScheduleFun op genv t + +data MaybeVar genv t where + NoVars :: MaybeVar genv t + ReturnVar :: GroundVar genv t -> MaybeVar genv t +type MaybeVars genv = TupR (MaybeVar genv) + +weakenMaybeVar :: LeftHandSide s t genv genv' -> MaybeVar genv' u -> MaybeVar genv u +weakenMaybeVar _ NoVars = NoVars +weakenMaybeVar (LeftHandSideWildcard _) v = v +weakenMaybeVar (LeftHandSideSingle _) (ReturnVar (Var t ix)) = case ix of + SuccIdx ix' -> ReturnVar $ Var t ix' + ZeroIdx -> NoVars +weakenMaybeVar (LeftHandSidePair l1 l2) v = weakenMaybeVar l1 $ weakenMaybeVar l2 v + +weakenMaybeVars :: LeftHandSide s t genv genv' -> MaybeVars genv' u -> MaybeVars genv u +weakenMaybeVars lhs = mapTupR (weakenMaybeVar lhs) + +lhsDestination :: GLeftHandSide t genv genv' -> MaybeVars genv' u -> TupR (Destination u) t +lhsDestination (LeftHandSidePair l1 l2) vars = lhsDestination l1 (weakenMaybeVars l2 vars) `TupRpair` lhsDestination l2 vars +lhsDestination (LeftHandSideWildcard t) _ = mapTupR (const DestinationNew) t +lhsDestination (LeftHandSideSingle _) vars = case findVar vars of + Just ix -> TupRsingle $ DestinationReuse ix + Nothing -> TupRsingle DestinationNew + where + findVar :: MaybeVars (env, t) s -> Maybe (TupleIdx s t) + findVar (TupRpair a b) = case (findVar a, findVar b) of + (Just i , _ ) -> Just $ TupleIdxLeft i + (Nothing, Just i) -> Just $ TupleIdxRight i + _ -> Nothing + findVar (TupRsingle (ReturnVar (Var _ ZeroIdx))) = Just TupleIdxSelf + findVar TupRunit = Nothing -- Should be unreachable + +unionVars :: MaybeVars genv t -> MaybeVars genv t -> MaybeVars genv t +unionVars m@(TupRsingle (ReturnVar (Var _ x))) (TupRsingle (ReturnVar (Var _ y))) + | x == y = m +unionVars (TupRpair x1 x2) (TupRpair y1 y2) = unionVars x1 y1 `TupRpair` unionVars x2 y2 +unionVars TupRunit _ = TupRunit +unionVars _ TupRunit = TupRunit +unionVars _ _ = TupRsingle NoVars + +partialSchedule :: forall op genv1 t1. C.PartitionedAcc (Cluster op) genv1 t1 -> PartialSchedule op genv1 t1 +partialSchedule = fst . travA (TupRsingle Shared) + where + travA :: forall genv t. Uniquenesses t -> C.PartitionedAcc (Cluster op) genv t -> (PartialSchedule op genv t, MaybeVars genv t) + travA _ (C.Exec cluster) = undefined + travA us (C.Return vars) = (PartialReturn us vars, mapTupR ReturnVar vars) + travA _ (C.Compute e) = partialLift f (expGroundVars e) + where + f :: genv :?> fenv -> Maybe (Binding fenv t) + f k = Compute <$> strengthenArrayInstr k e + travA us (C.Alet lhs us' bnd a) = (partialDeclare lhs dest us' (fst $ travA us' bnd) a', vars') + where + dest = lhsDestination lhs vars + (a', vars) = travA us a + vars' = weakenMaybeVars lhs vars + travA _ (C.Alloc shr tp sh) = partialLift1 (Alloc shr tp) sh + travA _ (C.Use tp buffer) = partialLift1 (const $ Use tp buffer) TupRunit + travA _ (C.Unit var) = partialLift1 f (TupRsingle var) + where + f (TupRsingle var') = Unit var' + travA us (C.Acond c t f) = (partialAcond c t' f', vars) + where + (t', vars1) = travA us t + (f', vars2) = travA us f + vars = unionVars vars1 vars2 + travA _ (C.Awhile us c f vars) = (partialAwhile us c' f' vars, TupRsingle NoVars) + where + c' = partialScheduleFun c + f' = partialScheduleFun f + +partialScheduleFun :: C.PartitionedAfun (Cluster op) genv t -> PartialScheduleFun op genv t +partialScheduleFun (C.Alam lhs f) = Plam lhs $ partialScheduleFun f +partialScheduleFun (C.Abody b) = Pbody $ partialSchedule b + +partialLift1 :: (forall fenv. ExpVars fenv t -> Binding fenv s) -> ExpVars genv t -> (PartialSchedule op genv s, MaybeVars genv s) +partialLift1 f = undefined + +partialLift :: (forall fenv. (genv :?> fenv) -> Maybe (Binding fenv s)) -> [Exists (GroundVar genv)] -> (PartialSchedule op genv s, MaybeVars genv s) +partialLift f = undefined + +syncEnv :: PartialSchedule op genv t -> SyncEnv genv +syncEnv (PartialDo _ env _) = convertEnvToSyncEnv env +syncEnv (PartialReturn u vars) = variablesToSyncEnv u vars +syncEnv (PartialDeclare s _ _ _ _ _) = s +syncEnv (PartialAcond s _ _ _) = s +syncEnv (PartialAwhile s _ _ _ _) = s + +syncEnvFun :: PartialScheduleFun op genv t -> SyncEnv genv +syncEnvFun (Plam lhs f) = weakenSyncEnv lhs $ syncEnvFun f +syncEnvFun (Pbody s) = syncEnv s + +convertEnvToSyncEnv :: ConvertEnv genv fenv fenv' -> SyncEnv genv +convertEnvToSyncEnv = partialEnvFromList (error "convertEnvToSyncEnv: Variable occurs multiple times") . (`go` []) + where + go :: ConvertEnv genv fenv fenv' -> [EnvBinding Sync genv] -> [EnvBinding Sync genv] + go (ConvertEnvSeq env1 env2) accum = go env1 $ go env2 accum + go (ConvertEnvAcquire (Acquire m (Var _ ix))) accum = EnvBinding ix s : accum + where + s = case m of + In -> SyncRead 1 + _ -> SyncWrite 1 0 + go _ accum = accum + +variablesToSyncEnv :: Uniquenesses t -> GroundVars genv t -> SyncEnv genv +variablesToSyncEnv uniquenesses vars = partialEnvFromList (error "convertEnvToSyncEnv: Variable occurs multiple times") $ go uniquenesses vars [] + where + go :: Uniquenesses t -> GroundVars genv t -> [EnvBinding Sync genv] -> [EnvBinding Sync genv] + go (TupRsingle Unique) (TupRsingle (Var (GroundRbuffer _) ix)) + accum = EnvBinding ix (SyncWrite 0 0) : accum + go (TupRsingle Shared) (TupRsingle (Var (GroundRbuffer _) ix)) + accum = EnvBinding ix (SyncRead 0) : accum + go u (TupRpair v1 v2) accum = go u1 v1 $ go u2 v2 accum + where (u1, u2) = pairUniqueness u + go _ _ accum = accum + +pairUniqueness :: Uniquenesses (s, t) -> (Uniquenesses s, Uniquenesses t) +pairUniqueness (TupRpair u1 u2) = (u1, u2) +pairUniqueness (TupRsingle Shared) = (TupRsingle Shared, TupRsingle Shared) + +-- Returns: +-- * Number of signals to grant read access (ie one per write operation) +-- * Number of signals to grant write access (ie one per read operation, +-- indicating that the read has finished and the data can be overriden.) +-- Note that one has to wait on both the read access signals and the +-- write access signals to get write access. +-- * A merged Sync value +-- +combineSync :: Sync t -> Sync t -> (Int, Int, Sync t) +combineSync (SyncRead r) (SyncRead r') = (0, 0, SyncRead (r + r')) +combineSync (SyncRead r) (SyncWrite w' r') = (0, r, SyncWrite w' r') +combineSync (SyncWrite w r) (SyncWrite w' r') = (w, r, SyncWrite w' r') +combineSync (SyncWrite w r) (SyncRead r') = (0, 0, SyncWrite w (r + r')) + +combineSync' :: Sync t -> Sync t -> Sync t +combineSync' a b = c + where (_, _, c) = combineSync a b + +weakenSyncEnv :: GLeftHandSide t env env' -> SyncEnv env' -> SyncEnv env +weakenSyncEnv _ PEnd = PEnd +weakenSyncEnv (LeftHandSideWildcard _) env = env +weakenSyncEnv (LeftHandSideSingle _) (PPush env _) = env +weakenSyncEnv (LeftHandSideSingle _) (PNone env) = env +weakenSyncEnv (LeftHandSidePair l1 l2) env = weakenSyncEnv l1 $ weakenSyncEnv l2 env + +maxSync :: Sync t -> Sync t -> Sync t +maxSync (SyncRead r) (SyncRead r') = SyncRead (max r r') +maxSync (SyncRead r) (SyncWrite w' r') = SyncWrite w' (max r r') +maxSync (SyncWrite w r) (SyncRead r') = SyncWrite w (max r r') +maxSync (SyncWrite w r) (SyncWrite w' r') = SyncWrite (max w w') (max r r') From 43f8bdc29df3fbc4028e1da122a6c562284b09b4 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Wed, 14 Oct 2020 13:36:27 +0200 Subject: [PATCH 011/813] Compile PartionedAcc to PartialSchedule --- src/Data/Array/Accelerate/AST/Operation.hs | 47 ++++ src/Data/Array/Accelerate/AST/Partitioned.hs | 4 + .../Array/Accelerate/AST/Schedule/Uniform.hs | 6 +- src/Data/Array/Accelerate/AST/Var.hs | 2 +- .../Trafo/Operation/Substitution.hs | 32 --- .../Accelerate/Trafo/Schedule/Uniform.hs | 212 +++++++++++++++--- 6 files changed, 234 insertions(+), 69 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index a5a35d532..9591e8ef9 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -34,6 +34,7 @@ module Data.Array.Accelerate.AST.Operation ( Var', Exp', Fun', In, Out, Mut, OpenExp, OpenFun, Exp, Fun, ArrayInstr(..), + expGroundVars, funGroundVars, arrayInstrsInExp, arrayInstrsInFun, encodeGroundR, encodeGroundsR, encodeGroundVar, encodeGroundVars, rnfGroundR, rnfGroundsR, rnfGroundVar, rnfGroundVars, @@ -46,6 +47,7 @@ module Data.Array.Accelerate.AST.Operation ( IsExecutableAcc(..), ReindexPartial, reindexArg, reindexArgs, reindexExp, reindexVar, reindexVars, weakenReindex, + argVars, argsVars, AccessGroundR(..), mapAccExecutable, mapAfunExecutable, @@ -62,6 +64,7 @@ import Data.Array.Accelerate.Representation.Array import Data.Array.Accelerate.Representation.Shape import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Trafo.Exp.Substitution +import Data.Array.Accelerate.Trafo.Exp.Shrink import Data.Array.Accelerate.Type import Data.Array.Accelerate.Error import Data.Typeable ( (:~:)(..) ) @@ -412,9 +415,53 @@ weakenReindex k = Identity . (k >:>) class IsExecutableAcc exe where reindexExecPartial :: Applicative f => ReindexPartial f env env' -> exe env -> f (exe env') + execVars :: exe env -> [Exists (Var AccessGroundR env)] instance IsExecutableAcc (Execute op) where reindexExecPartial k (Execute op args) = Execute op <$> reindexArgs k args + execVars (Execute _ args) = argsVars args + +data AccessGroundR tp where + AccessGroundRscalar :: ScalarType tp -> AccessGroundR tp + AccessGroundRbuffer :: Modifier m -> ScalarType tp -> AccessGroundR (Buffer tp) + +readonlyGroundRToAccessGroundR :: Exists (GroundVar env) -> Exists (Var AccessGroundR env) +readonlyGroundRToAccessGroundR (Exists (Var (GroundRscalar tp) ix)) = Exists $ Var (AccessGroundRscalar tp) ix +readonlyGroundRToAccessGroundR (Exists (Var (GroundRbuffer tp) ix)) = Exists $ Var (AccessGroundRbuffer In tp) ix + +argVars :: Arg env t -> [Exists (Var AccessGroundR env)] +argVars (ArgVar vars) = flattenTupR $ mapTupR (\(Var tp ix) -> Var (AccessGroundRscalar tp) ix) vars +argVars (ArgExp e) = map readonlyGroundRToAccessGroundR $ expGroundVars e +argVars (ArgFun e) = map readonlyGroundRToAccessGroundR $ funGroundVars e +argVars (ArgArray m _ sh buffers) = go buffers $ map readonlyGroundRToAccessGroundR $ flattenTupR sh + where + go :: GroundVars env s -> [Exists (Var AccessGroundR env)] -> [Exists (Var AccessGroundR env)] + go TupRunit accum = accum + go (TupRsingle (Var (GroundRbuffer tp) ix)) accum = Exists (Var (AccessGroundRbuffer m tp) ix) : accum + go (TupRsingle _) _ = error "Expected buffer" + go (TupRpair v1 v2) accum = go v1 $ go v2 accum + +argsVars :: Args env t -> [Exists (Var AccessGroundR env)] +argsVars (a :>: as) = argVars a ++ argsVars as +argsVars ArgsNil = [] + +expGroundVars :: OpenExp env benv t -> [Exists (GroundVar benv)] +expGroundVars = map arrayInstrGroundVars . arrayInstrsInExp + +funGroundVars :: OpenFun env benv t -> [Exists (GroundVar benv)] +funGroundVars = map arrayInstrGroundVars . arrayInstrsInFun + +arrayInstrGroundVars :: Exists (ArrayInstr benv) -> Exists (GroundVar benv) +arrayInstrGroundVars (Exists (Parameter (Var tp ix))) = Exists $ Var (GroundRscalar tp) ix +arrayInstrGroundVars (Exists (Index var)) = Exists var + +flattenTupR :: TupR s t -> [Exists s] +flattenTupR = (`go` []) + where + go :: TupR s t -> [Exists s] -> [Exists s] + go (TupRsingle s) accum = Exists s : accum + go (TupRpair t1 t2) accum = go t1 $ go t2 accum + go TupRunit accum = accum mapAccExecutable :: (forall benv'. exe benv' -> exe' benv') -> PreOpenAcc exe benv t -> PreOpenAcc exe' benv t mapAccExecutable f = \case diff --git a/src/Data/Array/Accelerate/AST/Partitioned.hs b/src/Data/Array/Accelerate/AST/Partitioned.hs index f087b73af..102a9edb0 100644 --- a/src/Data/Array/Accelerate/AST/Partitioned.hs +++ b/src/Data/Array/Accelerate/AST/Partitioned.hs @@ -27,5 +27,9 @@ data Cluster op env where Base :: op args -> Args env args -> Cluster op env -- TODO: Vertical, Horizontal, Diagonal +instance IsExecutableAcc (Cluster op) where + reindexExecPartial k (Base op args) = Base op <$> reindexArgs k args + execVars (Base _ args) = argsVars args + type PartitionedAcc op = PreOpenAcc (Cluster op) type PartitionedAfun op = PreOpenAfun (Cluster op) diff --git a/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs b/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs index 90660daaf..3e84977a9 100644 --- a/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs +++ b/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs @@ -23,9 +23,7 @@ module Data.Array.Accelerate.AST.Schedule.Uniform ( module Partitioned, ) where -import Data.Array.Accelerate.AST.Environment import Data.Array.Accelerate.AST.Exp -import Data.Array.Accelerate.AST.Operation (GroundR(..), GroundsR, GroundVar, GroundVars, Exp, OpenExp, Fun, OpenFun, Arg(..), Args, PreArgs(..), ArrayInstr(..)) import Data.Array.Accelerate.AST.Idx import Data.Array.Accelerate.AST.LeftHandSide import Data.Array.Accelerate.AST.Var @@ -128,9 +126,9 @@ data Effect exe env where Exec :: exe env -> Effect exe env - SignalAwait :: [BaseVar env Signal] -> Effect exe env + SignalAwait :: [Idx env Signal] -> Effect exe env - SignalResolve :: [BaseVar env SignalResolver] -> Effect exe env + SignalResolve :: [Idx env SignalResolver] -> Effect exe env RefWrite :: BaseVar env (OutputRef t) -> BaseVar env t -> Effect exe env diff --git a/src/Data/Array/Accelerate/AST/Var.hs b/src/Data/Array/Accelerate/AST/Var.hs index f4076a3b7..9970ce638 100644 --- a/src/Data/Array/Accelerate/AST/Var.hs +++ b/src/Data/Array/Accelerate/AST/Var.hs @@ -23,7 +23,7 @@ import Language.Haskell.TH import Data.Typeable ( (:~:)(..) ) -data Var s env t = Var (s t) (Idx env t) +data Var s env t = Var { varType :: (s t), varIdx :: (Idx env t) } type Vars s env = TupR (Var s env) varsType :: Vars s env t -> TupR s t diff --git a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs index 099030504..4581ca45d 100644 --- a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs +++ b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs @@ -32,7 +32,6 @@ module Data.Array.Accelerate.Trafo.Operation.Substitution ( pair, alet, weakenArrayInstr, strengthenArrayInstr, - expGroundVars, funGroundVars, ) where import Data.Array.Accelerate.AST.Idx @@ -44,7 +43,6 @@ import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Trafo.Var import Data.Array.Accelerate.Trafo.Substitution (Sink(..)) import Data.Array.Accelerate.Trafo.Exp.Substitution -import Data.Array.Accelerate.Trafo.Exp.Shrink data SunkReindexPartial f env env' where Sink :: SunkReindexPartial f env env' -> SunkReindexPartial f (env, s) (env', s) @@ -172,33 +170,3 @@ strengthenArrayInstr k = rebuildArrayInstrPartial f f :: ArrayInstr benv (u -> s) -> Maybe (OpenExp env' benv' u -> OpenExp env' benv' s) f (Parameter (Var tp ix)) = ArrayInstr . Parameter . Var tp <$> k ix f (Index (Var tp ix)) = ArrayInstr . Index . Var tp <$> k ix - -expGroundVars :: OpenExp env benv t -> [Exists (GroundVar benv)] -expGroundVars = map arrayInstrGroundVars . arrayInstrsInExp - -funGroundVars :: OpenFun env benv t -> [Exists (GroundVar benv)] -funGroundVars = map arrayInstrGroundVars . arrayInstrsInFun - -arrayInstrGroundVars :: Exists (ArrayInstr benv) -> Exists (GroundVar benv) -arrayInstrGroundVars (Exists (Parameter (Var tp ix))) = Exists $ Var (GroundRscalar tp) ix -arrayInstrGroundVars (Exists (Index var)) = Exists var - -argVars :: Arg benv t -> [(Exists (GroundVar benv), {- Mutable -} Bool)] -argVars (ArgExp e) = map (, False) $ expGroundVars e -argVars (ArgFun f) = map (, False) $ funGroundVars f -argVars (ArgVar vars) = map (, False) $ flattenTupR $ mapVars GroundRscalar vars -argVars (ArgArray m _ sh buffers) - = map (, False) (flattenTupR sh) - ++ map (, mut) (flattenTupR buffers) - where - mut = case m of - In -> False - _ -> True - -flattenTupR :: TupR s t -> [Exists s] -flattenTupR = (`go` []) - where - go :: TupR s t -> [Exists s] -> [Exists s] - go (TupRsingle s) accum = Exists s : accum - go (TupRpair t1 t2) accum = go t1 $ go t2 accum - go TupRunit accum = accum diff --git a/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs b/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs index 09ea471a3..c9aff6824 100644 --- a/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs +++ b/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs @@ -34,9 +34,10 @@ import Data.Array.Accelerate.AST.LeftHandSide import Data.Array.Accelerate.AST.Schedule.Uniform import Data.Array.Accelerate.AST.Environment import qualified Data.Array.Accelerate.AST.Partitioned as C +import Data.Array.Accelerate.Trafo.Var import Data.Array.Accelerate.Trafo.Substitution import Data.Array.Accelerate.Trafo.Exp.Substitution -import Data.Array.Accelerate.Trafo.Operation.Substitution (expGroundVars, strengthenArrayInstr) +import Data.Array.Accelerate.Trafo.Operation.Substitution (strengthenArrayInstr) import Data.Array.Accelerate.Representation.Array import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Type @@ -265,6 +266,8 @@ data Acquire genv t where -> Acquire genv (Signal, SignalResolver) data ConvertEnv genv fenv fenv' where + ConvertEnvNil :: ConvertEnv genv fenv fenv + ConvertEnvSeq :: ConvertEnv genv fenv1 fenv2 -> ConvertEnv genv fenv2 fenv3 -> ConvertEnv genv fenv1 fenv3 @@ -291,16 +294,16 @@ data OutputEnv fenv fenv' t r where OutputEnvUnit :: OutputEnv fenv fenv () () -data DeclareOutput op fenv t where +data DeclareOutput fenv t where DeclareOutput :: OutputEnv fenv fenv' t r -> fenv :> fenv' -> (forall fenv'' . fenv' :> fenv'' -> BaseVars fenv'' r) - -> DeclareOutput op fenv t + -> DeclareOutput fenv t -declareOutput :: forall op fenv t. +declareOutput :: forall fenv t. GroundsR t -> Uniquenesses t - -> DeclareOutput op fenv t + -> DeclareOutput fenv t declareOutput (TupRsingle tp) (TupRsingle Unique) = DeclareOutput env subst value where env = OutputEnvUnique lhs tp @@ -326,6 +329,20 @@ declareOutput (TupRpair t1 t2) us (u1, u2) = pairUniqueness us declareOutput TupRunit _ = DeclareOutput OutputEnvUnit weakenId (const TupRunit) +writeOutput :: OutputEnv fenv fenv' t r -> BaseVars fenv'' r -> BaseVars fenv'' t -> UniformSchedule (Cluster op) fenv'' +writeOutput outputEnv outputVars valueVars = go outputEnv outputVars valueVars Return + where + go :: OutputEnv fenv fenv' t r -> BaseVars fenv'' r -> BaseVars fenv'' t -> UniformSchedule (Cluster op) fenv'' -> UniformSchedule (Cluster op) fenv'' + go OutputEnvUnit _ _ = id + go (OutputEnvPair o1 o2) (TupRpair r1 r2) (TupRpair v1 v2) = go o1 r1 v1 . go o2 r2 v2 + go (OutputEnvShared _ _) (TupRpair (TupRsingle signal) (TupRsingle ref)) (TupRsingle v) + = Effect (RefWrite ref v) + . Effect (SignalResolve [varIdx signal]) + go (OutputEnvUnique _ _) (TupRpair (TupRpair (TupRsingle s1) (TupRsingle s2)) (TupRsingle ref)) (TupRsingle v) + = Effect (RefWrite ref v) + . Effect (SignalResolve [varIdx s1]) + . Effect (SignalResolve [varIdx s2]) + data ReEnv genv fenv where ReEnvEnd :: ReEnv genv fenv ReEnvSkip :: ReEnv genv fenv -> ReEnv (genv, t) fenv @@ -336,21 +353,63 @@ reEnvIdx (ReEnvKeep _) ZeroIdx = Just ZeroIdx reEnvIdx (ReEnvKeep r) (SuccIdx ix) = SuccIdx <$> reEnvIdx r ix reEnvIdx (ReEnvSkip r) (SuccIdx ix) = reEnvIdx r ix reEnvIdx _ _ = Nothing - +{- data ConvertEnvRead op genv fenv1 where ConvertEnvRead :: (UniformSchedule (Cluster op) fenv2 -> UniformSchedule (Cluster op) fenv1) -> (forall fenv3. ReEnv genv fenv2 fenv3 -> ReEnv genv fenv1 fenv3) -- TODO: This doesn't work. We need to assure that genv and fenv are in the same order -> fenv1 :> fenv2 -> ConvertEnvRead op genv fenv1 +-} +-- Void data type with orphan type argument. +-- Used to mark that a variable of the ground environment is used. +-- +data FutureRef fenv t = FutureRef (BaseVar fenv (Ref t)) + +convertEnvRefs :: forall genv fenv fenv'. ConvertEnv genv fenv fenv' -> PartialEnv (FutureRef fenv') genv +convertEnvRefs env = partialEnvFromList const $ snd $ go weakenId env [] + where + go :: fenv2 :> fenv' -> ConvertEnv genv fenv1 fenv2 -> [EnvBinding (FutureRef fenv') genv] -> (fenv1 :> fenv', [EnvBinding (FutureRef fenv') genv]) + go k ConvertEnvNil accum = (k, accum) + go k (ConvertEnvSeq e1 e2) accum = (k1, bs') + where + (k2, bs) = go k e2 accum + (k1, bs') = go k2 e1 bs + go k (ConvertEnvAcquire _) accum = (weakenSucc $ weakenSucc k, accum) + go k (ConvertEnvFuture (Var tp ix)) accum = (weakenSucc $ weakenSucc k, EnvBinding ix (FutureRef $ Var (BaseRref tp) $ k >:> ZeroIdx) : accum) + +data Reads exe genv fenv where + Reads :: ReEnv genv fenv' + -> (fenv :> fenv') + -> (UniformSchedule exe fenv' -> UniformSchedule exe fenv) + -> Reads exe genv fenv + +readRefs :: PartialEnv (FutureRef fenv) genv -> Reads exe genv fenv +readRefs PEnd = Reads ReEnvEnd weakenId id +readRefs (PPush env (FutureRef (Var tp idx))) + | Reads r k f <- readRefs env = + let + tp' = case tp of + BaseRref t -> BaseRground t + _ -> error "Impossible Ref base type" + r' = ReEnvKeep r + k' = weakenSucc' k + f' = f . Alet (LeftHandSideSingle tp') (RefRead $ Var tp $ k >:> idx) + in + Reads r' k' f' +readRefs (PNone env) + | Reads r k f <- readRefs env = Reads (ReEnvSkip r) k f -convertEnvRead :: ConvertEnv genv fenv fenv1 -> ConvertEnvRead op genv fenv1 -convertEnvRead (ConvertEnvAcquire _) = ConvertEnvRead id id weakenId -convertEnvRead env = undefined +convertEnvWeaken :: ConvertEnv genv fenv fenv' -> fenv :> fenv' +convertEnvWeaken ConvertEnvNil = weakenId +convertEnvWeaken (ConvertEnvAcquire _) = weakenSucc (weakenSucc weakenId) +convertEnvWeaken (ConvertEnvFuture _) = weakenSucc (weakenSucc weakenId) +convertEnvWeaken (ConvertEnvSeq e1 e2) = convertEnvWeaken e2 .> convertEnvWeaken e1 convertEnvSignals :: forall genv fenv fenv'. ConvertEnv genv fenv fenv' -> [Idx fenv' Signal] convertEnvSignals = snd . flip (go weakenId) [] where go :: fenv2 :> fenv' -> ConvertEnv genv fenv1 fenv2 -> [Idx fenv' Signal] -> (fenv1 :> fenv', [Idx fenv' Signal]) + go k ConvertEnvNil accum = (k, accum) go k (ConvertEnvAcquire _) accum = (weakenSucc $ weakenSucc k, k >:> SuccIdx ZeroIdx : accum) go k (ConvertEnvFuture _) accum = (weakenSucc $ weakenSucc k, k >:> SuccIdx ZeroIdx : accum) go k (ConvertEnvSeq e1 e2) accum = go k' e1 accum' @@ -361,25 +420,50 @@ convertEnvSignalResolvers :: forall genv fenv fenv' fenv''. fenv' :> fenv'' -> C convertEnvSignalResolvers k1 = snd . flip (go k1) [] where go :: fenv2 :> fenv'' -> ConvertEnv genv fenv1 fenv2 -> [Idx fenv'' SignalResolver] -> (fenv1 :> fenv'', [Idx fenv'' SignalResolver]) + go k ConvertEnvNil accum = (k, accum) go k (ConvertEnvAcquire _) accum = (weakenSucc $ weakenSucc k, k >:> ZeroIdx : accum) go k (ConvertEnvFuture _) accum = (weakenSucc $ weakenSucc k, accum) go k (ConvertEnvSeq e1 e2) accum = go k' e1 accum' where (k', accum') = go k e2 accum +convertEnvReadonlyFromList :: [Exists (GroundVar genv)] -> Exists (ConvertEnv genv fenv) +convertEnvReadonlyFromList [] + = Exists ConvertEnvNil +convertEnvReadonlyFromList [Exists var] + | Exists e1 <- convertEnvReadonlyVar var + = Exists e1 +convertEnvReadonlyFromList (Exists var:vars) + | Exists e1 <- convertEnvReadonlyVar var + , Exists e2 <- convertEnvReadonlyFromList vars + = Exists $ e1 `ConvertEnvSeq` e2 + +convertEnvReadonlyVar :: GroundVar genv t -> Exists (ConvertEnv genv fenv) +convertEnvReadonlyVar var@(Var tp _) + | GroundRbuffer _ <- tp = Exists $ future `ConvertEnvSeq` ConvertEnvAcquire (Acquire In var) + | otherwise = Exists future + where + future = ConvertEnvFuture var + +convertEnvFromList :: [Exists (Var AccessGroundR genv)] -> Exists (ConvertEnv genv fenv) +convertEnvFromList [] = Exists ConvertEnvNil +convertEnvFromList [Exists var] + | Exists e1 <- convertEnvVar var + = Exists e1 +convertEnvFromList (Exists var:vars) + | Exists e1 <- convertEnvVar var + , Exists e2 <- convertEnvFromList vars + = Exists $ e1 `ConvertEnvSeq` e2 + +convertEnvVar :: Var AccessGroundR genv t -> Exists (ConvertEnv genv fenv) +convertEnvVar (Var (AccessGroundRscalar tp) ix) = Exists $ ConvertEnvFuture $ Var (GroundRscalar tp) ix +convertEnvVar (Var (AccessGroundRbuffer m tp) ix) = Exists $ ConvertEnvFuture var `ConvertEnvSeq` ConvertEnvAcquire (Acquire m var) + where + var = Var (GroundRbuffer tp) ix + lhsSignalResolver :: BLeftHandSide SignalResolver fenv (fenv, SignalResolver) lhsSignalResolver = LeftHandSideSingle BaseRsignalResolver -data DeclareFutures genv fenv t where - DeclareFutures :: ConvertEnv genv fenv fenv' - -> (fenv :> fenv') - -> (forall fenv''. fenv' :> fenv'' -> [BaseVar fenv'' Signal]) - -> (forall fenv''. fenv' :> fenv'' -> BaseVars fenv'' t) - -> DeclareFutures genv fenv t - -declareFutures :: GroundVar genv e -> DeclareFutures genv fenv t -declareFutures = undefined - -- In PartialDeclare, we try to reuse the return address of the computation, -- if this variable will be returned. -- @@ -396,7 +480,7 @@ data PartialSchedule op genv t where PartialDo :: OutputEnv () fenv t r -> ConvertEnv genv fenv fenv' -> UniformSchedule (Cluster op) fenv' - -> PartialSchedule op genv () + -> PartialSchedule op genv t -- Returns a tuple of variables. Note that (some of) these -- variables may already have been resolved, as they may be @@ -522,13 +606,42 @@ unionVars TupRunit _ = TupRunit unionVars _ TupRunit = TupRunit unionVars _ _ = TupRsingle NoVars -partialSchedule :: forall op genv1 t1. C.PartitionedAcc (Cluster op) genv1 t1 -> PartialSchedule op genv1 t1 +data Exists' (a :: (* -> * -> *) -> *) where + Exists' :: a m -> Exists' a + +partialSchedule :: forall op genv1 t1. C.PartitionedAcc op genv1 t1 -> PartialSchedule op genv1 t1 partialSchedule = fst . travA (TupRsingle Shared) where - travA :: forall genv t. Uniquenesses t -> C.PartitionedAcc (Cluster op) genv t -> (PartialSchedule op genv t, MaybeVars genv t) - travA _ (C.Exec cluster) = undefined + travA :: forall genv t. Uniquenesses t -> C.PartitionedAcc op genv t -> (PartialSchedule op genv t, MaybeVars genv t) + travA _ (C.Exec cluster) + | Exists env <- convertEnvFromList $ map (foldr1 combineMod) $ groupBy (\(Exists v1) (Exists v2) -> isJust $ matchIdx (varIdx v1) (varIdx v2)) $ execVars cluster -- TODO: Remove duplicates more efficiently + , Reads reEnv k inputBindings <- readRefs $ convertEnvRefs env + , Just cluster' <- reindexExecPartial (reEnvIdx reEnv) cluster + = let + signals = convertEnvSignals env + resolvers = convertEnvSignalResolvers k env + in + ( PartialDo OutputEnvUnit env + $ Effect (SignalAwait signals) + $ inputBindings + $ Effect (Exec cluster') + $ Effect (SignalResolve resolvers) + $ Return + , TupRunit + ) + | otherwise = error "partialSchedule: reindexExecPartial returned Nothing. Probably some variable is missing in 'execVars'" + where + combineMod :: Exists (Var AccessGroundR env) -> Exists (Var AccessGroundR env) -> Exists (Var AccessGroundR env) + combineMod (Exists (Var (AccessGroundRbuffer m1 tp) ix)) var@(Exists (Var (AccessGroundRbuffer m2 _) _)) + | Exists' m <- combineMod' m1 m2 = Exists $ Var (AccessGroundRbuffer m tp) ix + | otherwise = var + + combineMod' :: Modifier m -> Modifier m' -> Exists' Modifier + combineMod' In In = Exists' In + combineMod' Out Out = Exists' Out + combineMod' _ _ = Exists' Mut travA us (C.Return vars) = (PartialReturn us vars, mapTupR ReturnVar vars) - travA _ (C.Compute e) = partialLift f (expGroundVars e) + travA _ (C.Compute e) = partialLift (mapTupR GroundRscalar $ expType e) f (expGroundVars e) where f :: genv :?> fenv -> Maybe (Binding fenv t) f k = Compute <$> strengthenArrayInstr k e @@ -537,9 +650,9 @@ partialSchedule = fst . travA (TupRsingle Shared) dest = lhsDestination lhs vars (a', vars) = travA us a vars' = weakenMaybeVars lhs vars - travA _ (C.Alloc shr tp sh) = partialLift1 (Alloc shr tp) sh - travA _ (C.Use tp buffer) = partialLift1 (const $ Use tp buffer) TupRunit - travA _ (C.Unit var) = partialLift1 f (TupRsingle var) + travA _ (C.Alloc shr tp sh) = partialLift1 (TupRsingle $ GroundRbuffer tp) (Alloc shr tp) sh + travA _ (C.Use tp buffer) = partialLift1 (TupRsingle $ GroundRbuffer tp) (const $ Use tp buffer) TupRunit + travA _ (C.Unit var@(Var tp _)) = partialLift1 (TupRsingle $ GroundRbuffer tp) f (TupRsingle var) where f (TupRsingle var') = Unit var' travA us (C.Acond c t f) = (partialAcond c t' f', vars) @@ -552,15 +665,50 @@ partialSchedule = fst . travA (TupRsingle Shared) c' = partialScheduleFun c f' = partialScheduleFun f -partialScheduleFun :: C.PartitionedAfun (Cluster op) genv t -> PartialScheduleFun op genv t +partialScheduleFun :: C.PartitionedAfun op genv t -> PartialScheduleFun op genv t partialScheduleFun (C.Alam lhs f) = Plam lhs $ partialScheduleFun f partialScheduleFun (C.Abody b) = Pbody $ partialSchedule b -partialLift1 :: (forall fenv. ExpVars fenv t -> Binding fenv s) -> ExpVars genv t -> (PartialSchedule op genv s, MaybeVars genv s) -partialLift1 f = undefined +partialLift1 :: GroundsR s -> (forall fenv. ExpVars fenv t -> Binding fenv s) -> ExpVars genv t -> (PartialSchedule op genv s, MaybeVars genv s) +partialLift1 tp f vars = partialLift tp (\k -> f <$> strengthenVars k vars) (expVarsList vars) -partialLift :: (forall fenv. (genv :?> fenv) -> Maybe (Binding fenv s)) -> [Exists (GroundVar genv)] -> (PartialSchedule op genv s, MaybeVars genv s) -partialLift f = undefined +expVarsList :: ExpVars genv t -> [Exists (GroundVar genv)] +expVarsList = (`go` []) + where + go :: ExpVars genv t -> [Exists (GroundVar genv)] -> [Exists (GroundVar genv)] + go TupRunit accum = accum + go (TupRsingle (Var tp ix)) accum = Exists (Var (GroundRscalar tp) ix) : accum + go (TupRpair v1 v2) accum = go v1 $ go v2 accum + +strengthenVars :: genv :?> fenv -> Vars s genv t -> Maybe (Vars s fenv t) +strengthenVars k TupRunit = pure TupRunit +strengthenVars k (TupRsingle (Var t ix)) = TupRsingle . Var t <$> k ix +strengthenVars k (TupRpair v1 v2) = TupRpair <$> strengthenVars k v1 <*> strengthenVars k v2 + +partialLift :: forall op genv s. GroundsR s -> (forall fenv. genv :?> fenv -> Maybe (Binding fenv s)) -> [Exists (GroundVar genv)] -> (PartialSchedule op genv s, MaybeVars genv s) +partialLift tp f vars + | DeclareOutput outputEnv kOut varsOut <- declareOutput @() @s tp (mapTupR uniqueIfBuffer tp) + , Exists env <- convertEnvReadonlyFromList $ nubBy (\(Exists v1) (Exists v2) -> isJust $ matchVar v1 v2) vars -- TODO: Remove duplicates more efficiently + , Reads reEnv k inputBindings <- readRefs $ convertEnvRefs env + , DeclareVars lhs k' value <- declareVars $ mapTupR BaseRground tp + , Just binding <- f (reEnvIdx reEnv) + = + let + signals = convertEnvSignals env + resolvers = convertEnvSignalResolvers (k' .> k) env + in + ( PartialDo outputEnv env + $ Effect (SignalAwait signals) + $ inputBindings + $ Alet lhs binding + $ Effect (SignalResolve resolvers) + $ writeOutput outputEnv (varsOut (k' .> k .> convertEnvWeaken env)) (value weakenId) + , mapTupR (const NoVars) tp + ) + +uniqueIfBuffer :: GroundR t -> Uniqueness t +uniqueIfBuffer (GroundRbuffer _) = Unique +uniqueIfBuffer _ = Shared syncEnv :: PartialSchedule op genv t -> SyncEnv genv syncEnv (PartialDo _ env _) = convertEnvToSyncEnv env From 340e18ebebdd799ba876dec32f3eaa239dfa87a4 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Tue, 27 Oct 2020 21:22:28 +0100 Subject: [PATCH 012/813] First work on PartialSchedule to UniformSchedule --- .../Array/Accelerate/AST/Schedule/Uniform.hs | 9 ++- .../Accelerate/Trafo/Schedule/Uniform.hs | 73 +++++++++++++++++++ 2 files changed, 80 insertions(+), 2 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs b/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs index 3e84977a9..0e930dadc 100644 --- a/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs +++ b/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs @@ -53,16 +53,21 @@ data UniformSchedule exe env where -> UniformSchedule exe env Acond :: ExpVar env PrimBool - -> UniformSchedule exe env - -> UniformSchedule exe env + -> UniformSchedule exe env -- True branch + -> UniformSchedule exe env -- False branch + -> UniformSchedule exe env -- Operations after the if-then-else -> UniformSchedule exe env Awhile :: InputOutputR input output -> UniformScheduleFun exe env (input -> Output PrimBool -> ()) -> UniformScheduleFun exe env (input -> output -> ()) -> BaseVars env input + -> UniformSchedule exe env -- Operations after the while loop -> UniformSchedule exe env + -- Whereas Fork is symmetric, we generate programs in a way in which it is usually better + -- to execute the first branch first. A fork should thus be evaluated by delegating the second branch + -- (eg by putting the second branch in a queue) and continueing with the first branch Fork :: UniformSchedule exe env -> UniformSchedule exe env -> UniformSchedule exe env diff --git a/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs b/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs index c9aff6824..fd6a51d6d 100644 --- a/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs +++ b/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs @@ -44,6 +44,7 @@ import Data.Array.Accelerate.Type import Data.Maybe import Data.List import qualified Data.Set as S +import GHC.Stack -- * Compilation from PartitionedAcc to UniformSchedule data FutureValue senv t @@ -283,6 +284,8 @@ data OutputEnv fenv fenv' t r where -> OutputEnv fenv2 fenv3 t' r' -> OutputEnv fenv1 fenv3 (t, t') (r, r') + -- First SignalResolver grants read access, second guarantees that all reads have been finished. + -- Together they thus grant write access. OutputEnvUnique :: BLeftHandSide ((SignalResolver, SignalResolver), OutputRef (Buffer t)) fenv fenv' -> GroundR (Buffer t) -> OutputEnv fenv fenv' (Buffer t) ((SignalResolver, SignalResolver), OutputRef (Buffer t)) @@ -294,6 +297,18 @@ data OutputEnv fenv fenv' t r where OutputEnvUnit :: OutputEnv fenv fenv () () +data OutputVars t r where + OutputVarsPair :: OutputVars t r + -> OutputVars t' r' + -> OutputVars (t, t') (r, r') + + OutputVarsUnique :: OutputVars (Buffer t) ((SignalResolver, SignalResolver), OutputRef (Buffer t)) + + OutputVarsShared :: OutputVars t (SignalResolver, OutputRef t) + + -- No need to propagate the output, as we reused the same variables (using Destination in PartialDeclare) + OutputVarsIgnore :: OutputVars t r + data DeclareOutput fenv t where DeclareOutput :: OutputEnv fenv fenv' t r -> fenv :> fenv' @@ -779,3 +794,61 @@ maxSync (SyncRead r) (SyncRead r') = SyncRead (max r r') maxSync (SyncRead r) (SyncWrite w' r') = SyncWrite w' (max r r') maxSync (SyncWrite w r) (SyncRead r') = SyncWrite w (max r r') maxSync (SyncWrite w r) (SyncWrite w' r') = SyncWrite (max w w') (max r r') + +data SyncedValue fenv t where + SyncedScalar :: ScalarType t + -> Idx fenv Signal + -> Idx fenv (Ref t) + -> SyncedValue fenv t + + SyncedBuffer :: [Idx fenv Signal] -- Signals which give read access + -> [Idx fenv Signal] -- Signals which give write access + -> [Idx fenv SignalResolver] -- SignalResolvers to denote that the write operations have finished + -> Idx fenv (Ref (Buffer t)) + -> SyncedValue fenv (Buffer t) + + + +fromPartial :: forall fenvO1 fenvO2 op fenv genv t r. + HasCallStack + => OutputVars t r + -> BaseVars fenv r + -> PartialEnv (SyncedValue fenv) genv + -> PartialSchedule (Cluster op) genv t + -> UniformSchedule (Cluster op) fenv +fromPartial outputEnv outputVars env = \case + PartialDo outputEnv' convertEnv schedule -> undefined -- Something with a substitution + PartialReturn uniquenesses vars -> undefined + PartialDeclare syncEnv lhs dest uniquenesses bnd body -> undefined -- Something with fork + PartialAcond syncEnv condition true false -> undefined + PartialAwhile syncEnv uniquenesses condition step vars -> undefined + where + travReturn' :: OutputVars t r -> BaseVars fenv r -> GroundVars fenv t -> [([Idx fenv Signal], UniformSchedule (Cluster op) fenv -> UniformSchedule (Cluster op) fenv)] -> [([Idx fenv Signal], UniformSchedule (Cluster op) fenv)] + travReturn' (OutputVarsPair o1 o2) (TupRpair r1 r2) (TupRpair v1 v2) accum = travReturn' o1 r1 v1 $ travReturn' o2 r2 v2 accum + travReturn' OutputVarsIgnore _ _ accum = accum + travReturn' (OutputEnvShared _ _) (TupRpair (TupRsingle signal) (TupRsingle ref)) (TupRsingle (Var tp ix)) accum = task : accum + where + task = case prjPartial ix env of + Nothing -> internalError "Variable not present in environment" + Just (SyncedScalar _ signal ref) -> ([signal], undefined) + Just (SyncedBuffer readAccess _ _ ref) -> (readAccess, Alet (LeftHandSideSingle $ BaseRground tp) (RefRead ref) $ Effect (RefWrite undefined undefined) $ Effect (SignalResolve undefined)) + travReturn' (OutputEnvUnique _ _) (TupRpair (TupRpair (TupRsingle signalRead) (TupRsingle signalWrite)) (TupRsingle ref)) (TupRsingle v) accum = undefined : accum + +forks :: [UniformSchedule (Cluster op) fenv] -> UniformSchedule (Cluster op) fenv +forks [] = Return +forks [u] = s +forks (u:us) = Fork (forks us) u + +serial :: forall op fenv. [UniformSchedule (Cluster op) fenv] -> UniformSchedule (Cluster op) fenv +serial = go weakenId + where + go :: fenv :> fenv' -> [UniformSchedule (Cluster op) fenv] -> UniformSchedule (Cluster op) fenv' + go k [] = Return + go k (u:us) = case u of + Return -> go k us + Alet lhs bnd u' + | Exists lhs' <- rebuildLHS lhs -> go (weakenWithLHS lhs' .> k) $ u' : us + Effect effect u' -> Effect (weaken k effect) $ go k $ u' : us + Acond cond true false u' -> Acond (weaken k cond) (weaken k true) (weaken k false) $ go k $ u' : us + Awhile io cond step input u' -> Awhile io (weaken k cond) (weaken k step) (weaken k) input $ go k $ u' : us + Fork u' u'' -> Fork (go k $ u' : us) (weaken k u'') From d4d05250a2b9e1245fc479884a0f3c98fa1d067a Mon Sep 17 00:00:00 2001 From: David van Balen Date: Mon, 23 Nov 2020 10:48:15 +0100 Subject: [PATCH 013/813] Added first version of Cluster datatype --- src/Data/Array/Accelerate/AST/Partitioned.hs | 48 +++++++++++++++++--- 1 file changed, 41 insertions(+), 7 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Partitioned.hs b/src/Data/Array/Accelerate/AST/Partitioned.hs index 102a9edb0..e3114799f 100644 --- a/src/Data/Array/Accelerate/AST/Partitioned.hs +++ b/src/Data/Array/Accelerate/AST/Partitioned.hs @@ -18,18 +18,52 @@ -- Stability : experimental -- Portability : non-portable (GHC extensions) -- - +{-# OPTIONS_GHC -Wno-unused-binds #-} -- for a more pleasant IDE experience :) module Data.Array.Accelerate.AST.Partitioned ( module Data.Array.Accelerate.AST.Operation, Cluster(..), PartitionedAcc, PartitionedAfun ) where import Data.Array.Accelerate.AST.Operation hiding ( OperationAcc, Execute(..) ) -data Cluster op env where - Base :: op args -> Args env args -> Cluster op env - -- TODO: Vertical, Horizontal, Diagonal +-- replaces 'Execute' during the fusion ILP pass: PreOpenAcc (Execute op) -> PreOpenAcc (Cluster op) +newtype Cluster op env = Root (forall args. ClusterTree op env args) + +data ClusterTree op env args where + Leaf :: op args -> Args env args -> ClusterTree op env args + + Node :: ClusterTree op env a + -> ClusterTree op env b + -> Combine a b c + -> ClusterTree op env c + +data Combine a b c = Vertical (Vertical a b c) + | Horizontal (Horizontal a b c) + | Diagonal (Diagonal a b c) + +-- Proof that `first` can fuse before `second`, giving result type `total`. +data Vertical first second total where + -- The canonical case: the `Array sh e` is produced and consumed. + OutVertical :: Vertical (Out sh e -> a) (In sh e -> a) a + MutVertical :: Vertical (Mut sh e -> a) (In sh e -> a) a + + -- Does this need induction? + -- InductVertical :: Vertical f s t + -- -> Vertical (In sh e -> f) (In sh e -> s) (In sh e -> t) + -- OutductVertical :: Vertical f s t + -- -> Vertical (Out sh e -> f) (Out sh e -> s) (Out sh e -> t) + -- MutductVertical :: Vertical f s t + -- -> Vertical (Mut sh e -> f) (Mut sh e -> s) (Mut sh e -> t) + +data Horizontal left right total where + -- Both outputs are stored. We can't neccesarily relate the shapes to eachother here. + ReallyHorizontal :: Horizontal (Out sh1 e1 -> a) (Out sh2 e2 -> a) (Out sh1 e1 -> Out sh2 e2 -> a) + -- Safely fusing `Mut` horizontally sounds like a minefield, so skipping until that seems needed + +data Diagonal first second total where + -- Like the canonical vertical case, but the `Array sh e` is stored for later use + OutDiagonal :: Diagonal (Out sh e -> a) (In sh e -> a) (Out sh e -> a) + MutDiagonal :: Diagonal (Mut sh e -> a) (In sh e -> a) (Mut sh e -> a) -instance IsExecutableAcc (Cluster op) where - reindexExecPartial k (Base op args) = Base op <$> reindexArgs k args - execVars (Base _ args) = argsVars args +-- todo +-- instance IsExecutableAcc (Cluster op) type PartitionedAcc op = PreOpenAcc (Cluster op) type PartitionedAfun op = PreOpenAfun (Cluster op) From 6f0502804e76ed0e8f7e6e916970f0535b89ccde Mon Sep 17 00:00:00 2001 From: David Date: Tue, 19 Jan 2021 17:07:11 +0100 Subject: [PATCH 014/813] outline for ILP plan --- src/Data/Array/Accelerate/AST/Partitioned.hs | 8 ++- .../Array/Accelerate/Trafo/Clustering/ILP.hs | 57 +++++++++++++++++++ 2 files changed, 63 insertions(+), 2 deletions(-) create mode 100644 src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs diff --git a/src/Data/Array/Accelerate/AST/Partitioned.hs b/src/Data/Array/Accelerate/AST/Partitioned.hs index e3114799f..1b5450008 100644 --- a/src/Data/Array/Accelerate/AST/Partitioned.hs +++ b/src/Data/Array/Accelerate/AST/Partitioned.hs @@ -18,8 +18,12 @@ -- Stability : experimental -- Portability : non-portable (GHC extensions) -- -{-# OPTIONS_GHC -Wno-unused-binds #-} -- for a more pleasant IDE experience :) -module Data.Array.Accelerate.AST.Partitioned ( module Data.Array.Accelerate.AST.Operation, Cluster(..), PartitionedAcc, PartitionedAfun ) where +module Data.Array.Accelerate.AST.Partitioned + ( module Data.Array.Accelerate.AST.Operation + , Cluster(..) + , PartitionedAcc + , PartitionedAfun + ) where import Data.Array.Accelerate.AST.Operation hiding ( OperationAcc, Execute(..) ) diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs new file mode 100644 index 000000000..ab518fd36 --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -0,0 +1,57 @@ +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures, RankNTypes #-} +module Data.Array.Accelerate.Trafo.Clustering.ILP where +import qualified Data.IntMap as M +import Data.Array.Accelerate.AST.Operation (PreOpenAcc, Execute) +import Data.Kind +import Data.Array.Accelerate.AST.Idx +import qualified Data.Set as S +import Data.Array.Accelerate.AST.Partitioned +import Data.Array.Accelerate.AST.LeftHandSide + +-- the graph datatype, including fusible/infusible edges, .., +-- identifies nodes with unique Ints +data Graph + + +class MakesILP op where + -- todo: maybe can extract more commonality from this, making the class more complicated but instances smaller/easier + mkGraph :: PreOpenAcc (Execute op) () a-> Graph + + -- for efficient reconstruction - important that the numbers match the numbers in mkGraph + mkMap :: PreOpenAcc (Execute op) () a -> M.IntMap (UnsafeConstruction op) + + +-- Describes how, given a list of indices into 'env', we can reconstruct an 'Execute op env'. +-- as the name suggests, this cannot be done 'safely': we're in the business of constructing +-- a strongly typed AST from untyped ILP output. +-- note that 'a list of indices' is akin to a weakening (that possibly reorders the env too) +-- todo: not all Idxs need to have the same 'a', so `list` should be `hlist` or tuplist :) +data UnsafeConstruction (op :: Type -> Type) = forall a. UnsafeConstruction (S.Set Int) (forall env. [Idx a env] -> Execute op env) + +-- todo: choose suitable library/bindings to solver +data ILP + +-- A program can result in multiple ILPs, for example, the body of an 'awhile' cannot be fused with anything outside of it. +-- you `can` encode this in the ILP, but since the solutions are independant of each other it should be much more efficient +-- to solve them separately. This avoids many 'infusible edges', and significantly reduces the search space. The extracted +-- subtree gets encoded as a sort of 'foreign call', preventing all fusion. +makeILPs :: Graph -> [ILP] +makeILPs = undefined + +-- call the solver, and interpret the result as a list (in order of execution) of clusters (sets of nodes). +-- gets called for each ILP +solveILP :: ILP -> [S.Set Int] +solveILP = undefined + +-- Order all lists of clusters in a logical way +combineSets :: [[S.Set Int]] -> [S.Set Int] +combineSets = undefined + +-- "open research question" +-- Each set of ints corresponds to a set of unsafeConstructions, which themselves contain a set of ints (the things they depend on). +-- Some of those ints will refer to nodes in previous clusters, others to nodes in this cluster. +-- One pass over these datatypes (back-to-front) should identify the 'output type' of each cluster: which nodes are needed in later clusters? +-- Then, we can construct the clusters front-to-back. +reconstruct :: [S.Set Int] -> M.IntMap (UnsafeConstruction op) -> Exists (PreOpenAcc (Cluster op) ()) +reconstruct = undefined From 45a3051b73f5fab63f095eec62e13b21c4c449dc Mon Sep 17 00:00:00 2001 From: David Date: Thu, 21 Jan 2021 12:00:52 +0100 Subject: [PATCH 015/813] checking out --- src/Data/Array/Accelerate/Interpreter.hs | 1 - src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs | 15 ++++++++------- .../Array/Accelerate/Trafo/Clustering/Stream.hs | 13 +++++++++++++ src/Data/Array/Accelerate/Trafo/NewNewFusion.hs | 5 +++-- 4 files changed, 24 insertions(+), 10 deletions(-) create mode 100644 src/Data/Array/Accelerate/Trafo/Clustering/Stream.hs diff --git a/src/Data/Array/Accelerate/Interpreter.hs b/src/Data/Array/Accelerate/Interpreter.hs index d4369fdbf..d137b8857 100644 --- a/src/Data/Array/Accelerate/Interpreter.hs +++ b/src/Data/Array/Accelerate/Interpreter.hs @@ -43,7 +43,6 @@ module Data.Array.Accelerate.Interpreter ( import Data.Array.Accelerate.AST hiding ( Boundary(..) ) import Data.Array.Accelerate.AST.Environment import Data.Array.Accelerate.AST.Var -import Data.Array.Accelerate.Array.Data import Data.Array.Accelerate.Error import Data.Array.Accelerate.Representation.Array import Data.Array.Accelerate.Representation.Elt diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs index ab518fd36..3a3d3221d 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -2,7 +2,7 @@ {-# LANGUAGE KindSignatures, RankNTypes #-} module Data.Array.Accelerate.Trafo.Clustering.ILP where import qualified Data.IntMap as M -import Data.Array.Accelerate.AST.Operation (PreOpenAcc, Execute) +import Data.Array.Accelerate.AST.Operation (Execute) import Data.Kind import Data.Array.Accelerate.AST.Idx import qualified Data.Set as S @@ -22,6 +22,7 @@ class MakesILP op where mkMap :: PreOpenAcc (Execute op) () a -> M.IntMap (UnsafeConstruction op) + -- Describes how, given a list of indices into 'env', we can reconstruct an 'Execute op env'. -- as the name suggests, this cannot be done 'safely': we're in the business of constructing -- a strongly typed AST from untyped ILP output. @@ -36,7 +37,7 @@ data ILP -- you `can` encode this in the ILP, but since the solutions are independant of each other it should be much more efficient -- to solve them separately. This avoids many 'infusible edges', and significantly reduces the search space. The extracted -- subtree gets encoded as a sort of 'foreign call', preventing all fusion. -makeILPs :: Graph -> [ILP] +makeILPs :: Graph -> (ILP, M.IntMap ILP) makeILPs = undefined -- call the solver, and interpret the result as a list (in order of execution) of clusters (sets of nodes). @@ -44,14 +45,14 @@ makeILPs = undefined solveILP :: ILP -> [S.Set Int] solveILP = undefined --- Order all lists of clusters in a logical way -combineSets :: [[S.Set Int]] -> [S.Set Int] -combineSets = undefined -- "open research question" -- Each set of ints corresponds to a set of unsafeConstructions, which themselves contain a set of ints (the things they depend on). -- Some of those ints will refer to nodes in previous clusters, others to nodes in this cluster. -- One pass over these datatypes (back-to-front) should identify the 'output type' of each cluster: which nodes are needed in later clusters? --- Then, we can construct the clusters front-to-back. -reconstruct :: [S.Set Int] -> M.IntMap (UnsafeConstruction op) -> Exists (PreOpenAcc (Cluster op) ()) +-- Then, we can construct the clusters front-to-back: +-- identify the nodes that only depend on nodes outside of the cluster, they are the initials +-- the `output type` indicates which nodes we will need to keep: they are all either a final node in the cluster, or get diagonally fused +-- how exactly we can use this information (and a dep. graph) to construct a cluster of ver,hor,diag is not clear.. Will also depend on the exact cluster definition. +reconstruct :: Graph -> [S.Set Int] -> M.IntMap [S.Set Int] -> M.IntMap (UnsafeConstruction op) -> Exists (PreOpenAcc (Cluster op) ()) reconstruct = undefined diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/Stream.hs b/src/Data/Array/Accelerate/Trafo/Clustering/Stream.hs new file mode 100644 index 000000000..7d7a72a67 --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/Clustering/Stream.hs @@ -0,0 +1,13 @@ +module Data.Array.Accelerate.Trafo.Clustering.Stream + where + +import Data.Array.Accelerate.AST.Partitioned +import Data.Array.Accelerate.AST.Operation (OperationAcc) + + + +-- Emulate the old 'delayed arrays' approach to fusion +streamfusion :: OperationAcc op benv a -> PartitionedAcc op benv a +streamfusion = undefined + + diff --git a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs index 886a16330..76e4d4d1a 100644 --- a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs +++ b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs @@ -40,6 +40,7 @@ import Data.Array.Accelerate.Error import Data.Array.Accelerate.Debug.Flags ( array_fusion ) import qualified Data.Array.Accelerate.Debug.Stats as Stats +import Data.Kind #ifdef ACCELERATE_DEBUG import System.IO.Unsafe -- for debugging #endif @@ -48,7 +49,7 @@ import System.IO.Unsafe -- for debugging -- Array Fusion -- ============ -class FusibleAcc (op :: * -> *) where +class FusibleAcc (op :: Type -> Type) where -- | Apply the fusion transformation to a de Bruijn AST -- @@ -78,4 +79,4 @@ withSimplStats x = x #endif dontFuse :: Execute op benv -> Cluster op benv -dontFuse (Execute op args) = Base op args +dontFuse = undefined \ No newline at end of file From 6058d0b15974f44b11bee72472283de18bbcd09c Mon Sep 17 00:00:00 2001 From: David Date: Fri, 22 Jan 2021 14:46:28 +0100 Subject: [PATCH 016/813] Updated version of cluster datatype --- src/Data/Array/Accelerate/AST/Partitioned.hs | 108 +++++++++++++------ 1 file changed, 77 insertions(+), 31 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Partitioned.hs b/src/Data/Array/Accelerate/AST/Partitioned.hs index 1b5450008..c8cf30ce4 100644 --- a/src/Data/Array/Accelerate/AST/Partitioned.hs +++ b/src/Data/Array/Accelerate/AST/Partitioned.hs @@ -8,7 +8,9 @@ {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} -{-# OPTIONS_HADDOCK hide #-} + +{-# OPTIONS_GHC -Wno-unused-binds #-} -- remove later, I don't like seeing the warnings now + -- | -- Module : Data.Array.Accelerate.AST.Partitioned -- Copyright : [2008..2020] The Accelerate Team @@ -27,47 +29,91 @@ module Data.Array.Accelerate.AST.Partitioned import Data.Array.Accelerate.AST.Operation hiding ( OperationAcc, Execute(..) ) --- replaces 'Execute' during the fusion ILP pass: PreOpenAcc (Execute op) -> PreOpenAcc (Cluster op) -newtype Cluster op env = Root (forall args. ClusterTree op env args) -data ClusterTree op env args where - Leaf :: op args -> Args env args -> ClusterTree op env args +-- `Cluster` replaces `Execute` during the fusion pass: +-- PreOpenAcc (Execute op) +-- -> PreOpenAcc (Cluster op) + +-- As a refresh, `Execute` is currently defined as: +-- data Execute op env where +-- Execute :: op args -> Args env args -> Execute op env + +data Cluster op env where + Root :: ClusterTree op args -> Args env args -> Cluster op env + +instance IsExecutableAcc (Cluster op) where + reindexExecPartial k (Root op args) = Root op <$> reindexArgs k args + execVars (Root _ args) = argsVars args + + -- Could even abstract one more step (will do once we settle on ClusterTree) + + -- data Foo f (op :: Type -> Type) env where + -- Foo :: f op args -> Args env args -> Foo f op env + + -- data Identity a b = Identity (a b) + -- data Bar a b = Bar Int (a b) + + -- type Execute' = Foo Identity + -- type LabelledExecute = Foo Bar -- as input to the ILP, give each Execute a unique (Int) label. + -- type Cluster' = Foo ClusterTree - Node :: ClusterTree op env a - -> ClusterTree op env b - -> Combine a b c - -> ClusterTree op env c + -- instance IsExecutableAcc (Foo f op) where + -- reindexExecPartial k (Foo fop args) = Foo fop <$> reindexArgs k args + -- execVars (Foo _ args) = argsVars args -data Combine a b c = Vertical (Vertical a b c) - | Horizontal (Horizontal a b c) - | Diagonal (Diagonal a b c) + + + +data ClusterTree op args where + Leaf :: op args -> ClusterTree op args + + Node :: ClusterTree op a + -> ClusterTree op b + -> Combine a b c + -> ClusterTree op c + + Reorder :: SwapArgs args args' + -> ClusterTree op args + -> ClusterTree op args' + +-- Note that, in general, these combination descriptors can definitely represent +-- undesirable states: It's probably not doable to encode all fusability rules +-- in the types (especially while abstracting over backends), instead we will need +-- to call `error "impossible fusion"` in the backends at some points (particularly codegen). +-- maybe should inline the three options? +data Combine a b c = CVertical (Vertical a b c) + | CHorizontal (Horizontal a b c) + | CDiagonal (Diagonal a b c) -- Proof that `first` can fuse before `second`, giving result type `total`. data Vertical first second total where - -- The canonical case: the `Array sh e` is produced and consumed. - OutVertical :: Vertical (Out sh e -> a) (In sh e -> a) a - MutVertical :: Vertical (Mut sh e -> a) (In sh e -> a) a - - -- Does this need induction? - -- InductVertical :: Vertical f s t - -- -> Vertical (In sh e -> f) (In sh e -> s) (In sh e -> t) - -- OutductVertical :: Vertical f s t - -- -> Vertical (Out sh e -> f) (Out sh e -> s) (Out sh e -> t) - -- MutductVertical :: Vertical f s t - -- -> Vertical (Mut sh e -> f) (Mut sh e -> s) (Mut sh e -> t) + -- An array is produced and consumed, fusing it away. + -- NOTE: this means that the array does not appear in the environment, and + -- it does not have an accompanying `Arg` constructor: Its scope is now + -- bound by this `Vertical` constructor. + Vertical :: Vertical (Out sh e -> a) (In sh e -> a) a data Horizontal left right total where - -- Both outputs are stored. We can't neccesarily relate the shapes to eachother here. - ReallyHorizontal :: Horizontal (Out sh1 e1 -> a) (Out sh2 e2 -> a) (Out sh1 e1 -> Out sh2 e2 -> a) - -- Safely fusing `Mut` horizontally sounds like a minefield, so skipping until that seems needed + -- Both outputs are stored. We purposely don't require sh1 == sh2, but the rest of the types + -- need to align, so this is why we need weakening. + Horizontal :: Horizontal (Out sh1 e1 -> a) (Out sh2 e2 -> a) (Out sh1 e1 -> Out sh2 e2 -> a) data Diagonal first second total where - -- Like the canonical vertical case, but the `Array sh e` is stored for later use - OutDiagonal :: Diagonal (Out sh e -> a) (In sh e -> a) (Out sh e -> a) - MutDiagonal :: Diagonal (Mut sh e -> a) (In sh e -> a) (Mut sh e -> a) + -- Like vertical, but the `Array sh e` is stored for later use + Diagonal :: Diagonal (Out sh e -> a) (In sh e -> a) (Out sh e -> a) --- todo --- instance IsExecutableAcc (Cluster op) type PartitionedAcc op = PreOpenAcc (Cluster op) type PartitionedAfun op = PreOpenAfun (Cluster op) + +-- Re-order the type level arguments, to align them for the fusion constructors. +-- pray we won't need it, fear we might, hope it doesn't complicate things +data SwapArgs a b where + -- Switch the first two arguments. This might be all we need, but probably not.. + Swap :: SwapArgs (a -> b -> x) (b -> a -> x) + + -- Alternatively, we would need constructors traversing the whole type, something like these: + Start :: SwapArgs () () + Dig :: SwapArgs a b -> SwapArgs (x -> a) (x -> b) + Swap' :: SwapArgs a (x -> y -> z) + -> SwapArgs a (y -> x -> z) From 8462c425c94d89066a01fe037e80d75b2b9afab5 Mon Sep 17 00:00:00 2001 From: David Date: Mon, 25 Jan 2021 18:04:06 +0100 Subject: [PATCH 017/813] using Limp for ILP solving for now, switching later should never be too difficult --- accelerate.cabal | 1 + .../Array/Accelerate/Trafo/Clustering/ILP.hs | 75 +++++++++++++++---- 2 files changed, 60 insertions(+), 16 deletions(-) diff --git a/accelerate.cabal b/accelerate.cabal index 32fda4c46..067eaa970 100644 --- a/accelerate.cabal +++ b/accelerate.cabal @@ -284,6 +284,7 @@ Library , hashtables >= 1.2.3 , hedgehog >= 0.5 , lens >= 4.0 + , limp >= 0.3.2.3 , mtl >= 2.0 , prettyprinter >= 1.2 , prettyprinter-ansi-terminal >= 1.0 diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs index 3a3d3221d..9f9fa70e3 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -1,27 +1,73 @@ +{-# LANGUAGE TypeFamilies #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE KindSignatures, RankNTypes #-} module Data.Array.Accelerate.Trafo.Clustering.ILP where import qualified Data.IntMap as M import Data.Array.Accelerate.AST.Operation (Execute) -import Data.Kind -import Data.Array.Accelerate.AST.Idx -import qualified Data.Set as S -import Data.Array.Accelerate.AST.Partitioned -import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.AST.Idx ( Idx ) +import Data.Array.Accelerate.AST.Partitioned ( PreOpenAcc, Cluster ) +import Data.Array.Accelerate.AST.LeftHandSide ( Exists ) + +import Data.Kind ( Type ) + +-- In this file, order very often subly does matter. +-- To keep this clear, we use S.Set whenever it does not, +-- and [] only when it does. +import qualified Data.Set as S + +-- Limp is a Linear Integer Mixed Programming library. +-- We only use the Integer part. It has a backend that +-- binds to CBC, which is apparently a good one? +import qualified Numeric.Limp.Program as P +import qualified Numeric.Limp.Rep.IntDouble as R + + + -- the graph datatype, including fusible/infusible edges, .., -- identifies nodes with unique Ints -data Graph +type Label = Int + +-- | Directed edge (a,b): `a` must be computed [strictly?] before `b`. +type Edge = (Label, Label) + + +data Graph = Graph + { nodes :: S.Set Label + , fusibleEdges :: S.Set Edge -- Can be fused over, otherwise `a` before `b`. + , infusibleEdges :: S.Set Edge -- Can't be fused over, always `a` before `b`. + } + + +-- The graph is the 'common part' of the ILP, +-- each backend has to encode their own constraints +-- describing the fusion rules. +data Information op = Information Graph (S.Set (BackendCon op)) class MakesILP op where - -- todo: maybe can extract more commonality from this, making the class more complicated but instances smaller/easier - mkGraph :: PreOpenAcc (Execute op) () a-> Graph + -- Variables needed to express backend-specific fusion rules. + type BackendVar op + + -- todo: maybe we can extract more commonality from this, making the class more complicated but instances smaller/easier + mkGraph :: PreOpenAcc (Execute op) () a-> Information op - -- for efficient reconstruction - important that the numbers match the numbers in mkGraph + -- for efficient reconstruction - important that the numbers match the numbers in mkGraph. Can fuse the two to ensure, + -- or do a separate 'labelling' pass first (:: Execute op -> LabelledExe op). mkMap :: PreOpenAcc (Execute op) () a -> M.IntMap (UnsafeConstruction op) +data Variable op + = Pi Label -- For acyclic ordering of clusters + | Fused Label Label -- 0 is fused (same cluster), 1 is unfused. We do *not* have one of these for all pairs! + | BackendSpecific (BackendVar op) -- Variables needed to express backend-specific fusion rules. + + +-- We have integer variables, and no reals. +type ILP op = P.Program (Variable op) () R.IntDouble +type Constraint op = P.Constraint (Variable op) () R.IntDouble +type BackendCon op = P.Constraint (BackendVar op) () R.IntDouble + -- Describes how, given a list of indices into 'env', we can reconstruct an 'Execute op env'. -- as the name suggests, this cannot be done 'safely': we're in the business of constructing @@ -30,19 +76,16 @@ class MakesILP op where -- todo: not all Idxs need to have the same 'a', so `list` should be `hlist` or tuplist :) data UnsafeConstruction (op :: Type -> Type) = forall a. UnsafeConstruction (S.Set Int) (forall env. [Idx a env] -> Execute op env) --- todo: choose suitable library/bindings to solver -data ILP - -- A program can result in multiple ILPs, for example, the body of an 'awhile' cannot be fused with anything outside of it. -- you `can` encode this in the ILP, but since the solutions are independant of each other it should be much more efficient -- to solve them separately. This avoids many 'infusible edges', and significantly reduces the search space. The extracted -- subtree gets encoded as a sort of 'foreign call', preventing all fusion. -makeILPs :: Graph -> (ILP, M.IntMap ILP) -makeILPs = undefined +makeILPs :: Information op -> (ILP op, M.IntMap (ILP op)) +makeILPs (Information graph backendcons) = undefined -- call the solver, and interpret the result as a list (in order of execution) of clusters (sets of nodes). -- gets called for each ILP -solveILP :: ILP -> [S.Set Int] +solveILP :: ILP op -> [S.Set Int] solveILP = undefined @@ -53,6 +96,6 @@ solveILP = undefined -- Then, we can construct the clusters front-to-back: -- identify the nodes that only depend on nodes outside of the cluster, they are the initials -- the `output type` indicates which nodes we will need to keep: they are all either a final node in the cluster, or get diagonally fused --- how exactly we can use this information (and a dep. graph) to construct a cluster of ver,hor,diag is not clear.. Will also depend on the exact cluster definition. +-- How exactly we can use this information (and a dep. graph) to construct a cluster of ver,hor,diag is not clear.. Will also depend on the exact cluster definition. reconstruct :: Graph -> [S.Set Int] -> M.IntMap [S.Set Int] -> M.IntMap (UnsafeConstruction op) -> Exists (PreOpenAcc (Cluster op) ()) reconstruct = undefined From 64497bf58663b3afe698781f84c9b05439ab3a21 Mon Sep 17 00:00:00 2001 From: David Date: Mon, 25 Jan 2021 18:57:14 +0100 Subject: [PATCH 018/813] comments --- .../Array/Accelerate/Trafo/Clustering/ILP.hs | 27 ++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-) diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs index 9f9fa70e3..86979821d 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -18,6 +18,8 @@ import qualified Data.Set as S -- Limp is a Linear Integer Mixed Programming library. -- We only use the Integer part. It has a backend that -- binds to CBC, which is apparently a good one? +-- We can always switch to a different ILP library +-- later, the interfaces are all quite similar import qualified Numeric.Limp.Program as P import qualified Numeric.Limp.Rep.IntDouble as R @@ -42,7 +44,7 @@ data Graph = Graph -- The graph is the 'common part' of the ILP, -- each backend has to encode their own constraints -- describing the fusion rules. -data Information op = Information Graph (S.Set (BackendCon op)) +data Information op = Information Graph (S.Set (Constraint op)) class MakesILP op where @@ -66,7 +68,6 @@ data Variable op -- We have integer variables, and no reals. type ILP op = P.Program (Variable op) () R.IntDouble type Constraint op = P.Constraint (Variable op) () R.IntDouble -type BackendCon op = P.Constraint (BackendVar op) () R.IntDouble -- Describes how, given a list of indices into 'env', we can reconstruct an 'Execute op env'. @@ -81,7 +82,27 @@ data UnsafeConstruction (op :: Type -> Type) = forall a. UnsafeConstruction (S.S -- to solve them separately. This avoids many 'infusible edges', and significantly reduces the search space. The extracted -- subtree gets encoded as a sort of 'foreign call', preventing all fusion. makeILPs :: Information op -> (ILP op, M.IntMap (ILP op)) -makeILPs (Information graph backendcons) = undefined +makeILPs (Information graph backendcons) = somehowCombine graphILPs backendcons + where + somehowCombine = undefined -- Put all backend-specific constraints into each ILP? Or can we be smarter, + -- only adding ones that somehow 'matter' for the ILPs? Is the solver smart + -- enough, and will it disregard these other constraints? What if the backend + -- somehow needs the values that the backend-specific variables take in the + -- solution, then we need to find out which solution is the relevant one? + graphILPs :: forall op. (ILP op, M.IntMap (ILP op)) + graphILPs = undefined -- Formula's from the papers, such that: + -- - clusters are acyclic (w.r.t. infusible edges and non-fused fusible edges) + -- - infusible edges are respected + -- - number of clusters is minimised + -- + -- New stuff: control flow cannot be fused, so we make separate ILPs for e.g. + -- then-branch and else-branch. In the future, a possible optimisation is to + -- generate code for the awhile-condition twice: once maybe fused after the body, + -- once maybe fused after input. For now, condition and body are both treated + -- as 'foreign calls', like if-then-else. + -- The IntMap maps from a label to the corresponding ILP (only for things treated + -- as 'foreign calls', like control flow). + -- call the solver, and interpret the result as a list (in order of execution) of clusters (sets of nodes). -- gets called for each ILP From 5f4498a25df6f8586dfdb076c441c213b97780ee Mon Sep 17 00:00:00 2001 From: David Date: Tue, 26 Jan 2021 17:48:38 +0100 Subject: [PATCH 019/813] some ILP work --- .../Array/Accelerate/Trafo/Clustering/ILP.hs | 92 ++++++++++++------- 1 file changed, 61 insertions(+), 31 deletions(-) diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs index 86979821d..40dfa2ea8 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -1,6 +1,9 @@ +{-# LANGUAGE DataKinds #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE GADTs #-} -{-# LANGUAGE KindSignatures, RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE KindSignatures #-} module Data.Array.Accelerate.Trafo.Clustering.ILP where import qualified Data.IntMap as M import Data.Array.Accelerate.AST.Operation (Execute) @@ -10,6 +13,7 @@ import Data.Array.Accelerate.AST.LeftHandSide ( Exists ) import Data.Kind ( Type ) + -- In this file, order very often subly does matter. -- To keep this clear, we use S.Set whenever it does not, -- and [] only when it does. @@ -22,6 +26,7 @@ import qualified Data.Set as S -- later, the interfaces are all quite similar import qualified Numeric.Limp.Program as P import qualified Numeric.Limp.Rep.IntDouble as R +import Data.List (foldl') @@ -30,12 +35,12 @@ import qualified Numeric.Limp.Rep.IntDouble as R -- identifies nodes with unique Ints type Label = Int --- | Directed edge (a,b): `a` must be computed [strictly?] before `b`. +-- | Directed edge (a,b): `a` must be computed [possibly strictly] before `b`. type Edge = (Label, Label) - +-- TODO: at some point, set fusibleEdges := fusibleEdges \\ infusibleEdges. Makes ILP smaller. data Graph = Graph - { nodes :: S.Set Label + { graphNodes :: S.Set Label , fusibleEdges :: S.Set Edge -- Can be fused over, otherwise `a` before `b`. , infusibleEdges :: S.Set Edge -- Can't be fused over, always `a` before `b`. } @@ -44,15 +49,26 @@ data Graph = Graph -- The graph is the 'common part' of the ILP, -- each backend has to encode their own constraints -- describing the fusion rules. -data Information op = Information Graph (S.Set (Constraint op)) +data Information op = Information Graph (Constraint op) (S.Set (P.Bounds (Variable op) () R.IntDouble)) class MakesILP op where -- Variables needed to express backend-specific fusion rules. type BackendVar op - + + -- Control flow cannot be fused, so we make separate ILPs for e.g. + -- then-branch and else-branch. In the future, a possible optimisation is to + -- generate code for the awhile-condition twice: once maybe fused after the body, + -- once maybe fused after input. For now, condition and body are both treated + -- as 'foreign calls', like if-then-else. + -- The IntMap maps from a label to the corresponding ILP (only for things treated + -- as 'foreign calls', like control flow). + -- A program can result in multiple ILPs, for example, the body of an 'awhile' cannot be fused with anything outside of it. + -- you `can` encode this in the ILP, but since the solutions are independant of each other it should be much more efficient + -- to solve them separately. This avoids many 'infusible edges', and significantly reduces the search space. The extracted + -- subtree gets encoded as a sort of 'foreign call', preventing all fusion. -- todo: maybe we can extract more commonality from this, making the class more complicated but instances smaller/easier - mkGraph :: PreOpenAcc (Execute op) () a-> Information op + mkGraph :: PreOpenAcc (Execute op) () a-> (Information op, M.IntMap (Information op)) -- for efficient reconstruction - important that the numbers match the numbers in mkGraph. Can fuse the two to ensure, -- or do a separate 'labelling' pass first (:: Execute op -> LabelledExe op). @@ -77,31 +93,45 @@ type Constraint op = P.Constraint (Variable op) () R.IntDouble -- todo: not all Idxs need to have the same 'a', so `list` should be `hlist` or tuplist :) data UnsafeConstruction (op :: Type -> Type) = forall a. UnsafeConstruction (S.Set Int) (forall env. [Idx a env] -> Execute op env) --- A program can result in multiple ILPs, for example, the body of an 'awhile' cannot be fused with anything outside of it. --- you `can` encode this in the ILP, but since the solutions are independant of each other it should be much more efficient --- to solve them separately. This avoids many 'infusible edges', and significantly reduces the search space. The extracted --- subtree gets encoded as a sort of 'foreign call', preventing all fusion. -makeILPs :: Information op -> (ILP op, M.IntMap (ILP op)) -makeILPs (Information graph backendcons) = somehowCombine graphILPs backendcons + +makeILP :: Information op -> ILP op +makeILP (Information + (Graph nodes fuseEdges nofuseEdges) + backendconstraints + backendbounds + ) = combine graphILP where - somehowCombine = undefined -- Put all backend-specific constraints into each ILP? Or can we be smarter, - -- only adding ones that somehow 'matter' for the ILPs? Is the solver smart - -- enough, and will it disregard these other constraints? What if the backend - -- somehow needs the values that the backend-specific variables take in the - -- solution, then we need to find out which solution is the relevant one? - graphILPs :: forall op. (ILP op, M.IntMap (ILP op)) - graphILPs = undefined -- Formula's from the papers, such that: - -- - clusters are acyclic (w.r.t. infusible edges and non-fused fusible edges) - -- - infusible edges are respected - -- - number of clusters is minimised - -- - -- New stuff: control flow cannot be fused, so we make separate ILPs for e.g. - -- then-branch and else-branch. In the future, a possible optimisation is to - -- generate code for the awhile-condition twice: once maybe fused after the body, - -- once maybe fused after input. For now, condition and body are both treated - -- as 'foreign calls', like if-then-else. - -- The IntMap maps from a label to the corresponding ILP (only for things treated - -- as 'foreign calls', like control flow). + combine (P.Program dir fun cons bnds) = + P.Program dir fun (cons <> backendconstraints) + (bnds <> S.toList backendbounds) + + n = S.size nodes + -- __ | don't know why the objFun has to be + -- / | 'real', everything else is integral + -- v + graphILP = P.Program P.Minimise (P.toR objFun) constraints bounds + + -- placeholder, currently maximising the number of vertical/diagonal fusions. + objFun = foldl' (\f (i, j) -> f P..+. P.z1 (Fused i j)) P.c0 (S.toList fuseEdges) + + constraints = acyclic <> infusible + + -- x_ij <= pi_j - pi_i <= n*x_ij for all fusible edges + acyclic = foldMap (\(i, j) -> P.Between + (P.z1 (Fused i j)) + (P.z1 (Pi j) P..-. P.z1 (Pi i)) + (P.z (Fused i j) (fromIntegral n))) fuseEdges + + -- pi_j - pi_i >= 1 for all infusible edges (i,j) + infusible = foldMap (\(i, j) -> (P.z1 (Pi j) P..-. P.z1 (Pi i)) P.:>= P.c1) nofuseEdges + + bounds = map (\i -> P.lowerUpperZ 0 (Pi i) (fromIntegral n)) + (S.toList nodes) + ++ map (\(i, j) -> P.binary (Fused i j)) + (S.toList fuseEdges) + + + -- call the solver, and interpret the result as a list (in order of execution) of clusters (sets of nodes). From 3f3ec505207da24e8b15e5de6feb4b6a1b83bc2d Mon Sep 17 00:00:00 2001 From: David Date: Tue, 26 Jan 2021 18:23:16 +0100 Subject: [PATCH 020/813] clean --- .../Array/Accelerate/Trafo/Clustering/ILP.hs | 78 +++++++++++-------- 1 file changed, 44 insertions(+), 34 deletions(-) diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs index 40dfa2ea8..5df80ca5d 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -4,20 +4,24 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} + module Data.Array.Accelerate.Trafo.Clustering.ILP where -import qualified Data.IntMap as M + import Data.Array.Accelerate.AST.Operation (Execute) import Data.Array.Accelerate.AST.Idx ( Idx ) import Data.Array.Accelerate.AST.Partitioned ( PreOpenAcc, Cluster ) import Data.Array.Accelerate.AST.LeftHandSide ( Exists ) +import qualified Data.IntMap as M +import Data.List (foldl') import Data.Kind ( Type ) -- In this file, order very often subly does matter. -- To keep this clear, we use S.Set whenever it does not, -- and [] only when it does. -import qualified Data.Set as S +import qualified Data.Set as S -- Limp is a Linear Integer Mixed Programming library. -- We only use the Integer part. It has a backend that @@ -25,13 +29,16 @@ import qualified Data.Set as S -- We can always switch to a different ILP library -- later, the interfaces are all quite similar import qualified Numeric.Limp.Program as P -import qualified Numeric.Limp.Rep.IntDouble as R -import Data.List (foldl') +import Numeric.Limp.Program hiding ( Constraint ) +import Numeric.Limp.Rep.Rep ( Assignment ) +import Numeric.Limp.Rep.IntDouble ( IntDouble ) + + --- the graph datatype, including fusible/infusible edges, .., +-- the graph datatype, including fusible/infusible edges, .., -- identifies nodes with unique Ints type Label = Int @@ -49,7 +56,7 @@ data Graph = Graph -- The graph is the 'common part' of the ILP, -- each backend has to encode their own constraints -- describing the fusion rules. -data Information op = Information Graph (Constraint op) (S.Set (P.Bounds (Variable op) () R.IntDouble)) +data Information op = Information Graph (Constraint op) (S.Set (Bounds (Variable op) () IntDouble)) class MakesILP op where @@ -57,8 +64,8 @@ class MakesILP op where type BackendVar op -- Control flow cannot be fused, so we make separate ILPs for e.g. - -- then-branch and else-branch. In the future, a possible optimisation is to - -- generate code for the awhile-condition twice: once maybe fused after the body, + -- then-branch and else-branch. In the future, a possible optimisation is to + -- generate code for the awhile-condition twice: once maybe fused after the body, -- once maybe fused after input. For now, condition and body are both treated -- as 'foreign calls', like if-then-else. -- The IntMap maps from a label to the corresponding ILP (only for things treated @@ -82,12 +89,12 @@ data Variable op -- We have integer variables, and no reals. -type ILP op = P.Program (Variable op) () R.IntDouble -type Constraint op = P.Constraint (Variable op) () R.IntDouble +type ILP op = Program (Variable op) () IntDouble +type Constraint op = P.Constraint (Variable op) () IntDouble -- Describes how, given a list of indices into 'env', we can reconstruct an 'Execute op env'. --- as the name suggests, this cannot be done 'safely': we're in the business of constructing +-- as the name suggests, this cannot be done 'safely': we're in the business of constructing -- a strongly typed AST from untyped ILP output. -- note that 'a list of indices' is akin to a weakening (that possibly reorders the env too) -- todo: not all Idxs need to have the same 'a', so `list` should be `hlist` or tuplist :) @@ -95,48 +102,51 @@ data UnsafeConstruction (op :: Type -> Type) = forall a. UnsafeConstruction (S.S makeILP :: Information op -> ILP op -makeILP (Information +makeILP (Information (Graph nodes fuseEdges nofuseEdges) backendconstraints backendbounds ) = combine graphILP where - combine (P.Program dir fun cons bnds) = - P.Program dir fun (cons <> backendconstraints) - (bnds <> S.toList backendbounds) - + combine (Program dir fun cons bnds) = + Program dir fun (cons <> backendconstraints) + (bnds <> S.toList backendbounds) + n = S.size nodes - -- __ | don't know why the objFun has to be - -- / | 'real', everything else is integral - -- v - graphILP = P.Program P.Minimise (P.toR objFun) constraints bounds + -- __ | don't know why the objFun has to be + -- / | 'real', everything else is integral + -- v + graphILP = Program Minimise (toR objFun) constraints bounds - -- placeholder, currently maximising the number of vertical/diagonal fusions. - objFun = foldl' (\f (i, j) -> f P..+. P.z1 (Fused i j)) P.c0 (S.toList fuseEdges) + -- placeholder, currently maximising the number of vertical/diagonal fusions. + objFun = foldl' (\f (i, j) -> f .+. z1 (Fused i j)) c0 (S.toList fuseEdges) constraints = acyclic <> infusible -- x_ij <= pi_j - pi_i <= n*x_ij for all fusible edges - acyclic = foldMap (\(i, j) -> P.Between - (P.z1 (Fused i j)) - (P.z1 (Pi j) P..-. P.z1 (Pi i)) - (P.z (Fused i j) (fromIntegral n))) fuseEdges + acyclic = foldMap + (\(i, j) -> Between + ( z1 (Fused i j) ) + ( z1 (Pi j) .-. z1 (Pi i) ) + ( z (Fused i j) (fromIntegral n) )) + fuseEdges -- pi_j - pi_i >= 1 for all infusible edges (i,j) - infusible = foldMap (\(i, j) -> (P.z1 (Pi j) P..-. P.z1 (Pi i)) P.:>= P.c1) nofuseEdges + infusible = foldMap (\(i, j) -> (z1 (Pi j) .-. z1 (Pi i)) :>= c1) + nofuseEdges - bounds = map (\i -> P.lowerUpperZ 0 (Pi i) (fromIntegral n)) + -- 0 <= pi_i <= n + bounds = map (\i -> lowerUpperZ 0 (Pi i) (fromIntegral n)) (S.toList nodes) - ++ map (\(i, j) -> P.binary (Fused i j)) + <> -- x_ij \in {0, 1} + map (\(i, j) -> binary (Fused i j)) (S.toList fuseEdges) - - --- call the solver, and interpret the result as a list (in order of execution) of clusters (sets of nodes). --- gets called for each ILP -solveILP :: ILP op -> [S.Set Int] + +-- call the solver. Gets called for each ILP +solveILP :: ILP op -> Assignment (Variable op) () IntDouble solveILP = undefined From c7210bc6f39d03c3b80d64ea5cc3c981489aac8c Mon Sep 17 00:00:00 2001 From: David Date: Wed, 27 Jan 2021 13:46:00 +0100 Subject: [PATCH 021/813] sorry I broke substitution - but I think this is clean --- src/Data/Array/Accelerate/AST/Operation.hs | 70 ++++++++-------- src/Data/Array/Accelerate/AST/Partitioned.hs | 80 +++++-------------- .../Array/Accelerate/Trafo/Clustering/ILP.hs | 26 +++--- .../Array/Accelerate/Trafo/NewNewFusion.hs | 4 +- 4 files changed, 70 insertions(+), 110 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index 9591e8ef9..52e71eb9d 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -23,7 +23,7 @@ module Data.Array.Accelerate.AST.Operation ( PreOpenAcc(..), PreOpenAfun(..), - OperationAcc, OperationAfun, Execute(..), + OperationAcc, OperationAfun, Uniqueness(..), Uniquenesses, shared, GroundR(..), GroundsR, GroundVar, GroundVars, GLeftHandSide, Var(..), Vars, @@ -44,7 +44,6 @@ module Data.Array.Accelerate.AST.Operation ( paramIn, paramsIn, paramIn', paramsIn', - IsExecutableAcc(..), ReindexPartial, reindexArg, reindexArgs, reindexExp, reindexVar, reindexVars, weakenReindex, argVars, argsVars, AccessGroundR(..), @@ -71,6 +70,7 @@ import Data.Typeable ( (:~:)(..) ) import Data.ByteString.Builder.Extra import Language.Haskell.TH ( Q, TExp ) +import Data.Kind (Type) -- | An intermediate representation parameterized over executable operations. -- This data type only consists of the control flow structure and @@ -89,23 +89,25 @@ import Language.Haskell.TH ( Q, TExp ) -- consisting of ground values typed by 'GroundR', and the return type, which -- is a tuple of ground values, typed by 'GroundsR'. -- -data PreOpenAcc exe env a where +data PreOpenAcc (op :: Type -> Type) env a where -- | Executes an executable operation. Such execution does not return a -- value, the effects of the execution are only visible by the mutation of -- buffers which were annotated with either 'Mut' or 'Out'. + -- Provides the operation arguments from the environment. -- - Exec :: exe env - -> PreOpenAcc exe env () + Exec :: op args + -> Args env args + -> PreOpenAcc op env () -- | Returns the values of the given variables. -- Return :: GroundVars env a - -> PreOpenAcc exe env a + -> PreOpenAcc op env a -- | Evaluates the expression and returns its value. -- Compute :: Exp env t - -> PreOpenAcc exe env t + -> PreOpenAcc op env t -- | Local binding of ground values. -- As it is common in this intermediate representation to evaluate some program @@ -113,16 +115,16 @@ data PreOpenAcc exe env a where -- and then do some other code, we write 'a; b' to denote 'let () = a in b'. Alet :: GLeftHandSide bnd env env' -> Uniquenesses bnd - -> PreOpenAcc exe env bnd - -> PreOpenAcc exe env' t - -> PreOpenAcc exe env t + -> PreOpenAcc op env bnd + -> PreOpenAcc op env' t + -> PreOpenAcc op env t -- | Allocates a new buffer of the given size. -- Alloc :: ShapeR sh -> ScalarType e -> ExpVars env sh - -> PreOpenAcc exe env (Buffer e) + -> PreOpenAcc op env (Buffer e) -- | Buffer inlet. To pass an array constant in this data type, one may need -- multiple 'Use' constructs because of the explicit Structure-of-Arrays. @@ -130,29 +132,29 @@ data PreOpenAcc exe env a where -- Use :: ScalarType e -> Buffer e - -> PreOpenAcc exe env (Buffer e) + -> PreOpenAcc op env (Buffer e) -- | Capture a scalar in a singleton buffer -- Unit :: ExpVar env e - -> PreOpenAcc exe env (Buffer e) + -> PreOpenAcc op env (Buffer e) -- | If-then-else for array-level computations -- Acond :: ExpVar env PrimBool - -> PreOpenAcc exe env a - -> PreOpenAcc exe env a - -> PreOpenAcc exe env a + -> PreOpenAcc op env a + -> PreOpenAcc op env a + -> PreOpenAcc op env a -- Value-recursion for array-level computations -- The uniqueness guarantees are an invariant of the loop -- and should hold before and after each iteration. -- Awhile :: Uniquenesses a - -> PreOpenAfun exe env (a -> PrimBool) - -> PreOpenAfun exe env (a -> a) + -> PreOpenAfun op env (a -> PrimBool) + -> PreOpenAfun op env (a -> a) -> GroundVars env a - -> PreOpenAcc exe env a + -> PreOpenAcc op env a -- | Function abstraction over parametrised array computations -- @@ -245,29 +247,23 @@ argVarType (ArgVar vars) = varsType vars argArrayR :: Arg env (m sh e) -> ArrayR (Array sh e) argArrayR (ArgArray _ repr _ _) = repr --- | Executes a single operation. Provides the operation arguments --- from the environment. --- -data Execute op env where - Execute :: op args -> Args env args -> Execute op env - -- | An intermediate representation consisting of operations. This data type -- only consists of the control flow structure and bookkeeping (allocating or -- copying buffers). It is parameterized over the actual type of operations. -- -type OperationAcc op = PreOpenAcc (Execute op) +type OperationAcc op = PreOpenAcc op -- | Functions on an intermediate representation consisting of operations. -- This data type only consists of the control flow structure and bookkeeping (allocating or -- copying buffers). It is parameterized over the actual type of operations. -- -type OperationAfun op = PreOpenAfun (Execute op) +type OperationAfun op = PreOpenAfun op class HasGroundsR f where groundsR :: f a -> GroundsR a instance HasGroundsR (PreOpenAcc exe env) where - groundsR (Exec _) = TupRunit + groundsR (Exec _ _) = TupRunit groundsR (Return vars) = groundsR vars groundsR (Compute e) = groundsR e groundsR (Alet _ _ _ a) = groundsR a @@ -413,13 +409,13 @@ reindexArgs k (a :>: as) = (:>:) <$> reindexArg k a <*> reindexArgs k as weakenReindex :: benv :> benv' -> ReindexPartial Identity benv benv' weakenReindex k = Identity . (k >:>) -class IsExecutableAcc exe where - reindexExecPartial :: Applicative f => ReindexPartial f env env' -> exe env -> f (exe env') - execVars :: exe env -> [Exists (Var AccessGroundR env)] +-- class IsExecutableAcc exe where +-- reindexExecPartial :: Applicative f => ReindexPartial f env env' -> exe env -> f (exe env') +-- execVars :: exe env -> [Exists (Var AccessGroundR env)] -instance IsExecutableAcc (Execute op) where - reindexExecPartial k (Execute op args) = Execute op <$> reindexArgs k args - execVars (Execute _ args) = argsVars args +-- instance IsExecutableAcc (Execute op) where +-- reindexExecPartial k (Execute op args) = Execute op <$> reindexArgs k args +-- execVars (Execute _ args) = argsVars args data AccessGroundR tp where AccessGroundRscalar :: ScalarType tp -> AccessGroundR tp @@ -463,9 +459,9 @@ flattenTupR = (`go` []) go (TupRpair t1 t2) accum = go t1 $ go t2 accum go TupRunit accum = accum -mapAccExecutable :: (forall benv'. exe benv' -> exe' benv') -> PreOpenAcc exe benv t -> PreOpenAcc exe' benv t +mapAccExecutable :: (forall args. op args -> op' args) -> PreOpenAcc op benv t -> PreOpenAcc op' benv t mapAccExecutable f = \case - Exec exe -> Exec $ f exe + Exec op args -> Exec (f op) args Return vars -> Return vars Compute e -> Compute e Alet lhs uniqueness bnd body -> Alet lhs uniqueness (mapAccExecutable f bnd) (mapAccExecutable f body) @@ -475,7 +471,7 @@ mapAccExecutable f = \case Acond var a1 a2 -> Acond var (mapAccExecutable f a1) (mapAccExecutable f a2) Awhile uniqueness c g a -> Awhile uniqueness (mapAfunExecutable f c) (mapAfunExecutable f g) a -mapAfunExecutable :: (forall benv'. exe benv' -> exe' benv') -> PreOpenAfun exe benv t -> PreOpenAfun exe' benv t +mapAfunExecutable :: (forall args. op args -> op' args) -> PreOpenAfun op benv t -> PreOpenAfun op' benv t mapAfunExecutable f (Abody a) = Abody $ mapAccExecutable f a mapAfunExecutable f (Alam lhs a) = Alam lhs $ mapAfunExecutable f a diff --git a/src/Data/Array/Accelerate/AST/Partitioned.hs b/src/Data/Array/Accelerate/AST/Partitioned.hs index c8cf30ce4..7a5f8f8d1 100644 --- a/src/Data/Array/Accelerate/AST/Partitioned.hs +++ b/src/Data/Array/Accelerate/AST/Partitioned.hs @@ -22,85 +22,45 @@ -- module Data.Array.Accelerate.AST.Partitioned ( module Data.Array.Accelerate.AST.Operation - , Cluster(..) - , PartitionedAcc - , PartitionedAfun + , Cluster(..), Combine(..), SwapArgs(..) + , PartitionedAcc, PartitionedAfun ) where -import Data.Array.Accelerate.AST.Operation hiding ( OperationAcc, Execute(..) ) +import Data.Array.Accelerate.AST.Operation --- `Cluster` replaces `Execute` during the fusion pass: --- PreOpenAcc (Execute op) --- -> PreOpenAcc (Cluster op) +data Cluster op args where + Leaf :: op args -> Cluster op args --- As a refresh, `Execute` is currently defined as: --- data Execute op env where --- Execute :: op args -> Args env args -> Execute op env - -data Cluster op env where - Root :: ClusterTree op args -> Args env args -> Cluster op env - -instance IsExecutableAcc (Cluster op) where - reindexExecPartial k (Root op args) = Root op <$> reindexArgs k args - execVars (Root _ args) = argsVars args - - -- Could even abstract one more step (will do once we settle on ClusterTree) - - -- data Foo f (op :: Type -> Type) env where - -- Foo :: f op args -> Args env args -> Foo f op env - - -- data Identity a b = Identity (a b) - -- data Bar a b = Bar Int (a b) - - -- type Execute' = Foo Identity - -- type LabelledExecute = Foo Bar -- as input to the ILP, give each Execute a unique (Int) label. - -- type Cluster' = Foo ClusterTree - - -- instance IsExecutableAcc (Foo f op) where - -- reindexExecPartial k (Foo fop args) = Foo fop <$> reindexArgs k args - -- execVars (Foo _ args) = argsVars args - - - - -data ClusterTree op args where - Leaf :: op args -> ClusterTree op args - - Node :: ClusterTree op a - -> ClusterTree op b - -> Combine a b c - -> ClusterTree op c + Node :: Cluster op a + -> Cluster op b + -> Combine a b c + -> Cluster op c Reorder :: SwapArgs args args' - -> ClusterTree op args - -> ClusterTree op args' + -> Cluster op args + -> Cluster op args' -- Note that, in general, these combination descriptors can definitely represent -- undesirable states: It's probably not doable to encode all fusability rules -- in the types (especially while abstracting over backends), instead we will need -- to call `error "impossible fusion"` in the backends at some points (particularly codegen). --- maybe should inline the three options? -data Combine a b c = CVertical (Vertical a b c) - | CHorizontal (Horizontal a b c) - | CDiagonal (Diagonal a b c) --- Proof that `first` can fuse before `second`, giving result type `total`. -data Vertical first second total where +data Combine a b c where -- An array is produced and consumed, fusing it away. -- NOTE: this means that the array does not appear in the environment, and -- it does not have an accompanying `Arg` constructor: Its scope is now -- bound by this `Vertical` constructor. - Vertical :: Vertical (Out sh e -> a) (In sh e -> a) a - -data Horizontal left right total where + Vertical :: Combine (Out sh e -> a) (In sh e -> a) a + + -- Like vertical, but the `Array sh e` is stored for later use + Diagonal :: Combine (Out sh e -> a) (In sh e -> a) (Out sh e -> a) + -- Both outputs are stored. We purposely don't require sh1 == sh2, but the rest of the types -- need to align, so this is why we need weakening. - Horizontal :: Horizontal (Out sh1 e1 -> a) (Out sh2 e2 -> a) (Out sh1 e1 -> Out sh2 e2 -> a) - -data Diagonal first second total where - -- Like vertical, but the `Array sh e` is stored for later use - Diagonal :: Diagonal (Out sh e -> a) (In sh e -> a) (Out sh e -> a) + -- TODO: perhaps this type is too strict, and we'll want to horizontally fuse two clusters + -- with multiple out-variables. + Horizontal :: Combine (Out sh1 e1 -> a) (Out sh2 e2 -> a) (Out sh1 e1 -> Out sh2 e2 -> a) type PartitionedAcc op = PreOpenAcc (Cluster op) diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs index 5df80ca5d..57d02ac33 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -8,9 +8,9 @@ module Data.Array.Accelerate.Trafo.Clustering.ILP where -import Data.Array.Accelerate.AST.Operation (Execute) +import Data.Array.Accelerate.AST.Operation import Data.Array.Accelerate.AST.Idx ( Idx ) -import Data.Array.Accelerate.AST.Partitioned ( PreOpenAcc, Cluster ) +import Data.Array.Accelerate.AST.Partitioned ( Cluster ) import Data.Array.Accelerate.AST.LeftHandSide ( Exists ) import qualified Data.IntMap as M @@ -34,15 +34,18 @@ import Numeric.Limp.Rep.Rep ( Assignment ) import Numeric.Limp.Rep.IntDouble ( IntDouble ) +-- before we do the ILP pass, we label each 'Exec' node +data LabelledOp op args = LabelledOp Int (op args) - +labelAcc :: PreOpenAcc op env a -> PreOpenAcc (LabelledOp op) env a +labelAcc = undefined -- the graph datatype, including fusible/infusible edges, .., -- identifies nodes with unique Ints type Label = Int --- | Directed edge (a,b): `a` must be computed [possibly strictly] before `b`. +-- | Directed edge (a,b): `b` depends on `a`. type Edge = (Label, Label) -- TODO: at some point, set fusibleEdges := fusibleEdges \\ infusibleEdges. Makes ILP smaller. @@ -75,11 +78,10 @@ class MakesILP op where -- to solve them separately. This avoids many 'infusible edges', and significantly reduces the search space. The extracted -- subtree gets encoded as a sort of 'foreign call', preventing all fusion. -- todo: maybe we can extract more commonality from this, making the class more complicated but instances smaller/easier - mkGraph :: PreOpenAcc (Execute op) () a-> (Information op, M.IntMap (Information op)) + mkGraph :: PreOpenAcc (LabelledOp op) () a-> (Information op, M.IntMap (Information op)) - -- for efficient reconstruction - important that the numbers match the numbers in mkGraph. Can fuse the two to ensure, - -- or do a separate 'labelling' pass first (:: Execute op -> LabelledExe op). - mkMap :: PreOpenAcc (Execute op) () a -> M.IntMap (UnsafeConstruction op) + -- for efficient reconstruction + mkMap :: PreOpenAcc (LabelledOp op) () a -> M.IntMap (UnsafeConstruction op) data Variable op @@ -98,7 +100,8 @@ type Constraint op = P.Constraint (Variable op) () IntDouble -- a strongly typed AST from untyped ILP output. -- note that 'a list of indices' is akin to a weakening (that possibly reorders the env too) -- todo: not all Idxs need to have the same 'a', so `list` should be `hlist` or tuplist :) -data UnsafeConstruction (op :: Type -> Type) = forall a. UnsafeConstruction (S.Set Int) (forall env. [Idx a env] -> Execute op env) +-- todo: figure out how this works with 'args' +data UnsafeConstruction (op :: Type -> Type) = forall a. UnsafeConstruction (S.Set Int) (forall args. [Idx a args] -> op args) makeILP :: Information op -> ILP op @@ -113,8 +116,9 @@ makeILP (Information (bnds <> S.toList backendbounds) n = S.size nodes - -- __ | don't know why the objFun has to be - -- / | 'real', everything else is integral + -- __ | don't know why the objFun has to be + -- / | 'real', everything else is integral + -- | | hope this doesn't slow the solving -- v graphILP = Program Minimise (toR objFun) constraints bounds diff --git a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs index 76e4d4d1a..1a9b79ccc 100644 --- a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs +++ b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs @@ -78,5 +78,5 @@ withSimplStats x = unsafePerformIO Stats.resetSimplCount `seq` x withSimplStats x = x #endif -dontFuse :: Execute op benv -> Cluster op benv -dontFuse = undefined \ No newline at end of file +dontFuse :: op args -> Cluster op args +dontFuse = Leaf \ No newline at end of file From 875d96a7d604b787c226ce8608f7ffa0e186f056 Mon Sep 17 00:00:00 2001 From: David Date: Thu, 28 Jan 2021 20:53:33 +0100 Subject: [PATCH 022/813] progress of the day --- src/Data/Array/Accelerate/AST/Operation.hs | 2 +- .../Array/Accelerate/Trafo/Clustering/ILP.hs | 121 +++++++++++++++--- 2 files changed, 105 insertions(+), 18 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index 52e71eb9d..8240df135 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -153,7 +153,7 @@ data PreOpenAcc (op :: Type -> Type) env a where Awhile :: Uniquenesses a -> PreOpenAfun op env (a -> PrimBool) -> PreOpenAfun op env (a -> a) - -> GroundVars env a + -> GroundVars env a -> PreOpenAcc op env a -- | Function abstraction over parametrised array computations diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs index 57d02ac33..de3d6be94 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE ViewPatterns #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE GADTs #-} @@ -9,9 +10,9 @@ module Data.Array.Accelerate.Trafo.Clustering.ILP where import Data.Array.Accelerate.AST.Operation -import Data.Array.Accelerate.AST.Idx ( Idx ) +import Data.Array.Accelerate.AST.Idx import Data.Array.Accelerate.AST.Partitioned ( Cluster ) -import Data.Array.Accelerate.AST.LeftHandSide ( Exists ) +import Data.Array.Accelerate.AST.LeftHandSide import qualified Data.IntMap as M import Data.List (foldl') @@ -32,10 +33,16 @@ import qualified Numeric.Limp.Program as P import Numeric.Limp.Program hiding ( Constraint ) import Numeric.Limp.Rep.Rep ( Assignment ) import Numeric.Limp.Rep.IntDouble ( IntDouble ) +import Data.Array.Accelerate.Representation.Type -- before we do the ILP pass, we label each 'Exec' node -data LabelledOp op args = LabelledOp Int (op args) +data LabelledOp op args = LabelledOp Label (op args) +-- with the Operation-base acc, that might not be enough.. +-- kind of need to label each array, so each Use/Unit too? +-- Don't need to label Allocs, we only care about the dependencies. +-- so.. probably need to back the recursive knot into the Operation +-- ast too, so we can label everything? labelAcc :: PreOpenAcc op env a -> PreOpenAcc (LabelledOp op) env a labelAcc = undefined @@ -54,13 +61,56 @@ data Graph = Graph , fusibleEdges :: S.Set Edge -- Can be fused over, otherwise `a` before `b`. , infusibleEdges :: S.Set Edge -- Can't be fused over, always `a` before `b`. } - +instance Semigroup Graph where + Graph n f i <> Graph n' f' i' = Graph (n <> n') (f <> f') (i <> i') +instance Monoid Graph where + mempty = Graph mempty mempty mempty -- The graph is the 'common part' of the ILP, -- each backend has to encode their own constraints -- describing the fusion rules. -data Information op = Information Graph (Constraint op) (S.Set (Bounds (Variable op) () IntDouble)) +data Information op = Information Graph (Constraint op) [ Bounds (Variable op) () IntDouble ] +instance Semigroup (Information op) where + Information g c b <> Information g' c' b' = Information (g <> g') (c <> c') (b <> b') +instance Monoid (Information op) where + mempty = Information mempty mempty mempty + +-- | Keeps track of which argument belongs to which labels +data LabelArgs args where + LabelArgsNil :: LabelArgs () + (:>>:) :: S.Set Label -> LabelArgs t -> LabelArgs (s -> t) + +-- | Keeps track of which array in the environment belongs to which label +data LabelEnv env where + LabelEnvNil :: LabelEnv () + (:>>>:) :: S.Set Label -> LabelEnv t -> LabelEnv (t, s) + +addLhsLabels :: LeftHandSide s v env env' -> S.Set Label -> LabelEnv env -> LabelEnv env' +addLhsLabels LeftHandSideWildcard{} _ lenv = lenv +addLhsLabels LeftHandSideSingle{} l lenv = l :>>>: lenv +addLhsLabels (LeftHandSidePair x y) l lenv = addLhsLabels y l (addLhsLabels x l lenv) + +mkLabelArgs :: Args env args -> LabelEnv env -> LabelArgs args +mkLabelArgs ArgsNil _ = LabelArgsNil +mkLabelArgs (arg :>: args) e = getLabelsArg arg e :>>: mkLabelArgs args e + where + getLabelsArg :: Arg env t -> LabelEnv env -> S.Set Label + getLabelsArg (ArgVar tup) env = getLabelsTup tup env + getLabelsArg (ArgExp x) env = undefined -- call function that I still have to write + getLabelsArg (ArgFun fun) env = undefined -- call function that I still have to write + getLabelsArg (ArgArray _ _ shVars bufVars) env = getLabelsTup shVars env `S.union` getLabelsTup bufVars env + +getLabelsTup :: TupR (Var a env) b -> LabelEnv env -> S.Set Label +getLabelsTup TupRunit _ = S.empty +getLabelsTup (TupRsingle var) env = getLabelsVar var env +getLabelsTup (TupRpair x y) env = getLabelsTup x env `S.union` getLabelsTup y env +getLabelsVar :: Var s env t -> LabelEnv env -> S.Set Label +getLabelsVar (varIdx -> idx) lenv = getLabelsIdx idx lenv + +getLabelsIdx :: Idx env a -> LabelEnv env -> S.Set Label +getLabelsIdx ZeroIdx (i :>>>: _) = i +getLabelsIdx (SuccIdx idx) (_ :>>>: env) = getLabelsIdx idx env class MakesILP op where -- Variables needed to express backend-specific fusion rules. @@ -78,12 +128,47 @@ class MakesILP op where -- to solve them separately. This avoids many 'infusible edges', and significantly reduces the search space. The extracted -- subtree gets encoded as a sort of 'foreign call', preventing all fusion. -- todo: maybe we can extract more commonality from this, making the class more complicated but instances smaller/easier - mkGraph :: PreOpenAcc (LabelledOp op) () a-> (Information op, M.IntMap (Information op)) + mkGraph :: op args -> LabelArgs args -> Label -> Information op -- for efficient reconstruction mkMap :: PreOpenAcc (LabelledOp op) () a -> M.IntMap (UnsafeConstruction op) +-- TODO doublecheck much of this, it's tricky: +-- in the Operation-based AST, everything is powered by side effects. +-- this makes a full-program analysis like this much more difficult, +-- luckily the Args give us all the information we really require. +-- For each node, we get the set of incoming edges and the set +-- of outgoing edges. Let-bindings are easy, but the array-level +-- control flow (acond and awhile) compensate: their bodies form separate +-- graphs. +mkFullGraph :: MakesILP op + => PreOpenAcc (LabelledOp op) aenv a + -> LabelEnv aenv + -> ( S.Set Label -- ingoing edges + , S.Set Label -- outgoing edges + , Information op, M.IntMap (Information op) ) +mkFullGraph (Exec (LabelledOp l op) args) lenv = undefined + +mkFullGraph _ _ = undefined +-- mkFullGraph (Return groundvars) _ = undefined -- what is this? does this do anything? +-- mkFullGraph (Compute expr) _ = undefined -- how is this even typecorrect? What does it mean? +-- mkFullGraph (Exec (LabelledOp l op) args) lenv = ( S.singleton l, mkGraph op (mkLabelArgs args lenv) l, M.empty ) +-- mkFullGraph (Alet lhs u bnd scp) lenv = +-- let (label1, info1, infomap1) = mkFullGraph bnd lenv +-- (label2, info2, infomap2) = mkFullGraph scp (addLhsLabels lhs label1 lenv) +-- in ( label2 +-- , info1 <> info2 +-- -- If we encounter any duplicate keys here, that's a bad sign +-- , M.unionWith (error "oops") infomap1 infomap2 ) +-- mkFullGraph (Alloc shr sct expv) lenv = ( getLabelsTup expv lenv, mempty, mempty ) +-- mkFullGraph (Use sct buf) lenv = ( mempty, mempty, mempty ) +-- mkFullGraph (Unit evar) lenv = ( getLabelsVar evar lenv, mempty, mempty ) + +-- -- now these are problematic: should we duplicate the informations and put them in the map with all the labels? +-- mkFullGraph (Acond c t e) lenv = undefined -- ifthenelse +-- mkFullGraph (Awhile us c b s) lenv = undefined -- while + data Variable op = Pi Label -- For acyclic ordering of clusters | Fused Label Label -- 0 is fused (same cluster), 1 is unfused. We do *not* have one of these for all pairs! @@ -105,24 +190,26 @@ data UnsafeConstruction (op :: Type -> Type) = forall a. UnsafeConstruction (S.S makeILP :: Information op -> ILP op -makeILP (Information - (Graph nodes fuseEdges nofuseEdges) - backendconstraints - backendbounds - ) = combine graphILP +makeILP (Information + (Graph nodes fuseEdges nofuseEdges) + backendconstraints + backendbounds + ) = combine graphILP where combine (Program dir fun cons bnds) = Program dir fun (cons <> backendconstraints) - (bnds <> S.toList backendbounds) + (bnds <> backendbounds) n = S.size nodes - -- __ | don't know why the objFun has to be - -- / | 'real', everything else is integral - -- | | hope this doesn't slow the solving - -- v + -- _____________________________________ + -- | Don't know why the objFun has to be | + -- ___ | real, everything else is integral. | + -- | | Hope this doesn't slow the solver. | + -- v ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾ graphILP = Program Minimise (toR objFun) constraints bounds - -- placeholder, currently maximising the number of vertical/diagonal fusions. + -- Placeholder, currently maximising the number of vertical/diagonal fusions. + -- In the future, maybe we want this to be backend-dependent. objFun = foldl' (\f (i, j) -> f .+. z1 (Fused i j)) c0 (S.toList fuseEdges) constraints = acyclic <> infusible From ec1f4b7880e986410ab39ab4dd103e1212644919 Mon Sep 17 00:00:00 2001 From: David Date: Tue, 2 Feb 2021 16:38:08 +0100 Subject: [PATCH 023/813] I think this ILP thing is getting somewhere? --- .../Array/Accelerate/AST/Schedule/Uniform.hs | 3 +- .../Array/Accelerate/Trafo/Clustering/ILP.hs | 202 ++++++++++++++---- .../Trafo/Operation/Substitution.hs | 18 +- .../Accelerate/Trafo/Schedule/Uniform.hs | 8 +- 4 files changed, 176 insertions(+), 55 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs b/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs index 3e84977a9..be4880665 100644 --- a/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs +++ b/src/Data/Array/Accelerate/AST/Schedule/Uniform.hs @@ -123,7 +123,8 @@ data Binding env t where -- Effects do not have a return value. data Effect exe env where - Exec :: exe env + Exec :: exe args + -> Args env args -> Effect exe env SignalAwait :: [Idx env Signal] -> Effect exe env diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs index de3d6be94..028974696 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -1,3 +1,5 @@ +{-# LANGUAGE EmptyCase #-} +{-# LANGUAGE TupleSections #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE TypeFamilies #-} @@ -21,31 +23,35 @@ import Data.Kind ( Type ) -- In this file, order very often subly does matter. -- To keep this clear, we use S.Set whenever it does not, --- and [] only when it does. +-- and [] only when it does. It's also often efficient +-- by removing duplicates. import qualified Data.Set as S -- Limp is a Linear Integer Mixed Programming library. --- We only use the Integer part. It has a backend that --- binds to CBC, which is apparently a good one? +-- We only use the Integer part (not the Mixed part, +-- which allows you to add non-integer variables and +-- constraints). It has a backend that binds to CBC, +-- which is apparently a good one? Does not seem to be +-- actively maintained though. -- We can always switch to a different ILP library --- later, the interfaces are all quite similar +-- later, the interfaces are all quite similar. import qualified Numeric.Limp.Program as P -import Numeric.Limp.Program hiding ( Constraint ) +import Numeric.Limp.Program hiding ( Constraint, r ) import Numeric.Limp.Rep.Rep ( Assignment ) import Numeric.Limp.Rep.IntDouble ( IntDouble ) import Data.Array.Accelerate.Representation.Type --- before we do the ILP pass, we label each 'Exec' node -data LabelledOp op args = LabelledOp Label (op args) --- with the Operation-base acc, that might not be enough.. --- kind of need to label each array, so each Use/Unit too? --- Don't need to label Allocs, we only care about the dependencies. --- so.. probably need to back the recursive knot into the Operation --- ast too, so we can label everything? +-- -- before we do the ILP pass, we label each 'Exec' node +-- data LabelledOp op args = LabelledOp Label (op args) +-- -- with the Operation-base acc, that might not be enough.. +-- -- kind of need to label each array, so each Use/Unit too? +-- -- Don't need to label Allocs, we only care about the dependencies. +-- -- so.. probably need to back the recursive knot into the Operation +-- -- ast too, so we can label everything? -labelAcc :: PreOpenAcc op env a -> PreOpenAcc (LabelledOp op) env a -labelAcc = undefined +-- labelAcc :: PreOpenAcc op env a -> PreOpenAcc (LabelledOp op) env a +-- labelAcc = undefined -- the graph datatype, including fusible/infusible edges, .., @@ -68,12 +74,13 @@ instance Monoid Graph where -- The graph is the 'common part' of the ILP, -- each backend has to encode their own constraints --- describing the fusion rules. -data Information op = Information Graph (Constraint op) [ Bounds (Variable op) () IntDouble ] +-- describing the fusion rules. The bounds is a [] instead of S.Set +-- for practical reasons (no Ord instance, LIMP expects a list) only. +data Information op = Info Graph (Constraint op) [ Bounds (Variable op) () IntDouble ] instance Semigroup (Information op) where - Information g c b <> Information g' c' b' = Information (g <> g') (c <> c') (b <> b') + Info g c b <> Info g' c' b' = Info (g <> g') (c <> c') (b <> b') instance Monoid (Information op) where - mempty = Information mempty mempty mempty + mempty = Info mempty mempty mempty -- | Keeps track of which argument belongs to which labels data LabelArgs args where @@ -90,20 +97,33 @@ addLhsLabels LeftHandSideWildcard{} _ lenv = lenv addLhsLabels LeftHandSideSingle{} l lenv = l :>>>: lenv addLhsLabels (LeftHandSidePair x y) l lenv = addLhsLabels y l (addLhsLabels x l lenv) -mkLabelArgs :: Args env args -> LabelEnv env -> LabelArgs args -mkLabelArgs ArgsNil _ = LabelArgsNil -mkLabelArgs (arg :>: args) e = getLabelsArg arg e :>>: mkLabelArgs args e - where - getLabelsArg :: Arg env t -> LabelEnv env -> S.Set Label - getLabelsArg (ArgVar tup) env = getLabelsTup tup env - getLabelsArg (ArgExp x) env = undefined -- call function that I still have to write - getLabelsArg (ArgFun fun) env = undefined -- call function that I still have to write - getLabelsArg (ArgArray _ _ shVars bufVars) env = getLabelsTup shVars env `S.union` getLabelsTup bufVars env +weakLhsEnv :: LeftHandSide s v env env' -> LabelEnv env' -> LabelEnv env +weakLhsEnv LeftHandSideSingle{} (_:>>>: env) = env +weakLhsEnv LeftHandSideWildcard{} env = env +weakLhsEnv (LeftHandSidePair l r) env = weakLhsEnv l (weakLhsEnv r env) + +emptyLabelEnv :: LabelEnv env -> LabelEnv env +emptyLabelEnv LabelEnvNil = LabelEnvNil +emptyLabelEnv (_:>>>:env) = mempty :>>>: emptyLabelEnv env + +getAllLabelsEnv :: LabelEnv env -> S.Set Label +getAllLabelsEnv LabelEnvNil = mempty +getAllLabelsEnv (set :>>>: lenv) = set <> getAllLabelsEnv lenv + +getLabelArgs :: Args env args -> LabelEnv env -> LabelArgs args +getLabelArgs ArgsNil _ = LabelArgsNil +getLabelArgs (arg :>: args) e = getLabelsArg arg e :>>: getLabelArgs args e + +getLabelsArg :: Arg env t -> LabelEnv env -> S.Set Label +getLabelsArg (ArgVar tup) env = getLabelsTup tup env +getLabelsArg (ArgExp expr) env = getLabelsExp expr env +getLabelsArg (ArgFun fun) env = getLabelsFun fun env +getLabelsArg (ArgArray _ _ shVars bufVars) env = getLabelsTup shVars env <> getLabelsTup bufVars env getLabelsTup :: TupR (Var a env) b -> LabelEnv env -> S.Set Label -getLabelsTup TupRunit _ = S.empty +getLabelsTup TupRunit _ = mempty getLabelsTup (TupRsingle var) env = getLabelsVar var env -getLabelsTup (TupRpair x y) env = getLabelsTup x env `S.union` getLabelsTup y env +getLabelsTup (TupRpair x y) env = getLabelsTup x env <> getLabelsTup y env getLabelsVar :: Var s env t -> LabelEnv env -> S.Set Label getLabelsVar (varIdx -> idx) lenv = getLabelsIdx idx lenv @@ -112,6 +132,36 @@ getLabelsIdx :: Idx env a -> LabelEnv env -> S.Set Label getLabelsIdx ZeroIdx (i :>>>: _) = i getLabelsIdx (SuccIdx idx) (_ :>>>: env) = getLabelsIdx idx env +getLabelsExp :: OpenExp x env y -> LabelEnv env -> S.Set Label +getLabelsExp = undefined -- TODO traverse everything, look for Idxs + +getLabelsFun :: OpenFun x env y -> LabelEnv env -> S.Set Label +getLabelsFun (Body expr) lenv = getLabelsExp expr lenv +getLabelsFun (Lam _ fun) lenv = getLabelsFun fun lenv + +updateLabelEnv :: Args env args -> LabelEnv env -> Label -> LabelEnv env +updateLabelEnv ArgsNil lenv _ = lenv +updateLabelEnv (arg :>: args) lenv l = case arg of + -- CHECK we only look at the 'Buffer' vars here, not the 'shape' ones. Is that ok? + ArgArray Out _ _ vars -> updateLabelEnv args (insertAtVars vars lenv l) l + ArgArray Mut _ _ vars -> updateLabelEnv args (insertAtVars vars lenv l) l + _ -> updateLabelEnv args lenv l + +insertAtVars :: TupR (Var a env) b -> LabelEnv env -> Label -> LabelEnv env +insertAtVars TupRunit lenv _ = lenv +insertAtVars (TupRpair x y) lenv l = insertAtVars x (insertAtVars y lenv l) l +insertAtVars (TupRsingle (varIdx -> idx)) (lset :>>>: lenv) l = case idx of + ZeroIdx -> (S.insert l lset) :>>>: lenv + SuccIdx idx' -> lset :>>>: insertAtVars (TupRsingle (Var undefined idx')) lenv l +insertAtVars (TupRsingle (varIdx -> idx)) LabelEnvNil _ = case idx of {} + +-- | Like `getLabelArgs`, but ignores the `Out` arguments +getInputArgLabels :: Args env args -> LabelEnv env -> S.Set Label +getInputArgLabels ArgsNil _ = mempty +getInputArgLabels (arg :>: args) lenv = getInputArgLabels args lenv <> case arg of + ArgArray Out _ _ _ -> mempty + _ -> getLabelsArg arg lenv + class MakesILP op where -- Variables needed to express backend-specific fusion rules. type BackendVar op @@ -131,7 +181,7 @@ class MakesILP op where mkGraph :: op args -> LabelArgs args -> Label -> Information op -- for efficient reconstruction - mkMap :: PreOpenAcc (LabelledOp op) () a -> M.IntMap (UnsafeConstruction op) + -- mkMap :: PreOpenAcc (LabelledOp op) () a -> M.IntMap (UnsafeConstruction op) -- TODO doublecheck much of this, it's tricky: @@ -142,18 +192,88 @@ class MakesILP op where -- of outgoing edges. Let-bindings are easy, but the array-level -- control flow (acond and awhile) compensate: their bodies form separate -- graphs. +-- We can practically ignore 'Return' nodes. +-- let bindings are more tricky, because of the side effects. Often, +-- a let will not add to the environment but instead mutate it. +-- I'm still not convinced 'Compute' nodes can even be used +-- things with labels include: +-- - Control flow (a label for each branch, treated as a separate ILP) (acond & awhile) +-- - Exec +-- - Use +-- - Alloc? Difficult case: if you include it, are the edges fusible? Do we +-- need to include a binary in the ILP describing whether the alloc is fused away? +-- probably yes, and then the edges are infusible if they exist +-- but maybe no need to label it, if we can infer them afterwards? +-- - Unit + +-- this function will also need to produce the 'reconstruction' lookup map, +-- to ensure that the labels we generate are consistent between the lookup map +-- and the graph. I'll do that Later (TM) mkFullGraph :: MakesILP op - => PreOpenAcc (LabelledOp op) aenv a - -> LabelEnv aenv - -> ( S.Set Label -- ingoing edges - , S.Set Label -- outgoing edges - , Information op, M.IntMap (Information op) ) -mkFullGraph (Exec (LabelledOp l op) args) lenv = undefined - -mkFullGraph _ _ = undefined + => PreOpenAcc op aenv a + -> LabelEnv aenv -- for each array in the environment, + -- the source labels of the currently open outgoing edges. + -> Label -- the next fresh label to use + -> ( + -- S.Set Label -- incoming edges + -- , S.Set Label -- outgoing edges + ( Information op, M.IntMap (Information op)) + , LabelEnv aenv -- like input, but adjusted for side-effects + , S.Set Label -- source labels of currently open outgoing edges of 'a' + , Label -- the next fresh label to use + -- , reconstruction thing + ) + +-- Exec case: think about the exact type of mkGraph, and adjust accordingly. +-- clear responsibility on who makes the graph! + +-- For all input arguments (that is, everything except `Out` buffers), we add fusible edges. If that's +-- not strict enough, the backend can add infusible edges, but this is a sound (or complete? not both!) +-- lowerbound on fusibility: these inputs have to exist to evaluate the op. +mkFullGraph (Exec op args) lenv l = let fuseedges = S.map (, l) $ getInputArgLabels args lenv in + ( (mkGraph op (getLabelArgs args lenv) l <> Info (Graph (S.singleton l) fuseedges mempty) mempty mempty, mempty) + , updateLabelEnv args lenv l -- add labels for `Out` and `Mut` args. + , mempty + , l + 1) +mkFullGraph (Alet lhs u bnd scp) lenv l = + let (bndInfo, lenv', lbnd, l') = mkFullGraph bnd lenv l + (scpInfo, lenv'', lscp, l'') = mkFullGraph scp (addLhsLabels lhs lbnd lenv') l' + in (bndInfo <> scpInfo + , weakLhsEnv lhs lenv'' + , lscp + , l'') +mkFullGraph (Return vars) lenv l = ( (mempty, mempty), lenv, getLabelsTup vars lenv, l) +mkFullGraph (Compute expr) lenv l = ( (mempty, mempty), lenv, getLabelsExp expr lenv, l) +mkFullGraph (Alloc shr scty vars) lenv l = ( (mempty, mempty), lenv, mempty, l) -- unless we can't infer alloc... +mkFullGraph Use{} lenv l = + ( (Info (Graph (S.singleton l) mempty mempty) mempty mempty, mempty) + , lenv, S.singleton l, l+1) +-- gets a variable from the env, puts it in a singleton buffer. +-- Here I'm assuming this fuses nicely, and doesn't even need a new label +-- (reuse the one that belongs to the variable). If not, change! +mkFullGraph (Unit var) lenv l = ( (mempty, mempty), lenv, getLabelsVar var lenv, l) +-- NOTE: We explicitly add infusible edges from every label in `lenv` to this Acond. +-- This makes the previous let-bindings strict: even if some result is only used in one +-- branch, we now require it to be present before we evaluate the condition. +-- I think this is safe: if a result is only used in one branch, it should be let-bound +-- within that branch. Note that this also means we ignore the contents of 'cond' for the graph. +-- We also add edges from the Acond to the true-branch, and from the true-branch to the false-branch? +-- TODO check if this is right/needed/if passing even more fresh labels down is correct. +mkFullGraph (Acond cond tbranch fbranch) lenv l = let tlabel = l+1 + flabel = l+2 + emptyEnv = emptyLabelEnv lenv + ( (tinfo, tinfoM), _, _, l') = mkFullGraph tbranch emptyEnv (l+3) + ( (finfo, finfoM), _, _, l'') = mkFullGraph fbranch emptyEnv (l') + nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, tlabel), (tlabel, flabel)] + in ( (Info (Graph (S.fromList [l, l+1, l+2]) mempty nonfuse) mempty mempty + , M.fromList [(tlabel, tinfo), (flabel, finfo)] <> tinfoM <> finfoM) + , emptyEnv, S.singleton l, l''+1) +mkFullGraph _ _ _ = undefined + + -- mkFullGraph (Return groundvars) _ = undefined -- what is this? does this do anything? -- mkFullGraph (Compute expr) _ = undefined -- how is this even typecorrect? What does it mean? --- mkFullGraph (Exec (LabelledOp l op) args) lenv = ( S.singleton l, mkGraph op (mkLabelArgs args lenv) l, M.empty ) +-- mkFullGraph (Exec (LabelledOp l op) args) lenv = ( S.singleton l, mkGraph op (getLabelArgs args lenv) l, M.empty ) -- mkFullGraph (Alet lhs u bnd scp) lenv = -- let (label1, info1, infomap1) = mkFullGraph bnd lenv -- (label2, info2, infomap2) = mkFullGraph scp (addLhsLabels lhs label1 lenv) @@ -190,7 +310,7 @@ data UnsafeConstruction (op :: Type -> Type) = forall a. UnsafeConstruction (S.S makeILP :: Information op -> ILP op -makeILP (Information +makeILP (Info (Graph nodes fuseEdges nofuseEdges) backendconstraints backendbounds @@ -206,7 +326,7 @@ makeILP (Information -- ___ | real, everything else is integral. | -- | | Hope this doesn't slow the solver. | -- v ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾ - graphILP = Program Minimise (toR objFun) constraints bounds + graphILP = Program Minimise (toR objFun) constraints bounds -- Placeholder, currently maximising the number of vertical/diagonal fusions. -- In the future, maybe we want this to be backend-dependent. diff --git a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs index 4581ca45d..30ca4c952 100644 --- a/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs +++ b/src/Data/Array/Accelerate/Trafo/Operation/Substitution.hs @@ -48,16 +48,16 @@ data SunkReindexPartial f env env' where Sink :: SunkReindexPartial f env env' -> SunkReindexPartial f (env, s) (env', s) ReindexF :: ReindexPartial f env env' -> SunkReindexPartial f env env' -reindexPartial :: (IsExecutableAcc exe, Applicative f) => ReindexPartial f env env' -> PreOpenAcc exe env t -> f (PreOpenAcc exe env' t) +reindexPartial :: (Applicative f) => ReindexPartial f env env' -> PreOpenAcc exe env t -> f (PreOpenAcc exe env' t) reindexPartial k = reindexA' (ReindexF k) -reindexPartialAfun :: (IsExecutableAcc exe, Applicative f) => ReindexPartial f env env' -> PreOpenAfun exe env t -> f (PreOpenAfun exe env' t) +reindexPartialAfun :: (Applicative f) => ReindexPartial f env env' -> PreOpenAfun exe env t -> f (PreOpenAfun exe env' t) reindexPartialAfun k = reindexAfun' (ReindexF k) -instance IsExecutableAcc exe => Sink (PreOpenAcc exe) where +instance Sink (PreOpenAcc exe) where weaken k = runIdentity . reindexPartial (Identity . (k >:>)) -instance IsExecutableAcc exe => Sink (PreOpenAfun exe) where +instance Sink (PreOpenAfun exe) where weaken k = runIdentity . reindexPartialAfun (Identity . (k >:>)) instance Sink Arg where @@ -95,9 +95,9 @@ reindexArrayInstr' k (Parameter v) = Parameter <$> reindexVar' k v reindexExp' :: (Applicative f, RebuildableExp e) => SunkReindexPartial f benv benv' -> e (ArrayInstr benv) env t -> f (e (ArrayInstr benv') env t) reindexExp' k = rebuildArrayInstrPartial (rebuildArrayInstrMap $ reindexArrayInstr' k) -reindexA' :: forall exe f env env' t. (IsExecutableAcc exe, Applicative f) => SunkReindexPartial f env env' -> PreOpenAcc exe env t -> f (PreOpenAcc exe env' t) +reindexA' :: forall exe f env env' t. (Applicative f) => SunkReindexPartial f env env' -> PreOpenAcc exe env t -> f (PreOpenAcc exe env' t) reindexA' k = \case - Exec exe -> Exec <$> reindexExecPartial (reindex' k) exe + Exec op args -> Exec op <$> reindexArgs (reindex' k) args Return vars -> Return <$> reindexVars' k vars Compute e -> Compute <$> reindexExp' k e Alet lhs uniqueness bnd body @@ -111,12 +111,12 @@ reindexA' k = \case travA :: PreOpenAcc exe env s -> f (PreOpenAcc exe env' s) travA = reindexA' k -reindexAfun' :: (IsExecutableAcc exe, Applicative f) => SunkReindexPartial f env env' -> PreOpenAfun exe env t -> f (PreOpenAfun exe env' t) +reindexAfun' :: (Applicative f) => SunkReindexPartial f env env' -> PreOpenAfun exe env t -> f (PreOpenAfun exe env' t) reindexAfun' k (Alam lhs f) | Exists lhs' <- rebuildLHS lhs = Alam lhs' <$> reindexAfun' (sinkReindexWithLHS lhs lhs' k) f reindexAfun' k (Abody a) = Abody <$> reindexA' k a -pair :: forall exe env a b. IsExecutableAcc exe => PreOpenAcc exe env a -> PreOpenAcc exe env b -> PreOpenAcc exe env (a, b) +pair :: forall exe env a b. PreOpenAcc exe env a -> PreOpenAcc exe env b -> PreOpenAcc exe env (a, b) pair a b = goA weakenId a where -- Traverse 'a' and look for a return. We can jump over let bindings @@ -139,7 +139,7 @@ pair a b = goA weakenId a | DeclareVars lhs k value <- declareVars $ groundsR b = Alet lhs (shared $ groundsR b) acc $ Return (TupRpair (weakenVars k varsA) (value weakenId)) -alet :: IsExecutableAcc exe => GLeftHandSide t env env' -> PreOpenAcc exe env t -> PreOpenAcc exe env' s -> PreOpenAcc exe env s +alet :: GLeftHandSide t env env' -> PreOpenAcc exe env t -> PreOpenAcc exe env' s -> PreOpenAcc exe env s alet lhs1 (Alet lhs2 uniqueness a1 a2) a3 | Exists lhs1' <- rebuildLHS lhs1 = Alet lhs2 uniqueness a1 $ alet lhs1' a2 $ weaken (sinkWithLHS lhs1 lhs1' $ weakenWithLHS lhs2) a3 alet (LeftHandSideWildcard TupRunit) (Return TupRunit) a = a diff --git a/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs b/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs index c9aff6824..dc6a314ed 100644 --- a/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs +++ b/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs @@ -613,10 +613,10 @@ partialSchedule :: forall op genv1 t1. C.PartitionedAcc op genv1 t1 -> PartialSc partialSchedule = fst . travA (TupRsingle Shared) where travA :: forall genv t. Uniquenesses t -> C.PartitionedAcc op genv t -> (PartialSchedule op genv t, MaybeVars genv t) - travA _ (C.Exec cluster) - | Exists env <- convertEnvFromList $ map (foldr1 combineMod) $ groupBy (\(Exists v1) (Exists v2) -> isJust $ matchIdx (varIdx v1) (varIdx v2)) $ execVars cluster -- TODO: Remove duplicates more efficiently + travA _ (C.Exec cluster args) + | Exists env <- convertEnvFromList $ map (foldr1 combineMod) $ groupBy (\(Exists v1) (Exists v2) -> isJust $ matchIdx (varIdx v1) (varIdx v2)) $ argsVars args -- TODO: Remove duplicates more efficiently , Reads reEnv k inputBindings <- readRefs $ convertEnvRefs env - , Just cluster' <- reindexExecPartial (reEnvIdx reEnv) cluster + , Just args' <- reindexArgs (reEnvIdx reEnv) args = let signals = convertEnvSignals env resolvers = convertEnvSignalResolvers k env @@ -624,7 +624,7 @@ partialSchedule = fst . travA (TupRsingle Shared) ( PartialDo OutputEnvUnit env $ Effect (SignalAwait signals) $ inputBindings - $ Effect (Exec cluster') + $ Effect (Exec cluster args') $ Effect (SignalResolve resolvers) $ Return , TupRunit From 5b3e1942e37597092abe6bb6669a14aafb14d475 Mon Sep 17 00:00:00 2001 From: David Date: Thu, 4 Feb 2021 14:40:30 +0100 Subject: [PATCH 024/813] Separated labels into Label and ELabel --- src/Data/Array/Accelerate/AST/Operation.hs | 8 -- .../Array/Accelerate/Trafo/Clustering/ILP.hs | 110 ++++++++++++------ 2 files changed, 72 insertions(+), 46 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index 8240df135..2e46fa942 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -409,14 +409,6 @@ reindexArgs k (a :>: as) = (:>:) <$> reindexArg k a <*> reindexArgs k as weakenReindex :: benv :> benv' -> ReindexPartial Identity benv benv' weakenReindex k = Identity . (k >:>) --- class IsExecutableAcc exe where --- reindexExecPartial :: Applicative f => ReindexPartial f env env' -> exe env -> f (exe env') --- execVars :: exe env -> [Exists (Var AccessGroundR env)] - --- instance IsExecutableAcc (Execute op) where --- reindexExecPartial k (Execute op args) = Execute op <$> reindexArgs k args --- execVars (Execute _ args) = argsVars args - data AccessGroundR tp where AccessGroundRscalar :: ScalarType tp -> AccessGroundR tp AccessGroundRbuffer :: Modifier m -> ScalarType tp -> AccessGroundR (Buffer tp) diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs index 028974696..86be1ec1c 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE EmptyCase #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE ViewPatterns #-} @@ -40,6 +41,7 @@ import Numeric.Limp.Program hiding ( Constraint, r ) import Numeric.Limp.Rep.Rep ( Assignment ) import Numeric.Limp.Rep.IntDouble ( IntDouble ) import Data.Array.Accelerate.Representation.Type +import Unsafe.Coerce (unsafeCoerce) -- -- before we do the ILP pass, we label each 'Exec' node @@ -54,9 +56,13 @@ import Data.Array.Accelerate.Representation.Type -- labelAcc = undefined --- the graph datatype, including fusible/infusible edges, .., --- identifies nodes with unique Ints -type Label = Int +-- identifies nodes with unique Ints. and tracks their dependencies +type Label = Int + +-- identifies elements of the environment with unique Ints. +-- newtype'd to avoid confusing them with Label (above). +newtype ELabel = ELabel Int + deriving (Show, Eq, Ord, Num) -- | Directed edge (a,b): `b` depends on `a`. type Edge = (Label, Label) @@ -90,12 +96,13 @@ data LabelArgs args where -- | Keeps track of which array in the environment belongs to which label data LabelEnv env where LabelEnvNil :: LabelEnv () - (:>>>:) :: S.Set Label -> LabelEnv t -> LabelEnv (t, s) + (:>>>:) :: (ELabel, S.Set Label) -> LabelEnv t -> LabelEnv (t, s) -addLhsLabels :: LeftHandSide s v env env' -> S.Set Label -> LabelEnv env -> LabelEnv env' -addLhsLabels LeftHandSideWildcard{} _ lenv = lenv -addLhsLabels LeftHandSideSingle{} l lenv = l :>>>: lenv -addLhsLabels (LeftHandSidePair x y) l lenv = addLhsLabels y l (addLhsLabels x l lenv) +addLhsLabels :: LeftHandSide s v env env' -> ELabel -> S.Set Label -> LabelEnv env -> (ELabel, LabelEnv env') +addLhsLabels LeftHandSideWildcard{} e _ lenv = (e, lenv) +addLhsLabels LeftHandSideSingle{} e l lenv = (e + 1, (e, l) :>>>: lenv) +addLhsLabels (LeftHandSidePair x y) e l lenv = let (e' , lenv' ) = addLhsLabels x e l lenv + in addLhsLabels y e' l lenv' weakLhsEnv :: LeftHandSide s v env env' -> LabelEnv env' -> LabelEnv env weakLhsEnv LeftHandSideSingle{} (_:>>>: env) = env @@ -104,11 +111,11 @@ weakLhsEnv (LeftHandSidePair l r) env = weakLhsEnv l (weakLhsEnv r env) emptyLabelEnv :: LabelEnv env -> LabelEnv env emptyLabelEnv LabelEnvNil = LabelEnvNil -emptyLabelEnv (_:>>>:env) = mempty :>>>: emptyLabelEnv env +emptyLabelEnv ((e,_):>>>:env) = (e, mempty) :>>>: emptyLabelEnv env getAllLabelsEnv :: LabelEnv env -> S.Set Label getAllLabelsEnv LabelEnvNil = mempty -getAllLabelsEnv (set :>>>: lenv) = set <> getAllLabelsEnv lenv +getAllLabelsEnv ((_,set) :>>>: lenv) = set <> getAllLabelsEnv lenv getLabelArgs :: Args env args -> LabelEnv env -> LabelArgs args getLabelArgs ArgsNil _ = LabelArgsNil @@ -129,9 +136,13 @@ getLabelsVar :: Var s env t -> LabelEnv env -> S.Set Label getLabelsVar (varIdx -> idx) lenv = getLabelsIdx idx lenv getLabelsIdx :: Idx env a -> LabelEnv env -> S.Set Label -getLabelsIdx ZeroIdx (i :>>>: _) = i +getLabelsIdx ZeroIdx ((_,ls) :>>>: _) = ls getLabelsIdx (SuccIdx idx) (_ :>>>: env) = getLabelsIdx idx env +getELabelIdx :: Idx env a -> LabelEnv env -> ELabel +getELabelIdx ZeroIdx ((e,_) :>>>: _) = e +getELabelIdx (SuccIdx idx) (_ :>>>: env) = getELabelIdx idx env + getLabelsExp :: OpenExp x env y -> LabelEnv env -> S.Set Label getLabelsExp = undefined -- TODO traverse everything, look for Idxs @@ -150,9 +161,9 @@ updateLabelEnv (arg :>: args) lenv l = case arg of insertAtVars :: TupR (Var a env) b -> LabelEnv env -> Label -> LabelEnv env insertAtVars TupRunit lenv _ = lenv insertAtVars (TupRpair x y) lenv l = insertAtVars x (insertAtVars y lenv l) l -insertAtVars (TupRsingle (varIdx -> idx)) (lset :>>>: lenv) l = case idx of - ZeroIdx -> (S.insert l lset) :>>>: lenv - SuccIdx idx' -> lset :>>>: insertAtVars (TupRsingle (Var undefined idx')) lenv l +insertAtVars (TupRsingle (varIdx -> idx)) ((e,lset) :>>>: lenv) l = case idx of + ZeroIdx -> (e, S.insert l lset) :>>>: lenv + SuccIdx idx' -> (e, lset) :>>>: insertAtVars (TupRsingle (Var undefined idx')) lenv l insertAtVars (TupRsingle (varIdx -> idx)) LabelEnvNil _ = case idx of {} -- | Like `getLabelArgs`, but ignores the `Out` arguments @@ -214,6 +225,7 @@ mkFullGraph :: MakesILP op -> LabelEnv aenv -- for each array in the environment, -- the source labels of the currently open outgoing edges. -> Label -- the next fresh label to use + -> ELabel -- the next fresh ELabel to use -> ( -- S.Set Label -- incoming edges -- , S.Set Label -- outgoing edges @@ -221,6 +233,7 @@ mkFullGraph :: MakesILP op , LabelEnv aenv -- like input, but adjusted for side-effects , S.Set Label -- source labels of currently open outgoing edges of 'a' , Label -- the next fresh label to use + , ELabel -- the next fresh ELabel to use -- , reconstruction thing ) @@ -230,28 +243,31 @@ mkFullGraph :: MakesILP op -- For all input arguments (that is, everything except `Out` buffers), we add fusible edges. If that's -- not strict enough, the backend can add infusible edges, but this is a sound (or complete? not both!) -- lowerbound on fusibility: these inputs have to exist to evaluate the op. -mkFullGraph (Exec op args) lenv l = let fuseedges = S.map (, l) $ getInputArgLabels args lenv in +mkFullGraph (Exec op args) lenv l e = let fuseedges = S.map (, l) $ getInputArgLabels args lenv in ( (mkGraph op (getLabelArgs args lenv) l <> Info (Graph (S.singleton l) fuseedges mempty) mempty mempty, mempty) , updateLabelEnv args lenv l -- add labels for `Out` and `Mut` args. , mempty - , l + 1) -mkFullGraph (Alet lhs u bnd scp) lenv l = - let (bndInfo, lenv', lbnd, l') = mkFullGraph bnd lenv l - (scpInfo, lenv'', lscp, l'') = mkFullGraph scp (addLhsLabels lhs lbnd lenv') l' + , l + 1 + , e) +mkFullGraph (Alet lhs u bnd scp) lenv l e = -- replace ticks with numbers? think of actual names for variables??? + let (bndInfo, lenv' , lbnd, l' , e' ) = mkFullGraph bnd lenv l e + (e'', lenv'') = addLhsLabels lhs e' lbnd lenv' + (scpInfo, lenv''', lscp, l'', e''') = mkFullGraph scp lenv'' l' e'' in (bndInfo <> scpInfo - , weakLhsEnv lhs lenv'' + , weakLhsEnv lhs lenv''' , lscp - , l'') -mkFullGraph (Return vars) lenv l = ( (mempty, mempty), lenv, getLabelsTup vars lenv, l) -mkFullGraph (Compute expr) lenv l = ( (mempty, mempty), lenv, getLabelsExp expr lenv, l) -mkFullGraph (Alloc shr scty vars) lenv l = ( (mempty, mempty), lenv, mempty, l) -- unless we can't infer alloc... -mkFullGraph Use{} lenv l = + , l'' + , e''') +mkFullGraph (Return vars) lenv l e = ( (mempty, mempty), lenv, getLabelsTup vars lenv, l, e) +mkFullGraph (Compute expr) lenv l e = ( (mempty, mempty), lenv, getLabelsExp expr lenv, l, e) +mkFullGraph (Alloc shr scty vars) lenv l e = ( (mempty, mempty), lenv, mempty, l, e) -- unless we can't infer alloc... +mkFullGraph Use{} lenv l e = ( (Info (Graph (S.singleton l) mempty mempty) mempty mempty, mempty) - , lenv, S.singleton l, l+1) + , undefined, S.singleton l, l+1, e) -- gets a variable from the env, puts it in a singleton buffer. -- Here I'm assuming this fuses nicely, and doesn't even need a new label -- (reuse the one that belongs to the variable). If not, change! -mkFullGraph (Unit var) lenv l = ( (mempty, mempty), lenv, getLabelsVar var lenv, l) +mkFullGraph (Unit var) lenv l e = ( (mempty, mempty), undefined, getLabelsVar var lenv, l, e) -- NOTE: We explicitly add infusible edges from every label in `lenv` to this Acond. -- This makes the previous let-bindings strict: even if some result is only used in one -- branch, we now require it to be present before we evaluate the condition. @@ -259,16 +275,16 @@ mkFullGraph (Unit var) lenv l = ( (mempty, mempty), lenv, getLabelsVar var lenv, -- within that branch. Note that this also means we ignore the contents of 'cond' for the graph. -- We also add edges from the Acond to the true-branch, and from the true-branch to the false-branch? -- TODO check if this is right/needed/if passing even more fresh labels down is correct. -mkFullGraph (Acond cond tbranch fbranch) lenv l = let tlabel = l+1 - flabel = l+2 - emptyEnv = emptyLabelEnv lenv - ( (tinfo, tinfoM), _, _, l') = mkFullGraph tbranch emptyEnv (l+3) - ( (finfo, finfoM), _, _, l'') = mkFullGraph fbranch emptyEnv (l') - nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, tlabel), (tlabel, flabel)] - in ( (Info (Graph (S.fromList [l, l+1, l+2]) mempty nonfuse) mempty mempty - , M.fromList [(tlabel, tinfo), (flabel, finfo)] <> tinfoM <> finfoM) - , emptyEnv, S.singleton l, l''+1) -mkFullGraph _ _ _ = undefined +mkFullGraph (Acond cond tbranch fbranch) lenv l e = let tlabel = l+1 + flabel = l+2 + emptyEnv = emptyLabelEnv lenv + ( (tinfo, tinfoM), _, _, l' , e' ) = mkFullGraph tbranch emptyEnv (l+3) e + ( (finfo, finfoM), _, _, l'', e'') = mkFullGraph fbranch emptyEnv l' e' + nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, tlabel), (tlabel, flabel)] + in ( (Info (Graph (S.fromList [l, l+1, l+2]) mempty nonfuse) mempty mempty + , M.fromList [(tlabel, tinfo), (flabel, finfo)] <> tinfoM <> finfoM) + , emptyEnv, S.singleton l, l''+1, e'') +mkFullGraph _ _ _ _ = undefined -- mkFullGraph (Return groundvars) _ = undefined -- what is this? does this do anything? @@ -306,8 +322,26 @@ type Constraint op = P.Constraint (Variable op) () IntDouble -- note that 'a list of indices' is akin to a weakening (that possibly reorders the env too) -- todo: not all Idxs need to have the same 'a', so `list` should be `hlist` or tuplist :) -- todo: figure out how this works with 'args' -data UnsafeConstruction (op :: Type -> Type) = forall a. UnsafeConstruction (S.Set Int) (forall args. [Idx a args] -> op args) +-- | Contains three things: +-- - Operation - works on arguments (backend-specific, we don't touch it during this whole pass) +-- - Args - describes how to get the arguments from the old environment +-- - LabelEnv - stores ELabels, which allow us to re-index the Args into the new environment +data UnsafeConstruction (op :: Type -> Type) = forall env args. UnsafeConstruction (LabelEnv env) (Args env args) (op args) + + +-- | Uses unsafeCoerce to convince the typechecker that we have found what we were looking for. +-- If we don't screw up with the ELabels, this is safe... +mkReindexPartial :: LabelEnv env -> LabelEnv env' -> ReindexPartial Maybe env env' +mkReindexPartial lenv lenv' = findIdx . flip getELabelIdx lenv + where findIdx = go lenv' + go :: LabelEnv e -> ELabel -> Maybe (Idx e a) + go ((e,_) :>>>: env) e' + -- here we have to convince GHC that the top element in the environment + -- really does have the same type as the one we were searching for. + | e == e' = Just $ unsafeCoerce ZeroIdx + | otherwise = SuccIdx <$> go env e' + go LabelEnvNil _ = Nothing makeILP :: Information op -> ILP op makeILP (Info From 349bbdb80ec5d33e5561e94cdb88140d461b733f Mon Sep 17 00:00:00 2001 From: David Date: Mon, 8 Feb 2021 14:39:06 +0100 Subject: [PATCH 025/813] reorganise ILP --- .../Array/Accelerate/Trafo/Clustering/ILP.hs | 408 +----------------- .../Accelerate/Trafo/Clustering/ILP/Graph.hs | 242 +++++++++++ .../Accelerate/Trafo/Clustering/ILP/Labels.hs | 113 +++++ .../Accelerate/Trafo/Clustering/ILP/Solve.hs | 98 +++++ 4 files changed, 456 insertions(+), 405 deletions(-) create mode 100644 src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs create mode 100644 src/Data/Array/Accelerate/Trafo/Clustering/ILP/Labels.hs create mode 100644 src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs index 86be1ec1c..f28288a7b 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -1,407 +1,5 @@ -{-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# LANGUAGE EmptyCase #-} -{-# LANGUAGE TupleSections #-} -{-# LANGUAGE ViewPatterns #-} -{-# LANGUAGE DataKinds #-} -{-# LANGUAGE TypeFamilies #-} -{-# LANGUAGE GADTs #-} -{-# LANGUAGE ScopedTypeVariables #-} -{-# LANGUAGE RankNTypes #-} -{-# LANGUAGE KindSignatures #-} -{-# LANGUAGE PatternSynonyms #-} - module Data.Array.Accelerate.Trafo.Clustering.ILP where -import Data.Array.Accelerate.AST.Operation -import Data.Array.Accelerate.AST.Idx -import Data.Array.Accelerate.AST.Partitioned ( Cluster ) -import Data.Array.Accelerate.AST.LeftHandSide - -import qualified Data.IntMap as M -import Data.List (foldl') -import Data.Kind ( Type ) - - --- In this file, order very often subly does matter. --- To keep this clear, we use S.Set whenever it does not, --- and [] only when it does. It's also often efficient --- by removing duplicates. -import qualified Data.Set as S - --- Limp is a Linear Integer Mixed Programming library. --- We only use the Integer part (not the Mixed part, --- which allows you to add non-integer variables and --- constraints). It has a backend that binds to CBC, --- which is apparently a good one? Does not seem to be --- actively maintained though. --- We can always switch to a different ILP library --- later, the interfaces are all quite similar. -import qualified Numeric.Limp.Program as P -import Numeric.Limp.Program hiding ( Constraint, r ) -import Numeric.Limp.Rep.Rep ( Assignment ) -import Numeric.Limp.Rep.IntDouble ( IntDouble ) -import Data.Array.Accelerate.Representation.Type -import Unsafe.Coerce (unsafeCoerce) - - --- -- before we do the ILP pass, we label each 'Exec' node --- data LabelledOp op args = LabelledOp Label (op args) --- -- with the Operation-base acc, that might not be enough.. --- -- kind of need to label each array, so each Use/Unit too? --- -- Don't need to label Allocs, we only care about the dependencies. --- -- so.. probably need to back the recursive knot into the Operation --- -- ast too, so we can label everything? - --- labelAcc :: PreOpenAcc op env a -> PreOpenAcc (LabelledOp op) env a --- labelAcc = undefined - - --- identifies nodes with unique Ints. and tracks their dependencies -type Label = Int - --- identifies elements of the environment with unique Ints. --- newtype'd to avoid confusing them with Label (above). -newtype ELabel = ELabel Int - deriving (Show, Eq, Ord, Num) - --- | Directed edge (a,b): `b` depends on `a`. -type Edge = (Label, Label) - --- TODO: at some point, set fusibleEdges := fusibleEdges \\ infusibleEdges. Makes ILP smaller. -data Graph = Graph - { graphNodes :: S.Set Label - , fusibleEdges :: S.Set Edge -- Can be fused over, otherwise `a` before `b`. - , infusibleEdges :: S.Set Edge -- Can't be fused over, always `a` before `b`. - } -instance Semigroup Graph where - Graph n f i <> Graph n' f' i' = Graph (n <> n') (f <> f') (i <> i') -instance Monoid Graph where - mempty = Graph mempty mempty mempty - --- The graph is the 'common part' of the ILP, --- each backend has to encode their own constraints --- describing the fusion rules. The bounds is a [] instead of S.Set --- for practical reasons (no Ord instance, LIMP expects a list) only. -data Information op = Info Graph (Constraint op) [ Bounds (Variable op) () IntDouble ] -instance Semigroup (Information op) where - Info g c b <> Info g' c' b' = Info (g <> g') (c <> c') (b <> b') -instance Monoid (Information op) where - mempty = Info mempty mempty mempty - --- | Keeps track of which argument belongs to which labels -data LabelArgs args where - LabelArgsNil :: LabelArgs () - (:>>:) :: S.Set Label -> LabelArgs t -> LabelArgs (s -> t) - --- | Keeps track of which array in the environment belongs to which label -data LabelEnv env where - LabelEnvNil :: LabelEnv () - (:>>>:) :: (ELabel, S.Set Label) -> LabelEnv t -> LabelEnv (t, s) - -addLhsLabels :: LeftHandSide s v env env' -> ELabel -> S.Set Label -> LabelEnv env -> (ELabel, LabelEnv env') -addLhsLabels LeftHandSideWildcard{} e _ lenv = (e, lenv) -addLhsLabels LeftHandSideSingle{} e l lenv = (e + 1, (e, l) :>>>: lenv) -addLhsLabels (LeftHandSidePair x y) e l lenv = let (e' , lenv' ) = addLhsLabels x e l lenv - in addLhsLabels y e' l lenv' - -weakLhsEnv :: LeftHandSide s v env env' -> LabelEnv env' -> LabelEnv env -weakLhsEnv LeftHandSideSingle{} (_:>>>: env) = env -weakLhsEnv LeftHandSideWildcard{} env = env -weakLhsEnv (LeftHandSidePair l r) env = weakLhsEnv l (weakLhsEnv r env) - -emptyLabelEnv :: LabelEnv env -> LabelEnv env -emptyLabelEnv LabelEnvNil = LabelEnvNil -emptyLabelEnv ((e,_):>>>:env) = (e, mempty) :>>>: emptyLabelEnv env - -getAllLabelsEnv :: LabelEnv env -> S.Set Label -getAllLabelsEnv LabelEnvNil = mempty -getAllLabelsEnv ((_,set) :>>>: lenv) = set <> getAllLabelsEnv lenv - -getLabelArgs :: Args env args -> LabelEnv env -> LabelArgs args -getLabelArgs ArgsNil _ = LabelArgsNil -getLabelArgs (arg :>: args) e = getLabelsArg arg e :>>: getLabelArgs args e - -getLabelsArg :: Arg env t -> LabelEnv env -> S.Set Label -getLabelsArg (ArgVar tup) env = getLabelsTup tup env -getLabelsArg (ArgExp expr) env = getLabelsExp expr env -getLabelsArg (ArgFun fun) env = getLabelsFun fun env -getLabelsArg (ArgArray _ _ shVars bufVars) env = getLabelsTup shVars env <> getLabelsTup bufVars env - -getLabelsTup :: TupR (Var a env) b -> LabelEnv env -> S.Set Label -getLabelsTup TupRunit _ = mempty -getLabelsTup (TupRsingle var) env = getLabelsVar var env -getLabelsTup (TupRpair x y) env = getLabelsTup x env <> getLabelsTup y env - -getLabelsVar :: Var s env t -> LabelEnv env -> S.Set Label -getLabelsVar (varIdx -> idx) lenv = getLabelsIdx idx lenv - -getLabelsIdx :: Idx env a -> LabelEnv env -> S.Set Label -getLabelsIdx ZeroIdx ((_,ls) :>>>: _) = ls -getLabelsIdx (SuccIdx idx) (_ :>>>: env) = getLabelsIdx idx env - -getELabelIdx :: Idx env a -> LabelEnv env -> ELabel -getELabelIdx ZeroIdx ((e,_) :>>>: _) = e -getELabelIdx (SuccIdx idx) (_ :>>>: env) = getELabelIdx idx env - -getLabelsExp :: OpenExp x env y -> LabelEnv env -> S.Set Label -getLabelsExp = undefined -- TODO traverse everything, look for Idxs - -getLabelsFun :: OpenFun x env y -> LabelEnv env -> S.Set Label -getLabelsFun (Body expr) lenv = getLabelsExp expr lenv -getLabelsFun (Lam _ fun) lenv = getLabelsFun fun lenv - -updateLabelEnv :: Args env args -> LabelEnv env -> Label -> LabelEnv env -updateLabelEnv ArgsNil lenv _ = lenv -updateLabelEnv (arg :>: args) lenv l = case arg of - -- CHECK we only look at the 'Buffer' vars here, not the 'shape' ones. Is that ok? - ArgArray Out _ _ vars -> updateLabelEnv args (insertAtVars vars lenv l) l - ArgArray Mut _ _ vars -> updateLabelEnv args (insertAtVars vars lenv l) l - _ -> updateLabelEnv args lenv l - -insertAtVars :: TupR (Var a env) b -> LabelEnv env -> Label -> LabelEnv env -insertAtVars TupRunit lenv _ = lenv -insertAtVars (TupRpair x y) lenv l = insertAtVars x (insertAtVars y lenv l) l -insertAtVars (TupRsingle (varIdx -> idx)) ((e,lset) :>>>: lenv) l = case idx of - ZeroIdx -> (e, S.insert l lset) :>>>: lenv - SuccIdx idx' -> (e, lset) :>>>: insertAtVars (TupRsingle (Var undefined idx')) lenv l -insertAtVars (TupRsingle (varIdx -> idx)) LabelEnvNil _ = case idx of {} - --- | Like `getLabelArgs`, but ignores the `Out` arguments -getInputArgLabels :: Args env args -> LabelEnv env -> S.Set Label -getInputArgLabels ArgsNil _ = mempty -getInputArgLabels (arg :>: args) lenv = getInputArgLabels args lenv <> case arg of - ArgArray Out _ _ _ -> mempty - _ -> getLabelsArg arg lenv - -class MakesILP op where - -- Variables needed to express backend-specific fusion rules. - type BackendVar op - - -- Control flow cannot be fused, so we make separate ILPs for e.g. - -- then-branch and else-branch. In the future, a possible optimisation is to - -- generate code for the awhile-condition twice: once maybe fused after the body, - -- once maybe fused after input. For now, condition and body are both treated - -- as 'foreign calls', like if-then-else. - -- The IntMap maps from a label to the corresponding ILP (only for things treated - -- as 'foreign calls', like control flow). - -- A program can result in multiple ILPs, for example, the body of an 'awhile' cannot be fused with anything outside of it. - -- you `can` encode this in the ILP, but since the solutions are independant of each other it should be much more efficient - -- to solve them separately. This avoids many 'infusible edges', and significantly reduces the search space. The extracted - -- subtree gets encoded as a sort of 'foreign call', preventing all fusion. - -- todo: maybe we can extract more commonality from this, making the class more complicated but instances smaller/easier - mkGraph :: op args -> LabelArgs args -> Label -> Information op - - -- for efficient reconstruction - -- mkMap :: PreOpenAcc (LabelledOp op) () a -> M.IntMap (UnsafeConstruction op) - - --- TODO doublecheck much of this, it's tricky: --- in the Operation-based AST, everything is powered by side effects. --- this makes a full-program analysis like this much more difficult, --- luckily the Args give us all the information we really require. --- For each node, we get the set of incoming edges and the set --- of outgoing edges. Let-bindings are easy, but the array-level --- control flow (acond and awhile) compensate: their bodies form separate --- graphs. --- We can practically ignore 'Return' nodes. --- let bindings are more tricky, because of the side effects. Often, --- a let will not add to the environment but instead mutate it. --- I'm still not convinced 'Compute' nodes can even be used --- things with labels include: --- - Control flow (a label for each branch, treated as a separate ILP) (acond & awhile) --- - Exec --- - Use --- - Alloc? Difficult case: if you include it, are the edges fusible? Do we --- need to include a binary in the ILP describing whether the alloc is fused away? --- probably yes, and then the edges are infusible if they exist --- but maybe no need to label it, if we can infer them afterwards? --- - Unit - --- this function will also need to produce the 'reconstruction' lookup map, --- to ensure that the labels we generate are consistent between the lookup map --- and the graph. I'll do that Later (TM) -mkFullGraph :: MakesILP op - => PreOpenAcc op aenv a - -> LabelEnv aenv -- for each array in the environment, - -- the source labels of the currently open outgoing edges. - -> Label -- the next fresh label to use - -> ELabel -- the next fresh ELabel to use - -> ( - -- S.Set Label -- incoming edges - -- , S.Set Label -- outgoing edges - ( Information op, M.IntMap (Information op)) - , LabelEnv aenv -- like input, but adjusted for side-effects - , S.Set Label -- source labels of currently open outgoing edges of 'a' - , Label -- the next fresh label to use - , ELabel -- the next fresh ELabel to use - -- , reconstruction thing - ) - --- Exec case: think about the exact type of mkGraph, and adjust accordingly. --- clear responsibility on who makes the graph! - --- For all input arguments (that is, everything except `Out` buffers), we add fusible edges. If that's --- not strict enough, the backend can add infusible edges, but this is a sound (or complete? not both!) --- lowerbound on fusibility: these inputs have to exist to evaluate the op. -mkFullGraph (Exec op args) lenv l e = let fuseedges = S.map (, l) $ getInputArgLabels args lenv in - ( (mkGraph op (getLabelArgs args lenv) l <> Info (Graph (S.singleton l) fuseedges mempty) mempty mempty, mempty) - , updateLabelEnv args lenv l -- add labels for `Out` and `Mut` args. - , mempty - , l + 1 - , e) -mkFullGraph (Alet lhs u bnd scp) lenv l e = -- replace ticks with numbers? think of actual names for variables??? - let (bndInfo, lenv' , lbnd, l' , e' ) = mkFullGraph bnd lenv l e - (e'', lenv'') = addLhsLabels lhs e' lbnd lenv' - (scpInfo, lenv''', lscp, l'', e''') = mkFullGraph scp lenv'' l' e'' - in (bndInfo <> scpInfo - , weakLhsEnv lhs lenv''' - , lscp - , l'' - , e''') -mkFullGraph (Return vars) lenv l e = ( (mempty, mempty), lenv, getLabelsTup vars lenv, l, e) -mkFullGraph (Compute expr) lenv l e = ( (mempty, mempty), lenv, getLabelsExp expr lenv, l, e) -mkFullGraph (Alloc shr scty vars) lenv l e = ( (mempty, mempty), lenv, mempty, l, e) -- unless we can't infer alloc... -mkFullGraph Use{} lenv l e = - ( (Info (Graph (S.singleton l) mempty mempty) mempty mempty, mempty) - , undefined, S.singleton l, l+1, e) --- gets a variable from the env, puts it in a singleton buffer. --- Here I'm assuming this fuses nicely, and doesn't even need a new label --- (reuse the one that belongs to the variable). If not, change! -mkFullGraph (Unit var) lenv l e = ( (mempty, mempty), undefined, getLabelsVar var lenv, l, e) --- NOTE: We explicitly add infusible edges from every label in `lenv` to this Acond. --- This makes the previous let-bindings strict: even if some result is only used in one --- branch, we now require it to be present before we evaluate the condition. --- I think this is safe: if a result is only used in one branch, it should be let-bound --- within that branch. Note that this also means we ignore the contents of 'cond' for the graph. --- We also add edges from the Acond to the true-branch, and from the true-branch to the false-branch? --- TODO check if this is right/needed/if passing even more fresh labels down is correct. -mkFullGraph (Acond cond tbranch fbranch) lenv l e = let tlabel = l+1 - flabel = l+2 - emptyEnv = emptyLabelEnv lenv - ( (tinfo, tinfoM), _, _, l' , e' ) = mkFullGraph tbranch emptyEnv (l+3) e - ( (finfo, finfoM), _, _, l'', e'') = mkFullGraph fbranch emptyEnv l' e' - nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, tlabel), (tlabel, flabel)] - in ( (Info (Graph (S.fromList [l, l+1, l+2]) mempty nonfuse) mempty mempty - , M.fromList [(tlabel, tinfo), (flabel, finfo)] <> tinfoM <> finfoM) - , emptyEnv, S.singleton l, l''+1, e'') -mkFullGraph _ _ _ _ = undefined - - --- mkFullGraph (Return groundvars) _ = undefined -- what is this? does this do anything? --- mkFullGraph (Compute expr) _ = undefined -- how is this even typecorrect? What does it mean? --- mkFullGraph (Exec (LabelledOp l op) args) lenv = ( S.singleton l, mkGraph op (getLabelArgs args lenv) l, M.empty ) --- mkFullGraph (Alet lhs u bnd scp) lenv = --- let (label1, info1, infomap1) = mkFullGraph bnd lenv --- (label2, info2, infomap2) = mkFullGraph scp (addLhsLabels lhs label1 lenv) --- in ( label2 --- , info1 <> info2 --- -- If we encounter any duplicate keys here, that's a bad sign --- , M.unionWith (error "oops") infomap1 infomap2 ) --- mkFullGraph (Alloc shr sct expv) lenv = ( getLabelsTup expv lenv, mempty, mempty ) --- mkFullGraph (Use sct buf) lenv = ( mempty, mempty, mempty ) --- mkFullGraph (Unit evar) lenv = ( getLabelsVar evar lenv, mempty, mempty ) - --- -- now these are problematic: should we duplicate the informations and put them in the map with all the labels? --- mkFullGraph (Acond c t e) lenv = undefined -- ifthenelse --- mkFullGraph (Awhile us c b s) lenv = undefined -- while - -data Variable op - = Pi Label -- For acyclic ordering of clusters - | Fused Label Label -- 0 is fused (same cluster), 1 is unfused. We do *not* have one of these for all pairs! - | BackendSpecific (BackendVar op) -- Variables needed to express backend-specific fusion rules. - - --- We have integer variables, and no reals. -type ILP op = Program (Variable op) () IntDouble -type Constraint op = P.Constraint (Variable op) () IntDouble - - --- Describes how, given a list of indices into 'env', we can reconstruct an 'Execute op env'. --- as the name suggests, this cannot be done 'safely': we're in the business of constructing --- a strongly typed AST from untyped ILP output. --- note that 'a list of indices' is akin to a weakening (that possibly reorders the env too) --- todo: not all Idxs need to have the same 'a', so `list` should be `hlist` or tuplist :) --- todo: figure out how this works with 'args' - --- | Contains three things: --- - Operation - works on arguments (backend-specific, we don't touch it during this whole pass) --- - Args - describes how to get the arguments from the old environment --- - LabelEnv - stores ELabels, which allow us to re-index the Args into the new environment -data UnsafeConstruction (op :: Type -> Type) = forall env args. UnsafeConstruction (LabelEnv env) (Args env args) (op args) - - --- | Uses unsafeCoerce to convince the typechecker that we have found what we were looking for. --- If we don't screw up with the ELabels, this is safe... -mkReindexPartial :: LabelEnv env -> LabelEnv env' -> ReindexPartial Maybe env env' -mkReindexPartial lenv lenv' = findIdx . flip getELabelIdx lenv - where findIdx = go lenv' - go :: LabelEnv e -> ELabel -> Maybe (Idx e a) - go ((e,_) :>>>: env) e' - -- here we have to convince GHC that the top element in the environment - -- really does have the same type as the one we were searching for. - | e == e' = Just $ unsafeCoerce ZeroIdx - | otherwise = SuccIdx <$> go env e' - go LabelEnvNil _ = Nothing - -makeILP :: Information op -> ILP op -makeILP (Info - (Graph nodes fuseEdges nofuseEdges) - backendconstraints - backendbounds - ) = combine graphILP - where - combine (Program dir fun cons bnds) = - Program dir fun (cons <> backendconstraints) - (bnds <> backendbounds) - - n = S.size nodes - -- _____________________________________ - -- | Don't know why the objFun has to be | - -- ___ | real, everything else is integral. | - -- | | Hope this doesn't slow the solver. | - -- v ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾ - graphILP = Program Minimise (toR objFun) constraints bounds - - -- Placeholder, currently maximising the number of vertical/diagonal fusions. - -- In the future, maybe we want this to be backend-dependent. - objFun = foldl' (\f (i, j) -> f .+. z1 (Fused i j)) c0 (S.toList fuseEdges) - - constraints = acyclic <> infusible - - -- x_ij <= pi_j - pi_i <= n*x_ij for all fusible edges - acyclic = foldMap - (\(i, j) -> Between - ( z1 (Fused i j) ) - ( z1 (Pi j) .-. z1 (Pi i) ) - ( z (Fused i j) (fromIntegral n) )) - fuseEdges - - -- pi_j - pi_i >= 1 for all infusible edges (i,j) - infusible = foldMap (\(i, j) -> (z1 (Pi j) .-. z1 (Pi i)) :>= c1) - nofuseEdges - - -- 0 <= pi_i <= n - bounds = map (\i -> lowerUpperZ 0 (Pi i) (fromIntegral n)) - (S.toList nodes) - <> -- x_ij \in {0, 1} - map (\(i, j) -> binary (Fused i j)) - (S.toList fuseEdges) - - - - --- call the solver. Gets called for each ILP -solveILP :: ILP op -> Assignment (Variable op) () IntDouble -solveILP = undefined - - --- "open research question" --- Each set of ints corresponds to a set of unsafeConstructions, which themselves contain a set of ints (the things they depend on). --- Some of those ints will refer to nodes in previous clusters, others to nodes in this cluster. --- One pass over these datatypes (back-to-front) should identify the 'output type' of each cluster: which nodes are needed in later clusters? --- Then, we can construct the clusters front-to-back: --- identify the nodes that only depend on nodes outside of the cluster, they are the initials --- the `output type` indicates which nodes we will need to keep: they are all either a final node in the cluster, or get diagonally fused --- How exactly we can use this information (and a dep. graph) to construct a cluster of ver,hor,diag is not clear.. Will also depend on the exact cluster definition. -reconstruct :: Graph -> [S.Set Int] -> M.IntMap [S.Set Int] -> M.IntMap (UnsafeConstruction op) -> Exists (PreOpenAcc (Cluster op) ()) -reconstruct = undefined +import Data.Array.Accelerate.Trafo.Clustering.ILP.Graph () +import Data.Array.Accelerate.Trafo.Clustering.ILP.Labels () +import Data.Array.Accelerate.Trafo.Clustering.ILP.Solve () diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs new file mode 100644 index 000000000..6f65d2ad0 --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs @@ -0,0 +1,242 @@ +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TupleSections #-} +module Data.Array.Accelerate.Trafo.Clustering.ILP.Graph where + +import Data.Array.Accelerate.Trafo.Clustering.ILP.Labels + +-- accelerate imports +import Data.Array.Accelerate.AST.Idx ( Idx(..) ) +import Data.Array.Accelerate.AST.Operation + +-- Data structures +import qualified Data.IntMap as M +-- In this file, order very often subly does matter. +-- To keep this clear, we use S.Set whenever it does not, +-- and [] only when it does. It's also often efficient +-- by removing duplicates. +import qualified Data.Set as S + + +-- GHC imports +import Data.Kind ( Type ) +import Unsafe.Coerce (unsafeCoerce) + + +-- Limp is a Linear Integer Mixed Programming library. +-- We only use the Integer part (not the Mixed part, +-- which allows you to add non-integer variables and +-- constraints). It has a backend that binds to CBC, +-- which is apparently a good one? Does not seem to be +-- actively maintained though. +-- We can always switch to a different ILP library +-- later, the interfaces are all quite similar. +import qualified Numeric.Limp.Program as P +import Numeric.Limp.Program ( Program, Bounds ) +import Numeric.Limp.Rep.IntDouble ( IntDouble ) + + + +-- | We have Int variables represented by @Variable op@, and no real variables. +type LIMP dttyp op = dttyp (Variable op) () IntDouble + +type ILP op = LIMP Program op +type Constraint op = LIMP P.Constraint op + + + +-- | Directed edge (a,b): `b` depends on `a`. +type Edge = (Label, Label) + +-- TODO: at some point, set fusibleEdges := fusibleEdges \\ infusibleEdges. Makes ILP smaller. +data Graph = Graph + { graphNodes :: S.Set Label + , fusibleEdges :: S.Set Edge -- Can be fused over, otherwise `a` before `b`. + , infusibleEdges :: S.Set Edge -- Can't be fused over, always `a` before `b`. + } +instance Semigroup Graph where + Graph n f i <> Graph n' f' i' = Graph (n <> n') (f <> f') (i <> i') +instance Monoid Graph where + mempty = Graph mempty mempty mempty + +-- The graph is the 'common part' of the ILP, +-- each backend has to encode their own constraints +-- describing the fusion rules. The bounds is a [] instead of S.Set +-- for practical reasons (no Ord instance, LIMP expects a list) only. +data Information op = Info Graph (Constraint op) [LIMP Bounds op] +instance Semigroup (Information op) where + Info g c b <> Info g' c' b' = Info (g <> g') (c <> c') (b <> b') +instance Monoid (Information op) where + mempty = Info mempty mempty mempty + + + +data Variable op + = Pi Label -- For acyclic ordering of clusters + | Fused Label Label -- 0 is fused (same cluster), 1 is unfused. We do *not* have one of these for all pairs! + | BackendSpecific (BackendVar op) -- Variables needed to express backend-specific fusion rules. + + + +class MakesILP op where + -- Variables needed to express backend-specific fusion rules. + type BackendVar op + + -- Control flow cannot be fused, so we make separate ILPs for e.g. + -- then-branch and else-branch. In the future, a possible optimisation is to + -- generate code for the awhile-condition twice: once maybe fused after the body, + -- once maybe fused after input. For now, condition and body are both treated + -- as 'foreign calls', like if-then-else. + -- The IntMap maps from a label to the corresponding ILP (only for things treated + -- as 'foreign calls', like control flow). + -- A program can result in multiple ILPs, for example, the body of an 'awhile' cannot be fused with anything outside of it. + -- you `can` encode this in the ILP, but since the solutions are independant of each other it should be much more efficient + -- to solve them separately. This avoids many 'infusible edges', and significantly reduces the search space. The extracted + -- subtree gets encoded as a sort of 'foreign call', preventing all fusion. + -- todo: maybe we can extract more commonality from this, making the class more complicated but instances smaller/easier + mkGraph :: op args -> LabelArgs args -> Label -> Information op + + -- for efficient reconstruction + -- mkMap :: PreOpenAcc (LabelledOp op) () a -> M.IntMap (UnsafeConstruction op) + + +-- TODO doublecheck much of this, it's tricky: +-- in the Operation-based AST, everything is powered by side effects. +-- this makes a full-program analysis like this much more difficult, +-- luckily the Args give us all the information we really require. +-- For each node, we get the set of incoming edges and the set +-- of outgoing edges. Let-bindings are easy, but the array-level +-- control flow (acond and awhile) compensate: their bodies form separate +-- graphs. +-- We can practically ignore 'Return' nodes. +-- let bindings are more tricky, because of the side effects. Often, +-- a let will not add to the environment but instead mutate it. +-- I'm still not convinced 'Compute' nodes can even be used +-- things with labels include: +-- - Control flow (a label for each branch, treated as a separate ILP) (acond & awhile) +-- - Exec +-- - Use +-- - Alloc? Difficult case: if you include it, are the edges fusible? Do we +-- need to include a binary in the ILP describing whether the alloc is fused away? +-- probably yes, and then the edges are infusible if they exist +-- but maybe no need to label it, if we can infer them afterwards? +-- - Unit + +-- this function will also need to produce the 'reconstruction' lookup map, +-- to ensure that the labels we generate are consistent between the lookup map +-- and the graph. I'll do that Later (TM) +mkFullGraph :: MakesILP op + => PreOpenAcc op aenv a + -> LabelEnv aenv -- for each array in the environment, + -- the source labels of the currently open outgoing edges. + -> Label -- the next fresh label to use + -> ELabel -- the next fresh ELabel to use + -> ( + -- S.Set Label -- incoming edges + -- , S.Set Label -- outgoing edges + ( Information op, M.IntMap (Information op)) + , LabelEnv aenv -- like input, but adjusted for side-effects + , S.Set Label -- source labels of currently open outgoing edges of 'a' + , Label -- the next fresh label to use + , ELabel -- the next fresh ELabel to use + -- , reconstruction thing + ) + +-- Exec case: think about the exact type of mkGraph, and adjust accordingly. +-- clear responsibility on who makes the graph! + +-- For all input arguments (that is, everything except `Out` buffers), we add fusible edges. If that's +-- not strict enough, the backend can add infusible edges, but this is a sound (or complete? not both!) +-- lowerbound on fusibility: these inputs have to exist to evaluate the op. +mkFullGraph (Exec op args) lenv l e = let fuseedges = S.map (, l) $ getInputArgLabels args lenv in + ( (mkGraph op (getLabelArgs args lenv) l <> Info (Graph (S.singleton l) fuseedges mempty) mempty mempty, mempty) + , updateLabelEnv args lenv l -- add labels for `Out` and `Mut` args. + , mempty + , l + 1 + , e) +mkFullGraph (Alet lhs u bnd scp) lenv l e = -- replace ticks with numbers? think of actual names for variables??? + let (bndInfo, lenv' , lbnd, l' , e' ) = mkFullGraph bnd lenv l e + (e'', lenv'') = addLhsLabels lhs e' lbnd lenv' + (scpInfo, lenv''', lscp, l'', e''') = mkFullGraph scp lenv'' l' e'' + in (bndInfo <> scpInfo + , weakLhsEnv lhs lenv''' + , lscp + , l'' + , e''') +mkFullGraph (Return vars) lenv l e = ( (mempty, mempty), lenv, getLabelsTup vars lenv, l, e) +mkFullGraph (Compute expr) lenv l e = ( (mempty, mempty), lenv, getLabelsExp expr lenv, l, e) +mkFullGraph (Alloc shr scty vars) lenv l e = ( (mempty, mempty), lenv, mempty, l, e) -- unless we can't infer alloc... +mkFullGraph Use{} lenv l e = + ( (Info (Graph (S.singleton l) mempty mempty) mempty mempty, mempty) + , undefined, S.singleton l, l+1, e) +-- gets a variable from the env, puts it in a singleton buffer. +-- Here I'm assuming this fuses nicely, and doesn't even need a new label +-- (reuse the one that belongs to the variable). If not, change! +mkFullGraph (Unit var) lenv l e = ( (mempty, mempty), undefined, getLabelsVar var lenv, l, e) +-- NOTE: We explicitly add infusible edges from every label in `lenv` to this Acond. +-- This makes the previous let-bindings strict: even if some result is only used in one +-- branch, we now require it to be present before we evaluate the condition. +-- I think this is safe: if a result is only used in one branch, it should be let-bound +-- within that branch. Note that this also means we ignore the contents of 'cond' for the graph. +-- We also add edges from the Acond to the true-branch, and from the true-branch to the false-branch? +-- TODO check if this is right/needed/if passing even more fresh labels down is correct. +mkFullGraph (Acond cond tbranch fbranch) lenv l e = let tlabel = l+1 + flabel = l+2 + emptyEnv = emptyLabelEnv lenv + ( (tinfo, tinfoM), _, _, l' , e' ) = mkFullGraph tbranch emptyEnv (l+3) e + ( (finfo, finfoM), _, _, l'', e'') = mkFullGraph fbranch emptyEnv l' e' + nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, tlabel), (tlabel, flabel)] + in ( (Info (Graph (S.fromList [l, l+1, l+2]) mempty nonfuse) mempty mempty + , M.fromList [(tlabel, tinfo), (flabel, finfo)] <> tinfoM <> finfoM) + , emptyEnv, S.singleton l, l''+1, e'') +mkFullGraph _ _ _ _ = undefined + + +-- mkFullGraph (Return groundvars) _ = undefined -- what is this? does this do anything? +-- mkFullGraph (Compute expr) _ = undefined -- how is this even typecorrect? What does it mean? +-- mkFullGraph (Exec (LabelledOp l op) args) lenv = ( S.singleton l, mkGraph op (getLabelArgs args lenv) l, M.empty ) +-- mkFullGraph (Alet lhs u bnd scp) lenv = +-- let (label1, info1, infomap1) = mkFullGraph bnd lenv +-- (label2, info2, infomap2) = mkFullGraph scp (addLhsLabels lhs label1 lenv) +-- in ( label2 +-- , info1 <> info2 +-- -- If we encounter any duplicate keys here, that's a bad sign +-- , M.unionWith (error "oops") infomap1 infomap2 ) +-- mkFullGraph (Alloc shr sct expv) lenv = ( getLabelsTup expv lenv, mempty, mempty ) +-- mkFullGraph (Use sct buf) lenv = ( mempty, mempty, mempty ) +-- mkFullGraph (Unit evar) lenv = ( getLabelsVar evar lenv, mempty, mempty ) + +-- -- now these are problematic: should we duplicate the informations and put them in the map with all the labels? +-- mkFullGraph (Acond c t e) lenv = undefined -- ifthenelse +-- mkFullGraph (Awhile us c b s) lenv = undefined -- while + +-- Describes how, given a list of indices into 'env', we can reconstruct an 'Execute op env'. +-- as the name suggests, this cannot be done 'safely': we're in the business of constructing +-- a strongly typed AST from untyped ILP output. +-- note that 'a list of indices' is akin to a weakening (that possibly reorders the env too) +-- todo: not all Idxs need to have the same 'a', so `list` should be `hlist` or tuplist :) +-- todo: figure out how this works with 'args' + +-- | Contains three things: +-- - Operation - works on arguments (backend-specific, we don't touch it during this whole pass) +-- - Args - describes how to get the arguments from the old environment +-- - LabelEnv - stores ELabels, which allow us to re-index the Args into the new environment +data UnsafeConstruction (op :: Type -> Type) = forall env args. UnsafeConstruction (LabelEnv env) (Args env args) (op args) + + +-- | Uses unsafeCoerce to convince the typechecker that we have found what we were looking for. +-- If we don't screw up with the ELabels, this is safe... +mkReindexPartial :: LabelEnv env -> LabelEnv env' -> ReindexPartial Maybe env env' +mkReindexPartial lenv lenv' = findIdx . flip getELabelIdx lenv + where findIdx = go lenv' + go :: LabelEnv e -> ELabel -> Maybe (Idx e a) + go ((e,_) :>>>: env) e' + -- here we have to convince GHC that the top element in the environment + -- really does have the same type as the one we were searching for. + -- some literature does this stuff too: 'effect handlers in haskell, evidently' + -- and 'a monadic framework for delimited continuations' (SPJ) come to mind + | e == e' = Just $ unsafeCoerce ZeroIdx + | otherwise = SuccIdx <$> go env e' + go LabelEnvNil _ = Nothing diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Labels.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Labels.hs new file mode 100644 index 000000000..961dee13a --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Labels.hs @@ -0,0 +1,113 @@ +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE EmptyCase #-} +{-# LANGUAGE ViewPatterns #-} +module Data.Array.Accelerate.Trafo.Clustering.ILP.Labels where + + +-- accelerate imports +import Data.Array.Accelerate.AST.Idx ( Idx(..) ) +import Data.Array.Accelerate.AST.LeftHandSide ( LeftHandSide(..) ) +import Data.Array.Accelerate.AST.Operation +import Data.Array.Accelerate.Representation.Type ( TupR(..) ) + +-- In this file, order very often subly does matter. +-- To keep this clear, we use S.Set whenever it does not, +-- and [] only when it does. It's also often efficient +-- by removing duplicates. +import qualified Data.Set as S + + +-- identifies nodes with unique Ints. and tracks their dependencies +type Label = Int + +-- identifies elements of the environment with unique Ints. +-- newtype'd to avoid confusing them with Label (above). +newtype ELabel = ELabel Int + deriving (Show, Eq, Ord, Num) + + +-- | Keeps track of which argument belongs to which labels +data LabelArgs args where + LabelArgsNil :: LabelArgs () + (:>>:) :: S.Set Label -> LabelArgs t -> LabelArgs (s -> t) + +-- | Keeps track of which array in the environment belongs to which label +data LabelEnv env where + LabelEnvNil :: LabelEnv () + (:>>>:) :: (ELabel, S.Set Label) -> LabelEnv t -> LabelEnv (t, s) + +addLhsLabels :: LeftHandSide s v env env' -> ELabel -> S.Set Label -> LabelEnv env -> (ELabel, LabelEnv env') +addLhsLabels LeftHandSideWildcard{} e _ lenv = (e , lenv) +addLhsLabels LeftHandSideSingle{} e l lenv = (e + 1, (e, l) :>>>: lenv) +addLhsLabels (LeftHandSidePair x y) e l lenv = let (e' , lenv') = addLhsLabels x e l lenv + in addLhsLabels y e' l lenv' + +weakLhsEnv :: LeftHandSide s v env env' -> LabelEnv env' -> LabelEnv env +weakLhsEnv LeftHandSideSingle{} (_:>>>: env) = env +weakLhsEnv LeftHandSideWildcard{} env = env +weakLhsEnv (LeftHandSidePair l r) env = weakLhsEnv l (weakLhsEnv r env) + +emptyLabelEnv :: LabelEnv env -> LabelEnv env +emptyLabelEnv LabelEnvNil = LabelEnvNil +emptyLabelEnv ((e,_):>>>:env) = (e, mempty) :>>>: emptyLabelEnv env + +getAllLabelsEnv :: LabelEnv env -> S.Set Label +getAllLabelsEnv LabelEnvNil = mempty +getAllLabelsEnv ((_,set) :>>>: lenv) = set <> getAllLabelsEnv lenv + +getLabelArgs :: Args env args -> LabelEnv env -> LabelArgs args +getLabelArgs ArgsNil _ = LabelArgsNil +getLabelArgs (arg :>: args) e = getLabelsArg arg e :>>: getLabelArgs args e + +getLabelsArg :: Arg env t -> LabelEnv env -> S.Set Label +getLabelsArg (ArgVar tup) env = getLabelsTup tup env +getLabelsArg (ArgExp expr) env = getLabelsExp expr env +getLabelsArg (ArgFun fun) env = getLabelsFun fun env +getLabelsArg (ArgArray _ _ shVars bufVars) env = getLabelsTup shVars env <> getLabelsTup bufVars env + +getLabelsTup :: TupR (Var a env) b -> LabelEnv env -> S.Set Label +getLabelsTup TupRunit _ = mempty +getLabelsTup (TupRsingle var) env = getLabelsVar var env +getLabelsTup (TupRpair x y) env = getLabelsTup x env <> getLabelsTup y env + +getLabelsVar :: Var s env t -> LabelEnv env -> S.Set Label +getLabelsVar (varIdx -> idx) = getLabelsIdx idx + +getLabelsIdx :: Idx env a -> LabelEnv env -> S.Set Label +getLabelsIdx ZeroIdx ((_,ls) :>>>: _) = ls +getLabelsIdx (SuccIdx idx) (_ :>>>: env) = getLabelsIdx idx env + +getELabelIdx :: Idx env a -> LabelEnv env -> ELabel +getELabelIdx ZeroIdx ((e,_) :>>>: _) = e +getELabelIdx (SuccIdx idx) (_ :>>>: env) = getELabelIdx idx env + +getLabelsExp :: OpenExp x env y -> LabelEnv env -> S.Set Label +getLabelsExp = undefined -- TODO traverse everything, look for Idxs + +getLabelsFun :: OpenFun x env y -> LabelEnv env -> S.Set Label +getLabelsFun (Body expr) lenv = getLabelsExp expr lenv +getLabelsFun (Lam _ fun) lenv = getLabelsFun fun lenv + +updateLabelEnv :: Args env args -> LabelEnv env -> Label -> LabelEnv env +updateLabelEnv ArgsNil lenv _ = lenv +updateLabelEnv (arg :>: args) lenv l = case arg of + -- CHECK we only look at the 'Buffer' vars here, not the 'shape' ones. Is that ok? + ArgArray Out _ _ vars -> updateLabelEnv args (insertAtVars vars lenv l) l + ArgArray Mut _ _ vars -> updateLabelEnv args (insertAtVars vars lenv l) l + _ -> updateLabelEnv args lenv l + +insertAtVars :: TupR (Var a env) b -> LabelEnv env -> Label -> LabelEnv env +insertAtVars TupRunit lenv _ = lenv +insertAtVars (TupRpair x y) lenv l = insertAtVars x (insertAtVars y lenv l) l +insertAtVars (TupRsingle (varIdx -> idx)) ((e,lset) :>>>: lenv) l = case idx of + ZeroIdx -> (e, S.insert l lset) :>>>: lenv + SuccIdx idx' -> (e, lset) :>>>: insertAtVars (TupRsingle (Var undefined idx')) lenv l +insertAtVars (TupRsingle (varIdx -> idx)) LabelEnvNil _ = case idx of {} + +-- | Like `getLabelArgs`, but ignores the `Out` arguments +getInputArgLabels :: Args env args -> LabelEnv env -> S.Set Label +getInputArgLabels ArgsNil _ = mempty +getInputArgLabels (arg :>: args) lenv = getInputArgLabels args lenv <> case arg of + ArgArray Out _ _ _ -> mempty + _ -> getLabelsArg arg lenv diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs new file mode 100644 index 000000000..83b8b59e7 --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs @@ -0,0 +1,98 @@ +module Data.Array.Accelerate.Trafo.Clustering.ILP.Solve where + +import Data.Array.Accelerate.Trafo.Clustering.ILP.Graph + +-- accelerate imports +import Data.Array.Accelerate.AST.LeftHandSide +import Data.Array.Accelerate.AST.Operation +import Data.Array.Accelerate.AST.Partitioned ( Cluster ) + +-- Data structures +-- M.IntMap is used +import qualified Data.IntMap as M +-- In this file, order very often subly does matter. +-- To keep this clear, we use S.Set whenever it does not, +-- and [] only when it does. It's also often efficient +-- by removing duplicates. +import qualified Data.Set as S +import Data.List (foldl') + + +-- GHC imports + + +-- Limp is a Linear Integer Mixed Programming library. +-- We only use the Integer part (not the Mixed part, +-- which allows you to add non-integer variables and +-- constraints). It has a backend that binds to CBC, +-- which is apparently a good one? Does not seem to be +-- actively maintained though. +-- We can always switch to a different ILP library +-- later, the interfaces are all quite similar. +import Numeric.Limp.Program hiding ( Constraint, r ) +import Numeric.Limp.Rep.Rep ( Assignment ) + + + +makeILP :: Information op -> ILP op +makeILP (Info + (Graph nodes fuseEdges nofuseEdges) + backendconstraints + backendbounds + ) = combine graphILP + where + combine (Program dir fun cons bnds) = + Program dir fun (cons <> backendconstraints) + (bnds <> backendbounds) + + n = S.size nodes + -- _____________________________________ + -- | Don't know why the objFun has to be | + -- ___ | real, everything else is integral. | + -- | | Hope this doesn't slow the solver. | + -- v ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾ + graphILP = Program Minimise (toR objFun) constraints bounds + + -- Placeholder, currently maximising the number of vertical/diagonal fusions. + -- In the future, maybe we want this to be backend-dependent. + objFun = foldl' (\f (i, j) -> f .+. z1 (Fused i j)) c0 (S.toList fuseEdges) + + constraints = acyclic <> infusible + + -- x_ij <= pi_j - pi_i <= n*x_ij for all fusible edges + acyclic = foldMap + (\(i, j) -> Between + ( z1 (Fused i j) ) + ( z1 (Pi j) .-. z1 (Pi i) ) + ( z (Fused i j) (fromIntegral n) )) + fuseEdges + + -- pi_j - pi_i >= 1 for all infusible edges (i,j) + infusible = foldMap (\(i, j) -> z1 (Pi j) .-. z1 (Pi i) :>= c1) + nofuseEdges + + -- 0 <= pi_i <= n + bounds = map (\i -> lowerUpperZ 0 (Pi i) (fromIntegral n)) + (S.toList nodes) + <> -- x_ij \in {0, 1} + map (\(i, j) -> binary (Fused i j)) + (S.toList fuseEdges) + + + + +-- call the solver. Gets called for each ILP +solveILP :: ILP op -> LIMP Assignment op +solveILP = undefined + + +-- "open research question" +-- Each set of ints corresponds to a set of unsafeConstructions, which themselves contain a set of ints (the things they depend on). +-- Some of those ints will refer to nodes in previous clusters, others to nodes in this cluster. +-- One pass over these datatypes (back-to-front) should identify the 'output type' of each cluster: which nodes are needed in later clusters? +-- Then, we can construct the clusters front-to-back: +-- identify the nodes that only depend on nodes outside of the cluster, they are the initials +-- the `output type` indicates which nodes we will need to keep: they are all either a final node in the cluster, or get diagonally fused +-- How exactly we can use this information (and a dep. graph) to construct a cluster of ver,hor,diag is not clear.. Will also depend on the exact cluster definition. +reconstruct :: Graph -> [S.Set Int] -> M.IntMap [S.Set Int] -> M.IntMap (UnsafeConstruction op) -> Exists (PreOpenAcc (Cluster op) ()) +reconstruct = undefined From 469138c29f74620da7f495370b1d76cf474e15d2 Mon Sep 17 00:00:00 2001 From: David Date: Mon, 15 Feb 2021 11:23:31 +0100 Subject: [PATCH 026/813] commit before rewrite of 'construct' --- .../Accelerate/Trafo/Clustering/ILP/Graph.hs | 247 ++++++++++++------ .../Accelerate/Trafo/Clustering/ILP/Labels.hs | 11 +- .../Accelerate/Trafo/Clustering/ILP/Solve.hs | 45 ++-- 3 files changed, 197 insertions(+), 106 deletions(-) diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs index 6f65d2ad0..38e89b3e3 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs @@ -1,8 +1,14 @@ +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE PolyKinds #-} +{-# LANGUAGE DataKinds #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE TupleSections #-} +{-# LANGUAGE ScopedTypeVariables #-} + module Data.Array.Accelerate.Trafo.Clustering.ILP.Graph where import Data.Array.Accelerate.Trafo.Clustering.ILP.Labels @@ -12,12 +18,12 @@ import Data.Array.Accelerate.AST.Idx ( Idx(..) ) import Data.Array.Accelerate.AST.Operation -- Data structures -import qualified Data.IntMap as M -- In this file, order very often subly does matter. -- To keep this clear, we use S.Set whenever it does not, -- and [] only when it does. It's also often efficient -- by removing duplicates. import qualified Data.Set as S +import qualified Data.IntMap as M -- GHC imports @@ -33,24 +39,31 @@ import Unsafe.Coerce (unsafeCoerce) -- actively maintained though. -- We can always switch to a different ILP library -- later, the interfaces are all quite similar. -import qualified Numeric.Limp.Program as P -import Numeric.Limp.Program ( Program, Bounds ) -import Numeric.Limp.Rep.IntDouble ( IntDouble ) - +import qualified Numeric.Limp.Program as LIMP +import qualified Numeric.Limp.Rep as LIMP +import Numeric.Limp.Program hiding ( Bounds, Constraint, Program, Linear, r ) +import Numeric.Limp.Rep ( IntDouble ) +import Data.Array.Accelerate.AST.LeftHandSide (Exists(Exists)) +import Data.Array.Accelerate.Array.Buffer +import Data.Array.Accelerate.Type +import Data.Type.Equality -- | We have Int variables represented by @Variable op@, and no real variables. -type LIMP dttyp op = dttyp (Variable op) () IntDouble - -type ILP op = LIMP Program op -type Constraint op = LIMP P.Constraint op - +-- These type synonyms instantiate the @z@, @r@ and @c@ type variables in Limp. +type LIMP datatyp op = datatyp (Variable op) () IntDouble +type LIMP' datatyp op a = datatyp (Variable op) () IntDouble a +type Assignment op = LIMP LIMP.Assignment op +type Bounds op = LIMP LIMP.Bounds op +type Constraint op = LIMP LIMP.Constraint op +type ILP op = LIMP LIMP.Program op +type Linear op res = LIMP' LIMP.Linear op res -- | Directed edge (a,b): `b` depends on `a`. type Edge = (Label, Label) --- TODO: at some point, set fusibleEdges := fusibleEdges \\ infusibleEdges. Makes ILP smaller. + data Graph = Graph { graphNodes :: S.Set Label , fusibleEdges :: S.Set Edge -- Can be fused over, otherwise `a` before `b`. @@ -65,7 +78,7 @@ instance Monoid Graph where -- each backend has to encode their own constraints -- describing the fusion rules. The bounds is a [] instead of S.Set -- for practical reasons (no Ord instance, LIMP expects a list) only. -data Information op = Info Graph (Constraint op) [LIMP Bounds op] +data Information op = Info Graph (Constraint op) [Bounds op] instance Semigroup (Information op) where Info g c b <> Info g' c' b' = Info (g <> g') (c <> c') (b <> b') instance Monoid (Information op) where @@ -78,6 +91,11 @@ data Variable op | Fused Label Label -- 0 is fused (same cluster), 1 is unfused. We do *not* have one of these for all pairs! | BackendSpecific (BackendVar op) -- Variables needed to express backend-specific fusion rules. +-- convenience synonyms +pi :: Label -> Linear op 'KZ +pi l = z1 $ Pi l +fused :: Label -> Label -> Linear op 'KZ +fused x y = z1 $ Fused x y class MakesILP op where @@ -127,13 +145,13 @@ class MakesILP op where -- this function will also need to produce the 'reconstruction' lookup map, -- to ensure that the labels we generate are consistent between the lookup map -- and the graph. I'll do that Later (TM) -mkFullGraph :: MakesILP op - => PreOpenAcc op aenv a +mkFullGraph :: MakesILP op + => PreOpenAcc op aenv a -> LabelEnv aenv -- for each array in the environment, -- the source labels of the currently open outgoing edges. -> Label -- the next fresh label to use -> ELabel -- the next fresh ELabel to use - -> ( + -> ( -- S.Set Label -- incoming edges -- , S.Set Label -- outgoing edges ( Information op, M.IntMap (Information op)) @@ -141,102 +159,157 @@ mkFullGraph :: MakesILP op , S.Set Label -- source labels of currently open outgoing edges of 'a' , Label -- the next fresh label to use , ELabel -- the next fresh ELabel to use - -- , reconstruction thing + , M.IntMap (Construction op) ) -- Exec case: think about the exact type of mkGraph, and adjust accordingly. -- clear responsibility on who makes the graph! -- For all input arguments (that is, everything except `Out` buffers), we add fusible edges. If that's --- not strict enough, the backend can add infusible edges, but this is a sound (or complete? not both!) --- lowerbound on fusibility: these inputs have to exist to evaluate the op. -mkFullGraph (Exec op args) lenv l e = let fuseedges = S.map (, l) $ getInputArgLabels args lenv in - ( (mkGraph op (getLabelArgs args lenv) l <> Info (Graph (S.singleton l) fuseedges mempty) mempty mempty, mempty) - , updateLabelEnv args lenv l -- add labels for `Out` and `Mut` args. - , mempty - , l + 1 - , e) +-- not strict enough, the backend can add infusible edges, but this is a sound +-- lowerbound on fusibility: these inputs cannot be computed _after_ the op. +-- Excessive fusible edges are filtered out before we feed them to the ILP solver. +mkFullGraph (Exec op args) lenv l e = + let fuseedges = S.map (, l) $ getInputArgLabels args lenv + in ( (mkGraph op (getLabelArgs args lenv) l <> Info (Graph (S.singleton l) fuseedges mempty) mempty mempty, mempty) + , updateLabelEnv args lenv l -- add labels for `Out` and `Mut` args. + , mempty + , l + 1 + , e + , M.singleton l $ CExe lenv args op) mkFullGraph (Alet lhs u bnd scp) lenv l e = -- replace ticks with numbers? think of actual names for variables??? - let (bndInfo, lenv' , lbnd, l' , e' ) = mkFullGraph bnd lenv l e + let (bndInfo, lenv' , lbnd, l' , e' , c ) = mkFullGraph bnd lenv l e (e'', lenv'') = addLhsLabels lhs e' lbnd lenv' - (scpInfo, lenv''', lscp, l'', e''') = mkFullGraph scp lenv'' l' e'' + (scpInfo, lenv''', lscp, l'', e''', c') = mkFullGraph scp lenv'' l' e'' in (bndInfo <> scpInfo , weakLhsEnv lhs lenv''' , lscp , l'' - , e''') -mkFullGraph (Return vars) lenv l e = ( (mempty, mempty), lenv, getLabelsTup vars lenv, l, e) -mkFullGraph (Compute expr) lenv l e = ( (mempty, mempty), lenv, getLabelsExp expr lenv, l, e) -mkFullGraph (Alloc shr scty vars) lenv l e = ( (mempty, mempty), lenv, mempty, l, e) -- unless we can't infer alloc... -mkFullGraph Use{} lenv l e = + , e''' + , c <> c') +mkFullGraph (Return vars) lenv l e = ( (mempty, mempty), lenv, getLabelsTup vars lenv, l, e, mempty) +mkFullGraph (Compute expr) lenv l e = ( (mempty, mempty), lenv, getLabelsExp expr lenv, l, e, mempty) +mkFullGraph (Alloc shr scty shvar) lenv l e = ( (mempty, mempty), lenv, mempty , l, e, mempty) -- unless we can't infer alloc... +mkFullGraph (Use sctype buff) lenv l e = ( (Info (Graph (S.singleton l) mempty mempty) mempty mempty, mempty) - , undefined, S.singleton l, l+1, e) + , lenv, S.singleton l, l+1, e + , M.singleton l $ CUse sctype buff) -- gets a variable from the env, puts it in a singleton buffer. -- Here I'm assuming this fuses nicely, and doesn't even need a new label --- (reuse the one that belongs to the variable). If not, change! -mkFullGraph (Unit var) lenv l e = ( (mempty, mempty), undefined, getLabelsVar var lenv, l, e) +-- (reuse the one that belongs to the variable). Might need to add a label +-- to avoid obfuscating the AST though. Change when needed. +mkFullGraph (Unit var) lenv l e = ( (mempty, mempty), lenv, getLabelsVar var lenv, l, e, mempty) + -- NOTE: We explicitly add infusible edges from every label in `lenv` to this Acond. -- This makes the previous let-bindings strict: even if some result is only used in one -- branch, we now require it to be present before we evaluate the condition. -- I think this is safe: if a result is only used in one branch, it should be let-bound --- within that branch. Note that this also means we ignore the contents of 'cond' for the graph. +-- within that branch already. Note that this also means we ignore the contents of 'cond' for the graph. -- We also add edges from the Acond to the true-branch, and from the true-branch to the false-branch? -- TODO check if this is right/needed/if passing even more fresh labels down is correct. mkFullGraph (Acond cond tbranch fbranch) lenv l e = let tlabel = l+1 flabel = l+2 emptyEnv = emptyLabelEnv lenv - ( (tinfo, tinfoM), _, _, l' , e' ) = mkFullGraph tbranch emptyEnv (l+3) e - ( (finfo, finfoM), _, _, l'', e'') = mkFullGraph fbranch emptyEnv l' e' + ( (tinfo, tinfoM), _, _, l' , e' , c ) = mkFullGraph tbranch emptyEnv (l+3) e + ( (finfo, finfoM), _, _, l'', e'', c') = mkFullGraph fbranch emptyEnv l' e' nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, tlabel), (tlabel, flabel)] - in ( (Info (Graph (S.fromList [l, l+1, l+2]) mempty nonfuse) mempty mempty + in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty , M.fromList [(tlabel, tinfo), (flabel, finfo)] <> tinfoM <> finfoM) - , emptyEnv, S.singleton l, l''+1, e'') -mkFullGraph _ _ _ _ = undefined - - --- mkFullGraph (Return groundvars) _ = undefined -- what is this? does this do anything? --- mkFullGraph (Compute expr) _ = undefined -- how is this even typecorrect? What does it mean? --- mkFullGraph (Exec (LabelledOp l op) args) lenv = ( S.singleton l, mkGraph op (getLabelArgs args lenv) l, M.empty ) --- mkFullGraph (Alet lhs u bnd scp) lenv = --- let (label1, info1, infomap1) = mkFullGraph bnd lenv --- (label2, info2, infomap2) = mkFullGraph scp (addLhsLabels lhs label1 lenv) --- in ( label2 --- , info1 <> info2 --- -- If we encounter any duplicate keys here, that's a bad sign --- , M.unionWith (error "oops") infomap1 infomap2 ) --- mkFullGraph (Alloc shr sct expv) lenv = ( getLabelsTup expv lenv, mempty, mempty ) --- mkFullGraph (Use sct buf) lenv = ( mempty, mempty, mempty ) --- mkFullGraph (Unit evar) lenv = ( getLabelsVar evar lenv, mempty, mempty ) - --- -- now these are problematic: should we duplicate the informations and put them in the map with all the labels? --- mkFullGraph (Acond c t e) lenv = undefined -- ifthenelse --- mkFullGraph (Awhile us c b s) lenv = undefined -- while - --- Describes how, given a list of indices into 'env', we can reconstruct an 'Execute op env'. --- as the name suggests, this cannot be done 'safely': we're in the business of constructing --- a strongly typed AST from untyped ILP output. --- note that 'a list of indices' is akin to a weakening (that possibly reorders the env too) --- todo: not all Idxs need to have the same 'a', so `list` should be `hlist` or tuplist :) --- todo: figure out how this works with 'args' - --- | Contains three things: --- - Operation - works on arguments (backend-specific, we don't touch it during this whole pass) --- - Args - describes how to get the arguments from the old environment --- - LabelEnv - stores ELabels, which allow us to re-index the Args into the new environment -data UnsafeConstruction (op :: Type -> Type) = forall env args. UnsafeConstruction (LabelEnv env) (Args env args) (op args) - - --- | Uses unsafeCoerce to convince the typechecker that we have found what we were looking for. --- If we don't screw up with the ELabels, this is safe... + , emptyEnv, S.singleton l, l'', e'' + , M.insert l (CITE lenv cond tlabel flabel) c <> c') +-- like Acond. The biggest difference is that 'cond' is a function instead of an expression here. +-- In fact, for the graph, we use 'startvars' much like we used 'cond' in Acond, and we use +-- 'cond' and 'bdy' much like we used 'tbranch' and 'fbranch'. +mkFullGraph (Awhile u cond bdy startvars) lenv l e = let clabel = l+1 + blabel = 1+2 + emptyEnv = emptyLabelEnv lenv + ( (cinfo, cinfoM), _, _, l' , e' , c ) = mkFullGraphF cond emptyEnv (l+3) e + ( (binfo, binfoM), _, _, l'', e'', c') = mkFullGraphF bdy emptyEnv l' e' + nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, clabel), (clabel, blabel)] + in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty + , M.fromList [(clabel, cinfo), (blabel, binfo)] <> cinfoM <> binfoM) + , emptyEnv, S.singleton l, l'', e'' + , M.insert l (CWHL lenv u clabel blabel startvars) c <> c') + + +mkFullGraphF :: MakesILP op + => PreOpenAfun op aenv a + -> LabelEnv aenv -- for each array in the environment, + -- the source labels of the currently open outgoing edges. + -> Label -- the next fresh label to use + -> ELabel -- the next fresh ELabel to use + -> ( + -- S.Set Label -- incoming edges + -- , S.Set Label -- outgoing edges + ( Information op, M.IntMap (Information op)) + , LabelEnv aenv -- like input, but adjusted for side-effects + , S.Set Label -- source labels of currently open outgoing edges of 'a' + , Label -- the next fresh label to use + , ELabel -- the next fresh ELabel to use + , M.IntMap (Construction op) + ) +mkFullGraphF = \case + Abody acc -> mkFullGraph acc + Alam lhs f -> \lenv l e -> let (e', lenv') = addLhsLabels lhs e mempty lenv -- it's a function, so we can fill the extra environment with mempties + ((info, infoM), lenv'', lset, l', e'', c) = mkFullGraphF f lenv' l e' + in ((info, infoM), weakLhsEnv lhs lenv'', lset, l', e'', c) + +-- | Information to construct AST nodes. Generally, constructors contain +-- both actual information, and a LabelEnv of the original environment +-- which helps to re-index into the new environment later. +data Construction (op :: Type -> Type) where + CExe :: LabelEnv env -> Args env args -> op args -> Construction op + CUse :: ScalarType e -> Buffer e -> Construction op + CITE :: LabelEnv env -> ExpVar env PrimBool -> Label -> Label -> Construction op + CWHL :: LabelEnv env -> Uniquenesses a -> Label -> Label -> GroundVars env a -> Construction op + +-- maybe rewrite this into partial functions for each option; +-- the 'ITE' one really needs to get the branches as argument, can't just try to make one like this. +construct :: forall op env'. Construction op -> LabelEnv env' -> M.IntMap (Construction op) -> Maybe (Exists (PreOpenAcc op env')) +construct construction lenv' intmap = case construction of + CExe lenv args op -> Exists . Exec op <$> reindexArgs (reindex lenv) args + CUse sctype buff -> Just . Exists $ Use sctype buff + CITE lenv cond thenL elseL -> do + thenConstruct <- M.lookup thenL intmap + Exists (thenAcc :: PreOpenAcc op env' a) <- construct thenConstruct lenv' intmap + elseConstruct <- M.lookup elseL intmap + Exists (elseAcc :: PreOpenAcc op env' b) <- construct elseConstruct lenv' intmap + newcond <- reindexVar (reindex lenv) cond + case unsafeCoerce Refl of -- convince the typechecker that the branches have the same type + (Refl :: a :~: b) -> return $ Exists $ Acond newcond thenAcc elseAcc + CWHL lenv u cndL bdyL start -> do + cndConstruct <- M.lookup cndL intmap + Exists (cndAcc :: PreOpenAfun op env' c) <- constructF cndConstruct lenv' intmap + bdyConstruct <- M.lookup bdyL intmap + Exists (bdyAcc :: PreOpenAfun op env' b) <- constructF bdyConstruct lenv' intmap + (newStart :: GroundVars env' a) <- reindexVars (reindex lenv) start + case unsafeCoerce Refl of -- convince the typechecker that the branches have the right type + (Refl :: c :~: (a -> PrimBool)) -> case unsafeCoerce Refl of + (Refl :: b :~: (a -> a)) -> return $ Exists $ Awhile u cndAcc bdyAcc newStart + where + reindex :: LabelEnv env -> ReindexPartial Maybe env env' + reindex env = mkReindexPartial env lenv' + +-- constructF :: Construction op -> + + +-- | Makes a ReindexPartial, which allows us to transform indices in @env@ into indices in @env'@. +-- We cannot guarantee the index is present in env', so we use the partiality of ReindexPartial by +-- returning a Maybe. Uses unsafeCoerce to re-introduce type information implied by the ELabels. mkReindexPartial :: LabelEnv env -> LabelEnv env' -> ReindexPartial Maybe env env' -mkReindexPartial lenv lenv' = findIdx . flip getELabelIdx lenv - where findIdx = go lenv' - go :: LabelEnv e -> ELabel -> Maybe (Idx e a) - go ((e,_) :>>>: env) e' - -- here we have to convince GHC that the top element in the environment - -- really does have the same type as the one we were searching for. - -- some literature does this stuff too: 'effect handlers in haskell, evidently' - -- and 'a monadic framework for delimited continuations' (SPJ) come to mind - | e == e' = Just $ unsafeCoerce ZeroIdx - | otherwise = SuccIdx <$> go env e' - go LabelEnvNil _ = Nothing +mkReindexPartial lenv lenv' = \idx -> go lenv' $ getELabelIdx idx lenv + where + go :: LabelEnv e -> ELabel -> Maybe (Idx e a) + go ((e,_) :>>>: env) e' + -- Here we have to convince GHC that the top element in the environment + -- really does have the same type as the one we were searching for. + -- Some literature does this stuff too: 'effect handlers in haskell, evidently' + -- and 'a monadic framework for delimited continuations' come to mind. + -- Basically: standard procedure if you're using Ints as a unique identifier + -- and want to re-introduce type information. :) + | e == e' = Just $ unsafeCoerce ZeroIdx + | otherwise = SuccIdx <$> go env e' + -- If we hit the end, the Elabel was not present in the environment. + -- That probably means we'll error out at a later point, but maybe there is + -- a case where we try multiple options? No need to worry about it here. + go LabelEnvNil _ = Nothing diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Labels.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Labels.hs index 961dee13a..ae7d1ddea 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Labels.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Labels.hs @@ -37,6 +37,15 @@ data LabelEnv env where LabelEnvNil :: LabelEnv () (:>>>:) :: (ELabel, S.Set Label) -> LabelEnv t -> LabelEnv (t, s) + + + +------------------------------- +-- Traversals over stuff to add/extract Labels and ELabels, +-- or otherwise manipulate LabelArgs' or LabelEnvs +-- vvvvvvvvvvvvvvvvvvvvvvvvv -- + + addLhsLabels :: LeftHandSide s v env env' -> ELabel -> S.Set Label -> LabelEnv env -> (ELabel, LabelEnv env') addLhsLabels LeftHandSideWildcard{} e _ lenv = (e , lenv) addLhsLabels LeftHandSideSingle{} e l lenv = (e + 1, (e, l) :>>>: lenv) @@ -103,7 +112,7 @@ insertAtVars (TupRpair x y) lenv l = insertAtVars x (insertAtVars y lenv l) l insertAtVars (TupRsingle (varIdx -> idx)) ((e,lset) :>>>: lenv) l = case idx of ZeroIdx -> (e, S.insert l lset) :>>>: lenv SuccIdx idx' -> (e, lset) :>>>: insertAtVars (TupRsingle (Var undefined idx')) lenv l -insertAtVars (TupRsingle (varIdx -> idx)) LabelEnvNil _ = case idx of {} +insertAtVars (TupRsingle (varIdx -> idx)) LabelEnvNil _ = case idx of {} -- convincing the exhausiveness checker -- | Like `getLabelArgs`, but ignores the `Out` arguments getInputArgLabels :: Args env args -> LabelEnv env -> S.Set Label diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs index 83b8b59e7..69171ad89 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs @@ -1,6 +1,10 @@ +{-# LANGUAGE TypeOperators #-} module Data.Array.Accelerate.Trafo.Clustering.ILP.Solve where import Data.Array.Accelerate.Trafo.Clustering.ILP.Graph +import Data.Array.Accelerate.Trafo.Clustering.ILP.Labels + +import Prelude hiding ( pi ) -- accelerate imports import Data.Array.Accelerate.AST.LeftHandSide @@ -8,13 +12,12 @@ import Data.Array.Accelerate.AST.Operation import Data.Array.Accelerate.AST.Partitioned ( Cluster ) -- Data structures --- M.IntMap is used -import qualified Data.IntMap as M -- In this file, order very often subly does matter. -- To keep this clear, we use S.Set whenever it does not, -- and [] only when it does. It's also often efficient -- by removing duplicates. import qualified Data.Set as S +import qualified Data.IntMap as M import Data.List (foldl') @@ -30,22 +33,28 @@ import Data.List (foldl') -- We can always switch to a different ILP library -- later, the interfaces are all quite similar. import Numeric.Limp.Program hiding ( Constraint, r ) -import Numeric.Limp.Rep.Rep ( Assignment ) +import Numeric.Limp.Rep.IntDouble makeILP :: Information op -> ILP op makeILP (Info - (Graph nodes fuseEdges nofuseEdges) + (Graph nodes fuseEdges' nofuseEdges) backendconstraints backendbounds ) = combine graphILP where + -- Remove any redundant 'fusible' edges + fuseEdges = fuseEdges' S.\\ nofuseEdges + combine (Program dir fun cons bnds) = Program dir fun (cons <> backendconstraints) (bnds <> backendbounds) - n = S.size nodes + -- n is used in some of the constraints, as an upperbound on the number of clusters. + -- We wrap it in the Z newtype here for convenience at use-sites. + n :: Z IntDouble + n = Z $ S.size nodes -- _____________________________________ -- | Don't know why the objFun has to be | -- ___ | real, everything else is integral. | @@ -55,44 +64,44 @@ makeILP (Info -- Placeholder, currently maximising the number of vertical/diagonal fusions. -- In the future, maybe we want this to be backend-dependent. - objFun = foldl' (\f (i, j) -> f .+. z1 (Fused i j)) c0 (S.toList fuseEdges) + objFun = foldl' (\f (i, j) -> f .+. fused i j) c0 (S.toList fuseEdges) constraints = acyclic <> infusible -- x_ij <= pi_j - pi_i <= n*x_ij for all fusible edges acyclic = foldMap (\(i, j) -> Between - ( z1 (Fused i j) ) - ( z1 (Pi j) .-. z1 (Pi i) ) - ( z (Fused i j) (fromIntegral n) )) + ( fused i j ) + ( pi j .-. pi i ) + ( z (Fused i j) n )) fuseEdges -- pi_j - pi_i >= 1 for all infusible edges (i,j) - infusible = foldMap (\(i, j) -> z1 (Pi j) .-. z1 (Pi i) :>= c1) + infusible = foldMap (\(i, j) -> pi j .-. pi i :>= c1) nofuseEdges -- 0 <= pi_i <= n - bounds = map (\i -> lowerUpperZ 0 (Pi i) (fromIntegral n)) + bounds = map (\i -> lowerUpperZ 0 (Pi i) n) (S.toList nodes) <> -- x_ij \in {0, 1} - map (\(i, j) -> binary (Fused i j)) + map (\(i, j) -> binary $ Fused i j) (S.toList fuseEdges) - - - -- call the solver. Gets called for each ILP -solveILP :: ILP op -> LIMP Assignment op +solveILP :: ILP op -> Assignment op solveILP = undefined +-- Extract the fusion information (ordered list of clustered Labels) +interpretSolution :: Assignment op -> [S.Set Label] +interpretSolution = undefined -- "open research question" --- Each set of ints corresponds to a set of unsafeConstructions, which themselves contain a set of ints (the things they depend on). +-- Each set of ints corresponds to a set of Constructions, which themselves contain a set of ints (the things they depend on). -- Some of those ints will refer to nodes in previous clusters, others to nodes in this cluster. -- One pass over these datatypes (back-to-front) should identify the 'output type' of each cluster: which nodes are needed in later clusters? -- Then, we can construct the clusters front-to-back: -- identify the nodes that only depend on nodes outside of the cluster, they are the initials -- the `output type` indicates which nodes we will need to keep: they are all either a final node in the cluster, or get diagonally fused -- How exactly we can use this information (and a dep. graph) to construct a cluster of ver,hor,diag is not clear.. Will also depend on the exact cluster definition. -reconstruct :: Graph -> [S.Set Int] -> M.IntMap [S.Set Int] -> M.IntMap (UnsafeConstruction op) -> Exists (PreOpenAcc (Cluster op) ()) +reconstruct :: Graph -> [S.Set Int] -> M.IntMap [S.Set Int] -> M.IntMap (Construction op) -> Exists (PreOpenAcc (Cluster op) ()) reconstruct = undefined From 64aabba5ca3e16a597baac1dc495443fa2b86a0c Mon Sep 17 00:00:00 2001 From: David Date: Mon, 15 Feb 2021 14:30:08 +0100 Subject: [PATCH 027/813] unsafeCoerce is friends with TypeApplications and ScopedTypeVariables --- src/Data/Array/Accelerate/AST/Environment.hs | 2 +- src/Data/Array/Accelerate/AST/Operation.hs | 2 +- .../Array/Accelerate/Trafo/Clustering/ILP.hs | 29 +++- .../Accelerate/Trafo/Clustering/ILP/Graph.hs | 130 +++++++++--------- .../Accelerate/Trafo/Clustering/ILP/Solve.hs | 8 +- .../Accelerate/Trafo/Clustering/Stream.hs | 8 +- 6 files changed, 97 insertions(+), 82 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Environment.hs b/src/Data/Array/Accelerate/AST/Environment.hs index 8cb663dc1..00f291b5a 100644 --- a/src/Data/Array/Accelerate/AST/Environment.hs +++ b/src/Data/Array/Accelerate/AST/Environment.hs @@ -33,7 +33,7 @@ import Data.Array.Accelerate.Error import Data.Array.Accelerate.Representation.Type import Data.Array.Accelerate.Analysis.Match ((:~:)(..)) import Data.Either -import Data.List +import Data.List ( sortOn ) -- Valuation for an environment -- diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index 2e46fa942..02a84a200 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -188,7 +188,7 @@ data Uniqueness t where type Uniquenesses = TupR Uniqueness shared :: TupR s t -> Uniquenesses t -shared = mapTupR (\_ -> Shared) +shared = mapTupR (const Shared) -- | The arguments to be passed to an operation of type `t`. -- This type is represented as a cons list, separated by (->) and ending diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs index f28288a7b..98d5a76a2 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -1,5 +1,28 @@ +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE ScopedTypeVariables #-} module Data.Array.Accelerate.Trafo.Clustering.ILP where -import Data.Array.Accelerate.Trafo.Clustering.ILP.Graph () -import Data.Array.Accelerate.Trafo.Clustering.ILP.Labels () -import Data.Array.Accelerate.Trafo.Clustering.ILP.Solve () +import Data.Array.Accelerate.Trafo.Clustering.ILP.Graph + ( MakesILP, Information(Info), makeFullGraph ) +import Data.Array.Accelerate.Trafo.Clustering.ILP.Solve + ( interpretSolution, makeILP, reconstruct, solveILP ) +import Data.Array.Accelerate.AST.Partitioned + ( OperationAcc, PartitionedAcc ) + +import qualified Data.IntMap as M +import Unsafe.Coerce (unsafeCoerce) +import Data.Array.Accelerate.AST.LeftHandSide ( Exists(Exists) ) + +ilpfusion :: forall op a. MakesILP op => OperationAcc op () a -> PartitionedAcc op () a +ilpfusion acc = fusedAcc + where + (info@(Info graph _ _), infos, constrM) = makeFullGraph acc + (ilp, ilps) = (makeILP info, M.map makeILP infos) + solution = (solveILP ilp, M.map solveILP ilps) + (labelCluster,labelClusters) = interpretSolution solution + reconstructedAcc = reconstruct graph labelCluster labelClusters constrM + -- Because we lose some type information by rebuilding the AST from scratch, we use + -- unsafeCoerce here to tell GHC that the new AST has the same return type. + -- Type applications allow us to restrict this function to the return type only. + fusedAcc = case reconstructedAcc of + Exists res -> unsafeCoerce @(PartitionedAcc op () _) @(PartitionedAcc op () a) res diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs index 38e89b3e3..6e4129aa0 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE PolyKinds #-} @@ -43,10 +44,8 @@ import qualified Numeric.Limp.Program as LIMP import qualified Numeric.Limp.Rep as LIMP import Numeric.Limp.Program hiding ( Bounds, Constraint, Program, Linear, r ) import Numeric.Limp.Rep ( IntDouble ) -import Data.Array.Accelerate.AST.LeftHandSide (Exists(Exists)) import Data.Array.Accelerate.Array.Buffer import Data.Array.Accelerate.Type -import Data.Type.Equality -- | We have Int variables represented by @Variable op@, and no real variables. @@ -102,23 +101,24 @@ class MakesILP op where -- Variables needed to express backend-specific fusion rules. type BackendVar op - -- Control flow cannot be fused, so we make separate ILPs for e.g. - -- then-branch and else-branch. In the future, a possible optimisation is to - -- generate code for the awhile-condition twice: once maybe fused after the body, - -- once maybe fused after input. For now, condition and body are both treated - -- as 'foreign calls', like if-then-else. - -- The IntMap maps from a label to the corresponding ILP (only for things treated - -- as 'foreign calls', like control flow). - -- A program can result in multiple ILPs, for example, the body of an 'awhile' cannot be fused with anything outside of it. - -- you `can` encode this in the ILP, but since the solutions are independant of each other it should be much more efficient - -- to solve them separately. This avoids many 'infusible edges', and significantly reduces the search space. The extracted - -- subtree gets encoded as a sort of 'foreign call', preventing all fusion. - -- todo: maybe we can extract more commonality from this, making the class more complicated but instances smaller/easier + -- | This function only needs to do the backend-specific things, that is, things which depend on the definition of @op@. + -- That includes "BackendVar op's" and all their constraints/bounds, but also some (in)fusible edges. + -- As a conveniece, fusible edges have already been made from all (incoming) labels in the LabelArgs to the current label. + -- These can be 'strengthened' by adding a corresponding infusible edge, in which case the fusible edge will later be optimised away. mkGraph :: op args -> LabelArgs args -> Label -> Information op - -- for efficient reconstruction - -- mkMap :: PreOpenAcc (LabelledOp op) () a -> M.IntMap (UnsafeConstruction op) - +-- Control flow cannot be fused, so we make separate ILPs for e.g. +-- then-branch and else-branch. In the future, a possible optimisation is to +-- generate code for the awhile-condition twice: once maybe fused after the body, +-- once maybe fused after input. For now, condition and body are both treated +-- as 'foreign calls', like if-then-else. +-- The IntMap maps from a label to the corresponding ILP (only for things treated +-- as 'foreign calls', like control flow). +-- A program can result in multiple ILPs, for example, the body of an 'awhile' cannot be fused with anything outside of it. +-- you `can` encode this in the ILP, but since the solutions are independant of each other it should be much more efficient +-- to solve them separately. This avoids many 'infusible edges', and significantly reduces the search space. The extracted +-- subtree gets encoded as a sort of 'foreign call', preventing all fusion. TODO test with 'nested foreign functions': +-- Does the algorithm work if a while contains other Awhile or Acond nodes in its condition or body? -- TODO doublecheck much of this, it's tricky: -- in the Operation-based AST, everything is powered by side effects. @@ -142,9 +142,15 @@ class MakesILP op where -- but maybe no need to label it, if we can infer them afterwards? -- - Unit --- this function will also need to produce the 'reconstruction' lookup map, --- to ensure that the labels we generate are consistent between the lookup map --- and the graph. I'll do that Later (TM) + +makeFullGraph :: MakesILP op + => PreOpenAcc op () a + -> (Information op, M.IntMap (Information op), M.IntMap (Construction op)) +makeFullGraph acc = (info, infoM, constrM) + where ((info, infoM), _, _, _, _, constrM) = mkFullGraph acc LabelEnvNil 1 (ELabel 1) + +-- TODO: This function would be cleaner with a datatype and State monad +-- replacing the tuples and explicit passing of every argument mkFullGraph :: MakesILP op => PreOpenAcc op aenv a -> LabelEnv aenv -- for each array in the environment, @@ -159,15 +165,13 @@ mkFullGraph :: MakesILP op , S.Set Label -- source labels of currently open outgoing edges of 'a' , Label -- the next fresh label to use , ELabel -- the next fresh ELabel to use - , M.IntMap (Construction op) + -- for reconstructing the AST later. We generate this and the graph in one pass, + , M.IntMap (Construction op) -- to guarantee that the labels match. ) --- Exec case: think about the exact type of mkGraph, and adjust accordingly. --- clear responsibility on who makes the graph! - -- For all input arguments (that is, everything except `Out` buffers), we add fusible edges. If that's -- not strict enough, the backend can add infusible edges, but this is a sound --- lowerbound on fusibility: these inputs cannot be computed _after_ the op. +-- lowerbound on fusibility: these inputs may never be computed _after_ the op. -- Excessive fusible edges are filtered out before we feed them to the ILP solver. mkFullGraph (Exec op args) lenv l e = let fuseedges = S.map (, l) $ getInputArgLabels args lenv @@ -177,7 +181,7 @@ mkFullGraph (Exec op args) lenv l e = , l + 1 , e , M.singleton l $ CExe lenv args op) -mkFullGraph (Alet lhs u bnd scp) lenv l e = -- replace ticks with numbers? think of actual names for variables??? +mkFullGraph (Alet lhs u bnd scp) lenv l e = -- we throw away the uniquenessess information here, that's Future Work let (bndInfo, lenv' , lbnd, l' , e' , c ) = mkFullGraph bnd lenv l e (e'', lenv'') = addLhsLabels lhs e' lbnd lenv' (scpInfo, lenv''', lscp, l'', e''', c') = mkFullGraph scp lenv'' l' e'' @@ -229,18 +233,16 @@ mkFullGraph (Awhile u cond bdy startvars) lenv l e = let clabel = l+1 in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty , M.fromList [(clabel, cinfo), (blabel, binfo)] <> cinfoM <> binfoM) , emptyEnv, S.singleton l, l'', e'' - , M.insert l (CWHL lenv u clabel blabel startvars) c <> c') - + , M.insert l (CWhl lenv u clabel blabel startvars) c <> c') +-- | Like mkFullGraph, but for @PreOpenAfun@. mkFullGraphF :: MakesILP op => PreOpenAfun op aenv a - -> LabelEnv aenv -- for each array in the environment, - -- the source labels of the currently open outgoing edges. + -- For each array in the environment, the source labels + -> LabelEnv aenv -- of the currently open outgoing edges. -> Label -- the next fresh label to use -> ELabel -- the next fresh ELabel to use -> ( - -- S.Set Label -- incoming edges - -- , S.Set Label -- outgoing edges ( Information op, M.IntMap (Information op)) , LabelEnv aenv -- like input, but adjusted for side-effects , S.Set Label -- source labels of currently open outgoing edges of 'a' @@ -261,55 +263,49 @@ data Construction (op :: Type -> Type) where CExe :: LabelEnv env -> Args env args -> op args -> Construction op CUse :: ScalarType e -> Buffer e -> Construction op CITE :: LabelEnv env -> ExpVar env PrimBool -> Label -> Label -> Construction op - CWHL :: LabelEnv env -> Uniquenesses a -> Label -> Label -> GroundVars env a -> Construction op - --- maybe rewrite this into partial functions for each option; --- the 'ITE' one really needs to get the branches as argument, can't just try to make one like this. -construct :: forall op env'. Construction op -> LabelEnv env' -> M.IntMap (Construction op) -> Maybe (Exists (PreOpenAcc op env')) -construct construction lenv' intmap = case construction of - CExe lenv args op -> Exists . Exec op <$> reindexArgs (reindex lenv) args - CUse sctype buff -> Just . Exists $ Use sctype buff - CITE lenv cond thenL elseL -> do - thenConstruct <- M.lookup thenL intmap - Exists (thenAcc :: PreOpenAcc op env' a) <- construct thenConstruct lenv' intmap - elseConstruct <- M.lookup elseL intmap - Exists (elseAcc :: PreOpenAcc op env' b) <- construct elseConstruct lenv' intmap - newcond <- reindexVar (reindex lenv) cond - case unsafeCoerce Refl of -- convince the typechecker that the branches have the same type - (Refl :: a :~: b) -> return $ Exists $ Acond newcond thenAcc elseAcc - CWHL lenv u cndL bdyL start -> do - cndConstruct <- M.lookup cndL intmap - Exists (cndAcc :: PreOpenAfun op env' c) <- constructF cndConstruct lenv' intmap - bdyConstruct <- M.lookup bdyL intmap - Exists (bdyAcc :: PreOpenAfun op env' b) <- constructF bdyConstruct lenv' intmap - (newStart :: GroundVars env' a) <- reindexVars (reindex lenv) start - case unsafeCoerce Refl of -- convince the typechecker that the branches have the right type - (Refl :: c :~: (a -> PrimBool)) -> case unsafeCoerce Refl of - (Refl :: b :~: (a -> a)) -> return $ Exists $ Awhile u cndAcc bdyAcc newStart - where - reindex :: LabelEnv env -> ReindexPartial Maybe env env' - reindex env = mkReindexPartial env lenv' + CWhl :: LabelEnv env -> Uniquenesses a -> Label -> Label -> GroundVars env a -> Construction op + +constructExe :: LabelEnv env' -> LabelEnv env + -> Args env args -> op args + -> Maybe (PreOpenAcc op env' ()) +constructExe lenv' lenv args op = Exec op <$> reindexArgs (mkReindexPartial lenv lenv') args +constructUse :: ScalarType e -> Buffer e + -> PreOpenAcc op env (Buffer e) +constructUse = Use +constructITE :: LabelEnv env' -> LabelEnv env + -> ExpVar env PrimBool -> PreOpenAcc op env' a -> PreOpenAcc op env' a + -> Maybe (PreOpenAcc op env' a) +constructITE lenv' lenv cond tbranch fbranch = Acond <$> reindexVar (mkReindexPartial lenv lenv') cond + <*> pure tbranch + <*> pure fbranch +constructWhl :: LabelEnv env' -> LabelEnv env + -> Uniquenesses a -> PreOpenAfun op env' (a -> PrimBool) -> PreOpenAfun op env' (a -> a) -> GroundVars env a + -> Maybe (PreOpenAcc op env' a) +constructWhl lenv' lenv u cond body start = Awhile u cond body <$> reindexVars (mkReindexPartial lenv lenv') start --- constructF :: Construction op -> -- | Makes a ReindexPartial, which allows us to transform indices in @env@ into indices in @env'@. -- We cannot guarantee the index is present in env', so we use the partiality of ReindexPartial by -- returning a Maybe. Uses unsafeCoerce to re-introduce type information implied by the ELabels. mkReindexPartial :: LabelEnv env -> LabelEnv env' -> ReindexPartial Maybe env env' -mkReindexPartial lenv lenv' = \idx -> go lenv' $ getELabelIdx idx lenv +mkReindexPartial lenv lenv' idx = go lenv' where - go :: LabelEnv e -> ELabel -> Maybe (Idx e a) - go ((e,_) :>>>: env) e' + -- The ELabel in the original environment + e = getELabelIdx idx lenv + go :: forall e a. LabelEnv e -> Maybe (Idx e a) + go ((e',_) :>>>: env) -- e' is the ELabel in the new environment -- Here we have to convince GHC that the top element in the environment -- really does have the same type as the one we were searching for. -- Some literature does this stuff too: 'effect handlers in haskell, evidently' -- and 'a monadic framework for delimited continuations' come to mind. -- Basically: standard procedure if you're using Ints as a unique identifier -- and want to re-introduce type information. :) - | e == e' = Just $ unsafeCoerce ZeroIdx - | otherwise = SuccIdx <$> go env e' + -- Type applications allow us to restrict unsafeCoerce to the return type. + | e == e' = Just $ unsafeCoerce @(Idx e _) @(Idx e a) ZeroIdx + -- Recurse if we did not find e' yet. + | otherwise = SuccIdx <$> go env -- If we hit the end, the Elabel was not present in the environment. -- That probably means we'll error out at a later point, but maybe there is -- a case where we try multiple options? No need to worry about it here. - go LabelEnvNil _ = Nothing + go LabelEnvNil = Nothing diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs index 69171ad89..fd80cb45a 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs @@ -92,16 +92,16 @@ solveILP :: ILP op -> Assignment op solveILP = undefined -- Extract the fusion information (ordered list of clustered Labels) -interpretSolution :: Assignment op -> [S.Set Label] +interpretSolution :: (Assignment op, M.IntMap (Assignment op)) -> ([S.Set Label], M.IntMap [S.Set Label]) interpretSolution = undefined -- "open research question" --- Each set of ints corresponds to a set of Constructions, which themselves contain a set of ints (the things they depend on). --- Some of those ints will refer to nodes in previous clusters, others to nodes in this cluster. +-- -- Each set of ints corresponds to a set of Constructions, which themselves contain a set of ints (the things they depend on). +-- -- Some of those ints will refer to nodes in previous clusters, others to nodes in this cluster. -- One pass over these datatypes (back-to-front) should identify the 'output type' of each cluster: which nodes are needed in later clusters? -- Then, we can construct the clusters front-to-back: -- identify the nodes that only depend on nodes outside of the cluster, they are the initials -- the `output type` indicates which nodes we will need to keep: they are all either a final node in the cluster, or get diagonally fused -- How exactly we can use this information (and a dep. graph) to construct a cluster of ver,hor,diag is not clear.. Will also depend on the exact cluster definition. -reconstruct :: Graph -> [S.Set Int] -> M.IntMap [S.Set Int] -> M.IntMap (Construction op) -> Exists (PreOpenAcc (Cluster op) ()) +reconstruct :: Graph -> [S.Set Label] -> M.IntMap [S.Set Label] -> M.IntMap (Construction op) -> Exists (PreOpenAcc (Cluster op) ()) reconstruct = undefined diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/Stream.hs b/src/Data/Array/Accelerate/Trafo/Clustering/Stream.hs index 7d7a72a67..ef3d44a86 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/Stream.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/Stream.hs @@ -1,13 +1,9 @@ -module Data.Array.Accelerate.Trafo.Clustering.Stream - where +module Data.Array.Accelerate.Trafo.Clustering.Stream where import Data.Array.Accelerate.AST.Partitioned -import Data.Array.Accelerate.AST.Operation (OperationAcc) -- Emulate the old 'delayed arrays' approach to fusion -streamfusion :: OperationAcc op benv a -> PartitionedAcc op benv a +streamfusion :: OperationAcc op () a -> PartitionedAcc op () a streamfusion = undefined - - From f414950de807784412de26d5c8fe24c0f288c416 Mon Sep 17 00:00:00 2001 From: David Date: Mon, 15 Feb 2021 18:01:53 +0100 Subject: [PATCH 028/813] start of rewrite --- .../Array/Accelerate/Trafo/Clustering/ILP.hs | 4 +- .../Accelerate/Trafo/Clustering/ILP/Graph.hs | 338 +++++++++++------- 2 files changed, 219 insertions(+), 123 deletions(-) diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs index 98d5a76a2..b60af1573 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs @@ -25,4 +25,6 @@ ilpfusion acc = fusedAcc -- unsafeCoerce here to tell GHC that the new AST has the same return type. -- Type applications allow us to restrict this function to the return type only. fusedAcc = case reconstructedAcc of - Exists res -> unsafeCoerce @(PartitionedAcc op () _) @(PartitionedAcc op () a) res + Exists res -> unsafeCoerce @(PartitionedAcc op () _) + @(PartitionedAcc op () a) + res diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs index 6e4129aa0..730a79c9d 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE BlockArguments #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE LambdaCase #-} @@ -20,9 +21,11 @@ import Data.Array.Accelerate.AST.Operation -- Data structures -- In this file, order very often subly does matter. --- To keep this clear, we use S.Set whenever it does not, +-- To keep this clear, we use Set whenever it does not, -- and [] only when it does. It's also often efficient -- by removing duplicates. +import Data.Set (Set) +import Data.IntMap (IntMap) import qualified Data.Set as S import qualified Data.IntMap as M @@ -46,6 +49,7 @@ import Numeric.Limp.Program hiding ( Bounds, Constraint, Program, Linear, r ) import Numeric.Limp.Rep ( IntDouble ) import Data.Array.Accelerate.Array.Buffer import Data.Array.Accelerate.Type +import Control.Monad.State -- | We have Int variables represented by @Variable op@, and no real variables. @@ -53,20 +57,20 @@ import Data.Array.Accelerate.Type type LIMP datatyp op = datatyp (Variable op) () IntDouble type LIMP' datatyp op a = datatyp (Variable op) () IntDouble a -type Assignment op = LIMP LIMP.Assignment op -type Bounds op = LIMP LIMP.Bounds op -type Constraint op = LIMP LIMP.Constraint op -type ILP op = LIMP LIMP.Program op -type Linear op res = LIMP' LIMP.Linear op res +type Assignment op = LIMP LIMP.Assignment op +type Bounds op = [LIMP LIMP.Bounds op] +type Constraint op = LIMP LIMP.Constraint op +type ILP op = LIMP LIMP.Program op +type Linear op res = LIMP' LIMP.Linear op res -- | Directed edge (a,b): `b` depends on `a`. type Edge = (Label, Label) data Graph = Graph - { graphNodes :: S.Set Label - , fusibleEdges :: S.Set Edge -- Can be fused over, otherwise `a` before `b`. - , infusibleEdges :: S.Set Edge -- Can't be fused over, always `a` before `b`. + { graphNodes :: Set Label + , fusibleEdges :: Set Edge -- Can be fused over, otherwise `a` before `b`. + , infusibleEdges :: Set Edge -- Can't be fused over, always `a` before `b`. } instance Semigroup Graph where Graph n f i <> Graph n' f' i' = Graph (n <> n') (f <> f') (i <> i') @@ -75,9 +79,9 @@ instance Monoid Graph where -- The graph is the 'common part' of the ILP, -- each backend has to encode their own constraints --- describing the fusion rules. The bounds is a [] instead of S.Set +-- describing the fusion rules. The bounds is a [] instead of Set -- for practical reasons (no Ord instance, LIMP expects a list) only. -data Information op = Info Graph (Constraint op) [Bounds op] +data Information op = Info Graph (Constraint op) (Bounds op) instance Semigroup (Information op) where Info g c b <> Info g' c' b' = Info (g <> g') (c <> c') (b <> b') instance Monoid (Information op) where @@ -145,116 +149,204 @@ class MakesILP op where makeFullGraph :: MakesILP op => PreOpenAcc op () a - -> (Information op, M.IntMap (Information op), M.IntMap (Construction op)) -makeFullGraph acc = (info, infoM, constrM) - where ((info, infoM), _, _, _, _, constrM) = mkFullGraph acc LabelEnvNil 1 (ELabel 1) - --- TODO: This function would be cleaner with a datatype and State monad --- replacing the tuples and explicit passing of every argument -mkFullGraph :: MakesILP op - => PreOpenAcc op aenv a - -> LabelEnv aenv -- for each array in the environment, - -- the source labels of the currently open outgoing edges. - -> Label -- the next fresh label to use - -> ELabel -- the next fresh ELabel to use - -> ( - -- S.Set Label -- incoming edges - -- , S.Set Label -- outgoing edges - ( Information op, M.IntMap (Information op)) - , LabelEnv aenv -- like input, but adjusted for side-effects - , S.Set Label -- source labels of currently open outgoing edges of 'a' - , Label -- the next fresh label to use - , ELabel -- the next fresh ELabel to use - -- for reconstructing the AST later. We generate this and the graph in one pass, - , M.IntMap (Construction op) -- to guarantee that the labels match. - ) - --- For all input arguments (that is, everything except `Out` buffers), we add fusible edges. If that's --- not strict enough, the backend can add infusible edges, but this is a sound --- lowerbound on fusibility: these inputs may never be computed _after_ the op. --- Excessive fusible edges are filtered out before we feed them to the ILP solver. -mkFullGraph (Exec op args) lenv l e = - let fuseedges = S.map (, l) $ getInputArgLabels args lenv - in ( (mkGraph op (getLabelArgs args lenv) l <> Info (Graph (S.singleton l) fuseedges mempty) mempty mempty, mempty) - , updateLabelEnv args lenv l -- add labels for `Out` and `Mut` args. - , mempty - , l + 1 - , e - , M.singleton l $ CExe lenv args op) -mkFullGraph (Alet lhs u bnd scp) lenv l e = -- we throw away the uniquenessess information here, that's Future Work - let (bndInfo, lenv' , lbnd, l' , e' , c ) = mkFullGraph bnd lenv l e - (e'', lenv'') = addLhsLabels lhs e' lbnd lenv' - (scpInfo, lenv''', lscp, l'', e''', c') = mkFullGraph scp lenv'' l' e'' - in (bndInfo <> scpInfo - , weakLhsEnv lhs lenv''' - , lscp - , l'' - , e''' - , c <> c') -mkFullGraph (Return vars) lenv l e = ( (mempty, mempty), lenv, getLabelsTup vars lenv, l, e, mempty) -mkFullGraph (Compute expr) lenv l e = ( (mempty, mempty), lenv, getLabelsExp expr lenv, l, e, mempty) -mkFullGraph (Alloc shr scty shvar) lenv l e = ( (mempty, mempty), lenv, mempty , l, e, mempty) -- unless we can't infer alloc... -mkFullGraph (Use sctype buff) lenv l e = - ( (Info (Graph (S.singleton l) mempty mempty) mempty mempty, mempty) - , lenv, S.singleton l, l+1, e - , M.singleton l $ CUse sctype buff) --- gets a variable from the env, puts it in a singleton buffer. --- Here I'm assuming this fuses nicely, and doesn't even need a new label --- (reuse the one that belongs to the variable). Might need to add a label --- to avoid obfuscating the AST though. Change when needed. -mkFullGraph (Unit var) lenv l e = ( (mempty, mempty), lenv, getLabelsVar var lenv, l, e, mempty) - --- NOTE: We explicitly add infusible edges from every label in `lenv` to this Acond. --- This makes the previous let-bindings strict: even if some result is only used in one --- branch, we now require it to be present before we evaluate the condition. --- I think this is safe: if a result is only used in one branch, it should be let-bound --- within that branch already. Note that this also means we ignore the contents of 'cond' for the graph. --- We also add edges from the Acond to the true-branch, and from the true-branch to the false-branch? --- TODO check if this is right/needed/if passing even more fresh labels down is correct. -mkFullGraph (Acond cond tbranch fbranch) lenv l e = let tlabel = l+1 - flabel = l+2 - emptyEnv = emptyLabelEnv lenv - ( (tinfo, tinfoM), _, _, l' , e' , c ) = mkFullGraph tbranch emptyEnv (l+3) e - ( (finfo, finfoM), _, _, l'', e'', c') = mkFullGraph fbranch emptyEnv l' e' - nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, tlabel), (tlabel, flabel)] - in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty - , M.fromList [(tlabel, tinfo), (flabel, finfo)] <> tinfoM <> finfoM) - , emptyEnv, S.singleton l, l'', e'' - , M.insert l (CITE lenv cond tlabel flabel) c <> c') --- like Acond. The biggest difference is that 'cond' is a function instead of an expression here. --- In fact, for the graph, we use 'startvars' much like we used 'cond' in Acond, and we use --- 'cond' and 'bdy' much like we used 'tbranch' and 'fbranch'. -mkFullGraph (Awhile u cond bdy startvars) lenv l e = let clabel = l+1 - blabel = 1+2 - emptyEnv = emptyLabelEnv lenv - ( (cinfo, cinfoM), _, _, l' , e' , c ) = mkFullGraphF cond emptyEnv (l+3) e - ( (binfo, binfoM), _, _, l'', e'', c') = mkFullGraphF bdy emptyEnv l' e' - nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, clabel), (clabel, blabel)] - in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty - , M.fromList [(clabel, cinfo), (blabel, binfo)] <> cinfoM <> binfoM) - , emptyEnv, S.singleton l, l'', e'' - , M.insert l (CWhl lenv u clabel blabel startvars) c <> c') - --- | Like mkFullGraph, but for @PreOpenAfun@. -mkFullGraphF :: MakesILP op - => PreOpenAfun op aenv a - -- For each array in the environment, the source labels - -> LabelEnv aenv -- of the currently open outgoing edges. - -> Label -- the next fresh label to use - -> ELabel -- the next fresh ELabel to use - -> ( - ( Information op, M.IntMap (Information op)) - , LabelEnv aenv -- like input, but adjusted for side-effects - , S.Set Label -- source labels of currently open outgoing edges of 'a' - , Label -- the next fresh label to use - , ELabel -- the next fresh ELabel to use - , M.IntMap (Construction op) - ) -mkFullGraphF = \case - Abody acc -> mkFullGraph acc - Alam lhs f -> \lenv l e -> let (e', lenv') = addLhsLabels lhs e mempty lenv -- it's a function, so we can fill the extra environment with mempties - ((info, infoM), lenv'', lset, l', e'', c) = mkFullGraphF f lenv' l e' - in ((info, infoM), weakLhsEnv lhs lenv'', lset, l', e'', c) + -> (Information op, IntMap (Information op), IntMap (Construction op)) +makeFullGraph = undefined +-- makeFullGraph acc = (info, infoM, constrM) +-- where ((info, infoM), _, _, _, _, constrM) = mkFullGraph acc LabelEnvNil 1 (ELabel 1) + +data FullGraphState env = FGState + { lenv :: LabelEnv env -- source of open outgoing edges for env + , freshL :: Label -- next fresh counter + , freshE :: ELabel -- next fresh counter + } +getL :: State (FullGraphState env) Label +getL = modify (\fgs -> fgs {freshL = 1 + freshL fgs}) >> gets freshL +getE :: State (FullGraphState env) ELabel +getE = modify (\fgs -> fgs {freshE = 1 + freshE fgs}) >> gets freshE + +data FullGraphResult op = FGRes + { info :: Information op + , infoM :: IntMap (Information op) + , lset :: Set Label -- source of open outgoing edges for result + , constr :: IntMap (Construction op) + } + +mkFullGraph :: MakesILP op => PreOpenAcc op env a -> State (FullGraphState env) (FullGraphResult op) +mkFullGraph (Exec op args) = do + l <- getL + env <- gets lenv + modify (\stt -> stt{lenv = updateLabelEnv args (lenv stt) l}) + let fuseedges = S.map (, l) $ getInputArgLabels args env + return $ FGRes (mkGraph op (getLabelArgs args env) l <> Info (Graph (S.singleton l) fuseedges mempty) mempty mempty) + mempty + mempty + (M.singleton l $ CExe env args op) + +-- we throw away the uniquenessess information here, that's Future Work.. +-- probably need to re-infer it after fusion anyway, until we incorporate in-place into ILP +mkFullGraph (Alet lhs u bnd scp) = do + e <- getE + env <- gets lenv + FGRes bndInfo bndInfoM bndL bndConstr <- mkFullGraph bnd + let (e', env') = addLhsLabels lhs e bndL env + modify (\stt -> stt{freshE = e'}) + stt <- get -- because we change the type of the state here, this part is ugly + let (FGRes scpInfo scpInfoM scpL scpConstr, scpState) = runState (mkFullGraph scp) $ stt{lenv = env'} + put (scpState{lenv = weakLhsEnv lhs (lenv scpState)}) + return $ FGRes (bndInfo <> scpInfo) (bndInfoM <> scpInfoM) scpL (bndConstr <> scpConstr) + + +-- mkFullGraph (Return vars) lenv l e = ( (mempty, mempty), lenv, getLabelsTup vars lenv, l, e, mempty) +-- mkFullGraph (Compute expr) lenv l e = ( (mempty, mempty), lenv, getLabelsExp expr lenv, l, e, mempty) +-- mkFullGraph (Alloc shr scty shvar) lenv l e = ( (mempty, mempty), lenv, mempty , l, e, mempty) -- unless we can't infer alloc... +-- mkFullGraph (Use sctype buff) lenv l e = +-- ( (Info (Graph (S.singleton l) mempty mempty) mempty mempty, mempty) +-- , lenv, S.singleton l, l+1, e +-- , M.singleton l $ CUse sctype buff) +-- -- gets a variable from the env, puts it in a singleton buffer. +-- -- Here I'm assuming this fuses nicely, and doesn't even need a new label +-- -- (reuse the one that belongs to the variable). Might need to add a label +-- -- to avoid obfuscating the AST though. Change when needed. +-- mkFullGraph (Unit var) lenv l e = ( (mempty, mempty), lenv, getLabelsVar var lenv, l, e, mempty) + +-- -- NOTE: We explicitly add infusible edges from every label in `lenv` to this Acond. +-- -- This makes the previous let-bindings strict: even if some result is only used in one +-- -- branch, we now require it to be present before we evaluate the condition. +-- -- I think this is safe: if a result is only used in one branch, it should be let-bound +-- -- within that branch already. Note that this also means we ignore the contents of 'cond' for the graph. +-- -- We also add edges from the Acond to the true-branch, and from the true-branch to the false-branch? +-- -- TODO check if this is right/needed/if passing even more fresh labels down is correct. +-- mkFullGraph (Acond cond tbranch fbranch) lenv l e = let tlabel = l+1 +-- flabel = l+2 +-- emptyEnv = emptyLabelEnv lenv +-- ( (tinfo, tinfoM), _, _, l' , e' , c ) = mkFullGraph tbranch emptyEnv (l+3) e +-- ( (finfo, finfoM), _, _, l'', e'', c') = mkFullGraph fbranch emptyEnv l' e' +-- nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, tlabel), (tlabel, flabel)] +-- in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty +-- , M.fromList [(tlabel, tinfo), (flabel, finfo)] <> tinfoM <> finfoM) +-- , emptyEnv, S.singleton l, l'', e'' +-- , M.insert l (CITE lenv cond tlabel flabel) c <> c') +-- -- like Acond. The biggest difference is that 'cond' is a function instead of an expression here. +-- -- In fact, for the graph, we use 'startvars' much like we used 'cond' in Acond, and we use +-- -- 'cond' and 'bdy' much like we used 'tbranch' and 'fbranch'. +-- mkFullGraph (Awhile u cond bdy startvars) lenv l e = let clabel = l+1 +-- blabel = 1+2 +-- emptyEnv = emptyLabelEnv lenv +-- ( (cinfo, cinfoM), _, _, l' , e' , c ) = mkFullGraphF cond emptyEnv (l+3) e +-- ( (binfo, binfoM), _, _, l'', e'', c') = mkFullGraphF bdy emptyEnv l' e' +-- nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, clabel), (clabel, blabel)] +-- in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty +-- , M.fromList [(clabel, cinfo), (blabel, binfo)] <> cinfoM <> binfoM) +-- , emptyEnv, S.singleton l, l'', e'' +-- , M.insert l (CWhl lenv u clabel blabel startvars) c <> c') + + +mkFullGraph _ = undefined + +-- -- TODO: This function would be cleaner with a datatype and State monad +-- -- replacing the tuples and explicit passing of every argument +-- mkFullGraph :: MakesILP op +-- => PreOpenAcc op aenv a +-- -> LabelEnv aenv -- for each array in the environment, +-- -- the source labels of the currently open outgoing edges. +-- -> Label -- the next fresh label to use +-- -> ELabel -- the next fresh ELabel to use +-- -> ( +-- ( Information op, IntMap (Information op)) +-- , LabelEnv aenv -- like input, but adjusted for side-effects +-- , Set Label -- source labels of currently open outgoing edges of 'a' +-- , Label -- the next fresh label to use +-- , ELabel -- the next fresh ELabel to use +-- -- for reconstructing the AST later. We generate this and the graph in one pass, +-- , IntMap (Construction op) -- to guarantee that the labels match. +-- ) + +-- -- For all input arguments (that is, everything except `Out` buffers), we add fusible edges. If that's +-- -- not strict enough, the backend can add infusible edges, but this is a sound +-- -- lowerbound on fusibility: these inputs may never be computed _after_ the op. +-- -- Excessive fusible edges are filtered out before we feed them to the ILP solver. +-- foo (Exec op args) lenv l e = +-- let fuseedges = S.map (, l) $ getInputArgLabels args lenv +-- in ( (mkGraph op (getLabelArgs args lenv) l <> Info (Graph (S.singleton l) fuseedges mempty) mempty mempty, mempty) +-- , updateLabelEnv args lenv l -- add labels for `Out` and `Mut` args. +-- , mempty +-- , l + 1 +-- , e +-- , M.singleton l $ CExe lenv args op) +-- mkFullGraph (Alet lhs u bnd scp) lenv l e = -- we throw away the uniquenessess information here, that's Future Work +-- let (bndInfo, lenv' , lbnd, l' , e' , c ) = mkFullGraph bnd lenv l e +-- (e'', lenv'') = addLhsLabels lhs e' lbnd lenv' +-- (scpInfo, lenv''', lscp, l'', e''', c') = mkFullGraph scp lenv'' l' e'' +-- in (bndInfo <> scpInfo +-- , weakLhsEnv lhs lenv''' +-- , lscp +-- , l'' +-- , e''' +-- , c <> c') +-- mkFullGraph (Return vars) lenv l e = ( (mempty, mempty), lenv, getLabelsTup vars lenv, l, e, mempty) +-- mkFullGraph (Compute expr) lenv l e = ( (mempty, mempty), lenv, getLabelsExp expr lenv, l, e, mempty) +-- mkFullGraph (Alloc shr scty shvar) lenv l e = ( (mempty, mempty), lenv, mempty , l, e, mempty) -- unless we can't infer alloc... +-- mkFullGraph (Use sctype buff) lenv l e = +-- ( (Info (Graph (S.singleton l) mempty mempty) mempty mempty, mempty) +-- , lenv, S.singleton l, l+1, e +-- , M.singleton l $ CUse sctype buff) +-- -- gets a variable from the env, puts it in a singleton buffer. +-- -- Here I'm assuming this fuses nicely, and doesn't even need a new label +-- -- (reuse the one that belongs to the variable). Might need to add a label +-- -- to avoid obfuscating the AST though. Change when needed. +-- mkFullGraph (Unit var) lenv l e = ( (mempty, mempty), lenv, getLabelsVar var lenv, l, e, mempty) + +-- -- NOTE: We explicitly add infusible edges from every label in `lenv` to this Acond. +-- -- This makes the previous let-bindings strict: even if some result is only used in one +-- -- branch, we now require it to be present before we evaluate the condition. +-- -- I think this is safe: if a result is only used in one branch, it should be let-bound +-- -- within that branch already. Note that this also means we ignore the contents of 'cond' for the graph. +-- -- We also add edges from the Acond to the true-branch, and from the true-branch to the false-branch? +-- -- TODO check if this is right/needed/if passing even more fresh labels down is correct. +-- mkFullGraph (Acond cond tbranch fbranch) lenv l e = let tlabel = l+1 +-- flabel = l+2 +-- emptyEnv = emptyLabelEnv lenv +-- ( (tinfo, tinfoM), _, _, l' , e' , c ) = mkFullGraph tbranch emptyEnv (l+3) e +-- ( (finfo, finfoM), _, _, l'', e'', c') = mkFullGraph fbranch emptyEnv l' e' +-- nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, tlabel), (tlabel, flabel)] +-- in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty +-- , M.fromList [(tlabel, tinfo), (flabel, finfo)] <> tinfoM <> finfoM) +-- , emptyEnv, S.singleton l, l'', e'' +-- , M.insert l (CITE lenv cond tlabel flabel) c <> c') +-- -- like Acond. The biggest difference is that 'cond' is a function instead of an expression here. +-- -- In fact, for the graph, we use 'startvars' much like we used 'cond' in Acond, and we use +-- -- 'cond' and 'bdy' much like we used 'tbranch' and 'fbranch'. +-- mkFullGraph (Awhile u cond bdy startvars) lenv l e = let clabel = l+1 +-- blabel = 1+2 +-- emptyEnv = emptyLabelEnv lenv +-- ( (cinfo, cinfoM), _, _, l' , e' , c ) = mkFullGraphF cond emptyEnv (l+3) e +-- ( (binfo, binfoM), _, _, l'', e'', c') = mkFullGraphF bdy emptyEnv l' e' +-- nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, clabel), (clabel, blabel)] +-- in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty +-- , M.fromList [(clabel, cinfo), (blabel, binfo)] <> cinfoM <> binfoM) +-- , emptyEnv, S.singleton l, l'', e'' +-- , M.insert l (CWhl lenv u clabel blabel startvars) c <> c') + +-- -- | Like mkFullGraph, but for @PreOpenAfun@. +-- mkFullGraphF :: MakesILP op +-- => PreOpenAfun op aenv a +-- -- For each array in the environment, the source labels +-- -> LabelEnv aenv -- of the currently open outgoing edges. +-- -> Label -- the next fresh label to use +-- -> ELabel -- the next fresh ELabel to use +-- -> ( +-- ( Information op, IntMap (Information op)) +-- , LabelEnv aenv -- like input, but adjusted for side-effects +-- , Set Label -- source labels of currently open outgoing edges of 'a' +-- , Label -- the next fresh label to use +-- , ELabel -- the next fresh ELabel to use +-- , IntMap (Construction op) +-- ) +-- mkFullGraphF = \case +-- Abody acc -> mkFullGraph acc +-- Alam lhs f -> \lenv l e -> let (e', lenv') = addLhsLabels lhs e mempty lenv -- it's a function, so we can fill the extra environment with mempties +-- ((info, infoM), lenv'', lset, l', e'', c) = mkFullGraphF f lenv' l e' +-- in ((info, infoM), weakLhsEnv lhs lenv'', lset, l', e'', c) -- | Information to construct AST nodes. Generally, constructors contain -- both actual information, and a LabelEnv of the original environment @@ -302,7 +394,9 @@ mkReindexPartial lenv lenv' idx = go lenv' -- Basically: standard procedure if you're using Ints as a unique identifier -- and want to re-introduce type information. :) -- Type applications allow us to restrict unsafeCoerce to the return type. - | e == e' = Just $ unsafeCoerce @(Idx e _) @(Idx e a) ZeroIdx + | e == e' = Just $ unsafeCoerce @(Idx e _) + @(Idx e a) + ZeroIdx -- Recurse if we did not find e' yet. | otherwise = SuccIdx <$> go env -- If we hit the end, the Elabel was not present in the environment. From a502352b51c1cb6aa827a47bddd247e715af7919 Mon Sep 17 00:00:00 2001 From: David Date: Tue, 16 Feb 2021 13:19:02 +0100 Subject: [PATCH 029/813] refactor of mkFullGraph --- .../Accelerate/Trafo/Clustering/ILP/Graph.hs | 328 +++++++----------- .../Accelerate/Trafo/Clustering/ILP/Solve.hs | 6 +- 2 files changed, 135 insertions(+), 199 deletions(-) diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs index 730a79c9d..7ff588555 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs @@ -81,7 +81,11 @@ instance Monoid Graph where -- each backend has to encode their own constraints -- describing the fusion rules. The bounds is a [] instead of Set -- for practical reasons (no Ord instance, LIMP expects a list) only. -data Information op = Info Graph (Constraint op) (Bounds op) +data Information op = Info + { graph :: Graph + , constr :: Constraint op + , bounds :: Bounds op + } instance Semigroup (Information op) where Info g c b <> Info g' c' b' = Info (g <> g') (c <> c') (b <> b') instance Monoid (Information op) where @@ -124,229 +128,161 @@ class MakesILP op where -- subtree gets encoded as a sort of 'foreign call', preventing all fusion. TODO test with 'nested foreign functions': -- Does the algorithm work if a while contains other Awhile or Acond nodes in its condition or body? --- TODO doublecheck much of this, it's tricky: --- in the Operation-based AST, everything is powered by side effects. --- this makes a full-program analysis like this much more difficult, + +-- In the Operation-based AST, everything is powered by side effects. +-- This makes a full-program analysis like this much more difficult, -- luckily the Args give us all the information we really require. -- For each node, we get the set of incoming edges and the set -- of outgoing edges. Let-bindings are easy, but the array-level -- control flow (acond and awhile) compensate: their bodies form separate -- graphs. -- We can practically ignore 'Return' nodes. --- let bindings are more tricky, because of the side effects. Often, +-- Let bindings are more tricky, because of the side effects. Often, -- a let will not add to the environment but instead mutate it. --- I'm still not convinced 'Compute' nodes can even be used --- things with labels include: --- - Control flow (a label for each branch, treated as a separate ILP) (acond & awhile) --- - Exec --- - Use --- - Alloc? Difficult case: if you include it, are the edges fusible? Do we --- need to include a binary in the ILP describing whether the alloc is fused away? --- probably yes, and then the edges are infusible if they exist --- but maybe no need to label it, if we can infer them afterwards? --- - Unit makeFullGraph :: MakesILP op => PreOpenAcc op () a -> (Information op, IntMap (Information op), IntMap (Construction op)) -makeFullGraph = undefined --- makeFullGraph acc = (info, infoM, constrM) --- where ((info, infoM), _, _, _, _, constrM) = mkFullGraph acc LabelEnvNil 1 (ELabel 1) +makeFullGraph acc = (i, iM, constrM) + where (FGRes i iM _ constrM, _) = runState (mkFullGraph acc) $ FGState LabelEnvNil 1 1 data FullGraphState env = FGState - { lenv :: LabelEnv env -- source of open outgoing edges for env + { lenv :: LabelEnv env -- sources of open outgoing edges for env , freshL :: Label -- next fresh counter , freshE :: ELabel -- next fresh counter } getL :: State (FullGraphState env) Label -getL = modify (\fgs -> fgs {freshL = 1 + freshL fgs}) >> gets freshL +getL = do + l <- gets freshL + modify (\fgs -> fgs {freshL = 1 + freshL fgs}) + return l getE :: State (FullGraphState env) ELabel -getE = modify (\fgs -> fgs {freshE = 1 + freshE fgs}) >> gets freshE - +getE = do + e <- gets freshE + modify (\fgs -> fgs {freshE = 1 + freshE fgs}) + return e +putE :: ELabel -> State (FullGraphState env) () +putE e = modify $ \stt -> stt{freshE = e} +putEnv :: LabelEnv env -> State (FullGraphState env) () +putEnv env = modify $ \stt -> stt{lenv = env} data FullGraphResult op = FGRes - { info :: Information op - , infoM :: IntMap (Information op) - , lset :: Set Label -- source of open outgoing edges for result - , constr :: IntMap (Construction op) + { info :: Information op + , infoM :: IntMap (Information op) + , lset :: Set Label -- sources of open outgoing edges for result + , construc :: IntMap (Construction op) } +instance Semigroup (FullGraphResult op) where + FGRes a b c d <> FGRes e f g h = FGRes (a <> e) (b <> f) (c <> g) (d <> h) +instance Monoid (FullGraphResult op) where mempty = FGRes mempty mempty mempty mempty mkFullGraph :: MakesILP op => PreOpenAcc op env a -> State (FullGraphState env) (FullGraphResult op) mkFullGraph (Exec op args) = do l <- getL env <- gets lenv - modify (\stt -> stt{lenv = updateLabelEnv args (lenv stt) l}) + putEnv $ updateLabelEnv args env l let fuseedges = S.map (, l) $ getInputArgLabels args env - return $ FGRes (mkGraph op (getLabelArgs args env) l <> Info (Graph (S.singleton l) fuseedges mempty) mempty mempty) + return $ FGRes (mkGraph op (getLabelArgs args env) l <> mempty{graph = Graph (S.singleton l) fuseedges mempty}) mempty mempty (M.singleton l $ CExe env args op) --- we throw away the uniquenessess information here, that's Future Work.. --- probably need to re-infer it after fusion anyway, until we incorporate in-place into ILP -mkFullGraph (Alet lhs u bnd scp) = do +-- We throw away the uniquenessess information here, that's Future Work.. +-- Probably need to re-infer it after fusion anyway, until we incorporate in-place into ILP +mkFullGraph (Alet lhs _ bnd scp) = do e <- getE env <- gets lenv - FGRes bndInfo bndInfoM bndL bndConstr <- mkFullGraph bnd + bndRes@(FGRes _ _ bndL _) <- mkFullGraph bnd let (e', env') = addLhsLabels lhs e bndL env - modify (\stt -> stt{freshE = e'}) - stt <- get -- because we change the type of the state here, this part is ugly - let (FGRes scpInfo scpInfoM scpL scpConstr, scpState) = runState (mkFullGraph scp) $ stt{lenv = env'} + putE e' + -- Because the type of the state is different in the 'scope', we explicitly wrap/unwrap the State monad + stt <- get + let (scpRes@(FGRes _ _ scpL _), scpState) = runState (mkFullGraph scp) stt{lenv = env'} put (scpState{lenv = weakLhsEnv lhs (lenv scpState)}) - return $ FGRes (bndInfo <> scpInfo) (bndInfoM <> scpInfoM) scpL (bndConstr <> scpConstr) - - --- mkFullGraph (Return vars) lenv l e = ( (mempty, mempty), lenv, getLabelsTup vars lenv, l, e, mempty) --- mkFullGraph (Compute expr) lenv l e = ( (mempty, mempty), lenv, getLabelsExp expr lenv, l, e, mempty) --- mkFullGraph (Alloc shr scty shvar) lenv l e = ( (mempty, mempty), lenv, mempty , l, e, mempty) -- unless we can't infer alloc... --- mkFullGraph (Use sctype buff) lenv l e = --- ( (Info (Graph (S.singleton l) mempty mempty) mempty mempty, mempty) --- , lenv, S.singleton l, l+1, e --- , M.singleton l $ CUse sctype buff) --- -- gets a variable from the env, puts it in a singleton buffer. --- -- Here I'm assuming this fuses nicely, and doesn't even need a new label --- -- (reuse the one that belongs to the variable). Might need to add a label --- -- to avoid obfuscating the AST though. Change when needed. --- mkFullGraph (Unit var) lenv l e = ( (mempty, mempty), lenv, getLabelsVar var lenv, l, e, mempty) - --- -- NOTE: We explicitly add infusible edges from every label in `lenv` to this Acond. --- -- This makes the previous let-bindings strict: even if some result is only used in one --- -- branch, we now require it to be present before we evaluate the condition. --- -- I think this is safe: if a result is only used in one branch, it should be let-bound --- -- within that branch already. Note that this also means we ignore the contents of 'cond' for the graph. --- -- We also add edges from the Acond to the true-branch, and from the true-branch to the false-branch? --- -- TODO check if this is right/needed/if passing even more fresh labels down is correct. --- mkFullGraph (Acond cond tbranch fbranch) lenv l e = let tlabel = l+1 --- flabel = l+2 --- emptyEnv = emptyLabelEnv lenv --- ( (tinfo, tinfoM), _, _, l' , e' , c ) = mkFullGraph tbranch emptyEnv (l+3) e --- ( (finfo, finfoM), _, _, l'', e'', c') = mkFullGraph fbranch emptyEnv l' e' --- nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, tlabel), (tlabel, flabel)] --- in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty --- , M.fromList [(tlabel, tinfo), (flabel, finfo)] <> tinfoM <> finfoM) --- , emptyEnv, S.singleton l, l'', e'' --- , M.insert l (CITE lenv cond tlabel flabel) c <> c') --- -- like Acond. The biggest difference is that 'cond' is a function instead of an expression here. --- -- In fact, for the graph, we use 'startvars' much like we used 'cond' in Acond, and we use --- -- 'cond' and 'bdy' much like we used 'tbranch' and 'fbranch'. --- mkFullGraph (Awhile u cond bdy startvars) lenv l e = let clabel = l+1 --- blabel = 1+2 --- emptyEnv = emptyLabelEnv lenv --- ( (cinfo, cinfoM), _, _, l' , e' , c ) = mkFullGraphF cond emptyEnv (l+3) e --- ( (binfo, binfoM), _, _, l'', e'', c') = mkFullGraphF bdy emptyEnv l' e' --- nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, clabel), (clabel, blabel)] --- in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty --- , M.fromList [(clabel, cinfo), (blabel, binfo)] <> cinfoM <> binfoM) --- , emptyEnv, S.singleton l, l'', e'' --- , M.insert l (CWhl lenv u clabel blabel startvars) c <> c') - - -mkFullGraph _ = undefined - --- -- TODO: This function would be cleaner with a datatype and State monad --- -- replacing the tuples and explicit passing of every argument --- mkFullGraph :: MakesILP op --- => PreOpenAcc op aenv a --- -> LabelEnv aenv -- for each array in the environment, --- -- the source labels of the currently open outgoing edges. --- -> Label -- the next fresh label to use --- -> ELabel -- the next fresh ELabel to use --- -> ( --- ( Information op, IntMap (Information op)) --- , LabelEnv aenv -- like input, but adjusted for side-effects --- , Set Label -- source labels of currently open outgoing edges of 'a' --- , Label -- the next fresh label to use --- , ELabel -- the next fresh ELabel to use --- -- for reconstructing the AST later. We generate this and the graph in one pass, --- , IntMap (Construction op) -- to guarantee that the labels match. --- ) - --- -- For all input arguments (that is, everything except `Out` buffers), we add fusible edges. If that's --- -- not strict enough, the backend can add infusible edges, but this is a sound --- -- lowerbound on fusibility: these inputs may never be computed _after_ the op. --- -- Excessive fusible edges are filtered out before we feed them to the ILP solver. --- foo (Exec op args) lenv l e = --- let fuseedges = S.map (, l) $ getInputArgLabels args lenv --- in ( (mkGraph op (getLabelArgs args lenv) l <> Info (Graph (S.singleton l) fuseedges mempty) mempty mempty, mempty) --- , updateLabelEnv args lenv l -- add labels for `Out` and `Mut` args. --- , mempty --- , l + 1 --- , e --- , M.singleton l $ CExe lenv args op) --- mkFullGraph (Alet lhs u bnd scp) lenv l e = -- we throw away the uniquenessess information here, that's Future Work --- let (bndInfo, lenv' , lbnd, l' , e' , c ) = mkFullGraph bnd lenv l e --- (e'', lenv'') = addLhsLabels lhs e' lbnd lenv' --- (scpInfo, lenv''', lscp, l'', e''', c') = mkFullGraph scp lenv'' l' e'' --- in (bndInfo <> scpInfo --- , weakLhsEnv lhs lenv''' --- , lscp --- , l'' --- , e''' --- , c <> c') --- mkFullGraph (Return vars) lenv l e = ( (mempty, mempty), lenv, getLabelsTup vars lenv, l, e, mempty) --- mkFullGraph (Compute expr) lenv l e = ( (mempty, mempty), lenv, getLabelsExp expr lenv, l, e, mempty) --- mkFullGraph (Alloc shr scty shvar) lenv l e = ( (mempty, mempty), lenv, mempty , l, e, mempty) -- unless we can't infer alloc... --- mkFullGraph (Use sctype buff) lenv l e = --- ( (Info (Graph (S.singleton l) mempty mempty) mempty mempty, mempty) --- , lenv, S.singleton l, l+1, e --- , M.singleton l $ CUse sctype buff) --- -- gets a variable from the env, puts it in a singleton buffer. --- -- Here I'm assuming this fuses nicely, and doesn't even need a new label --- -- (reuse the one that belongs to the variable). Might need to add a label --- -- to avoid obfuscating the AST though. Change when needed. --- mkFullGraph (Unit var) lenv l e = ( (mempty, mempty), lenv, getLabelsVar var lenv, l, e, mempty) - --- -- NOTE: We explicitly add infusible edges from every label in `lenv` to this Acond. --- -- This makes the previous let-bindings strict: even if some result is only used in one --- -- branch, we now require it to be present before we evaluate the condition. --- -- I think this is safe: if a result is only used in one branch, it should be let-bound --- -- within that branch already. Note that this also means we ignore the contents of 'cond' for the graph. --- -- We also add edges from the Acond to the true-branch, and from the true-branch to the false-branch? --- -- TODO check if this is right/needed/if passing even more fresh labels down is correct. --- mkFullGraph (Acond cond tbranch fbranch) lenv l e = let tlabel = l+1 --- flabel = l+2 --- emptyEnv = emptyLabelEnv lenv --- ( (tinfo, tinfoM), _, _, l' , e' , c ) = mkFullGraph tbranch emptyEnv (l+3) e --- ( (finfo, finfoM), _, _, l'', e'', c') = mkFullGraph fbranch emptyEnv l' e' --- nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, tlabel), (tlabel, flabel)] --- in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty --- , M.fromList [(tlabel, tinfo), (flabel, finfo)] <> tinfoM <> finfoM) --- , emptyEnv, S.singleton l, l'', e'' --- , M.insert l (CITE lenv cond tlabel flabel) c <> c') --- -- like Acond. The biggest difference is that 'cond' is a function instead of an expression here. --- -- In fact, for the graph, we use 'startvars' much like we used 'cond' in Acond, and we use --- -- 'cond' and 'bdy' much like we used 'tbranch' and 'fbranch'. --- mkFullGraph (Awhile u cond bdy startvars) lenv l e = let clabel = l+1 --- blabel = 1+2 --- emptyEnv = emptyLabelEnv lenv --- ( (cinfo, cinfoM), _, _, l' , e' , c ) = mkFullGraphF cond emptyEnv (l+3) e --- ( (binfo, binfoM), _, _, l'', e'', c') = mkFullGraphF bdy emptyEnv l' e' --- nonfuse = S.map (,l) (getAllLabelsEnv lenv) <> S.fromList [(l, clabel), (clabel, blabel)] --- in ( (Info (Graph (S.fromList [l .. l+2]) mempty nonfuse) mempty mempty --- , M.fromList [(clabel, cinfo), (blabel, binfo)] <> cinfoM <> binfoM) --- , emptyEnv, S.singleton l, l'', e'' --- , M.insert l (CWhl lenv u clabel blabel startvars) c <> c') - --- -- | Like mkFullGraph, but for @PreOpenAfun@. --- mkFullGraphF :: MakesILP op --- => PreOpenAfun op aenv a --- -- For each array in the environment, the source labels --- -> LabelEnv aenv -- of the currently open outgoing edges. --- -> Label -- the next fresh label to use --- -> ELabel -- the next fresh ELabel to use --- -> ( --- ( Information op, IntMap (Information op)) --- , LabelEnv aenv -- like input, but adjusted for side-effects --- , Set Label -- source labels of currently open outgoing edges of 'a' --- , Label -- the next fresh label to use --- , ELabel -- the next fresh ELabel to use --- , IntMap (Construction op) --- ) --- mkFullGraphF = \case --- Abody acc -> mkFullGraph acc --- Alam lhs f -> \lenv l e -> let (e', lenv') = addLhsLabels lhs e mempty lenv -- it's a function, so we can fill the extra environment with mempties --- ((info, infoM), lenv'', lset, l', e'', c) = mkFullGraphF f lenv' l e' --- in ((info, infoM), weakLhsEnv lhs lenv'', lset, l', e'', c) + return $ (bndRes <> scpRes){lset = scpL} + +mkFullGraph (Return vars) = do + env <- gets lenv + return $ mempty{lset = getLabelsTup vars env} +mkFullGraph (Compute expr) = do + env <- gets lenv + return $ mempty{lset = getLabelsExp expr env} +mkFullGraph Alloc{} = return mempty +mkFullGraph (Use sctype buff) = do + l <- getL + return $ FGRes mempty{graph = mempty{graphNodes = S.singleton l}} + mempty + (S.singleton l) + (M.singleton l $ CUse sctype buff) + +-- gets a variable from the env, puts it in a singleton buffer. +-- Here I'm assuming this fuses nicely, and doesn't even need a new label +-- (reuse the one that belongs to the variable). Might need to add a label +-- to avoid obfuscating the AST though. Change when needed. +mkFullGraph (Unit var) = do + env <- gets lenv + return mempty{lset = getLabelsVar var env} + +-- NOTE: We explicitly add infusible edges from every label in `lenv` to this Acond. +-- This makes the previous let-bindings strict: even if some result is only used in one +-- branch, we now require it to be present before we evaluate the condition. +-- I think this is safe: if a result is only used in one branch, it should be let-bound +-- within that branch already. Note that this also means we ignore the contents of 'cond' for the graph. +-- We also add edges from the Acond to the true-branch, and from the true-branch to the false-branch? +-- TODO check if this is right/needed/if passing even more fresh labels down is correct. +mkFullGraph (Acond cond tacc facc) = do + l <- getL + tl <- getL + fl <- getL + env <- gets lenv + let emptyEnv = emptyLabelEnv env + putEnv emptyEnv + FGRes tinfo tinfoM _ tConstr <- mkFullGraph tacc + putEnv emptyEnv + FGRes finfo finfoM _ fConstr <- mkFullGraph facc + putEnv emptyEnv + let nonfuse = S.map (,l) (getAllLabelsEnv env) <> S.fromList [(l,tl), (tl,fl)] + return $ FGRes mempty{graph = Graph (S.fromList [l, tl, fl]) mempty nonfuse} + (M.insert tl tinfo $ M.insert fl finfo $ tinfoM <> finfoM) + (S.singleton l) + (M.insert l (CITE env cond tl fl) $ tConstr <> fConstr) + +-- like Acond. The biggest difference is that 'cond' is a function instead of an expression here. +-- In fact, for the graph, we use 'startvars' much like we used 'cond' in Acond, and we use +-- 'cond' and 'bdy' much like we used 'tbranch' and 'fbranch'. +mkFullGraph (Awhile u cond bdy startvars) = do + l <- getL + cl <- getL + bl <- getL + env <- gets lenv + let emptyEnv = emptyLabelEnv env + putEnv emptyEnv + FGRes cinfo cinfoM _ cConstr <- mkFullGraphF cond + putEnv emptyEnv + FGRes binfo binfoM _ bConstr <- mkFullGraphF bdy + putEnv emptyEnv + let nonfuse = S.map (,l) (getAllLabelsEnv env) <> S.fromList [(l,cl), (cl,bl)] + return $ FGRes mempty{graph = Graph (S.fromList [l, cl, bl]) mempty nonfuse} + (M.insert cl cinfo $ M.insert bl binfo $ cinfoM <> binfoM) + (S.singleton l) + (M.insert l (CWhl env u cl bl startvars) $ cConstr <> bConstr) + + +-- | Like mkFullGraph, but for @PreOpenAfun@. +mkFullGraphF :: MakesILP op + => PreOpenAfun op env a + -> State (FullGraphState env) (FullGraphResult op) +mkFullGraphF (Abody acc) = mkFullGraph acc +mkFullGraphF (Alam lhs f) = do + e <- gets freshE + env <- gets lenv + let (e', env') = addLhsLabels lhs e mempty env + putE e' + stt <- get + let (res, stt') = runState (mkFullGraphF f) stt{lenv=env'} + put stt'{lenv = weakLhsEnv lhs $ lenv stt'} + return res + -- | Information to construct AST nodes. Generally, constructors contain -- both actual information, and a LabelEnv of the original environment @@ -360,20 +296,20 @@ data Construction (op :: Type -> Type) where constructExe :: LabelEnv env' -> LabelEnv env -> Args env args -> op args -> Maybe (PreOpenAcc op env' ()) -constructExe lenv' lenv args op = Exec op <$> reindexArgs (mkReindexPartial lenv lenv') args +constructExe env' env args op = Exec op <$> reindexArgs (mkReindexPartial env env') args constructUse :: ScalarType e -> Buffer e -> PreOpenAcc op env (Buffer e) constructUse = Use constructITE :: LabelEnv env' -> LabelEnv env -> ExpVar env PrimBool -> PreOpenAcc op env' a -> PreOpenAcc op env' a -> Maybe (PreOpenAcc op env' a) -constructITE lenv' lenv cond tbranch fbranch = Acond <$> reindexVar (mkReindexPartial lenv lenv') cond +constructITE env' env cond tbranch fbranch = Acond <$> reindexVar (mkReindexPartial env env') cond <*> pure tbranch <*> pure fbranch constructWhl :: LabelEnv env' -> LabelEnv env -> Uniquenesses a -> PreOpenAfun op env' (a -> PrimBool) -> PreOpenAfun op env' (a -> a) -> GroundVars env a -> Maybe (PreOpenAcc op env' a) -constructWhl lenv' lenv u cond body start = Awhile u cond body <$> reindexVars (mkReindexPartial lenv lenv') start +constructWhl env' env u cond body start = Awhile u cond body <$> reindexVars (mkReindexPartial env env') start @@ -381,12 +317,12 @@ constructWhl lenv' lenv u cond body start = Awhile u cond body <$> reindexVars ( -- We cannot guarantee the index is present in env', so we use the partiality of ReindexPartial by -- returning a Maybe. Uses unsafeCoerce to re-introduce type information implied by the ELabels. mkReindexPartial :: LabelEnv env -> LabelEnv env' -> ReindexPartial Maybe env env' -mkReindexPartial lenv lenv' idx = go lenv' +mkReindexPartial env env' idx = go env' where -- The ELabel in the original environment - e = getELabelIdx idx lenv + e = getELabelIdx idx env go :: forall e a. LabelEnv e -> Maybe (Idx e a) - go ((e',_) :>>>: env) -- e' is the ELabel in the new environment + go ((e',_) :>>>: rest) -- e' is the ELabel in the new environment -- Here we have to convince GHC that the top element in the environment -- really does have the same type as the one we were searching for. -- Some literature does this stuff too: 'effect handlers in haskell, evidently' @@ -398,7 +334,7 @@ mkReindexPartial lenv lenv' idx = go lenv' @(Idx e a) ZeroIdx -- Recurse if we did not find e' yet. - | otherwise = SuccIdx <$> go env + | otherwise = SuccIdx <$> go rest -- If we hit the end, the Elabel was not present in the environment. -- That probably means we'll error out at a later point, but maybe there is -- a case where we try multiple options? No need to worry about it here. diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs index fd80cb45a..1c96a6072 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs +++ b/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs @@ -60,13 +60,13 @@ makeILP (Info -- ___ | real, everything else is integral. | -- | | Hope this doesn't slow the solver. | -- v ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾ - graphILP = Program Minimise (toR objFun) constraints bounds + graphILP = Program Minimise (toR objFun) myConstraints myBounds -- Placeholder, currently maximising the number of vertical/diagonal fusions. -- In the future, maybe we want this to be backend-dependent. objFun = foldl' (\f (i, j) -> f .+. fused i j) c0 (S.toList fuseEdges) - constraints = acyclic <> infusible + myConstraints = acyclic <> infusible -- x_ij <= pi_j - pi_i <= n*x_ij for all fusible edges acyclic = foldMap @@ -81,7 +81,7 @@ makeILP (Info nofuseEdges -- 0 <= pi_i <= n - bounds = map (\i -> lowerUpperZ 0 (Pi i) n) + myBounds = map (\i -> lowerUpperZ 0 (Pi i) n) (S.toList nodes) <> -- x_ij \in {0, 1} map (\(i, j) -> binary $ Fused i j) From 5b7565796228f57080a8bb3b7b4b01dc9ef0d545 Mon Sep 17 00:00:00 2001 From: David Date: Tue, 16 Feb 2021 17:53:19 +0100 Subject: [PATCH 030/813] commit --- src/Data/Array/Accelerate/AST/Partitioned.hs | 26 ++++++++++++------- .../Array/Accelerate/Trafo/NewNewFusion.hs | 2 +- 2 files changed, 18 insertions(+), 10 deletions(-) diff --git a/src/Data/Array/Accelerate/AST/Partitioned.hs b/src/Data/Array/Accelerate/AST/Partitioned.hs index 7a5f8f8d1..0254f1ec6 100644 --- a/src/Data/Array/Accelerate/AST/Partitioned.hs +++ b/src/Data/Array/Accelerate/AST/Partitioned.hs @@ -20,13 +20,14 @@ -- Stability : experimental -- Portability : non-portable (GHC extensions) -- -module Data.Array.Accelerate.AST.Partitioned +module Data.Array.Accelerate.AST.Partitioned ( module Data.Array.Accelerate.AST.Operation , Cluster(..), Combine(..), SwapArgs(..) , PartitionedAcc, PartitionedAfun ) where import Data.Array.Accelerate.AST.Operation +import Data.Array.Accelerate.AST.Environment data Cluster op args where @@ -41,26 +42,32 @@ data Cluster op args where -> Cluster op args -> Cluster op args' + -- | Not a true weakening: that would imply adding inputs and/or removing outputs. + -- This 'weakening' only adds arguments, in and/or out, to the phantom types. + -- Maybe think of a different name for it :) + Weaken :: args :> args' -- TODO replace with an Arg-level weakening + -> Cluster op args' + -> Cluster op args + -- Note that, in general, these combination descriptors can definitely represent -- undesirable states: It's probably not doable to encode all fusability rules -- in the types (especially while abstracting over backends), instead we will need -- to call `error "impossible fusion"` in the backends at some points (particularly codegen). +-- | All these options will, in general, require the underlying Clusters to be weakened +-- by adding superfluous Args. The constructors below are the only way to "remove Args". data Combine a b c where -- An array is produced and consumed, fusing it away. -- NOTE: this means that the array does not appear in the environment, and -- it does not have an accompanying `Arg` constructor: Its scope is now -- bound by this `Vertical` constructor. Vertical :: Combine (Out sh e -> a) (In sh e -> a) a - + -- Like vertical, but the `Array sh e` is stored for later use Diagonal :: Combine (Out sh e -> a) (In sh e -> a) (Out sh e -> a) - - -- Both outputs are stored. We purposely don't require sh1 == sh2, but the rest of the types - -- need to align, so this is why we need weakening. - -- TODO: perhaps this type is too strict, and we'll want to horizontally fuse two clusters - -- with multiple out-variables. - Horizontal :: Combine (Out sh1 e1 -> a) (Out sh2 e2 -> a) (Out sh1 e1 -> Out sh2 e2 -> a) + + -- Both outputs are stored. Because of the weakening, this combination is trivial. + Horizontal :: Combine a a a type PartitionedAcc op = PreOpenAcc (Cluster op) @@ -72,8 +79,9 @@ data SwapArgs a b where -- Switch the first two arguments. This might be all we need, but probably not.. Swap :: SwapArgs (a -> b -> x) (b -> a -> x) - -- Alternatively, we would need constructors traversing the whole type, something like these: + -- Alternatively, we could need constructors traversing the whole type, something like these: Start :: SwapArgs () () Dig :: SwapArgs a b -> SwapArgs (x -> a) (x -> b) Swap' :: SwapArgs a (x -> y -> z) -> SwapArgs a (y -> x -> z) + SSwap :: SwapArgs a b -> SwapArgs b c -> SwapArgs a c diff --git a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs index 1a9b79ccc..84698c457 100644 --- a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs +++ b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs @@ -79,4 +79,4 @@ withSimplStats x = x #endif dontFuse :: op args -> Cluster op args -dontFuse = Leaf \ No newline at end of file +dontFuse = Leaf From fb827bda3329712cf5ce23c396592fab3c01aec6 Mon Sep 17 00:00:00 2001 From: David Date: Wed, 17 Feb 2021 18:08:11 +0100 Subject: [PATCH 031/813] new version of Cluster, SwapArgs is a category --- accelerate.cabal | 6 + src/Data/Array/Accelerate/AST/Partitioned.hs | 117 ++++++++++++------ .../Array/Accelerate/Trafo/Clustering/ILP.hs | 30 ----- .../Array/Accelerate/Trafo/NewNewFusion.hs | 5 +- .../Accelerate/Trafo/Partitioning/ILP.hs | 24 ++++ .../Trafo/Partitioning/ILP/Clustering.hs | 30 +++++ .../{Clustering => Partitioning}/ILP/Graph.hs | 4 +- .../ILP/Labels.hs | 2 +- .../{Clustering => Partitioning}/ILP/Solve.hs | 51 ++++---- .../{Clustering => Partitioning}/Stream.hs | 0 10 files changed, 169 insertions(+), 100 deletions(-) delete mode 100644 src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs create mode 100644 src/Data/Array/Accelerate/Trafo/Partitioning/ILP.hs create mode 100644 src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Clustering.hs rename src/Data/Array/Accelerate/Trafo/{Clustering => Partitioning}/ILP/Graph.hs (99%) rename src/Data/Array/Accelerate/Trafo/{Clustering => Partitioning}/ILP/Labels.hs (98%) rename src/Data/Array/Accelerate/Trafo/{Clustering => Partitioning}/ILP/Solve.hs (63%) rename src/Data/Array/Accelerate/Trafo/{Clustering => Partitioning}/Stream.hs (100%) diff --git a/accelerate.cabal b/accelerate.cabal index 067eaa970..95d0350c3 100644 --- a/accelerate.cabal +++ b/accelerate.cabal @@ -321,6 +321,7 @@ Library Data.Array.Accelerate.AST.Idx Data.Array.Accelerate.AST.LeftHandSide Data.Array.Accelerate.AST.Operation + Data.Array.Accelerate.AST.Partitioned Data.Array.Accelerate.AST.Var Data.Array.Accelerate.Analysis.Hash Data.Array.Accelerate.Analysis.Hash.Exp @@ -357,6 +358,11 @@ Library Data.Array.Accelerate.Trafo.Exp.Shrink Data.Array.Accelerate.Trafo.Exp.Substitution Data.Array.Accelerate.Trafo.Fusion + Data.Array.Accelerate.Trafo.Partitioning.ILP + Data.Array.Accelerate.Trafo.Partitioning.ILP.Graph + Data.Array.Accelerate.Trafo.Partitioning.ILP.Labels + Data.Array.Accelerate.Trafo.Partitioning.ILP.Solve + Data.Array.Accelerate.Trafo.Partitioning.Stream Data.Array.Accelerate.Trafo.Sharing Data.Array.Accelerate.Trafo.Substitution Data.Array.Accelerate.Type diff --git a/src/Data/Array/Accelerate/AST/Partitioned.hs b/src/Data/Array/Accelerate/AST/Partitioned.hs index 0254f1ec6..03ec25f9f 100644 --- a/src/Data/Array/Accelerate/AST/Partitioned.hs +++ b/src/Data/Array/Accelerate/AST/Partitioned.hs @@ -9,8 +9,6 @@ {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} -{-# OPTIONS_GHC -Wno-unused-binds #-} -- remove later, I don't like seeing the warnings now - -- | -- Module : Data.Array.Accelerate.AST.Partitioned -- Copyright : [2008..2020] The Accelerate Team @@ -22,32 +20,33 @@ -- module Data.Array.Accelerate.AST.Partitioned ( module Data.Array.Accelerate.AST.Operation - , Cluster(..), Combine(..), SwapArgs(..) + , Cluster(..), Combine(..) , PartitionedAcc, PartitionedAfun + , SwapArgs(..), Take(..) ) where import Data.Array.Accelerate.AST.Operation -import Data.Array.Accelerate.AST.Environment - -data Cluster op args where - Leaf :: op args -> Cluster op args +import Control.Category ( Category(..) ) - Node :: Cluster op a - -> Cluster op b - -> Combine a b c - -> Cluster op c - Reorder :: SwapArgs args args' - -> Cluster op args - -> Cluster op args' +type PartitionedAcc op = PreOpenAcc (Cluster op) +type PartitionedAfun op = PreOpenAfun (Cluster op) - -- | Not a true weakening: that would imply adding inputs and/or removing outputs. - -- This 'weakening' only adds arguments, in and/or out, to the phantom types. - -- Maybe think of a different name for it :) - Weaken :: args :> args' -- TODO replace with an Arg-level weakening - -> Cluster op args' - -> Cluster op args +data Cluster op args where + -- Currently, we only swap the order of the arguments at the leaves. + -- This is needed to be able to horizontally fuse (x -> y -> a) with (y -> x -> a). + -- I think it is also sufficient to do it only at leaves, and not in every node. + -- Maybe putting it in the nodes will turn out to be easier though! + Leaf :: op args + -> SwapArgs args args' + -> Cluster op args + + -- Fuse two clusters. + Branch :: Cluster op a + -> Cluster op b + -> Combine a b c + -> Cluster op c -- Note that, in general, these combination descriptors can definitely represent -- undesirable states: It's probably not doable to encode all fusability rules @@ -56,32 +55,72 @@ data Cluster op args where -- | All these options will, in general, require the underlying Clusters to be weakened -- by adding superfluous Args. The constructors below are the only way to "remove Args". -data Combine a b c where +data Combine left right result where -- An array is produced and consumed, fusing it away. -- NOTE: this means that the array does not appear in the environment, and -- it does not have an accompanying `Arg` constructor: Its scope is now - -- bound by this `Vertical` constructor. - Vertical :: Combine (Out sh e -> a) (In sh e -> a) a + -- bound by this `Node` constructor in `Cluster`. + Vertical :: Combine a b c + -> Combine (Out sh e -> a) (In sh e -> b) c - -- Like vertical, but the `Array sh e` is stored for later use - Diagonal :: Combine (Out sh e -> a) (In sh e -> a) (Out sh e -> a) + -- Like vertical, but the arg is stored for later use + Diagonal :: Combine a b c + -> Combine (Out sh e -> a) (In sh e -> b) (Out sh e -> c) - -- Both outputs are stored. Because of the weakening, this combination is trivial. - Horizontal :: Combine a a a + -- Both computations use the argument in the same fashion. + -- Note that you can't recreate this type using WeakLeft and WeakRight, + -- as that would duplicate the argument in the resulting type + Horizontal :: Combine a b c + -> Combine (x -> a) (x -> b) (x -> c) + -- Only the right computation uses x, so this 'weakens' the left computation + WeakLeft :: Combine a b c + -> Combine a (x -> b) (x -> c) + WeakRight :: Combine a b c + -> Combine (x -> a) b (x -> c) -type PartitionedAcc op = PreOpenAcc (Cluster op) -type PartitionedAfun op = PreOpenAfun (Cluster op) -- Re-order the type level arguments, to align them for the fusion constructors. --- pray we won't need it, fear we might, hope it doesn't complicate things data SwapArgs a b where - -- Switch the first two arguments. This might be all we need, but probably not.. - Swap :: SwapArgs (a -> b -> x) (b -> a -> x) - - -- Alternatively, we could need constructors traversing the whole type, something like these: - Start :: SwapArgs () () - Dig :: SwapArgs a b -> SwapArgs (x -> a) (x -> b) - Swap' :: SwapArgs a (x -> y -> z) - -> SwapArgs a (y -> x -> z) - SSwap :: SwapArgs a b -> SwapArgs b c -> SwapArgs a c + -- no swapping, base case + Start :: SwapArgs a a + -- put x on top + Swap :: SwapArgs a xb + -> Take x xb b + -> SwapArgs a (x -> b) + +instance Category SwapArgs where -- neat + id = Start + (.) = flip composeSwap + +data Take x xa a where + Here :: Take x (x -> a) a + There :: Take x xa a + -> Take x (y -> xa) (y -> a) + +composeSwap :: forall a b c. SwapArgs a b -> SwapArgs b c -> SwapArgs a c +composeSwap x = go + where go :: SwapArgs b x -> SwapArgs a x + -- If the second SwapArgs is identity, return x + go Start = x + -- Otherwise, the second SwapArgs puts something in front. + -- Recurse, then wrap that in a Swap which puts the same thing in front! + go (Swap a b) = Swap (go a) b + +-- Alternative SwapArgs constructors: + + -- Start' :: SwapArgs () () + + -- Dig :: SwapArgs a b + -- -> SwapArgs (x -> a) (x -> b) + + -- SSwap :: SwapArgs a b + -- -> SwapArgs b c + -- -> SwapArgs a c + + -- Swap :: SwapArgs a (x -> y -> z) + -- -> SwapArgs a (y -> x -> z) + + -- Swap' :: Take x xa a + -- -> SwapArgs xa (x -> a) + diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs b/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs deleted file mode 100644 index b60af1573..000000000 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP.hs +++ /dev/null @@ -1,30 +0,0 @@ -{-# LANGUAGE TypeApplications #-} -{-# LANGUAGE ScopedTypeVariables #-} -module Data.Array.Accelerate.Trafo.Clustering.ILP where - -import Data.Array.Accelerate.Trafo.Clustering.ILP.Graph - ( MakesILP, Information(Info), makeFullGraph ) -import Data.Array.Accelerate.Trafo.Clustering.ILP.Solve - ( interpretSolution, makeILP, reconstruct, solveILP ) -import Data.Array.Accelerate.AST.Partitioned - ( OperationAcc, PartitionedAcc ) - -import qualified Data.IntMap as M -import Unsafe.Coerce (unsafeCoerce) -import Data.Array.Accelerate.AST.LeftHandSide ( Exists(Exists) ) - -ilpfusion :: forall op a. MakesILP op => OperationAcc op () a -> PartitionedAcc op () a -ilpfusion acc = fusedAcc - where - (info@(Info graph _ _), infos, constrM) = makeFullGraph acc - (ilp, ilps) = (makeILP info, M.map makeILP infos) - solution = (solveILP ilp, M.map solveILP ilps) - (labelCluster,labelClusters) = interpretSolution solution - reconstructedAcc = reconstruct graph labelCluster labelClusters constrM - -- Because we lose some type information by rebuilding the AST from scratch, we use - -- unsafeCoerce here to tell GHC that the new AST has the same return type. - -- Type applications allow us to restrict this function to the return type only. - fusedAcc = case reconstructedAcc of - Exists res -> unsafeCoerce @(PartitionedAcc op () _) - @(PartitionedAcc op () a) - res diff --git a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs index 84698c457..281407d3b 100644 --- a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs +++ b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs @@ -38,6 +38,8 @@ import Data.Array.Accelerate.AST.Partitioned import Data.Array.Accelerate.Trafo.Config import Data.Array.Accelerate.Error +import Control.Category + import Data.Array.Accelerate.Debug.Flags ( array_fusion ) import qualified Data.Array.Accelerate.Debug.Stats as Stats import Data.Kind @@ -45,6 +47,7 @@ import Data.Kind import System.IO.Unsafe -- for debugging #endif +import Prelude hiding (id, (.)) -- Array Fusion -- ============ @@ -79,4 +82,4 @@ withSimplStats x = x #endif dontFuse :: op args -> Cluster op args -dontFuse = Leaf +dontFuse op = Leaf op id diff --git a/src/Data/Array/Accelerate/Trafo/Partitioning/ILP.hs b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP.hs new file mode 100644 index 000000000..b98d9e8ad --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP.hs @@ -0,0 +1,24 @@ +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE ScopedTypeVariables #-} +module Data.Array.Accelerate.Trafo.Partitioning.ILP where + +import Data.Array.Accelerate.Trafo.Partitioning.ILP.Graph + ( MakesILP, Information(Info), makeFullGraph ) +import Data.Array.Accelerate.Trafo.Partitioning.ILP.Solve + ( interpretSolution, makeILP, solveILP ) +import Data.Array.Accelerate.Trafo.Partitioning.ILP.Clustering + ( reconstruct ) +import Data.Array.Accelerate.AST.Partitioned + ( OperationAcc, PartitionedAcc ) + +import qualified Data.IntMap as M + +ilpfusion :: forall op a. MakesILP op => OperationAcc op () a -> PartitionedAcc op () a +ilpfusion acc = fusedAcc + where + (info@(Info graph _ _), infos, constrM) = makeFullGraph acc + (ilp, ilps) = (makeILP info, M.map makeILP infos) + (solution, solutions) = (solveILP ilp, M.map solveILP ilps) + labelClusters = interpretSolution $ solution : M.elems solutions + fusedAcc = reconstruct graph labelClusters constrM + diff --git a/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Clustering.hs b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Clustering.hs new file mode 100644 index 000000000..74eece18b --- /dev/null +++ b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Clustering.hs @@ -0,0 +1,30 @@ +module Data.Array.Accelerate.Trafo.Partitioning.ILP.Clustering where + +import Data.Array.Accelerate.Trafo.Partitioning.ILP.Graph +import qualified Data.Set as S +import Data.Array.Accelerate.Trafo.Partitioning.ILP.Labels +import qualified Data.IntMap as M +import Data.Array.Accelerate.AST.Partitioned + + + +-- "open research question" +-- -- Each set of ints corresponds to a set of Constructions, which themselves contain a set of ints (the things they depend on). +-- -- Some of those ints will refer to nodes in previous clusters, others to nodes in this cluster. +-- One pass over these datatypes (back-to-front) should identify the 'output type' of each cluster: which nodes are needed in later clusters? +-- Then, we can construct the clusters front-to-back: +-- identify the nodes that only depend on nodes outside of the cluster, they are the initials +-- the `output type` indicates which nodes we will need to keep: they are all either a final node in the cluster, or get diagonally fused +-- How exactly we can use this information (and a dep. graph) to construct a cluster of ver,hor,diag is not clear.. Will also depend on the exact cluster definition. + +reconstruct :: Graph -> [S.Set Label] -> M.IntMap (Construction op) -> PreOpenAcc (Cluster op) () a +reconstruct = undefined + + + -- Because we lose some type information by rebuilding the AST from scratch, we use + -- unsafeCoerce here to tell GHC that the new AST has the same return type. + -- Type applications allow us to restrict this function to the return type only. + -- fusedAcc = case reconstructedAcc of + -- Exists res -> unsafeCoerce @(PartitionedAcc op () _) + -- @(PartitionedAcc op () a) + -- res \ No newline at end of file diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Graph.hs similarity index 99% rename from src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs rename to src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Graph.hs index 7ff588555..0a1b771a7 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Graph.hs +++ b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Graph.hs @@ -11,9 +11,9 @@ {-# LANGUAGE TupleSections #-} {-# LANGUAGE ScopedTypeVariables #-} -module Data.Array.Accelerate.Trafo.Clustering.ILP.Graph where +module Data.Array.Accelerate.Trafo.Partitioning.ILP.Graph where -import Data.Array.Accelerate.Trafo.Clustering.ILP.Labels +import Data.Array.Accelerate.Trafo.Partitioning.ILP.Labels -- accelerate imports import Data.Array.Accelerate.AST.Idx ( Idx(..) ) diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Labels.hs b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Labels.hs similarity index 98% rename from src/Data/Array/Accelerate/Trafo/Clustering/ILP/Labels.hs rename to src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Labels.hs index ae7d1ddea..594a2dc7d 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Labels.hs +++ b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Labels.hs @@ -2,7 +2,7 @@ {-# LANGUAGE GADTs #-} {-# LANGUAGE EmptyCase #-} {-# LANGUAGE ViewPatterns #-} -module Data.Array.Accelerate.Trafo.Clustering.ILP.Labels where +module Data.Array.Accelerate.Trafo.Partitioning.ILP.Labels where -- accelerate imports diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Solve.hs similarity index 63% rename from src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs rename to src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Solve.hs index 1c96a6072..9403ded36 100644 --- a/src/Data/Array/Accelerate/Trafo/Clustering/ILP/Solve.hs +++ b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Solve.hs @@ -1,8 +1,10 @@ +{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeOperators #-} -module Data.Array.Accelerate.Trafo.Clustering.ILP.Solve where +{-# LANGUAGE ScopedTypeVariables #-} +module Data.Array.Accelerate.Trafo.Partitioning.ILP.Solve where -import Data.Array.Accelerate.Trafo.Clustering.ILP.Graph -import Data.Array.Accelerate.Trafo.Clustering.ILP.Labels +import Data.Array.Accelerate.Trafo.Partitioning.ILP.Graph +import Data.Array.Accelerate.Trafo.Partitioning.ILP.Labels import Prelude hiding ( pi ) @@ -17,11 +19,8 @@ import Data.Array.Accelerate.AST.Partitioned ( Cluster ) -- and [] only when it does. It's also often efficient -- by removing duplicates. import qualified Data.Set as S -import qualified Data.IntMap as M -import Data.List (foldl') - - --- GHC imports +import qualified Data.Map as M +import Data.List (group, sortOn, foldl') -- Limp is a Linear Integer Mixed Programming library. @@ -34,6 +33,8 @@ import Data.List (foldl') -- later, the interfaces are all quite similar. import Numeric.Limp.Program hiding ( Constraint, r ) import Numeric.Limp.Rep.IntDouble +import qualified Numeric.Limp.Rep.Rep as LIMP +import Data.Bifunctor (Bifunctor(bimap), second) @@ -64,7 +65,9 @@ makeILP (Info -- Placeholder, currently maximising the number of vertical/diagonal fusions. -- In the future, maybe we want this to be backend-dependent. - objFun = foldl' (\f (i, j) -> f .+. fused i j) c0 (S.toList fuseEdges) + objFun = foldl' (\f (i, j) -> f .+. fused i j) + c0 + (S.toList fuseEdges) myConstraints = acyclic <> infusible @@ -82,26 +85,20 @@ makeILP (Info -- 0 <= pi_i <= n myBounds = map (\i -> lowerUpperZ 0 (Pi i) n) - (S.toList nodes) - <> -- x_ij \in {0, 1} - map (\(i, j) -> binary $ Fused i j) - (S.toList fuseEdges) + (S.toList nodes) + <> -- x_ij \in {0, 1} + map (\(i, j) -> binary $ Fused i j) + (S.toList fuseEdges) -- call the solver. Gets called for each ILP solveILP :: ILP op -> Assignment op solveILP = undefined --- Extract the fusion information (ordered list of clustered Labels) -interpretSolution :: (Assignment op, M.IntMap (Assignment op)) -> ([S.Set Label], M.IntMap [S.Set Label]) -interpretSolution = undefined - --- "open research question" --- -- Each set of ints corresponds to a set of Constructions, which themselves contain a set of ints (the things they depend on). --- -- Some of those ints will refer to nodes in previous clusters, others to nodes in this cluster. --- One pass over these datatypes (back-to-front) should identify the 'output type' of each cluster: which nodes are needed in later clusters? --- Then, we can construct the clusters front-to-back: --- identify the nodes that only depend on nodes outside of the cluster, they are the initials --- the `output type` indicates which nodes we will need to keep: they are all either a final node in the cluster, or get diagonally fused --- How exactly we can use this information (and a dep. graph) to construct a cluster of ver,hor,diag is not clear.. Will also depend on the exact cluster definition. -reconstruct :: Graph -> [S.Set Label] -> M.IntMap [S.Set Label] -> M.IntMap (Construction op) -> Exists (PreOpenAcc (Cluster op) ()) -reconstruct = undefined +-- Extract the fusion information (ordered list of clusters of Labels) (head is the first cluster) +interpretSolution :: forall op. [Assignment op] -> [S.Set Label] +interpretSolution assignments = map (S.fromList . map fst) $ group $ sortOn snd $ map (bimap (\(Pi l)->l) (fromIntegral @_ @Int)) pis + where + pis :: [(Variable op, Z IntDouble)] + pis = concatMap (\(LIMP.Assignment x _) -> M.toList $ M.filterWithKey (const . isPi) x) assignments + isPi (Pi _) = True + isPi _ = False diff --git a/src/Data/Array/Accelerate/Trafo/Clustering/Stream.hs b/src/Data/Array/Accelerate/Trafo/Partitioning/Stream.hs similarity index 100% rename from src/Data/Array/Accelerate/Trafo/Clustering/Stream.hs rename to src/Data/Array/Accelerate/Trafo/Partitioning/Stream.hs From 576af8dd252d60bf889d1748584d81416d1462f7 Mon Sep 17 00:00:00 2001 From: David Date: Mon, 22 Feb 2021 17:51:51 +0100 Subject: [PATCH 032/813] honestly, can't remember. Reconstruction of AST after ILP work. --- accelerate.cabal | 1 + src/Data/Array/Accelerate/AST/Operation.hs | 2 +- src/Data/Array/Accelerate/AST/Partitioned.hs | 25 ++- .../Array/Accelerate/Trafo/NewNewFusion.hs | 2 +- .../Accelerate/Trafo/Partitioning/ILP.hs | 2 +- .../Trafo/Partitioning/ILP/Clustering.hs | 175 ++++++++++++++++-- .../Trafo/Partitioning/ILP/Graph.hs | 26 ++- .../Trafo/Partitioning/ILP/Labels.hs | 23 +-- .../Trafo/Partitioning/ILP/Solve.hs | 2 +- .../Accelerate/Trafo/Partitioning/Stream.hs | 2 +- .../Accelerate/Trafo/Schedule/Uniform.hs | 2 + 11 files changed, 221 insertions(+), 41 deletions(-) diff --git a/accelerate.cabal b/accelerate.cabal index 95d0350c3..45a9be885 100644 --- a/accelerate.cabal +++ b/accelerate.cabal @@ -270,6 +270,7 @@ Library Build-depends: base >= 4.12 && < 4.15 , ansi-terminal >= 0.6.2 + , array >= 0.4 , base-orphans >= 0.3 , bytestring >= 0.10.2 , containers >= 0.3 diff --git a/src/Data/Array/Accelerate/AST/Operation.hs b/src/Data/Array/Accelerate/AST/Operation.hs index 02a84a200..24d480a4c 100644 --- a/src/Data/Array/Accelerate/AST/Operation.hs +++ b/src/Data/Array/Accelerate/AST/Operation.hs @@ -159,7 +159,7 @@ data PreOpenAcc (op :: Type -> Type) env a where -- | Function abstraction over parametrised array computations -- data PreOpenAfun op env t where - Abody :: PreOpenAcc op env t -> PreOpenAfun op env t + Abody :: PreOpenAcc op env t -> PreOpenAfun op env t Alam :: GLeftHandSide a env env' -> PreOpenAfun op env' t -> PreOpenAfun op env (a -> t) diff --git a/src/Data/Array/Accelerate/AST/Partitioned.hs b/src/Data/Array/Accelerate/AST/Partitioned.hs index 03ec25f9f..7e7123f86 100644 --- a/src/Data/Array/Accelerate/AST/Partitioned.hs +++ b/src/Data/Array/Accelerate/AST/Partitioned.hs @@ -28,17 +28,32 @@ module Data.Array.Accelerate.AST.Partitioned import Data.Array.Accelerate.AST.Operation import Control.Category ( Category(..) ) - +import Prelude hiding (id, (.)) type PartitionedAcc op = PreOpenAcc (Cluster op) type PartitionedAfun op = PreOpenAfun (Cluster op) +-- data Cluster op args where +-- Leaf :: op args -> Cluster op args +-- ConsCluster :: op a' +-- -> SwapArgs a' a +-- -> Combine a b c +-- -> Cluster op b +-- -> Cluster op c + +-- | These definitions are far from guaranteeing a unique representation; +-- there are many equivalent ways to represent a clustering, even ignoring +-- the ambiguity in SwapArgs (where you can make many convoluted versions +-- of `id`). I don't think this is a big deal, but since it seems to always +-- be possible to construct a Cluster by appending a single element at a time, +-- it might be better to refactor this into a pseudo list (instead of binary tree). +-- Even then, every topologically sorted order will be a valid sequence. data Cluster op args where -- Currently, we only swap the order of the arguments at the leaves. -- This is needed to be able to horizontally fuse (x -> y -> a) with (y -> x -> a). -- I think it is also sufficient to do it only at leaves, and not in every node. -- Maybe putting it in the nodes will turn out to be easier though! - Leaf :: op args + Leaf :: op args' -> SwapArgs args args' -> Cluster op args @@ -84,17 +99,19 @@ data Combine left right result where data SwapArgs a b where -- no swapping, base case Start :: SwapArgs a a - -- put x on top + -- put x on top of a recursive swap Swap :: SwapArgs a xb -> Take x xb b -> SwapArgs a (x -> b) -instance Category SwapArgs where -- neat +instance Category SwapArgs where -- neat, but is it actually useful? id = Start (.) = flip composeSwap data Take x xa a where + -- base case Here :: Take x (x -> a) a + -- recursive case There :: Take x xa a -> Take x (y -> xa) (y -> a) diff --git a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs index 281407d3b..4f2ef6f82 100644 --- a/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs +++ b/src/Data/Array/Accelerate/Trafo/NewNewFusion.hs @@ -38,7 +38,6 @@ import Data.Array.Accelerate.AST.Partitioned import Data.Array.Accelerate.Trafo.Config import Data.Array.Accelerate.Error -import Control.Category import Data.Array.Accelerate.Debug.Flags ( array_fusion ) import qualified Data.Array.Accelerate.Debug.Stats as Stats @@ -48,6 +47,7 @@ import System.IO.Unsafe -- for debugging #endif import Prelude hiding (id, (.)) +import Control.Category -- Array Fusion -- ============ diff --git a/src/Data/Array/Accelerate/Trafo/Partitioning/ILP.hs b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP.hs index b98d9e8ad..fd7f1bf97 100644 --- a/src/Data/Array/Accelerate/Trafo/Partitioning/ILP.hs +++ b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP.hs @@ -20,5 +20,5 @@ ilpfusion acc = fusedAcc (ilp, ilps) = (makeILP info, M.map makeILP infos) (solution, solutions) = (solveILP ilp, M.map solveILP ilps) labelClusters = interpretSolution $ solution : M.elems solutions - fusedAcc = reconstruct graph labelClusters constrM + fusedAcc = _ reconstruct graph labelClusters constrM diff --git a/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Clustering.hs b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Clustering.hs index 74eece18b..7be6b8638 100644 --- a/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Clustering.hs +++ b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Clustering.hs @@ -1,12 +1,23 @@ +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE GADTs #-} module Data.Array.Accelerate.Trafo.Partitioning.ILP.Clustering where import Data.Array.Accelerate.Trafo.Partitioning.ILP.Graph -import qualified Data.Set as S import Data.Array.Accelerate.Trafo.Partitioning.ILP.Labels import qualified Data.IntMap as M import Data.Array.Accelerate.AST.Partitioned +import Data.Array.Accelerate.AST.LeftHandSide +import Data.Maybe +import Unsafe.Coerce (unsafeCoerce) +import Prelude hiding (id, (.)) +import Control.Category +import Data.Bifunctor - +import qualified Data.Graph as G +import qualified Data.Array as A +import qualified Data.Set as S +import Data.Function ( on ) -- "open research question" -- -- Each set of ints corresponds to a set of Constructions, which themselves contain a set of ints (the things they depend on). @@ -17,14 +28,156 @@ import Data.Array.Accelerate.AST.Partitioned -- the `output type` indicates which nodes we will need to keep: they are all either a final node in the cluster, or get diagonally fused -- How exactly we can use this information (and a dep. graph) to construct a cluster of ver,hor,diag is not clear.. Will also depend on the exact cluster definition. -reconstruct :: Graph -> [S.Set Label] -> M.IntMap (Construction op) -> PreOpenAcc (Cluster op) () a -reconstruct = undefined +{- +Within each cluster (Labels), we do a topological sort using the edges in Graph +((a,b) means a before b in ordering). Then, we can simply insert them front-to-back: +existing `In` arguments are never touched, existing `Out` arguments are matched with +new `In` arguments vertically or diagonally (depending on if they'll be needed still), +new `Out` arguments are never touched. We can even do the re-ordering of Args as we go +on the fresh leaves, never need to touch the existing tree. + Note that we basically build a list instead of a binary tree. + Could refactor Cluster to reflect this. + +Data.Graph (containers) has a nice topological sort. Then we just need to know, given +such an ordering, what the live args should be at each point, or even just the death points +of each arg. +-} + + +-- Note that the return type `a` is not existentially qualified: The caller of this function tells +-- us what the result type should be (namely, what it was before fusion). We use unsafe tricks to +-- fulfill this contract: if something goes wrong during fusion or at the caller, bad things happen. +reconstruct :: forall op a. Graph -> [Labels] -> M.IntMap [Labels] -> M.IntMap (Construction op) -> PreOpenAcc (Cluster op) () a +reconstruct a b c d = case openReconstruct LabelEnvNil a b c d of + -- see [NOTE unsafeCoerce result type] + Exists res -> unsafeCoerce @(PartitionedAcc op () _) + @(PartitionedAcc op () a) + res + +-- ordered list of labels +type ClusterL = [Label] + +-- Internally uses Data.Graph.Graph for utilities. This is nice, maybe refactor to use it all the way? +-- type G.Graph = A.Array Label [Label] +topSortDieMap :: Graph -> Labels -> (M.IntMap Labels, ClusterL) +topSortDieMap (Graph _ fedges _) cluster = (dieMap, topsorted) + where + graph, transposed :: G.Graph + graph = G.buildG (minimum cluster, maximum cluster) + . S.toList + . S.filter (uncurry ((&&) `on` (`elem` cluster))) -- filter edges on 'both vertices are in the cluster' + $ fedges + transposed = G.transposeG graph + topsorted = G.topSort graph + -- traverses the nodes in reverse topsort order + dieMap = fst $ foldl f mempty topsorted + f :: (M.IntMap Labels, Labels) -> Label -> (M.IntMap Labels, Labels) + f (dieMap', keepAlive) x = let incomingEdges = S.fromList $ transposed A.! x in + (M.insert x incomingEdges dieMap', S.insert x incomingEdges <> keepAlive) + +-- | This function can - and, until it's stable, will - throw errors. +-- It is very partial, even ignoring the unsafeCoerce: +-- - fromJust calls are used when a re-indexing is expected to succeed +-- - errors are thrown when certain invariants are not met +-- - partial indexing is used in the M.IntMaps +-- none of these situations can be recovered from, so we crash and hope to diagnose the stack trace. +-- Some errors, in particular the second category, which explicitly calls 'error', could reasonably +-- be statically avoided. The rest is a result of the inherently partial practice of constructing +-- a strongly typed AST using the ILP output. +openReconstruct :: forall op aenv. LabelEnv aenv -> Graph -> [Labels] -> M.IntMap [Labels] -> M.IntMap (Construction op) -> Exists (PreOpenAcc (Cluster op) aenv) +openReconstruct labelenv graph clustersets ilpsets construction = recurseHere labelenv clusters + where + -- do the topological sorting and computing of dieMap for each set + (dieMapC, clusters) = first mconcat . unzip . map (topSortDieMap graph) $ clustersets + (dieMapI, ilps) = sequence . M.map (first mconcat . unzip . map (topSortDieMap graph)) $ ilpsets + -- ^ uses monoid of IntMap to union the dieMaps + dieMap = dieMapC <> dieMapI + + -- calls makeCluster on each cluster, and let-binds them together. + -- both of these functions still lack something.. need to construct + -- LHS's, but no type information is available. Back to the construction definition? + recurseHere :: LabelEnv env -> [ClusterL] -> Exists (PreOpenAcc (Cluster op) env) + recurseHere env [] = error "empty program?" + recurseHere env [c] = makeCluster c env + recurseHere env (c:cs) = case makeCluster c env of + Exists (bnd :: PreOpenAcc (Cluster op) env a) -> case recurseHere _ cs of + Exists (scp :: PreOpenAcc (Cluster op) env' b) -> + Exists (Alet _ _ bnd scp) + + -- equivalent to the above for PreOpenAfun + -- currently only called by while-loops, both cond and body, both have only 1 argument. + -- this is a scary assumption to make though! Can we just change the definition of Afun + -- to always be uncurried? TODO + recurseHereF :: LabelEnv env -> [ClusterL] -> Exists (PreOpenAfun (Cluster op) env) + recurseHereF env cs = case recurseHere _ cs of + Exists acc -> Exists $ Alam _ $ Abody acc + + makeCluster :: forall env. + ClusterL + -> LabelEnv env + -> Exists (PreOpenAcc (Cluster op) env) -- We don't know the result type of this AST right now + makeCluster [] _ = error "empty cluster" + makeCluster (label:labels) env = makeAcc $ foldl cons (makeLeaf label) labels + where + cons :: FoldType op env -> Label -> FoldType op env + cons (NotFold _) _ = error "cluster with size (>1) contains non-clusterable acc at head" + cons (FT cluster args) l = + let verticalLabels = dieMap M.! l + in case makeLeaf l of + NotFold _ -> error "cluster contains non-clusterable acc after head" + -- do some swapping and combining. verticalLabels stores the ones that get vertically fused away. + FT (Leaf op Start) args' -> FT (Branch cluster (Leaf op _) _) _ + where + _ = _ args args' verticalLabels + FT _ _ -> error "impossible" + + makeLeaf :: Label -> FoldType op env + makeLeaf l = case M.lookup l construction of + Nothing -> error $ "not in construction map: " ++ show l + Just (CExe env' args op) -> FT (Leaf op id) (fromJust $ reindexArgs (mkReindexPartial env' env) args) + Just (CUse sctype buff) -> NotFold $ Use sctype buff + -- for these two, recurse up (so not makeCluster, but its caller or smth) to the point where + -- you can call the sub-ILP. + Just (CITE env' cond t f) -> case recurseHere env (ilps M.! t) of + Exists (tbranch :: PreOpenAcc (Cluster op) env a) -> case recurseHere env (ilps M.! f) of + Exists (fbranch :: PreOpenAcc (Cluster op) env b) -> + NotFold $ Acond (fromJust $ reindexVar (mkReindexPartial env' env) cond) + tbranch + -- see [NOTE unsafeCoerce result type] + (unsafeCoerce @(PreOpenAcc (Cluster op) env b) + @(PreOpenAcc (Cluster op) env a) + fbranch) + Just (CWhl env' u c b (start :: GroundVars env' a)) -> case recurseHereF env (ilps M.! c) of + Exists (cond :: PreOpenAfun (Cluster op) env c) -> case recurseHereF env (ilps M.! b) of + Exists (body :: PreOpenAfun (Cluster op) env b) -> + NotFold $ Awhile u + -- see [NOTE unsafeCoerce result type] + (unsafeCoerce @(PreOpenAfun (Cluster op) env c) + @(PreOpenAfun (Cluster op) env (a -> PrimBool)) + cond) + -- see [NOTE unsafeCoerce result type] + (unsafeCoerce @(PreOpenAfun (Cluster op) env b) + @(PreOpenAfun (Cluster op) env (a -> a)) + body) + (fromJust $ reindexVars (mkReindexPartial env' env) start) + + makeAcc (FT cluster args) = Exists $ Exec cluster args + makeAcc (NotFold acc) = Exists acc + + +-- | Internal datatype for `makeCluster`. +data FoldType op env + = forall args. FT (Cluster op args) (Args env args) -- add LabelArgs + -- We say that all Constructions other than Exe are 'not foldable', meaning they cannot be in a cluster: + -- they are either control-flow, or a 'Use' statement (which we can also safely consider not fusible) + | forall a. NotFold (PreOpenAcc (Cluster op) env a) + + +{- [NOTE unsafeCoerce result type] + Because we lose some type information by rebuilding the AST from scratch, we use + unsafeCoerce to tell GHC what the result type of the computation is. + TypeApplications allows us to specify the exact types unsafeCoerce works on, + which in turn helps retain as much typesafety as possible. - -- Because we lose some type information by rebuilding the AST from scratch, we use - -- unsafeCoerce here to tell GHC that the new AST has the same return type. - -- Type applications allow us to restrict this function to the return type only. - -- fusedAcc = case reconstructedAcc of - -- Exists res -> unsafeCoerce @(PartitionedAcc op () _) - -- @(PartitionedAcc op () a) - -- res \ No newline at end of file +-} diff --git a/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Graph.hs b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Graph.hs index 0a1b771a7..b22fcd2cf 100644 --- a/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Graph.hs +++ b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Graph.hs @@ -82,7 +82,7 @@ instance Monoid Graph where -- describing the fusion rules. The bounds is a [] instead of Set -- for practical reasons (no Ord instance, LIMP expects a list) only. data Information op = Info - { graph :: Graph + { graphI :: Graph , constr :: Constraint op , bounds :: Bounds op } @@ -182,7 +182,7 @@ mkFullGraph (Exec op args) = do env <- gets lenv putEnv $ updateLabelEnv args env l let fuseedges = S.map (, l) $ getInputArgLabels args env - return $ FGRes (mkGraph op (getLabelArgs args env) l <> mempty{graph = Graph (S.singleton l) fuseedges mempty}) + return $ FGRes (mkGraph op (getLabelArgs args env) l <> mempty{graphI = Graph (S.singleton l) fuseedges mempty}) mempty mempty (M.singleton l $ CExe env args op) @@ -208,12 +208,18 @@ mkFullGraph (Compute expr) = do env <- gets lenv return $ mempty{lset = getLabelsExp expr env} mkFullGraph Alloc{} = return mempty -mkFullGraph (Use sctype buff) = do - l <- getL - return $ FGRes mempty{graph = mempty{graphNodes = S.singleton l}} - mempty - (S.singleton l) - (M.singleton l $ CUse sctype buff) + +-- We put this as a 'foreign' thing, forcing it to be unfused with anything. +-- This is because it doesn't go into a 'cluster': it's not a computation. +-- We simply let-bind it at some point before the computation! +-- note that we let the ILP decide where to let-bind it, so (within the control +-- flow region) it might be bound way higher than needed, causing slower compile times. +mkFullGraph (Use sctype buff) = _ -- TODO do as the comment says ^^^^^^^^ + -- l <- getL + -- return $ FGRes mempty{graph = mempty{graphNodes = S.singleton l}} + -- mempty + -- (S.singleton l) + -- (M.singleton l $ CUse sctype buff) -- gets a variable from the env, puts it in a singleton buffer. -- Here I'm assuming this fuses nicely, and doesn't even need a new label @@ -242,7 +248,7 @@ mkFullGraph (Acond cond tacc facc) = do FGRes finfo finfoM _ fConstr <- mkFullGraph facc putEnv emptyEnv let nonfuse = S.map (,l) (getAllLabelsEnv env) <> S.fromList [(l,tl), (tl,fl)] - return $ FGRes mempty{graph = Graph (S.fromList [l, tl, fl]) mempty nonfuse} + return $ FGRes mempty{graphI = Graph (S.fromList [l, tl, fl]) mempty nonfuse} (M.insert tl tinfo $ M.insert fl finfo $ tinfoM <> finfoM) (S.singleton l) (M.insert l (CITE env cond tl fl) $ tConstr <> fConstr) @@ -262,7 +268,7 @@ mkFullGraph (Awhile u cond bdy startvars) = do FGRes binfo binfoM _ bConstr <- mkFullGraphF bdy putEnv emptyEnv let nonfuse = S.map (,l) (getAllLabelsEnv env) <> S.fromList [(l,cl), (cl,bl)] - return $ FGRes mempty{graph = Graph (S.fromList [l, cl, bl]) mempty nonfuse} + return $ FGRes mempty{graphI = Graph (S.fromList [l, cl, bl]) mempty nonfuse} (M.insert cl cinfo $ M.insert bl binfo $ cinfoM <> binfoM) (S.singleton l) (M.insert l (CWhl env u cl bl startvars) $ cConstr <> bConstr) diff --git a/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Labels.hs b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Labels.hs index 594a2dc7d..27e6a7d0d 100644 --- a/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Labels.hs +++ b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Labels.hs @@ -20,6 +20,7 @@ import qualified Data.Set as S -- identifies nodes with unique Ints. and tracks their dependencies type Label = Int +type Labels = S.Set Label -- identifies elements of the environment with unique Ints. -- newtype'd to avoid confusing them with Label (above). @@ -30,12 +31,12 @@ newtype ELabel = ELabel Int -- | Keeps track of which argument belongs to which labels data LabelArgs args where LabelArgsNil :: LabelArgs () - (:>>:) :: S.Set Label -> LabelArgs t -> LabelArgs (s -> t) + (:>>:) :: Labels -> LabelArgs t -> LabelArgs (s -> t) -- | Keeps track of which array in the environment belongs to which label data LabelEnv env where LabelEnvNil :: LabelEnv () - (:>>>:) :: (ELabel, S.Set Label) -> LabelEnv t -> LabelEnv (t, s) + (:>>>:) :: (ELabel, Labels) -> LabelEnv t -> LabelEnv (t, s) @@ -46,7 +47,7 @@ data LabelEnv env where -- vvvvvvvvvvvvvvvvvvvvvvvvv -- -addLhsLabels :: LeftHandSide s v env env' -> ELabel -> S.Set Label -> LabelEnv env -> (ELabel, LabelEnv env') +addLhsLabels :: LeftHandSide s v env env' -> ELabel -> Labels -> LabelEnv env -> (ELabel, LabelEnv env') addLhsLabels LeftHandSideWildcard{} e _ lenv = (e , lenv) addLhsLabels LeftHandSideSingle{} e l lenv = (e + 1, (e, l) :>>>: lenv) addLhsLabels (LeftHandSidePair x y) e l lenv = let (e' , lenv') = addLhsLabels x e l lenv @@ -61,7 +62,7 @@ emptyLabelEnv :: LabelEnv env -> LabelEnv env emptyLabelEnv LabelEnvNil = LabelEnvNil emptyLabelEnv ((e,_):>>>:env) = (e, mempty) :>>>: emptyLabelEnv env -getAllLabelsEnv :: LabelEnv env -> S.Set Label +getAllLabelsEnv :: LabelEnv env -> Labels getAllLabelsEnv LabelEnvNil = mempty getAllLabelsEnv ((_,set) :>>>: lenv) = set <> getAllLabelsEnv lenv @@ -69,21 +70,21 @@ getLabelArgs :: Args env args -> LabelEnv env -> LabelArgs args getLabelArgs ArgsNil _ = LabelArgsNil getLabelArgs (arg :>: args) e = getLabelsArg arg e :>>: getLabelArgs args e -getLabelsArg :: Arg env t -> LabelEnv env -> S.Set Label +getLabelsArg :: Arg env t -> LabelEnv env -> Labels getLabelsArg (ArgVar tup) env = getLabelsTup tup env getLabelsArg (ArgExp expr) env = getLabelsExp expr env getLabelsArg (ArgFun fun) env = getLabelsFun fun env getLabelsArg (ArgArray _ _ shVars bufVars) env = getLabelsTup shVars env <> getLabelsTup bufVars env -getLabelsTup :: TupR (Var a env) b -> LabelEnv env -> S.Set Label +getLabelsTup :: TupR (Var a env) b -> LabelEnv env -> Labels getLabelsTup TupRunit _ = mempty getLabelsTup (TupRsingle var) env = getLabelsVar var env getLabelsTup (TupRpair x y) env = getLabelsTup x env <> getLabelsTup y env -getLabelsVar :: Var s env t -> LabelEnv env -> S.Set Label +getLabelsVar :: Var s env t -> LabelEnv env -> Labels getLabelsVar (varIdx -> idx) = getLabelsIdx idx -getLabelsIdx :: Idx env a -> LabelEnv env -> S.Set Label +getLabelsIdx :: Idx env a -> LabelEnv env -> Labels getLabelsIdx ZeroIdx ((_,ls) :>>>: _) = ls getLabelsIdx (SuccIdx idx) (_ :>>>: env) = getLabelsIdx idx env @@ -91,10 +92,10 @@ getELabelIdx :: Idx env a -> LabelEnv env -> ELabel getELabelIdx ZeroIdx ((e,_) :>>>: _) = e getELabelIdx (SuccIdx idx) (_ :>>>: env) = getELabelIdx idx env -getLabelsExp :: OpenExp x env y -> LabelEnv env -> S.Set Label +getLabelsExp :: OpenExp x env y -> LabelEnv env -> Labels getLabelsExp = undefined -- TODO traverse everything, look for Idxs -getLabelsFun :: OpenFun x env y -> LabelEnv env -> S.Set Label +getLabelsFun :: OpenFun x env y -> LabelEnv env -> Labels getLabelsFun (Body expr) lenv = getLabelsExp expr lenv getLabelsFun (Lam _ fun) lenv = getLabelsFun fun lenv @@ -115,7 +116,7 @@ insertAtVars (TupRsingle (varIdx -> idx)) ((e,lset) :>>>: lenv) l = case idx of insertAtVars (TupRsingle (varIdx -> idx)) LabelEnvNil _ = case idx of {} -- convincing the exhausiveness checker -- | Like `getLabelArgs`, but ignores the `Out` arguments -getInputArgLabels :: Args env args -> LabelEnv env -> S.Set Label +getInputArgLabels :: Args env args -> LabelEnv env -> Labels getInputArgLabels ArgsNil _ = mempty getInputArgLabels (arg :>: args) lenv = getInputArgLabels args lenv <> case arg of ArgArray Out _ _ _ -> mempty diff --git a/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Solve.hs b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Solve.hs index 9403ded36..fc0385ae1 100644 --- a/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Solve.hs +++ b/src/Data/Array/Accelerate/Trafo/Partitioning/ILP/Solve.hs @@ -95,7 +95,7 @@ solveILP :: ILP op -> Assignment op solveILP = undefined -- Extract the fusion information (ordered list of clusters of Labels) (head is the first cluster) -interpretSolution :: forall op. [Assignment op] -> [S.Set Label] +interpretSolution :: forall op. [Assignment op] -> [Labels] interpretSolution assignments = map (S.fromList . map fst) $ group $ sortOn snd $ map (bimap (\(Pi l)->l) (fromIntegral @_ @Int)) pis where pis :: [(Variable op, Z IntDouble)] diff --git a/src/Data/Array/Accelerate/Trafo/Partitioning/Stream.hs b/src/Data/Array/Accelerate/Trafo/Partitioning/Stream.hs index ef3d44a86..641663fac 100644 --- a/src/Data/Array/Accelerate/Trafo/Partitioning/Stream.hs +++ b/src/Data/Array/Accelerate/Trafo/Partitioning/Stream.hs @@ -1,4 +1,4 @@ -module Data.Array.Accelerate.Trafo.Clustering.Stream where +module Data.Array.Accelerate.Trafo.Partitioning.Stream where import Data.Array.Accelerate.AST.Partitioned diff --git a/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs b/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs index dc6a314ed..86ba5f634 100644 --- a/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs +++ b/src/Data/Array/Accelerate/Trafo/Schedule/Uniform.hs @@ -44,6 +44,8 @@ import Data.Array.Accelerate.Type import Data.Maybe import Data.List import qualified Data.Set as S +import Prelude hiding (id, (.)) +import Control.Category -- * Compilation from PartitionedAcc to UniformSchedule data FutureValue senv t From b97ca7523f7784a90a3786fb3ca17653fb89eb1b Mon Sep 17 00:00:00 2001 From: David Date: Wed, 24 Feb 2021 14:00:41 +0100 Subject: [PATCH 033/813] commit --- accelerate.cabal | 5 + .../build/autogen/Paths_accelerate.hs | 50 ++ .../build/autogen/cabal_macros.h | 462 ++++++++++++++++++ .../ghc-8.6.5/accelerate-1.4.0.0/cache/config | Bin 0 -> 35091 bytes .../package.conf.inplace/package.cache | Bin 0 -> 40 bytes .../ghc-8.6.5/accelerate-1.4.0.0/setup-config | Bin 0 -> 573188 bytes .../accelerate-1.4.0.0/setup/Main.hi | Bin 0 -> 7018 bytes .../ghc-8.6.5/accelerate-1.4.0.0/setup/Main.o | Bin 0 -> 3576 bytes .../ghc-8.6.5/accelerate-1.4.0.0/setup/setup | Bin 0 -> 14652392 bytes .../accelerate-1.4.0.0/setup/setup.hs | 21 + .../accelerate-1.4.0.0/setup/setup.version | 1 + .../accelerate-1.4.0.0/setup/setup_macros.h | 33 ++ dist-newstyle/cache/compiler | Bin 0 -> 11478 bytes dist-newstyle/cache/config | Bin 0 -> 33623 bytes dist-newstyle/cache/elaborated-plan | Bin 0 -> 1187512 bytes dist-newstyle/cache/improved-plan | Bin 0 -> 2330767 bytes dist-newstyle/cache/plan.json | 1 + dist-newstyle/cache/solver-plan | Bin 0 -> 988395 bytes dist-newstyle/cache/source-hashes | Bin 0 -> 47534 bytes dist-newstyle/cache/up-to-date | Bin 0 -> 6689 bytes .../packagedb/ghc-8.6.5/package.cache | Bin 0 -> 40 bytes hie.yaml | 11 + .../Trafo/Partitioning/ILP/Clustering.hs | 4 +- .../Trafo/Partitioning/ILP/Graph.hs | 12 + .../Trafo/Partitioning/ILP/Labels.hs | 2 +- 25 files changed, 600 insertions(+), 2 deletions(-) create mode 100644 dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/build/autogen/Paths_accelerate.hs create mode 100644 dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/build/autogen/cabal_macros.h create mode 100644 dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/cache/config create mode 100644 dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/package.conf.inplace/package.cache create mode 100644 dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/setup-config create mode 100644 dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/setup/Main.hi create mode 100644 dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/setup/Main.o create mode 100755 dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/setup/setup create mode 100644 dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/setup/setup.hs create mode 100644 dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/setup/setup.version create mode 100644 dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/setup/setup_macros.h create mode 100644 dist-newstyle/cache/compiler create mode 100644 dist-newstyle/cache/config create mode 100644 dist-newstyle/cache/elaborated-plan create mode 100644 dist-newstyle/cache/improved-plan create mode 100644 dist-newstyle/cache/plan.json create mode 100644 dist-newstyle/cache/solver-plan create mode 100644 dist-newstyle/cache/source-hashes create mode 100644 dist-newstyle/cache/up-to-date create mode 100644 dist-newstyle/packagedb/ghc-8.6.5/package.cache create mode 100644 hie.yaml diff --git a/accelerate.cabal b/accelerate.cabal index 45a9be885..a99155200 100644 --- a/accelerate.cabal +++ b/accelerate.cabal @@ -323,6 +323,7 @@ Library Data.Array.Accelerate.AST.LeftHandSide Data.Array.Accelerate.AST.Operation Data.Array.Accelerate.AST.Partitioned + Data.Array.Accelerate.AST.Schedule.Uniform Data.Array.Accelerate.AST.Var Data.Array.Accelerate.Analysis.Hash Data.Array.Accelerate.Analysis.Hash.Exp @@ -346,6 +347,7 @@ Library Data.Array.Accelerate.Representation.Tag Data.Array.Accelerate.Representation.Type Data.Array.Accelerate.Representation.Vec + Data.Array.Accelerate.Schedule Data.Array.Accelerate.Smart Data.Array.Accelerate.Sugar.Array Data.Array.Accelerate.Sugar.Elt @@ -359,11 +361,13 @@ Library Data.Array.Accelerate.Trafo.Exp.Shrink Data.Array.Accelerate.Trafo.Exp.Substitution Data.Array.Accelerate.Trafo.Fusion + Data.Array.Accelerate.Trafo.NewNewFusion Data.Array.Accelerate.Trafo.Partitioning.ILP Data.Array.Accelerate.Trafo.Partitioning.ILP.Graph Data.Array.Accelerate.Trafo.Partitioning.ILP.Labels Data.Array.Accelerate.Trafo.Partitioning.ILP.Solve Data.Array.Accelerate.Trafo.Partitioning.Stream + Data.Array.Accelerate.Trafo.Schedule.Uniform Data.Array.Accelerate.Trafo.Sharing Data.Array.Accelerate.Trafo.Substitution Data.Array.Accelerate.Type @@ -418,6 +422,7 @@ Library Data.Array.Accelerate.Trafo.Environment Data.Array.Accelerate.Trafo.Exp.Simplify Data.Array.Accelerate.Trafo.LetSplit + Data.Array.Accelerate.Trafo.Operation.Substitution Data.Array.Accelerate.Trafo.Shrink Data.Array.Accelerate.Trafo.Var Data.Atomic diff --git a/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/build/autogen/Paths_accelerate.hs b/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/build/autogen/Paths_accelerate.hs new file mode 100644 index 000000000..c19ebd36d --- /dev/null +++ b/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/build/autogen/Paths_accelerate.hs @@ -0,0 +1,50 @@ +{-# LANGUAGE CPP #-} +{-# LANGUAGE NoRebindableSyntax #-} +{-# OPTIONS_GHC -fno-warn-missing-import-lists #-} +module Paths_accelerate ( + version, + getBinDir, getLibDir, getDynLibDir, getDataDir, getLibexecDir, + getDataFileName, getSysconfDir + ) where + +import qualified Control.Exception as Exception +import Data.Version (Version(..)) +import System.Environment (getEnv) +import Prelude + +#if defined(VERSION_base) + +#if MIN_VERSION_base(4,0,0) +catchIO :: IO a -> (Exception.IOException -> IO a) -> IO a +#else +catchIO :: IO a -> (Exception.Exception -> IO a) -> IO a +#endif + +#else +catchIO :: IO a -> (Exception.IOException -> IO a) -> IO a +#endif +catchIO = Exception.catch + +version :: Version +version = Version [1,4,0,0] [] +bindir, libdir, dynlibdir, datadir, libexecdir, sysconfdir :: FilePath + +bindir = "/home/david/.cabal/bin" +libdir = "/home/david/.cabal/lib/x86_64-linux-ghc-8.6.5/accelerate-1.4.0.0-inplace" +dynlibdir = "/home/david/.cabal/lib/x86_64-linux-ghc-8.6.5" +datadir = "/home/david/.cabal/share/x86_64-linux-ghc-8.6.5/accelerate-1.4.0.0" +libexecdir = "/home/david/.cabal/libexec/x86_64-linux-ghc-8.6.5/accelerate-1.4.0.0" +sysconfdir = "/home/david/.cabal/etc" + +getBinDir, getLibDir, getDynLibDir, getDataDir, getLibexecDir, getSysconfDir :: IO FilePath +getBinDir = catchIO (getEnv "accelerate_bindir") (\_ -> return bindir) +getLibDir = catchIO (getEnv "accelerate_libdir") (\_ -> return libdir) +getDynLibDir = catchIO (getEnv "accelerate_dynlibdir") (\_ -> return dynlibdir) +getDataDir = catchIO (getEnv "accelerate_datadir") (\_ -> return datadir) +getLibexecDir = catchIO (getEnv "accelerate_libexecdir") (\_ -> return libexecdir) +getSysconfDir = catchIO (getEnv "accelerate_sysconfdir") (\_ -> return sysconfdir) + +getDataFileName :: FilePath -> IO FilePath +getDataFileName name = do + dir <- getDataDir + return (dir ++ "/" ++ name) diff --git a/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/build/autogen/cabal_macros.h b/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/build/autogen/cabal_macros.h new file mode 100644 index 000000000..caf258ffc --- /dev/null +++ b/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/build/autogen/cabal_macros.h @@ -0,0 +1,462 @@ +/* DO NOT EDIT: This file is automatically generated by Cabal */ + +/* package accelerate-1.4.0.0 */ +#ifndef VERSION_accelerate +#define VERSION_accelerate "1.4.0.0" +#endif /* VERSION_accelerate */ +#ifndef MIN_VERSION_accelerate +#define MIN_VERSION_accelerate(major1,major2,minor) (\ + (major1) < 1 || \ + (major1) == 1 && (major2) < 4 || \ + (major1) == 1 && (major2) == 4 && (minor) <= 0) +#endif /* MIN_VERSION_accelerate */ + +/* package ansi-terminal-0.11 */ +#ifndef VERSION_ansi_terminal +#define VERSION_ansi_terminal "0.11" +#endif /* VERSION_ansi_terminal */ +#ifndef MIN_VERSION_ansi_terminal +#define MIN_VERSION_ansi_terminal(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 11 || \ + (major1) == 0 && (major2) == 11 && (minor) <= 0) +#endif /* MIN_VERSION_ansi_terminal */ + +/* package array-0.5.3.0 */ +#ifndef VERSION_array +#define VERSION_array "0.5.3.0" +#endif /* VERSION_array */ +#ifndef MIN_VERSION_array +#define MIN_VERSION_array(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 5 || \ + (major1) == 0 && (major2) == 5 && (minor) <= 3) +#endif /* MIN_VERSION_array */ + +/* package base-4.12.0.0 */ +#ifndef VERSION_base +#define VERSION_base "4.12.0.0" +#endif /* VERSION_base */ +#ifndef MIN_VERSION_base +#define MIN_VERSION_base(major1,major2,minor) (\ + (major1) < 4 || \ + (major1) == 4 && (major2) < 12 || \ + (major1) == 4 && (major2) == 12 && (minor) <= 0) +#endif /* MIN_VERSION_base */ + +/* package base-orphans-0.8.4 */ +#ifndef VERSION_base_orphans +#define VERSION_base_orphans "0.8.4" +#endif /* VERSION_base_orphans */ +#ifndef MIN_VERSION_base_orphans +#define MIN_VERSION_base_orphans(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 8 || \ + (major1) == 0 && (major2) == 8 && (minor) <= 4) +#endif /* MIN_VERSION_base_orphans */ + +/* package bytestring-0.10.8.2 */ +#ifndef VERSION_bytestring +#define VERSION_bytestring "0.10.8.2" +#endif /* VERSION_bytestring */ +#ifndef MIN_VERSION_bytestring +#define MIN_VERSION_bytestring(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 10 || \ + (major1) == 0 && (major2) == 10 && (minor) <= 8) +#endif /* MIN_VERSION_bytestring */ + +/* package containers-0.6.0.1 */ +#ifndef VERSION_containers +#define VERSION_containers "0.6.0.1" +#endif /* VERSION_containers */ +#ifndef MIN_VERSION_containers +#define MIN_VERSION_containers(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 6 || \ + (major1) == 0 && (major2) == 6 && (minor) <= 0) +#endif /* MIN_VERSION_containers */ + +/* package cryptonite-0.28 */ +#ifndef VERSION_cryptonite +#define VERSION_cryptonite "0.28" +#endif /* VERSION_cryptonite */ +#ifndef MIN_VERSION_cryptonite +#define MIN_VERSION_cryptonite(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 28 || \ + (major1) == 0 && (major2) == 28 && (minor) <= 0) +#endif /* MIN_VERSION_cryptonite */ + +/* package deepseq-1.4.4.0 */ +#ifndef VERSION_deepseq +#define VERSION_deepseq "1.4.4.0" +#endif /* VERSION_deepseq */ +#ifndef MIN_VERSION_deepseq +#define MIN_VERSION_deepseq(major1,major2,minor) (\ + (major1) < 1 || \ + (major1) == 1 && (major2) < 4 || \ + (major1) == 1 && (major2) == 4 && (minor) <= 4) +#endif /* MIN_VERSION_deepseq */ + +/* package directory-1.3.3.0 */ +#ifndef VERSION_directory +#define VERSION_directory "1.3.3.0" +#endif /* VERSION_directory */ +#ifndef MIN_VERSION_directory +#define MIN_VERSION_directory(major1,major2,minor) (\ + (major1) < 1 || \ + (major1) == 1 && (major2) < 3 || \ + (major1) == 1 && (major2) == 3 && (minor) <= 3) +#endif /* MIN_VERSION_directory */ + +/* package exceptions-0.10.4 */ +#ifndef VERSION_exceptions +#define VERSION_exceptions "0.10.4" +#endif /* VERSION_exceptions */ +#ifndef MIN_VERSION_exceptions +#define MIN_VERSION_exceptions(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 10 || \ + (major1) == 0 && (major2) == 10 && (minor) <= 4) +#endif /* MIN_VERSION_exceptions */ + +/* package filepath-1.4.2.1 */ +#ifndef VERSION_filepath +#define VERSION_filepath "1.4.2.1" +#endif /* VERSION_filepath */ +#ifndef MIN_VERSION_filepath +#define MIN_VERSION_filepath(major1,major2,minor) (\ + (major1) < 1 || \ + (major1) == 1 && (major2) < 4 || \ + (major1) == 1 && (major2) == 4 && (minor) <= 2) +#endif /* MIN_VERSION_filepath */ + +/* package ghc-prim-0.5.3 */ +#ifndef VERSION_ghc_prim +#define VERSION_ghc_prim "0.5.3" +#endif /* VERSION_ghc_prim */ +#ifndef MIN_VERSION_ghc_prim +#define MIN_VERSION_ghc_prim(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 5 || \ + (major1) == 0 && (major2) == 5 && (minor) <= 3) +#endif /* MIN_VERSION_ghc_prim */ + +/* package half-0.3.1 */ +#ifndef VERSION_half +#define VERSION_half "0.3.1" +#endif /* VERSION_half */ +#ifndef MIN_VERSION_half +#define MIN_VERSION_half(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 3 || \ + (major1) == 0 && (major2) == 3 && (minor) <= 1) +#endif /* MIN_VERSION_half */ + +/* package hashable-1.3.0.0 */ +#ifndef VERSION_hashable +#define VERSION_hashable "1.3.0.0" +#endif /* VERSION_hashable */ +#ifndef MIN_VERSION_hashable +#define MIN_VERSION_hashable(major1,major2,minor) (\ + (major1) < 1 || \ + (major1) == 1 && (major2) < 3 || \ + (major1) == 1 && (major2) == 3 && (minor) <= 0) +#endif /* MIN_VERSION_hashable */ + +/* package hashtables-1.2.4.1 */ +#ifndef VERSION_hashtables +#define VERSION_hashtables "1.2.4.1" +#endif /* VERSION_hashtables */ +#ifndef MIN_VERSION_hashtables +#define MIN_VERSION_hashtables(major1,major2,minor) (\ + (major1) < 1 || \ + (major1) == 1 && (major2) < 2 || \ + (major1) == 1 && (major2) == 2 && (minor) <= 4) +#endif /* MIN_VERSION_hashtables */ + +/* package hedgehog-1.0.4 */ +#ifndef VERSION_hedgehog +#define VERSION_hedgehog "1.0.4" +#endif /* VERSION_hedgehog */ +#ifndef MIN_VERSION_hedgehog +#define MIN_VERSION_hedgehog(major1,major2,minor) (\ + (major1) < 1 || \ + (major1) == 1 && (major2) < 0 || \ + (major1) == 1 && (major2) == 0 && (minor) <= 4) +#endif /* MIN_VERSION_hedgehog */ + +/* package lens-4.19.2 */ +#ifndef VERSION_lens +#define VERSION_lens "4.19.2" +#endif /* VERSION_lens */ +#ifndef MIN_VERSION_lens +#define MIN_VERSION_lens(major1,major2,minor) (\ + (major1) < 4 || \ + (major1) == 4 && (major2) < 19 || \ + (major1) == 4 && (major2) == 19 && (minor) <= 2) +#endif /* MIN_VERSION_lens */ + +/* package limp-0.3.2.3 */ +#ifndef VERSION_limp +#define VERSION_limp "0.3.2.3" +#endif /* VERSION_limp */ +#ifndef MIN_VERSION_limp +#define MIN_VERSION_limp(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 3 || \ + (major1) == 0 && (major2) == 3 && (minor) <= 2) +#endif /* MIN_VERSION_limp */ + +/* package mtl-2.2.2 */ +#ifndef VERSION_mtl +#define VERSION_mtl "2.2.2" +#endif /* VERSION_mtl */ +#ifndef MIN_VERSION_mtl +#define MIN_VERSION_mtl(major1,major2,minor) (\ + (major1) < 2 || \ + (major1) == 2 && (major2) < 2 || \ + (major1) == 2 && (major2) == 2 && (minor) <= 2) +#endif /* MIN_VERSION_mtl */ + +/* package prettyprinter-1.7.0 */ +#ifndef VERSION_prettyprinter +#define VERSION_prettyprinter "1.7.0" +#endif /* VERSION_prettyprinter */ +#ifndef MIN_VERSION_prettyprinter +#define MIN_VERSION_prettyprinter(major1,major2,minor) (\ + (major1) < 1 || \ + (major1) == 1 && (major2) < 7 || \ + (major1) == 1 && (major2) == 7 && (minor) <= 0) +#endif /* MIN_VERSION_prettyprinter */ + +/* package prettyprinter-ansi-terminal-1.1.2 */ +#ifndef VERSION_prettyprinter_ansi_terminal +#define VERSION_prettyprinter_ansi_terminal "1.1.2" +#endif /* VERSION_prettyprinter_ansi_terminal */ +#ifndef MIN_VERSION_prettyprinter_ansi_terminal +#define MIN_VERSION_prettyprinter_ansi_terminal(major1,major2,minor) (\ + (major1) < 1 || \ + (major1) == 1 && (major2) < 1 || \ + (major1) == 1 && (major2) == 1 && (minor) <= 2) +#endif /* MIN_VERSION_prettyprinter_ansi_terminal */ + +/* package primitive-0.7.1.0 */ +#ifndef VERSION_primitive +#define VERSION_primitive "0.7.1.0" +#endif /* VERSION_primitive */ +#ifndef MIN_VERSION_primitive +#define MIN_VERSION_primitive(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 7 || \ + (major1) == 0 && (major2) == 7 && (minor) <= 1) +#endif /* MIN_VERSION_primitive */ + +/* package tasty-1.4.1 */ +#ifndef VERSION_tasty +#define VERSION_tasty "1.4.1" +#endif /* VERSION_tasty */ +#ifndef MIN_VERSION_tasty +#define MIN_VERSION_tasty(major1,major2,minor) (\ + (major1) < 1 || \ + (major1) == 1 && (major2) < 4 || \ + (major1) == 1 && (major2) == 4 && (minor) <= 1) +#endif /* MIN_VERSION_tasty */ + +/* package template-haskell-2.14.0.0 */ +#ifndef VERSION_template_haskell +#define VERSION_template_haskell "2.14.0.0" +#endif /* VERSION_template_haskell */ +#ifndef MIN_VERSION_template_haskell +#define MIN_VERSION_template_haskell(major1,major2,minor) (\ + (major1) < 2 || \ + (major1) == 2 && (major2) < 14 || \ + (major1) == 2 && (major2) == 14 && (minor) <= 0) +#endif /* MIN_VERSION_template_haskell */ + +/* package terminal-size-0.3.2.1 */ +#ifndef VERSION_terminal_size +#define VERSION_terminal_size "0.3.2.1" +#endif /* VERSION_terminal_size */ +#ifndef MIN_VERSION_terminal_size +#define MIN_VERSION_terminal_size(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 3 || \ + (major1) == 0 && (major2) == 3 && (minor) <= 2) +#endif /* MIN_VERSION_terminal_size */ + +/* package text-1.2.3.1 */ +#ifndef VERSION_text +#define VERSION_text "1.2.3.1" +#endif /* VERSION_text */ +#ifndef MIN_VERSION_text +#define MIN_VERSION_text(major1,major2,minor) (\ + (major1) < 1 || \ + (major1) == 1 && (major2) < 2 || \ + (major1) == 1 && (major2) == 2 && (minor) <= 3) +#endif /* MIN_VERSION_text */ + +/* package transformers-0.5.6.2 */ +#ifndef VERSION_transformers +#define VERSION_transformers "0.5.6.2" +#endif /* VERSION_transformers */ +#ifndef MIN_VERSION_transformers +#define MIN_VERSION_transformers(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 5 || \ + (major1) == 0 && (major2) == 5 && (minor) <= 6) +#endif /* MIN_VERSION_transformers */ + +/* package unique-0.0.1 */ +#ifndef VERSION_unique +#define VERSION_unique "0.0.1" +#endif /* VERSION_unique */ +#ifndef MIN_VERSION_unique +#define MIN_VERSION_unique(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 0 || \ + (major1) == 0 && (major2) == 0 && (minor) <= 1) +#endif /* MIN_VERSION_unique */ + +/* package unix-2.7.2.2 */ +#ifndef VERSION_unix +#define VERSION_unix "2.7.2.2" +#endif /* VERSION_unix */ +#ifndef MIN_VERSION_unix +#define MIN_VERSION_unix(major1,major2,minor) (\ + (major1) < 2 || \ + (major1) == 2 && (major2) < 7 || \ + (major1) == 2 && (major2) == 7 && (minor) <= 2) +#endif /* MIN_VERSION_unix */ + +/* package unordered-containers-0.2.13.0 */ +#ifndef VERSION_unordered_containers +#define VERSION_unordered_containers "0.2.13.0" +#endif /* VERSION_unordered_containers */ +#ifndef MIN_VERSION_unordered_containers +#define MIN_VERSION_unordered_containers(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 2 || \ + (major1) == 0 && (major2) == 2 && (minor) <= 13) +#endif /* MIN_VERSION_unordered_containers */ + +/* package vector-0.12.2.0 */ +#ifndef VERSION_vector +#define VERSION_vector "0.12.2.0" +#endif /* VERSION_vector */ +#ifndef MIN_VERSION_vector +#define MIN_VERSION_vector(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 12 || \ + (major1) == 0 && (major2) == 12 && (minor) <= 2) +#endif /* MIN_VERSION_vector */ + +/* tool gcc-9 */ +#ifndef TOOL_VERSION_gcc +#define TOOL_VERSION_gcc "9" +#endif /* TOOL_VERSION_gcc */ +#ifndef MIN_TOOL_VERSION_gcc +#define MIN_TOOL_VERSION_gcc(major1,major2,minor) (\ + (major1) < 9 || \ + (major1) == 9 && (major2) < 0 || \ + (major1) == 9 && (major2) == 0 && (minor) <= 0) +#endif /* MIN_TOOL_VERSION_gcc */ + +/* tool ghc-8.6.5 */ +#ifndef TOOL_VERSION_ghc +#define TOOL_VERSION_ghc "8.6.5" +#endif /* TOOL_VERSION_ghc */ +#ifndef MIN_TOOL_VERSION_ghc +#define MIN_TOOL_VERSION_ghc(major1,major2,minor) (\ + (major1) < 8 || \ + (major1) == 8 && (major2) < 6 || \ + (major1) == 8 && (major2) == 6 && (minor) <= 5) +#endif /* MIN_TOOL_VERSION_ghc */ + +/* tool ghc-pkg-8.6.5 */ +#ifndef TOOL_VERSION_ghc_pkg +#define TOOL_VERSION_ghc_pkg "8.6.5" +#endif /* TOOL_VERSION_ghc_pkg */ +#ifndef MIN_TOOL_VERSION_ghc_pkg +#define MIN_TOOL_VERSION_ghc_pkg(major1,major2,minor) (\ + (major1) < 8 || \ + (major1) == 8 && (major2) < 6 || \ + (major1) == 8 && (major2) == 6 && (minor) <= 5) +#endif /* MIN_TOOL_VERSION_ghc_pkg */ + +/* tool haddock-2.22.0 */ +#ifndef TOOL_VERSION_haddock +#define TOOL_VERSION_haddock "2.22.0" +#endif /* TOOL_VERSION_haddock */ +#ifndef MIN_TOOL_VERSION_haddock +#define MIN_TOOL_VERSION_haddock(major1,major2,minor) (\ + (major1) < 2 || \ + (major1) == 2 && (major2) < 22 || \ + (major1) == 2 && (major2) == 22 && (minor) <= 0) +#endif /* MIN_TOOL_VERSION_haddock */ + +/* tool hpc-0.67 */ +#ifndef TOOL_VERSION_hpc +#define TOOL_VERSION_hpc "0.67" +#endif /* TOOL_VERSION_hpc */ +#ifndef MIN_TOOL_VERSION_hpc +#define MIN_TOOL_VERSION_hpc(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 67 || \ + (major1) == 0 && (major2) == 67 && (minor) <= 0) +#endif /* MIN_TOOL_VERSION_hpc */ + +/* tool hsc2hs-0.68.5 */ +#ifndef TOOL_VERSION_hsc2hs +#define TOOL_VERSION_hsc2hs "0.68.5" +#endif /* TOOL_VERSION_hsc2hs */ +#ifndef MIN_TOOL_VERSION_hsc2hs +#define MIN_TOOL_VERSION_hsc2hs(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 68 || \ + (major1) == 0 && (major2) == 68 && (minor) <= 5) +#endif /* MIN_TOOL_VERSION_hsc2hs */ + +/* tool pkg-config-0.29.1 */ +#ifndef TOOL_VERSION_pkg_config +#define TOOL_VERSION_pkg_config "0.29.1" +#endif /* TOOL_VERSION_pkg_config */ +#ifndef MIN_TOOL_VERSION_pkg_config +#define MIN_TOOL_VERSION_pkg_config(major1,major2,minor) (\ + (major1) < 0 || \ + (major1) == 0 && (major2) < 29 || \ + (major1) == 0 && (major2) == 29 && (minor) <= 1) +#endif /* MIN_TOOL_VERSION_pkg_config */ + +/* tool runghc-8.6.5 */ +#ifndef TOOL_VERSION_runghc +#define TOOL_VERSION_runghc "8.6.5" +#endif /* TOOL_VERSION_runghc */ +#ifndef MIN_TOOL_VERSION_runghc +#define MIN_TOOL_VERSION_runghc(major1,major2,minor) (\ + (major1) < 8 || \ + (major1) == 8 && (major2) < 6 || \ + (major1) == 8 && (major2) == 6 && (minor) <= 5) +#endif /* MIN_TOOL_VERSION_runghc */ + +/* tool strip-2.34 */ +#ifndef TOOL_VERSION_strip +#define TOOL_VERSION_strip "2.34" +#endif /* TOOL_VERSION_strip */ +#ifndef MIN_TOOL_VERSION_strip +#define MIN_TOOL_VERSION_strip(major1,major2,minor) (\ + (major1) < 2 || \ + (major1) == 2 && (major2) < 34 || \ + (major1) == 2 && (major2) == 34 && (minor) <= 0) +#endif /* MIN_TOOL_VERSION_strip */ + +#ifndef CURRENT_PACKAGE_KEY +#define CURRENT_PACKAGE_KEY "accelerate-1.4.0.0-inplace" +#endif /* CURRENT_PACKAGE_KEY */ +#ifndef CURRENT_COMPONENT_ID +#define CURRENT_COMPONENT_ID "accelerate-1.4.0.0-inplace" +#endif /* CURRENT_COMPONENT_ID */ +#ifndef CURRENT_PACKAGE_VERSION +#define CURRENT_PACKAGE_VERSION "1.4.0.0" +#endif /* CURRENT_PACKAGE_VERSION */ diff --git a/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/cache/config b/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/cache/config new file mode 100644 index 0000000000000000000000000000000000000000..c51f540e6730796d9dffaf3b6fbedbe9e5afbed8 GIT binary patch literal 35091 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 N5RzSfU4JKQ_rJcf8I1q{ literal 0 HcmV?d00001 diff --git a/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/package.conf.inplace/package.cache b/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/package.conf.inplace/package.cache new file mode 100644 index 0000000000000000000000000000000000000000..b3cae5cf028ad4728b344193a7c6fe4e76e36af3 GIT binary patch literal 40 ZcmZQb&qyxFPGnVzMeq6fW7-|_I{84($o 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]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 literal 0 HcmV?d00001 diff --git a/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/setup/Main.hi b/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/setup/Main.hi new file mode 100644 index 0000000000000000000000000000000000000000..1cbd2840e4d5a69ba3e19c82cdbec0825ab12c2b GIT binary patch literal 7018 zcmb7JYit}>6`q(RwG%t7Zg+CQ-rAkFFuDmVT4|lfcMN%ly5XFSe-rA zz2~g)*N%O=&cFAYO@COj;8OZpL4N__b%xUHxy^E@c_`+i@JRJQ4Ja0%Scsw#MH7leC>Enwf?_F(Whj=TfOKW0Pe*Mt zz5!MNK+$RdC|d)7rnLa*cq;(JtYdH+gY^t<2Y}TZ7;L;B2t(S$U^9a)4DMjCmBBU! zA7!we!43u=W3ZD!3j=TFpmZ14U~)Y(+8DGmNH9n;Km>SXgo6imGeDqtHC+t$F!(rw zI~m-?U@wEa8SG=w&7g-tFM~9L{S5jT9AMDTAj9Aj3_i(VfWaVxgA9fk3^Vu?gAoQ< z2BQoPF*wZN2!o>xKF#15gL@bpXYd&Y_cHh_gZmf=1~~>A1D%0nFvcLyV4Q)$APmR} zt}z)D7+4H!21N!Z01)C1gAxOmL7Blx2B#QIGMHlU0E5#EKF8qm3?5|g5Q8%S$OUH^ ze1X9i8GMPsIR+0imzPNfAszr-grCtQsyF z8VeI{g7e@>d}AIkO_*tXV-hicm~ecf4KsspaM2$zfa$O0!}F+zZ0JB=n_l!+=^gLA zp8m&kk7OEm{piB){`SYjU+UmvNP$K$5ezIDS`dhk3Q70|H%%|Nun5+0A80`|Kr?vg z3l3h$g!OD4+Q4O9ABGD%U=Q>_Mhm^r4Os{|u1B!3PS^tv!(Q}7J&y;`i450CFP0*H zlk`F^c;G`m`hp8t)w2X1`oqKMi{B1Ze(m+vH-9X?cebexTOOoAGFTj+Jo=g9kG&0Vf`gI3 zGW3VFsK+m|l&ASmuQU%`7`b%u=TBaFVb|~9oi~RX$k^>GHa_=G_w=h>_dj&R{PPb{ zSN}5<&nk86t~9-}=hF1I{&)T4+}y98f(nJY)!&%+_!)&lxK2?XRrWl*?cMADI#{nx zCw_YLGAQ&k%$@hxi=Hj@L?fP8xll3oKK1_KUH^W0y}n4f=f=G-jGl%qD7K>rYW!^v zZBSVCcwdhP6;A}ea|^<-7!Ou(Q?JMgv!z{4s;#QG7Za&TIF6WVX;nMago?SwGdCwn z@D`p$Il~eT7%8Td}UPg)abSbMoSwhOSN=#C3f#l$=%5g z*_r4{Xj(_Ay(^JQw&uDz+7fNaRC}wQ%4uyP*WNMK)hUFYNG3Z{ovB=|E7dl})-Ka* z%cT)Xr$lPWoNyeAbt#J_d4lvMF~Go>rMlrr&9!L&Z8X5j5SNS@rYs6~-0RRD%Bjzf zYb`~`K-l70XjrbyOQ$7YKs@1TD7f$<{rTU@;-YX$Qfo=5ZE9OZ#iF7kT^EX>8fy~I z;-X_~vQ(n#PI5XM+UUwjIIEqgJlaOrC`hVH(KuPx3fB=@I!eOT0r7yh^N|q^VXbEq9WK3!9&f7E1CktUU>V_ANgW40xARDB?JC?H_3tH|yZrnGe7s0SRGw;e<9vS~Qb->deSwm_D{ zQ;&+C%BonIHW2-}vTN8DHE0t>dVQ|4A+}NNE1Tva%WyMDMtC;H^9F6bY|8AoDDnWe z#1n@d`GL73Qs`5?cA-eVvv^duMdW(vAzPH%VG1o8mT#o8CQ2d^G+756QN(VIr$&lT z$jX9|ckD7RnyABI2(3R3h7}PN1BNE8Fcelr+Whez6ye;jjWl~Pq^TsnFoXTs;q*~8 zsv+v#YQp|WO%^f3;goHTsEcxGxtFT^cI%APP}-&$DI;=BI?~cO0&b5ojY83s{z4oT zPG0hau8X79IJ?F!UsT%9*8YSltK-DT~hF~hW!L|$erUE-vJC!Xinc}En~KEvWA6{~hQ;L#fPrPZuFRvXYpr;3v8iw1u{ z%t|+m>*Y~bO_f~9TSwGpPpaCTGt#n1Nr&c^lW{bJLteiq@d}GhtIy~m3F8Ifu*2_& z7*fOWQs7*ic9Fo z*Eq@Q8@($AMrej7m=#`KU)jQK6em<<+Q5`$HEncE3R+f1S~7HOa4R-OMbarpFKgU! zNu*=8%!iVNUOnB)Y=hT{e}k(%u>04(ur|DX1%~-Uj82Y!t2|th?A@BkZ+x0+#4RdF z;as-_b(tY@Z*bNQ6fE!zt-fdY!=)%46vbL|!ZuoDwQWoNA>Z7|zk_D6{nJT1zFUmE z;PPBK32gSR*K`}B+x{^9lZdN!TbAt#I#Q_p<@~rT4SWAHKqFgo6SanL3yHyQ6?h@K aBFL4FP@`vc@2cu8grG~q7T59f`~Ly|)F9vJ(lXZPLRM_;IelgfXw zK3)6&QRnccnxVtpm^0t<0(Joo?7T6T*9+A`sh(t03O}3rId)ayZ>Ihvdqm;yq<)TV zDIDA!dvF8=u6AY25s`GSa?%%L_?Kh&cVqbVG5pRLenmW(W8%4Y#d#2#za#jl>-;v2 z&#`(MJv@9gCjK(kzl)(%{~FfW7?wz_>tpKthVk1<{2ycDnNxIiGv*PCi>_vRK`YEG zrxV7#$Ys5v8=G;&!B|L*sHoYdy)Hf$I1X@Xi^Gca40_;?{^d1=KgW+xrX zwmONApLXJFi8q~idg51VrI{Jsohet`YN=LooQhtomGttoU8`s%t*jTPo4W02mR+p0 zYE{c>mdfRdUe#^8rfV(DocF|pJiEueFi5<{B_3IcH=ivbX47q1y$**(Yqrh>~KWl&q#a;ZK(ga_@_DlAn~UqejMvSyv#8?-Ju|aW}3$nz_L9f z17{>I&tY2P^4#hYe+q3-t7xnB+Y*=Ww<~dZJ{uB$7Hv>h(T4i;E&%#Q;xG%^Nwy>| z$NwmCh^PH)TjI~74eGYUVGduRe^=q(qt6QQy3Z|JXdY#{O;+S~tO9p0aaKspro}B* zu;WMxd6%==ZGmxc0)y(o-P{ZBwcAsbSE=t23^Uqhz$ zugfnv6hgsrDS!Q-z`iK2toq$^OeNqj|hjmC6>MQF} styU54pr-X$oga)@ogMTu@F#9wDNcRqnqaROm46u;3VAOdq5uE@ literal 0 HcmV?d00001 diff --git a/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/setup/setup b/dist-newstyle/build/x86_64-linux/ghc-8.6.5/accelerate-1.4.0.0/setup/setup new file mode 100755 index 0000000000000000000000000000000000000000..90983db6be0ab578016d3adeb67a765681e5262a GIT binary patch literal 14652392 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

wmv{9|pOgeV9ITnjZgpW5n#e{!QD&%{cD; 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 Y=E6-_a1(RFb@TEq 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

~kGZwdu)aAkQ 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

H!Rw}PSR9Cg~s#RE>wmPmY6!?_E(54|}ev4G#n3 z<+oGi{I18jO_PO($mtWqL;C?$;i31rTJVq+kd@$}8FKUCVT_-u#KWYtKTm&aV)7dJ zR8{h7`Fkz$3J1%p4t3*`SCOCINqPPL)QQO}{pqUY)$nXB@+yiGP=c=n>c%Ip24w$^ z%Io}7O5}xEWchKvnLl%0!*?+-?(DT);2Fqvb~mW=+=m9)EkP$Gba<)dU%#9;fzV(^F zdW@S%HqW^F*dQ1-endtW#vEFl8(t-=f{T4iUzREyGjoMzAbq6WnO*5Z-p+l(eCE%Z z&+nD_!k6(8?Fm@3ENO zO8jBW_)Ge-|RRaFfBE^oe#r!XyQW(4-I@6!$XV@ zX*@LYA%llHK4kF_Bz|0S7pjWQM5LRddgG>?pEeK zOITNd)ebYlpup+WNYCb&*}|Hvq}fksr*Aw^(qnxe?`Fo53q1#W4ep&bDyKMK>V0>i+22>GVxg-x_F-QWygtcEsxq2+OfPRP z2gcFn74o0t4O_}swSpyO!DYQTWoyb~aEu~2>pZ^*W3?rgW^IRsxI1AH?(R_7y~sy8 z4r3@5g)3Zh+{pt=BF8eQ>uGo#QvUH1omS0V?`hhNfP9_v!OG^FiGE@He4k*x-*EG7 zR0YO5({b{3&h`0vx$>%Mf0@FSJtC}%USWmv{4}U~Hx^HXQZ=KF))RgnI>C`cqJ$r# zUzYqGIUMZeXWs6DfzZL8HXIe;mA&LS-_6sJfy^I|BL~N=INh7CTkk^(e?%$dkRm%{ z>eCVc6b1ipq9DWX*`#I@qH%U~BF5dSu~}6A46EwKZ#tsU-USvtcR@%FK5Lgx_>d~( z^948KVEF{(>-Zx_dgY_)MGJzO3fU+b3~5%zmBIgf!;wK81?S=g^z%$T8T)DBqrvz^ zpLY3}x049HA+E}9GPG1uu0r zfs^;UIZh!?GMW`rZQT7_qAM33?-V|63cs;9Y5wB)IN9CJs|-#891N%i$oS*(-;G^N({x(QHJ4zr;ap`jR+wd^zmoW>iKF0r@%YXTp_((obDr znn=h%VLq!_C|A}?=R0LJttj_}82e!SBjY#Q>!$Wq`On)|_Q)lY=BcxkMgD$sWp&RjeTvv}Jo4CyyJ*Am_tMZQ?>o8x3#3Nn0W3eDf zTKrYKpYF}Jvgeim;v&7{=-PEBieF>-a~0`cQ=ab0IKE3{?73G`af#t z_qCJD%Ha&d@6{VY_sa5g&ogun+X%XcmZ!VS(0%!(+U4-#g0gbxHFPiE2)dV+r@PY7 zJ!B*39#o!g($IbW#oFbt_N20M__3jT$wts!QJ(J44BgLe1lAHzpEaU0yng!|a$KK8nggYM&)`;b%uNU0s)- zhXn9vjm)EX?L|1Jvh&Na_FMb=rXAzDyiPm)2UL2~-r-GtthYGht(=jQak}U6f!*!& zELC^zzMDu7!<_Z~Y(?|`z-k4%tGgCm+bzW>=|tVT9%;Y4$ru^0;zBoP^fp{>p-vU= zzN;>O-`AZj*)bBnOqM~!o%PI=*PzG?JBl#smgsw;`iNeXUbv5bM4ChlvMNp_;cN`l+CTLqVvzY z91}ewjSk0wSsVh<5vlXC;cSz=J0I$7(% z@tYUUP&cqEI<_7qk&npd64YLRd=iw;${AeuzVN$tK6uVH9nr3s1cf?aA__dn!uR~I zAZ=?`aQ?P?7I^omrI9b>>G**UQ=Wy?SBR|{VU9lGmRhPvfym3>w7Hs0jc`AW&3}4J z&HsbJcAyvel;yuzmjApv;69UYjisbad_1Ji{nrh5)mTPl~a%__;|cY*1W71Ny)n69N_ zx`PAL#VV%TGB90k(@N!g;NL-V8LF7>M}g@&E2cXxFkQT2y1fF^g)638_eN0p(wkJ0 z%Z-8Q`YWdUZeY6Bis`--n69B>y6v2F#=kapp7UvSne%7|rM>$w?abg@`e^H?jedI{ zTm{2TQ++dJmvsJ?3yzavJ;&bAugN@i9;44%(ZTt}Xuj?3xt?~U*J@9L?bsQ`Ao({} zO!t|{vNyErgid&P7|2c~PPm~QvLbfJpro?9Oz zm$A1i$>n!}>5>)GofDX@%}UovJT|q6TO1t;e;GX~jYaMX-o@GXZ}3b!4!yE4)V&r? z_M4k@d>-jTZAd?oo4Gc`H1B5`2cL}3UjpDovx-Cj@FkyDV(>cXCH_(BKdxMa&undc zhW&g-zg8Qc&mUBl&mcW-QT(d@*xy-b>_cq-I(7Z^(J_bz>p-TBM!Q~yG&u7=AIG?e z-skfFI{zCUmnI=DD|1%f;PP<-=oDogL9Gm5IG{g}s z-s)Xv()AYP3y&3R7`p$4nt20#vc;-T=J>X^3M0j16eAqlL=gs27Rh1s@UMxv5-O`_ zg!@rgba4`#f2JQo97K_y!Oi_V%0hR}>M(9;mm~Kk_(G9GpeExF$LQV}{O4Uk zhid=~UDLmTeeIWi@N|U2IW&_Wk>w5i00%wO2?w16wdjPQ6r8lh7TRsDOj(c7`m;$j8pvu)&OP)Q1i2qha8ZAc-+$7EZ@8*H1rBWymu(4@QwS&<2;OkTh+-px2oq3I18(j z^a&0Ktd=-KJ~KZlG!8IN_=L{uls#S$S@ z1)tP}ZDX?{met{ME`uD@gD9Ah!zmv+1gi{`pqW_CWnfM4rNEqu&7zW=>ApdZm|>Ui z4Pd`LzwS?nrx!?}BJ1FGFu@_DU?)!NE{+m}Fc|h+2X3r|>W= zM^54)h4ya@XGWz<&WeJwLib|~?gz{<$=Ejk>=_0Zv1p+#nqCS&{qj;A-(kp5Ev>BBXozf7m! z0{I$Q5IFQx8viNsQ0H*`5utQFS{HcdTJ8ns&R9Kxn4fl|jMW>DW--R<50$a{Ov4FO z&-oZ~09f1uII=-D73jxAosekIN))Xskt`&Zq8|MRM+dpyApa%2d&hmrcN_eAcbq@c^E-Tl zK051yZXxs8R`3zbcQ!ySAR#}}?}c1!`oG7wkqcoCAVxW%CZ$aS-$(9VE7!R)z}N4I z`{=9!9VU74UV=DuqSi{TFXVK@>>?El5qMZyr01J3UamfouY#}K&tr5FltRO#gdT+? zTPw+ktf7Pl5d=x1mWMSe$_{n-ncek^^9CmvBD$k zcp_$pdu~lHlIBC#FCYo|kuUz}Z{v??rPC-s*3%x2^H%5V0h6*frXg_N>Y+Gq^>CcG zI_EH)xq1XlIF9RsKa0pXu1}rYhvWLxxqUdUPo3MRPgyk$C9v50O?H^n3DryL<5PX| z`?2+0$xcAZSgXj>o`30oPV7*X^Dn2))ngVy$F{4KqZ!xwAS%|a6MO#VW1jh&+S9*q z`o!}8wI}^9;F-4B@L}~IIsYA5`V#O3V`3J?MwX}f0hO2<1j^XxDp#avh5af`1{`4X4m;lbrPxNIS?C}M6GJ?V7)Sj(Sb(e^w4)!#Z* zk$|K}LM^tRXX>Nk`l%BRExYdG_hvmud}OrNLEu}Mb+-{5I* zSm>@g?M=vW%BB@B&Ro5DJ!Qqkp|3iz#C?zfuAP6oK!&5x4x9B7rkykUTEM^ZzwS`{ zXEUb@|7d?#%W32KUWILFTg{+5DW-FhZv^xD843*ZoGkGP5{%@mku5fdSNt zVHcg78FemvGi`rikhnx+be{)Y{K_%a_@qzH1Erjl6Ay((2$(U&_kO~-F5KHdmkSnN z&dIj@IoopzwI#luCojQS^BI9SJF#;kadzom9-Og$_-_X?fuCtl zW&;dSV+B9$0l)0?!$EZ$?xo0!?Wg_)^4U#xe7vDtl|ugG`#TFS*%NWwL4#`}udw7Q z`D(wMOhCU{&NR5@LG1H(#=;eaZ4HaL0to}Uf!1us(fX;b%vzH+w(`dpHc-|g25`eyw{0PcCtS7hnKs(hJj zyOeJW94Ic(e}ywleXly`&nEij+8U6_A9;$S0qxB4SHBVsXg9?a4d@SBr5U6)vvV@U z5)CU2m=B%cDro3%KcB`#2ucI=YWNI4WsL^p!l(+$rNHPSiieFT@(@LXqXuYCjh|!c z0U8&x$F~oME+~*R3iQ(I1};6;G%9iq_LBPCXrE*{W-`4OoeQ0540$k9zujo5J>Rj?d@qoEb0*(8mGceN zo^O1iF``a+&ysu_)QZAF{z)ups8HU)zq|EXrJRRL^ZmBu8#ei#P&wb`+VgEZyQI9Q zNWKY^?~A~1h4L1kt+~8|rTKnC@@+Huo?SWLf!gzpEh;JR*CgLwlkb~Yx=^9KiQ4n+ zFU@zF|T&d!Xd2m&F$HTUXAvzxI54OY=Qa@@-V^MInDFmO@mJ zbG-I^L+6x~SLHisNoUzWXaVtCh-y z{63ZQZK^%rw#6lK{;1^JZ1TMxOCKtfH~Y7m@tiHq_d}9zyUF*U%K7%zo^MNMNqKjX ze3K^MJFtYJLU|i&&o^C~@Ai`KkjeM(%K2upHOo2i?UM4oNAgXZd>{E&#qxI5o^Pr& z-%TXng2{JY<$N1z&$sD2CFOl%A)Tw}9O(`f@@xMYSYFdlF#T3*oJhvamcY-78$atr z`fy_fbksN^q=qDNa9a7MW@m=T$I9vT_c%SdCyl$88+}DMY9vP(X~j62oL`QC(hnJ< zda%o69M0HC@#}ib!WqY<|H_}~KkaV2elp8~p#tT(=8uszX6ig`(@&@&{jcow?6;Y| z5A(O=B>k!GFF=ALP4g7LlvBUClWBlE2}}<`&)qLk)s+%~CS;j_J{Md`m0bwR5!-o4}EERQ`8@Jqa-+FMMu-$pKn z(&xHe{%ZL~y4iz)f23Yl2E;wyeaDWbep6kEe6iC`{ z+l~PS4Gy2LY{xK(rTA&g7?434gmMPt2h|!7jx%UQ>x4w|zv_1kNGsoejCThY2KTo8 zI2gtj|PsykTv!sTA}pTK+RIIYe9t0<+- zzu3RQ40UrN{F`x}3WkvUQ-52!#A9lBoyqZOlMq`M;F?fw3VLzkskD zjauskqiDe zrYr_hGLXni{LV9jGH3g*tyxX=qeHZuPOawM>y%Z-qF}n z60`JP&A%>GAU2IeWcktZ;ceLQRu#ksq8RI;EY0;ok)9hsO9^YhwEu%jhZW$}2w}Dx zI&5n$l)1d-{=8bvwV*F!_b*@OK))G$<)6m89>-&u`7^k&@&9vt2UePm{@zShhX<Zkr4OK2bzyBD#zW)zjj6aB>in>EdL$pGX(hCFiyOT5nvoj0Vk!+&CqyC zx6%IgcfRi^o%q|Q;(bAKsjd)%LtEcIqwI;#-|i*0b$jD&Cd>0(gW^duv*Nt4w%Dl1 zeApd&5YC5^3qs@Z{a2I;b>i@Shse5lBl)hOc^qlhR)Q9IP(YQj{C{9fu60x=6#iP; z$sl}c)n895faOKWUV~2Tla^MBU!xbY8k{CEO7Pw;ttGN?6R7nECPk+4g|_hRD((giwsR72frE*W9 zuR69dCW>tgi`ar9T2;wuVg-@U!X?r6D9A5}KPcl*;umzUL}nuc27h9l?&1nEcrdgv ztMa$6!(MP_yh8Y5dbTUh{*y)Q?G;lO1@hCe1N9O%vnMlL@WyNynk?~`*hbwBfq)(jU4Xt^qcDP z$3b07*G~>JzE|#7Qto5mKL7_EJO|U3Pp3)GT}<6?)^{vq>5ELQ8nK_-k}b_Yd!I+X zfA-1u6pUs^2qP)qk=72j2Ez4!%pX z7fybkayxrF476?uRSxH)z^TEbvBO+$rG~kpd0y;lhqo|4R6sijA>NDKKL4?a;jUd; zA@0B37gU7n^4CJ`b$`aDU%Xq^dnZi)h38xfhy_epXqN$#8Y_tb2ns^z#ij@{CEG5j z0Kdyp3=FoaRgXjD8WCY*ePSqIq+KCN<=v{wZYwBvfX z?bRNVkJ#Q0 zz?k_t^c;LF+RNr?HS0K#r;+RG(TP<2jno~h2I>jJ0c30NoS%+HkK@JW$NYv@d+Ld+ z+Cyn1^5Zi9*ni$Ocr@wh2d0=_+vlc4_e!knZ4kbg$c`EZv-;dx%Td;KP%vcNC};T8fWCThZ>Vo{{VN z5e{`3oWTjUp~FNBx%{7QnXB5^5V3r|tAsNJZhtmP=zLx!k%_1-T6MJN4zrW$8hcO%(W>Oq%yK&R zs>8-@pj={FE?vlga%ny-ST2-NS-W!G`yH7q+QY{0w9#SHzdYtjr+;b7dtAD6%G15w z(A{u_Lzn&&+h)IAnKs&T+*;hfe$ZU+{(y@8=0|ocTdu#pq|X67-_74H*AVIx@)CWI z`*rJFi|#C2Uex!tE83w_>lFQ5eh*C_evA3hJ~fkmAN0H*MHA2Hmp29JIn$J_x7T(k zTfT=)`L6!4BVUt0<<>Y}`L49+mXt4XCCm4_<3xVB{2`jYuYBn{bos)td{Vwu!$IZC zF`jPkzTlVh4i+D>_|(|d(J`^7IYqmWKNYm89;J3t_$WvJ`uDl=^U`ng(todqzVRRF z31t-jf)npPOhBRiDr&tfj+H%FJ8jsLT$*|y4*Hp1?=$NzzNcgBk*?#Fz|c^QIgerw z?R?|o<(sRVZ>S_+id0-49AN1@O1?%PIggxF`Koq)YjA|kIm7tw%xk`c7pg@2dNzUB zDBw&fFO&Vyjo^*jV`Q@n_SA60^q~IMiD&v`YBx3dIlX*KCcq9K`kNq+nb_#UG<3Ex zJ*tTEWsp&ZayssC;!7$~DybjFqG(YWC*7_eGA1Znmry~u7X45d)(^#uJZxTHhwW-y zV}NZle^ahRA^(BzIL;?!pbWIT&xH6GzD@8QjF03`E8?S*={Eu&vGMW^UtKZZY|5W+ zb@<3Jozl0+(v87KGi2h&$C&eH+pY`c`_~`u*#|YubnvT&2jpCt zjuGFu)|d`2ApF*U@BDITvjC?aQ;6@({rnz`k$5YZ7-_rzIdyW)fAE!t z+G*#>f9h7^O)srkF=xYyufD|tQ9BMohs{~LFPB~9;y|zJYGXo~TPAWaTh?@D4CL~$ zPRy)WNo6BOF7}f$Nk2~s>5c|krKcw|u+)giU8#*(c{K`UD{fc^M%W8y4N zU*^TTP)=jFSqsVj{CGEgb+kJL9EwNS*)wS-$bo^i4AEY}Q{b zR_7(Be@P&!@zH`f;~XDdsu^MX(aHL>+WD(gm4>>0?QQ3W)*bJekB>7Qn&N>$r=90( z6eUni-5xJH^DuUPO*&l$>3r?~=S}->$8SV@Gk*6|=Fktu+_wKfk&JJDAj=hFK4||P z-{CrZWcoNb)Kh5J>Umd4Uw+b_LXI+ThieRhzw!Kr0nu^}(U0Rdzji_Q!zR@O8kgTKb;LubW-&USlrFN z#9a5faDPAjPD6k7jEtceYlEtXmsWw)<|EFH0Mn!surIsW{Apm{+29q3-v6SkSPsH=R{g(cVm7_+F`3YR07Z)Ciz|<=UjK?< zQ1m-U|3*JpQUB)6^ypuJ{I<$JU2x=QaAw&Bt`AuFZI24!{DA)7vzV|2923)53vi9p zUS27lcq&P|<0uwB963HHa*GK;b-w`N!ILJr=tt?3f1awc{fL8}sDNufUPrsACm3U> z;_>Xq0#tO9QLwLg3h%QY=|R*GGqNm3R`QlR?#dgBCdGo9A1SMc#y`FUvB^gGzv-u7 zTZ-6=LjK&toHE4`CI1@kr-HtidbH&2Z08bv9BUk61uA=yG4{eL!}xbCiy0|sGh*du z;U>5}86*E}uY&NrZr6%Mc#f>A9nWq5Qx%>sJGojs7f?_oU)5Ah6wgsG=)?2g z|8VL)hPt05Ja>X|AD)LK?Fdrax4L=R0w|R(19{g@R5dp0l9m!}BpOICVdXcuweyEZf!v z;n3yto;%}n<~Ghg58mj-^OMt@G6|mNoKPj6(^7#Gvd^KDREMS(``q@&aq#?=_gBR8 zi}A{MJ~LN4p2Ndc;rXB6s20yj6m&B2JOp|^JTHIVsryO9bDhq}!gDi(Gevmryvd8_ ztq*a^BzW#_trE`zQh^h~bJ)dm1%GMbKC}A9X7;@SPibaff%g+^$F!qc;(zO6fO4^g+&0hUmagb9c(Z9{+SE+w7 z5SpNW6x#?q58pBlp5NZCBA&1OTxC4(@l5S_ZW*l#&%c;gEuOO|=w!AhAu#B}^Jo9& z)cqv3Cv9NdhvxywdrI&;cB>c9BTY`31kVS2y-GY6qyi_@o-}L(o_kZ{;Q15VRK)YW zpRJ7NBc84u&keU#h37xFREy^!6m&B2oCZA~o=;xm)cqvlxk+b~bw_a9A)G1lkNR)- z;`zl-J7p3)pKwf-cuq+LP6*G9E}m=lk3Pe+qo2V49zW*U+u+AEO@QvfLU%7e-HS*! z?$WK=KMLPDj{f~FTv7iH|5RoDd+^EH^=}Y-RWTlV)ZA+IuTcn2o`2K~dOrPo{s{-G zlc;~gca*dz1<89#+LO9fUj6&lC!I2h{;i!;rT)e5GWKpd4mH>FCzcJVVmvgl5qQp! z|8nD@YqqF}=X3Y3jOPuR+VR}Ex+**``)aj#4hg}@!*dMue0bg&<(zzfzZW&+^N&)J z_mto{H|E9jmHRnm53je<_5e^dZHAD$2Ui&OV8$ZL|u_gi#EmTgNyI8)>w4d3g< z^S%2zWs0Lr`9r@_C7!cVffMqNT3kHW>>nM+w4+Dke~*83=P>-3)(OyEAauXtr+XUd zwoQQU8AA65eWrbw@o4|?_bwFak5qSxR0a+P{LEEPB* zz3$uyJU6Gu!SjN*D&l!Fl(*8n-SP)($8!OERnd>wMwWF{v#z332u_~g)em|;JYW5Q zQ}>gI=aA0G!gJF@Q-a_G?)U!1t0!-M*eR3f$=TDZ)RQ5pzzNy? z7pVr%?Lu(!?0ypTe0aWg%&GfH z#B&h{V@4L98y}l8Jhx=Lc-|-Glu7V>4c2c|W%s+l;{@$~|3=`s?(uQ({L|Me;`yLG zD&zUqRkh=J7<^TM=jpOsq#8WOh2Z4jxfS$$cz*0Ir|u^a&tpKC56__|rVP&wPkQk@ z?}JX61kaBgTqT~H!Q%w+JmBKFWO?&);6VUMK%rm0q9rd6KS1uj_>1 zlVF!Q>~LQ_$uE&X;?F1 zy-sZeo>Sz%+&stnmn!1<(z?oc-Z@n}o?Ek3;rXfqtHpB;1)a=(L>LVE@VwuxPTfx; zp4-8=56^>=_mto{{WmY3ug6(VHlFuslKQTU=b}{Lg!&O<8-eHKGvnZSuNNxf`3{_? zRH+|v*e$i=xp8e(c)ss5)#7;=1)WShXF$(~=i_g7>V6XO9M>6T-E|mz>PL)81x^UhX&28m`(2MR?dSve-{W^Zbv68$%mnDJ5xT4VbeEBC z)}?Foz2Z9A=yT)f-!Gr5sDFpPud@EFzNvQo8v;yHtYPNsiU1U(;~54ql{`$@FVtvaKu>mT()I8)>wrT*c?^BwPX$|QI`2-KV|} zx=k+Kvgftz6O!{!a(U1%m!pwiscJ^twzQ%nEr zLceCY?=5oQ1OI#c@f*4!_Xbz)HPijL(B0Wj_gKlAeSZ0xsg?H&Kc8Cq7YhBF z<$i?7{V>1WpS=KbZ+7KgGu^pD_Ygnbi%7R+0(9pK-B0`Jeu{KkCqVZkp}Vc0?o(Z$ z+vd`pI{e);Kz!6J=flLlF81?XPrf@{zH6p?y3jq(Pxrp_LAPrHbng>3+Y^ zdVZhve8m}VoX=U$x1a8Q|FZS`!fEdJ3$5pmTF?LeEjP}A*7M`1y5GNHJ?BqxzxP?s z+gr~+Zgb-tXgxnp39GVm9hv!=aUM*uZdeh2YeW5At-pB+xHISG@#xmxgK@sAzGtE2 zyyTY6A#={Nb>EfCpMi@c(SYN;-ctJd{NfM%lPA=gV7YI&f%I{lbrVRs+8@?d&m2rj|&RH%3?VMZ~<8iO)qzKQm$~(LTBH(o8iJr6E`+2wi<(%dCmS>^0 z_nxzS=&L80F;Y2ac?9b}Ue6;1&k=HAe|@qxB!Xe-+`b)1Z2eXXO9KMnocQjYEI z4Bv}d-CP}YJZ+eIcq{)K-R>+pxNCSY8V?>Hfq~Rx($vxX;cEQ_9_7dKw2=?zJp7JJ z>`)`@CQ||ADRk@QpBu0s>Ii~U3!e)Wie4rxufr`Q0}u_ z`s4E(>3J5d19`|=JYOPrA%_}OHX<9`SISsP>(ed-NtdZp{&nPaO11fS{95v^RGx3R z^ca80;-VUP#kZ~?udjLOM^$_&IOsFWUh7kNoE+)W8DH)lf|E=ozGhZSFVZs|a}i{8 z(4vWYlym1z9hv%Z@fzvbLDzrLN{4$ZNUCug*CLquw?2(i|I@1FTi3s$T3(M2bm>X` zTU=CC|Jzom|NXu6qbk0q{;f~t>;I!JovP};5?>#3=}FyMOjJ|urtK<}dl#4f`24zd zB5cvrcA`anvhBpM^=TZOY+r5u3Mb)6h4Q?|rAK*XEH0{%S6e0en|SFrsrWWdhOAHJ zaq`B(YTHq<6CpI$XqwCG$1By+bL~XhDr+rvB4+Vo?zb7wzFhyNvP&)AbR!Avv=Db? z`|Bg141d+`_b@MW|H&?>Wapk3-QOwXw|m|6cgo$TVf&N28z-+&0EaW>+KxrITcq!f z{9lt!4}o_g(Zy2t<~8Vf-x=m&7KHleDaZB~|6J~sILUVMW{ZQ@xcyn7*|^qccHb+r z`ckTQg)2y;gO%ueW%P9RvPV}+4}5kOqj;f|9- zdA}C#+1d(K#QSoh`L$?tP_IFLI+D8n>W}#XKRv#K>#v^qcl2p2Fa3k20*h@2umaUZ z1plT#jv)n0KKWa)x}rjR*zsRB>DwKDJYkXM9S1U6(Qf?ivU1%h{J!n<*K5P?5QOBx z?*}ig5x)k`);xPT{1%XzjbBzh@vHv6GI}y)Gy1%o7+ns(zs2BzRX-!0mGEoiL5%Q6 zK0A+>PRF&++ff zy;O%jBjY7zoWvTRk$T<7wx4*;c7i@IUvl4#z6aXyY4X96masn4ESf*R&sle7^xEWG zd3>f38T;0E?FV`q9Wj)R2F%c7IpSY;>wP|yw$a>UGs9CT=Q3xkb58>q%p^w(To{xr zaa9wIYR1?N-}MNMD(8Z-`=(s@C_mzF_-n!k$2%iSufzvrUrf|F_6qom^jw4Q&XqxJ zc**a-DN5IUXPe=AEv*=2xgB{M=oe0ptsmmsa8V0qjGPXz1ai4eCbOlwJWQ2Gj&4*% znXU?jAtv_%FR@q|M+v&Xg!5y4CRq-r{~qZ%9&OynO^C0povk;-H-BdQ@pO;Kap%_< z%D?}52dQt}Ki^a(ljdh_qSg@#5&UQHWZPbKUsC!H51`7_{es5siq41~H+Uq`bjvt; zli0=5o3A+b)t|q{ayY;B)6O^}F=udRaEx+Oe)ciJMk+AT_c({U(e@@( z+sm8OBRy$Ebs!*DEPf&cn<3@6Lo;H@!5QzmAH#6aM_v{UHlG1&+r8tnJbth%VVTz zG5FEj65VfvBP*Xl)>N-tBMZM`ejN*6;Flu#GP?5uMc_ITQge&mCOqPyLp1=ce4ToG z5cP&Sn~l2r->SENEfX7)g+xQWl&DiZVN_3@RLxAO8q3b+FaM8RN5=Kt#@?BFH~5Eq zTa4j4#>keE8&c!!$MQzgMS2Xp9RQ)t%J9CkAqqJwVoyP5_#I8CHo^}(GI!_f7=SCaFdR`Y%$&lA!(nFbmdfwKitwhPP-oakkzj5{#-?W_<+Z1^M`vuA0}j@ z{NXdd>)?7EJ8Igg#ol{iL2?x1AX_MG&vA1*6*5Lcm1_Yfs@c|e0K-GP7nZ7!fB8Fp zeJL3K)7Vnu&p7_4@#hnJN%?B?=a0i8ivJV-{9hp%nh$5)hSM&>V)sD#R~PolE<9ge+rr-K~(R_MF&hm1aQTxW2m+m3aBv1Y^A z{8BqGuZ|23r_j1EuQ9%*i~3D56K`M`J9c0aCD0tDO;;mNTjBcR&5EmW#(TnwKX3ci z^s!3q+cd1QKxxXfZ@t2^Y2VVqGs^>>2gvirj`#GIZ{L~|HMVb%4D6(|Hznge!zjPg zUgh%J-0U6iIre3xUmzhrV{af3$9=DLyeD~>;G|6Zw~y8SRWaW4f%~QXtGaz?+jk?{ zhlAJsA88+MSu{@jkb-EHiNM-H#{f-myeIT=BhPnb`>^b#{}b)Q7H7NdLnkHbRL^+h zJ=eZi(moh_Z2TkWY4zhhtpEsZmVdlw2s*>>8#&%HaH!iZR59Mu28-lc&Z2%(J)PE1 zAPlB8#RwA}?+Jr1$j3L{lS3A!>lQfP)9+a3GUGj|FG_jc@t(Ry)M(In&v7ppyAohu z9lk1!_Y67=1&{Z{!H*g5iI1LavXZ$p<4+_u+<~TaL9!(voP8G)-X0K6%$e}sfN2;b5Qe=Q(pT}9d7#5#@?CyFA4}3{C3~5DFB|lCV)Q3JN(~VA^k%E z;e!9}J2oTzoDQc<`7?YP{>-}xH~r?|aR+)^YTSW3VA7JVHI7I>D$-q#(2+qba-wIh z2b(zNonMMY7w$TLc`EcN+Z<=w{sQBSi2x2n z(g-WNJaj5P!!AGW*kxE~H3s=AEMFaMOW?S+J5JMa$jHz7UN&==wQ$MT|{%8~UGxgJy=zb|Y zs}Dm+YZ85{_fO>xU3?O1|ITotC$(q~_CH&SkJ8mGP8)sizcK^{#+lwaLDb7yuU?Vv zi|3T3`?(V|-OD$E?xp4FZe#d8WFzPvRG#jBhVJuk)-H#&9cAV4EkpMbmu}g4rh{NT zed`2cpLhC)k)=1Wl2Lu_>sfvCi+Iiz4&0KY>dXNJBNFZqkI(rI_bM%GeS z28#m^Vjv!qokNQ-tAvN)SNOoe5x$L?@O1p*=OsLoz61{|r`P|QDwbuWoQYHzhBos{ z@e~q4qAx@Z z%cAphl*QR~&WerqE!_=V_4LB)k~zhHKTZ1rGV(L_)b@KHVj&7$KfYKbQKa+B316SnH7RG*oR z|B!tK>l&h_3CnMLDo5VY-!SE8J!a+r7Y0Y0M0!pFj%0!w73W*`Fw)sE{v@eQw~KVK z@E{Jhpk5tU!amYR=a2ceGMw{}zy}tZy!eQ<-asPZKh{svvcXh)%+BX#E}hp9wA$Z8C%?!SH}Ta@{V=XHbg1N@l8Jt!yS)sOgyop0K4 z-@tkI7~`$P!d|XFGV;hAtmW~(r@Zob=E?sBc{GeCk4CWSmB*TEgXGb4x01&o;!_?C zJM8QDuCxPn3^#JP3Z5;69g0&2#HOp2N6#RpW77p8=_gKd=mg>85vu#7;-l1VlGXSj zemOk)%OE*4jwv||AwK00d*8k&llqbWD8r5ZZXQ|M0HdGiE^ZN7x*gPjh>9zrY)vhE zKj-F6a?!)|YDGT_`Y``nqKe1`1$F71<9?rN|h^z z_>@~Ny01v1d740E8%ks6fc;S^ovse?L>{+hyz;mt^RALdFZlGz1{l1CBo zDUVD9^5`yZ=HjI7iz1nAgK;vb(>EZN$mQC{ymDDAYb)M0I2iz+Ub&oeO^{sDcPhC= z4^?tWZ6|Ws)RjvYLSR(33zkb#r;j6+$mNnpy>dDJ(RUSIhQX&-F30^mNG`*7D7iFD zS8^HLR_RX??~q2Moc?s_bS;P{@;Lu5$A}x}^Uqrt&u_m|GlV#O@^bb&`j>Zy{SJXu zuN-&!S&$stZ&z|`M||pC>o#8d-OTWD?RV%)B9tA1@fX$f2S8us9r?2te@{R1uEJjv zO5>H=nyZ84)^wYa+aTgoZVg*2{6!BFY3x`Ie<7VNgLEQ~4G(+e@!-SnDtRPO9hwuM?rGQ{ZW;xi1?ICW)puq+14y_Dbvpx z)ae@#OXPCx-CnsYzWZGzmjUqUmCHFl43bOwMqS@WD!HUWN`E@>K3+ekU#E*Bp2*|! zvA}k+o$>tkd+@75d_4QzF!t`S-#L`eE5}b<79_{sKPWl2plHNb=Z1YuvnuUz8^g!7 z-#I0eGVOnZrr(QLBJaIdd-3=Bs&^IsVsrd*TmOR~xi#OQK#5?d; zwx3g{)1?qks=*}#-sf5c<%c_@`zur(tRdlXMrc6I4 zq|>L7UgWajPOn@Zyz^Zpmjp`V)vpJVL2_yMA0?Mz#HU>9-V(W3<5Ueti(Ja|b8`Q! z(&vy~62pZWJuAv-*~8~8xcn!cuRHCR-*O5z=Mc~iUpY^NL4=~@s^ zaCLs_7&Cuj#~XXZn}3Th|5iOaYNj($d#?vKf7jzvV4?u=-x`AnN5=}6C6SU>6PYqje!WaN^AGv*PrmLezoyfr^KaGpXH@=Wan!2Q4Ve5t8=QYv+E;#G z{&kv8XudB0KXv)>J|2#;b-MhBr^G>p<Q~8(0L$gjdWb)rTIRAEE{vlufVNEA`ye|K% zy8L(_4-e^`bomiamH$t`gE*!;ZK@1LuR;b*Q>3SWg+@W`PWpbYd|LnMl~0?_XGrtc zsQC-G3V&ts(Wuj<4S!pKzW{tR`|{7e=FLC%eqB!FM|(B&ijq&S%D=3=7}DvQ5l`f^ z{HDPC)A#wx@5{eU(;3qFH|qSu-;nZ`#Ydw~mp1ut6`X&wFaPYTzVh#=%a8n|`~_Wp zm4DfGXGo`OMm$yiVZjF+bc2spg%2JV8R;3shJzq{4BhLMPu#~}Lg$m#{6#f?4c{Ce zA5opIVEB9fkAd~m=*vI#idQ~kJ1F@yBR|R~`LdGFpvu22K9V|JJK~9aP7cn0=pJAB zefcLeowUwBs`GC+VSIc~ez>k~^^9=*M94%AaSDTahjSjO z-Ch*8SLF#IuJHBXADn)nEd5;m2d7_XukXt;o$;SG>A1*p(-)`2MQ@dU&J3)Vmj#O9 z9CDa;6PM>t8~*vr&xLMH;lI%#{5Ng1PuA2a|2>rd^M~iabj3aXc>kDJ4h=6KWmf(P zo7o#q@~mr&gFl-mneQkJ$f%yfQ!#ULbv&U@A*=Ta`6lpYt&C+2_MdcCDBp_w(GJLu z{fkr-^1%^MHV>;sE?GG>7ffmM{KN{vVM4uaN&Qlm9OsrHGw= zO=z80PQ%xG`HYiKw;pdV<+oGjp#5w)%o}v ziv-oai7I$hZH_E1v}N53a}J!A?DfvNg%%pL=-n9?9ti zllJ=9uI(gW(c@0h<5e&>GAc0ppcbgdbniOePAh&K+~^~EI9vKb6W_*XQpJy|bAUF~ z-(UFcQ^sGg)_NuW#(sTJpZ-Nx7cPw*7PThJ+;n1k$qT8F9dOvB^NuDWsxIK zVo>fnHM$`u`f_xmV=rfIYYZv!PyL>zI_|MU_)b2Z<5X}iUH9euhEbGUr^sqPR+{77 zAFdTQJmtO19p`7fHxXigHh7u`s|jk%Dw`T{|sc*U=~_`oH=C2L=Yl`CH2@9 zpw_DAP%f@h&x(oo0`kx%wE+}Iib3m#3rBLD`qQKNv(}-#2%Yw{s;47&+ar_=8b``* z4g9Ei7rBS1(DE%ba6FjNdoFBvv0A)Mxfxs$9|K4~i|y!&bN2%__CVXH&MuB%fqcL` zJ(4*21@C8g?&#gh>}LS&XnyZwb~E~C_^|LT=Nx<)nDFdjiJj(PUGPxm-VQcW2^Doe z!UpSJS*Jqr&mNXeZd)@y@zbl8Pn(KbK|b?#w)WUK z`wS}9(^&O<6sqF`SakOKRL@8A8CA=pQ$?*L4~$cf%ZHrHTt**0x2x8NAiI*xfmL%~ zPa6<8^MX5L_@m8BWcf^fTfMA4hvQs(q1!Y2Zm2KfncqUt(Ukrc#WTOv;cr%d;{opc z)`-9TIUF&&Qiad#TUOts!{Yec4v>;=v;Nj%#b-F$zF-J2xq(CZ7>Q+&%|+=!+c9MhJPXZPzD)YPJl_OO)4v=*DvK0&Q(}e|8-3- z%a>2;7qwxfALP{00~d)L5`EZ=w50wvI0UjQh$$#Dv?aO`fj!E$OA;J4Bs-L%wq06Aql6#h zw;(?D{b6gG*kZ)*h{Cyzq2*}E?=YJ-)6?EHDEfsVMIXl)9gef-d2BA4O|_YqXM#t1 z0`}`NzufM^UoonRgtP0R^VTNdYp{IrO_nz?w zTxVpz^;QUhCC2HdUHop#iSLeoviZVKacp`a9h^|zB2i+_A4Ph0fls1tYssB0pE+S1 z>3J9|a9>9t}?A$#eh0VK>o)t(8 z@1)5wAIDQ^pm1p(S({ify*^Im%DNlBxEr0P*veME^vphYBYFcieO1kW{vc#jPHq9^ z&2L>}{3oHywa~xLiVvaiM;!CVeh!W-hU{@UwH@g95p9xMFa4KuFQ&~>f_X6IYR#t5YO}rLNfHyRwSsg zS^UK*L$h=E3oYc)&tkMP$hN~hXLM@xtZQ+go;9n_!Ftws&NzA&Qz`v=R#0iG)U$Yp zq&4KW+&*>l&t1A6w#s{f~FMsIK`r;|k2)3}j5Clk9WACi7~q_XI|mkMUIRUwTo)irr=~Eo z?P6T8;8_vE4S~DcU^<@$4%8jNiKSJ@8wReXjp} zQIaijaypu3Yt_xBh_GQ#)jDl@NN!diYz}+d%dYF zph@pG?YO=fy1rQ{3PGbflX4^z2M4*hDrGytJR8E`)REhY89<+0Rf4t#G2p4j?NK6YeC&KK2Kp_cAu;I$;=vy*fe4W6)4o#;GdmKdK!akON{$KE9R|r#2 zNZo-oT;%lPjgoi>-58yirRFIncH%E$qmHFB`BSe@hbOB3j2Rzx#0r7&=s$>I7)Zgm|D`UQP+O`jkuGWu_%aC)9HF}S+lnZGprnEC;BobwUo{DK1U z4ryXQoQHkri-&ml7!Uejwe()VY0{2pKC|ypp>FWYAL(WP1r}G&h&HJRz&+TV&k_4N zCeN!OC-+31MzFP1QoH>xn;$h_S(YCjhUURfEAsDNi{ZF80k*HQp7bQ}7#Lzdj?6$G z^H;n5KN}}8#eXOaQL}f2`!Y4qIl7s@;Bq;!#yPInb7D<#5T=#Jff7o9z_ihaBbZ3( zdz`J!8|b(}95bT%x6W7EV&^;fPpR7OELbmY(s3n)tNMz#d1wwSjK(|b&eR|Al)Ome zDe}^|cuJ7IA5YPqjmOjCA5A8nGTj;mp(@Kgkb44(QypbVaVb6zQ)T9~h6cYS!;43?%0p5hm3Jl&di z@I*g|ShaCid{J2FLDyiQXs4*3%1)(SuTacq@1+yQ zm1Rdb*hwSN_&p8#@9%w-*N*iU9NcyM#n`ZR6&=j-MzU~zA28`_2V0Sjl+%bxyp3R- z*0e8n{WUS3uD|ZP5ki(Uhn#)PU;YC@rZbNTOE*Va9oA_!26a^K5nP&rRC7BdN%!a( zL2TcenSGDa?7az2WBG^BX4^G-AgFun_TbCl$GCxgPjo*6JNR#y@Nd&cvf8IVF|R^e z46U?H+tkxkGAFiAvHa?yH>U@`FXeC=IFH3HG=v{B8dl8ol7;iaoRKX|8*Sg=d1w%p zyXY(2^8ZN82MVXV?KE*%ScgQep8e2Fma}29@ixYIsFxHJAhDwRRwPZVxN5Le1 zdNk5=I5M)v@2z<|&R<8C{)ueCzbW*QS?e4rPRM)rm*az5{>>MDSjOi$EV_d`BZjvf ztv8OwGsgQp-!_$RJ6Yd2;W0qHLCW1X1EapYw{>m~0!~w*zNuyfl8mnI{B_oob!!D9 ze=RSO9Pj!S|38-B?*T6^KYNMOe%kfjCFx*<%z3h#bR=#3-z@l#qtv=#sB2h(hGF<; zJU+YDVkQE5CA>6qTZU?OYdB%UGkRv@uf`a3D zi2>f~Vn<$vKZ65XK2`d!iHo%1t^2Uo-$=X&meDR0Ayuh6pZ{71h}nj$edUDP1&e5UrO)4*g?C6zcAw~E6L}MRieaa=t51ESm!HA4viqBLKyjQ&BN!XJS>0!}|I|n7gh|i-WAr^3M9}w? zd>n$zwO;~2_q{GQsSnLtv`rfs@k1Ss=bjy)t_{82u=&qD+&XK>y;va}c6f+t%>W7(uFBii4y8?_BiLsqV- z=)P-AOvE}+^_qxh`+QBk*vcphP62urcj;9CJeD<q5aa@<*?QADUm~CUdf@zs(Gj7(0N(ya@f!_C30xU zDLI75(mO4Ot{>Jehu4=)i5z0jD>;P8(mO4O-XGO2hnKsjL=JVhMHMEi7$r-SBnSGj z#&@P2;kse|oObbYSU4Cpcb?*0et=O+^=`v{>Johfc3V50rzNmx@WWE{&r}z@4U;u& zXyCi;#^IK+mdn}b-vPsxW>l;a!iuZD4m3o{=bok3k+4DS*u~k`%R6BBV>{59W%(_? zY4e4Pa9i#c3qK1+&9GHu`GbfG6Z!!%TO0y*%&^tqkNLcYT)mOs8V!giS-(oQnX~F?cC!00%z->NTX=w#c=7Sb?}L(X0Or&rEZ7NGyeSDcU3jRSa4#g>T@v=g=$V9d zS6GaG`QMJ0FT=hUULc-@Deq#q&GYsX5=pl0ddN3!li1*nLo}h3`NKd$`;Fhz4Fu)e zz6R;t1zC%w|B@aMpJhhO_}~rVgQFfArLyq=cLtI+L-T30X-yb$&^;4oNXMfQ!pJ|+ zW&DZn;WK~CcL4d4jJ}$^!RFy6mMqV z*dI^bCEZ0*cD$rN-iySl8iV9a=SX3(Ss?F8*Ti%X^>9Ds!~RTN{+|U7%f+33w5R`Y zSVQgW+e25fu+AL~LFa6+JmjN6MXj)2*|W#vmThZY-=3_VpW*8GvDdeMyk>r4S5+;a zgo;{0KK95{X+O~Pt4j7E3|7xax;j2KZhd>>PpXzji;7xF9vF>v*SGHstQlXNxMMrk z^(Wx}f;+=7ZO+=#kKn~DLvM|+0lT5zUWPs(_VR{$H7B@CmZ7KgH(6GWrRfQbx0u!A zT&B*Y=Jqo5X5fo-+hkm3S$(?|zeUIIl(6abU0I2|s6I)P*00FoGp*SGKMl5_R@^n{ z1^p&-3mLN_J;mr*nz%teNgI3xpK!P8vigORr&z~j^+0rVoI8NijPO@C^5Yw#r=}1!pHl%C!|55iY@NHM+|9H4A zAdo01Q9**662(gpfea8bwn`?e6xpD#4XO+*c&i(AMHqy2buD9Gii%e8Qt?6&l>%N0 z)!8}50tgfk2q+N5OFmX1AYTcf?Eij0=kht97Wkj{xnrb>?W= zqSx2Yw!NRPjeFl*WzR*2tv4>?G6mo-_%f~}1kZ${-GSqmy4@7(U9oC3qoI|Re2W;~ zg1pGib2hvOUx-_ZEP}Tr-6r{pIyhkXk&O_P-GXZUNFUuSzJ2AY7;Et!DA(A&6aUx^C_P*bKT1-@7S@A%L25 z*Zl@G*x3w%f1P!!Jj)LO83rx&e~0r|P#}fzB)PtT$3D6@m%O11PL8b6W0>`#OQikV z0tfjyiB3t%i^;c!wXaBf+225Y0tN-$>)P3UvDlh7D$pVsH4k=gDwBCFBA^V~Zt+v1E zqUjgwS&d#3h5ovA1oCdNo)f9UfwQ!rc@t6f_hst zY5IGo)W+K=mVEa!WxH^hTbH9&+ay51)toAc6BrTo>Vr0Bw-JIy|s_0&NWL*xr#h zrDxs-{LWwZe$*-+i(17$bIA3lBft1p>>+;;X!%vH?{4)X7PNsBDwYdhx+`!XN2f+B z*{exD|4i-*=J{9bth4ZOuVbaUCZiYaKr>%Js9|C~eVCgj*1G!ASzD{EXc>q=jTUbJ%>?NU{fZ3J=&q!D)gK(2LL}) zk1ZEFUmB|C=NHikbP3~=6q=Kl2_)@&msOnEI)1DhKDF9Z}=f@hj^*Ceah>JU#1RsVk!2ug5J* z5j1?ONeq1I>3MEWZEqTo?ik~OJqxjvzpUG?MaX5(|S^&yj{_J)5vyRRG`1*2M)t$8vRqh1A4>`XJUgS^c~Pc&3m1H?ma_l=)sST#yz_BebFbj_s4xJ z8PvQln%h9@fX_uu2mJ$VgL`K_q%LBhy>-VQ`=6CIE_z?>_}$L<%vRa)H;f(b`PV2^ zyxXrez|-G&Jtm;PW#rY-|3l(uz8w}4!xdYvH@r|nB|{lmRrp@waB+J#)-wt#0(|VE zjS1zd?bqaoCTwvwXHfQ@g*`JVn(*Ii-UHL19u2dU$A>I}V}le3@?vF~`}z6Ytky3b=12z8}4w-q3IU;H@D1oWq7Jfjcb$G4j6 zE$*ftKiu-x+qfE(=kr}g{AEnu&Rsum*7f{T0pCf&Qbp1&uPI0c!A5>p@{gLH`T@Ks zh|X2@!;XB0S@PKrVM)#-jA;V*+{dgx-gg21fR6)T+Q29I)FNjzFsKRfTY}T0UPh%^ zu~pcVVkVcVYEIY!%|yp7wwgyvfyYSnN1z!)ZElXoz0H3o1oI-1U0DF5=kL88ZP0dv zZN*pe<i|Wf^VRYJ6qt70rKJ; z6c5iw@o;R-9q_{lM6UvZ&Nc$UCgm!eMtPdaugmgvjW5CTq?!o?&zGI^AHcKHyRLj> zZxg&wKD1n*81Qv^T^-lqOGSlT-yPnO&nP~1@fuP6o%lD_6D6}#9;CaJP|{r(FnJ2M z|5!ohufwyE(e96OQ-Y4Lu*ens4JeI6)BqBPz1aF=yIkn=N8-yDK#q&(nE>f{grAnN z#jC#Oq{uF-{B{FZu9))v}+JJ=HDsrw7Bal zZIOPF76PpD9yxE_Cnb(EJ}<`~VLKbgb&-h+id+K(NUj{Y6kf zs2@PUDf(}*u-s_;JeArq{NDaUj;%^r2j73D=vxzW5EIn5gPebTlhU{6Xnh;~8TIWQ zAv;-0-@aI{Z_^w{>02W=QA5ksodJCd&G{&n8BhF_Di=x$i&1Vo_cpMoxc368l^|3c ziDVS#MpW(txxU*OyP|uxaraTx-PhEQPTcA2HF$6QC>c6T@0zW_m7+;S%MzPL$%+Dg z1(odQ&w`KNKjV$0M!0^JcVvxzg%&aj-9SbCDo|DN12nF$U$a)fK280~q9$Oi{YLTx z5G|#w#Pw-UnmEJd-?q(Y2Z2lem~;*1;llK6n(eioP2RwteLefdkJanhh-#mq{sEPt zV;SqN!crVP`+(L*6#~6(ZX-S0A}~&&XAd~j>e-6=ts-qqqF!~xcvm`PjE@{;Jdsg(*B>wTB_{U$>`nvq{ z$^GL4(GLFctKvRAiW}W^#Ck4(&4c`AfepxGGvskmD+o$#fajpHea#!qV7dmr@`uTi zlljVRjr+a@eO>ps^TS#WCi9PFU*$jSAB*$;V4Kw^m)zvzl|Q-uyXX@GUyl0wW%=(Q zP13m2qLrxb)2_O2g}T@I6<3c}eo47#qTGYFzCUZ_{y;Gf#?LxMyW**v$R4;Kr4u&g zR`2jK?Uc(u0~{A}n#I0kBm3aCZ&z@LA3nmt9s6+ZnJV`dS7W(qp6|J1n(8<_654&q z%*lD$zD4*04*Ve)6KQ=nbgK2Ng+hm%uK8yMH&pR);ujlV1^5RD4W|#Irt#aJP~nqU zWA0Bn@fA=UHS}q0jx~K;KfGlFaUpT4?}y(kx>yRnu zITu&&j}Pq?^v9Eg6aM%Z^vJgO<5ZF4*Af9X{`iX@sq@G6xaORw_~X6oD>>|K^T&sb ze%F3c?+9U5{&@U|GZB9@ClP}HF{_O6q)(sn4g|Bp?u>w=$+sWi|MX{9^8@~+|K3H| z);EoaJ-7vy3X3deX{02f&r&o$VFHJqKCyD*KPgT;pXw_E}Tnq$5;0RgpLmtmQilKGk#?c==Y?6EA$Zq4nsbu z{AZQUfIVm8O#E(R$vbCbzaahDC%9WzM3y6#n%&t&N(^?bQan0 z3-z41E)De@yHuu|L>3is!y?M*uFv~;;!of!3y0)4jDC>mr=@S}^#e4iuOH|P2mRGS zi4PgyII#^5BOBY+y@JBcB!tLiuXdesw~(DWF&*L`Wx3z=h{11w{v03rx<&FD;riNb zA6M{*KRhOr`1*R;sY+ib)mS0=x|(E|T%)h?2X!rw_`{!a{b3=-TNWC9U7ydl^mv*2 z8d1Vjx&E{I*E#X0O6dgXk%GR~^gu3pXRWV`f&_;GaqkDe#}Gze zx7)ehSPl(C;ANT0eR(o?MqF8C2~m zc{9&(Q|3v|gkwM)1o9-U9H%BvQs$W3;z#Q|$q=jowLajFj!7O%=Sl8(HyI(q@Xq9D zs9&6YL^%)HeH)bV=!hOgrx?fs-fK?a9@Gmk#04~gUa}_;9-^|VvV;|C5!|hG%L_nq znz}{ubEa0z_&p;3vM&-Y|8?zkTrhrzqKVm;T6Pl2lC`yHc6{aEBw$NY2noCYgze0i zupM;Pfb~(DBwgMG&Ad=fXL^75iTa;1kLY zS4PM+5h%7?Hy7)|cx?$>HB5=Oe$Vd*cG~Glc2E z%Qh$UWAgHFD=uuNRU6~6oC1&KD91?qz+&-A{^q(|VYhzXtcN53WO``WXboPRLao7@ zAczN-4!yq*!lh`x-MMm|_LvkgbSCF)n2&N6Z{gm&Erp0y(vkL9v3i!ROH$sux(6-I zan1cRUq>@4P%YtE{Oaw!;7lcCPY{Pm%8^_5Re4QzC(t8CjKHrZxE3^o}xZ(we=Rh`Y=Ul)F1eWp3MK6%rqo zjakPW>hE~#8tXjNokfluh1Lyb3Ge!*G4bPH!b&*g*gZx}FxD!JCH$iHOrHXC=z6Rf zzz09nAJvkqI|DvRSvmZpQaq``y#$eR2sM$w8dBZ>@*A!`8BzU{jvOz4BVbA9?qgpH z6Z%p>lHL;8ri3n+!4M91zgq#G>~b4Z&~U#A8f!npg*V6fpuY-tQ*^@Zj@v$=;1j2#vjAH)*f^gL@8`(N+mVq>pC+QN9Q6HLm1=ZL_si# z3j@%cp(aP&+UKG|2BAX-$5)C*=bvEcb_LDw$0YGt6i3x*8hP zQALkdu%4zz3VbX!*6d%o?R$0m@?C5%_1-D(j1P+aarvrEwX3G=xZJ#A0G$K|fmUEe zJAiq!|L4kclKm~cP^+O>x|~1Q?JW=V6+g{V&V_?em$A-7hG-|)M-@akq`9v@U{At?f?e%|z zhxeWE1De|NOb39up&%CTLE1{*N$&rUn@lCigd3}Oyvv@LWsZp!Nc<2pzH6^KSSPOT zQ;Dtq23mu~%EP}AA;P`CC<+TaxZOF^@}s1$<~M;42{S*`<4KI?!h5e0Mpo~fXzf)c zA`^7NUf}@-rf1YmtgzwZN>|U>kXrC(DW-b{5K!vlUUSnTSxbLEXutz zy5HD7+IQ|~OWk(-d=*QP&kg>GuQ>Ya^9TFkEexQDx=6o8b%gMaZLigLIbX*= z9)MsiWsp{Gd4PkhAiB!lo8B(ys`&M!oR1%p73nZ<$2TjvGw^Wykxs~+;)mr2)Q&%b z@d035QAcKJpRH!$y3D6`p0Dk%<{^zZm!Xrx-}d|z`5XSt;uz^Acb*7;s~2x@hzcH< z_iVxPcM`){{x;+C{8r^$S%=W21B_r3Evp{Umz>ea6Zk^n`qkIqTcWY>+ge_a_3RCyWGJNUqBzXr>1MXhWce>YhCeVwB>Ir3 z8jyTxoxKigUwT+rkoV7}yc^%I9H%1ir}Uy6rV*oml|`Z`szH=?^r-3m`F(qIldH4T zJDxh;NU6AD%Z{^T9~!ok1ZP-5@LL6ZrvxfN0)7v3J39NV!a{)@{`{Kpcs@!qkbwL2 z(a@`FYVqa6JLrxtcHZnkBtzll`1SER_dp&0>_Dg+EGil$jstms26-3wiN;s&evRaD zsjA`19U~qAhH4ECwO;a7JvtCGe4t~mSkJA@J<=b6AOtu^&2Mr|rXN|b6)ec;WnFlE z=sw)k&}^uD{y{3OSykBEH7-nY(59DuL;;d7&{FNWAm%pFkI~`xGVJCc?`6FGw6H%eOCF#79 zU5$Sn);@_Tw11rR=FU~}mQ#Z;P_ctR-s(x07JAo>>+`X4FoC&=+bK@tGO!~~0^i+1 zQNI63tq+Zkvg@%Ys?U0ka9V$wSKu$C=Y4CFDjshT4$wBRTPb)v?tFeU@ zCvFYo703samtN9ya(T%Zd8u0mC^SYup?kHwq`Y^}nM__HIpH6Pk0B{?&N0@b^2=f8 z7Aqr@!}kNq2Q{Rj5!dC|r?SXL8j^>_mNO+T7OA?I=*H?aMA^F_OOS(p7{?(84m`&7 zg~#)C@~nwh<}}bBCXc)i#^+e=YOLCLo?i`17l+YF_E^ua0L9jsq4QWh-T6xl5Y5Zd zYz)1Gc&U{K&2uXjs5I_HT%ra!672qUsL8A*d%eG?`KuG>k2Y7#SxZU_f1h}=o{o+j zK1-IQd~cD?`iMF^H=bum#=UPcJt*fX<$Q4I@p>J2t)Q_EAHZ8RkLI8+!VxO)CN4pI zE}jq0X$;ir{m^rjm%&zPJ5h^w5;&*kp`MLn9x4cP9=sl3fNQt`TvMFaRs6nLF>kr> zd*Sy5egBwW!}5La153K+ZU>GM9*t(6AU+&MWbmMvkt$U5_iFsWkJYneBA*{eu-wx-ERRHvpf6&xX}J)8?}TmJ!DP)8aGUhYzZi2mVN6L!s93 z+5ShI90}v^NJY&{IKew|WXt*;b#&88D*GqG>g&~84p(}0OpO(ySEEts63WgSz(Hi^ zU|x!RB}&of=bw?Ei?T%O*KOkGHgw8z*eSpGR+YZwtz^ zVW=MV_2PQ+Wllh}d@25Tt^Z^E&J)GXFEu`ASFkJ2Y1wgJ=pVfLDb_QIzc@V6nBRK0h2LV6+wm?n&$Rii)Bvt2_>K9{*y@*Yze~C0 zF8J}dBH;}6;Ig^jCHXg^v+?~d{Rb&lZAZHhR{gi#?@|Ss9R-McjOf?CtovR1HJPUu zk90h_P5c!{^G5n?U|aZWzsdQlDEODSc3SaBwgFt^uPNj#w)${r1SpG2?&*45ti*RZ zKUF912nezj!H4T7#(IuGOAruWmlaq6*RLR7#RsLQ*XPe%8PwGrC)bprssMB&DtA4Ey-`7CIkG#^cRFa!jb#_ z?ihtw&*5kZZdJu=Xv+)iChnaCzy5w|`tP+mMD|mY8tb8XJUI}Jd_LsgJKooeVe<{| zwUT*tnNRM$ZGE;L{QH0m=)Dkrii`t1&Br#b-48sRniM|4I~gwSUFYYK!p0xK_&B5P zMc#IDy?+KeR`vH|pFS|~eQ{5$3*RTO9QH3P4SqkOzt7-%=5oECy~XBnnfE0u2AE%ylOwk^D$Q zaYJDAyE^h5syJIku>$v^qum^7#V_8-Ol%}NHI+|r-(#wpO4MPP`z>UfWQv+fYAVWI zh<*U*%>aE7^n|UG?)fk8iDCzF2*c|x(F6S8?uSaC2p*$^s+X(jK8yb z48q8du{W|;1n=A9`+V@L8rDG_h)($4oWFg)jH3Q$YV!CS*PreN4vqZ$4>*B{Ex$m- z0?q!>Tj*F-clu4V(S9e_#}DBvucpYsuA%PK>L=JX1|}FXGWI-&#GPb!c~@WriBs$R z5_JIw9T2L8{+%?i9KU${1&XiWD-L2T9txzlg+gka%7&R_2_=gN`%wRY{@zL)Kyh7( zKko;=l|t1QwqKrZGs&Y-kQla0$J@3gN#W;Dp29_o#rO3dp$xC6_yC zL~$K)t^;dm!(i(ErsvcODs?OPN%W-1Xghde(pst-{n2(Y@C>$UBfepeFe-5(Zn<~I zEZU~f_`d6dfXnQQvuXu{RL1^Eq6J-$mErVHa9&;S>eBy0P5+S>Ih6P-15?u7!B?qS z;cEc>)j?4BsU&(bjOeRp1d0C4zCv_x6o?*p9VBo*2G)mlod_B3Qbd=GpQ%mB0}IeQ z-Xr1x>z|NKbyCqeJQ5qZKmSCAbdiMbN%g1{~w@a9Kw^>2KcoB<$+})AC{ek&B2w zb3U{49E?+r|BEXb+MBfTv# zT(5}!sa%NpO+D04A@BgI)Um^I0L8-sjskKo47&;(BDFykK*N%~#2CBCVG)u3Yd8|V zf}HnGJm%-;=D><`Ti92)d%3@pd(lT(cH#~@6bNGdM?|b-$D?}@8_Kj4IQWx ziZI;1=^rv*v?m(_>S}Qfb;XEuIl{38ywa7@V2T>+z7qLg4wsm zERWB1SK$;cnAg4mUXeGluAh5Zk_DnixY zanAje*0+!bInV%Z;Q+rFG#=sQ{L>KsH2f{(kNLxh?v&eDj=LSl_+`O#yonvu6WQxz=8FkSpe&OhMl#+#gmRijT665hk9h)o(Dz>ve9ugEg%#VwcPUVwZ#?_V2lk6Y)S#7qd%d0kcbp*(I}pS@W!s!t9gD zi}BnSF?$*?Yid~)NtO_^ONiMevw&H7S1TGPXDbha(N)y@@JE7}J!NnBH}40U_#t1G z&$Idnyos!q_%n}n{~6KuR-6Tn0Szwxz`RIAK~wbHiNgm(jy~+khYjh$xRxvfeeDYL zZ(k>QIajZ>tNG!(`Sn@bDLJhUZcp;7LOobUrg@-CgzS_QdV_hc!?iC7j<=<$niRbZ zU#-b>^7BGd`2jm>14#T7o5X&~9e{%v)Aj$N$`wdr66C;^CPkU7+`0(9j=)tnPXl|s zhKs<5^R;t6$Ve1=SMInGV~v?;tb;S{j+sV>rs1cBy z{eW1{W3XrelNYb$Am@>Jj6O?*G3U%o-V zkNEb^;}!k2b~4wX-*vz(0HuBP4nse(@Y=WH2S9F&UAztJSI(l4@^|1veC?~_pG<1( zcof>=LL0lMC$3hrK8=fbWcsHku4v%dxRP@Ho}$F!;y~W&3Shv2g!yRTKw9fJ3u_c3 zF-J*NykjRy)e39_!aK6dS3e1-5Q%$v@C)!4yjY3&?8!ncDr1nr=H zvg>AZbaj2Ru@gDkDCF<=-LomdYxrMs4vCdgK1al-%)b*`I-AJHWX2m)Qald%@n z`h|%{TvPM@-Kj5Dfr>9}zx)xG#{;G&sdT+z>lZN=*_!qj-h+I^U;327XL5JLXZ7`h zZu=p&*Y$$Q-Pp&k7yRODRGqimzDu>IoWhm_^3-dX6D2JxGEU94$NqgDEdrXe(JUqV zct6a=N_w|5gZGH2dE>5puEcyUzJBSt!@w8ZVZh(KvFQfty3k1|J z0?V6yQ5PTWs=vjDuHA`sZ=&*Gpegq+qou+?5OUWbc}fwCza_Hg{V72Co<6iAjoRHSonK zzHo)_#;Djwmmd8e6FD(@GGq6rc3ANxXfMQG&|X)$()c4+8g+20bL+S`qkA*&c~^NF zcYP_&0{}~}78<&BEHVa*Kc-LwNt}ttU%EV?uEcK)$ur|adeSH z5E9~kNvw~HmaomI*SB42{v>b@9e}&?jQv3DPXE}&$c^3}TN|X&x-WpMQV-V~ z!r^L=S3u-0AIfb@yW;Djh`iL1VYy9d5U=wv=%DH}@(AvD5j9>lLP1vgk?0fl^?tjn z=t=rZP#`uxWA;6vhkB)saewVERT5;R7qQ<|(Yc4RFx8F9UwTzcd2C$A$VY{rTEOpd z;dk(1t8~{|20*k#geRrO#SuRw%wEJ@D-Xju;8IH2V?%t)NDMx57Hrkx-EpPtpSu0a zXUTf}{$E9Z3Rmg1MC?)_&^Oe%hhs4xKb&`%{gARrzK+dEPg4(tG)uGb-zy~VAS-vs z*s^opvUTR}jPvo~IPGeFrMvxm&eMP&X9Sz=J+N!;gff{NRXH$pJ9w&vB*4#Y%9&o; zhQGCA{dmXad$N9a{_>f!{;B70#{9&~pe%SP50=JyjuEZH>uvbqdImTiY;baKvQ!cF zUZaNZ6=YRa$0CCsav9&l;kdnmZ>B|VMavfNqD!a?^Bnh8y5NK3XB51xz8~1Rk=W!EymNS1T|goKT(yU1_fevsU22pm2J)@hafy>8q) zo19n_S+}3xZg`ojGm<9nuUnNx;~W|j_bnb@p}@Gi%<#yP;4d1%$ZeIV64~=TSf<{kakrG zQfn%wb#FOS!Byzen0*MTW{|flY55?`u(#s?M?7{+S~Z2l58pf zY`90TPWT~dER&@6%#&mE3*;;SZ{&)$VhaK3We6nr>KYZ-Ppe zEtnEk0~eRu(c-bjy$9DQ*6SzjBsetd+!q>4t@C~UI*Tdczog{W;pgK!*SvGw{ao0{QB+fQ2&rK>JFk-p(0WjSw_9r zKCJoemC$>o(*TEg|6mh5egIXhzD1^sg82iA4+24MP+Iw|Xbh7Hy8u4#MYm+?t#n)q z4DA@}!Ieh6z+GsO^seE^XgcvA?NQRFLmTH;_r1e!SY+>4SlvgTkWUNAZV72A?-f5Z zaYet|KiR1NY|3&-e~ z3u|mOuZI9%LGR6~;8(F*u_aUIw#q!cem;HVf34R5b zvk6+^hs!X=e~2Geavu!*&@nT>4@)mRGeQyXsW7jFYyB*V;6nroKBiYHf?hATR0PFA zNmF{YzIA%FA_)qdyHR#XHb|v+{_iqVy&)Li7rzVtPbPoj@4RgJQ~LP>S%?Kb^e-~4 zB425p?}v=ZyRvW`shu90gG+Yj}P2f*9e`(M@#HW1mC%U zf}D*+<1&rRGk&tn6Zhk~SkEa+HC3`Si*o-ejs@sPvV3Sku@C@XioBZ(XB-57xaJ<<1JEYm1|){xMK=J5!A_N~4oOU0D|W0Te6x##pSF{N zdeg>B4=MYfLO)o&$0ojeR=?XX)u`X)%I=$f-Z`L%)(>v~@}dUwUasuD?f-W459sQH zu&vP8%+Dp*zE6}W3No+)2N~X#)c-W_f2M_@fyX=YOOtA;kK&3Q=a-w^Uw)|L4w1tv zp4M^*h~?w>;nt2flEbNk3>MkKwyRf9Q)B?9hU4Cs?hdMhJphK1*N}INEFAJ)O1M6N zU!a0caV+Rhz_IY1f8U>YhS-Astq>XsJb96~_ehuHPw?Rpv6aiUKhb{x8~gsm$wyf2 zCRjYa;@gkNWY!z`ttmVqcMi@C;rX+5Y_&~*nt6l*!?rwpSb$J z)1RQgx&Fi-4+~Q1k-r8N$es9I`4f}iyOAD)wwQ+eX@A18^X213zTig$-cM$}JLpeD zTz}$N?N6lNDHOxZ)Id;+QSan)DaCn8u$!03t9cMg`}I7=pXlc()9@#_cft?#dz$0f zd;~lW1yQjo5HbI6>Uo%4U3`G#H{>?eQZT=|ie^eh@=L^PIji5z1I1q-=7;3G%8wUC zqD~&AfA26qByK}IIk^>f)65=(zL*^gt(g_cHFQ87B*mH6=Ptide z55FXLP~$w^gLQejGykIbY_(uh;gdhYyxV-~zdKLY-zX1^Fx2N$BvFMcllyUaz%llBWx|%k{}%7--)v=S)&gU1$KX;qD<{2-kU&H~-Uc z9xsP>l%ML-q4?J;X0i66D@z; zM5BI=Kh1uP{ORHc8qDkX)6&1rpMKk<{`3(+e>$ELWCZ-_xcJk}vkM{q zG^X_ZY5B$Y)ACEepKkh-rsKcgpB_1w450k!_umpUha3L*pZ2G-?k`2>S4m|&$RgIva=m z&jo=aTnk8>1z|_H7W8e*ZS>-Sp6(H@1w6vFfJe9%@Cere=WtvgFP8&x76eYmE#Mh0 zUNwN8IK#CYOOzt*6g1;U_brWjUw=oCFjqVtR2)6{UHs^svDw1Ul=%Qj;FrwiFJwT) z;Ye0D*o0Gl^n53OQ<@jl`-sbv$a|w^q{feqf(S^P%%Gm`IbJA&qEwum?aBz%Bro?6 zm0}+}a-K2W>1-{>u0P$O<_q}Kr>RiCTI5LK_3@{Oi>dt%*Pl*uybymnH=AR#3%J201B8<`74`n~i1DW#x?~d(=7Xy4L5bDCb`%@0`c6-;pLPL+@jEz3s{Z6kUJi_8UJY*iY)OqAlo&m(P*; zmX~8thG^1dC?)fL_Y1m=*@#;&)vL!*{tfD_ZbnSNsyWtxs`|VvxTwY3g6DlT-QE7V z+WwzaF-4^12ok=9xCdD}Q^_KWPA9)~^+M+@FZm#Um~Qf1YGpIfoooHzRsocng?X`9YG=jp^${76~5 zipoyYA``@Woa15rU2N*EKLfdiPlX5%30tPOQCCi;hzdSUJyp(o_n9_M-qq1lBU!-* zR$}60RZlf8uJR@?Il3&et5f&X%k~&PDLhwH^;BuhpW)o9p6U{({wks5Dkt%9XN#_D zX!XW7FN$2^)ODrxxOtAdZdC@nltp9oTblFkfT4k3)0-p}wSHxLM}O?1P+2VqD%~0Z zGK$nw5lZrARf6B^&_OU2Ey_|Po4_?(!`h}i=K*KRhkVn2v^$@wt11{?bVL7X)K$F~ zdJ}b3MHAS_y&+Cr)s%YU3avLHSu#Vt-guS7;QhNE;KLsw{7P>`wcd!Pk70LTZxA`r ziLV6u6^;t_6TJ~B&Y|9TUi3!A9imG7dNVf&y>e=Lk-NMaN7rRRZ;V>KkpQh(2*T3e zoOkRqR&Tidv$g%t*LtJ(Xfn*w6iKJ+G+nwy+0Wq<{pRd=f!(Ag4yhaS8szzsx?yZ`APwCYSX2qvqQ-eKiJ)Vs9&-JS{uyH5<4O;qGypLdYd&%t7e)FUeONp~;GkViM@2rcDX8X!OGHTFE>yOm$~?lfSbLuATGsJtwzI9mB^`_ZD53 z=l5al2iRV{FBV&!1*4HTnR!G4^BR;th5e&N2e>uzk37&g&Q92Ouw;X3=ztZZhIpn` z9;9L=BHwM|=2YOEVEJ&tmz=*y&Lw-T0*-H;v*B=H0vJ<)>LvH^eM_@;%EdVQfqre$ z=X?lZC!R%nJ1`&_CA|3H-Tx0^y=qmO1W(}#yF~#Im3imusIs#bx1z80_yf{epOa+m z81Bv&|B^G@2%?SlYLW%dCAOG#S-TkP;dyt-9*C}vTRUO&wOOB2-#8}urxd=yV#|g1 z8#+O0s&k3nFK@KbL>74Q4!a+}JBd-bfNshHMi5J)2X*(yltqk6Pt9=rqK?@@N0T2- zLblaA-8(FAA)VTr2)ecv-kX65yjMy@Miy6u7KfPWXHgc4qV?sA@AvToJ;C=kVykcBFVGXtTZg6M zv9b^Z5sMQTsSE&Aq3!q3*d`Nbg1ztDOU043_gNAien36@Ea2VL8)Lj0#psO!|1xfF zxsg-@Bi<6}iL)N&o|;K{mFmX7=TMtfp(E!fU$)9J7RSV-srSmQo^kLX_mk2u_HnT8 zd>CcE#rPg7o$k#Q?;U-otEUGsHgRv}Gxv95y&0n?4+RrQ!O?gmM_)*axp{vf7On2y zVJy$JjvF3*28+@9ID^r70jQEgqvs91S>8MLUeMd<`7hxQfV~`@FErD|TDTutDSSCb z@n%c26k2-Rb@ zqF%pkhC9MV*!v_guY9Qg+71!;$A$msun_l&;{bn+ol^J8xpwLhfG+tIgMWwLw#82A zFNO#l#wRA`8cOHTGbM6=*{(|NpFz2`~ji}^38KI z^h@bx@ha5dp&2z=c%9IW(1g8h*Pf;~lz7Vf28>A%12;&V*3uMSCj_xw^6^8o~y zNvI?dD|7#V>95nf!;L$TK?$# zSdgt>f0tNC%f@0IOReB5ieQD5s%Fo;4cS!@NVRK5cBLlK3_2bK$iHKgLfbo^tOIxe>gc2mma@AK@Yy z!VAUCOKuk@30Q>=8!;gKNWObo6*X5p7Ee0TMQv*Mj{329kU!tP!6{adffOy@gF))` zFxNTY^na7vf5Sact9F2=as34c2*~yH@O0Am!|;@J=6yx*bi7<6($foKa6hpYPs8cy z;AvOA%%EP!aPkpflj(#b{!xJ2*Qw=27D_>Xc>csIs#{GLm>52)gE6)+v^ z^OG2wwK7PaAn7nl;L39xY(QJMUajDgKq0!wfh+1Qse$Xg7}B*>?;wkp2Aii8a$c;g zd0k+exQz>p)V}vfxEwkEqC3}^%w@!>OqJkk77_pTa;KisEYtzcq=MDYU{Vc45=imR z!taV7T)MTrtA=jhftO+E*4FCaC*d8rC`h-xWLeq3d6_uJbLh6Cpj+}Pif)%7_3z^5 z?gDX>2ZRB-72a7xw zZX32(x`~DO5q?*6Gj@;iG4zfgo@ebUez3I@zaalqg;DT4Ds>=3XKO3s+E$1j)b5DL zOH0kTOO$Ge#9M%Jl%p;8QiEKyv zkCeGSk8a*QaL=0$tM--B2X%W~0J5$V;UaRMCIPK(0jYTVd_(1_TsS*){{-iwf3t2Y zu&Lb}f9g++iHYr4Y!M;_s+VfqyY@v?!48v%Q~wA z(ueXO_tmR-YsJ?kPuW8uz(@2S+JlG9z2LF6pB1@5w33sR>zoKxE*$~%SoHZgL1%{}24}ur9-f{ic7K}spp)96h68`9X zz0JG0_9m|SN4kiAFed5jeF5kFF=%v%gOXV^AAL#jQSK!ExiKHP@C~OFAB{^N``)$U zqXRh)A7=C~MMw^bP1gr%5aRPV_o6HyP@>Geb3nm+0n|H-G&?Mkfnqwc*xd-d@$_9Zebw zzq<1dA0X?Gbe$|Xn^IroRr|_-=r8D(N%X~Ezf!L+vbukc^G#P@j0kW(owdG5)0|F1 zXIEbo-m2(akUll~Vy*xharMOj+6VN-b{hZXq~d=ox30dBiUaD4M49;M;}uHSkA$3w z&NvujAaCUIUz%_^bg$DFzkRL&-D~xQ%q{w&MeB=}5PdQBmKuFArpGT0Ge{Hl*GOL| zUGXN%NA5b>F)rnNTwIB5m-CeBA4!XS({g_8mzA9NbI^J@PoFwD{ayG9vlRVDq)&~U z&*eO>oWuLWVyY!q)q*LbR?B*pvL3kaEK4{Xde_N$H?rf? zmUF0YE$2Bc=Q)qJ2q`%a`2RD5^WFkoAFxZe)y%8R1>b_FjvrwXe+TVY(eAczUZAqPnDS7=7x)W2c7;wy|GRPdz=c{|5hB!9ZgRaCEAYUd9=KSMtR`a(n(es=70$Os;&p=qb4B!5^cF0sCp4TsD=fW5~mZ$x;j>G#g*2D zO=BEy;^*R!+oEI1mgr0@A}ZiZs5gyGgCruWezzW|u)pBj>=$HVbCcLxQ}WSdT9AD7FG0aGJ@ZW9830i20k~uaQ@p#_=EMA^THh{JS@P zui#%K|C+Fdxj0WC9`cy?%|||B;x?E6GMpFd>X3B-pH5v8-w)#bp>F%AZeOQ0ld)m6=7vGwOF@rtyyk#7q*_0Ehs zONpDwJf4@}KFC@vnA985KM9{C{C(vN(3SOuI#6Hc+z&JICgF<=952WU>b64UWxRe~ zZv>p_%1Z_Fg~`kKYAY{-!pevvFDF4>EHXu21er`{7Z{p{A#s{=)cau`1wo1_fG&?$ z$oISQRQf}>Jmo*ND6(MoSm!?Ak7_Rvz#3;c-lO-#_S@kMVeBd6kpr$c0tBLb z88NZRV=#e=kHm3*Gtm$$w&hsK>H|>)92J~2p!cJub9M9=4;cRmiXPY0!96({0 zP6o%;@?8zE4eF9N&fn;vE?KHt=Wo4j0jey8kI=lA@;LO7a9%3G|9AOl?1^wbYWrl6 zk2?05nvW7^)XnL2U_O_RhCq)nKI+W}`Dh4r7gq278~JD)Fo*EbO-QH)_-Nqw;e3?& z1o;RhuA4zw`bF|)#Dc!Dms1Nq_OffioofKH)2aopj*~&SN8~d7+aoAB)*Mt>7S8zJ zK%lMsw;2xKj{`r7u0g&ZzR=RO3mEdof4nTxEmEN5CGiIEmE&)&!st}lNq{GI$-Xr- z>76^Vp6evA9nHc-q8_D$Ey}Wcb{%>3sypxC>oG6nBqgSSc1wIF34@H?dL7`T?Fz9k zW3qqrCwNU5q+CA7*cUh*y1wG{&s*D)#Ted$thcDEujp5{MQSL5+EA4qY=cSRB~bxo z@pZthp6D41J|ZJe^qdZ(V@N%I7U73>L-7J`OIVurUJsMg|2Z9qQ?Cs?R;wo%HfFrc zInZm4y=hNaJpo(e+|#VX=x2YSk$fqtoHArB)gghfTbg~JF7ox=!FDoIxxIkf`o!`|ts zR)rnzGCRmB*A)BbM=ZZY&(=f)yQ}*$!7_h>0P6gWPLPprMu4B7UQm29@L5Yw(F-HP zxL?e*kFOIx0uRZB=Ts{6b?o~zuTiGaoa2nGeM<0*g09)s&Ur+3VHzy3kR?6JTTe1g zWiGyx3&>_yS2jaJ#;7K$X2n)Qo`Z$Z_TQD0j^BmLN&KT&uO2KX>H=KlqVH;dJoh|D z*CXNhYdz26PvoKNx@D2oKmk9*dugwrUcDH@Q?F*Zkm=VE#d>(zIf{ncZ0L~<%+tkr zfS|mr$@jNKUI0+@$$!L`;ZoWPPQ@W@iB!O_r8VG1p&R7e>j}p z$uk#4cG+L8nDpq_Q}{Utex_a&k zl(3G+9&#%!KL~=_e<=P_3a>eBzx)_*o<)@(w=y%NN~7S5o7fe{l3;YQt~AJv925e; zheJ^T5c^R!jhFJ|BkO!f@R3$=i4R|V8U3VNmA@UwK+4~K37A#-<+|rSLLP{>eJx{n85jhv}EhXBI_z<33!KR}22Lz<(0>H~u!_HOJq6w$|Uis8UxYk&Kg5Wc&zdXNSk2XmFCYZig%RaSyA9>)hM8Zm zo@3bKj*EP@kH$aEX?!ioU^nXh_F3US*Dki+AI|U9(}Qx_v4@pYFenb0W6 z<(TNKe)qnE+ye$r5Oe3A*%b0;x(q?|V{SW1IHm_JZO8uw{fR%oP-t@f% zxfucaF|nM;P&bK-{=QG?Z}%SDmfr{-Qc6Ff(n;U9S~(5y(OBTrjqk7ic*d_qoFd~&0lxe4%j zFYpt_=k3UAY5EDD_kM3#QnXehPGx-FJ8A>)?Elxr*Sb2)aR4=(_ZCrPF9dyR3ozmW=M#23J$|dsN)- z4X<7nF@CC<$Jqx_@&0S67vZNyyTbj{J@I|ePksE`ucV)9@{JB12X+y>Gfo2U*T>sK zpW!;8FXddqdw`kX`H93mhJPS7Qntl?5S&Z+c#wY*Scq(vP+vCO2a)2}X&sixt|VLn z6t7(szINm4)ZHQ{Nu?)wOi#g8I3;*qVjx=2ck3`9$W(0S+R1l1NX4PLsdqYx-cOFX zTft-aK;(t-@;&h9kipLSNiu9 zi8|hfJeWPZ(cc9=pn}@b5QIPDKl7_2-)g_84d1HF`wIMo)s$N0EKz9I{2{_({Vn*g?vq8A6%}W z%RYPu=RqA7@1LeSI`2CtHJUGy=6tFS(KjF~#DDYxQDQ1Q3f(msiay%)bO^}eeK z1U`lypu4H(TPexiauJ5ZuyU2>8wF23wkR!3NGLmR_|%N&=E+Y7h{S1x3<~4tJ#~JN zz8@8s@`T5&Gl|>@eeYxg6hHPWxRT=N8UQQ!0nU&V_sf%Z)WWFfz+2S-Gc8;w<42R6 zMXfuv!>1#<_PX-`3=jv9@wN+LFPT)hrwSXARyA4F=W#EO=mQ*+QaE5n0)M7M?bZxm z`8C0Bk0vG{FYjrbr5`n_dfUuAI~Md0PRmXeq{Uh(AUm>#3!MSIS`f+ zZCeFg>+ApWpIsJl>5C;d z7OFKG&L7Qi@*ut2i9MD>Mh+5AGX%iS9V9EI8Gv&3;60emwZs+*aGRNsDf>&Amh*M=F zbGR6M$Zsubo=Qb{K%e_2g&6CoK>A+@G1$@ik-WAWHw=PY{V=|@gX+FI$YCYFO9d*>2{m~h)YZ3xY_G+$ zML^j?#VuvZ9DigJoHAz)0>X8S{R{o{`OfZ#@Q2Y34Xu9;l<*F)9pFh{JUw{Y*uN*avbzt-A&v%(2d%>x zJm1>IaU445FuqH-6u;MW%Ww+5HD>V?_aeUvr(2Zk3(##ily0RL(GGYn%hpA`R!xy@k`m|OJ0-AIa;Dbn|2D_;CYS3mcverV^% z?I&vABHF`cZSuajLiuZ-qe8%k^A!wS!mH`|_xuT~&3Ff4rTy+cp70$sdP%{APz7g1 zrBA|}Cje!wf6j5MivKD@L=-f%KDF!W*=B$zde*f|3P7Z$pH48_dd8Hf}eoBRPa=zLSn}+1;)g@B++*=d#UexpGBvcf8%RYu0!-0#Z zdW$PSul^TYd5!h(b{e2RGDwK%m!AA-GEW|)jqHj4j4tEvl&6vB(OygF0y1b0f>-vn1!$daDbwsH?;b zYs%=~J>STS<8MS&KfvJ2%ZK!u# zl!+h*+JLeBplV+!5(D9K&}rqs@$cHvFCYh500nl>2(eu`*ctgmEeG5Z!pRkRtup5w z^1P7)$B&CEc&hO}1&@u-fHGlAQlwT69Jt1xQ|s>{j$Apo`b)kXICvgZ?W^O`-j#z| z!E@yxYoMD{4qQBEIFD~{a9gbM^-D66y6XFjpH%wK)ywe>wepknX0?-HvVr=h;y+~F z)gg{Ig@3B@mf(_V6kOu?zt+o9_naLA{@{mv(#7$8`0)}v4`-Q6y_BEh>g^oci*0}m z-SaqzmXQJ%cszGu=5jk{u1k1yevNg!VSdjz$8-IjmUSGUu14JWJw+|u#FOiZbez&(&6xQEeoq>Z)cZYDLk8F68|vNG{}sH9OCGNc zdY8ba`c?OC9Wb4NzuQcQWQ|_Ep7&Y6$n!(~8-BJUkWUEQ?<(1Ysq$NMZX#^FyaGE8 z0b8B+K93!Q;JfaFm=AbQ+VkC)p)+8Qlt~0A-#?!d%!8bMskJ{Y+?g7<19`b=!42IB z$3j)BvsCIK$Wq#?FrPvDw_btM3UExUKzxm;i}Ug0=9iqJM((6i zWYlgdj|zt7J5AP*dEELu*kC|TVm%+E?bUMFf0^K1jCZNMKEF)5R1Mw{4q~GTYAM#U zKn!W{9xjnD(urdR@P>YZH$ShS>P1P_G1WQ@Z=;FT%C9-AUtvkf&-l{;xxZP?FmVM~ zeWU%TIXCs=e0OtSWzL3~)h8p~Uh?d=uTQnvrCyf%Ji_lu`OIF2>U{ze=NmfWsaRUM{c=IX&QLEZI4&la^C-#E67Yx=hFk$x^hy}jwUZo(c+aTrCZ3Gb9^l+G z9lbzag6$z$@Q==i?<@DGF(Z}q9{c59#*ftMNA!;#zd8^c-&)MtyoYWdiK0C`9@>+N zEQHdm&b%;h!Z|D6o>&a>IcC0^{g34rva`8=20xd&J})?eS_tlaeA0>yN#p%`t@0-f zz8$%Vn|oj6UaRUD6tWT-oQUpwlxjvUmGRCyP+u9vI+5COi0`z3vSNnHd3tBRbCG|4 zUhO*G=B@)77b2ykkb-?2y@%tSwdXYWr6~4f9INCQi7x_tQF6$hKO}~UPd;0AQG2|9 zLu-p5+1$VObFyn{&ONMr0um^fPjR2VzjZJ09k%&-jARf$K%wydZm5@Gem^oOOJ9o3 zl_j$Z@Q0AqUScj&YQJCZMHu0qV3=6eK}E#7sCaeHLn>d4pZd*i|1;nO-V;Gi)p3lg z&xN0?-H!D%Q6E8kN4aZ5#zj|G9|zl?TLhY_AU}YNKDnyw9f1U?*6(Cg?f}wH zGavG4_HVHFl81cg6C^LH`gA<8&9Cu*9VKm0YY*a^cR$ zpWWptx#-}1Z|moxI7O9Y@SY25OhWAYb>#E0zY3lT!k2r25;ZWD#sQN-li_tLr`K$q z>B?0X#sM6Dz3~XBA%>y58i`$+;cr{Vay>ZCwG;ZG=@@2;X1}~VGTPtqBw0Zjn*;DI zxV`(9;z74z!=Cr$RNKBpIl-BITxzOqOCQReyH!AiN6(cVyhS6%=nH5Ds2ZtfL^561 zN#Tmyk6;SwPUuj5W!nW$W1j6sPJ`gAKM#V#vM!_|=11pme0+!I?KU2B>yEMQa_c|4 z71c1YHE(8rz?<8O_glxM1mq6X6L}|qx1DVnuCIXgv8gwHp>?}b0Mjd@oMSnxEEh^0d(kD&f zzLdQZcW2>;@(Eyfw31EN3Kc+=r-wNv0Ksh*sD+0EIkCQO9(EF;gswqTz|KR(&g`+Z zf0RkL3!juq1rzeZ|GvFuVFYZVsmZ*31*P+56-XOGN!2Mo6y*oBE9BPa61nv)iQMda zmS=KXB8?_l!b!N@rB`Jq;aNVAUkK2>F*BnObfc?M?iXOPplsRKhxXq zR0?|@Ux&8Kcp_&ip7=2uQO=@YrED#pfy5{Xskcd<#FuJ+WitoEhx}YEqd)w5@H23Y z`do+ua}2W|y6BC$BbG)ldM&<9ok<4u(ZX0OF8Y85HY|c%7^0) za$Ja5`YRN%$^7k$l{W%=@9OI|-M_cCKO{~>)t=A(3Kx~<#Ka*#oIk1hR|@QJ>+YFT z4{kYKsqb9~#lOkh{|f`s4r%&j@T+&xMIvY!<2b-pE>;&rCSWJY5GAsnW9NkP!C2!) zd(yyP!ufE0~YQF0&1&`+nU=?9A+ zI~&~t{#pq`X@6&2`#VVt1}?FF&$#!aU5wx3(v@)24$8I?lIyLIG2<6--rS!=9@IX; zUFcae_jv2qgdxD}yiV^#F#cjNJ?1ude|K*l*LKLPhj^;|k#d537|hNENo8_YwPNr@ z6$2VmlVH!TtuqfAn|RF8*xrXwdExwyZqfYL0S7hs9@r{&zVqISwgftX1`W0MMwsk= z;({MbM}V&Nc7}PQCiS)b-qD;Z*F&tMG@Cs?M62AEZPnYjRmAG;CLJhSIF#N7Y8&e9 zr>3vB%|sqql8y$|btxzE(u|A&Wej&uJdV|s54smJkp%Xt*>8|r9}^|T%cHT_KJLm$ z2D>I-dTR}yMB|zBPmX;*oJPa9eX+H#=PGc189cOyK-DW!xe8K)ON)`DNb?6+pZDV8 zsLm*JEu{s0^Q=>_VEr681yAEhF`R-E;1v8GPQmSSZ{0Dz-2%KVgmW9QHJdpH_{2B` zsPl!x0>9vSZ!f?@KhVUHhF_Uy;%ENFx0LXYJ;lszAq(!poyB z9HO(Er}0;@LSX=ZUw`Q=4oMP@v2~#$f926UIZ}r|6(f+YW*ikOyT+XNlb<{5CWd9V zNnH$-nie50c(ix5sS3>FSBoFx#~b`WKQV4v{%SJJ(6>Y$tKO|Z_~@`50Y|9}E| z??wa7IviJe({ay z?Dz>{XTFDZ>U_)O^_ednA6B2)ezo6!>iW!GaVkb)9l>83E907WG6sl0&_r*34cCY(hSio0$@MsT9Ba&@DA`@(!f6w!B zI|7{I2NfeEC%&xxpiA-q0w2@o50TA+(_@b5CvLs=-MByv3{I%)Rn79YoK?pza} z*Am4Y0q^q9z}}d8PL9hDbfLXvLh{dJMa22go^c8*QUL1ij&aJiy08Tb5Xab{1*r)p zIV4DJ=~s<0!^>2FHZ#_qVS<#(NAD0@-3KB7KhgGYQ}L?}q!Slf(<-aDqf_#xldVI5 zeZ|&MS3}BW*!p0DN36rot6vSoQgGAXk#%^Nofurh3|T{-_@8VYl2?Dl))7t*f?3sI zmOr$to<8_~ z#_v07#c%k@mCF!5pg4}-_QaDgncFItq5MoXh+Iv`H+he@1iAGTK-oVTd?9+{{{UY& zpSt_bl$(IO9i<2o8PqG-4=XV7wpQc@ujmJA`1J?+nVo2INES~ojf5J6((Zn7``GGl zb1opKmEWs7T{}mERGf_}jsGCOHlkm2%wK}H@A1R{{GK}bgqt*Q4cF?#^9k@L{vw(C z8o%1TPg3JuM+;{AB%6y*UI?<`#`k`0JDE~R=r*Y?hDd?@eC5? zI;jP#MqzVpc3inP{Pvz8Wxn|-%Li_~G2v?{U&x3nyC(+lW!OETPtfqGQwMp@>-u;6 z9gDz~MTkgoWzkH{#%)|264~C#%@+P$^K7l~I{cvIWg;!t8obu~g>L)2ZXee)E0nup(bJJmfnexy*T+<{h@UiHPqA5~u09e+TLACT|UHBO5Juur}F#5l*~g#+tX z{o!LZXN*tM{aFscrvud`U`eVc*=rZ|@Ge4%^=Ez{BvWWn<7-8q2GP9NeZt&J?aJfu z*MjE>?i6L7zKTONCCP_nsw@70Ky-@p1bVs@r@Q*&mT!8rKvEtDz8b9i7rRobi1)AN z<1{iK;$1nmFs-`(%$A@z%B54nD-!`2(@k|k6M zuHt<%es#c(Z|WE8^`)wJ!g)mQ{^>jVXZN#8o2Fz?1UHw zd)*I^XQ(vFGvo+|lV{*uCeK5f@v{g1OW%cd`rV-JYw(BBc(<+NtY)qkY#H3zDEqa7 zUjsMsTfS598yP?kT?c@ep8MDY+B+MMmjvqkN7&xVZRh8~B_KfKI{#j_r(9zf2J2F# z43&1yCKu0`eG0eE-@wOp@)L;jlQ*zy2wpef{g6?_Qm* zy8vFZ4qp2)Ik<2dc^U;}tfMBUYP{y}K)V25I~=^0G5PfHn&CLWYwpLPc)e+;2Cq@J-v+!E zZ%6w&ye2r?%j4H^=^DbXdjQnYd?UP$Q@*Ex*A(Fm;C0Z!YxXD8#cSy{j03z5qDKh7 ze)#GdybiPdHsCeS_H}se;B0kxHFa1@`jx&Lryf!3ROh*}KgH6*&vT7y47leF436>sF!@3B5IOdk&xEPOGgk4p|63IujqdZU%&fDWmj zh0@`n@7B;E#rE4khw2uzucJd1@YU0yVLtXiAPjbT1a2;AWc&d6ng7!t>hFr8+o05g zd=rr&7FX=r!0DL%EJ0P3)p;%F{LZy#hp4O%sm_YJOo7+&ZD~r4{G1&N^ZV{G_hQL) zcsxvT*)3 zAJbNNYd>uLW7l7+C_S99`2nOP&jMp1Ry1#AtQ?__UQs#HrPvx`B?Jm-AZ7qzRaTzy zLVT4246WYJP~_vz8^gTrU~==C9;_)tKfg+P>H*UjFlPpA!GLYvhN`*8WH-(6#7n!@ zqir_{XTs_8b8E&gb=!;HCEq|k5+m&6=jj%nrSf!XHCBT>onUcJ8~kH;+#3Bn;x6@8 z2XDL~O)V8Mw%{&=-0x=YtZ7i^!-q2Qu_igFGW54-uA zA?Oo#NfKWgc9Zl5*)2gD0Hj1=RMb=y0Hh!_+?nI^!3nQ;EOuYPD>*c%J5hwDxIG0D z=UsCo_`%(eic+5i&J!iQ9dSpkD-!=)N^;>|Q0E?0>P;7JsarE}16;*B2#^KtNIw;c zxMgxINZ|Hn0cIK3iI0*358v(Z=`l;wBZ5Jg{QSca3ZAw5L9pAxZ zvfitq8UpWAj!_?jWm{#eqOxeAN4_!w1`(lyXopgePcrW)!zQXEWNyZsIfb=>#1Z)P_EzhRC z-yDqdctbstrwwZ2(>T{RNjqgcr3 z2msLeiF9?N+Vo>y3rwMR{Lga#Y1{ag1Z~Ppf&t1Kdqx04>>>1#xK$TD?={ zeymHf(oOiZcnjuN`8yaR+-IayRpz|M8lHL!9qTN6Kjf~?c)c7Cx@zQ?hEHtn&+h-Y z?OS#GjI@`0N8Hg|DLEHpl=T%#0y8RREZ}H!GTPUb|;$AocRh98-Gmc{>ujk@r zY}4d;=~;?$fzZib!elzn=-{P8jR$?;>yfiHue6K-SEAQDFQraz%E9UcsG;^1{sMEu zWel=Ca;nV6VBZ{ninfAL>eOrkl1ViX^^Q4==bYVhn}fgN`ku3HA#JC1Nr{} zX{YRdTDWlx-JoRXN+)FSzs=Eg2=0AndDRaf`0F+2oC^dNdh-W|D!u8R+sv^a*4Tba zKtW@&q_;*U3ZC0csP>h98M9cgKVv=i+@{MnrHyKywqFr(JnzVCS502dq2I7>AMyDV z?U`?1YW3wV$%uT!?^NxpX*+(Sd|0f<=H;S(|E%g?>1Y4iyd2QKsOsqX+Ps{TzpakR zI;-P#a3pK=w$95{5}VA7p}8~U=iPm^0gms>-v;`kWXNF|MQz95@?J$}*Uo3xFrSL! zXEw%7dJEsB?62D{qv7x3cmcZuQL4%RDLi8KYEiYW%hS}K=Pdp*0RNQdIfvMuYovsR zoafAdZyTNGd?n(k1o5%HNySrd*6~#C4u(aItS83;z77R zFVu$B+OA|Bf8Q=JJ;*y&HB9#2cR!&L#dA=B-HMLfN={;Dx5halrnRO zZxEP61y?LXG;@SRS8Wqpx4L+ZZvcJ3frVSO6tOglepxNMI)0fO4~_pq^A}_&y_r1k z$60@E6|-3F<=9dypf}EJez(W^N3!7iP@GYN_W?D2#@EZ8KX7s48>Iw*{Cg8YKusTYzXoOgCN-Z2-rB!uhgOVDe<3+e{cCi{Ch(? z@$Un$sz}As4irgr6&i#p?>s_aEKN_x3=6ngA$LB3mn zGLPDLWeELTya(2UFr^0fDuQv>6KR160<&?T_@y2AmUW4Kw(-je|BL+7PL6%SeMIE@ynQMUmfOr0Xvecv4i39OJ4U+-Y)&kxk@W}I(}*6 z*Nr!x{P;!W^I)mCi0tIVFR4|*{Z@%z44(^E2l!k?G(KO{hBVt9fRLszMM&e)bL1xA z)!Oq|&jFfO3bJnaJI}p?%#x>QGIv5&FnLtw`}l!<^7p~U#WscIzb{AryQqVmy8W6I z@ojyBxW~D|@~){H(JqkxuKMv)HT!F!R-GSEzYkWrLGjZddMK%KlfT}F`)l&9!)$Ny zH1$4Mp6x{sy8B=qoUJbZO?EK3YvPl5&5y=DEgHx!6Q+HBA=oluvYu^royrrji2j15PXlDXi*sB@4_~TT57KGO?t}%YWRPZ+A zkibI#nhrt|K*JoN8e>aShA0LY8Se)u$PoRkrWJcLf_X7R+Qh*iDk6lnm3AWHwwv-aNS z?30|#P2TT&^ZP;1B>Swr_S);V*IH+tx2o^Kpo;HB2R9mWMx7IYQuR8@w_+VYJNbY} z0?#>!ElMqpdmgvnubk84Q-llO1H{63^c6ZMrOxCr1;}?MzuM1qC!l77c-VAk23*)X zm+!>hy#;)iMsF?~{}Aza_EMGR&@a1kek8|%js?lt6zPz8G`^ z|0{c1NfM6F-@=jKEhv)0QB@CANvn}Hw%V(ImL1+Y*VVI{odj=AZ11zDXKBugU{ULU zH-$bZqc{2W%IC=AwCCX0!AD3d73(PM8{7vaBx68N9t6kegVM%%VA|U_-bc6U17xJv z>w_|?M%T~|@s5$?S5!Rtw6xkCB^Q-pdp(`LJ}9<@hf<=EL_ZKX5!&xF`%HhVYnk^P z&DhW3ocr#e=WvS4z5B<14revmYIx7#7{9ZszeZ$rP@nYHM}?qpUHrX5s`{i4&92=) zo3GxAKIxOfJNnp!@GgDk{}|q*6T`dd{{y_kh&qt>&2uwyjsKZ_u+A;&`C<0w(tYW1 z1#v8u9;b*0^reRma$SWuU^*wwa`jU{{kYqoT=Y|^Lx`lFo2t0|$>|92@x~Gb57o;? z-l$jkf!;CCZ*`tYqcT(=c6T|8_jbL4IL0{-Cy0x$Z#M4-Kf8E{KV8a-a9DWI&Uy9d z1`*EHD3rL%*|L{^uG3|%Zo*&9|KVfswdYgo4ypO{>Gi+q%l>z40MQyGTJUY1<2<~? zUOez=cR%zoTkvW>$6rUS>_rv_Do{5r@fTw=%D8CcH?l+e1TkJ;_R*i3eB3mzFMHxo za=3K+vU8uMXFmF}Gcq<_U-s#;mQb%1f2o`q6ffwq)19yg<(!2fj+4&p%_njv98D^5xhhplHR@fzf1&~x=7fo$;^PhRR_4j30hn`9d zbQI@=uDfK)#gQ;|D>d>0{wPsIv>)Zn{Lf6vgdX`t;-6ZQ%vDK>j?$>9kC$8na_7dcy7gxEdfGYOJ%5fL7i#8st`G4L&_UNn z_hGi$xX^g z?aV<5JZ5Z(;kP*HXX10mfrGKQLhKptMg2bIOEFI6?_*Dq3{{Pn<2WfXU=em!@4@&( z4=2Nia*_El*XPeWtblryxQmQZTYE}KVUtvCD+mAuP62iy9;c&)6n9OKQd{^uzqg0PyaXq~=SXNK(h zjQAI-^W%-qM)*yYx;#J{;K%)BZ8K{U-&5T0$oziy8MWk7WHA=*;yv?*PRTi@#V0< z4CF_*?j#&l0!cn@!+kz}>;M3;U2_dTo{c&p&5sN_F+7+Me%u8iIG|c?{M$tN(V|aL z*|Tznc)R=Hrl(K9}~7U{jfj(-RuI{xvFQ$x0%YCWZzkK@jnJJ;5EBo$tj zHo_Vw?%~yWEa;p_u1)CpDVYO*5`!EHFT@B(}RQqxyZ^L zmYu$_C(ur}bG)l>CgA^Ye2ty%!)Iw&s|<36c=W0BQK=qDgsY2U1F@6ma&Bk;X@ zN|#gN?FU!I%e&z(*l`{&PHf_bas*V#*TDE;ZC`CPT9F3}nw+Om)bH=B-KPALxSL;E z4`wByOC>VaUC!kZS1;Rnl)}|&KN2zw#)t*Ka~ma~dl+QWzs!f4=r`E+XK}y1PA_jU z(RD&6!F-A55%uzaab4LlZ$n=YEdbPe35|E7{O-rwi({7gYhC{lyC@&Riz|5L zVba0XV?eCRt~PC%=}R%@Q0rj(l>}(hx{?e>_kK+==@65*yF*%M$PBe38|wxX7wGlP{7b z5u@)>4JMau-M3~Q$VF5Qll~qi?o%_4%0NAv9F}8NsDuRp`1Z^kBCkYpz)vtA(mh4| zJo|Ou$Y4=56L#L*!PI{R@m)-|^HgT^Igv4n9Emu1@Fe5YQ!C z4KcZ#X_mjxaGQVSGWsu75W%uYRsn$vnbE`*xXsj%)v{u`h82@8D<*)K`j8%FpFNNC z9yJah%J?z)a4)FGT0Rs%L&uT!tLBNuGPiAcbk@4d6nB-J=7&$zjF`~aDn4ukzNTOH zUtx7AC+5TTG;uxPpD;jToRdUw%jVBi+2zk=i>mR+2_7DA9;vu$P<<_2#s2s9e7qK; zm3FxkA{Dg}5K`?cld;yBq0c4QI7IF!VGxlAc4nPs<~lNtUDkAT7&q zCR9xD0X!Z$QZTk&_|oth=jF%hy9>+XKab?Uq2#Ic6(vutk9+bY_j7*8TbKSlZpj;e zFJ7U3AH?rsKhB4QJI6l&+u`~J9GBJOvK%MLsV`9#@QJlQ-+Lm=;T*4Kj^i_Wd{NKa zJt(JXdaj5yN!Vx1y!OxnkuR@~(S7ek&HKOqvry|Z6CPwdI=slcfBd}m4R4!rUc2d^ zBnbK^kDb>ZZK(Ax-#Win>2o8;6UxVzCWd$P{~F#yuTF^GtpRl)Z#BK&g1q)JSraj{GW!7?ryT}(kiR>=DD+ZZ4(f{VQY+hM&|+{#}M;{0#d+qYis#W{0;Ira<3 z_s1emOZQrF%J`A~ytc$CiYW_!qU{kFQ%oqYo%jqBe>dhNV+{&nF+IlV;RT4$Nzp|3w6F*q?Y_yGi&$KR5f#$VNE4zPxrf=tx3=hr&@= zUtnH)pZ_csHtWC+TLFRkdF`&XVz)Elxm8Sm)RVNVF&94R=sJpb>Va0VX=ESw{)fnP< zS8m3S>vnKF*XPS?w_!H36+Nna)Ox?S@gJ;nfEO>1y-E59$II_u2_H78>EQPpQv<|% z{CIip5{&c3%iArw_HpvMaY=(W^==p8fUYIE!=mecz%hWXNsgZcU1J3tEKB( zk=HIIKSqi=1L!*Tc>DSiJ^^Kp` z?vruKERA9kn5F8x_M+(~KWOE(bLzghogXxL?Y0}T&t!&OzWtC!Dy%hL~k1@L_Q+UVRJkk2m2IAw>sFiSu_ z`^O=}ua>>csrv%++0p5WUr!aZ{Q2xY-UmL6ZRhf#o6kN>Ci3UATh;h-ffRtHt$B{q z^id!mCNMF0s=0;_zk!@J_)rJ(#XkmIlkYZs=uc#jZkP9l#z3+FK;M6V2KU?ezg79^B+jSy`B?j> zUjF@k+K{w|)zTtZn&u08ePO-6(SY^Mk@bN-l`MhO^%tkpIN?M6SW^CCxk=rj>w|0U zY4{f#O)m?fTqXLy8PBWDV<&umsy~lCxPy>PbZ6nkrEXqQ^gq@}jtR*a^26A9>_WH5 zX{C+h$I+i&9(z=cuF(U`W9MA`Lz?qLygE3KC*Qv3pWcPv`D~pwH&RcGKdFaQ-<4Ov zNmx`N7B%8stnM%_1sOdU2R|6CyWm?iMM$N4bZdHMNKd_0*^eD8yA~#1(z*+6Ck7TJ z;Ibk0g7nK9Xp-_ra1JOK2c;3fe-comZGdX}R=y#vEALV1uc$-6QR3n|TK;e5Vu26X zEr7i!3Ha#ktKqNaA}O&@IDo(TYWxwiChMy|SrKu4d!B@vCv56lE`1#XurN%#1QW|k ziBg!HYr$M7R(@2y=5zD6#hqfO{GQ*+J+fZnrrt3sS=HM)sK`w081+BQ?DJW8 zd9x!e0rot+vnv_G5T}TS*vaybViyU&he{kN{O$^f`+T-NzI37NpFnTiiT8N@VSfJ( zJ{p<`+2gZne8M7mD+t_V_p!Y67G1oPRY>sJZcj>2G+Heb+lBL4k4wwrx!1ULulBqN zgQr`E+4*ZyBu$*vvywuQ0;V?o*X;X4b?`R4+Ow6%7ap$UoeC%F6{Lw`|HI7hqwk0g zC=0J_*vXBP&d>~F^b_ojTlgXITf;B%9Csal0R`vCyRIa3T9;o8LzNASRd5kAnLqMN z0y#Cch_A_#mPn|z`E6VX-eU-b@$#3Y1R?7D^Z-h9$d9u4Be-Sk@Exb8a_hQc^*@k6@D)%>NhXhpz10xeY*m{-X`yYYc# zd9C1N|U~CxF{2SXWJ79kQhRxRlY&`r<+7&cl&Wlm;Uilk${#ijP6>Nr4P4!1HudL-S zg*7>chh6y#(AO!GwHNsl?X2YFe^EJS-%iR&*|O}gTd%!yoV%d*q0puHtnVGdFM<6t z?C}{rK1Sf?d9y=y5x%s?b#t75e`Q~MdU-kRANIIaO>Xzxi1eQ3>g8ei+0x6>8Pe0s z_Pk*=Z`6x_iCzxn;mUv*LWoP1PEOnR+0hT)WBp?(Z^3}ecZS!!HPacp8%U5 z4&C16hyM8 zKYQ*t>wHp_v{~nCN}a?;xlRf7dHOo$yn#an^wC%29{fJS$Cf53wkjSrYaNxf^XSp1 z=z2LDpH@9SBjY<$uAYuL@B10u$2q7qu=);XKWy}L6uZF+UOnPJbH*@A(&-ZwA%Y0}*q{Xle=2ps5{V$p>)*Lyy~>lXXn2ry+|0^1I-{2#OZcN!H^(KMQl;jbap`<( z8}$Zz_r2emt;C-wVS_~I(2rw=Vr2eTkkyr%DR5mU-+Lakp3!CCJM;edr?{SWy`Iz3hHpr(A&%RC(l&w) z=!eZZLfcMuaJ)WMw7(1P1eP;j?z;d2at|~1*uSvTts*p)VFkD5L_7evHr--`>&i*z z-BcQyE!ipQWLTgykA?gY@6wkw9=^O@Gcl^^V`k>zaVO6EbUu|Gi+y#*Mcj@(ach2e zSEad}lON7o?C8Ln;iGYp55FLK)rQY;nva$R*PEX<$JC7n+$Z(VpR2~JYtI_IDF5bT z@qK7W4K;O?EQlgE%f}r@|I)3aRL_GD7qibirdQ4pI*GpM`7?fHYC?-b3BNmAQJ8>A zM_wDBsR-I_&nm|_bX9D(#~|UCHt;3I^ZLK)d(k(~vt%OvE=`)`*n6pZ@i*>o#XaiT z7FD2VuG{fF5#<~R>24jueo?1%Q;7OPSUUe2nX^2WEN15v573wDyB>thy zx2dnxXKnmGOIA>?h*_=H*m9QC^BudQ7fjrSbkCga<8R0VBO0Pc8dddf+q*>qjig9d zDHT7q;j|GB>~>m4)37ebSpn6Dd;IZD6F;`cH*vhA-CAHNH}yP?o&Oi!*EowV9dMo3 zzmW=!K_o&{Pu>qC0kZ|$nM5+J1qLAr*=~W=n@hb@5Nmf3sG{|sIeSnK<<9c>W_1x? z5On){WNEMuN5o)FdG3A!V~azaC%8^8-1rZ_K(ytOnc@}o>unW2;$_*;cn zIjUr6VqQC>o$~~YIVDWTXN?{o1p_bvcZrASq(mJtr0%yXl8Gm|D1|7w3HWseWVK{yAC+t`WM-54k4(I(VtkB`(B5Q zTvoZ1y+>3}g=^zd`0^2Xv}Vxq*9?Ccc*Lvg4B-!{FWD1#l{?}!CTwq<_eU)_W^Kf$ z8TZ2m?+qIacj5xL7Rw{E*6B5coqJzj5OVeZJN0;DpPG|BFNEj!W0&D2Z8$hrdS)$n zvFGk^vNyM4Zz9uLc@)e!x8g!9J3rW0l^I*l7Z7gJTE{1=;SN}E<)Kppcip?b3U_wh z;5^xavh$Aj8Q`>UW}Re%&|Y30bFf|gO5D^x+xN9vc*&By`e{DLk^7OJx%hE)cc5Rb z>(<{R`|~PEf+yy+vyF`|J1?(#Qxt*9SD1Y^a~ zE_i+9A3DLP|9IhIUo9#%hwx(%{H8AnABq2Pg3X|F?1{>;_gWLtU+XW=T6YOH0ZS{D z&V_!2#8Wf8%x%ZoO3tm#3vIDbSafqeL3oUQaYA@>1>uq04VzIHj}O(w!^peQn??_T z3`wJY5~Opk6?ATaI#i}UO{!z9Q0&IKhxSzipz!C=?bZ*0jOx#HTSuH_-!Q@o6)tpiGYc{13LawFf9z z+)I9pexnCXm3qa)%I+FI<~g%{3qWcAxn`cm_u2Evc5#+m0pJ&)N(GhdM0G=QC< z4MW*ur&eH~wi9+HX#K_0 z+dzw!nv&Pfw`@KE!;AgD?9eMh~Ma{j0YaIr0|CvT~&>+;xpFpCQoFlh0;S7G$*K zGli9NfL}ge@(3#O+2NPZC;#vTtl0BY3_m2d-h~@a^Vvs^t7{+c`bu5cl}P2$9JT+E*)Mra8I8C+@948Z3s3O^GK*sql?4Ws%%E~o1F2lk3k+9$bcaZjGvWM}?0L0Ec0^LidNn?o3w( zr|7*i)rt#TjIl0j4FQt##~1WD%I*_AycG85lDj#;Sl|0$g7#o&hhd)X{W%riQhJp< zAj_3?cgy~%<9gbh5s)g4!mlSZY+?kUW$jl5!xk_wyyOk*T6g*@j$oavR%v$H(cVCrJ^y=Sa;JbV z5w~glporp15yLld)Ps8gx|y6ql;p$p@dLcv^S5kcIo7)ZKoF;?Ie*7p zgc5Qu|HtzxKXvW=6BpIh>qnoh1!>K;leZT=_2C|A^!h%%?dK~0ATwwXK~?q5}x4*O>`+?7*+ySzT!2X5DJ z_nrdWnf2kGWcF>tG?xyx{cMC@hFlaFziacE80!B+mWS3Q&nqHibKU`{1yTvaBK}2u z5{bi}-xZvru3Ze7?G^#k|D)UvL!Zd4#;CqFQ<>fo!o!{DT5Is&_#uqfHG7?ZLI6}f z_lfyck|~TkqRtaHJQ{Huh1xsXpUPrHxBA zc*!^6O+on$QAKCW@59C=%Nm#LGCBo04jMIs@}u9tz4)f^0RmYY?6+m#`BxcK>EHzh zO~h|&1D!3ujcK52zs;so*GaBj@ch>BN2};m>$i6O6?B?_-)e|dwSGgSG5yviO{B^t zyqMVfGbj4jKc3$j=Xf1gsqtI8g$|ZKdB=O|`K{&G&IdCnzxApQ*7}p#C1cD}s-EYV zy7Tl|^L!*=p43?Lqz>i2TI+fK-SyTJx90i%fwk)?oiN6Fveomft~*cmRgZ3`>UqKt zK7JTC8dCFQ#UDN$8mCG(W|JRdGJJVbl;OY;apbugvBoCE-I@`cPssVJe{K$5+$gFF z^KhOEDAq2bDKZsj*4cPE0#}#ZoyBBY;v;Jw!yojBQ;?o87BjE^3TYuTum6|ggPKIB za$~Pj2~^`TL)yD3+kG8!=c--?RKZXI$UWsAhRN z&sjb*;z4ki=QRA5_f)ydW%ykD4es)`4eKAmU+dENALDb(k2X7-&q8sBI)re!&Migp z^X&6M(_-u^>kJTlLfs)kmnhLjVG~LOaVB_tR?ky2=JmXeMCQFr7x~Dx@>)Z(X7KaW zNH!#Q{{KWW9z%ps`b2E&$;{_nevhnv3dF18!&3VvT%D=Pk{-n%zipZGBy{Hg5!;g5 zUE7v0FTgaxwnfhQScrVYKWGIVEc*xb=k5?wa&_Mvd&N|MhY=h zowAnlL5u_yiUneC=au{M%2QM?Kr0lT-h#$=M+@!{;i~!tsMAHw&;wAh7p9;G5_qm0 z1>lQNHoOFNZ+Mv=R8azJI5Y|Egi%NAmqaC13OkCj>cxA2<%x%@T-&JebR|hMJhFNH ztF*!_h}~G#klffLx4?|hOo%8x(7amKpB^KN7Qx=$nOHw(r*ag=q&?)J>?{m{sUfQNp*RgLI zot%fEQW@_uc{K8IOu+|vmw>V@t=Nlp>_rFmqK!Hkdx1S!1XH&JIvToK?F9?rPT*cJ zd@-MUfie^nA8=z@=l8!X0=e=WwqYK$yC3(^82~ zkwu7C6Y#Qm_+j!ec3bj8<>*Jq$1T{sotbwI6+Vsl1>VD02Fi`=-*pG_jq2fm1h^0w z&TVv_JY^dl!12wKTBP`U$nf`VsQu9OFUC(0y`;ufIxv$#Ma6HLbo{0X>sL`&^_<>m zX;Z&%&M}7WSXaAo{y$H-9IEX67~(HXEa9*05Y9OK3!H~E4ZkW3LHm;ri@N9oB1=XZ zQt?1sA<(t0WXk?r6~1W)F-OARR^b~J54G)18~5MzGc|GL%q%W)%(!v^LOl`x{3guI zLrjj#@XjX_^3UD4^5+Qziww3QZk~txl;%EJ_G4WCoa5{H=kd>w4wgT==R4~8v#A$6 zKl9)F)cUj8g=5UqS3S?oZ?88`X|p%a6?z_H2kFmtU>+#MK3uvAQQFk{vYyKuvAs>) zlI{Zbnpwa!t5fZm>wG9pd|wrFO#oH$;3zlM@*CmWj2&xL4yTT_GI|XiagTHTDXzyz zlo_@@&5c`|ydveWvOwsk{Pf511;lnW5A%V)-RA_DM@0}Df>scxVo8Do809zljBMYMMt)O-N`xcJ-e9^S zt&EE}zp3CNtRl^{FW_gOxdDobMh-PQFag^nRg_uDsf|zN7_1+ft~^^rQ^lDVLscOT zVvoz~aoux-G*FqWq@NpO%w)aRYxet0ht&8=#vRW_8-WG*8538w{rNV1f1&1n*aC@b z$F*MUbmP)N@#7fafZlPV7aK^~Qa4shwO1y~RcKIo*!X*uii=~vMuxs)BGmXxea4Lk z-``$0{&%X0r>%VPWMNCt+18u6qg{E9to{Y&!{&G;1{>ysMnC3cel! zp7@SgG4mn6br9ab?5zWdf3r%ffcM!?Tk(+HfzzKqOK?2+p-oLAb-`wTZMZQ#E^Uq5 zpvs?pdb6BT@Um*$LF5;V6aU=omyt(f$6UMdEzF3`bA$I6a`VbjfMVSf(5!SFj%(#; zme;kvL7Q+7`NH9QowYM5en91+r3QVGL;hidmcD!{FMv5J-$SaRIyYc}8!5Y7fxLzJ zjLR3doK}}FzG(R3q!$ADB1$?cdlJkSm1Hnqe0(sFFLFmsjxW+255DM9)70gQc0Dd* zjSJ$7gdUey_R`fxX%sNrsLCJ%S>(z^JbY54d%9$fkn)NwfO%E!pLt(QL}dfCL8 z%Z=Z~mQfJT!vzI#U5*z}($70zxZAbualjiX;uq3f@}iul+Ao%Soe$wQW&aF5f(-sg zd@@Ihd`X^hcWRd05vr~h%7i*=CRA+dduk$cpXgWK=lX@6JDXT)A1tW3-VN70ADPd% zdSc*|y7c{?q3@xk$?w}C_2GWXgz3;zAMPt{ntu=S@U7c7?%|!~`8M0m5(l{8C~tiGnJ#WPv0&( z1N`8#!SN$~y0-H~H;@tsSZBB2FZKBxQX5lpdAo_>PV)9sP!{rx0GwRAqJ_BeL;i{r z50AexR!+o+Z}aCcPS(>6sLtCjI?=zL7=PF2k<+TzQ?9!nv7K}7m-V=2_!&49ZY^>- ziJR3b#Gj)14Lb*~GHvcHJ;?Q>=UMBS)|s(A5qp2yG0wKn`(VzfnE!T}kA;JnZ`Qg` z{;m*m?s)cO6CftWboZ@1AMy`QT9pAb8y3Dr}_=@S213b9O9ld%d`z=RZ@#$H@1z&Ictf$z1h0 z-t#H8T$Gd?iymfwS645s8-`lp)4V{W?7S&2Ws?Mg)6h3XROj|hiw>B zuMMJ#R`l9D*7Qj&S$(}0A|7Vl(>r~7&Dd|sZBFf%Jf~2T=WJgwwm zi*NigS{p~vd?E8J1YfuZ#=~qPQwf1Us%|ch*;SlOF-9r0kkLXujDfS6bM8y7yv4B) zrIWgG<$lQDNvv;O8ypMcES&V_F{U2E-Z$Q4^jGlnEVsU<47Yk7jQ5)R8F!D5oX`8k zzgdDMRWd+U9tPxT>9RdtTt(v_^E<{ZI43_w4sCIf{$}My05LmVrs7u_sEVS$nLi2` zLx+oA6#CZiUB{v^`R?w!$K<+oHEZWZ4>_eLP!^=5f3q9;2I&j& z>iqtfxU#Z}YcDAxq+3FT2_E8=XM^(2aC;+Erj z9H;WIP00Nv+>ejLXASW?1GHr&elWSfqVT-|6wTrxgp z1l?ck5WjB`LgWjv8YC7~Q;f9>nNiq{YcCZzBTAhlx2PX~LZ>VyfVl1`;`&Xr+_I#E zgusjhyW3dzR+?SbqKl4ssvK z0#XU=K@;#u$oyICw|lA-*sKm1YZt-OubIF$MD_lMLQBAa z*zlKTt$X}!IGOh^NjU%f_!6BT)(j_piEo|LB9|_PR1xt65XZ_A&a=B5qt6dEeTEZi zeZz~nKIxm2z&a88pPO)wc-zUC$w!ZFJ-&?bvhXJnxOEp!&%ycKuT7rcT6c!`u@9B| zoO|TbECd9!aBI--z{Kb;0ZC4XNQ(%Bx=&e-deny^FM<#!G`uc|z4ynW`OOJ8vgSfe zECQ5*$#98xBCr2KhJnCfJ$JoMo9SCm`qOItaR?e~4$!A)9fQeC#W;s-8?7GSrpM>8 zFM2y@GMymegp z&zg0NeoCz)6|{~srbj^?c_^frJG8GL7+RwbTI8SnCxtJYP2MGMWEbwUM+U zi^Q}P0;c!|$_o8#Z~-Rb_%s=Oq+eU1PYw`DPLNnr%{0qIrqWK=7CT+gw2MWT*6zY3DyZs0{ew)gE$*|);>Y>1+GHV>Ya?P7WZH6G4QPahLX z+x*b1;TXNt`)lB``T8nE`iMvi5Rr4CEw^3j{x}p7^mR+Z#^(;fM~YNXJy4mqVcP~i zE5ns#fEYGL=Uq2CN1qVE-}fi`AKd&K{qL_d4ha(H_3TpMjVpfST;a|O<>%Rn&fkvk zDNzu(6-NsEQ{MbydX07ncwfgS+2(<+*M!r##D(bgo_GvZ840 zodtn}YsWeNpl|+2@3Bf}8O^hDy-RDuj-1ih?@%A@_rQgaT_n0Oag+1p@e!NdMlx5A z`(6UO4`&8X0#S5-zG`tPe1mzgcjkHh$eQ!mC=G^&^vg9#AcOU2 zrkJ2ZeUp+Dy3km68^dPW{aV2L&EUfr30&YFzm%D=0?tHkUQe;oG7y?OkbD7!q}z4U zr3kg3#5^(zkYEqqM8nB>>;|k}RMe83we=}8CSU;k%4{3^C!nP;kKh|-yL|<1y2nTl zYCp`@3=M=n4?>oZ?Vnh7vDB=_Z{CPI!ZESJ3_$%ZEVo^c7jAHOyGch|E()6N9ft0Y z1=lN?ab+{^AZfZN`$L%gjGN#1>Abr6g4<2t^SB2B^ALn@;vhA7hz0fG<_z4e8(p~Y z*W4Hh;nJ^e1s&%1zqYOfF`Bh5+Px*@yk~jUdm8DLq)0CvPY&q6u)`0Y5v}D^5D`>I z@PyQb(?kaN@m^deaT+$64Ds0`eS+<*yT#ZKfRGRM$td>Q*44`Y%YK12UqwR9`E4Wy zoOr@;^JE%~th?_T^o-TYV$)~L$1j8v*5h)V7Jj2M;}*VEq}#yazvJ@Ng2U_b)dqL}fA8+UfjutV zH$Gbz?)J-c9_qSaxQ*1Cnonx_-2BLbOMT+@&skUcA=xjq&$Eh)HhuC~;UbD|LY}=P z4;el(eJ?PN^o?4*4nG21G4(|%i~=fKC0%36nAoR@Jt^fW+@k1(dvS;Bb&K&j>L%BZ zGUssa6F)Y;i62#_Z=lQ+{R7Q-EJ=^Tdb{}%b3aE?I}Nv!OX1J}L#d{WQcpSm0~JL+ zHN(mn#9>w!Cvq^h1*WBm1NJZT$ydaAwaPzIW$!CH6{%1uzU`JCUzGyf6HOAGQPc;ur{HqJ*s zb}YXsSGZ|BxNx~hjIei*e*K$s{*yR!x%n2-vyX5*e`cLoF9~nY*T!+|3pUV#5?imY z+dd#Rs2+Fwx|I{a2oP1lTLr(BDgRei)hR^@PxJL>z!2`CYk#i6Ynr5zc9m`{3JX#v zE`W6Uy!srfQ>sYOOSXO_U$@hrSc{+p<2GyY1;Cf`XHYkxD0lgGAki)$k>Tc&6Pf3# zO*s#&`9&Zfrw$RlS#=)Ba_!pF^LAAq0|Ho^%;N8pQu(mZS@^q)Xo7KFmq79CB3M?@ ze@3pvo&X<1&j5S!d1FsT4^x_edceMa^h(j+5?`hTBjS%qCnN9;_llY`5wh< zu3u@(ce}b@^morY@e5U^wyz?$&t+=%gH2%}d&b6&azS}n-cSdZ=j*qz7OQqmZjHRk zdW@e$ds#RV>v8v?^Ux|;tr?%;c<^)a%OV=W&j+dV?2vpl+caS10ju*7Ti!WeJMZV? z=v8)i2W59-uH7wl5S-ml)wOBjp&gDJ^ts&7mv$qp?1r+BH{uH)d%#vkm-}QI!4eE| zRi^|>PQ8vMGJ)^ahjRsy5iJUG^(T9tLmFT!!sEK- zO(nE~yZ9JF-`lI>qqwZff2%m(_`-?s--ri4gxjs)#!P;s_dURYQ4(PoxWgnyhI`n* zNdjt;r(oHAq*uR3N*80%ys4+C=ue-}kl1{;ma|sOLoj{7%{l5C*B`RiSIL_7$<)v& zi=x>7R%4!i$vqxcA}OtH7wU%;nt>bT58G~g!rB4WuJEvJM;qaqs@Pz%|K-i!J1uSF z(Lp?1`Hb}LMLF^JK2|S!YNCI3h7XKhpr2V$c~o_N`mrKd zF?FuM#`#IIgJYbZeEvuRw>yz*MX#9z)=Hm0GOGO%h`;p7qd5nCOWh)@x|=YT4Sz)k zr=SE~>0vYBxbs;hJ@7vbKa-!DxDJbc^heB@fM*cOxfxG8Q~HqSk4(bOBp{xiLF~gG za3xlkJ*G)iTidd8?F8&hNZ}#=YfYU&dL{P3@?Wd!lCEV0zQ-%ssj9bZhwn`4R&M77 z$q3Bq)mwIb5cDwgtEx+~^)5)~`s=~@=yQ+QQ`<%RzRH0@@8ETIb&a{sUqf^!vd)8t z#$RU#@tEK`;h#mF>pr)qiN_eZp&l;nFY76=p6(*Zqj&T}{GoUr*P}|NaE4`FlnOUI zk2_r(B;khQkpKOA?Z5Qr&(-r8LqZ@O4)6bqN?o&B?(t1Z(bw4TIN*rh-hgN*(UFH` zfk@c-G47G^W`8I@l@DM&8_;G7V26X1(x;xQS%xI7ui7x~69_@Z*b zg!y9hYCm73ZVuv$tPm)GFYYYV;fpZf7`|vCIv!uF#XU8AQQS}QMHj}_@Wm(gui=Zl z8XwAFJo%#WQ9oY{>)#9bU7dff4&;kIMaN*i$gCQZFTVQyiSflt6X1&w@t6!>to&>s zUu54u246%knlN7sU*+eE=HVc|$P0l2_~QCU>+nVSMvpI&7y9_36Zh2c#pwGKU!*a% zhA;MQtl^8S8XwAGJozH}h@US8_3vf;E_|`|%0RwIDLMx8MNa7G#e1sk<%%mO#uxLh z8Q+e``X|5_tv}?u?qNqBNbX|nh^_yi0@d%Io)gG73DU*9k7yGHSKFG7?mE2lHcaEU zH7mZS&O2s)(fdF5^UnkH7|P*`2{eFzzW9j0L}MR-bk8S*mum3mW#oOv<&tcSh6jt( zNBEu{3p;NIT=yJq>@4BM0S`+K6>!J8#vgHG{^H#AKH)EWTuhH^1UWcl_(4B^RrXc< zno{JNK`+{zPOkVaS`^fwfPnl=We{kUZ9eRGIqw%oI-%S?l z-do(qLg+qm7B4TrdD4@cr|h5SJ~PkBHG%>?)&Ogtu_H)1$>i+wuoPj3&>8$<8$)-wUU z(T5dIPH+5R+L(GHuI8Vp-pJ_rwcgn0HJzpY`i@hfVbdY;#f-uOV! zJk(Ss_C+~ly~Qy3&Diz%tfj@dad?1?&G*(JQ+*+dk*!Si#Tet7^Cm!We*6t#7dJwV zNQ;Uf7Yf3}CcTpuTzULog^)27swC(5Vy5R0iW;TeOpwPAq*CHC#b@xhKTg$7zG8i| zslUW)&Yy(9L#4Zj{04|@M>A3w5^HP_X%G4P(eHYH zGY91K<8Pl|Qo;TLM>p*xeo3*Lfi9i*EaL)kCr0jctfYwJGLv5xMX*cZLLYA8LHa68 zLcd`(X5@$ZE>Aw{`CY}Pht#$el9KgD#ET6$RN^g;M5&H+=`MhT-vRiu)_t6r&wlLJ z2@QDf6yNuY8J~Y@>sJ4MG*Uk7{Xna~=MW*o{3eDSS@SLlL?Kq4lO15tl2Ny`(!vPF zVbO{VD7(ZwDu{`h5zfBHIaorG(pnJdz1O!{cDN7tTm!rrPM(U05_lsVHdTwxmK8NX z|HQj&9N#3;xG^8c*~J4>mcQgZk3nF*1u(vS9-8Tk-$&Nm3b?Rc(yuKamh-X-FDe=o z)Hh+Z4Jn|aC-xU=WUNd!klIKf~+^W3Yp&4^KC z%}h;_LRi4@HRMK=vg#Y~D=RV~X~ee7-Ri+jBc-3Hk|&i1HE~b!XJt?D%LeF`esaF4 z!=EcWE5Y>}alg*D*!P97Ue}&%yX+M7Q`v6WJU|L{QE3eiclbK{++ZEBQN72HE+Y zaqFFSdT-r&r{;cbNp8Dt@^w_V>{A!+*G%8>lcoT7aecUl8GL6<0q*qraQ8D7^~Rq} zo(?~a*QLWp4cz0V0Cz!sxZgJP-TGq}-@5%0zKPB};9ujv@;s4MesQp$-*mY!Cd*q` zo>AQoVcP*Q(C#C(Rq^@64bQ-|K=oe3i*e%fO_TNW_xswrg8VrwN%?zw?-?_{o4k;b zcgYW89Q+f>53YVMC;}NPl+swQ)YTy`J~_Zs~~BK7IaQ6uv$gG>_gVu(Lw2IUp1Xqd+QAr*Pfq>x6LLgP0o zjjkT&r}=}*%y`;VO8oKF}!(-!n>6(e* zyTkS4<2y<_HUWIge>;=-$~hu9KepG=536?|x_%4uNsZ5X_tnqqzvCEvulOTIUYXCV z#Dq@FM@3faetvdNsxbUbVO|tusInROln`0z-#}6Ae6K5}?EvQ_zp~V=v!#3v0zUZC z?X!vgp*@%5d$QzELH0p8H^clUt0am73MS3*t5NfsnS2zOP$r8;O6@8%sh7~X-#e62 zRILr6V`I*JZ&y`-we?*&wf4Ui zHU53)?)Hv=xLCAs#yIosHG8AxOWXd%pYixIn4gb4GKimBt^4Zp^Jk8#$Ip$skHgR1 z-<}jdclG%BdGwuQ@N?!{ggsGyE@Jc)`T1XOv-#PaFQ^YjpFGFiuln@6?9TtFJrjN4 z+qXx@+wTv}3fk|cr^egw6Xyr*ce{08eSD8;skh(FyUBi2Z>l;+OW8!$@PrKu>?t$} zMtb#sLxbN@M$y(j3#on3blR_d@_J;En#tBYJn|Xy56z?cAEBu#-w}cSN4vQFkEkCR zcy{a2=_m3dakQ2D2gX-h-{JCeZM{JBdxn=6v$^P4^#a4){`hM16+!XU{2&1a#8fXPtT4u`;%4ULv0u@@$Xyx`!lG2 zPvdtL|Gp@2f69LvPk-!{4ALKsfA;RHuRq=~ub%#>5I^O2O+|kcWZ9-+xbj|t^+)t7 zrD-OqKcYK~uRn~RyN^%RZJ1k1eP0FXdCqjs{+aO$$kY6o^OMy}%qOqZPtp8%aPLXD1H~Y+3$itxoKLh>jbWA z9J@|nj|O)iYHy7dru zTvV?o4UqDj9v6Mc_Cgmkmhi%QTo&UvB!06;7h^9CzBSM7B!;-nUVeS|+UIsSS90LW z@9-b>$Vr&7$8LUa(N0*xOZnlQC{q6NM5su#H3FPBq*O2^^$>T?!P2o^iH;+HOgUmnCJXy1zzdDaU?TT^oammTe zll9Nz=JCJ#&2i=-zlh(qKJLnu(I51~hr+Vn;5yIIA5B=lRnGP6x9-b=^jqH#>*%+a zhU@qR&46R{TZrg*`t3Kkr$)aG&%k;Z|Hs%G{dUGSHTrExjSqEUJmt9c7oHqb&b#&R z8T>B#?eKF0^;?YN>cw%ouJy}%l^p)Mb7FG%_ypuIy*==lfE==?q4340e-oG&ZzP^!(L%@$=H-$VXyw^CW(()>)kwe|yk8sZwyiFUll8 z(w9K#fsC9Be}PU}VBSLV=j4|q*vQTz66J2^E+ozwlvSbUXQerpmAiFTEEhg92{!d; z0#Ap9G9?GCsCbN5XTprT5G!fk1mH>MSJ9}^ka1v%J_!J8CCzui-y(N>&XXU?Nsj#Q z@?B(g1+AHJ#C365hd8gwnYW8kQawC$niyI^9Y`%)*aax%e89sciCLVlFLQBW)q!&f z{`U2qDS&S=uUr15>hqdlrJ+R-Tt{LOIlaMK@VBndb2{O0S{A|iAYjV+?0z;wRd6?w zuH~qLi&(va+jX4<_dOomIC1^sm;Jc^4u8u$CLcjMmZyV`>bbH6p4Dl_1M-b%4AX>8 zNnzx55bWPHtLJIF^X^}GILW~c_F}KW3kJOg&K+(m` z$+$Ps=dPuHbn_4Own;?y+zvl^Ps8834-N3-hxk^uvG^1u48!@baYSv0MZ#vBMBTl; zks7n5QDKZ;JzOTJ*bIzIf-xV%Clz^&WoZjvCB+lXfxzCz^!MlZG5t0EW*%dWV5#s- z`S4tEs*U4aJ{;R5;G_62KRi_&`))*9UAJaRcr_tH*>`LFW@yKjbPNGM;N-^3@f;zV z!3`X-H~iXzxX(jz31H%BGsLKdK`XHC3iZyP9Dg5;3*HNn+Q;`repOOAFxBj@!r(X= zFM~BnpPeU#LF9#KNW_7))&dGHns_mUi)LrX_5U%H7WHt-+2mKBo|-1|1^z^T9wlEf z@M@IuWxr4I()U#{Mh1(sWJ_YA@-neX=q4ig;QanOH8Z0J<3^u&NxwLRy`QQ~{Kj$E?;4ZdzjX~~y?TQiwlGK-*f5}e)a z9P{%UxpdA(u26HkUR10d6vFtJ^Uzr?=S$hsZ=p~0SW)jci++I>ln>Y4toSTx*2niM z>3rb=={J|le2u!jvzct9(x9!9wpI+MR@tS#f&Q1*%Y+7hg%YIO_H z=n55+AbuOzJ~=R-|DMp$p6q`(*^f6#&S_|O_65@5XIp40JKwsi5{SaAre zrS-4Kiuc34s#qqndVk0yg(MDD%o;rA_3qfZugxzp!X3cc8I?$Mt(JoTk$R(L{4TU4QjEXbnvSoqWkOzR zBd|Fn>L`f{{f74 zD0<)4eb*@Q5_?#BL%~Vhp!>3|(bSj|^3fy5ar8_2@7nwTVHR-%VDiEFNbk#XlkG1F zeu~ejYYm^fy4LXf;7>^(^a8mHd>+QWU z8hV^wY{}Azku_(b28+9qA@`HyS@N;kpho0&`SL`~?2^01iy^sZ?#5*1p;@JD42m1e z>IIhl5Aw{QUq)FW_M693pFO_=m`&5yVnPj>2^4P~||(rJb#^NO5TO z1T7M!KpJJr;~aT7KX94wTFm+V4>)^bR^{K=bRSgn8hsgAvkvoe?YWfet1=UWZwevt z#O<;>)$hrAJh>oNSiS3$dx*X4OaZ$%_fO0O(R;ZCk`E1#0Cw{s@d@>^PwXlFNID%T z+n|5LhpG9YULX2b6@4D6qR*&=LR+A56n$Ww(e4+T2^avA3zM83JsL?tJnDj%w8AOW zlPf}PbY4TPAM}ooKA4y6+jX<(12NP6OX5z~id}r;@_Jkz9=-cq&H*p;?C%?w(c^MB zQ80cGyZQq#brlruP1nk*>6a7~wv#~jnEtuaPU4+XM`-&cZ3<4M#FGijEUo8v9{B>N z_48Nv>sW_5Z=oi3+n2#!SXYSa5?9QfEz-MOY97vh%@^6qCvE7 zOGWj{{!q4Fj1o^X@3xWEOQ{xFE4d2L!b1XW@pN(r@BY5(s1a9-f`2IOz+$2^SP)Ax zBz*GRrSK}1f5QDK046Q^q%p4&iy|&WNozksjcGP#f`Y6UiFEKHaDxkp3n+%UO@bU>pgWoO zBArn=1Kw`M?rPr4LAvI4o%1A$rA5dRoo%QyjhSA=oYvNS78C#fXr%#;p-<+b) z!De3ShfD?Y%0cRJyy6{Y+0#0QZ20S{;OpMCbVgpDwXOuO49G>D^IlvON&}pH2scHz zSVDqJFx}8NmJ8`zs{-)>d4ZU^FEohz)=QUMG&7ug@T<<2I~GGYyE%cWcjGlb($Agu z8Tv^yACr$}F*&AmHtjmoM~eMH3a=hU^yF*8uWmd;y`N+BR^e5NJD{tj31!HVzl|mP z>xT%Z6>zHP`DyAH66ulA#i5bLVO3HM{boMAFTwkayie;~G%~74i);kQ7>eF5oUpyy z3Qfcw`3%any`P0wh3=swmhPk9jkhnB4M~$Grsau#a#4invydSL&)_vKzwi6cx^k2> z{QkiCF27G0?*0F$3-?F^cjXk|F0T*wSOa(ODZrgsAMO$Zcf)y;r^8*Z)TP504BT_3 z0QZdgaL+Pu_m~3QUF*YLVc@RsnmipwUam`riwxY;rvP_peYk53+{hH*?o=P{fPs74 z%E{B=mY3?%A#LEEGzGYe>%;w)fjeUgaHrRY`#l5q#&ai6ho6?~(&1_Y_qZv*T~HtH ztUu`IHnw(79^W^%)W!EF2H)$Z0QX1r;r`UXJ!%SYkEjp#W&`)N6_cmKD=*fi!yN|h z52gV3%KC8cHgFH00^Hg4;ofK9ZdpEgI&A)XT{>(uaKAGJxZkV~_fZ4)(^G)^iTZG# zFmRt+HhDTc^Fm!Z6b;eA{PN`K@Wkf2bSN9RYo-9V zr#{@*4BUgJ0QZ3UaQ|)KKGrdLIz0S*T{?s+TK`@=1-KW~hx;}IcfVk`*;m|i#j=|I zsUBUje!4vEB0nj* z9AUw)qRSzMF0Y;C(#4#=c#dzk@bFXXAilpTplH=kWAB z45EGnSpjKh!u@yNJlj`#F%r979WYOG&*S6r!Q$sUdRDDBVb(jtTknMVYkGaSjRx+G zX9m)-OVN?4Ia4vur_I$WQwFA80yZc0SPYuV42qQ475D1zSl7bECioQ8TLZQbwJ6G`0a z>WO`xFt=m>?R`yI_fMb?QWncr=|op?2zqyZ$)`M2A0(rX%zTWW7ymBn<#Taf|M14& zgO3gWnG0;TPKM z;Ww6iW;YoD^UG)XdGG!)}0yGoj}5%jf6= zlb6r$d~OQzIVkA=H}cu-fZmgk&kl~)&qq&CK4XHUkGA)m z0qYFpe>Gnf|35SZ{>MA8CT*Vv1^xeu|DT;C|8x8#`CpK9`5&~IB>yvuxGnxO{Q@NK zhQEP_>KAYcegW-FF>++h7x)EBAPO5)^@lD*zSpgoEkqwdDP{jFwBiM%V2dWji_#qS z0J)HFP%1EI_yM=EfRwatnagZuH>MYy_%HpuuD^jU%xAKj|GXcW10kHkePaaxr8?i+m%6J5&I`ZV}@oDaW#eAPbZ>3{ZIFyn)f z-p4Srs0tLdRB$s&?tm2&>yh4T1gom&04axQ-tViISkcO*H3mB(?vbJVA0<)$#v|NatPfv?`D25x3A zOEzB3|D5zpw0oFbUt4CiF7n`P^Y#tz$Ch*cevIy3I0G zSf!PJtqnTI{uwN%^-d#Z5?adqhK|B-_{I1s0e z)XGmmaNy8*tx5`U7bln-wO1v61xpM=0rP+-II(Z9JHPYxsR@vS_o?z{;djOfmt9P` z?)x)ntDc>v<6`x7;$}M?hb_fF>O;QF;(jRYMq?7u*J<|Nz!xtFTkvT-V7(P%$WO%r z_KXG+^6pmtu4pJ4>2De}2Z}_9uN@~Z7=E_=P2uN-wv{-H(920+%>X%7a{FJXnR0l5 z$vk2KfATMw$heqdgq%axT)9K z6EUDlwjZflUlDR?^w}}sKUcqh+_zZWo(U_-E%>(gYe30+_vr-)YKszDN zNk92iV86-HA&>48h$oCM_7Ppaw{~Sqs9Od}6Vn=J=N0If` z$*S+_KBTKYDrvs?6hs@Ou6Cg!PfHjXfOWJz-JB|6-R;;$F1<)wdU& zr?~qN$MT%Q|BQ)alir8QgV6FpI9BJ4(&T3k&ucB(`uGNOyLutO&$-9Qd+KP<&$0P# zocn)n?vGCG{vVn9^C@qBqaUcZo0I7OpyNsP`zGCdw(c1eD8J_Zfc1}<`BT>XL4ID- zAB8_@KO#Nf1%>EIX$2|%+iQo&27CS+SuW^Zr+t4Tqws0d>OckDBXTLE%;&c;C;$!% zrJk!jNIK6S@9zWO_lU(8IJ13^`(O3mV#dn&p`5mIygGO8g;fzT%oQHST=u#1DGa6Z z?#919yA-*t{Wgf&q_%=-M zJ?H)AObScuy>qoo&CJfd>gAE}un_y|kv7JW-Y0Mq?57PsMfgUZK(_(HEk`KGnSle>CyKLNYeUGmvASFB#2@46A5T?>*g@|D*AULLpXXa<@@9`~H4Dmesi zxhMO2dEA_!KS6m6%;O6F7XO?_dsiiQLF+E$gFeR7~@3#S>lGJ^f4lFC;o?2s$+UXg;#3vi-2YBymUcx20q zVe(SOG3RrT5-LLf`JVHJxGt9-ojWO7NDiF3tnc|6p^x+~6c@~Uk1pk@?;%&7BCB7; z7YK1?@Q?OqB5NdC24&;=^X_?c0c3SK9u-{NG;hPD4Q&8E3L8DI|CbFNxaN0sO2QN~ zEVYlMNGIhl>Fc`?9klV)u!+{DIZA~{O{?Eg_1jefh(F6q6>jELf%g{8@0^_9mPkgp zP=>ONAOpX8x{9)8r{u{vmrEI+j9qsHuxp+t-$DEb*tK%k{`c|tuQq=1+JRG$yS5id z{Qn)f6J8U&XrBKgKQ$|P<2gOD`j7Ym{FKH&E}K#)!thWZ_=?XE zYaW91GKet5jszJtR~Y7xu<7QRW5X8YKYlB0Bm8BtjgV!nc-#mekewbhL{$Z~XIw!h?66y7%I|kMnkBr-Xr2xVIM7{~a zlkZ0`7EkF(ybq6tDSc2g9)e$dQKmVRZv1+6wyVq66Rw3dDJi1dhQ>p8SKQ zSEqM&TQpD8!cxZhA3tII*P+(gC;Yw-JQb`nJNgf^gtoh?&^HebHP< zUUo1yhsS^som!N~L-=?F_o5-h$PyH?eTPI!rs7{@En9J8Us_pl%lRne3@&SNHJc2E47VHP|9BRx+QI4aXn9XlW z2B|jDR*7=o$H&xpk;X+cF9vau;KdLwqP)o9qKOy7xPZ}RdmM;)PSgV~M!R_!T>DFH zUQBzFW?8J=-bCq>6^yU0-~nPq0}^ql#_h)oAM&cb31TBj@))`-&BcYXhqz8beI%Vt z-=ZtvHbr#y-;d9s+WU~cU;GH~IaJaf#9<;?`mmInger?b6+EYpJ!r&E&$|7vAO01u zS3L90XF}_D!~fQ0{=+K5&LpM=Q=vV7|B^ECG7fstIs1pxe7Icwe$&T^`44_52ZL4k z{6XQfI6?}RQ%`dzT9WhnRg0edD^SpAR8U4!g~s)7N33IAdir09NJ4sE^`n7A51z+; z{uk5aV5jt#z5e`tihq;fEaBhN_2cV^OWEUMdfYI^DU@(rK(ivb=SsQ9N7vH53T_1$ zVoc{!#k|hjeaI>#4K>KSN@|WqTFXs-=mP6SU40v`$O!f%_ocZvBIak3+tO@U?4d*WwS# zR6ERI2jZHPCuI^>HFR?y`-=FMuM-<2V-NAGOl4=b@GzoMl6abtj6UdW{#GP|6RPqp zz+Qd45=P6ohwK~;2VXV*=aH}XZwYzXY9cw(v0i0Gp~uX6@U?uno;2yE^Npu~;Fb8R zAP{+Icg}0c(yUAUVJ+;gS?_l){*Kb+I?{pW6W58Z=)KpPIum0r2E?s`7itMe64E>a1gDmsP7f_r6sxbqF% zHNkL)&l&^Y+4bR`Xy6_c47YVGxSM}fmkwK=({y-jVIUnsW5NAqeYiUsd@l}$n>lj~ zI((u&+_-_eUohO%Sa6^DWnDU4YT!PwAdn7~GseJopg!F18n`Qi;SP-j_mKK_4BT^q;SP=k_kj9vcl(Ow-#voiCdPvM z@XdAUaHxU1{^&qDl)g9y9WJO3_hN_*f&XEq`o@LNp3C&oSUzZQRmb#Kc)27kqi zmmyzUdJ`2114lF?uF-^KDq?2K0eCq8OCp>J@S?NVlcp}ooTJ@1fK`7GzHX7*H;(fb z?~!?j<^1^qB9m2f568Dz5s-V&Vru%$Is6;PzoYoK5&!1#FC0&_NM;B|<>=wUOOAfn zdE&9-&C#I?NIFaRJ~d8nmo^OI zZ(QS)c4@;9t~n-yf8&RI4o9?08@|r(@Y}HdEsKB4cfn_oj#8I4Jrzah=!K6MkmXRPF7UXc|}8R);c#S{E0){C|VM0REZ|94;|$@`2+U=0}T+D;vcJ=A48>5`~?n|j3cy07Uk(lb|4T8lA>#wsbnBcuo%O8zM6cQ%USvkbr_UyD`qJ1aih-} zCoZkG==5`ZA#~cVicUA+2R9blhCiIjZcDlKZH7ovgW(au5GiYjRJDFXq=F$*(E8mX ziLc`@NFpJVQX4S!uRq517=4fRQ$JO&pRo#l$j^g!$oiS*U-nTS`)-(9h;9#CmBQpO zj&WF^sJ1{}mDte_tJA5_)y~5azN!0Ctsqsf9OYq%r69#@N@bx}%zaY-uukxidf)d| z;ZsTjAK2=cek`}-+@O_CZT!8sAKu3yHG*O1t4sLejD&BV{BOpXr&2x7XX?(=WzEwN zFi*RhN9rUeSf@6O*;UZSt5bWyxLJcAa#d6uB(BMmWt88e@~cl_L=6qYE^o88DALOZ za$Mf-#vjhR-vQqKKcWLBmNcl{|Dh4T92^)R2PS`D)nLBcR`C`!1xJ z$sa7<6$Ke8Z;(e!uzBIJQDJ)Gf%w&d*6XY2r-Vr2DtbXL23M2Y~C4g;mzVjALaS|ODZbFicYRQ zaKO*nN#kqB!Mg}o^*@H|F5PjHI1j*;p9{6X^8tGzFTvSh`JqYJodou6KXx$2C~4Ne z2RNJ4yHVLM0x#ngW?>*1m8B=h@8|_)#TcO3FMpu>mmFBpkmMiKtu6gmiSNhJ^!rpU z<5Eev=MlqXI)hN$STD?Aw@G;P4eJqKk`YLr&`J&_MFFg8$k0(4=2!atyE-tOqbsnQ z{>&(U%*U`hEv#i|fuB?2SE>;yM#2Bl84|n#^CJx{{V&by&q;;^1=x?$rZ7R0p!ZC# z7}rVAKH=QH3L#&c?xEZNTe>?va3{r1>;m%hLwlXc3S8{Yk`yu+ZP?Rx_@AwMPZQWv zq@NcxVo$NRs25gy$_I5$;GRlxQhYvEi9`&Zx0%zB;%>LjXD;Z8`TY;K^xxOgef#nsmN}MO78&{BPO$7F!OBw}B3jm#mSO)BhiP?*blIRrQTeDbPWI87;za zv!jh~gWOWQ5JhB4TbbHK0xc3Ol>r6gJ+uvt0xv_`(8N%PQXxo%Kt%#xh=LG|hEy&c zs6Yw=gD4CFGKVS*qI9_S|NE_d_Bs2^oHLWe!uLJj^PlHwbI!~;Yp=cTYwa86^m0}h z##?k=OT6kxFW8S!YK{y^aSvmTPsHu&S?^ z)jF~7qtcAdCmbDV;}?*tOb;?=4p1PZ=CA{z={$uLA+_vUJr~*|Cv)UFqtxuzDPb9< z;W$H^do4q=1-TQIed2n_j-SC$dXv(~>Z$mhN~IH1UNb43IcTAg3w@H(b#_v^t}H2? z*R}TlKtj6CPDs~DLP`S=13%_<{cgJ^qK#euZzZ9PFh!Dhc5NKK9?1bVH!jFfNWyyN zP+DafwUu(mvR&vP5}tZT{Vifo!qCnrYzay_ZE@HV*pIoeBaQGA3%1S0V&uk-2O}N- zOEcgthFs+*a|itYGAFu7?-xbo;QxJ@tNn*9bFBwEGS>>TX@#aBHePvWt0(X4%}W~J zz}Zi7%!nNPa}LvWm_OP^_~AJ;ntH)O22r>eP8I0GO7_xna&-2eGCE5y?2gbT(DYF8 zZX{w|ZHPD9a+sUqoRWq|v&aLA&Nwt4mJjWE>L%#JnzXAP@O%8^6~D~9LDv%4FVee@@a%E& zz38Zu?^^~N_M*z)idJ&ksiC2aLzFb%(;woK;`?1s%o<*SXTaI8_3792{^t5QW4v1O zyxz{A51OLRW6%!}PksO` zGzw_Qv#tEG2Qb$Wx~N~(dc1*O2|XnLJ**VZulKrm%Hm)LPu94&KNIs?XC6N56*^{N z8>IJ$f#Hv&QTH~)>;?;>dkHVt=JmW`XNs1 zo!-`efBgdXDn2M*pBomih=n;VKW-gv!|e%z`wC(=k`U)k*u*3MS_a&8dDjqnvp{dd zo@w^(aB*u68(#T357p7jB=%y*^z!_+VMWk^pr)^orU5;a_jc*|e(6$eEbbBtJ!0ru zYn?ve9BS4A^|IDXvh9%OJ@M~6L*}pX0d0ymsd$)Ew0MBV(rK^_GhibQMaA`S`2C|A zx)&XTyzp3^7oMo|!c%zs5YmqYU*V}P$UT;Rnvc70{#Bq#&cETiH@%2I#45+X-79JLlZdDDa@)O4Zr9cn>k<+e~1+i6$Dl@A}i+)9BkrEk~bW2;!P88ION2eX5Mhji8m?U zaL|c2Exh5V6K`61!(k`hwDX4JP7U2R*Q7xJ-iKiRc~2JeK5XBU$Gnf)_hd5f8S?Y_ zKKnjy-;>S!omn@3C!cv=XWx_2yk{kXzmM4WtR?WCtmf}Y`<}e!Jwr79PG<9-H45J6 z?E92`Pj>V77Wyyi_WZ^&uh^znvF zNfm^ z)reYK4|)sLg*4E1KH5(~=T)6e%`NL$Wk12+Q$KU;V5H*(;0S9KZH>V!$zqnfqLQrs z00(Mqn~p41K76m%eD5yxUT6@=;XS_7c7w8w1^G&?$UziBm(Ju|<~=fg;D_+CH;6w$ z-hzA{1~V%zOioXVbes+Nh=$2TUm%?6ISTA>w&$W7DFaFWw)Pe2HVZEh6lS$b$oV-J|- zj0#J^j@VF9g<9C$g|}N?H0hY|v=`~9wdHNgJ!g30$XLm9m*AKsKnriV+WTCg-^4%C zagqI;br!nnv)*u|S^}=Vj54%F+cN+TDh9fDurE|D?Oi;`$EZl z*4RDXJc#&cxn^B%@TDd2eXqb&O|jN~W~$UR^zTvrejVh-9vAoDN9PbQnBlT3ZyZlc z8}FSBgmq1C`In$M?xYwQPhS+18eifA4C%Q_hXy$%cb+9n__~W$~)3*hD~+WTrbZtjLFqrEmpIU;G4yNOnN zQK5x=8+FL8`?2@?tJvTIMk2lh^Qe($v)-*H_}q2DOpRf^jiIuGI?g2h5+rPjH}zAX=Og>B-07JWo2GD&EYrYCx5NfmmPL+pB6EO!h*UF5~y032nxd; z`t&t#vmnF1a%mI^&yDCvYg6vgoO~$vt!P*0r`*S)SX+Z+8taB_zvS*4701)odw@1L z6W1}eXP4l77HFyh2F8WR`uq?Xpk+Q`%e*v>|Jd)sPfYvQwqB(hLoM!WYCUABe)PWJ z>c_I#<@(V}xE1wdceR;QiGB^rPv2#-tzpFMIVP0l22Q^6E#^hqi})nD(`Bjr2o}o3DVNmgsrD zWd@sc*9(5v(Qg_LE03e5OcUl&l+hya4N~J~(`0Eirq57njPW1+q5dR^ryKuVI8;O= zBMLXYNBcQ#ze@ewEFkC%?jArxQy2kv=&NW6LbX5=N?e#V9Dh}+Lq+R=-JR(MF|bS8Iyqc~iUZ`6=XyapD@LYwumDGdE)+H>u!1eF4d4;YA%^E&JVN|fD?5bURkEV-J z5A%mRIT&t(hI`|?#}D^s9fA0sqT!x60k{i-;eJKK-S)2WHa>MC+#pHn= zf4J09bIQLp>BZARo_vI`OtpFtB^A~|M7w%EOq;>IGS$X{1+}|c)Ozr{CxnK2?o%P5 zBgZIDUzsDK6~KWo_8ecjOcVR+kmH`PLk`Lp$>E*H**d;<3f^`cGMwty zj>+eo^5ZfOFjeCFvgt$o=B(!svSM^aqUo%4?Df9;#kBygXTP|uaqm3glKtYE@w}cl z=H*M zdE_J0E%AiV^YbP2%nu&wjV0`T;eON9bm^)1=zL_}AF>iEHVV{*j)M6?X%3BAcD*^h?b^`2&9N z8qj(i)ulh$-kJ9EAu*h+1T(~T@@Ty-6vGjiFH!^qv={EJqg*({5xOpA!XLRz$wfUM zwdrAPde#}#6|24;=VX=4Zzl{BFG+?Afq04CH2IfgyBsw!_OU(+7Mf@`kxVYy&VI2b z-eDW>Q4{Z}z*}C_n-Qyg)oge4Qq|w6Vg=9F!FlN78yxv0-TUq5I^E~mHro4Bn0Tbs zbHxF9ZuTi9@=>N|^;a2kaS|lcAYx?ok@x~u1JbE#4TS>4PEvIgBRW5d>oo{UVN=|3 zyF>BHw&@UKY|Vku&^qiAYU0;SI=S)iqkvqtFNaB=_A70^fDi45kq_L7R6yUi?^`I9 z+wElj?QN$(I*g;8sL@W&+s^4`JE@X(I>*^g|Bv1NBtPQm&zt)g{VBfe?N5B1?IetL z2E6V3&}^rtq@BSZj*o8Hb#8xR5D0@m2csRMFekpUOz(R6zUI@8OFo)hS=?y}2jWBh z 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

  • +_CQ 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

    6h;VI)`3l>U3(R5m%T_?E^nu%hM#k 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 z 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∋p6T8my?GFET*V;|Ze@J|r50bn@{l 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

    ;X6HG|jv4_c4!YH+KcMp< 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

    • 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 z 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 z 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