Safe Haskell	None
Language	Haskell2010

Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Contents

Chunk number
Chunk size
Layout
Assertions

Synopsis

data ChunkInfo = UniformChunkSize !ChunkSize
simpleChunkInfo :: EpochSize -> ChunkInfo
singleChunkInfo :: ChunkSize -> ChunkInfo
chunkInfoSupportsEBBs :: ChunkInfo -> Bool
newtype ChunkNo = ChunkNo {
- unChunkNo :: Word64
}
firstChunkNo :: ChunkNo
chunkNoToInt :: ChunkNo -> Int
chunkNoFromInt :: Int -> ChunkNo
nextChunkNo :: ChunkNo -> ChunkNo
prevChunkNo :: ChunkNo -> Maybe ChunkNo
countChunks :: ChunkNo -> ChunkNo -> Word64
chunksBetween :: ChunkNo -> ChunkNo -> [ChunkNo]
unsafeEpochNoToChunkNo :: EpochNo -> ChunkNo
unsafeChunkNoToEpochNo :: ChunkNo -> EpochNo
data ChunkSize = ChunkSize {
- chunkCanContainEBB :: !Bool
- numRegularBlocks :: !Word64
}
getChunkSize :: ChunkInfo -> ChunkNo -> ChunkSize
data RelativeSlot = RelativeSlot {
- relativeSlotChunkNo :: !ChunkNo
- relativeSlotChunkSize :: !ChunkSize
- relativeSlotIndex :: !Word64
}
maxRelativeIndex :: ChunkSize -> Word64
mkRelativeSlot :: HasCallStack => ChunkInfo -> ChunkNo -> Word64 -> RelativeSlot
assertRelativeSlotInChunk :: HasCallStack => ChunkNo -> RelativeSlot -> Word64
compareRelativeSlot :: HasCallStack => RelativeSlot -> RelativeSlot -> Ordering
data ChunkAssertionFailure
assertSameChunk :: HasCallStack => ChunkNo -> ChunkNo -> a -> a
assertWithinBounds :: HasCallStack => Word64 -> ChunkSize -> a -> a
assertChunkCanContainEBB :: HasCallStack => ChunkNo -> ChunkSize -> a -> a

Documentation

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 # show :: ChunkInfo -> String # showList :: [ChunkInfo] -> ShowS #
Generic ChunkInfo Source #
Instance details Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal Associated Types type Rep ChunkInfo :: Type -> Type # Methods from :: ChunkInfo -> Rep ChunkInfo x # to :: Rep ChunkInfo x -> ChunkInfo #
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.0-GfJNvFcM6lj2s5utKAUPEp" '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

Chunk number

newtype ChunkNo Source #

Chunk number

Constructors

ChunkNo
Fields unChunkNo :: Word64

Instances

Instances details

Eq ChunkNo Source #
Instance details Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal Methods (==) :: ChunkNo -> ChunkNo -> Bool # (/=) :: ChunkNo -> ChunkNo -> Bool #
Ord ChunkNo Source #
Instance details Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal Methods compare :: ChunkNo -> ChunkNo -> Ordering # (<) :: ChunkNo -> ChunkNo -> Bool # (<=) :: ChunkNo -> ChunkNo -> Bool # (>) :: ChunkNo -> ChunkNo -> Bool # (>=) :: ChunkNo -> ChunkNo -> Bool # max :: ChunkNo -> ChunkNo -> ChunkNo # min :: ChunkNo -> ChunkNo -> ChunkNo #
Show ChunkNo Source #
Instance details Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal Methods showsPrec :: Int -> ChunkNo -> ShowS # show :: ChunkNo -> String # showList :: [ChunkNo] -> ShowS #
Generic ChunkNo Source #
Instance details Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal Associated Types type Rep ChunkNo :: Type -> Type # Methods from :: ChunkNo -> Rep ChunkNo x # to :: Rep ChunkNo x -> ChunkNo #
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.0-GfJNvFcM6lj2s5utKAUPEp" 'True) (C1 ('MetaCons "ChunkNo" 'PrefixI 'True) (S1 ('MetaSel ('Just "unChunkNo") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word64)))

firstChunkNo :: ChunkNo Source #

First chunk

