Language.Halide

This package provides Haskell bindings that allow to write Halide embedded in Haskell without C++.

This module contains the reference documentation for Halide. If you're new, the best way to learn Halide is to have a look at the tutorials.

Scalar expressions

The basic building block of Halide pipelines is Expr. Expr a represents a scalar expression of type a, where a must be an instance of IsHalideType.

data Expr a

A scalar expression in Halide.

To have a nice experience writing arithmetic expressions in terms of Exprs, we want to derive Num, Floating etc. instances for Expr. Unfortunately, that means that we encode Expr, Var, RVar, and ScalarParam by the same type, and passing an Expr to a function that expects a Var will produce a runtime error.

Constructors

Expr (ForeignPtr CxxExpr)

Scalar expression.

Var (ForeignPtr CxxVar)

Index variable.

RVar (ForeignPtr CxxRVar)

Reduction variable.

ScalarParam (IORef (Maybe (ForeignPtr CxxParameter)))

Scalar parameter.

The IORef is initialized with Nothing and filled in on the first call to asExpr.

Instances

HasField "extent" Dimension (Expr Int32)

Defined in Language.Halide.Dimension

Methods

getField :: Dimension -> Expr Int32

HasField "max" Dimension (Expr Int32)

Defined in Language.Halide.Dimension

Methods

getField :: Dimension -> Expr Int32

HasField "min" Dimension (Expr Int32)

Defined in Language.Halide.Dimension

Methods

getField :: Dimension -> Expr Int32

HasField "stride" Dimension (Expr Int32)

Defined in Language.Halide.Dimension

Methods

getField :: Dimension -> Expr Int32

HasField "var" (LoopLevel 'LockedTy) (Expr Int32)

Defined in Language.Halide.LoopLevel

Methods

getField :: LoopLevel 'LockedTy -> Expr Int32

(IsHalideType a, Floating a) => Floating (Expr a)

Defined in Language.Halide.Expr

Methods

pi :: Expr a

exp :: Expr a -> Expr a

log :: Expr a -> Expr a

sqrt :: Expr a -> Expr a

(**) :: Expr a -> Expr a -> Expr a

logBase :: Expr a -> Expr a -> Expr a

sin :: Expr a -> Expr a

cos :: Expr a -> Expr a

tan :: Expr a -> Expr a

asin :: Expr a -> Expr a

acos :: Expr a -> Expr a

atan :: Expr a -> Expr a

sinh :: Expr a -> Expr a

cosh :: Expr a -> Expr a

tanh :: Expr a -> Expr a

asinh :: Expr a -> Expr a

acosh :: Expr a -> Expr a

atanh :: Expr a -> Expr a

log1p :: Expr a -> Expr a

expm1 :: Expr a -> Expr a

log1pexp :: Expr a -> Expr a

log1mexp :: Expr a -> Expr a

(IsHalideType a, Num a) => Num (Expr a)

Defined in Language.Halide.Expr

Methods

(+) :: Expr a -> Expr a -> Expr a

(-) :: Expr a -> Expr a -> Expr a

(*) :: Expr a -> Expr a -> Expr a

negate :: Expr a -> Expr a

abs :: Expr a -> Expr a

signum :: Expr a -> Expr a

fromInteger :: Integer -> Expr a

(IsHalideType a, Fractional a) => Fractional (Expr a)

Defined in Language.Halide.Expr

Methods

(/) :: Expr a -> Expr a -> Expr a

recip :: Expr a -> Expr a

fromRational :: Rational -> Expr a

IsHalideType a => Show (Expr a)

Defined in Language.Halide.Expr

Methods

showsPrec :: Int -> Expr a -> ShowS

show :: Expr a -> String

showList :: [Expr a] -> ShowS

IsTuple '[Expr a1] (Expr a1)

Defined in Language.Halide.Expr

Methods

toTuple :: Arguments '[Expr a1] -> Expr a1

fromTuple :: Expr a1 -> Arguments '[Expr a1]

type Var = Expr Int32

A Var.

type RVar = Expr Int32

An RVar.

type VarOrRVar = Expr Int32

Either Var or RVar.

class Storable a => IsHalideType a

Specifies that a type is supported by Halide.

Minimal complete definition

halideTypeFor, toCxxExpr

Instances

IsHalideType CDouble

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy CDouble -> HalideType

toCxxExpr :: CDouble -> IO (ForeignPtr CxxExpr)

IsHalideType CFloat

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy CFloat -> HalideType

toCxxExpr :: CFloat -> IO (ForeignPtr CxxExpr)

IsHalideType Int16

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy Int16 -> HalideType

toCxxExpr :: Int16 -> IO (ForeignPtr CxxExpr)

IsHalideType Int32

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy Int32 -> HalideType

toCxxExpr :: Int32 -> IO (ForeignPtr CxxExpr)

IsHalideType Int64

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy Int64 -> HalideType

toCxxExpr :: Int64 -> IO (ForeignPtr CxxExpr)

IsHalideType Int8

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy Int8 -> HalideType

toCxxExpr :: Int8 -> IO (ForeignPtr CxxExpr)

IsHalideType Word16

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy Word16 -> HalideType

toCxxExpr :: Word16 -> IO (ForeignPtr CxxExpr)

IsHalideType Word32

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy Word32 -> HalideType

toCxxExpr :: Word32 -> IO (ForeignPtr CxxExpr)

IsHalideType Word64

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy Word64 -> HalideType

toCxxExpr :: Word64 -> IO (ForeignPtr CxxExpr)

IsHalideType Word8

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy Word8 -> HalideType

toCxxExpr :: Word8 -> IO (ForeignPtr CxxExpr)

IsHalideType Bool

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy Bool -> HalideType

toCxxExpr :: Bool -> IO (ForeignPtr CxxExpr)

IsHalideType Double

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy Double -> HalideType

toCxxExpr :: Double -> IO (ForeignPtr CxxExpr)

IsHalideType Float

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy Float -> HalideType

toCxxExpr :: Float -> IO (ForeignPtr CxxExpr)

data ReductionDomain (n :: Nat)

An n-dimensional reduction domain.

Creating

mkExpr :: IsHalideType a => a -> Expr a

Create a scalar expression from a Haskell value.

mkVar :: Text -> IO (Expr Int32)

Create a named index variable.

mkRVar

Arguments

:: Text

name

-> Expr Int32

min index

-> Expr Int32

extent

-> IO (Expr Int32)

Create a named reduction variable.

For more information about reduction variables, see Halide::RDom.

mkRDom

Arguments

:: forall n. HasIndexType n

=> Text

name

-> IndexType n

mins

-> IndexType n

extents

-> IO (ReductionDomain n)

reduction variables

Create a reduction domain. Use asRVar to cast it into an index.

For more information about reduction variables, see Halide::RDom.

toRVars :: forall n. HasIndexType n => ReductionDomain n -> IO (IndexType n)

Cast a reduction domain into a multi-dimensional index that can be used to perform multi-dimensional reductions.

undef :: forall a. IsHalideType a => Expr a

Return an undef value of the given type.

For more information, see Halide::undef.

cast :: forall to from. (IsHalideType to, IsHalideType from) => Expr from -> Expr to

Cast a scalar expression to a different type.

Use TypeApplications with this function, e.g. cast @Float x.

ifThenElse :: IsHalideType a => Expr Bool -> Expr a -> Expr a -> Expr a

'ifThenElse cond a b' is the analogue of if cond then a else b, but lifted to work with Expr types.

See also the RebindableSyntax extension.

Inspecting

toIntImm :: IsHalideType a => Expr a -> Maybe Int

Convert expression to integer immediate.

Tries to extract the value of an expression if it is a compile-time constant. If the expression isn't known at compile-time of the Halide pipeline, returns Nothing.

printed :: forall a t. (IsHalideType a, PrintedType t (Expr a)) => Expr a -> t

Print all expressions to stdout when the result is evaluates. The first expression is returned.

This is useful for debugging Halide pipelines.

This function is similar to printf in that it accepts a variable number of arguments, i.e the following is valid:

let x :: Expr Float
    x = 1
 in printed (sin x) ("<- sin(" :: Text) x (")" :: Text)

:: Text specifications are only needed if you have the OverloadedStrings extension enabled.

Arguments to printed can be Expr a, String, or Text.

printedWhen :: forall a t. (IsHalideType a, PrintedType t (Expr a)) => Expr Bool -> Expr a -> t

evaluate :: forall a. IsHalideType a => Expr a -> IO a

Evaluate a scalar expression.

It should contain no parameters. If it does contain parameters, an exception will be thrown.

Comparisons

We can't use Eq and Ord instances here, because we want the comparison to happen when the pipeline is run rather than when it's built. Hence, we define lifted version of various comparison operators. Note, that infix versions of the these functions have the same precedence as the normal comparison operators.

eq :: IsHalideType a => Expr a -> Expr a -> Expr Bool infix 4

== but lifted to return an Expr.

neq :: IsHalideType a => Expr a -> Expr a -> Expr Bool infix 4

/= but lifted to return an Expr.

lt :: IsHalideType a => Expr a -> Expr a -> Expr Bool infix 4

< but lifted to return an Expr.

lte :: IsHalideType a => Expr a -> Expr a -> Expr Bool infix 4

<= but lifted to return an Expr.

gt :: IsHalideType a => Expr a -> Expr a -> Expr Bool infix 4

> but lifted to return an Expr.

gte :: IsHalideType a => Expr a -> Expr a -> Expr Bool infix 4

>= but lifted to return an Expr.

min :: IsHalideType a => Expr a -> Expr a -> Expr a

min but lifted to return an Expr.

max :: IsHalideType a => Expr a -> Expr a -> Expr a

max but lifted to return an Expr.

div :: forall a. (IsHalideType a, Integral a) => Expr a -> Expr a -> Expr a

Divide two integers, rounding towards zero.

mod :: forall a. (IsHalideType a, Integral a) => Expr a -> Expr a -> Expr a

Compute the remainder of dividing two integers, when division is rounding toward zero.

Boolean functions

and :: Expr Bool -> Expr Bool -> Expr Bool

&& but lifted to return an Expr.

or :: Expr Bool -> Expr Bool -> Expr Bool

|| but lifted to return an Expr.

Functions

data Func (t :: FuncTy) (n :: Nat) (a :: Type) where

A function in Halide. Conceptually, it can be thought of as a lazy n-dimensional buffer of type a.

Here, a is most often Expr t for a type t that is an instance of IsHalideType. However, one can also define Funcs that return multiple values. In this case, a will be a tuple of Exprs.

This is a wrapper around the Halide::Func C++ type.

Constructors

Func :: !(ForeignPtr CxxFunc) -> Func 'FuncTy n a

Param :: IsHalideType a => !(IORef (Maybe (ForeignPtr CxxImageParam))) -> Func 'ParamTy n (Expr a)

Instances

KnownNat n => Schedulable (Func t) n a

Defined in Language.Halide.Func

Methods

vectorize :: VarOrRVar -> Func t n a -> IO (Func t n a)

unroll :: VarOrRVar -> Func t n a -> IO (Func t n a)

reorder :: [VarOrRVar] -> Func t n a -> IO (Func t n a)

split :: TailStrategy -> VarOrRVar -> (VarOrRVar, VarOrRVar) -> Expr Int32 -> Func t n a -> IO (Func t n a)

fuse :: (VarOrRVar, VarOrRVar) -> VarOrRVar -> Func t n a -> IO (Func t n a)

serial :: VarOrRVar -> Func t n a -> IO (Func t n a)

parallel :: VarOrRVar -> Func t n a -> IO (Func t n a)

atomic :: Bool -> Func t n a -> IO (Func t n a)

specialize :: Expr Bool -> Func t n a -> IO (Stage n a)

specializeFail :: Text -> Func t n a -> IO ()

gpuBlocks :: forall (k :: Nat). (KnownNat k, 1 <= k, k <= 3) => DeviceAPI -> IndexType k -> Func t n a -> IO (Func t n a)

gpuThreads :: forall (k :: Nat). (KnownNat k, 1 <= k, k <= 3) => DeviceAPI -> IndexType k -> Func t n a -> IO (Func t n a)

gpuLanes :: DeviceAPI -> VarOrRVar -> Func t n a -> IO (Func t n a)

computeWith :: forall (t0 :: LoopLevelTy). LoopAlignStrategy -> Func t n a -> LoopLevel t0 -> IO ()

type Function n a = Func 'FuncTy n (Expr a)

Synonym for the most commonly used function type.

type Parameter n a = Func 'ParamTy n (Expr a)

Synonym for the most commonly used parameter type.

data FuncTy

Function type. It can either be FuncTy which means that we have defined the function ourselves, or ParamTy which means that it's a parameter to our pipeline.

Constructors

FuncTy

ParamTy

Instances

Show FuncTy

Defined in Language.Halide.Func

Methods

showsPrec :: Int -> FuncTy -> ShowS

show :: FuncTy -> String

showList :: [FuncTy] -> ShowS

Eq FuncTy

Defined in Language.Halide.Func

Methods

(==) :: FuncTy -> FuncTy -> Bool

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

Ord FuncTy

Defined in Language.Halide.Func

Methods

compare :: FuncTy -> FuncTy -> Ordering

(<) :: FuncTy -> FuncTy -> Bool

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

(>) :: FuncTy -> FuncTy -> Bool

(>=) :: FuncTy -> FuncTy -> Bool

max :: FuncTy -> FuncTy -> FuncTy

min :: FuncTy -> FuncTy -> FuncTy

newtype Stage (n :: Nat) (a :: Type)

A single definition of a Func.

Constructors

Stage (ForeignPtr CxxStage)

Instances

KnownNat n => Schedulable Stage n a

Defined in Language.Halide.Func

Methods

vectorize :: VarOrRVar -> Stage n a -> IO (Stage n a)

unroll :: VarOrRVar -> Stage n a -> IO (Stage n a)

reorder :: [VarOrRVar] -> Stage n a -> IO (Stage n a)

split :: TailStrategy -> VarOrRVar -> (VarOrRVar, VarOrRVar) -> Expr Int32 -> Stage n a -> IO (Stage n a)

fuse :: (VarOrRVar, VarOrRVar) -> VarOrRVar -> Stage n a -> IO (Stage n a)

serial :: VarOrRVar -> Stage n a -> IO (Stage n a)

parallel :: VarOrRVar -> Stage n a -> IO (Stage n a)

atomic :: Bool -> Stage n a -> IO (Stage n a)

specialize :: Expr Bool -> Stage n a -> IO (Stage n a)

specializeFail :: Text -> Stage n a -> IO ()

gpuBlocks :: forall (k :: Nat). (KnownNat k, 1 <= k, k <= 3) => DeviceAPI -> IndexType k -> Stage n a -> IO (Stage n a)

gpuThreads :: forall (k :: Nat). (KnownNat k, 1 <= k, k <= 3) => DeviceAPI -> IndexType k -> Stage n a -> IO (Stage n a)

gpuLanes :: DeviceAPI -> VarOrRVar -> Stage n a -> IO (Stage n a)

computeWith :: forall (t :: LoopLevelTy). LoopAlignStrategy -> Stage n a -> LoopLevel t -> IO ()

Creating

define :: forall n d. (HasIndexType n, IsFuncDefinition d) => Text -> IndexType n -> d -> IO (Func 'FuncTy n d)

Define a Halide function.

define "f" i e defines a Halide function called "f" such that f[i] = e.

Here, i is an n-element tuple of Var, i.e. the following are all valid:

>>> [x, y, z] <- mapM mkVar ["x", "y", "z"]
>>> f1 <- define "f1" x (0 :: Expr Float)
>>> f2 <- define "f2" (x, y) (0 :: Expr Float)
>>> f3 <- define "f3" (x, y, z) (0 :: Expr Float)

update :: forall n d. (HasIndexType n, IsFuncDefinition d) => Func 'FuncTy n d -> IndexType n -> d -> IO ()

Create an update definition for a Halide function.

update f i e creates an update definition for f that performs f[i] = e.

(!) :: (HasIndexType n, IsFuncDefinition a) => Func t n a -> IndexType n -> a infix 9

Apply a Halide function. Conceptually, f ! i is equivalent to f[i], i.e. indexing into a lazy array.

repeatEdge :: (KnownNat n, IsHalideType a) => Func 'ParamTy n (Expr a) -> IO (Func 'FuncTy n (Expr a))

Impose a boundary condition such that the nearest edge sample is returned everywhere outside the given region.

For more information, see Halide::repeat_edge.

constantExterior :: (KnownNat n, IsHalideType a) => Expr a -> Func 'ParamTy n (Expr a) -> IO (Func 'FuncTy n (Expr a))

