Skip to content

Commit ee8e376

Browse files
cheatfatecheatfate
committed
Do some BlockBuffer adding refactoring and fixing tests.
1 parent 66b37b4 commit ee8e376

File tree

2 files changed

+59
-65
lines changed

2 files changed

+59
-65
lines changed

‎beacon_chain/sync/block_buffer.nim‎

Lines changed: 19 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -170,9 +170,9 @@ proc add*(
170170
doAssert(not(isNil(blck)), "Block should not be nil at this point!")
171171

172172
let
173-
(blockSlot, blockRoot) =
173+
(blockSlot, blockRoot, blockParentRoot) =
174174
withBlck(blck[]):
175-
(forkyBlck.message.slot, forkyBlck.root)
175+
(forkyBlck.message.slot, forkyBlck.root, forkyBlck.message.parent_root)
176176

177177
if len(buffer.blocks) == 0:
178178
buffer.blocks.add(blck)
@@ -195,33 +195,26 @@ proc add*(
195195
buffer.roots[blockRoot] = blck
196196
ok()
197197
else:
198-
if buffer.before(blockSlot, buffer.startSlot):
198+
# Block replacement
199+
let
200+
index = buffer.getIndex(blockSlot).get()
201+
innerBlock = buffer.blocks[index]
202+
if (innerBlock[].slot == blockSlot) and (innerBlock[].root == blockRoot) and
203+
(innerBlock[].parent_root == blockParentRoot):
204+
return err(VerifierError.Duplicate)
205+
if index == 0:
199206
buffer.resetBuffer(0)
200207
buffer.blocks.add(blck)
201208
buffer.roots[blockRoot] = blck
202-
ok()
203-
else:
204-
# Block replacement
205-
let
206-
index = buffer.getIndex(blockSlot).get()
207-
innerBlock = buffer.blocks[index]
208-
209-
if (innerBlock[].slot == blockSlot) and (innerBlock[].root == blockRoot):
210-
return err(VerifierError.Duplicate)
211-
212-
if buffer.beforeOrEq(blockSlot, buffer.startSlot):
213-
buffer.resetBuffer(0)
214-
buffer.blocks.add(blck)
215-
buffer.roots[blockRoot] = blck
216-
ok()
217-
else:
218-
let prevBlock = buffer.blocks[index - 1]
219-
if not(buffer.checkRoots(blck, prevBlock)):
220-
return err(VerifierError.MissingParent)
221-
buffer.resetBuffer(index)
222-
buffer.blocks.add(blck)
223-
buffer.roots[blockRoot] = blck
224-
ok()
209+
return ok()
210+
211+
let prevBlock = buffer.blocks[index - 1]
212+
if not(buffer.checkRoots(blck, prevBlock)):
213+
return err(VerifierError.MissingParent)
214+
buffer.resetBuffer(index)
215+
buffer.blocks.add(blck)
216+
buffer.roots[blockRoot] = blck
217+
ok()
225218

226219
iterator blocks(
227220
buffer: BlocksRangeBuffer,

‎tests/test_block_buffer.nim‎

Lines changed: 40 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -81,14 +81,15 @@ suite "BlocksRangeBuffer test suite":
8181
test "Add and query blocks test [backward]":
8282
var buffer = BlocksRangeBuffer.init(SyncQueueKind.Backward)
8383
const TestChain = [
84-
(Slot(1923340), createRoot(1), createRoot(0)),
85-
(Slot(1923339), createRoot(2), createRoot(1)),
84+
(Slot(1923340), createRoot(5), createRoot(4)),
85+
(Slot(1923339), createRoot(4), createRoot(3)),
8686
(Slot(1923338), createRoot(3), createRoot(2)),
87-
(Slot(1923335), createRoot(4), createRoot(3)),
88-
(Slot(1923330), createRoot(5), createRoot(4))
87+
(Slot(1923335), createRoot(2), createRoot(1)),
88+
(Slot(1923330), createRoot(1), createRoot(0))
8989
]
9090
for vector in TestChain:
91-
check buffer.add(createBlock(vector[0], vector[1], vector[2])).isOk()
91+
let res = buffer.add(createBlock(vector[0], vector[1], vector[2]))
92+
check res.isOk() == true
9293
for slot in SlotRange.init(Slot(1923350), Slot(1923341)):
9394
check isNil(buffer[slot]) == true
9495
check:
@@ -269,11 +270,11 @@ suite "BlocksRangeBuffer test suite":
269270
test "Block insertion test [backward]":
270271
var buffer = BlocksRangeBuffer.init(SyncQueueKind.Backward)
271272
const TestChain = [
272-
(Slot(1923340), createRoot(1), createRoot(0)),
273-
(Slot(1923339), createRoot(2), createRoot(1)),
273+
(Slot(1923340), createRoot(5), createRoot(4)),
274+
(Slot(1923339), createRoot(4), createRoot(3)),
274275
(Slot(1923338), createRoot(3), createRoot(2)),
275-
(Slot(1923335), createRoot(4), createRoot(3)),
276-
(Slot(1923330), createRoot(5), createRoot(4))
276+
(Slot(1923335), createRoot(2), createRoot(1)),
277+
(Slot(1923330), createRoot(1), createRoot(0))
277278
]
278279
for vector in TestChain:
279280
check buffer.add(createBlock(vector[0], vector[1], vector[2])).isOk()
@@ -288,10 +289,10 @@ suite "BlocksRangeBuffer test suite":
288289
r1.error == VerifierError.MissingParent
289290

290291
let r2 =
291-
buffer.add(createBlock(Slot(1923330), createRoot(7), createRoot(4)))
292+
buffer.add(createBlock(Slot(1923330), createRoot(1), createRoot(10)))
292293
check:
293294
r2.isOk() == true
294-
buffer[Slot(1923330)][].root == createRoot(7)
295+
buffer[Slot(1923330)][].root == createRoot(1)
295296
len(buffer) == 11
296297

297298
let r3 =
@@ -301,11 +302,11 @@ suite "BlocksRangeBuffer test suite":
301302
r3.error == VerifierError.MissingParent
302303

303304
let r4 =
304-
buffer.add(createBlock(Slot(1923331), createRoot(8), createRoot(4)))
305+
buffer.add(createBlock(Slot(1923331), createRoot(1), createRoot(11)))
305306
check:
306307
r4.isOk() == true
307308
isNil(buffer[Slot(1923330)]) == true
308-
buffer[Slot(1923331)][].root == createRoot(8)
309+
buffer[Slot(1923331)][].root == createRoot(1)
309310
len(buffer) == 10
310311

311312
let r5 =
@@ -315,66 +316,66 @@ suite "BlocksRangeBuffer test suite":
315316
r5.error == VerifierError.MissingParent
316317

317318
let r6 =
318-
buffer.add(createBlock(Slot(1923334), createRoot(9), createRoot(4)))
319+
buffer.add(createBlock(Slot(1923334), createRoot(1), createRoot(12)))
319320
check r6.isOk() == true
320321
for slot in SlotRange.init(Slot(1923330), Slot(1923333)):
321322
check isNil(buffer[slot]) == true
322323
check:
323-
buffer[Slot(1923334)][].root == createRoot(9)
324+
buffer[Slot(1923334)][].root == createRoot(1)
324325
len(buffer) == 7
325326

326327
let r7 =
327-
buffer.add(createBlock(Slot(1923335), createRoot(10), createRoot(3)))
328+
buffer.add(createBlock(Slot(1923335), createRoot(2), createRoot(13)))
328329
check r7.isOk() == true
329330
for slot in SlotRange.init(Slot(1923330), Slot(1923334)):
330331
check isNil(buffer[slot]) == true
331332
check:
332-
buffer[Slot(1923335)][].root == createRoot(10)
333+
buffer[Slot(1923335)][].root == createRoot(2)
333334
len(buffer) == 6
334335

335336
let r8 =
336-
buffer.add(createBlock(Slot(1923335), createRoot(11), createRoot(3)))
337+
buffer.add(createBlock(Slot(1923335), createRoot(2), createRoot(14)))
337338
check r8.isOk() == true
338339
for slot in SlotRange.init(Slot(1923330), Slot(1923334)):
339340
check isNil(buffer[slot]) == true
340341
check:
341-
buffer[Slot(1923335)][].root == createRoot(11)
342+
buffer[Slot(1923335)][].root == createRoot(2)
342343
len(buffer) == 6
343344

344345
let r9 =
345-
buffer.add(createBlock(Slot(1923336), createRoot(12), createRoot(3)))
346+
buffer.add(createBlock(Slot(1923336), createRoot(2), createRoot(15)))
346347
check r9.isOk() == true
347348
for slot in SlotRange.init(Slot(1923330), Slot(1923335)):
348349
check isNil(buffer[slot]) == true
349350
check:
350-
buffer[Slot(1923336)][].root == createRoot(12)
351+
buffer[Slot(1923336)][].root == createRoot(2)
351352
len(buffer) == 5
352353

353354
let r10 =
354-
buffer.add(createBlock(Slot(1923337), createRoot(13), createRoot(3)))
355+
buffer.add(createBlock(Slot(1923337), createRoot(2), createRoot(16)))
355356
check r10.isOk() == true
356357
for slot in SlotRange.init(Slot(1923330), Slot(1923336)):
357358
check isNil(buffer[slot]) == true
358359
check:
359-
buffer[Slot(1923337)][].root == createRoot(13)
360+
buffer[Slot(1923337)][].root == createRoot(2)
360361
len(buffer) == 4
361362

362363
let r11 =
363-
buffer.add(createBlock(Slot(1923338), createRoot(14), createRoot(2)))
364+
buffer.add(createBlock(Slot(1923338), createRoot(3), createRoot(17)))
364365
check r11.isOk() == true
365366
for slot in SlotRange.init(Slot(1923330), Slot(1923337)):
366367
check isNil(buffer[slot]) == true
367368
check:
368-
buffer[Slot(1923338)][].root == createRoot(14)
369+
buffer[Slot(1923338)][].root == createRoot(3)
369370
len(buffer) == 3
370371

371372
let r12 =
372-
buffer.add(createBlock(Slot(1923339), createRoot(15), createRoot(1)))
373+
buffer.add(createBlock(Slot(1923339), createRoot(4), createRoot(18)))
373374
check r12.isOk() == true
374375
for slot in SlotRange.init(Slot(1923330), Slot(1923338)):
375376
check isNil(buffer[slot]) == true
376377
check:
377-
buffer[Slot(1923339)][].root == createRoot(15)
378+
buffer[Slot(1923339)][].root == createRoot(4)
378379
len(buffer) == 2
379380

380381
let r13 =
@@ -467,11 +468,11 @@ suite "BlocksRangeBuffer test suite":
467468
test "Buffer advance test [backward]":
468469
var buffer = BlocksRangeBuffer.init(SyncQueueKind.Backward)
469470
const TestChain = [
470-
(Slot(1923340), createRoot(1), createRoot(0)),
471-
(Slot(1923339), createRoot(2), createRoot(1)),
471+
(Slot(1923340), createRoot(5), createRoot(4)),
472+
(Slot(1923339), createRoot(4), createRoot(3)),
472473
(Slot(1923338), createRoot(3), createRoot(2)),
473-
(Slot(1923335), createRoot(4), createRoot(3)),
474-
(Slot(1923330), createRoot(5), createRoot(4))
474+
(Slot(1923335), createRoot(2), createRoot(1)),
475+
(Slot(1923330), createRoot(1), createRoot(0))
475476
]
476477
const TestVectors = [
477478
(Slot(1923360), Slot(1923340), Slot(1923330), 11),
@@ -553,11 +554,11 @@ suite "BlocksRangeBuffer test suite":
553554

554555
test "Buffer invalidate test [backward]":
555556
const TestChain = [
556-
(Slot(1923340), createRoot(1), createRoot(0)),
557-
(Slot(1923339), createRoot(2), createRoot(1)),
557+
(Slot(1923340), createRoot(5), createRoot(4)),
558+
(Slot(1923339), createRoot(4), createRoot(3)),
558559
(Slot(1923338), createRoot(3), createRoot(2)),
559-
(Slot(1923335), createRoot(4), createRoot(3)),
560-
(Slot(1923330), createRoot(5), createRoot(4))
560+
(Slot(1923335), createRoot(2), createRoot(1)),
561+
(Slot(1923330), createRoot(1), createRoot(0))
561562
]
562563
const TestVectors = [
563564
(FAR_FUTURE_SLOT, FAR_FUTURE_SLOT, FAR_FUTURE_SLOT, 0),
@@ -643,11 +644,11 @@ suite "BlocksRangeBuffer test suite":
643644
test "Range peek test [backward]":
644645
var buffer = BlocksRangeBuffer.init(SyncQueueKind.Backward)
645646
const TestChain = [
646-
(Slot(1923340), createRoot(1), createRoot(0)),
647-
(Slot(1923339), createRoot(2), createRoot(1)),
647+
(Slot(1923340), createRoot(5), createRoot(4)),
648+
(Slot(1923339), createRoot(4), createRoot(3)),
648649
(Slot(1923338), createRoot(3), createRoot(2)),
649-
(Slot(1923335), createRoot(4), createRoot(3)),
650-
(Slot(1923330), createRoot(5), createRoot(4))
650+
(Slot(1923335), createRoot(2), createRoot(1)),
651+
(Slot(1923330), createRoot(1), createRoot(0))
651652
]
652653
const TestVectors = [
653654
(Slot(1923320), Slot(1923360), 5,

0 commit comments

Comments
 (0)