Futhark.CodeGen.ImpGen.Kernels.Base

Documentation

data KernelConstants

Constructors

KernelConstants

Fields

• kernelGlobalThreadId :: Exp
• kernelLocalThreadId :: Exp
• kernelGroupId :: Exp
• kernelGlobalThreadIdVar :: VName
• kernelLocalThreadIdVar :: VName
• kernelGroupIdVar :: VName
• kernelNumGroups :: Exp
• kernelGroupSize :: Exp
• kernelNumThreads :: Exp
• kernelWaveSize :: Exp
• kernelThreadActive :: Exp
• kernelLocalIdMap :: Map [SubExp] [Exp]

  A mapping from dimensions of nested SegOps to already computed local thread IDs.

keyWithEntryPoint :: Maybe Name -> Name -> Name

type CallKernelGen = ImpM KernelsMem HostEnv HostOp

type InKernelGen = ImpM KernelsMem KernelEnv KernelOp

newtype HostEnv

Constructors

HostEnv

Fields

• hostAtomics :: AtomicBinOp

data KernelEnv

Constructors

KernelEnv

Fields

• kernelAtomics :: AtomicBinOp
• kernelConstants :: KernelConstants

computeThreadChunkSize :: SplitOrdering -> Exp -> Count Elements Exp -> Count Elements Exp -> VName -> ImpM lore r op ()

groupReduce :: Exp -> Lambda KernelsMem -> [VName] -> InKernelGen ()

groupScan :: Maybe (Exp -> Exp -> Exp) -> Exp -> Exp -> Lambda KernelsMem -> [VName] -> InKernelGen ()

isActive :: [(VName, SubExp)] -> Exp

sKernelThread :: String -> Count NumGroups Exp -> Count GroupSize Exp -> VName -> InKernelGen () -> CallKernelGen ()

sKernelGroup :: String -> Count NumGroups Exp -> Count GroupSize Exp -> VName -> InKernelGen () -> CallKernelGen ()

sReplicate :: VName -> SubExp -> CallKernelGen ()

Perform a Replicate with a kernel.

sIota :: VName -> Exp -> Exp -> Exp -> IntType -> CallKernelGen ()

Perform an Iota with a kernel.

sCopy :: CopyCompiler KernelsMem HostEnv HostOp

compileThreadResult :: SegSpace -> PatElem KernelsMem -> KernelResult -> InKernelGen ()

compileGroupResult :: SegSpace -> PatElem KernelsMem -> KernelResult -> InKernelGen ()

virtualiseGroups :: SegVirt -> Exp -> (VName -> InKernelGen ()) -> InKernelGen ()

For many kernels, we may not have enough physical groups to cover the logical iteration space. Some groups thus have to perform double duty; we put an outer loop to accomplish this. The advantage over just launching a bazillion threads is that the cost of memory expansion should be proportional to the number of *physical* threads (hardware parallelism), not the amount of application parallelism.

groupLoop :: Exp -> (Exp -> InKernelGen ()) -> InKernelGen ()

Assign iterations of a for-loop to threads in the workgroup. The passed-in function is invoked with the (symbolic) iteration. For multidimensional loops, use groupCoverSpace.

kernelLoop :: Exp -> Exp -> Exp -> (Exp -> InKernelGen ()) -> InKernelGen ()

Assign iterations of a for-loop to all threads in the kernel. The passed-in function is invoked with the (symbolic) iteration. threadOperations will be in effect in the body. For multidimensional loops, use groupCoverSpace.

groupCoverSpace :: [Exp] -> ([Exp] -> InKernelGen ()) -> InKernelGen ()

Iterate collectively though a multidimensional space, such that all threads in the group participate. The passed-in function is invoked with a (symbolic) point in the index space.

precomputeSegOpIDs :: Stms KernelsMem -> InKernelGen a -> InKernelGen a

atomicUpdateLocking :: AtomicBinOp -> Lambda KernelsMem -> AtomicUpdate KernelsMem KernelEnv

Do an atomic update corresponding to a binary operator lambda.

type AtomicBinOp = BinOp -> Maybe (VName -> VName -> Count Elements Exp -> Exp -> AtomicOp)

Is there an atomic BinOp corresponding to this BinOp?

data Locking

Locking strategy used for an atomic update.

Constructors

Locking

Fields

• lockingArray :: VName

  Array containing the lock.

• lockingIsUnlocked :: Exp

  Value for us to consider the lock free.

• lockingToLock :: Exp

  What to write when we lock it.

• lockingToUnlock :: Exp

  What to write when we unlock it.

• lockingMapping :: [Exp] -> [Exp]

  A transformation from the logical lock index to the physical position in the array. This can also be used to make the lock array smaller.

data AtomicUpdate lore r

The mechanism that will be used for performing the atomic update. Approximates how efficient it will be. Ordered from most to least efficient.

Constructors

AtomicPrim (DoAtomicUpdate lore r)

Supported directly by primitive.

AtomicCAS (DoAtomicUpdate lore r)

Can be done by efficient swaps.

AtomicLocking (Locking -> DoAtomicUpdate lore r)

Requires explicit locking.

type DoAtomicUpdate lore r = Space -> [VName] -> [Exp] -> ImpM lore r KernelOp ()

A function for generating code for an atomic update. Assumes that the bucket is in-bounds.