ouroboros-consensus-0.1.0.1: Consensus layer for the Ouroboros blockchain protocol
Safe Haskell None
Language Haskell2010

Ouroboros.Consensus.Storage.ImmutableDB.Chunks

Synopsis

Documentation

data RelativeSlot Source #

A relative slot within a chunk

Instances

Instances details
Eq RelativeSlot Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

(==) :: RelativeSlot -> RelativeSlot -> Bool Source #

(/=) :: RelativeSlot -> RelativeSlot -> Bool Source #

Show RelativeSlot Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

showsPrec :: Int -> RelativeSlot -> ShowS Source #

show :: RelativeSlot -> String Source #

showList :: [ RelativeSlot ] -> ShowS Source #

Generic RelativeSlot Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Associated Types

type Rep RelativeSlot :: Type -> Type Source #

Methods

from :: RelativeSlot -> Rep RelativeSlot x Source #

to :: Rep RelativeSlot x -> RelativeSlot Source #

NoThunks RelativeSlot Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

noThunks :: Context -> RelativeSlot -> IO ( Maybe ThunkInfo ) Source #

wNoThunks :: Context -> RelativeSlot -> IO ( Maybe ThunkInfo ) Source #

showTypeOf :: Proxy RelativeSlot -> String Source #

type Rep RelativeSlot Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

