Language.Atom

Atom is a Haskell DSL for designing hard realtime embedded software.

Based on guarded atomic actions (similar to STM), Atom enables highly concurrent programming without the need for mutex locking. In addition, Atom performs compile-time task scheduling and generates code with deterministic execution time and constant memory use, simplifying the process of timing verification and memory consumption in hard realtime applications. Without mutex locking and run-time task scheduling, Atom eliminates the need and overhead of RTOSes for many embedded applications.

Code

Module: Language.Atom.Code

data Config

C code configuration parameters.

Constructors

Config

Fields

cFuncName :: String

Alternative primary function name. If this is empty, then it will default to the name passed to compile.

cStateName :: String

Name of state variable structure. Default: state

cCode :: [Name] -> [Name] -> [(Name, Type)] -> (String, String)

Custom C code to insert above and below the functions, given assertion names, coverage names, and probe names and types.

hCode :: [Name] -> [Name] -> [(Name, Type)] -> (String, String)

Custom C code to insert above and below the state definition in the header file, given assertion names, coverage names, and probe names and types.

cRuleCoverage :: Bool

Enable rule coverage tracking.

cAssert :: Bool

Enable assertions and functional coverage.

cAssertName :: String

Name of assertion function. Prototype: void assert(int, bool, uint64_t);

cCoverName :: String

Name of coverage function. Prototype: void cover(int, bool, uint64_t);

hardwareClock :: Maybe Clock

Hardware counter to schedule rules, or Nothing (the default).

defaults :: Config

Default C code configuration parameters (default function name, no pre/post code, ANSI C types).

data Clock

Data associated with sampling a hardware clock. For the clock to work correctly, you MUST assign __global_clock the current time (according to clockName) the first time you enter the main Atom-generated function calling your rules.

Constructors

Clock

Fields

clockName :: String

C function to sample the clock. The function is assumed to have the prototype: clockType clockName(void).

clockType :: Type

Clock type. Assumed to be one of Word8, Word16, Word32, or Word64. It is permissible for the clock to roll over.

delta :: Integer

Number of ticks in a phase. Must be greater than 0.

delay :: String

C function to delay/sleep. The function is assumed to have the prototype: void delay(clockType i), where i is the duration of delay/sleep.

err :: Maybe String

Nothing, or a user-defined error-reporting function if the period duration is violated, e.g., the execution time was greater than delta. Assumed to have prototype: void err(void).

defaultClock :: Clock

Default hardware clock parameters (name "clk", Word64, delta 1, delay function is "delay", no error function).

writeC :: Name -> Config -> StateHierarchy -> [Rule] -> Schedule -> [Name] -> [Name] -> [(Name, Type)] -> IO RuleCoverage

cType :: Type -> String

C99 type naming rules.

type RuleCoverage = [(Name, Int, Int)]

Compilation

Module: Language.Atom.Compile

compile :: Name -> Config -> Atom () -> IO (Schedule, RuleCoverage, [Name], [Name], [(Name, Type)])

Compiles an atom description to C.

reportSchedule :: Schedule -> String

Generate a rule scheduling report for the given schedule.

type Schedule = (UeMap, [(Int, Int, [Rule])])

Schedule expressed as a UeMap and a list of (period, phase, rules).

Common

Module: Language.Atom.Common

data Timer

A Timer.

timer :: Name -> Atom Timer

Creates a new timer.

startTimer

Arguments

:: Timer

Timer to start

-> E Word64

Number of clock ticks the timer shall run

-> Atom ()

Starts a Timer. A timer can be restarted at any time.

startTimerIf

Arguments

:: Timer

Timer to start conditionally

-> E Bool

Condition for starting the timer

-> E Word64

Number of ticks the timer shall run

-> Atom ()

Conditionally start a Timer.

timerDone :: Timer -> E Bool

True when a timer has completed. Note that this remains True until the timer is restarted.

oneShotRise :: E Bool -> Atom (E Bool)

One-shot on a rising transition.

oneShotFall :: E Bool -> Atom (E Bool)

One-shot on a falling transition.

debounce

Arguments

:: Name

Name of the resulting atom

-> E Word64

On time in ticks

-> E Word64

Off time in ticks

-> Bool

Initial value

-> E Bool

The boolean to debounce

-> Atom (E Bool)

Resulting debounced boolean

Debounces a boolean given an on and off time (ticks) and an initial state.

lookupTable

Arguments

:: FloatingE a

=> [(E a, E a)]

(x, y) lookup table

-> E a

