Futhark.CodeGen.Backends.GenericC.Monad

C code generator framework.

Pluggable compiler

data Operations op s

Constructors

Operations

Fields

• opsWriteScalar :: WriteScalar op s
• opsReadScalar :: ReadScalar op s
• opsAllocate :: Allocate op s
• opsDeallocate :: Deallocate op s
• opsCopy :: Copy op s
• opsMemoryType :: MemoryType op s
• opsCompiler :: OpCompiler op s
• opsError :: ErrorCompiler op s
• opsCall :: CallCompiler op s
• opsCopies :: Map (Space, Space) (DoCopy op s)

  (dst,src)-space mapping to copy functions.

• opsFatMemory :: Bool

  If true, use reference counting. Otherwise, bare pointers.

• opsCritical :: ([BlockItem], [BlockItem])

  Code to bracket critical sections.

data Publicness

Constructors

Private

Public

Instances

Show Publicness

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

showsPrec :: Int -> Publicness -> ShowS

show :: Publicness -> String

showList :: [Publicness] -> ShowS

Eq Publicness

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

(==) :: Publicness -> Publicness -> Bool

(/=) :: Publicness -> Publicness -> Bool

Ord Publicness

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

compare :: Publicness -> Publicness -> Ordering

(<) :: Publicness -> Publicness -> Bool

(<=) :: Publicness -> Publicness -> Bool

(>) :: Publicness -> Publicness -> Bool

(>=) :: Publicness -> Publicness -> Bool

max :: Publicness -> Publicness -> Publicness

min :: Publicness -> Publicness -> Publicness

type OpCompiler op s = op -> CompilerM op s ()

A substitute expression compiler, tried before the main compilation function.

type ErrorCompiler op s = ErrorMsg Exp -> String -> CompilerM op s ()

type CallCompiler op s = [VName] -> Name -> [Exp] -> CompilerM op s ()

Call a function.

type PointerQuals = String -> [TypeQual]

The address space qualifiers for a pointer of the given type with the given annotation.

type MemoryType op s = SpaceId -> CompilerM op s Type

The type of a memory block in the given memory space.

type WriteScalar op s = Exp -> Exp -> Type -> SpaceId -> Volatility -> Exp -> CompilerM op s ()

Write a scalar to the given memory block with the given element index and in the given memory space.

writeScalarPointerWithQuals :: PointerQuals -> WriteScalar op s

type ReadScalar op s = Exp -> Exp -> Type -> SpaceId -> Volatility -> CompilerM op s Exp

Read a scalar from the given memory block with the given element index and in the given memory space.

readScalarPointerWithQuals :: PointerQuals -> ReadScalar op s

type Allocate op s = Exp -> Exp -> Exp -> SpaceId -> CompilerM op s ()

Allocate a memory block of the given size and with the given tag in the given memory space, saving a reference in the given variable name.

type Deallocate op s = Exp -> Exp -> Exp -> SpaceId -> CompilerM op s ()

De-allocate the given memory block, with the given tag, with the given size,, which is in the given memory space.

data CopyBarrier

