Futhark.CodeGen.ImpGen.Kernels.Base

Documentation

data KernelConstants

Constructors

KernelConstants

Fields

• kernelOuterVTable :: VTable ExplicitMemory
• kernelGlobalThreadId :: Exp
• kernelLocalThreadId :: Exp
• kernelGroupId :: Exp
• kernelGlobalThreadIdVar :: VName
• kernelLocalThreadIdVar :: VName
• kernelGroupIdVar :: VName
• kernelGroupSize :: Exp
• kernelNumGroups :: Exp
• kernelNumThreads :: Exp
• kernelWaveSize :: Exp
• kernelDimensions :: [(VName, Exp)]
• kernelThreadActive :: Exp
• kernelStreamed :: [(VName, DimSize)]

  Chunk sizes and their maximum size. Hint for unrolling.

inKernelOperations :: KernelConstants -> Operations InKernel KernelOp

keyWithEntryPoint :: Name -> Name -> Name

type CallKernelGen = ImpM ExplicitMemory HostOp

type InKernelGen = ImpM InKernel KernelOp

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

simpleKernelConstants :: Exp -> String -> CallKernelGen (KernelConstants, ImpM InKernel KernelOp ())

kernelInitialisation :: KernelSpace -> CallKernelGen (KernelConstants, ImpM InKernel KernelOp ())

kernelInitialisationSimple :: Exp -> Exp -> Maybe (VName, VName, VName) -> CallKernelGen (KernelConstants, ImpM InKernel KernelOp ())

kernelInitialisationSetSpace :: KernelSpace -> InKernelGen () -> CallKernelGen (KernelConstants, ImpM InKernel KernelOp ())

setSpaceIndices :: Exp -> KernelSpace -> InKernelGen ()

makeAllMemoryGlobal :: CallKernelGen a -> CallKernelGen a

Change every memory block to be in the global address space, except those who are in the local memory space. This only affects generated code - we still need to make sure that the memory is actually present on the device (and dared as variables in the kernel).

allThreads :: KernelConstants -> InKernelGen () -> InKernelGen ()

compileKernelStms :: KernelConstants -> Stms InKernel -> InKernelGen a -> InKernelGen a

groupReduce :: ExplicitMemorish lore => KernelConstants -> Exp -> Lambda lore -> [VName] -> ImpM lore KernelOp ()

groupScan :: KernelConstants -> Maybe (Exp -> Exp -> Exp) -> Exp -> Lambda InKernel -> [VName] -> ImpM InKernel KernelOp ()

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

sKernel :: KernelConstants -> String -> ImpM InKernel KernelOp a -> CallKernelGen ()

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

Perform a Replicate with a kernel.

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

Perform an Iota with a kernel.

sCopy :: PrimType -> MemLocation -> MemLocation -> Count Elements -> CallKernelGen ()

compileKernelResult :: KernelConstants -> PatElem InKernel -> KernelResult -> InKernelGen ()

virtualiseGroups :: KernelConstants -> 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.

atomicUpdate :: ExplicitMemorish lore => Space -> [VName] -> [Exp] -> Lambda lore -> Locking -> ImpM lore KernelOp ()

atomicUpdateLocking :: ExplicitMemorish lore => Lambda lore -> Either (AtomicUpdate lore) (Locking -> AtomicUpdate lore)

atomicUpdate, but where it is explicitly visible whether a locking strategy is necessary.

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.

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

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