Input x value

-> E a

Output y value

1-D lookup table. x values out of table range are clipped at end y values. Input table must be monotonically increasing in x.

linear

Arguments

:: FloatingE a

=> (E a, E a)

First point, (x1, y1)

-> (E a, E a)

Second point, (x2, y2)

-> E a

Input x value

-> E a

Interpolated/extrapolated y value

Linear extrapolation and interpolation on a line with 2 points. The two x points must be different to prevent a divide-by-zero.

hysteresis

Arguments

:: OrdE a

=> E a

min

-> E a

max

-> E a

Input

-> Atom (E Bool)

Hysteresis returns True when the input exceeds max and False when the input is less than min. The state is held when the input is between min and max.

data Channel a

A channel is a uni-directional communication link that ensures one read for every write.

Constructors

Channel a (V Bool)

channel :: a -> Atom (Channel a)

Creates a new channel, with a given name and data.

writeChannel :: Channel a -> Atom ()

Write data to a Channel. A write will only suceed if the Channel is empty.

readChannel :: Channel a -> Atom a

Read data from a Channel. A read will only suceed if the Channel has data to be read.

Signal fading

Module: Language.Atom.Common.Fader

data Fader

Fader object.

data FaderInit

Fader initalization.

Constructors

OnA

Start at signal A

OnB

Start at signal B

OnCenter

Start at average of A and B

fader

Arguments

:: Name

Name

-> Double

Fade rate

-> FaderInit

Initialization

-> E Double

Signal A

-> E Double

Signal B

-> Atom (Fader, E Double)

Fader construction

fadeToA :: Fader -> Atom ()

Fade to signal A.

fadeToB :: Fader -> Atom ()

Fade to signal B.

fadeToCenter :: Fader -> Atom ()

Fade to center, i.e. average of signal A and B.

Thresholds

Module: Language.Atom.Common.Threshold

boolThreshold :: Name -> Int32 -> Bool -> E Bool -> Atom (E Bool)

Boolean thresholding over time. Output is set when internal counter hits limit, and cleared when counter is 0.

doubleThreshold :: Name -> Double -> E Double -> Atom (E Bool)

Integrating threshold. Output is set with integral reaches limit, and cleared when integral reaches 0.

Valid/Invalid data

Module: Language.Atom.Common.ValidData

data ValidData a

ValidData captures the data and its validity condition. ValidData is abstract to prevent rules from using invalid data.

validData :: a -> E Bool -> ValidData a

Create ValidData given the data and validity condition.

getValidData :: ValidData a -> Atom a

Get a valid data. Action is disabled if data is invalid.

whenValid :: ValidData a -> Atom ()

Action enabled if ValidData is valid.

whenInvalid :: ValidData a -> Atom ()

Action enabled if ValidData is not valid.

Language & EDSL

Module: Language.Atom.Language

type Atom = Atom

The Atom monad captures variable and transition rule declarations.

atom :: Name -> Atom a -> Atom a

Creates a hierarchical node, where each node could be an atomic rule.

period :: Int -> Atom a -> Atom a

Defines the period of execution of sub-rules as a factor of the base rate of the system. Rule period is bound by the closest period assertion. For example: > period 10 $ period 2 a -- Rules in a have a period of 2, not 10.

getPeriod :: Atom Int

Returns the execution period of the current scope.

phase :: Int -> Atom a -> Atom a

Defines the earliest phase within the period at which the rule should execute; the scheduler attempt to find an optimal phase from 0 <= n < period (thus, the phase must be at least zero and less than the current period.).

exactPhase :: Int -> Atom a -> Atom a

Ensures an atom is scheduled only at phase n.

getPhase :: Atom Int

Returns the phase of the current scope.

cond :: E Bool -> Atom ()

Adds an enabling condition to an atom subtree of rules. This condition must be true before any rules in hierarchy are allowed to execute.

class Expr a => Assign a where

Minimal complete definition

Nothing

Methods

(<==) :: V a -> E a -> Atom () infixr 1

Assign an E to a V.

Instances

Assign Bool

Assign Double

Assign Float

Assign Int8

Assign Int16

Assign Int32

Assign Int64

Assign Word8

Assign Word16

Assign Word32

Assign Word64

incr :: (Assign a, NumE a) => V a -> Atom ()

Increments a NumE V.

decr :: (Assign a, NumE a) => V a -> Atom ()

Decrements a NumE V.

var :: Expr a => Name -> a -> Atom (V a)

Generic local variable declaration.

var' :: Name -> Type -> V a