type Rep RelativeSlot = D1 (' MetaData "RelativeSlot" "Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "RelativeSlot" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "relativeSlotChunkNo") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ChunkNo ) :*: ( S1 (' MetaSel (' Just "relativeSlotChunkSize") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ChunkSize ) :*: S1 (' MetaSel (' Just "relativeSlotIndex") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 Word64 ))))

data ChunkNo Source #

Chunk number

Instances

Instances details
Eq ChunkNo Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

(==) :: ChunkNo -> ChunkNo -> Bool Source #

(/=) :: ChunkNo -> ChunkNo -> Bool Source #

Ord ChunkNo Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

compare :: ChunkNo -> ChunkNo -> Ordering Source #

(<) :: ChunkNo -> ChunkNo -> Bool Source #

(<=) :: ChunkNo -> ChunkNo -> Bool Source #

(>) :: ChunkNo -> ChunkNo -> Bool Source #

(>=) :: ChunkNo -> ChunkNo -> Bool Source #

max :: ChunkNo -> ChunkNo -> ChunkNo Source #

min :: ChunkNo -> ChunkNo -> ChunkNo Source #

Show ChunkNo Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

showsPrec :: Int -> ChunkNo -> ShowS Source #

show :: ChunkNo -> String Source #

showList :: [ ChunkNo ] -> ShowS Source #

Generic ChunkNo Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Associated Types

type Rep ChunkNo :: Type -> Type Source #

Methods

from :: ChunkNo -> Rep ChunkNo x Source #

to :: Rep ChunkNo x -> ChunkNo Source #

NoThunks ChunkNo Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

noThunks :: Context -> ChunkNo -> IO ( Maybe ThunkInfo ) Source #

wNoThunks :: Context -> ChunkNo -> IO ( Maybe ThunkInfo ) Source #

showTypeOf :: Proxy ChunkNo -> String Source #

type Rep ChunkNo Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

type Rep ChunkNo = D1 (' MetaData "ChunkNo" "Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' True ) ( C1 (' MetaCons "ChunkNo" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unChunkNo") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Word64 )))

data ChunkSize Source #

Size of a chunk

The total number of slots available in a chunk is equal to numRegularBlocks if not chunkCanContainEBB , and numRegularBlocks + 1 otherwise.

Constructors

ChunkSize

Fields

Instances

Instances details
Show ChunkSize Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

showsPrec :: Int -> ChunkSize -> ShowS Source #

show :: ChunkSize -> String Source #

showList :: [ ChunkSize ] -> ShowS Source #

Generic ChunkSize Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Associated Types

type Rep ChunkSize :: Type -> Type Source #

Methods

from :: ChunkSize -> Rep ChunkSize x Source #

to :: Rep ChunkSize x -> ChunkSize Source #

NoThunks ChunkSize Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

noThunks :: Context -> ChunkSize -> IO ( Maybe ThunkInfo ) Source #

wNoThunks :: Context -> ChunkSize -> IO ( Maybe ThunkInfo ) Source #

showTypeOf :: Proxy ChunkSize -> String Source #

type Rep ChunkSize Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

type Rep ChunkSize = D1 (' MetaData "ChunkSize" "Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "ChunkSize" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "chunkCanContainEBB") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 Bool ) :*: S1 (' MetaSel (' Just "numRegularBlocks") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 Word64 )))

data ChunkInfo Source #

Size of the chunks of the immutable DB

This is the key data structure that drives all layout functions.

TODO: Add support for non-uniform ChunkInfo https://github.com/input-output-hk/ouroboros-network/issues/1754

Constructors

UniformChunkSize ! ChunkSize

A single, uniform, chunk size

If EBBs are present, the chunk size must line up precisely with the epoch size (that is, the number of regular blocks in the chunk must equal the number of regular blocks in an epoch).

Instances

Instances details
Show ChunkInfo Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

showsPrec :: Int -> ChunkInfo -> ShowS Source #

show :: ChunkInfo -> String Source #

showList :: [ ChunkInfo ] -> ShowS Source #

Generic ChunkInfo Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Associated Types

type Rep ChunkInfo :: Type -> Type Source #

Methods

from :: ChunkInfo -> Rep ChunkInfo x Source #

to :: Rep ChunkInfo x -> ChunkInfo Source #

NoThunks ChunkInfo Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

noThunks :: Context -> ChunkInfo -> IO ( Maybe ThunkInfo ) Source #

wNoThunks :: Context -> ChunkInfo -> IO ( Maybe ThunkInfo ) Source #

showTypeOf :: Proxy ChunkInfo -> String Source #

type Rep ChunkInfo Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

type Rep ChunkInfo = D1 (' MetaData "ChunkInfo" "Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "UniformChunkSize" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ChunkSize )))

simpleChunkInfo :: EpochSize -> ChunkInfo Source #

Simple chunk config with a single chunk size

This intentionally takes EpochSize (number of slots) rather than ChunkSize : the translation from EpochSize to ChunkSize (number of available entries in a chunk) should not be done by client code.

singleChunkInfo :: ChunkSize -> ChunkInfo Source #

ChunkInfo for a single ChunkSize

See also simpleChunkInfo .

chunkInfoSupportsEBBs :: ChunkInfo -> Bool Source #

Can we store EBBs in the chunks described by this ChunkInfo ?

This is only used for tests. This API will need to change (and the tests will become more complicated) once we support non-uniform ChunkInfo .

firstChunkNo :: ChunkNo Source #

First chunk

nextChunkNo :: ChunkNo -> ChunkNo Source #

prevChunkNo :: ChunkNo -> Maybe ChunkNo Source #

countChunks :: ChunkNo -> ChunkNo -> Word64 Source #

Count number of chunks between two indices 

countChunks x              x  == 0
countChunks x (nextChunkNo x) == 1

chunksBetween :: ChunkNo -> ChunkNo -> [ ChunkNo ] Source #

Enumerate all chunks 

chunksBetween x              x  == [x]
chunksBetween x (nextChunkNo x) == [x, nextChunkNo x]

getChunkSize :: ChunkInfo -> ChunkNo -> ChunkSize Source #

mkRelativeSlot :: HasCallStack => ChunkInfo -> ChunkNo -> Word64 -> RelativeSlot Source #

Smart constructor for RelativeSlot

compareRelativeSlot :: HasCallStack => RelativeSlot -> RelativeSlot -> Ordering Source #

RelativeSlot is partially ordered, not totally ordered

It makes no sense to compare RelativeSlots from different chunks. Doing so will result in an assertion failure.

data ChunkSlot Source #

Uniquely identify a block within the immutable DB

Constructor marked as Unsafe ; construction should normally happen inside this module only (though see the ChunkSlot pattern synonym).

Constructors

UnsafeChunkSlot

Fields

Instances

Instances details
Eq ChunkSlot Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Layout

Methods

(==) :: ChunkSlot -> ChunkSlot -> Bool Source #

(/=) :: ChunkSlot -> ChunkSlot -> Bool Source #

Ord ChunkSlot Source #

We provide a manual Ord instance because RelativeSlot does not (and cannot) define one. By comparing the chunkIndex before the index here, we establish the precondition to compareRelativeSlot .

Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Layout

Methods

compare :: ChunkSlot -> ChunkSlot -> Ordering Source #

(<) :: ChunkSlot -> ChunkSlot -> Bool Source #

(<=) :: ChunkSlot -> ChunkSlot -> Bool Source #

(>) :: ChunkSlot -> ChunkSlot -> Bool Source #

(>=) :: ChunkSlot -> ChunkSlot -> Bool Source #

max :: ChunkSlot -> ChunkSlot -> ChunkSlot Source #

min :: ChunkSlot -> ChunkSlot -> ChunkSlot Source #

Show ChunkSlot Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Layout

Methods

showsPrec :: Int -> ChunkSlot -> ShowS Source #

show :: ChunkSlot -> String Source #

showList :: [ ChunkSlot ] -> ShowS Source #

Generic ChunkSlot Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Layout

Associated Types

type Rep ChunkSlot :: Type -> Type Source #

Methods

from :: ChunkSlot -> Rep ChunkSlot x Source #

to :: Rep ChunkSlot x -> ChunkSlot Source #

NoThunks ChunkSlot Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Layout

Methods

noThunks :: Context -> ChunkSlot -> IO ( Maybe ThunkInfo ) Source #

wNoThunks :: Context -> ChunkSlot -> IO ( Maybe ThunkInfo ) Source #

showTypeOf :: Proxy ChunkSlot -> String Source #

type Rep ChunkSlot Source #
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Layout

type Rep ChunkSlot = D1 (' MetaData "ChunkSlot" "Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Layout" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "UnsafeChunkSlot" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "chunkIndex") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ChunkNo ) :*: S1 (' MetaSel (' Just "chunkRelative") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 RelativeSlot )))

data NextRelativeSlot Source #

Result of nextRelativeSlot

Constructors

NextRelativeSlot RelativeSlot

There is a next negative slot

NoMoreRelativeSlots

We reached the end of the chunk

pattern ChunkSlot :: ChunkNo -> RelativeSlot -> ChunkSlot Source #

maxRelativeSlot :: ChunkInfo -> ChunkNo -> RelativeSlot Source #

The last relative slot within a chunk of the given size

relativeSlotIsEBB :: RelativeSlot -> IsEBB Source #

Is this relative slot reserved for an EBB?

nthBlockOrEBB :: ( HasCallStack , Integral a) => ChunkInfo -> ChunkNo -> a -> RelativeSlot Source #

The n 'th relative slot for an arbitrary block

NOTE: Offset 0 refers to an EBB only if the ChunkSize supports it.

firstBlockOrEBB :: ChunkInfo -> ChunkNo -> RelativeSlot Source #

The first relative slot

NOTE: This refers to an EBB only if the ChunkSize supports it.

nextRelativeSlot :: HasCallStack => RelativeSlot -> NextRelativeSlot Source #

Next relative slot

unsafeNextRelativeSlot :: HasCallStack => RelativeSlot -> RelativeSlot Source #

Variation on nextRelativeSlot where the caller knows that there must be a next slot

Throws an assertion failure (if assertions are enabled) if there is no next slot.

chunkIndexOfSlot :: ChunkInfo -> SlotNo -> ChunkNo Source #

chunkSlotForUnknownBlock :: HasCallStack => ChunkInfo -> SlotNo -> ( ChunkNo , Maybe ChunkSlot , ChunkSlot ) Source #

Chunk slot for an unknown block

This returns two ChunkSlot s: one in case the block could be an EBB, and one in case the block is a regular block. In addition, it also returns the ChunkNo that both of these ChunkSlot s must necessarily share.

chunkSlotForRegularBlock :: ChunkInfo -> SlotNo -> ChunkSlot Source #

Chunk slot for a regular block (i.e., not an EBB)

chunkSlotForBoundaryBlock :: HasCallStack => ChunkInfo -> EpochNo -> ChunkSlot Source #

Chunk slot for EBB

chunkSlotForBlockOrEBB :: ChunkInfo -> BlockOrEBB -> ChunkSlot Source #

Chunk slot for BlockOrEBB

chunkSlotForTip :: ChunkInfo -> Tip blk -> ChunkSlot Source #

Chunk slot for Tip

chunkSlotForRelativeSlot :: ChunkNo -> RelativeSlot -> ChunkSlot Source #

chunkSlotToSlot :: ChunkInfo -> ChunkSlot -> SlotNo Source #

From relative to absolute slot

This can be used for EBBs and regular blocks, since they don't share a relative slot.

chunkSlotToBlockOrEBB :: ChunkInfo -> ChunkSlot -> BlockOrEBB Source #

slotNoOfEBB :: HasCallStack => ChunkInfo -> EpochNo -> SlotNo Source #

slotMightBeEBB :: ChunkInfo -> SlotNo -> Maybe EpochNo Source #

slotNoOfBlockOrEBB :: ChunkInfo -> BlockOrEBB -> SlotNo Source #