Whether a copying operation should implicitly function as a barrier regarding further operations on the source. This is a rather subtle detail and is mostly useful for letting some device/GPU copies be asynchronous (#1664).

Constructors

CopyBarrier

CopyNoBarrier

Explicit context synchronisation should be done before the source or target is used.

Instances

Show CopyBarrier

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

showsPrec :: Int -> CopyBarrier -> ShowS

show :: CopyBarrier -> String

showList :: [CopyBarrier] -> ShowS

Eq CopyBarrier

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

(==) :: CopyBarrier -> CopyBarrier -> Bool

(/=) :: CopyBarrier -> CopyBarrier -> Bool

type Copy op s = CopyBarrier -> Exp -> Exp -> Space -> Exp -> Exp -> Space -> Exp -> CompilerM op s ()

Copy from one memory block to another.

type DoCopy op s = CopyBarrier -> PrimType -> [Count Elements Exp] -> Exp -> (Count Elements Exp, [Count Elements Exp]) -> Exp -> (Count Elements Exp, [Count Elements Exp]) -> CompilerM op s ()

Perform an Copy. It is expected that these functions are each specialised on which spaces they operate on, so that is not part of their arguments.

Monadic compiler interface

data CompilerM op s a

Instances

MonadState (CompilerState s) (CompilerM op s)

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

get :: CompilerM op s (CompilerState s)

put :: CompilerState s -> CompilerM op s ()

state :: (CompilerState s -> (a, CompilerState s)) -> CompilerM op s a

Applicative (CompilerM op s)

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

pure :: a -> CompilerM op s a

(<*>) :: CompilerM op s (a -> b) -> CompilerM op s a -> CompilerM op s b

liftA2 :: (a -> b -> c) -> CompilerM op s a -> CompilerM op s b -> CompilerM op s c

(*>) :: CompilerM op s a -> CompilerM op s b -> CompilerM op s b

(<*) :: CompilerM op s a -> CompilerM op s b -> CompilerM op s a

Functor (CompilerM op s)

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

fmap :: (a -> b) -> CompilerM op s a -> CompilerM op s b

(<$) :: a -> CompilerM op s b -> CompilerM op s a

Monad (CompilerM op s)

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

(>>=) :: CompilerM op s a -> (a -> CompilerM op s b) -> CompilerM op s b

(>>) :: CompilerM op s a -> CompilerM op s b -> CompilerM op s b

return :: a -> CompilerM op s a

MonadFreshNames (CompilerM op s)

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

getNameSource :: CompilerM op s VNameSource

putNameSource :: VNameSource -> CompilerM op s ()

MonadReader (CompilerEnv op s) (CompilerM op s)

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

ask :: CompilerM op s (CompilerEnv op s)

local :: (CompilerEnv op s -> CompilerEnv op s) -> CompilerM op s a -> CompilerM op s a

reader :: (CompilerEnv op s -> a) -> CompilerM op s a

data CompilerState s

Constructors

CompilerState

Fields

• compArrayTypes :: Map ArrayType Publicness
• compEarlyDecls :: DList Definition
• compNameSrc :: VNameSource
• compUserState :: s
• compHeaderDecls :: Map HeaderSection (DList Definition)
• compLibDecls :: DList Definition
• compCtxFields :: DList (Id, Type, Maybe Exp, Maybe (Stm, Stm))
• compClearItems :: DList BlockItem
• compDeclaredMem :: [(VName, Space)]
• compItems :: DList BlockItem

Instances

MonadState (CompilerState s) (CompilerM op s)

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

get :: CompilerM op s (CompilerState s)

put :: CompilerState s -> CompilerM op s ()

state :: (CompilerState s -> (a, CompilerState s)) -> CompilerM op s a

data CompilerEnv op s

Constructors

CompilerEnv

Fields

• envOperations :: Operations op s
• envCachedMem :: Map Exp VName

  Mapping memory blocks to sizes. These memory blocks are CPU memory that we know are used in particularly simple ways (no reference counting necessary). To cut down on allocator pressure, we keep these allocations around for a long time, and record their sizes so we can reuse them if possible (and realloc() when needed).

Instances

MonadReader (CompilerEnv op s) (CompilerM op s)

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

ask :: CompilerM op s (CompilerEnv op s)

local :: (CompilerEnv op s -> CompilerEnv op s) -> CompilerM op s a -> CompilerM op s a

reader :: (CompilerEnv op s -> a) -> CompilerM op s a

getUserState :: CompilerM op s s

modifyUserState :: (s -> s) -> CompilerM op s ()

generateProgramStruct :: CompilerM op s ()

runCompilerM :: Operations op s -> VNameSource -> s -> CompilerM op s a -> (a, CompilerState s)

inNewFunction :: CompilerM op s a -> CompilerM op s a

Used when we, inside an existing CompilerM action, want to generate code for a new function. Use this so that the compiler understands that previously declared memory doesn't need to be freed inside this action.

cachingMemory :: Map VName Space -> ([BlockItem] -> [Stm] -> CompilerM op s a) -> CompilerM op s a

volQuals :: Volatility -> [TypeQual]

rawMem :: VName -> CompilerM op s Exp

item :: BlockItem -> CompilerM op s ()

items :: [BlockItem] -> CompilerM op s ()

stm :: Stm -> CompilerM op s ()

stms :: [Stm] -> CompilerM op s ()

decl :: InitGroup -> CompilerM op s ()

headerDecl :: HeaderSection -> Definition -> CompilerM op s ()

publicDef :: Text -> HeaderSection -> (Text -> (Definition, Definition)) -> CompilerM op s Text

Construct a publicly visible definition using the specified name as the template. The first returned definition is put in the header file, and the second is the implementation. Returns the public name.

publicDef_ :: Text -> HeaderSection -> (Text -> (Definition, Definition)) -> CompilerM op s ()

As publicDef, but ignores the public name.

onClear :: BlockItem -> CompilerM op s ()

data HeaderSection

In which part of the header file we put the declaration. This is to ensure that the header file remains structured and readable.

Constructors

ArrayDecl Name

OpaqueTypeDecl Name

OpaqueDecl Name

EntryDecl

MiscDecl

InitDecl

Instances

Eq HeaderSection

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

(==) :: HeaderSection -> HeaderSection -> Bool

(/=) :: HeaderSection -> HeaderSection -> Bool

Ord HeaderSection

Defined in Futhark.CodeGen.Backends.GenericC.Monad

Methods

compare :: HeaderSection -> HeaderSection -> Ordering

(<) :: HeaderSection -> HeaderSection -> Bool

(<=) :: HeaderSection -> HeaderSection -> Bool

(>) :: HeaderSection -> HeaderSection -> Bool

(>=) :: HeaderSection -> HeaderSection -> Bool

max :: HeaderSection -> HeaderSection -> HeaderSection

min :: HeaderSection -> HeaderSection -> HeaderSection

libDecl :: Definition -> CompilerM op s ()

earlyDecl :: Definition -> CompilerM op s ()

publicName :: Text -> CompilerM op s Text

Public names must have a consitent prefix.

contextField :: Id -> Type -> Maybe Exp -> CompilerM op s ()

contextFieldDyn :: Id -> Type -> Stm -> Stm -> CompilerM op s ()

memToCType :: VName -> Space -> CompilerM op s Type

cacheMem :: ToExp a => a -> CompilerM op s (Maybe VName)

fatMemory :: Space -> CompilerM op s Bool

rawMemCType :: Space -> CompilerM op s Type

freeRawMem :: (ToExp a, ToExp b, ToExp c) => a -> b -> Space -> c -> CompilerM op s ()

allocRawMem :: (ToExp a, ToExp b, ToExp c) => a -> b -> Space -> c -> CompilerM op s ()

fatMemType :: Space -> Type

declAllocatedMem :: CompilerM op s [BlockItem]

freeAllocatedMem :: CompilerM op s [BlockItem]

collect :: CompilerM op s () -> CompilerM op s [BlockItem]

collect' :: CompilerM op s a -> CompilerM op s (a, [BlockItem])

contextType :: CompilerM op s Type

The generated code must define a context struct with this name.

configType :: CompilerM op s Type

The generated code must define a configuration struct with this name.

Building Blocks

copyMemoryDefaultSpace :: Exp -> Exp -> Exp -> Exp -> Exp -> CompilerM op s ()

derefPointer :: Exp -> Exp -> Type -> Exp

setMem :: (ToExp a, ToExp b) => a -> b -> Space -> CompilerM op s ()

allocMem :: (ToExp a, ToExp b) => a -> b -> Space -> Stm -> CompilerM op s ()

unRefMem :: ToExp a => a -> Space -> CompilerM op s ()

declMem :: VName -> Space -> CompilerM op s ()

resetMem :: ToExp a => a -> Space -> CompilerM op s ()

fatMemAlloc :: Space -> String

fatMemSet :: Space -> String

fatMemUnRef :: Space -> String

criticalSection :: Operations op s -> [BlockItem] -> [BlockItem]

module Futhark.CodeGen.Backends.SimpleRep