Copyright	(C) 2019 Google Inc.
License	BSD2 (see the file LICENSE)
Maintainer	Christiaan Baaij <christiaan.baaij@gmail.com>
Safe Haskell	None
Language	Haskell2010

Clash.Class.AutoReg

Description

Synopsis

class NFDataX a => AutoReg a where
- autoReg :: (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> a -> Signal dom a -> Signal dom a
deriveAutoReg :: Name -> DecsQ

Documentation

class NFDataX a => AutoReg a where Source #

autoReg is a "smart" version of register. It does two things:

It splits product types over their fields. For example, given a 3-tuple, the corresponding HDL will end up with three instances of a register (or more if the three fields can be split up similarly).
Given a data type where a constructor indicates (parts) of the data will (not) be updated a given cycle, it will split the data in two parts. The first part will contain the "always interesting" parts (the constructor bits). The second holds the "potentially uninteresting" data (the rest). Both parts will be stored in separate registers. The register holding the "potentially uninteresting" part will only be enabled if the constructor bits indicate they're interesting.

The most important example of this is Maybe. Consider "Maybe Byte)"; when viewed as bits, a Nothing would look like:

>>> pack @(Maybe (Signed 16)) Nothing
0_...._...._...._....

and Just

>>> pack @(Maybe (Signed 16)) (Just 3)
1_0000_0000_0000_0011

In the first case, Nothing, we don't particularly care about updating the register holding the "Signed 16" field, as they'll be unknown anyway. We can therefore deassert its enable line.

Making Clash lay it out like this increases the chances of synthesis tools clock gating the registers, saving energy.

This version of autoReg will split the given data type up recursively. For example, given "a :: Maybe (Maybe Int, Maybe Int)", a total of five registers will be rendered. Both the "interesting" and "uninteresting" enable lines of the inner Maybe types will be controlled by the outer one, in addition to the inner parts controlling their "uninteresting" parts as described in (2).

The default implementation is just register. If you don't need or want the special features of AutoReg, you can use that by writing an empty instance.

data MyDataType = ...
instance AutoReg MyDataType

If you have a product type you can use deriveAutoReg to derive an instance.

Clash.Prelude exports an implicit version of this: autoReg

Minimal complete definition

Nothing

Methods

autoReg Source #

Arguments

:: (HasCallStack, KnownDomain dom)
=> Clock dom
-> Reset dom
-> Enable dom
-> a	Reset value
-> Signal dom a
-> Signal dom a

Instances

Instances details

AutoReg Bool Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Bool -> Signal dom Bool -> Signal dom Bool Source #
AutoReg Char Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Char -> Signal dom Char -> Signal dom Char Source #
AutoReg Double Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Double -> Signal dom Double -> Signal dom Double Source #
AutoReg Float Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Float -> Signal dom Float -> Signal dom Float Source #
AutoReg Int Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Int -> Signal dom Int -> Signal dom Int Source #
AutoReg Int8 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Int8 -> Signal dom Int8 -> Signal dom Int8 Source #
AutoReg Int16 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Int16 -> Signal dom Int16 -> Signal dom Int16 Source #
AutoReg Int32 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Int32 -> Signal dom Int32 -> Signal dom Int32 Source #
AutoReg Int64 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Int64 -> Signal dom Int64 -> Signal dom Int64 Source #
AutoReg Integer Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Integer -> Signal dom Integer -> Signal dom Integer Source #
AutoReg Word Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Word -> Signal dom Word -> Signal dom Word Source #
AutoReg Word8 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Word8 -> Signal dom Word8 -> Signal dom Word8 Source #
AutoReg Word16 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Word16 -> Signal dom Word16 -> Signal dom Word16 Source #
AutoReg Word32 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Word32 -> Signal dom Word32 -> Signal dom Word32 Source #
AutoReg Word64 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Word64 -> Signal dom Word64 -> Signal dom Word64 Source #
AutoReg () Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> () -> Signal dom () -> Signal dom () Source #
AutoReg CUShort Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> CUShort -> Signal dom CUShort -> Signal dom CUShort Source #
AutoReg Half Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Half -> Signal dom Half -> Signal dom Half Source #
AutoReg Bit Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Bit -> Signal dom Bit -> Signal dom Bit Source #
AutoReg a => AutoReg (Maybe a) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Maybe a -> Signal dom (Maybe a) -> Signal dom (Maybe a) Source #
AutoReg a => AutoReg (Ratio a) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Ratio a -> Signal dom (Ratio a) -> Signal dom (Ratio a) Source #
AutoReg a => AutoReg (Complex a) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Complex a -> Signal dom (Complex a) -> Signal dom (Complex a) Source #
AutoReg a => AutoReg (Down a) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Down a -> Signal dom (Down a) -> Signal dom (Down a) Source #
AutoReg (BitVector n) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> BitVector n -> Signal dom (BitVector n) -> Signal dom (BitVector n) Source #
AutoReg (Index n) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Index n -> Signal dom (Index n) -> Signal dom (Index n) Source #
AutoReg (Unsigned n) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Unsigned n -> Signal dom (Unsigned n) -> Signal dom (Unsigned n) Source #
AutoReg (Signed n) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Signed n -> Signal dom (Signed n) -> Signal dom (Signed n) Source #
(AutoReg a, AutoReg b) => AutoReg (a, b) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b) -> Signal dom (a, b) -> Signal dom (a, b) Source #
(KnownNat n, AutoReg a) => AutoReg (Vec n a) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Vec n a -> Signal dom (Vec n a) -> Signal dom (Vec n a) Source #
(KnownNat d, AutoReg a) => AutoReg (RTree d a) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> RTree d a -> Signal dom (RTree d a) -> Signal dom (RTree d a) Source #
(AutoReg a, AutoReg b, AutoReg c) => AutoReg (a, b, c) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b, c) -> Signal dom (a, b, c) -> Signal dom (a, b, c) Source #
NFDataX (rep (int + frac)) => AutoReg (Fixed rep int frac) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Fixed rep int frac -> Signal dom (Fixed rep int frac) -> Signal dom (Fixed rep int frac) Source #
(AutoReg a, AutoReg b, AutoReg c, AutoReg d) => AutoReg (a, b, c, d) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b, c, d) -> Signal dom (a, b, c, d) -> Signal dom (a, b, c, d) Source #
(AutoReg a, AutoReg b, AutoReg c, AutoReg d, AutoReg e) => AutoReg (a, b, c, d, e) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b, c, d, e) -> Signal dom (a, b, c, d, e) -> Signal dom (a, b, c, d, e) Source #
(AutoReg a, AutoReg b, AutoReg c, AutoReg d, AutoReg e, AutoReg f) => AutoReg (a, b, c, d, e, f) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b, c, d, e, f) -> Signal dom (a, b, c, d, e, f) -> Signal dom (a, b, c, d, e, f) Source #
(AutoReg a, AutoReg b, AutoReg c, AutoReg d, AutoReg e, AutoReg f, AutoReg g) => AutoReg (a, b, c, d, e, f, g) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b, c, d, e, f, g) -> Signal dom (a, b, c, d, e, f, g) -> Signal dom (a, b, c, d, e, f, g) Source #
(AutoReg a, AutoReg b, AutoReg c, AutoReg d, AutoReg e, AutoReg f, AutoReg g, AutoReg h) => AutoReg (a, b, c, d, e, f, g, h) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b, c, d, e, f, g, h) -> Signal dom (a, b, c, d, e, f, g, h) -> Signal dom (a, b, c, d, e, f, g, h) Source #
(AutoReg a, AutoReg b, AutoReg c, AutoReg d, AutoReg e, AutoReg f, AutoReg g, AutoReg h, AutoReg i) => AutoReg (a, b, c, d, e, f, g, h, i) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b, c, d, e, f, g, h, i) -> Signal dom (a, b, c, d, e, f, g, h, i) -> Signal dom (a, b, c, d, e, f, g, h, i) Source #
(AutoReg a, AutoReg b, AutoReg c, AutoReg d, AutoReg e, AutoReg f, AutoReg g, AutoReg h, AutoReg i, AutoReg j) => AutoReg (a, b, c, d, e, f, g, h, i, j) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b, c, d, e, f, g, h, i, j) -> Signal dom (a, b, c, d, e, f, g, h, i, j) -> Signal dom (a, b, c, d, e, f, g, h, i, j) Source #
(AutoReg a, AutoReg b, AutoReg c, AutoReg d, AutoReg e, AutoReg f, AutoReg g, AutoReg h, AutoReg i, AutoReg j, AutoReg k) => AutoReg (a, b, c, d, e, f, g, h, i, j, k) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b, c, d, e, f, g, h, i, j, k) -> Signal dom (a, b, c, d, e, f, g, h, i, j, k) -> Signal dom (a, b, c, d, e, f, g, h, i, j, k) Source #
(AutoReg a, AutoReg b, AutoReg c, AutoReg d, AutoReg e, AutoReg f, AutoReg g, AutoReg h, AutoReg i, AutoReg j, AutoReg k, AutoReg l) => AutoReg (a, b, c, d, e, f, g, h, i, j, k, l) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Signal dom (a, b, c, d, e, f, g, h, i, j, k, l) -> Signal dom (a, b, c, d, e, f, g, h, i, j, k, l) Source #

deriveAutoReg :: Name -> DecsQ Source #

Automatically derives an AutoReg instance for a product type

Usage:

data Pair a b = MkPair { getA :: a, getB :: b } deriving (Generic, NFDataX)
data Tup3 a b c = MkTup3 { getAB :: Pair a b, getC :: c } deriving (Generic, NFDataX)
deriveAutoReg ''Pair
deriveAutoReg ''Tup3

NB: Because of the way template haskell works the order here matters, if you try to deriveAutoReg ''Tup3 before Pair it will complain about missing an instance AutoReg (Pair a b).