Impose a boundary condition such that a given expression is returned everywhere outside the boundary.

For more information, see Halide::constant_exterior.

Inspecting

getArgs :: KnownNat n => Func t n a -> IO [Var]

Get the index arguments of the function.

The returned list contains exactly n elements.

hasUpdateDefinitions :: KnownNat n => Func t n a -> IO Bool

Return True when the function has update definitions, False otherwise.

getUpdateStage :: KnownNat n => Int -> Func 'FuncTy n a -> IO (Stage n a)

Get a handle to an update step for the purposes of scheduling it.

Buffers

In the C interface of Halide, buffers are described by the C struct halide_buffer_t. On the Haskell side, we have HalideBuffer.

newtype HalideBuffer (n :: Nat) (a :: Type)

An n-dimensional buffer of elements of type a.

Most pipelines use Ptr (HalideBuffer n a) for input and output array arguments.

Constructors

HalideBuffer

Fields

• unHalideBuffer :: RawHalideBuffer

Instances

Show (HalideBuffer n a)

Defined in Language.Halide.Buffer

Methods

showsPrec :: Int -> HalideBuffer n a -> ShowS

show :: HalideBuffer n a -> String

showList :: [HalideBuffer n a] -> ShowS

Eq (HalideBuffer n a)

Defined in Language.Halide.Buffer

Methods

(==) :: HalideBuffer n a -> HalideBuffer n a -> Bool

(/=) :: HalideBuffer n a -> HalideBuffer n a -> Bool

To easily test out your pipeline, there are helper functions to create HalideBuffers without worrying about the low-level representation.

allocaCpuBuffer :: forall n a b. (HasCallStack, KnownNat n, IsHalideType a) => [Int] -> (Ptr (HalideBuffer n a) -> IO b) -> IO b

Temporary allocate a CPU buffer.

This is useful for testing and debugging when you need to allocate an output buffer for your pipeline. E.g.

allocaCpuBuffer [3, 3] $ out -> do
  myKernel out                -- fill the buffer
  print =<< peekToList out  -- print it for debugging

allocaBuffer :: forall n a b. (HasCallStack, KnownNat n, IsHalideType a) => Target -> [Int] -> (Ptr (HalideBuffer n a) -> IO b) -> IO b

Buffers can also be converted to lists to easily print them for debugging.

class (KnownNat n, IsHalideType a, NestedList n a ~ b, NestedListLevel b ~ n, NestedListType b ~ a) => IsListPeek n a b | n a -> b, n b -> a, a b -> n where

Methods

peekToList :: HasCallStack => Ptr (HalideBuffer n a) -> IO b

Instances

(IsHalideType a, NestedListLevel [a] ~ 1, NestedListType [a] ~ a) => IsListPeek 1 a [a]

Defined in Language.Halide.Buffer

Methods

peekToList :: Ptr (HalideBuffer 1 a) -> IO [a]

(IsHalideType a, NestedListLevel [[a]] ~ 2, NestedListType [[a]] ~ a) => IsListPeek 2 a [[a]]

Defined in Language.Halide.Buffer

Methods

peekToList :: Ptr (HalideBuffer 2 a) -> IO [[a]]

(IsHalideType a, NestedListLevel [[[a]]] ~ 3, NestedListType [[[a]]] ~ a) => IsListPeek 3 a [[[a]]]

Defined in Language.Halide.Buffer

Methods

peekToList :: Ptr (HalideBuffer 3 a) -> IO [[[a]]]

(IsHalideType a, NestedListLevel [[[[a]]]] ~ 4, NestedListType [[[[a]]]] ~ a) => IsListPeek 4 a [[[[a]]]]

Defined in Language.Halide.Buffer

Methods

peekToList :: Ptr (HalideBuffer 4 a) -> IO [[[[a]]]]

peekScalar :: forall a. (HasCallStack, IsHalideType a) => Ptr (HalideBuffer 0 a) -> IO a

For production usage however, you don't want to work with lists. Instead, you probably want Halide to work with your existing array data types. For this, we define IsHalideBuffer typeclass that teaches Halide how to convert your data into a HalideBuffer. Depending on how you implement the instance, this can be very efficient, because it need not involve any memory copying.

class (KnownNat n, IsHalideType a) => IsHalideBuffer t n a where

Specifies that a type t can be used as an n-dimensional Halide buffer with elements of type a.

Methods

withHalideBufferImpl :: t -> (Ptr (HalideBuffer n a) -> IO b) -> IO b

Instances

IsHalideType a => IsHalideBuffer (Vector a) 1 a

Storable vectors are one-dimensional buffers. This involves no copying.

Defined in Language.Halide.Buffer

Methods

withHalideBufferImpl :: Vector a -> (Ptr (HalideBuffer 1 a) -> IO b) -> IO b

IsHalideType a => IsHalideBuffer [[[[a]]]] 4 a

Lists can also act as Halide buffers. Use for testing only.

Defined in Language.Halide.Buffer

Methods

withHalideBufferImpl :: [[[[a]]]] -> (Ptr (HalideBuffer 4 a) -> IO b) -> IO b

IsHalideType a => IsHalideBuffer [[[a]]] 3 a

Lists can also act as Halide buffers. Use for testing only.

Defined in Language.Halide.Buffer

Methods

withHalideBufferImpl :: [[[a]]] -> (Ptr (HalideBuffer 3 a) -> IO b) -> IO b

IsHalideType a => IsHalideBuffer [[a]] 2 a

Lists can also act as Halide buffers. Use for testing only.

Defined in Language.Halide.Buffer

Methods

withHalideBufferImpl :: [[a]] -> (Ptr (HalideBuffer 2 a) -> IO b) -> IO b

IsHalideType a => IsHalideBuffer [a] 1 a

Lists can also act as Halide buffers. Use for testing only.

Defined in Language.Halide.Buffer

Methods

withHalideBufferImpl :: [a] -> (Ptr (HalideBuffer 1 a) -> IO b) -> IO b

IsHalideType a => IsHalideBuffer (MVector RealWorld a) 1 a

Storable vectors are one-dimensional buffers. This involves no copying.

Defined in Language.Halide.Buffer

Methods

withHalideBufferImpl :: MVector RealWorld a -> (Ptr (HalideBuffer 1 a) -> IO b) -> IO b

withHalideBuffer :: forall n a t b. IsHalideBuffer t n a => t -> (Ptr (HalideBuffer n a) -> IO b) -> IO b

Treat a type t as a HalideBuffer and use it in an IO action.

This function is a simple wrapper around withHalideBufferImpl, except that the order of type parameters is reversed. If you have TypeApplications extension enabled, this allows you to write withHalideBuffer 3 Float yourBuffer to specify that you want a 3-dimensional buffer of Float.

There are also helper functions to simplify writing instances of IsHalideBuffer.

bufferFromPtrShapeStrides

Arguments

:: forall n a b. (HasCallStack, KnownNat n, IsHalideType a)

=> Ptr a

CPU pointer to the data

-> [Int]

Extents (in number of elements, not in bytes)

-> [Int]

Strides (in number of elements, not in bytes)

-> (Ptr (HalideBuffer n a) -> IO b)

Action to run

-> IO b

Construct a HalideBuffer from a pointer to the data, a list of extents, and a list of strides, and use it in an IO action.

This function throws a runtime error if the number of dimensions does not match n.

bufferFromPtrShape

Arguments

:: (HasCallStack, KnownNat n, IsHalideType a)

=> Ptr a

CPU pointer to the data

-> [Int]

