{-# LANGUAGE TypeFamilies #-}
module Futhark.IR.MC
( MC,
simplifyProg,
module Futhark.IR.Prop,
module Futhark.IR.Traversals,
module Futhark.IR.Pretty,
module Futhark.IR.Syntax,
module Futhark.IR.SegOp,
module Futhark.IR.SOACS.SOAC,
module Futhark.IR.MC.Op,
)
where
import Futhark.Builder
import Futhark.Construct
import Futhark.IR.MC.Op
import Futhark.IR.Pretty
import Futhark.IR.Prop
import Futhark.IR.SOACS.SOAC hiding (HistOp (..))
import Futhark.IR.SOACS.Simplify qualified as SOAC
import Futhark.IR.SegOp
import Futhark.IR.Syntax
import Futhark.IR.Traversals
import Futhark.IR.TypeCheck qualified as TypeCheck
import Futhark.Optimise.Simplify qualified as Simplify
import Futhark.Optimise.Simplify.Engine qualified as Engine
import Futhark.Optimise.Simplify.Rules
import Futhark.Pass
data MC
instance RepTypes MC where
type Op MC = MCOp MC (SOAC MC)
instance ASTRep MC where
expTypesFromPat :: forall (m :: * -> *).
(HasScope MC m, Monad m) =>
Pat (LetDec MC) -> m [BranchType MC]
expTypesFromPat = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall dec. Typed dec => Pat dec -> [ExtType]
expExtTypesFromPat
instance TypeCheck.CheckableOp MC where
checkOp :: OpWithAliases (Op MC) -> TypeM MC ()
checkOp = forall {k} (rep :: k) op.
Checkable rep =>
(op -> TypeM rep ()) -> MCOp (Aliases rep) op -> TypeM rep ()
typeCheckMCOp forall {k} (rep :: k).
Checkable rep =>
SOAC (Aliases rep) -> TypeM rep ()
typeCheckSOAC
instance TypeCheck.Checkable MC
instance Buildable MC where
mkBody :: Stms MC -> Result -> Body MC
mkBody = forall {k} (rep :: k).
BodyDec rep -> Stms rep -> Result -> Body rep
Body ()
mkExpPat :: [Ident] -> Exp MC -> Pat (LetDec MC)
mkExpPat [Ident]
idents Exp MC
_ = [Ident] -> Pat Type
basicPat [Ident]
idents
mkExpDec :: Pat (LetDec MC) -> Exp MC -> ExpDec MC
mkExpDec Pat (LetDec MC)
_ Exp MC
_ = ()
mkLetNames :: forall (m :: * -> *).
(MonadFreshNames m, HasScope MC m) =>
[VName] -> Exp MC -> m (Stm MC)
mkLetNames = forall {k} (rep :: k) (m :: * -> *).
(ExpDec rep ~ (), LetDec rep ~ Type, MonadFreshNames m,
TypedOp (Op rep), HasScope rep m) =>
[VName] -> Exp rep -> m (Stm rep)
simpleMkLetNames
instance BuilderOps MC
instance BuilderOps (Engine.Wise MC)
instance PrettyRep MC
instance TraverseOpStms (Engine.Wise MC) where
traverseOpStms :: forall (m :: * -> *).
Monad m =>
OpStmsTraverser m (Op (Wise MC)) (Wise MC)
traverseOpStms = forall {k} (m :: * -> *) op (rep :: k).
Monad m =>
OpStmsTraverser m op rep -> OpStmsTraverser m (MCOp rep op) rep
traverseMCOpStms forall {k} (m :: * -> *) (rep :: k).
Monad m =>
OpStmsTraverser m (SOAC rep) rep
traverseSOACStms
simpleMC :: Simplify.SimpleOps MC
simpleMC :: SimpleOps MC
simpleMC = forall {k} (rep :: k).
(SimplifiableRep rep, Buildable rep) =>
SimplifyOp rep (Op (Wise rep)) -> SimpleOps rep
Simplify.bindableSimpleOps forall a b. (a -> b) -> a -> b
$ forall {k} (rep :: k) op.
(SimplifiableRep rep, BodyDec rep ~ ()) =>
SimplifyOp rep op
-> MCOp (Wise rep) op
-> SimpleM rep (MCOp (Wise rep) op, Stms (Wise rep))
simplifyMCOp forall {k} (rep :: k).
SimplifiableRep rep =>
SimplifyOp rep (SOAC (Wise rep))
SOAC.simplifySOAC
simplifyProg :: Prog MC -> PassM (Prog MC)
simplifyProg :: Prog MC -> PassM (Prog MC)
simplifyProg = forall {k} (rep :: k).
SimplifiableRep rep =>
SimpleOps rep
-> RuleBook (Wise rep)
-> HoistBlockers rep
-> Prog rep
-> PassM (Prog rep)
Simplify.simplifyProg SimpleOps MC
simpleMC RuleBook (Wise MC)
rules forall {k} {rep :: k}. HoistBlockers rep
blockers
where
blockers :: HoistBlockers rep
blockers = forall {k} {rep :: k}. HoistBlockers rep
Engine.noExtraHoistBlockers
rules :: RuleBook (Wise MC)
rules = forall rep.
(BuilderOps rep, TraverseOpStms rep, Aliased rep) =>
RuleBook rep
standardRules forall a. Semigroup a => a -> a -> a
<> forall rep.
(HasSegOp rep, BuilderOps rep, Buildable rep, Aliased rep) =>
RuleBook rep
segOpRules
instance HasSegOp MC where
type SegOpLevel MC = ()
asSegOp :: Op MC -> Maybe (SegOp (SegOpLevel MC) MC)
asSegOp = forall a b. a -> b -> a
const forall a. Maybe a
Nothing
segOp :: SegOp (SegOpLevel MC) MC -> Op MC
segOp = forall {k} (rep :: k) op.
Maybe (SegOp () rep) -> SegOp () rep -> MCOp rep op
ParOp forall a. Maybe a
Nothing
instance HasSegOp (Engine.Wise MC) where
type SegOpLevel (Engine.Wise MC) = ()
asSegOp :: Op (Wise MC) -> Maybe (SegOp (SegOpLevel (Wise MC)) (Wise MC))
asSegOp = forall a b. a -> b -> a
const forall a. Maybe a
Nothing
segOp :: SegOp (SegOpLevel (Wise MC)) (Wise MC) -> Op (Wise MC)
segOp = forall {k} (rep :: k) op.
Maybe (SegOp () rep) -> SegOp () rep -> MCOp rep op
ParOp forall a. Maybe a
Nothing