Generic external variable declaration.

array :: Expr a => Name -> [a] -> Atom (A a)

Generic array declaration.

array' :: Expr a => Name -> Type -> A a

Generic external array declaration.

bool :: Name -> Bool -> Atom (V Bool)

Local boolean variable declaration.

bool' :: Name -> V Bool

External boolean variable declaration.

int8 :: Name -> Int8 -> Atom (V Int8)

Local int8 variable declaration.

int8' :: Name -> V Int8

External int8 variable declaration.

int16 :: Name -> Int16 -> Atom (V Int16)

Local int16 variable declaration.

int16' :: Name -> V Int16

External int16 variable declaration.

int32 :: Name -> Int32 -> Atom (V Int32)

Local int32 variable declaration.

int32' :: Name -> V Int32

External int32 variable declaration.

int64 :: Name -> Int64 -> Atom (V Int64)

Local int64 variable declaration.

int64' :: Name -> V Int64

External int64 variable declaration.

word8 :: Name -> Word8 -> Atom (V Word8)

Local word8 variable declaration.

word8' :: Name -> V Word8

External word8 variable declaration.

word16 :: Name -> Word16 -> Atom (V Word16)

Local word16 variable declaration.

word16' :: Name -> V Word16

External word16 variable declaration.

word32 :: Name -> Word32 -> Atom (V Word32)

Local word32 variable declaration.

word32' :: Name -> V Word32

External word32 variable declaration.

word64 :: Name -> Word64 -> Atom (V Word64)

Local word64 variable declaration.

word64' :: Name -> V Word64

External word64 variable declaration.

float :: Name -> Float -> Atom (V Float)

Local float variable declaration.

float' :: Name -> V Float

External float variable declaration.

double :: Name -> Double -> Atom (V Double)

Local double variable declaration.

double' :: Name -> V Double

External double variable declaration.

action

Arguments

:: ([String] -> String)

A function which receives a list of C parameters, and returns C code that should be executed.

-> [UE]

A list of expressions; the supplied functions receive parameters which correspond to these expressions.

-> Atom ()

Declares an action, which executes C code that is optionally passed some parameters.

call

Arguments

:: Name

Function f

-> Atom ()

Calls an external C function of type 'void f(void)'.

probe

Arguments

:: Expr a

=> Name

Human-readable probe name

-> E a

Expression to inspect

-> Atom ()

Declares a probe. A probe allows inspecting any expression, remotely to its context, at any desired rate.

probes :: Atom [(String, UE)]

Fetches all declared probes to current design point. The list contained therein is (probe name, untyped expression). See printProbe.

assert :: Name -> E Bool -> Atom ()

An assertions checks that an 'E Bool' is true. Assertions are checked between the execution of every rule. Parent enabling conditions can disable assertions, but period and phase constraints do not. Assertion names should be globally unique.

cover :: Name -> E Bool -> Atom ()

A functional coverage point tracks if an event has occured (true). Coverage points are checked at the same time as assertions. Coverage names should be globally unique.

assertImply :: Name -> E Bool -> E Bool -> Atom ()

Implication assertions. Creates an implicit coverage point for the precondition.

type Name = String

A name.

liftIO :: MonadIO m => forall a. IO a -> m a

Lift a computation from the IO monad.

path :: Atom String

Returns the current atom hierarchical path.

clock :: E Word64

Reference to the 64-bit free running clock.

nextCoverage :: Atom (E Word32, E Word32)

Rule coverage information. (current coverage index, coverage data)

Expressions

Module: Language.Atom.Expressions

data E a where

A typed expression.

Constructors

VRef :: V a -> E a

Const :: a -> E a

Cast :: (NumE a, NumE b) => E a -> E b

Add :: NumE a => E a -> E a -> E a

Sub :: NumE a => E a -> E a -> E a

Mul :: NumE a => E a -> E a -> E a

Div :: NumE a => E a -> E a -> E a

Mod :: IntegralE a => E a -> E a -> E a

Not :: E Bool -> E Bool

And :: E Bool -> E Bool -> E Bool

BWNot :: IntegralE a => E a -> E a

BWAnd :: IntegralE a => E a -> E a -> E a

BWOr :: IntegralE a => E a -> E a -> E a

BWXor :: IntegralE a => E a -> E a -> E a

BWShiftL :: (IntegralE a, IntegralE b) => E a -> E b -> E a

BWShiftR :: (IntegralE a, IntegralE b) => E a -> E b -> E a