Extents (in number of elements, not in bytes)

-> (Ptr (HalideBuffer n a) -> IO b)

-> IO b

Similar to bufferFromPtrShapeStrides, but assumes column-major ordering of data.

Running the pipelines

There are a few ways how one can run a Halide pipeline.

The simplest way to build a Func and then call realize to evaluate it over a rectangular domain.

realize

Arguments

:: forall n a t b. (KnownNat n, IsHalideType a)

=> Func t n (Expr a)

Function to evaluate

-> [Int]

Domain over which to evaluate

-> (Ptr (HalideBuffer n a) -> IO b)

What to do with the buffer afterwards. Note that the buffer is allocated only temporary, so do not return it directly.

-> IO b

Similar to realizeOnTarget except that the pipeline is run on hostTarget.

realizeOnTarget

Arguments

:: forall n a t b. (KnownNat n, IsHalideType a)

=> Target

Target on which to run the pipeline

-> Func t n (Expr a)

Function to evaluate

-> [Int]

Domain over which to evaluate

-> (Ptr (HalideBuffer n a) -> IO b)

What to do with the buffer afterwards. Note that the buffer is allocated only temporary, so do not return it directly.

-> IO b

Evaluate this function over a rectangular domain.

If your target is a GPU, this function will not automatically copy data back from the GPU.

asBufferParam

Arguments

:: forall n a t b. IsHalideBuffer t n a

=> t

Object to treat as a buffer

