Safe Haskell	None
Language	Haskell2010

Futhark.Pass.ExtractKernels.Distribution

Synopsis

type Target = (Pattern Kernels, Result)
data Targets
ppTargets :: Targets -> String
singleTarget :: Target -> Targets
outerTarget :: Targets -> Target
innerTarget :: Targets -> Target
pushInnerTarget :: Target -> Targets -> Targets
popInnerTarget :: Targets -> Maybe (Target, Targets)
targetsScope :: Targets -> Scope Kernels
data LoopNesting = MapNesting {
- loopNestingPattern :: Pattern Kernels
- loopNestingCertificates :: Certificates
- loopNestingWidth :: SubExp
- loopNestingParamsAndArrs :: [(Param Type, VName)]
}
ppLoopNesting :: LoopNesting -> String
data Nesting = Nesting {
- nestingLetBound :: Names
- nestingLoop :: LoopNesting
}
type Nestings = (Nesting, [Nesting])
ppNestings :: Nestings -> String
letBindInInnerNesting :: Names -> Nestings -> Nestings
singleNesting :: Nesting -> Nestings
pushInnerNesting :: Nesting -> Nestings -> Nestings
type KernelNest = (LoopNesting, [LoopNesting])
ppKernelNest :: KernelNest -> String
newKernel :: LoopNesting -> KernelNest
pushKernelNesting :: Target -> LoopNesting -> KernelNest -> KernelNest
pushInnerKernelNesting :: Target -> LoopNesting -> KernelNest -> KernelNest
removeArraysFromNest :: [VName] -> KernelNest -> KernelNest
kernelNestLoops :: KernelNest -> [LoopNesting]
kernelNestWidths :: KernelNest -> [SubExp]
boundInKernelNest :: KernelNest -> Names
boundInKernelNests :: KernelNest -> [Names]
flatKernel :: MonadFreshNames m => KernelNest -> m ([(VName, SubExp)], [KernelInput])
constructKernel :: (MonadFreshNames m, LocalScope Kernels m) => MkSegLevel m -> KernelNest -> Body Kernels -> m (Stm Kernels, Stms Kernels)
tryDistribute :: (MonadFreshNames m, LocalScope Kernels m, MonadLogger m) => MkSegLevel m -> Nestings -> Targets -> Stms Kernels -> m (Maybe (Targets, Stms Kernels))
tryDistributeStm :: (MonadFreshNames m, HasScope t m, Attributes lore) => Nestings -> Targets -> Stm lore -> m (Maybe (Result, Targets, KernelNest))

Documentation

type Target = (Pattern Kernels, Result) Source #

data Targets Source #

First pair element is the very innermost ("current") target. In the list, the outermost target comes first. Invariant: Every element of a pattern must be present as the result of the immediately enclosing target. This is ensured by pushInnerTarget by removing unused pattern elements.

ppTargets :: Targets -> String Source #

singleTarget :: Target -> Targets Source #

outerTarget :: Targets -> Target Source #

innerTarget :: Targets -> Target Source #

pushInnerTarget :: Target -> Targets -> Targets Source #

popInnerTarget :: Targets -> Maybe (Target, Targets) Source #

targetsScope :: Targets -> Scope Kernels Source #

data LoopNesting Source #

Constructors

MapNesting
Fields loopNestingPattern :: Pattern Kernels loopNestingCertificates :: Certificates loopNestingWidth :: SubExp loopNestingParamsAndArrs :: [(Param Type, VName)]

Instances

Show LoopNesting Source #
Instance details Defined in Futhark.Pass.ExtractKernels.Distribution Methods showsPrec :: Int -> LoopNesting -> ShowS # show :: LoopNesting -> String # showList :: [LoopNesting] -> ShowS #
FreeIn LoopNesting Source #
Instance details Defined in Futhark.Pass.ExtractKernels.Distribution Methods freeIn' :: LoopNesting -> FV Source #
Scoped Kernels LoopNesting Source #
Instance details Defined in Futhark.Pass.ExtractKernels.Distribution Methods scopeOf :: LoopNesting -> Scope Kernels Source #

ppLoopNesting :: LoopNesting -> String Source #

data Nesting Source #

Constructors

Nesting
Fields nestingLetBound :: Names nestingLoop :: LoopNesting

Instances

Show Nesting Source #
Instance details Defined in Futhark.Pass.ExtractKernels.Distribution Methods showsPrec :: Int -> Nesting -> ShowS # show :: Nesting -> String # showList :: [Nesting] -> ShowS #

type Nestings = (Nesting, [Nesting]) Source #

ppNestings :: Nestings -> String Source #

letBindInInnerNesting :: Names -> Nestings -> Nestings Source #

singleNesting :: Nesting -> Nestings Source #

pushInnerNesting :: Nesting -> Nestings -> Nestings Source #

type KernelNest = (LoopNesting, [LoopNesting]) Source #

Note: first element is *outermost* nesting. This is different from the similar types elsewhere!

ppKernelNest :: KernelNest -> String Source #

newKernel :: LoopNesting -> KernelNest Source #

pushKernelNesting :: Target -> LoopNesting -> KernelNest -> KernelNest Source #

Add new outermost nesting, pushing the current outermost to the list, also taking care to swap patterns if necessary.

pushInnerKernelNesting :: Target -> LoopNesting -> KernelNest -> KernelNest Source #

Add new innermost nesting, pushing the current outermost to the list. It is important that the Target has the right order (non-permuted compared to what is expected by the outer nests).

removeArraysFromNest :: [VName] -> KernelNest -> KernelNest Source #

Remove these arrays from the outermost nesting, and all uses of corresponding parameters from innermost nesting.

kernelNestLoops :: KernelNest -> [LoopNesting] Source #

kernelNestWidths :: KernelNest -> [SubExp] Source #

boundInKernelNest :: KernelNest -> Names Source #

boundInKernelNests :: KernelNest -> [Names] Source #

flatKernel :: MonadFreshNames m => KernelNest -> m ([(VName, SubExp)], [KernelInput]) Source #

Flatten a kernel nesting to:

The index space.
The kernel inputs - note that some of these may be unused.

constructKernel :: (MonadFreshNames m, LocalScope Kernels m) => MkSegLevel m -> KernelNest -> Body Kernels -> m (Stm Kernels, Stms Kernels) Source #

tryDistribute :: (MonadFreshNames m, LocalScope Kernels m, MonadLogger m) => MkSegLevel m -> Nestings -> Targets -> Stms Kernels -> m (Maybe (Targets, Stms Kernels)) Source #

tryDistributeStm :: (MonadFreshNames m, HasScope t m, Attributes lore) => Nestings -> Targets -> Stm lore -> m (Maybe (Result, Targets, KernelNest)) Source #