Eq :: EqE a => E a -> E a -> E Bool

Lt :: OrdE a => E a -> E a -> E Bool

Mux :: E Bool -> E a -> E a -> E a

F2B :: E Float -> E Word32

D2B :: E Double -> E Word64

B2F :: E Word32 -> E Float

B2D :: E Word64 -> E Double

Retype :: UE -> E a

Pi :: FloatingE a => E a

Exp :: FloatingE a => E a -> E a

Log :: FloatingE a => E a -> E a

Sqrt :: FloatingE a => E a -> E a

Pow :: FloatingE a => E a -> E a -> E a

Sin :: FloatingE a => E a -> E a

Asin :: FloatingE a => E a -> E a

Cos :: FloatingE a => E a -> E a

Acos :: FloatingE a => E a -> E a

Sinh :: FloatingE a => E a -> E a

Cosh :: FloatingE a => E a -> E a

Asinh :: FloatingE a => E a -> E a

Acosh :: FloatingE a => E a -> E a

Atan :: FloatingE a => E a -> E a

Atanh :: FloatingE a => E a -> E a

Instances

Expr a => Eq (E a)

(Num a, Fractional a, Floating a, FloatingE a) => Floating (E a)

(OrdE a, NumE a, Num a, Fractional a) => Fractional (E a)

(Num a, NumE a, OrdE a) => Num (E a)

Show (E a)

(Expr a, OrdE a, EqE a, IntegralE a, Bits a) => Bits (E a)

Expr a => TypeOf (E a)

Expr a => Width (E a)

data V a

Variables updated by state transition rules.

Constructors

V UV

Instances

Eq (V a)

TypeOf (V a)

Expr a => Width (V a)

data UE

An untyped term.

Constructors

UVRef UV

UConst Const

UCast Type UE

UAdd UE UE

USub UE UE

UMul UE UE

UDiv UE UE

UMod UE UE

UNot UE

UAnd [UE]

UBWNot UE

UBWAnd UE UE

UBWOr UE UE

UBWXor UE UE

UBWShiftL UE UE

UBWShiftR UE UE

UEq UE UE

ULt UE UE

UMux UE UE UE

UF2B UE

UD2B UE

UB2F UE

UB2D UE

UPi

UExp UE

ULog UE

USqrt UE

UPow UE UE

USin UE

UAsin UE

UCos UE

UAcos UE

USinh UE

UCosh UE

UAsinh UE

UAcosh UE

UAtan UE

UAtanh UE

Instances

Eq UE

Data UE

Ord UE

Show UE

TypeOf UE

Width UE

Typeable * UE

data UV

Untyped variables.

Constructors

UV Int String Const

UVArray UA UE

UVExtern String Type

Instances

Eq UV

Data UV

Ord UV

Show UV

TypeOf UV

Width UV

Typeable * UV

data A a

A typed array.

Constructors

A UA

Instances

Eq (A a)

TypeOf (A a)

data UA

An untyped array.

Constructors

UA Int String [Const]

UAExtern String Type

Instances

Eq UA

Data UA

Ord UA

Show UA

TypeOf UA

Typeable * UA

class Eq a => Expr a where

Typed expression:

Methods

eType :: E a -> Type

constant :: a -> Const

expression :: E a -> Expression

variable :: V a -> Variable

rawBits :: E a -> E Word64

Instances

Expr Bool

Expr Double

Expr Float

Expr Int8

Expr Int16

Expr Int32

Expr Int64

Expr Word8

Expr Word16

Expr Word32

Expr Word64

data Expression

Typed expression

Constructors

EBool (E Bool)

EInt8 (E Int8)

EInt16 (E Int16)

EInt32 (E Int32)

EInt64 (E Int64)

EWord8 (E Word8)

EWord16 (E Word16)

EWord32 (E Word32)

EWord64 (E Word64)

EFloat (E Float)

EDouble (E Double)

data Variable

Typed variable

Constructors

VBool (V Bool)

VInt8 (V Int8)

VInt16 (V Int16)

VInt32 (V Int32)

VInt64 (V Int64)

VWord8 (V Word8)

VWord16 (V Word16)

VWord32 (V Word32)

VWord64 (V Word64)

VFloat (V Float)

VDouble (V Double)

Instances

Eq Variable

data Type

The type of a E.

Constructors

Bool

Int8

Int16

Int32

Int64

Word8

Word16

Word32

Word64

Float

Double

Instances

Enum Type

Eq Type

Data Type

Ord Type

Read Type

Show Type

Width Type