-> (Func 'ParamTy n (Expr a) -> IO b)

What to do with the temporary buffer

-> IO b

Wrap a buffer into a Func.

Suppose, we are defining a pipeline that adds together two vectors, and we'd like to call realize to evaluate it directly, how do we pass the vectors to the Func? asBufferParam allows to do exactly this.

asBuffer [1, 2, 3] $ \a ->
  asBuffer [4, 5, 6] $ \b -> do
    i <- mkVar "i"
    f <- define "vectorAdd" i $ a ! i + b ! i
    realize f [3] $ \result ->
      print =<< peekToList f

The drawback of calling realize all the time is that it's impossible to pass parameters to pipelines. We can define pipelines that operate on buffers using asBufferParam, but we have to recompile the pipeline for every new buffer.

A better way to handle pipeline parameters is to define a Haskell function that accepts Exprs and Funcs as arguments and returns a Func. We can then pass this function to compile (or compileForTarget), and it compile it into a Haskell function that can now be invoked with normal scalars instead of Exprs and Ptr HalideBuffers instead of Funcs.

compile

Arguments

:: forall f n a. (FuncBuilder f n a, IsHalideKernel (LoweredSignature f))

=> f

Function to compile

-> IO (LoweredSignature f)

Compiled kernel

Specifies how Expr and Func parameters become scalar and buffer arguments in compiled kernels. type family Lowered (t :: k) :: k where Lowered (Expr a) = a Lowered (Func t n (Expr a)) = Ptr (HalideBuffer n a) Lowered '[] = '[] Lowered (t ': ts) = (Lowered t ': Lowered ts)

A constraint that specifies that the function f returns IO (Func t n a). class (FunctionReturn f ~ IO (Func 'FuncTy n a), KnownNat n) => ReturnsFunc f n a | f -> n a

Convert a function that builds a Halide Func into a normal Haskell function acccepting scalars and HalideBuffers.

For example:

builder :: Expr Float -> Func 'ParamTy 1 Float -> IO (Func 'FuncTy 1 Float)
builder scale inputVector = do
  i <- mkVar "i"
  scaledVector <- define "scaledVector" i $ scale * inputVector ! i
  pure scaledVector

The builder function accepts a scalar parameter and a vector and scales the vector by the given factor. We can now pass builder to compile:

scaler <- compile builder
withHalideBuffer 1 Float [1, 1, 1] $ inputVector ->
  allocaCpuBuffer [3] $ outputVector -> do
    -- invoke the kernel
    scaler 2.0 inputVector outputVector
    -- print the result
    print =<< peekToList outputVector

Parameters

Similar to how we can specify the name of a variable in mkVar (or mkRVar) or function in define, one can also specify the name of a pipeline parameter. This is achieved by using the ViewPatterns extension together with the scalar and buffer helper functions.

buffer :: forall n a. (KnownNat n, IsHalideType a) => Text -> Func 'ParamTy n (Expr a) -> Func 'ParamTy n (Expr a)

A view pattern to specify the name of a buffer argument.

Example usage:

>>> :{
_ <- compile $ \(buffer "src" -> src) -> do
  i <- mkVar "i"
  define "dest" i $ (src ! i :: Expr Float)
:}

or if we want to specify the dimension and type, we can use type applications:

>>> :{
_ <- compile $ \(buffer @1 @Float "src" -> src) -> do
  i <- mkVar "i"
  define "dest" i $ src ! i
:}

scalar :: forall a. IsHalideType a => Text -> Expr a -> Expr a

Similar to buffer, but for scalar parameters.

Example usage:

>>> :{
_ <- compile $ \(scalar @Float "a" -> a) -> do
  i <- mkVar "i"
  define "dest" i $ a
:}

Another common thing to do with the parameters is to explicitly specify their shapes. For this, we expose the Dimension type:

newtype Dimension

Information about a buffer's dimension, such as the min, extent, and stride.

Constructors

Dimension (ForeignPtr CxxDimension)

Instances

Show Dimension

Defined in Language.Halide.Dimension

Methods

showsPrec :: Int -> Dimension -> ShowS

show :: Dimension -> String

showList :: [Dimension] -> ShowS

HasField "extent" Dimension (Expr Int32)

Defined in Language.Halide.Dimension

Methods

getField :: Dimension -> Expr Int32

HasField "max" Dimension (Expr Int32)

Defined in Language.Halide.Dimension

Methods

getField :: Dimension -> Expr Int32

HasField "min" Dimension (Expr Int32)

Defined in Language.Halide.Dimension

Methods

getField :: Dimension -> Expr Int32

HasField "stride" Dimension (Expr Int32)

Defined in Language.Halide.Dimension

Methods

getField :: Dimension -> Expr Int32

dim :: forall n a. (HasCallStack, KnownNat n) => Int -> Func 'ParamTy n (Expr a) -> IO Dimension

Get a particular dimension of a pipeline parameter.

setMin :: Expr Int32 -> Dimension -> IO Dimension

Set the min in a given dimension to equal the given expression. Setting the mins to zero may simplify some addressing math.

For more info, see Halide::Internal::Dimension::set_min.

setExtent :: Expr Int32 -> Dimension -> IO Dimension

Set the extent in a given dimension to equal the given expression.

Halide will generate runtime errors for Buffers that fail this check.

For more info, see Halide::Internal::Dimension::set_extent.

setStride :: Expr Int32 -> Dimension -> IO Dimension

Set the stride in a given dimension to equal the given expression.

This is particularly useful to set when vectorizing. Known strides for the vectorized dimensions generate better code.

For more info, see Halide::Internal::Dimension::set_stride.

setEstimate

Arguments

:: Expr Int32

min estimate

-> Expr Int32

extent estimate

-> Dimension

-> IO Dimension

Set estimates for autoschedulers.

setScalarEstimate

Arguments

:: IsHalideType a

=> a

Estimate

-> Expr a

Parameter

-> IO ()

Targets

newtype Target

The compilation target.

This is the Haskell counterpart of Halide::Target.

Constructors

Target (ForeignPtr CxxTarget)

Instances

Show Target

Defined in Language.Halide.Target

Methods

showsPrec :: Int -> Target -> ShowS

show :: Target -> String

showList :: [Target] -> ShowS

Eq Target

Defined in Language.Halide.Target

Methods

(==) :: Target -> Target -> Bool

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

hostTarget :: Target

Return the target that Halide will use by default.

If the HL_TARGET environment variable is set, it uses that. Otherwise, it returns the target corresponding to the host machine.

gpuTarget :: Maybe Target

Get the default GPU target. We first check for CUDA and then for OpenCL. If neither of the two is usable, Nothing is returned.

compileForTarget :: forall f n a. (FuncBuilder f n a, IsHalideKernel (LoweredSignature f)) => Target -> f -> IO (LoweredSignature f)

Similar to compile, but the first argument lets you explicitly specify the compilation target.

data DeviceAPI

An enum describing the type of device API.

This is the Haskell counterpart of Halide::DeviceAPI.

Constructors

DeviceNone

DeviceHost

DeviceDefaultGPU

DeviceCUDA

DeviceOpenCL

DeviceOpenGLCompute

DeviceMetal

DeviceHexagon

DeviceHexagonDma

DeviceD3D12Compute

Instances

Enum DeviceAPI

Defined in Language.Halide.Target

Methods

succ :: DeviceAPI -> DeviceAPI

pred :: DeviceAPI -> DeviceAPI

toEnum :: Int -> DeviceAPI

fromEnum :: DeviceAPI -> Int

enumFrom :: DeviceAPI -> [DeviceAPI]

enumFromThen :: DeviceAPI -> DeviceAPI -> [DeviceAPI]

enumFromTo :: DeviceAPI -> DeviceAPI -> [DeviceAPI]

enumFromThenTo :: DeviceAPI -> DeviceAPI -> DeviceAPI -> [DeviceAPI]

Show DeviceAPI

Defined in Language.Halide.Target

Methods

showsPrec :: Int -> DeviceAPI -> ShowS

show :: DeviceAPI -> String

showList :: [DeviceAPI] -> ShowS

Eq DeviceAPI

Defined in Language.Halide.Target

Methods

(==) :: DeviceAPI -> DeviceAPI -> Bool

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

Ord DeviceAPI

Defined in Language.Halide.Target

Methods

compare :: DeviceAPI -> DeviceAPI -> Ordering

(<) :: DeviceAPI -> DeviceAPI -> Bool

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

(>) :: DeviceAPI -> DeviceAPI -> Bool

(>=) :: DeviceAPI -> DeviceAPI -> Bool

max :: DeviceAPI -> DeviceAPI -> DeviceAPI

min :: DeviceAPI -> DeviceAPI -> DeviceAPI

data TargetFeature

Note: generated automatically using

cat $HALIDE_PATH/include/Halide.h | \
  grep -E '.* = halide_target_feature_.*' | \
  sed -E 's/^\s*(.*) = .*$/  | \1/g' | \
  grep -v FeatureEnd

Constructors

FeatureJIT

FeatureDebug

FeatureNoAsserts

FeatureNoBoundsQuery

FeatureSSE41

FeatureAVX

FeatureAVX2

FeatureFMA

FeatureFMA4

FeatureF16C

FeatureARMv7s

FeatureNoNEON

FeatureVSX

FeaturePOWER_ARCH_2_07

FeatureCUDA

FeatureCUDACapability30

FeatureCUDACapability32

FeatureCUDACapability35

FeatureCUDACapability50

FeatureCUDACapability61

FeatureCUDACapability70

FeatureCUDACapability75

FeatureCUDACapability80

FeatureCUDACapability86

FeatureOpenCL

FeatureCLDoubles

FeatureCLHalf

FeatureCLAtomics64

FeatureOpenGLCompute

FeatureEGL

FeatureUserContext

FeatureProfile

FeatureNoRuntime

FeatureMetal

FeatureCPlusPlusMangling

FeatureLargeBuffers

FeatureHexagonDma

FeatureHVX_128

FeatureHVX_v62

FeatureHVX_v65

FeatureHVX_v66

FeatureFuzzFloatStores

FeatureSoftFloatABI

FeatureMSAN

FeatureAVX512

FeatureAVX512_KNL

FeatureAVX512_Skylake

FeatureAVX512_Cannonlake

FeatureAVX512_SapphireRapids

FeatureTraceLoads

FeatureTraceStores

FeatureTraceRealizations

FeatureTracePipeline

FeatureD3D12Compute

FeatureStrictFloat

FeatureTSAN

FeatureASAN

FeatureCheckUnsafePromises

FeatureEmbedBitcode

FeatureEnableLLVMLoopOpt

FeatureWasmSimd128

FeatureWasmSignExt

FeatureWasmSatFloatToInt

FeatureWasmThreads

FeatureWasmBulkMemory

FeatureSVE

FeatureSVE2

FeatureARMDotProd

FeatureARMFp16

FeatureRVV

FeatureARMv81a

FeatureSanitizerCoverage

FeatureProfileByTimer

FeatureSPIRV

Instances

Enum TargetFeature

Defined in Language.Halide.Target

Methods

succ :: TargetFeature -> TargetFeature

pred :: TargetFeature -> TargetFeature

toEnum :: Int -> TargetFeature

fromEnum :: TargetFeature -> Int

enumFrom :: TargetFeature -> [TargetFeature]

enumFromThen :: TargetFeature -> TargetFeature -> [TargetFeature]

enumFromTo :: TargetFeature -> TargetFeature -> [TargetFeature]

enumFromThenTo :: TargetFeature -> TargetFeature -> TargetFeature -> [TargetFeature]

Show TargetFeature

Defined in Language.Halide.Target

Methods

showsPrec :: Int -> TargetFeature -> ShowS

show :: TargetFeature -> String

showList :: [TargetFeature] -> ShowS

Eq TargetFeature

Defined in Language.Halide.Target

Methods

(==) :: TargetFeature -> TargetFeature -> Bool

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

Ord TargetFeature

Defined in Language.Halide.Target

Methods

compare :: TargetFeature -> TargetFeature -> Ordering

(<) :: TargetFeature -> TargetFeature -> Bool

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

(>) :: TargetFeature -> TargetFeature -> Bool

(>=) :: TargetFeature -> TargetFeature -> Bool

max :: TargetFeature -> TargetFeature -> TargetFeature

min :: TargetFeature -> TargetFeature -> TargetFeature

setFeature

Arguments

:: TargetFeature

Feature to add

-> Target

Initial target

-> Target

New target

Add a feature to target.

hasGpuFeature :: Target -> Bool

Return whether a GPU compute runtime is enabled.

Checks whether gpuBlocks and similar are going to work.

For more info, see Target::has_gpu_feature.

hostSupportsTargetDevice

Arguments

:: Target

-> Bool

Whether the target appears to be usable

Attempt to sniff whether a given Target (and its implied DeviceAPI) is usable on the current host.

Note that a return value of True does not guarantee that future usage of that device will succeed; it is intended mainly as a simple diagnostic to allow early-exit when a desired device is definitely not usable.

Also note that this call is NOT threadsafe, as it temporarily redirects various global error-handling hooks in Halide.

Scheduling

class KnownNat n => Schedulable f (n :: Nat) (a :: Type) where

Common scheduling functions

Methods

vectorize :: VarOrRVar -> f n a -> IO (f n a)

Vectorize the dimension.

unroll :: VarOrRVar -> f n a -> IO (f n a)

Unroll the dimension.

reorder

Arguments

:: [VarOrRVar]

variables

-> f n a

function or stage

-> IO (f n a)

Reorder variables to have the given nesting order, from innermost out.

Note that variables should only contain variables that belong to the function. If this is not the case, a runtime error will be thrown.

split :: TailStrategy -> VarOrRVar -> (VarOrRVar, VarOrRVar) -> Expr Int32 -> f n a -> IO (f n a)

Split a dimension into inner and outer subdimensions with the given names, where the inner dimension iterates from 0 to factor-1.

The inner and outer subdimensions can then be dealt with using the other scheduling calls. It's okay to reuse the old variable name as either the inner or outer variable. The first argument specifies how the tail should be handled if the split factor does not provably divide the extent.

fuse :: (VarOrRVar, VarOrRVar) -> VarOrRVar -> f n a -> IO (f n a)

Join two dimensions into a single fused dimenion.

The fused dimension covers the product of the extents of the inner and outer dimensions given.

serial :: VarOrRVar -> f n a -> IO (f n a)

Mark the dimension to be traversed serially

parallel :: VarOrRVar -> f n a -> IO (f n a)

Mark the dimension to be traversed in parallel

atomic

Arguments

:: Bool

whether to override the associativity test

-> f n a

-> IO (f n a)

Issue atomic updates for this Func.

specialize :: Expr Bool -> f n a -> IO (Stage n a)

specializeFail :: Text -> f n a -> IO ()

gpuBlocks :: (KnownNat k, 1 <= k, k <= 3) => DeviceAPI -> IndexType k -> f n a -> IO (f n a)

gpuThreads :: (KnownNat k, 1 <= k, k <= 3) => DeviceAPI -> IndexType k -> f n a -> IO (f n a)

gpuLanes :: DeviceAPI -> VarOrRVar -> f n a -> IO (f n a)

computeWith :: LoopAlignStrategy -> f n a -> LoopLevel t -> IO ()

Schedule the iteration over this stage to be fused with another stage from outermost loop to a given LoopLevel.

For more info, see Halide::Stage::compute_with.

Instances

KnownNat n => Schedulable Stage n a

Defined in Language.Halide.Func

Methods

vectorize :: VarOrRVar -> Stage n a -> IO (Stage n a)

unroll :: VarOrRVar -> Stage n a -> IO (Stage n a)

reorder :: [VarOrRVar] -> Stage n a -> IO (Stage n a)

split :: TailStrategy -> VarOrRVar -> (VarOrRVar, VarOrRVar) -> Expr Int32 -> Stage n a -> IO (Stage n a)

fuse :: (VarOrRVar, VarOrRVar) -> VarOrRVar -> Stage n a -> IO (Stage n a)

serial :: VarOrRVar -> Stage n a -> IO (Stage n a)

parallel :: VarOrRVar -> Stage n a -> IO (Stage n a)

atomic :: Bool -> Stage n a -> IO (Stage n a)

specialize :: Expr Bool -> Stage n a -> IO (Stage n a)

specializeFail :: Text -> Stage n a -> IO ()

gpuBlocks :: forall (k :: Nat). (KnownNat k, 1 <= k, k <= 3) => DeviceAPI -> IndexType k -> Stage n a -> IO (Stage n a)

gpuThreads :: forall (k :: Nat). (KnownNat k, 1 <= k, k <= 3) => DeviceAPI -> IndexType k -> Stage n a -> IO (Stage n a)

gpuLanes :: DeviceAPI -> VarOrRVar -> Stage n a -> IO (Stage n a)

computeWith :: forall (t :: LoopLevelTy). LoopAlignStrategy -> Stage n a -> LoopLevel t -> IO ()

KnownNat n => Schedulable (Func t) n a

Defined in Language.Halide.Func

Methods

vectorize :: VarOrRVar -> Func t n a -> IO (Func t n a)

unroll :: VarOrRVar -> Func t n a -> IO (Func t n a)

reorder :: [VarOrRVar] -> Func t n a -> IO (Func t n a)

split :: TailStrategy -> VarOrRVar -> (VarOrRVar, VarOrRVar) -> Expr Int32 -> Func t n a -> IO (Func t n a)

fuse :: (VarOrRVar, VarOrRVar) -> VarOrRVar -> Func t n a -> IO (Func t n a)

serial :: VarOrRVar -> Func t n a -> IO (Func t n a)

parallel :: VarOrRVar -> Func t n a -> IO (Func t n a)

atomic :: Bool -> Func t n a -> IO (Func t n a)

specialize :: Expr Bool -> Func t n a -> IO (Stage n a)

specializeFail :: Text -> Func t n a -> IO ()

gpuBlocks :: forall (k :: Nat). (KnownNat k, 1 <= k, k <= 3) => DeviceAPI -> IndexType k -> Func t n a -> IO (Func t n a)

gpuThreads :: forall (k :: Nat). (KnownNat k, 1 <= k, k <= 3) => DeviceAPI -> IndexType k -> Func t n a -> IO (Func t n a)

gpuLanes :: DeviceAPI -> VarOrRVar -> Func t n a -> IO (Func t n a)

computeWith :: forall (t0 :: LoopLevelTy). LoopAlignStrategy -> Func t n a -> LoopLevel t0 -> IO ()

data TailStrategy

Different ways to handle a tail case in a split when the split factor does not provably divide the extent.

This is the Haskell counterpart of Halide::TailStrategy.

Constructors

TailRoundUp

Round up the extent to be a multiple of the split factor.

Not legal for RVars, as it would change the meaning of the algorithm.

• Pros: generates the simplest, fastest code.
• Cons: if used on a stage that reads from the input or writes to the output, constrains the input or output size to be a multiple of the split factor.

TailGuardWithIf

Guard the inner loop with an if statement that prevents evaluation beyond the original extent.

Always legal. The if statement is treated like a boundary condition, and factored out into a loop epilogue if possible.

• Pros: no redundant re-evaluation; does not constrain input our output sizes.
• Cons: increases code size due to separate tail-case handling; vectorization will scalarize in the tail case to handle the if statement.

TailPredicate

Guard the loads and stores in the loop with an if statement that prevents evaluation beyond the original extent.

Always legal. The if statement is treated like a boundary condition, and factored out into a loop epilogue if possible. * Pros: no redundant re-evaluation; does not constrain input or output sizes. * Cons: increases code size due to separate tail-case handling.

TailPredicateLoads

Guard the loads in the loop with an if statement that prevents evaluation beyond the original extent.

Only legal for innermost splits. Not legal for RVars, as it would change the meaning of the algorithm. The if statement is treated like a boundary condition, and factored out into a loop epilogue if possible. * Pros: does not constrain input sizes, output size constraints are simpler than full predication. * Cons: increases code size due to separate tail-case handling, constrains the output size to be a multiple of the split factor.

TailPredicateStores

Guard the stores in the loop with an if statement that prevents evaluation beyond the original extent.

Only legal for innermost splits. Not legal for RVars, as it would change the meaning of the algorithm. The if statement is treated like a boundary condition, and factored out into a loop epilogue if possible. * Pros: does not constrain output sizes, input size constraints are simpler than full predication. * Cons: increases code size due to separate tail-case handling, constraints the input size to be a multiple of the split factor.

TailShiftInwards

Prevent evaluation beyond the original extent by shifting the tail case inwards, re-evaluating some points near the end.

Only legal for pure variables in pure definitions. If the inner loop is very simple, the tail case is treated like a boundary condition and factored out into an epilogue.

This is a good trade-off between several factors. Like TailRoundUp, it supports vectorization well, because the inner loop is always a fixed size with no data-dependent branching. It increases code size slightly for inner loops due to the epilogue handling, but not for outer loops (e.g. loops over tiles). If used on a stage that reads from an input or writes to an output, this stategy only requires that the input/output extent be at least the split factor, instead of a multiple of the split factor as with TailRoundUp.

TailAuto

For pure definitions use TailShiftInwards.

For pure vars in update definitions use TailRoundUp. For RVars in update definitions use TailGuardWithIf.

Instances

Enum TailStrategy

Defined in Language.Halide.Func

Methods

succ :: TailStrategy -> TailStrategy

pred :: TailStrategy -> TailStrategy

toEnum :: Int -> TailStrategy

fromEnum :: TailStrategy -> Int

enumFrom :: TailStrategy -> [TailStrategy]

enumFromThen :: TailStrategy -> TailStrategy -> [TailStrategy]

enumFromTo :: TailStrategy -> TailStrategy -> [TailStrategy]

enumFromThenTo :: TailStrategy -> TailStrategy -> TailStrategy -> [TailStrategy]

Show TailStrategy

Defined in Language.Halide.Func

Methods

showsPrec :: Int -> TailStrategy -> ShowS

show :: TailStrategy -> String

showList :: [TailStrategy] -> ShowS

Eq TailStrategy

Defined in Language.Halide.Func

Methods

(==) :: TailStrategy -> TailStrategy -> Bool

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

Ord TailStrategy

Defined in Language.Halide.Func

Methods

compare :: TailStrategy -> TailStrategy -> Ordering

(<) :: TailStrategy -> TailStrategy -> Bool

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

(>) :: TailStrategy -> TailStrategy -> Bool

(>=) :: TailStrategy -> TailStrategy -> Bool

max :: TailStrategy -> TailStrategy -> TailStrategy

min :: TailStrategy -> TailStrategy -> TailStrategy

data LoopLevel (t :: LoopLevelTy) where

A reference to a site in a Halide statement at the top of the body of a particular for loop.

Constructors

InlinedLoopLevel :: LoopLevel 'InlinedTy

RootLoopLevel :: LoopLevel 'RootTy

LoopLevel :: !(ForeignPtr CxxLoopLevel) -> LoopLevel 'LockedTy

Instances

HasField "func" (LoopLevel 'LockedTy) Text

Defined in Language.Halide.LoopLevel

Methods

getField :: LoopLevel 'LockedTy -> Text

HasField "var" (LoopLevel 'LockedTy) (Expr Int32)

Defined in Language.Halide.LoopLevel

Methods

getField :: LoopLevel 'LockedTy -> Expr Int32

Show (LoopLevel t)

Defined in Language.Halide.LoopLevel

Methods

showsPrec :: Int -> LoopLevel t -> ShowS

show :: LoopLevel t -> String

showList :: [LoopLevel t] -> ShowS

Eq (LoopLevel t)

Defined in Language.Halide.LoopLevel

Methods

(==) :: LoopLevel t -> LoopLevel t -> Bool

(/=) :: LoopLevel t -> LoopLevel t -> Bool

data LoopLevelTy

Constructors

InlinedTy

RootTy

LockedTy

data LoopAlignStrategy

Different ways to handle the case when the start/end of the loops of stages computed with (fused) are not aligned.

Constructors

LoopAlignStart

Shift the start of the fused loops to align.

LoopAlignEnd

Shift the end of the fused loops to align.

LoopNoAlign

computeWith will make no attempt to align the start/end of the fused loops.

LoopAlignAuto

By default, LoopAlignStrategy is set to LoopNoAlign.

Instances

Enum LoopAlignStrategy

Defined in Language.Halide.LoopLevel

Methods

succ :: LoopAlignStrategy -> LoopAlignStrategy

pred :: LoopAlignStrategy -> LoopAlignStrategy

toEnum :: Int -> LoopAlignStrategy

fromEnum :: LoopAlignStrategy -> Int

enumFrom :: LoopAlignStrategy -> [LoopAlignStrategy]

enumFromThen :: LoopAlignStrategy -> LoopAlignStrategy -> [LoopAlignStrategy]

enumFromTo :: LoopAlignStrategy -> LoopAlignStrategy -> [LoopAlignStrategy]

enumFromThenTo :: LoopAlignStrategy -> LoopAlignStrategy -> LoopAlignStrategy -> [LoopAlignStrategy]

Show LoopAlignStrategy

Defined in Language.Halide.LoopLevel

Methods

showsPrec :: Int -> LoopAlignStrategy -> ShowS

show :: LoopAlignStrategy -> String

showList :: [LoopAlignStrategy] -> ShowS

Eq LoopAlignStrategy

Defined in Language.Halide.LoopLevel

Methods

(==) :: LoopAlignStrategy -> LoopAlignStrategy -> Bool

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

Ord LoopAlignStrategy

Defined in Language.Halide.LoopLevel

Methods

compare :: LoopAlignStrategy -> LoopAlignStrategy -> Ordering

(<) :: LoopAlignStrategy -> LoopAlignStrategy -> Bool

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

(>) :: LoopAlignStrategy -> LoopAlignStrategy -> Bool

(>=) :: LoopAlignStrategy -> LoopAlignStrategy -> Bool

max :: LoopAlignStrategy -> LoopAlignStrategy -> LoopAlignStrategy

min :: LoopAlignStrategy -> LoopAlignStrategy -> LoopAlignStrategy

computeRoot :: KnownNat n => Func t n a -> IO (Func t n a)

Compute all of this function once ahead of time.

See Halide::Func::compute_root for more info.

getStage :: KnownNat n => Func t n a -> IO (Stage n a)

Get the pure stage of a Func for the purposes of scheduling it.

getLoopLevel :: KnownNat n => Func t n a -> Expr Int32 -> IO (LoopLevel 'LockedTy)

Same as getLoopLevelAtStage except that the stage is -1.

getLoopLevelAtStage

Arguments

:: KnownNat n

=> Func t n a

-> Expr Int32

-> Int

update index

-> IO (LoopLevel 'LockedTy)

Identify the loop nest corresponding to some dimension of some function.

asUsed :: KnownNat n => Func t n a -> IO (Func 'FuncTy n a)

Create and return a global identity wrapper, which wraps all calls to this Func by any other Func.

If a global wrapper already exists, returns it. The global identity wrapper is only used by callers for which no custom wrapper has been specified.

asUsedBy :: (KnownNat n, KnownNat m) => Func t1 n a -> Func 'FuncTy m b -> IO (Func 'FuncTy n a)

Creates and returns a new identity Func that wraps this Func.

During compilation, Halide replaces all calls to this Func done by f with calls to the wrapper. If this Func is already wrapped for use in f, will return the existing wrapper.

For more info, see Halide::Func::in.

copyToDevice :: KnownNat n => DeviceAPI -> Func t n a -> IO (Func t n a)

Declare that this function should be implemented by a call to halide_buffer_copy with the given target device API.

Asserts that the Func has a pure definition which is a simple call to a single input, and no update definitions. The wrapper Funcs returned by asUsed are suitable candidates. Consumes all pure variables, and rewrites the Func to have an extern definition that calls halide_buffer_copy.

copyToHost :: KnownNat n => Func t n a -> IO (Func t n a)

Same as copyToDevice DeviceHost

storeAt :: KnownNat n => Func 'FuncTy n a -> LoopLevel t -> IO (Func 'FuncTy n a)

Allocate storage for this function within a particular loop level.

Scheduling storage is optional, and can be used to separate the loop level at which storage is allocated from the loop level at which computation occurs to trade off between locality and redundant work.

For more info, see Halide::Func::store_at.

computeAt :: KnownNat n => Func 'FuncTy n a -> LoopLevel t -> IO (Func 'FuncTy n a)

Schedule a function to be computed within the iteration over a given loop level.

For more info, see Halide::Func::compute_at.

estimate

Arguments

:: KnownNat n

=> Expr Int32

index variable

-> Expr Int32

min estimate

-> Expr Int32

extent estimate

-> Func t n a

-> IO ()

Statically declare the range over which the function will be evaluated in the general case.

This provides a basis for the auto scheduler to make trade-offs and scheduling decisions. The auto generated schedules might break when the sizes of the dimensions are very different from the estimates specified. These estimates are used only by the auto scheduler if the function is a pipeline output.

bound

Arguments

:: KnownNat n

=> Expr Int32

index variable

-> Expr Int32

min estimate

-> Expr Int32

extent estimate

-> Func t n a

-> IO ()

Statically declare the range over which a function should be evaluated.

This can let Halide perform some optimizations. E.g. if you know there are going to be 4 color channels, you can completely vectorize the color channel dimension without the overhead of splitting it up. If bounds inference decides that it requires more of this function than the bounds you have stated, a runtime error will occur when you try to run your pipeline.

Debugging / Tracing

For debugging, it's often useful to observe the value of an expression when it's evaluated. If you have a complex expression that does not depend on any buffers or indices, you can evaluate it. | However, often an expression is only used within a definition of a pipeline, and it's impossible to call evaluate on it. In such cases, it can be wrapped with printed to indicate to Halide that the value of the expression should be dumped to screen when it's computed.

prettyLoopNest :: KnownNat n => Func t n r -> IO Text

Get the loop nests specified by the schedule for this function.

Helpful for understanding what a schedule is doing.

For more info, see Halide::Func::print_loop_nest

compileToLoweredStmt :: forall n a f. FuncBuilder f n a => StmtOutputFormat -> Target -> f -> IO Text

Get the internal representation of lowered code.

Useful for analyzing and debugging scheduling. Can emit HTML or plain text.

data StmtOutputFormat

Format in which to return the lowered code.

Constructors

StmtText

plain text

StmtHTML

HTML

Instances

Enum StmtOutputFormat

Defined in Language.Halide.Kernel

Methods

succ :: StmtOutputFormat -> StmtOutputFormat

pred :: StmtOutputFormat -> StmtOutputFormat

toEnum :: Int -> StmtOutputFormat

fromEnum :: StmtOutputFormat -> Int

enumFrom :: StmtOutputFormat -> [StmtOutputFormat]

enumFromThen :: StmtOutputFormat -> StmtOutputFormat -> [StmtOutputFormat]

enumFromTo :: StmtOutputFormat -> StmtOutputFormat -> [StmtOutputFormat]

enumFromThenTo :: StmtOutputFormat -> StmtOutputFormat -> StmtOutputFormat -> [StmtOutputFormat]

Show StmtOutputFormat

Defined in Language.Halide.Kernel

Methods

showsPrec :: Int -> StmtOutputFormat -> ShowS

show :: StmtOutputFormat -> String

showList :: [StmtOutputFormat] -> ShowS

Eq StmtOutputFormat

Defined in Language.Halide.Kernel

Methods

(==) :: StmtOutputFormat -> StmtOutputFormat -> Bool

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

data TraceEvent

Constructors

TraceEvent

Fields

• funcName :: !Text
• eventCode :: !TraceEventCode
• loadStoreContents :: !(Maybe TraceLoadStoreContents)

Instances

Show TraceEvent

Defined in Language.Halide.Trace

Methods

showsPrec :: Int -> TraceEvent -> ShowS

show :: TraceEvent -> String

showList :: [TraceEvent] -> ShowS

data TraceEventCode

Haskell counterpart of halide_trace_event_code_t.

Constructors

TraceLoad

TraceStore

TraceBeginRealization

TraceEndRealization

TraceProduce

TraceEndProduce

TraceConsume

TraceEndConsume

TraceBeginPipeline

TraceEndPipeline

TraceTag

Instances

Enum TraceEventCode

Defined in Language.Halide.Trace

Methods

succ :: TraceEventCode -> TraceEventCode

pred :: TraceEventCode -> TraceEventCode

toEnum :: Int -> TraceEventCode

fromEnum :: TraceEventCode -> Int

enumFrom :: TraceEventCode -> [TraceEventCode]

enumFromThen :: TraceEventCode -> TraceEventCode -> [TraceEventCode]

enumFromTo :: TraceEventCode -> TraceEventCode -> [TraceEventCode]

enumFromThenTo :: TraceEventCode -> TraceEventCode -> TraceEventCode -> [TraceEventCode]

Show TraceEventCode

Defined in Language.Halide.Trace

Methods

showsPrec :: Int -> TraceEventCode -> ShowS

show :: TraceEventCode -> String

showList :: [TraceEventCode] -> ShowS

Eq TraceEventCode

Defined in Language.Halide.Trace

Methods

(==) :: TraceEventCode -> TraceEventCode -> Bool

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

Ord TraceEventCode

Defined in Language.Halide.Trace

Methods

compare :: TraceEventCode -> TraceEventCode -> Ordering

(<) :: TraceEventCode -> TraceEventCode -> Bool

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

(>) :: TraceEventCode -> TraceEventCode -> Bool

(>=) :: TraceEventCode -> TraceEventCode -> Bool

max :: TraceEventCode -> TraceEventCode -> TraceEventCode

min :: TraceEventCode -> TraceEventCode -> TraceEventCode

data TraceLoadStoreContents

Constructors

TraceLoadStoreContents

Fields

• valuePtr :: !(Ptr ())
• valueType :: !HalideType
• coordinates :: ![Int]

Instances

Show TraceLoadStoreContents

Defined in Language.Halide.Trace

Methods

showsPrec :: Int -> TraceLoadStoreContents -> ShowS

show :: TraceLoadStoreContents -> String

showList :: [TraceLoadStoreContents] -> ShowS

setCustomTrace

Arguments

:: KnownNat n

=> (TraceEvent -> IO ())

Custom trace function

-> Func t n a

For which func to enable it

-> IO b

For the duration of which computation to enable it

-> IO b

traceStores :: KnownNat n => Func t n a -> IO (Func t n a)

traceLoads :: KnownNat n => Func t n a -> IO (Func t n a)

collectIterationOrder :: KnownNat n => (TraceEventCode -> Bool) -> Func t n a -> IO b -> IO ([[Int]], b)

Type helpers

class (ToTuple a ~ t, FromTuple t ~ a) => IsTuple a t | a -> t, t -> a where

Specifies that there is an isomorphism between a type a and a tuple t.

We use this class to convert between Arguments and normal tuples.

Methods

toTuple :: Arguments a -> t

fromTuple :: t -> Arguments a

Instances

IsTuple ('[] :: [Type]) ()

Defined in Language.Halide.Expr

Methods

toTuple :: Arguments '[] -> ()

fromTuple :: () -> Arguments '[]

IsTuple '[Expr a1] (Expr a1)

Defined in Language.Halide.Expr

Methods

toTuple :: Arguments '[Expr a1] -> Expr a1

fromTuple :: Expr a1 -> Arguments '[Expr a1]

IsTuple '[a1, a2] (a1, a2)

Defined in Language.Halide.Expr

Methods

toTuple :: Arguments '[a1, a2] -> (a1, a2)

fromTuple :: (a1, a2) -> Arguments '[a1, a2]

IsTuple '[a1, a2, a3] (a1, a2, a3)

Defined in Language.Halide.Expr

Methods

toTuple :: Arguments '[a1, a2, a3] -> (a1, a2, a3)

fromTuple :: (a1, a2, a3) -> Arguments '[a1, a2, a3]

IsTuple '[a1, a2, a3, a4] (a1, a2, a3, a4)

Defined in Language.Halide.Expr

Methods

toTuple :: Arguments '[a1, a2, a3, a4] -> (a1, a2, a3, a4)

fromTuple :: (a1, a2, a3, a4) -> Arguments '[a1, a2, a3, a4]

IsTuple '[a1, a2, a3, a4, a5] (a1, a2, a3, a4, a5)

Defined in Language.Halide.Expr

Methods

toTuple :: Arguments '[a1, a2, a3, a4, a5] -> (a1, a2, a3, a4, a5)

fromTuple :: (a1, a2, a3, a4, a5) -> Arguments '[a1, a2, a3, a4, a5]

IsTuple '[a1, a2, a3, a4, a5, a6] (a1, a2, a3, a4, a5, a6)

Defined in Language.Halide.Expr

Methods

toTuple :: Arguments '[a1, a2, a3, a4, a5, a6] -> (a1, a2, a3, a4, a5, a6)

fromTuple :: (a1, a2, a3, a4, a5, a6) -> Arguments '[a1, a2, a3, a4, a5, a6]

IsTuple '[a1, a2, a3, a4, a5, a6, a7] (a1, a2, a3, a4, a5, a6, a7)

Defined in Language.Halide.Expr

Methods

toTuple :: Arguments '[a1, a2, a3, a4, a5, a6, a7] -> (a1, a2, a3, a4, a5, a6, a7)

fromTuple :: (a1, a2, a3, a4, a5, a6, a7) -> Arguments '[a1, a2, a3, a4, a5, a6, a7]

IsTuple '[a1, a2, a3, a4, a5, a6, a7, a8] (a1, a2, a3, a4, a5, a6, a7, a8)

Defined in Language.Halide.Expr

Methods

toTuple :: Arguments '[a1, a2, a3, a4, a5, a6, a7, a8] -> (a1, a2, a3, a4, a5, a6, a7, a8)

fromTuple :: (a1, a2, a3, a4, a5, a6, a7, a8) -> Arguments '[a1, a2, a3, a4, a5, a6, a7, a8]

IsTuple '[a1, a2, a3, a4, a5, a6, a7, a8, a9] (a1, a2, a3, a4, a5, a6, a7, a8, a9)

Defined in Language.Halide.Expr

Methods

toTuple :: Arguments '[a1, a2, a3, a4, a5, a6, a7, a8, a9] -> (a1, a2, a3, a4, a5, a6, a7, a8, a9)

fromTuple :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Arguments '[a1, a2, a3, a4, a5, a6, a7, a8, a9]

IsTuple '[a1, a2, a3, a4, a5, a6, a7, a8, a9, a10] (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

Defined in Language.Halide.Expr

Methods

toTuple :: Arguments '[a1, a2, a3, a4, a5, a6, a7, a8, a9, a10] -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

fromTuple :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> Arguments '[a1, a2, a3, a4, a5, a6, a7, a8, a9, a10]

type family ToTuple t = s | s -> t where ...

Type family that maps Arguments ts to the corresponding tuple type.

Equations

ToTuple '[] = ()

ToTuple '[Expr a1] = Expr a1

ToTuple '[a1, a2] = (a1, a2)

ToTuple '[a1, a2, a3] = (a1, a2, a3)

ToTuple '[a1, a2, a3, a4] = (a1, a2, a3, a4)

ToTuple '[a1, a2, a3, a4, a5] = (a1, a2, a3, a4, a5)

ToTuple '[a1, a2, a3, a4, a5, a6] = (a1, a2, a3, a4, a5, a6)

ToTuple '[a1, a2, a3, a4, a5, a6, a7] = (a1, a2, a3, a4, a5, a6, a7)

ToTuple '[a1, a2, a3, a4, a5, a6, a7, a8] = (a1, a2, a3, a4, a5, a6, a7, a8)

ToTuple '[a1, a2, a3, a4, a5, a6, a7, a8, a9] = (a1, a2, a3, a4, a5, a6, a7, a8, a9)

ToTuple '[a1, a2, a3, a4, a5, a6, a7, a8, a9, a10] = (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

type family FromTuple t = s | s -> t where ...

Type family that maps tuples to the corresponding Arguments ts type. This is essentially the inverse of ToTuple.

Equations

FromTuple () = '[]

FromTuple (Expr a1) = '[Expr a1]

FromTuple (a1, a2) = '[a1, a2]

FromTuple (a1, a2, a3) = '[a1, a2, a3]

FromTuple (a1, a2, a3, a4) = '[a1, a2, a3, a4]

FromTuple (a1, a2, a3, a4, a5) = '[a1, a2, a3, a4, a5]

FromTuple (a1, a2, a3, a4, a5, a6) = '[a1, a2, a3, a4, a5, a6]

FromTuple (a1, a2, a3, a4, a5, a6, a7) = '[a1, a2, a3, a4, a5, a6, a7]

FromTuple (a1, a2, a3, a4, a5, a6, a7, a8) = '[a1, a2, a3, a4, a5, a6, a7, a8]

FromTuple (a1, a2, a3, a4, a5, a6, a7, a8, a9) = '[a1, a2, a3, a4, a5, a6, a7, a8, a9]

FromTuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) = '[a1, a2, a3, a4, a5, a6, a7, a8, a9, a10]

type family Length (xs :: [k]) :: Nat where ...

A type family that returns the length of a type-level list.

Equations

Length '[] = 0

Length (x ': xs) = 1 + Length xs

type family All (c :: Type -> Constraint) (ts :: [Type]) = (p :: Constraint) | p -> ts where ...

Apply constraint to all types in a list.

Equations

All c '[] = ()

All c (t ': ts) = (c t, All c ts)

Internal

compileToCallable :: forall n a f. (FuncBuilder f n a, IsHalideKernel (LoweredSignature f)) => Target -> f -> IO (Callable (LoweredSignature f))

testCUDA :: IO ()

A test that tries to compile and run a Halide pipeline using FeatureCUDA.

This is implemented fully in C++ to make sure that we test the installation rather than our Haskell code.

On non-NixOS systems one should do the following:

nixGLNvidia cabal repl --ghc-options='-fobject-code -O0'
ghci> testCUDA

testOpenCL :: IO ()

Similar to testCUDA but for FeatureOpenCL.

data SomeLoopLevel where

Constructors

SomeLoopLevel :: LoopLevel t -> SomeLoopLevel

Instances

Show SomeLoopLevel

Defined in Language.Halide.LoopLevel

Methods

showsPrec :: Int -> SomeLoopLevel -> ShowS

show :: SomeLoopLevel -> String

showList :: [SomeLoopLevel] -> ShowS

Eq SomeLoopLevel

Defined in Language.Halide.LoopLevel

Methods

(==) :: SomeLoopLevel -> SomeLoopLevel -> Bool

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

data RawHalideBuffer

The low-level untyped Haskell analogue of halide_buffer_t.

It's quite difficult to use RawHalideBuffer correctly, and misusage can result in crashes and segmentation faults. Hence, prefer the higher-level HalideBuffer wrapper for all your code

Constructors

RawHalideBuffer

Fields

• halideBufferDevice :: !Word64
• halideBufferDeviceInterface :: !(Ptr HalideDeviceInterface)
• halideBufferHost :: !(Ptr Word8)
• halideBufferFlags :: !Word64
• halideBufferType :: !HalideType
• halideBufferDimensions :: !Int32
• halideBufferDim :: !(Ptr HalideDimension)
• halideBufferPadding :: !(Ptr ())

Instances

Storable RawHalideBuffer

Defined in Language.Halide.Buffer

Methods

sizeOf :: RawHalideBuffer -> Int

alignment :: RawHalideBuffer -> Int

peekElemOff :: Ptr RawHalideBuffer -> Int -> IO RawHalideBuffer

pokeElemOff :: Ptr RawHalideBuffer -> Int -> RawHalideBuffer -> IO ()

peekByteOff :: Ptr b -> Int -> IO RawHalideBuffer

pokeByteOff :: Ptr b -> Int -> RawHalideBuffer -> IO ()

peek :: Ptr RawHalideBuffer -> IO RawHalideBuffer

poke :: Ptr RawHalideBuffer -> RawHalideBuffer -> IO ()

Show RawHalideBuffer

Defined in Language.Halide.Buffer

Methods

showsPrec :: Int -> RawHalideBuffer -> ShowS

show :: RawHalideBuffer -> String

showList :: [RawHalideBuffer] -> ShowS

Eq RawHalideBuffer

Defined in Language.Halide.Buffer

Methods

(==) :: RawHalideBuffer -> RawHalideBuffer -> Bool

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

data HalideDimension

Information about a dimension in a buffer.

It is the Haskell analogue of halide_dimension_t.

Constructors

HalideDimension

Fields

• halideDimensionMin :: !Int32

  Starting index.

• halideDimensionExtent :: !Int32

  Length of the dimension.

• halideDimensionStride :: !Int32

  Stride along this dimension.

• halideDimensionFlags :: !Word32

  Extra flags.

Instances

Storable HalideDimension

Defined in Language.Halide.Buffer

Methods

sizeOf :: HalideDimension -> Int

alignment :: HalideDimension -> Int

peekElemOff :: Ptr HalideDimension -> Int -> IO HalideDimension

pokeElemOff :: Ptr HalideDimension -> Int -> HalideDimension -> IO ()

peekByteOff :: Ptr b -> Int -> IO HalideDimension

pokeByteOff :: Ptr b -> Int -> HalideDimension -> IO ()

peek :: Ptr HalideDimension -> IO HalideDimension

poke :: Ptr HalideDimension -> HalideDimension -> IO ()

Read HalideDimension

Defined in Language.Halide.Buffer

Methods

readsPrec :: Int -> ReadS HalideDimension

readList :: ReadS [HalideDimension]

readPrec :: ReadPrec HalideDimension

readListPrec :: ReadPrec [HalideDimension]

Show HalideDimension

Defined in Language.Halide.Buffer

Methods

showsPrec :: Int -> HalideDimension -> ShowS

show :: HalideDimension -> String

showList :: [HalideDimension] -> ShowS

Eq HalideDimension

Defined in Language.Halide.Buffer

Methods

(==) :: HalideDimension -> HalideDimension -> Bool

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

data HalideDeviceInterface

Haskell analogue of halide_device_interface_t.

rowMajorStrides

Arguments

:: Integral a

=> [a]

Extents

-> [a]

Get strides corresponding to row-major ordering

colMajorStrides

Arguments

:: Integral a

=> [a]

Extents

-> [a]

Get strides corresponding to column-major ordering.

isDeviceDirty :: Ptr RawHalideBuffer -> IO Bool

Do we have changes on the device the have not been copied to the host?

isHostDirty :: Ptr RawHalideBuffer -> IO Bool

Do we have changes on the device the have not been copied to the host?

getBufferExtent :: forall n a. KnownNat n => Ptr (HalideBuffer n a) -> Int -> IO Int

bufferCopyToHost :: HasCallStack => Ptr RawHalideBuffer -> IO ()

Copy the underlying memory from device to host.

withCopiedToHost :: Ptr (HalideBuffer n a) -> IO b -> IO b

withCopiedToHost buf action performs the action action ensuring that buf has been copied to the host beforehand. If buf is already on the host, no copying is performed.

withCropped

Arguments

:: Ptr (HalideBuffer n a)

buffer

-> Int

dimension

-> Int

min

-> Int

extent

-> (Ptr (HalideBuffer n a) -> IO b)

what to do

-> IO b

Perform an action on a cropped buffer.

data Dim

Constructors

Dim

Fields

• var :: !Text
• forType :: !ForType
• deviceApi :: !DeviceAPI
• dimType :: !DimType

Instances

Storable Dim

Defined in Language.Halide.Schedule

Methods

sizeOf :: Dim -> Int

alignment :: Dim -> Int

peekElemOff :: Ptr Dim -> Int -> IO Dim

pokeElemOff :: Ptr Dim -> Int -> Dim -> IO ()

peekByteOff :: Ptr b -> Int -> IO Dim

pokeByteOff :: Ptr b -> Int -> Dim -> IO ()

peek :: Ptr Dim -> IO Dim

poke :: Ptr Dim -> Dim -> IO ()

Show Dim

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> Dim -> ShowS

show :: Dim -> String

showList :: [Dim] -> ShowS

Eq Dim

Defined in Language.Halide.Schedule

Methods

(==) :: Dim -> Dim -> Bool

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

data DimType

Type of dimension that tells which transformations are legal on it.

Constructors

DimPureVar

DimPureRVar

DimImpureRVar

Instances

Enum DimType

Defined in Language.Halide.Schedule

Methods

succ :: DimType -> DimType

pred :: DimType -> DimType

toEnum :: Int -> DimType

fromEnum :: DimType -> Int

enumFrom :: DimType -> [DimType]

enumFromThen :: DimType -> DimType -> [DimType]

enumFromTo :: DimType -> DimType -> [DimType]

enumFromThenTo :: DimType -> DimType -> DimType -> [DimType]

Show DimType

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> DimType -> ShowS

show :: DimType -> String

showList :: [DimType] -> ShowS

Eq DimType

Defined in Language.Halide.Schedule

Methods

(==) :: DimType -> DimType -> Bool

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

data ForType

Specifies how loop values are traversed.

Constructors

ForSerial

ForParallel

ForVectorized

ForUnrolled

ForExtern

ForGPUBlock

ForGPUThread

ForGPULane

Instances

Enum ForType

Defined in Language.Halide.Schedule

Methods

succ :: ForType -> ForType

pred :: ForType -> ForType

toEnum :: Int -> ForType

fromEnum :: ForType -> Int

enumFrom :: ForType -> [ForType]

enumFromThen :: ForType -> ForType -> [ForType]

enumFromTo :: ForType -> ForType -> [ForType]

enumFromThenTo :: ForType -> ForType -> ForType -> [ForType]

Show ForType

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> ForType -> ShowS

show :: ForType -> String

showList :: [ForType] -> ShowS

Eq ForType

Defined in Language.Halide.Schedule

Methods

(==) :: ForType -> ForType -> Bool

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

data SplitContents

Constructors

SplitContents

Fields

• splitOld :: !Text
• splitOuter :: !Text
• splitInner :: !Text
• splitFactor :: !(Expr Int32)
• splitExact :: !Bool
• splitTail :: !TailStrategy

Instances

Show SplitContents

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> SplitContents -> ShowS

show :: SplitContents -> String

showList :: [SplitContents] -> ShowS

data FuseContents

Constructors

FuseContents

Fields

• fuseOuter :: !Text
• fuseInner :: !Text
• fuseNew :: !Text

Instances

Show FuseContents

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> FuseContents -> ShowS

show :: FuseContents -> String

showList :: [FuseContents] -> ShowS

Eq FuseContents

Defined in Language.Halide.Schedule

Methods

(==) :: FuseContents -> FuseContents -> Bool

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

data Split

Constructors

SplitVar !SplitContents

FuseVars !FuseContents

Instances

Storable Split

Defined in Language.Halide.Schedule

Methods

sizeOf :: Split -> Int

alignment :: Split -> Int

peekElemOff :: Ptr Split -> Int -> IO Split

pokeElemOff :: Ptr Split -> Int -> Split -> IO ()

peekByteOff :: Ptr b -> Int -> IO Split

pokeByteOff :: Ptr b -> Int -> Split -> IO ()

peek :: Ptr Split -> IO Split

poke :: Ptr Split -> Split -> IO ()

Show Split

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> Split -> ShowS

show :: Split -> String

showList :: [Split] -> ShowS

data Bound

Constructors

Bound

Fields

• boundVar :: !Text
• boundMin :: !(Maybe (Expr Int32))
• boundExtent :: !(Expr Int32)
• boundModulus :: !(Maybe (Expr Int32))
• boundRemainder :: !(Maybe (Expr Int32))

Instances

Show Bound

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> Bound -> ShowS

show :: Bound -> String

showList :: [Bound] -> ShowS

data StorageDim

Constructors

StorageDim

Fields

• storageVar :: !Text
• storageAlignment :: !(Maybe (Expr Int32))
• storageBound :: !(Maybe (Expr Int32))
• storageFold :: !(Maybe (Expr Int32, Bool))

Instances

Show StorageDim

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> StorageDim -> ShowS

show :: StorageDim -> String

showList :: [StorageDim] -> ShowS

data FusedPair

Constructors

FusedPair !Text !(Text, Int) !(Text, Int)

Instances

Storable FusedPair

Defined in Language.Halide.Schedule

Methods

sizeOf :: FusedPair -> Int

alignment :: FusedPair -> Int

peekElemOff :: Ptr FusedPair -> Int -> IO FusedPair

pokeElemOff :: Ptr FusedPair -> Int -> FusedPair -> IO ()

peekByteOff :: Ptr b -> Int -> IO FusedPair

pokeByteOff :: Ptr b -> Int -> FusedPair -> IO ()

peek :: Ptr FusedPair -> IO FusedPair

poke :: Ptr FusedPair -> FusedPair -> IO ()

Show FusedPair

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> FusedPair -> ShowS

show :: FusedPair -> String

showList :: [FusedPair] -> ShowS

Eq FusedPair

Defined in Language.Halide.Schedule

Methods

(==) :: FusedPair -> FusedPair -> Bool

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

data FuseLoopLevel

Constructors

FuseLoopLevel !SomeLoopLevel

Instances

Show FuseLoopLevel

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> FuseLoopLevel -> ShowS

show :: FuseLoopLevel -> String

showList :: [FuseLoopLevel] -> ShowS

Eq FuseLoopLevel

Defined in Language.Halide.Schedule

Methods

(==) :: FuseLoopLevel -> FuseLoopLevel -> Bool

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

data StageSchedule

Constructors

StageSchedule

Fields

• rvars :: ![ReductionVariable]
• splits :: ![Split]
• dims :: ![Dim]
• prefetches :: ![PrefetchDirective]
• fuseLevel :: !FuseLoopLevel
• fusedPairs :: ![FusedPair]
• allowRaceConditions :: !Bool
• atomic :: !Bool
• overrideAtomicAssociativityTest :: !Bool

Instances

Show StageSchedule

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> StageSchedule -> ShowS

show :: StageSchedule -> String

showList :: [StageSchedule] -> ShowS

data ReductionVariable

Constructors

ReductionVariable

Fields

• varName :: !Text
• minExpr :: !(Expr Int32)
• extentExpr :: !(Expr Int32)

Instances

Storable ReductionVariable

Defined in Language.Halide.Schedule

Methods

sizeOf :: ReductionVariable -> Int

alignment :: ReductionVariable -> Int

peekElemOff :: Ptr ReductionVariable -> Int -> IO ReductionVariable

pokeElemOff :: Ptr ReductionVariable -> Int -> ReductionVariable -> IO ()

peekByteOff :: Ptr b -> Int -> IO ReductionVariable

pokeByteOff :: Ptr b -> Int -> ReductionVariable -> IO ()

peek :: Ptr ReductionVariable -> IO ReductionVariable

poke :: Ptr ReductionVariable -> ReductionVariable -> IO ()

Show ReductionVariable

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> ReductionVariable -> ShowS

show :: ReductionVariable -> String

showList :: [ReductionVariable] -> ShowS

data PrefetchDirective

Constructors

PrefetchDirective

Fields

• prefetchFunc :: !Text
• prefetchAt :: !Text
• prefetchFrom :: !Text
• prefetchOffset :: !(Expr Int32)
• prefetchStrategy :: !PrefetchBoundStrategy
• prefetchParameter :: !(Maybe (ForeignPtr CxxParameter))

Instances

Storable PrefetchDirective

Defined in Language.Halide.Schedule

Methods

sizeOf :: PrefetchDirective -> Int

alignment :: PrefetchDirective -> Int

peekElemOff :: Ptr PrefetchDirective -> Int -> IO PrefetchDirective

pokeElemOff :: Ptr PrefetchDirective -> Int -> PrefetchDirective -> IO ()

peekByteOff :: Ptr b -> Int -> IO PrefetchDirective

pokeByteOff :: Ptr b -> Int -> PrefetchDirective -> IO ()

peek :: Ptr PrefetchDirective -> IO PrefetchDirective

poke :: Ptr PrefetchDirective -> PrefetchDirective -> IO ()

Show PrefetchDirective

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> PrefetchDirective -> ShowS

show :: PrefetchDirective -> String

showList :: [PrefetchDirective] -> ShowS

getStageSchedule :: Stage n a -> IO StageSchedule

data AutoScheduler

Constructors

Adams2019

Li2018

Mullapudi2016

Instances

Show AutoScheduler

Defined in Language.Halide.Schedule

Methods

showsPrec :: Int -> AutoScheduler -> ShowS

show :: AutoScheduler -> String

showList :: [AutoScheduler] -> ShowS

Eq AutoScheduler

Defined in Language.Halide.Schedule

Methods

(==) :: AutoScheduler -> AutoScheduler -> Bool

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

loadAutoScheduler :: AutoScheduler -> IO ()

applyAutoScheduler :: KnownNat n => AutoScheduler -> Target -> Func t n a -> IO Text

getHalideLibraryPath :: IO (Maybe Text)

applySplits :: KnownNat n => [Split] -> Stage n a -> IO ()

applyDims :: KnownNat n => [Dim] -> Stage n a -> IO ()

applySchedule :: KnownNat n => StageSchedule -> Stage n a -> IO ()

type family FunctionArguments (f :: Type) :: [Type] where ...

Return the list of arguments to of a function type.

Equations

FunctionArguments (a -> b) = a ': FunctionArguments b

FunctionArguments a = '[]

type family FunctionReturn (f :: Type) :: Type where ...

Get the return type of a function.

Equations

FunctionReturn (a -> b) = FunctionReturn b

FunctionReturn a = a

class Curry (args :: [Type]) (r :: Type) (f :: Type) | args r -> f where

A helper typeclass to convert a function that takes Arguments as input into a normal curried function. This is the inverse of UnCurry.

For instance, if we have a function f :: Arguments '[Int, Float] -> Double, then it will be converted to f' :: Int -> Float -> Double.

Methods

curryG :: (Arguments args -> r) -> f

Instances

Curry ('[] :: [Type]) r r

Defined in Language.Halide.Type

Methods

curryG :: (Arguments '[] -> r) -> r

Curry args r f => Curry (a ': args) r (a -> f)

Defined in Language.Halide.Type

Methods

curryG :: (Arguments (a ': args) -> r) -> a -> f

class UnCurry (f :: Type) (args :: [Type]) (r :: Type) | args r -> f, args f -> r where

A helper typeclass to convert a normal curried function to a function that takes Arguments as input.

For instance, if we have a function f :: Int -> Float -> Double, then it will be converted to f' :: Arguments '[Int, Float] -> Double.

Methods

uncurryG :: f -> Arguments args -> r

Instances

(FunctionArguments f ~ ('[] :: [Type]), FunctionReturn f ~ r, f ~ r) => UnCurry f ('[] :: [Type]) r

Defined in Language.Halide.Type

Methods

uncurryG :: f -> Arguments '[] -> r

UnCurry f args r => UnCurry (a -> f) (a ': args) r

Defined in Language.Halide.Type

Methods

uncurryG :: (a -> f) -> Arguments (a ': args) -> r

type family LoweredSignature f where ...

Equations

LoweredSignature (Expr a -> r) = a -> LoweredSignature r

LoweredSignature (Func t n (Expr a) -> r) = Ptr (HalideBuffer n a) -> LoweredSignature r

LoweredSignature (IO (Func t n (Expr a))) = Ptr (HalideBuffer n a) -> IO ()

LoweredSignature (IO (Func t n (Expr a1, Expr a2))) = Ptr (HalideBuffer n a1) -> Ptr (HalideBuffer n a2) -> IO ()

inline-c helpers

importHalide :: DecsQ

One stop function to include all the neccessary machinery to call Halide functions via inline-c.

Put importHalide somewhere at the beginning of the file and enjoy using the C++ interface of Halide via inline-c quasiquotes.

testWriteToStderr :: IO ()

data CxxExpr

Haskell counterpart of Halide::Expr.

data CxxVar

Haskell counterpart of Halide::Var.

data CxxRVar

Haskell counterpart of Halide::RVar.

data CxxParameter

Haskell counterpart of Halide::Internal::Parameter.

data CxxFunc

Haskell counterpart of Halide::Func.

data CxxImageParam

Haskell counterpart of Halide::ImageParam.

data CxxStage

Haskell counterpart of Halide::Stage.

data CxxDimension

Haskell counterpart of Halide::Internal::Dimension.

data CxxTarget

Haskell counterpart of Halide::Target.

data CxxLoopLevel

Haskell counterpart of Halide::LoopLevel

Convenience re-exports

data Int32

32-bit signed integer type

Instances

Storable Int32

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Int32 -> Int

alignment :: Int32 -> Int

peekElemOff :: Ptr Int32 -> Int -> IO Int32

pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Int32

pokeByteOff :: Ptr b -> Int -> Int32 -> IO ()

peek :: Ptr Int32 -> IO Int32

poke :: Ptr Int32 -> Int32 -> IO ()

Bits Int32

Since: base-2.1

Defined in GHC.Int

Methods

(.&.) :: Int32 -> Int32 -> Int32

(.|.) :: Int32 -> Int32 -> Int32

xor :: Int32 -> Int32 -> Int32

complement :: Int32 -> Int32

shift :: Int32 -> Int -> Int32

rotate :: Int32 -> Int -> Int32

zeroBits :: Int32

bit :: Int -> Int32

setBit :: Int32 -> Int -> Int32

clearBit :: Int32 -> Int -> Int32

complementBit :: Int32 -> Int -> Int32

testBit :: Int32 -> Int -> Bool

bitSizeMaybe :: Int32 -> Maybe Int

bitSize :: Int32 -> Int

isSigned :: Int32 -> Bool

shiftL :: Int32 -> Int -> Int32

unsafeShiftL :: Int32 -> Int -> Int32

shiftR :: Int32 -> Int -> Int32

unsafeShiftR :: Int32 -> Int -> Int32

rotateL :: Int32 -> Int -> Int32

rotateR :: Int32 -> Int -> Int32

popCount :: Int32 -> Int

FiniteBits Int32

Since: base-4.6.0.0

Defined in GHC.Int

Methods

finiteBitSize :: Int32 -> Int

countLeadingZeros :: Int32 -> Int

countTrailingZeros :: Int32 -> Int

Bounded Int32

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int32

maxBound :: Int32

Enum Int32

Since: base-2.1

Defined in GHC.Int

Methods

succ :: Int32 -> Int32

pred :: Int32 -> Int32

toEnum :: Int -> Int32

fromEnum :: Int32 -> Int

enumFrom :: Int32 -> [Int32]

enumFromThen :: Int32 -> Int32 -> [Int32]

enumFromTo :: Int32 -> Int32 -> [Int32]

enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32]

Ix Int32

Since: base-2.1

Defined in GHC.Int

Methods

range :: (Int32, Int32) -> [Int32]

index :: (Int32, Int32) -> Int32 -> Int

unsafeIndex :: (Int32, Int32) -> Int32 -> Int

inRange :: (Int32, Int32) -> Int32 -> Bool

rangeSize :: (Int32, Int32) -> Int

unsafeRangeSize :: (Int32, Int32) -> Int

Num Int32

Since: base-2.1

Defined in GHC.Int

Methods

(+) :: Int32 -> Int32 -> Int32

(-) :: Int32 -> Int32 -> Int32

(*) :: Int32 -> Int32 -> Int32

negate :: Int32 -> Int32

abs :: Int32 -> Int32

signum :: Int32 -> Int32

fromInteger :: Integer -> Int32

Read Int32

Since: base-2.1

Defined in GHC.Int

Methods

readsPrec :: Int -> ReadS Int32

readList :: ReadS [Int32]

readPrec :: ReadPrec Int32

readListPrec :: ReadPrec [Int32]

Integral Int32

Since: base-2.1

Defined in GHC.Int

Methods

quot :: Int32 -> Int32 -> Int32

rem :: Int32 -> Int32 -> Int32

div :: Int32 -> Int32 -> Int32

mod :: Int32 -> Int32 -> Int32

quotRem :: Int32 -> Int32 -> (Int32, Int32)

divMod :: Int32 -> Int32 -> (Int32, Int32)

toInteger :: Int32 -> Integer

Real Int32

Since: base-2.1

Defined in GHC.Int

Methods

toRational :: Int32 -> Rational

Show Int32

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int32 -> ShowS

show :: Int32 -> String

showList :: [Int32] -> ShowS

Eq Int32

Since: base-2.1

Defined in GHC.Int

Methods

(==) :: Int32 -> Int32 -> Bool

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

Ord Int32

Since: base-2.1

Defined in GHC.Int

Methods

compare :: Int32 -> Int32 -> Ordering

(<) :: Int32 -> Int32 -> Bool

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

(>) :: Int32 -> Int32 -> Bool

(>=) :: Int32 -> Int32 -> Bool

max :: Int32 -> Int32 -> Int32

min :: Int32 -> Int32 -> Int32

IsHalideType Int32

Defined in Language.Halide.Expr

Methods

halideTypeFor :: proxy Int32 -> HalideType

toCxxExpr :: Int32 -> IO (ForeignPtr CxxExpr)

Hashable Int32

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Int32 -> Int

hash :: Int32 -> Int

Prim Int32

Defined in Data.Primitive.Types

Methods

sizeOf# :: Int32 -> Int#

alignment# :: Int32 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int32

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32 #)

writeByteArray# :: MutableByteArray# s -> Int# -> Int32 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int32 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int32

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int32 #)

writeOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Int32 -> State# s -> State# s

Uniform Int32

Defined in System.Random.Internal

Methods

uniformM :: StatefulGen g m => g -> m Int32

UniformRange Int32

Defined in System.Random.Internal

Methods

uniformRM :: StatefulGen g m => (Int32, Int32) -> g -> m Int32

Lift Int32

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Int32 -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Int32 -> Code m Int32

HasField "extent" Dimension (Expr Int32)

Defined in Language.Halide.Dimension

Methods

getField :: Dimension -> Expr Int32

HasField "max" Dimension (Expr Int32)

Defined in Language.Halide.Dimension

Methods

getField :: Dimension -> Expr Int32

HasField "min" Dimension (Expr Int32)

Defined in Language.Halide.Dimension

Methods

getField :: Dimension -> Expr Int32

HasField "stride" Dimension (Expr Int32)

Defined in Language.Halide.Dimension

Methods

getField :: Dimension -> Expr Int32

HasField "var" (LoopLevel 'LockedTy) (Expr Int32)

Defined in Language.Halide.LoopLevel

Methods

getField :: LoopLevel 'LockedTy -> Expr Int32

data Ptr a

A value of type Ptr a represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type a.

The type a will often be an instance of class Storable which provides the marshalling operations. However this is not essential, and you can provide your own operations to access the pointer. For example you might write small foreign functions to get or set the fields of a C struct.

Instances

Generic1 (URec (Ptr ()) :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec (Ptr ())) :: k -> Type

Methods

from1 :: forall (a :: k0). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a

to1 :: forall (a :: k0). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a

Foldable (UAddr :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UAddr m -> m

foldMap :: Monoid m => (a -> m) -> UAddr a -> m

foldMap' :: Monoid m => (a -> m) -> UAddr a -> m

foldr :: (a -> b -> b) -> b -> UAddr a -> b

foldr' :: (a -> b -> b) -> b -> UAddr a -> b

foldl :: (b -> a -> b) -> b -> UAddr a -> b

foldl' :: (b -> a -> b) -> b -> UAddr a -> b

foldr1 :: (a -> a -> a) -> UAddr a -> a

foldl1 :: (a -> a -> a) -> UAddr a -> a

toList :: UAddr a -> [a]

null :: UAddr a -> Bool

length :: UAddr a -> Int

elem :: Eq a => a -> UAddr a -> Bool

maximum :: Ord a => UAddr a -> a

minimum :: Ord a => UAddr a -> a

sum :: Num a => UAddr a -> a

product :: Num a => UAddr a -> a

Traversable (UAddr :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b)

sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a)

mapM :: Monad m => (a -> m b) -> UAddr a -> m (UAddr b)

sequence :: Monad m => UAddr (m a) -> m (UAddr a)

Storable (Ptr a)

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Ptr a -> Int

alignment :: Ptr a -> Int

peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a)

pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Ptr a)

pokeByteOff :: Ptr b -> Int -> Ptr a -> IO ()

peek :: Ptr (Ptr a) -> IO (Ptr a)

poke :: Ptr (Ptr a) -> Ptr a -> IO ()

Show (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

Eq (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

(==) :: Ptr a -> Ptr a -> Bool

(/=) :: Ptr a -> Ptr a -> Bool

Ord (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

compare :: Ptr a -> Ptr a -> Ordering

(<) :: Ptr a -> Ptr a -> Bool

(<=) :: Ptr a -> Ptr a -> Bool

(>) :: Ptr a -> Ptr a -> Bool

(>=) :: Ptr a -> Ptr a -> Bool

max :: Ptr a -> Ptr a -> Ptr a

min :: Ptr a -> Ptr a -> Ptr a

Hashable (Ptr a)

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Ptr a -> Int

hash :: Ptr a -> Int

Prim (Ptr a)

Defined in Data.Primitive.Types

Methods

sizeOf# :: Ptr a -> Int#

alignment# :: Ptr a -> Int#

indexByteArray# :: ByteArray# -> Int# -> Ptr a

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Ptr a #)

writeByteArray# :: MutableByteArray# s -> Int# -> Ptr a -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Ptr a -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Ptr a

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Ptr a #)

writeOffAddr# :: Addr# -> Int# -> Ptr a -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Ptr a -> State# s -> State# s

Functor (URec (Ptr ()) :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a

Generic (URec (Ptr ()) p)

Defined in GHC.Generics

Associated Types

type Rep (URec (Ptr ()) p) :: Type -> Type

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p

Eq (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

Ord (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering

(<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

data URec (Ptr ()) (p :: k)

Used for marking occurrences of Addr#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec (Ptr ()) (p :: k) = UAddr {

• uAddr# :: Addr#

}

type Rep1 (URec (Ptr ()) :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep1 (URec (Ptr ()) :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: k -> Type)))

type Rep (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep (URec (Ptr ()) p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: Type -> Type)))

class KnownNat (n :: Nat)

This class gives the integer associated with a type-level natural. There are instances of the class for every concrete literal: 0, 1, 2, etc.

Since: base-4.7.0.0

Minimal complete definition

natSing