mirror of
https://github.com/codex-storage/nim-codex.git
synced 2025-01-10 04:55:40 +00:00
72da534856
* Setting up testfixture for proof datasampler * Sets up calculating number of cells in a slot * Sets up tests for bitwise modulo * Implements cell index collection * setting up slot blocks module * Implements getting treeCID from slot * implements getting slot blocks by index * Implements out-of-range check for slot index * cleanup * Sets up getting sample from block * Implements selecting a cell sample from a block * Implements building a minitree for block cells * Adds method to get dataset block index from slot block index * It's running * splits up indexing * almost there * Fixes test. Implementation is now functional * Refactoring to object-oriented * Cleanup * Lining up output type with updated reference code. * setting up * Updates expected samples * Updates proof checking test to match new format * move builder to own dir * move sampler to own dir * fix paths * various changes to add support for the sampler * wip sampler implementation * don't use upraises * wip sampler integration * misc * move tests around * Various fixes to select correct slot and block index * removing old tests * cleanup * misc fix tests that work with correct cell indices * remove unused file * fixup logging * add logscope * truncate entropy to 31 bytes, otherwise it might be > than mod * forwar getCidAndProof to local store * misc * Adds missing test for initial-proving state * reverting back to correct slot/block indexing * fix tests for revert * misc * misc --------- Co-authored-by: benbierens <thatbenbierens@gmail.com>
107 lines
2.8 KiB
Nim
107 lines
2.8 KiB
Nim
import std/sequtils
|
|
|
|
import ./errors
|
|
import ./utils
|
|
import ./utils/asynciter
|
|
|
|
{.push raises: [].}
|
|
|
|
type
|
|
# Representing a strategy for grouping indices (of blocks usually)
|
|
# Given an interation-count as input, will produce a seq of
|
|
# selected indices.
|
|
|
|
IndexingError* = object of CodexError
|
|
IndexingWrongIndexError* = object of IndexingError
|
|
IndexingWrongIterationsError* = object of IndexingError
|
|
|
|
IndexingStrategy* = ref object of RootObj
|
|
firstIndex*: int # Lowest index that can be returned
|
|
lastIndex*: int # Highest index that can be returned
|
|
numberOfIterations*: int # getIndices(iteration) will run from 0 ..< numberOfIterations
|
|
step*: int
|
|
|
|
# Simplest approach:
|
|
# 0 => 0, 1, 2
|
|
# 1 => 3, 4, 5
|
|
# 2 => 6, 7, 8
|
|
LinearIndexingStrategy* = ref object of IndexingStrategy
|
|
|
|
# Stepped indexing:
|
|
# 0 => 0, 3, 6
|
|
# 1 => 1, 4, 7
|
|
# 2 => 2, 5, 8
|
|
SteppedIndexingStrategy* = ref object of IndexingStrategy
|
|
|
|
proc checkIteration(
|
|
self: IndexingStrategy,
|
|
iteration: int): void {.raises: [IndexingError].} =
|
|
if iteration >= self.numberOfIterations:
|
|
raise newException(
|
|
IndexingError,
|
|
"Indexing iteration can't be greater than or equal to numberOfIterations.")
|
|
|
|
method getIndicies*(
|
|
self: IndexingStrategy,
|
|
iteration: int): Iter[int] {.base, raises: [IndexingError].} =
|
|
raiseAssert("Not implemented")
|
|
|
|
proc getIter(first, last, step: int): Iter[int] =
|
|
var
|
|
finish = false
|
|
cur = first
|
|
proc get(): int =
|
|
result = cur
|
|
cur += step
|
|
|
|
if cur > last:
|
|
finish = true
|
|
|
|
proc isFinished(): bool =
|
|
finish
|
|
|
|
Iter.new(get, isFinished)
|
|
|
|
method getIndicies*(
|
|
self: LinearIndexingStrategy,
|
|
iteration: int): Iter[int] {.raises: [IndexingError].} =
|
|
|
|
self.checkIteration(iteration)
|
|
|
|
let
|
|
first = self.firstIndex + iteration * (self.step + 1)
|
|
last = min(first + self.step, self.lastIndex)
|
|
|
|
getIter(first, last, 1)
|
|
|
|
method getIndicies*(
|
|
self: SteppedIndexingStrategy,
|
|
iteration: int): Iter[int] {.raises: [IndexingError].} =
|
|
|
|
self.checkIteration(iteration)
|
|
|
|
let
|
|
first = self.firstIndex + iteration
|
|
last = self.lastIndex
|
|
|
|
getIter(first, last, self.numberOfIterations)
|
|
|
|
proc new*(
|
|
T: type IndexingStrategy,
|
|
firstIndex, lastIndex, numberOfIterations: int): T {.raises: [IndexingError].} =
|
|
if firstIndex > lastIndex:
|
|
raise newException(
|
|
IndexingWrongIndexError,
|
|
"firstIndex (" & $firstIndex & ") can't be greater than lastIndex (" & $lastIndex & ")")
|
|
|
|
if numberOfIterations <= 0:
|
|
raise newException(
|
|
IndexingWrongIterationsError,
|
|
"numberOfIteration (" & $numberOfIterations & ") must be greater than zero.")
|
|
|
|
T(
|
|
firstIndex: firstIndex,
|
|
lastIndex: lastIndex,
|
|
numberOfIterations: numberOfIterations,
|
|
step: divUp((lastIndex - firstIndex), numberOfIterations))
|