Typeable * Type

data Const

Typed constant

Constructors

CBool Bool

CInt8 Int8

CInt16 Int16

CInt32 Int32

CInt64 Int64

CWord8 Word8

CWord16 Word16

CWord32 Word32

CWord64 Word64

CFloat Float

CDouble Double

Instances

Eq Const

Data Const

Ord Const

Show Const

TypeOf Const

Width Const

Typeable * Const

class Width a where

Types with a defined width in bits

Methods

width :: a -> Int

The width of a type, in number of bits

Instances

Width UE

Width UV

Width Const

Width Type

Expr a => Width (E a)

Expr a => Width (V a)

class TypeOf a where

Types which have a defined Type

Methods

typeOf :: a -> Type

The corresponding Type of the given object

Instances

TypeOf UE

TypeOf UA

TypeOf UV

TypeOf Const

Expr a => TypeOf (E a)

TypeOf (A a)

TypeOf (V a)

bytes :: Width a => a -> Int

The number of bytes that an object occupies

ue :: Expr a => E a -> UE

Converts an typed expression (E a) to an untyped expression (UE).

uv :: V a -> UV

Convert a typed variable to an untyped one

class (Num a, Expr a, EqE a, OrdE a) => NumE a

Expression of numerical type

Instances

NumE Double

NumE Float

NumE Int8

NumE Int16

NumE Int32

NumE Int64

NumE Word8

NumE Word16

NumE Word32

NumE Word64

class (NumE a, Integral a) => IntegralE a

Expression of integral type

Minimal complete definition

signed

Instances

IntegralE Int8

IntegralE Int16

IntegralE Int32

IntegralE Int64

IntegralE Word8

IntegralE Word16

IntegralE Word32

IntegralE Word64

class (RealFloat a, NumE a, OrdE a) => FloatingE a

Floating-point typed expression

Instances

FloatingE Double

FloatingE Float

class (Eq a, Expr a) => EqE a

Expressions which can be compared for equality

Instances

EqE Bool

EqE Double

EqE Float

EqE Int8

EqE Int16

EqE Int32

EqE Int64

EqE Word8

EqE Word16

EqE Word32

EqE Word64

class (Eq a, Ord a, EqE a) => OrdE a

Expressions which can be ordered

Instances

OrdE Double

OrdE Float

OrdE Int8

OrdE Int16

OrdE Int32

OrdE Int64

OrdE Word8

OrdE Word16

OrdE Word32

OrdE Word64

true :: E Bool

True term.

false :: E Bool

False term.

value :: V a -> E a

Returns the value of a V.

not_ :: E Bool -> E Bool

Logical negation.

(&&.) :: E Bool -> E Bool -> E Bool infixl 3

Logical AND.

(||.) :: E Bool -> E Bool -> E Bool infixl 2

Logical OR.

and_ :: [E Bool] -> E Bool

The conjunction of a E Bool list.

or_ :: [E Bool] -> E Bool

The disjunction of a E Bool list.

any_ :: (a -> E Bool) -> [a] -> E Bool

True iff the predicate is true for any element.

all_ :: (a -> E Bool) -> [a] -> E Bool

True iff the predicate is true for all elements.

imply

Arguments

:: E Bool

a

-> E Bool

b

-> E Bool

Logical implication (if a then b).

(.&.) :: Bits a => a -> a -> a

Bitwise "and"

complement :: Bits a => a -> a

Reverse all the bits in the argument

(.|.) :: Bits a => a -> a -> a

Bitwise "or"

xor :: Bits a => a -> a -> a

Bitwise "xor"

(.<<.) :: (Bits a, IntegralE a, IntegralE n) => E a -> E n -> E a

Bitwise left-shifting.

(.>>.) :: (Bits a, IntegralE a, IntegralE n) => E a -> E n -> E a

Bitwise right-shifting.

rol :: (IntegralE a, IntegralE n, Bits a) => E a -> E n -> E a

Bitwise left-rotation.

ror :: (IntegralE a, IntegralE n, Bits a) => E a -> E n -> E a

Bitwise right-rotation.

bitSize :: Bits a => a -> Int

Return the number of bits in the type of the argument. The actual value of the argument is ignored. The function bitSize is undefined for types that do not have a fixed bitsize, like Integer.

isSigned :: Bits a => a -> Bool

Return True if the argument is a signed type. The actual value of the argument is ignored

(==.) :: EqE a => E a -> E a -> E Bool infix 4

Equal.

(/=.) :: EqE a => E a -> E a -> E Bool infix 4

