Futhark.CodeGen.ImpGen.GPU.Base

Documentation

data KernelConstants

Constructors

KernelConstants

Fields

• kernelGlobalThreadId :: TExp Int32
• kernelLocalThreadId :: TExp Int32
• kernelGroupId :: TExp Int32
• kernelGlobalThreadIdVar :: VName
• kernelLocalThreadIdVar :: VName
• kernelGroupIdVar :: VName
• kernelNumGroupsCount :: Count NumGroups SubExp
• kernelGroupSizeCount :: Count GroupSize SubExp
• kernelNumGroups :: TExp Int64
• kernelGroupSize :: TExp Int64
• kernelNumThreads :: TExp Int32
• kernelWaveSize :: TExp Int32
• kernelLocalIdMap :: Map [SubExp] [TExp Int32]

  A mapping from dimensions of nested SegOps to already computed local thread IDs. Only valid in non-virtualised case.

• kernelChunkItersMap :: Map [SubExp] (TExp Int32)

  Mapping from dimensions of nested SegOps to how many iterations the virtualisation loop needs.

threadOperations :: Operations GPUMem KernelEnv KernelOp

keyWithEntryPoint :: Maybe Name -> Name -> Name

type CallKernelGen = ImpM GPUMem HostEnv HostOp

type InKernelGen = ImpM GPUMem KernelEnv KernelOp

data Locks

Information about the locks available for accumulators.

Constructors

Locks

Fields

• locksArray :: VName
• locksCount :: Int

data HostEnv

Constructors

HostEnv

Fields

• hostAtomics :: AtomicBinOp
• hostTarget :: Target
• hostLocks :: Map VName Locks

data Target

Which target are we ultimately generating code for? While most of the kernels code is the same, there are some cases where we generate special code based on the ultimate low-level API we are targeting.

Constructors

CUDA

OpenCL

HIP

data KernelEnv

Constructors

KernelEnv

Fields

• kernelAtomics :: AtomicBinOp
• kernelConstants :: KernelConstants
• kernelLocks :: Map VName Locks

groupReduce :: TExp Int32 -> Lambda GPUMem -> [VName] -> InKernelGen ()

groupScan :: Maybe (TExp Int32 -> TExp Int32 -> TExp Bool) -> TExp Int64 -> TExp Int64 -> Lambda GPUMem -> [VName] -> InKernelGen ()

groupLoop :: IntExp t => TExp t -> (TExp t -> 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.

isActive :: [(VName, SubExp)] -> TExp Bool

sKernel :: Operations GPUMem KernelEnv KernelOp -> (KernelConstants -> TExp Int32) -> String -> VName -> KernelAttrs -> InKernelGen () -> CallKernelGen ()

sKernelThread :: String -> VName -> KernelAttrs -> InKernelGen () -> CallKernelGen ()

data KernelAttrs

Various extra configuration of the kernel being generated.

Constructors

KernelAttrs

Fields

• kAttrFailureTolerant :: Bool

  Can this kernel execute correctly even if previous kernels failed?

• kAttrCheckLocalMemory :: Bool

  Does whatever launch this kernel check for local memory capacity itself?

• kAttrNumGroups :: Count NumGroups SubExp

  Number of groups.

• kAttrGroupSize :: Count GroupSize SubExp

  Group size.

defKernelAttrs :: Count NumGroups SubExp -> Count GroupSize SubExp -> KernelAttrs

The default kernel attributes.

lvlKernelAttrs :: SegLevel -> CallKernelGen KernelAttrs

Compute kernel attributes from SegLevel; including synthesising group-size and thread count if no grid is provided.

allocLocal :: AllocCompiler GPUMem r KernelOp

kernelAlloc :: Pat LetDecMem -> SubExp -> Space -> InKernelGen ()

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

virtualiseGroups :: SegVirt -> TExp Int32 -> (TExp Int32 -> 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.

kernelLoop :: IntExp t => TExp t -> TExp t -> TExp t -> (TExp t -> InKernelGen ()) -> InKernelGen ()

Assign iterations of a for-loop to all threads in the kernel. The passed-in function is invoked with the (symbolic) iteration. The body must contain thread-level code. For multidimensional loops, use groupCoverSpace.

groupCoverSpace :: IntExp t => [TExp t] -> ([TExp t] -> 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.

fenceForArrays :: [VName] -> InKernelGen Fence

If we are touching these arrays, which kind of fence do we need?

updateAcc :: VName -> [SubExp] -> [SubExp] -> InKernelGen ()

genZeroes :: String -> Int -> CallKernelGen VName

Generate a constant device array of 32-bit integer zeroes with the given number of elements. Initialised with a replicate.

Host-level bulk operations

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

Perform a Replicate with a kernel.

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

Perform an Iota with a kernel.

Atomics

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

Is there an atomic BinOp corresponding to this BinOp?

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

Do an atomic update corresponding to a binary operator lambda.

data Locking

Locking strategy used for an atomic update.

Constructors

Locking

Fields

• lockingArray :: VName

  Array containing the lock.

• lockingIsUnlocked :: TExp Int32

  Value for us to consider the lock free.

• lockingToLock :: TExp Int32

  What to write when we lock it.

• lockingToUnlock :: TExp Int32

  What to write when we unlock it.

• lockingMapping :: [TExp Int64] -> [TExp Int64]

  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 rep 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 rep r)

Supported directly by primitive.

AtomicCAS (DoAtomicUpdate rep r)

Can be done by efficient swaps.

AtomicLocking (Locking -> DoAtomicUpdate rep r)

Requires explicit locking.

type DoAtomicUpdate rep r = Space -> [VName] -> [TExp Int64] -> ImpM rep r KernelOp ()

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