chunkNoToInt :: ChunkNo -> Int Source #

Convert ChunkNo to Int

This is primarily useful for the immutable DB, which uses an IntPSQ.

chunkNoFromInt :: Int -> ChunkNo Source #

Convert Int to ChunkNo

See chunkNoToInt for motivation.

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]

unsafeEpochNoToChunkNo :: EpochNo -> ChunkNo Source #

Translate EpochNo to ChunkNo

This should ONLY be used to translate the EpochNo of an EBB, since the invariant says EBBs can only exist in the first period of the DB, where the chunk size must equal the epoch size. See ChunkInfo for details.

unsafeChunkNoToEpochNo :: ChunkNo -> EpochNo Source #

Translate ChunkNo to EpochNo

This should ONLY be used for chunks that contain EBBs. See unsafeEpochNoToChunkNo and ChunkInfo for details.

Chunk size

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 chunkCanContainEBB :: !Bool Does this chunk also accomodate an EBB? numRegularBlocks :: !Word64 The number of regular blocks in this chunk

Instances

Instances details

Show ChunkSize Source #
Instance details Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal Methods showsPrec :: Int -> ChunkSize -> ShowS # show :: ChunkSize -> String # showList :: [ChunkSize] -> ShowS #
Generic ChunkSize Source #
Instance details Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal Associated Types type Rep ChunkSize :: Type -> Type # Methods from :: ChunkSize -> Rep ChunkSize x # to :: Rep ChunkSize x -> ChunkSize #
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.0-GfJNvFcM6lj2s5utKAUPEp" 'False) (C1 ('MetaCons "ChunkSize" 'PrefixI 'True) (S1 ('MetaSel ('Just "chunkCanContainEBB") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool) :*: S1 ('MetaSel ('Just "numRegularBlocks") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Word64)))

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

Layout

data RelativeSlot Source #

A relative slot within a chunk

Constructors

RelativeSlot
Fields relativeSlotChunkNo :: !ChunkNo The chunk index of the chunk this slot is in Recorded primarily to be able to define a semi-sensible `Ord` instance. relativeSlotChunkSize :: !ChunkSize The size of the chunk that this slot is in We record this for bounds checking as well as to be able to answer questions such as `relativeSlotIsEBB`. relativeSlotIndex :: !Word64 The index within the chunk

Instances

Instances details

Eq RelativeSlot Source #
Instance details Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal Methods (==) :: RelativeSlot -> RelativeSlot -> Bool # (/=) :: RelativeSlot -> RelativeSlot -> Bool #
Show RelativeSlot Source #
Instance details Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal Methods showsPrec :: Int -> RelativeSlot -> ShowS # show :: RelativeSlot -> String # showList :: [RelativeSlot] -> ShowS #
Generic RelativeSlot Source #
Instance details Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal Associated Types type Rep RelativeSlot :: Type -> Type # Methods from :: RelativeSlot -> Rep RelativeSlot x # to :: Rep RelativeSlot x -> RelativeSlot #
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.0-GfJNvFcM6lj2s5utKAUPEp" '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))))

maxRelativeIndex :: ChunkSize -> Word64 Source #

Maximum relative index within a chunk

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

Smart constructor for RelativeSlot

assertRelativeSlotInChunk :: HasCallStack => ChunkNo -> RelativeSlot -> Word64 Source #

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.

Assertions

data ChunkAssertionFailure Source #

Instances

Instances details

Show ChunkAssertionFailure Source #
Instance details Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal Methods showsPrec :: Int -> ChunkAssertionFailure -> ShowS # show :: ChunkAssertionFailure -> String # showList :: [ChunkAssertionFailure] -> ShowS #
Exception ChunkAssertionFailure Source #
Instance details Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal Methods toException :: ChunkAssertionFailure -> SomeException # fromException :: SomeException -> Maybe ChunkAssertionFailure # displayException :: ChunkAssertionFailure -> String #

assertSameChunk :: HasCallStack => ChunkNo -> ChunkNo -> a -> a Source #

assertWithinBounds :: HasCallStack => Word64 -> ChunkSize -> a -> a Source #

assertChunkCanContainEBB :: HasCallStack => ChunkNo -> ChunkSize -> a -> a Source #