Not equal.

(<.) :: OrdE a => E a -> E a -> E Bool infix 4

Less than.

(<=.) :: OrdE a => E a -> E a -> E Bool infix 4

Less than or equal.

(>.) :: OrdE a => E a -> E a -> E Bool infix 4

Greater than.

(>=.) :: OrdE a => E a -> E a -> E Bool infix 4

Greater than or equal.

min_ :: OrdE a => E a -> E a -> E a

Returns the minimum of two numbers.

minimum_ :: OrdE a => [E a] -> E a

Returns the minimum of a list of numbers.

max_ :: OrdE a => E a -> E a -> E a

Returns the maximum of two numbers.

maximum_ :: OrdE a => [E a] -> E a

Returns the maximum of a list of numbers.

limit :: OrdE a => E a -> E a -> E a -> E a

Limits between min and max.

div_ :: IntegralE a => E a -> E a -> E a

Division. If both the dividend and divisor are constants, a compile-time check is made for divide-by-zero. Otherwise, if the divisor ever evaluates to 0, a runtime exception will occur, even if the division occurs within the scope of a cond or mux that tests for 0 (because Atom generates deterministic-time code, every branch of a cond or mux is executed).

div0_ :: IntegralE a => E a -> E a -> a -> E a

Division, where the C code is instrumented with a runtime check to ensure the divisor does not equal 0. If it is equal to 0, the 3rd argument is a user-supplied non-zero divsor.

mod_ :: IntegralE a => E a -> E a -> E a

Modulo. If both the dividend and modulus are constants, a compile-time check is made for divide-by-zero. Otherwise, if the modulus ever evaluates to 0, a runtime exception will occur, even if the division occurs within the scope of a cond or mux that tests for 0 (because Atom generates deterministic-time code, every branch of a cond or mux is executed).

mod0_ :: IntegralE a => E a -> E a -> a -> E a

Modulus, where the C code is instrumented with a runtime check to ensure the modulus does not equal 0. If it is equal to 0, the 3rd argument is a user-supplied non-zero divsor.

mux :: Expr a => E Bool -> E a -> E a -> E a

Conditional expression. Note, both branches are evaluated!

mux test onTrue onFalse

(!) :: (Expr a, IntegralE b) => A a -> E b -> V a infixl 9

Array index to variable.

(!.) :: (Expr a, IntegralE b) => A a -> E b -> E a infixl 9

Array index to expression.

ubool :: Bool -> UE

Produced an untyped expression from a constant Bool

unot :: UE -> UE

Logical NOT of an untyped expression

uand :: UE -> UE -> UE

Logical AND of two untyped expressions

uor :: UE -> UE -> UE

Logical OR of two untyped expressions

ueq :: UE -> UE -> UE

Check equality on two untyped expressions

umux

Arguments

:: UE

Selector

-> UE

Input 1

-> UE

Input 2

-> UE

2-to-1 multiplexer. If selector is true, this returns input 1; if selector is false, this returns input 2.

Testing

Module: Language.Atom.Unit

data Test

Parameters for a test simulation

Constructors

Test

Fields

name :: String

Name for test (used in log file, state name, and output)

cycles :: Int

Number of simulation cycles to run

testbench :: Atom ()

Atom specification to test

modules :: [FilePath]

Other C files to build in

includes :: [FilePath]

Other C headers to include

declCode :: String

C declarations and definitions inserted prior to the main function

initCode :: String

C code executed inside the main function, prior to loopCode

loopCode :: String

C code executed inside the loop running the test

endCode :: String

C code executed after that loop, but still in main

defaultTest :: Test

Default test parameters

class Expr a => Random a where

Methods

random :: E a

Instances

Random Bool

Random Int8

Random Int16

Random Int32

Random Int64

Random Word8

Random Word16

Random Word32

Random Word64

runTests

Arguments

:: Int

Random seed

-> [IO Test]

List of tests to run

-> IO ()

Run a list of tests, output a report on test passes and coverage.

printStrLn :: String -> Atom ()

Print a string in C using printf, appending a newline.

printIntegralE

Arguments

:: IntegralE a

=> String

Prefix for printed value

-> E a

Integral value to print

-> Atom ()

Print an integral value in C using printf.

printFloatingE

Arguments

:: FloatingE a

=> String

Prefix for printed value

-> E a

Floating point value to print

-> Atom ()

Print a floating point value in C using printf.

printProbe :: (String, UE) -> Atom ()

Print the value of a probe to the console (along with its name).