Skip to content

Commit 5383dad

Browse files
emwang-jumpemwang-jump
committed
replay: track shred idxs to trigger slice replay
1 parent e20965a commit 5383dad

File tree

5 files changed

+129
-60
lines changed

5 files changed

+129
-60
lines changed

‎src/disco/fd_disco_base.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -151,7 +151,7 @@ fd_disco_shred_replay_sig( int type, int is_code_or_data_completes, ulong slot,
151151
ulong is_code_or_data_completes_ul = (ulong)is_code_or_data_completes;
152152
ulong slot_ul = fd_ulong_min( (ulong)slot, (ulong)UINT_MAX );
153153
ulong fec_set_idx_ul = fd_ulong_min( (ulong)fec_set_idx, (ulong)FD_SHRED_MAX_PER_SLOT );
154-
ulong shred_idx_or_data_cnt_or_parent_off_ul = fd_ulong_min( (ulong)shred_idx_or_data_cnt_or_parent_off, (ulong)FD_SHRED_MAX_PER_SLOT );
154+
ulong shred_idx_or_data_cnt_or_parent_off_ul = fd_ulong_extract( fd_ulong_min( (ulong)shred_idx_or_data_cnt_or_parent_off, (ulong)FD_SHRED_MAX_PER_SLOT ), 0, 14 );
155155
return type_ul << 63 | is_code_or_data_completes_ul << 62 | slot_ul << 30 | fec_set_idx_ul << 15 | shred_idx_or_data_cnt_or_parent_off_ul;
156156
}
157157

‎src/disco/shred/fd_shred_tile.c

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -610,7 +610,6 @@ after_frag( fd_shred_ctx_t * ctx,
610610
fd_memcpy( buf, shred, sz );
611611

612612
/* Publish the frag. */
613-
614613
ulong tspub = fd_frag_meta_ts_comp( fd_tickcount() );
615614
fd_stem_publish( stem, REPLAY_OUT_IDX, sig, ctx->replay_out_chunk, sz, 0UL, ctx->tsorig, tspub );
616615
ctx->replay_out_chunk = fd_dcache_compact_next( ctx->replay_out_chunk, sz, ctx->replay_out_chunk0, ctx->replay_out_wmark );
@@ -678,7 +677,7 @@ after_frag( fd_shred_ctx_t * ctx,
678677
complete notification. */
679678

680679
fd_shred_t const * last = (fd_shred_t const *)fd_type_pun_const( set->data_shreds[ set->data_shred_cnt - 1 ] );
681-
int data_completes = last->data.flags & FD_SHRED_DATA_FLAG_DATA_COMPLETE;
680+
int data_completes = !!( last->data.flags & FD_SHRED_DATA_FLAG_DATA_COMPLETE );
682681
ulong sig = fd_disco_shred_replay_sig( 1, data_completes, last->slot, last->fec_set_idx, last->data.parent_off );
683682

684683
/* Copy the merkle root and chained merkle root of the FEC set
@@ -688,7 +687,6 @@ after_frag( fd_shred_ctx_t * ctx,
688687
ulong sz = fd_shred_header_sz( last->variant );
689688
memcpy( buf, out_merkle_root, FD_SHRED_MERKLE_ROOT_SZ );
690689
memcpy( buf + FD_SHRED_MERKLE_ROOT_SZ, (uchar const *)last + fd_shred_chain_off( last->variant ), FD_SHRED_MERKLE_ROOT_SZ );
691-
692690
ulong tspub = fd_frag_meta_ts_comp( fd_tickcount() );
693691
fd_stem_publish( stem, REPLAY_OUT_IDX, sig, ctx->replay_out_chunk, sz, 0UL, ctx->tsorig, tspub );
694692
ctx->replay_out_chunk = fd_dcache_compact_next( ctx->replay_out_chunk, sz, ctx->replay_out_chunk0, ctx->replay_out_wmark );

‎src/discof/replay/fd_replay.c

Lines changed: 10 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -6,11 +6,10 @@ fd_replay_new( void * shmem, ulong fec_max, ulong slice_max, ulong block_max ) {
66
int lg_block_max = fd_ulong_find_msb( fd_ulong_pow2_up( block_max ) );
77

88
FD_SCRATCH_ALLOC_INIT( l, shmem );
9-
fd_replay_t * replay = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_align(), sizeof(fd_replay_t) );
10-
void * fec_map = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_fec_map_align(), fd_replay_fec_map_footprint( lg_fec_max ) );
11-
void * fec_deque = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_fec_deque_align(), fd_replay_fec_deque_footprint( fec_max ) );
12-
void * idxs_map = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_idxs_map_align(), fd_replay_idxs_map_footprint( lg_block_max ) );
13-
void * slice_buf = FD_SCRATCH_ALLOC_APPEND( l, 128UL, FD_SLICE_MAX );
9+
fd_replay_t * replay = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_align(), sizeof(fd_replay_t) );
10+
void * fec_map = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_fec_map_align(), fd_replay_fec_map_footprint( lg_fec_max ) );
11+
void * fec_deque = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_fec_deque_align(), fd_replay_fec_deque_footprint( fec_max ) );
12+
void * shred_map = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_idxs_map_align(), fd_replay_idxs_map_footprint( lg_block_max ) );
1413
void * slice_map = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_slice_map_align(), fd_replay_slice_map_footprint( lg_block_max ) );
1514
for( ulong i = 0UL; i < block_max; i++ ) {
1615
void * slice_deque = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_slice_deque_align(), fd_replay_slice_deque_footprint( slice_max ) );
@@ -19,10 +18,9 @@ fd_replay_new( void * shmem, ulong fec_max, ulong slice_max, ulong block_max ) {
1918
ulong top = FD_SCRATCH_ALLOC_FINI( l, fd_replay_align() );
2019
FD_TEST( top == (ulong)shmem + fd_replay_footprint( fec_max, slice_max, block_max ) );
2120

22-
fd_replay_fec_map_new ( fec_map , lg_fec_max );
23-
fd_replay_fec_deque_new( fec_deque, fec_max );
24-
fd_replay_idxs_map_new ( idxs_map , lg_block_max );
25-
(void)slice_buf;
21+
fd_replay_fec_map_new( fec_map, lg_fec_max );
22+
fd_replay_fec_deque_new( fec_deque, fec_max );
23+
fd_replay_idxs_map_new( shred_map, lg_block_max );
2624
fd_replay_slice_map_new( slice_map, lg_block_max );
2725

2826

@@ -43,14 +41,12 @@ fd_replay_join( void * shreplay ) {
4341
replay = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_align(), sizeof(fd_replay_t) );
4442
void * fec_map = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_fec_map_align(), fd_replay_fec_map_footprint( lg_fec_max ) );
4543
void * fec_deque = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_fec_deque_align(), fd_replay_fec_deque_footprint( replay->fec_max ) );
46-
void * idxs_map = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_idxs_map_align(), fd_replay_idxs_map_footprint( lg_block_max ) );
47-
void * slice_buf = FD_SCRATCH_ALLOC_APPEND( l, 128UL, FD_SLICE_MAX );
48-
void * slice_map = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_slice_map_align(), fd_replay_slice_map_footprint( lg_block_max ) );
44+
void * shred_map = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_idxs_map_align(), fd_replay_idxs_map_footprint( lg_block_max ) );
45+
void * slice_map = FD_SCRATCH_ALLOC_APPEND( l, fd_replay_slice_map_align(), fd_replay_slice_map_footprint( lg_block_max ) );
4946

5047
replay->fec_map = fd_replay_fec_map_join ( fec_map );
5148
replay->fec_deque = fd_replay_fec_deque_join( fec_deque );
52-
replay->idxs_map = fd_replay_idxs_map_join ( idxs_map );
53-
(void)slice_buf;
49+
replay->idxs_map = fd_replay_idxs_map_join( shred_map );
5450
replay->slice_map = fd_replay_slice_map_join( slice_map );
5551

5652
/* Initialize each map slot to point to a deque. Each slot should

‎src/discof/replay/fd_replay.h

Lines changed: 49 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -173,13 +173,24 @@ ulong fd_replay_slice_key( uint start_idx, uint end_idx ) {
173173
also be the first to attempt replay. */
174174

175175
struct __attribute__((aligned(128UL))) fd_replay {
176-
ulong fec_max;
177-
ulong slice_max;
178-
ulong block_max;
176+
ulong fec_max;
177+
ulong slice_max;
178+
ulong block_max;
179+
180+
/* Track in-progress FEC sets to repair if they don't complete in a
181+
timely way. */
182+
179183
fd_replay_fec_t * fec_map; /* map of slot to in-progress fec */
180184
fd_replay_fec_t * fec_deque; /* deque of in-progress fecs by insert order (FIFO) */
181-
fd_replay_idxs_t * idxs_map; /* map of slot to metadata about received shred idxs */
182-
fd_replay_slice_t * slice_map; /* map of slot to deque of replayable block slices */
185+
186+
/* Track shreds stored to blockstore to generate slices */
187+
188+
fd_replay_idxs_t * idxs_map; /* map of slot to metadata about received shred idxs */
189+
190+
/* Track block slices to be replayed. */
191+
192+
fd_replay_slice_t * slice_map; /* map of slot to deque of replayable block slices */
193+
void * slice_deques; /* mem for contiguous deques of ulongs */
183194
};
184195
typedef struct fd_replay fd_replay_t;
185196

@@ -201,22 +212,20 @@ fd_replay_footprint( ulong fec_max, ulong slice_max, ulong block_max ) {
201212
int lg_fec_max = fd_ulong_find_msb( fd_ulong_pow2_up( fec_max ) );
202213
int lg_block_max = fd_ulong_find_msb( fd_ulong_pow2_up( block_max ) );
203214
return FD_LAYOUT_FINI(
204-
FD_LAYOUT_APPEND(
205-
FD_LAYOUT_APPEND(
206-
FD_LAYOUT_APPEND(
207-
FD_LAYOUT_APPEND(
208-
FD_LAYOUT_APPEND(
209-
FD_LAYOUT_APPEND(
210-
FD_LAYOUT_APPEND(
211-
FD_LAYOUT_INIT,
212-
alignof(fd_replay_t), sizeof(fd_replay_t) ),
213-
fd_replay_fec_map_align(), fd_replay_fec_map_footprint( lg_fec_max ) ),
214-
fd_replay_fec_deque_align(), fd_replay_fec_deque_footprint( fec_max ) ),
215-
fd_replay_idxs_map_align(), fd_replay_idxs_map_footprint( lg_block_max ) ),
216-
FD_SLICE_ALIGN, FD_SLICE_MAX ),
217-
fd_replay_slice_map_align(), fd_replay_slice_map_footprint( lg_block_max ) ),
218-
fd_replay_slice_deque_align(), fd_replay_slice_deque_footprint( slice_max ) * block_max ),
219-
fd_replay_align() );
215+
FD_LAYOUT_APPEND(
216+
FD_LAYOUT_APPEND(
217+
FD_LAYOUT_APPEND(
218+
FD_LAYOUT_APPEND(
219+
FD_LAYOUT_APPEND(
220+
FD_LAYOUT_APPEND(
221+
FD_LAYOUT_INIT,
222+
alignof(fd_replay_t), sizeof(fd_replay_t) ),
223+
fd_replay_fec_map_align(), fd_replay_fec_map_footprint( lg_fec_max ) ),
224+
fd_replay_fec_deque_align(), fd_replay_fec_deque_footprint( fec_max ) ),
225+
fd_replay_idxs_map_align(), fd_replay_idxs_map_footprint( lg_block_max ) ),
226+
fd_replay_slice_map_align(), fd_replay_slice_map_footprint( lg_block_max ) ),
227+
fd_replay_slice_deque_align(), fd_replay_slice_deque_footprint( slice_max ) * block_max ),
228+
fd_replay_align() );
220229
}
221230

222231
/* fd_replay_new formats an unused memory region for use as a replay.
@@ -279,6 +288,17 @@ fd_replay_fec_insert( fd_replay_t * replay, ulong slot, uint fec_set_idx ) {
279288
return fec;
280289
}
281290

291+
static inline fd_replay_idxs_t *
292+
fd_replay_idxs_insert( fd_replay_t * replay, ulong slot ) {
293+
fd_replay_idxs_t * idxs = fd_replay_idxs_map_insert( replay->idxs_map, slot );
294+
if ( FD_UNLIKELY( !idxs ) ) return NULL;
295+
idxs->slot = slot;
296+
idxs->wmark = ULONG_MAX;
297+
fd_replay_idxs_set_null( idxs->shred_received_idxs );
298+
fd_replay_fec_idxs_null( idxs->data_completes_idxs );
299+
return idxs;
300+
}
301+
282302
/* fd_replay_fec_query removes an in-progress FEC set from the map.
283303
Returns NULL if no fec set keyed by slot and fec_set_idx is found. */
284304

@@ -290,6 +310,14 @@ fd_replay_fec_remove( fd_replay_t * replay, ulong slot, uint fec_set_idx ) {
290310
fd_replay_fec_map_remove( replay->fec_map, fec ); /* cannot fail */
291311
}
292312

313+
static inline void
314+
fd_replay_idxs_set_range( fd_replay_idxs_set_t * set, uint start_idx, uint end_idx ) {
315+
/* TODO: change to better */
316+
for( uint i = start_idx; i < end_idx; i++ ) {
317+
fd_replay_idxs_set_insert( set, i );
318+
}
319+
}
320+
293321
FD_PROTOTYPES_END
294322

295323
#endif /* HEADER_fd_src_discof_replay_fd_replay_h */

‎src/discof/replay/fd_replay_tile.c

Lines changed: 68 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -240,6 +240,7 @@ struct fd_replay_tile_ctx {
240240

241241
ulong fecs_inserted;
242242
ulong fecs_removed;
243+
fd_shred_t shred[1];
243244
/* Other metadata */
244245

245246
ulong funk_seed;
@@ -430,13 +431,27 @@ publish_stake_weights( fd_replay_tile_ctx_t * ctx,
430431

431432
/* Polls the blockstore block info object for newly completed slices of
432433
slot. Adds it to the tail of slice_deque (which should be the
433-
slice_deque object of the slot, slice_map[slot]) */
434+
slice_deque object of the slot, slice_map[slot]). Currently used as
435+
a fallback, as there are shreds that pass through repair but not shred
436+
tile before getting added to blockstore, so replay doesn't know of
437+
their existence until they poll the block info itself. Typically will
438+
be used heavily during repair / catching up, and only occasionally
439+
after we are caught up / executing turbine shreds. */
434440

435441
int
436-
slice_poll( fd_replay_tile_ctx_t * ctx,
442+
slice_poll_block_info( fd_replay_tile_ctx_t * ctx,
437443
fd_replay_slice_t * slice_deque,
438444
ulong slot ) {
439445
uint consumed_idx, slices_added;
446+
447+
fd_replay_idxs_t * shred_idxs = fd_replay_idxs_map_query( ctx->replay->idxs_map, slot, NULL );
448+
uint turbine_shred_wmark;
449+
if( !shred_idxs ) {
450+
turbine_shred_wmark = UINT_MAX;
451+
} else {
452+
turbine_shred_wmark = (uint)shred_idxs->wmark;
453+
}
454+
440455
for(;;) { /* speculative query */
441456
fd_block_map_query_t query[1] = { 0 };
442457
int err = fd_block_map_query_try( ctx->blockstore->block_map, &slot, NULL, query, 0 );
@@ -445,7 +460,7 @@ slice_poll( fd_replay_tile_ctx_t * ctx,
445460
if( FD_UNLIKELY( err == FD_MAP_ERR_KEY ) ) return 0;
446461
if( FD_UNLIKELY( err == FD_MAP_ERR_AGAIN ) ) continue;
447462

448-
consumed_idx = block_info->consumed_idx;
463+
consumed_idx = fd_uint_min( block_info->consumed_idx, turbine_shred_wmark );
449464
slices_added = 0;
450465

451466
if( FD_UNLIKELY( block_info->buffered_idx == UINT_MAX ) ) return 1;
@@ -454,7 +469,7 @@ slice_poll( fd_replay_tile_ctx_t * ctx,
454469
if( FD_UNLIKELY( fd_block_set_test( block_info->data_complete_idxs, idx ) ) ) {
455470
slices_added++;
456471
fd_replay_slice_deque_push_tail( slice_deque->deque, ((ulong)(consumed_idx + 1) << 32) | ((ulong)idx) );
457-
FD_LOG_INFO(( "adding slice replay: slot %lu, slice start: %u, slice end: %u", slot, consumed_idx + 1, idx ));
472+
FD_LOG_INFO(( "adding slice replay from repair: slot %lu, slice start: %u, slice end: %u", slot, consumed_idx + 1, idx ));
458473
consumed_idx = idx;
459474
}
460475
}
@@ -476,6 +491,33 @@ slice_poll( fd_replay_tile_ctx_t * ctx,
476491
return 0;
477492
}
478493

494+
ulong
495+
slice_poll_shred_idxs( fd_replay_tile_ctx_t * ctx,
496+
fd_replay_slice_t * slice_deque,
497+
ulong slot ) {
498+
fd_replay_idxs_t * shred_idxs = fd_replay_idxs_map_query( ctx->replay->idxs_map, slot, NULL );
499+
ulong slices_added = 0;
500+
for( ulong idx = shred_idxs->wmark + 1; idx < FD_SHRED_MAX_PER_SLOT; idx++ ) {
501+
if( !fd_replay_idxs_set_test( shred_idxs->shred_received_idxs, idx ) ) {
502+
/* Contiguous shred not recieved; exit now.
503+
There may be ways to exit even earlier; */
504+
return slices_added;
505+
}
506+
if( FD_UNLIKELY( fd_replay_idxs_set_test( shred_idxs->data_completes_idxs, idx ) ) ) {
507+
/* Batch completed */
508+
slices_added++;
509+
fd_replay_slice_deque_push_tail( slice_deque->deque, ((ulong)(shred_idxs->wmark + 1) << 32) | ((ulong)idx) );
510+
FD_LOG_INFO(( "adding slice replay: slot %lu, slice start: %lu, slice end: %lu", slot, shred_idxs->wmark + 1, idx ));
511+
shred_idxs->wmark = idx;
512+
}
513+
}
514+
/* TODO: how do I know if it's done to evict from the map? We need
515+
slot complete idx maybe. */
516+
return slices_added;
517+
}
518+
519+
520+
479521
static int
480522
before_frag( fd_replay_tile_ctx_t * ctx,
481523
ulong in_idx,
@@ -484,6 +526,10 @@ before_frag( fd_replay_tile_ctx_t * ctx,
484526
(void)ctx;
485527
(void)seq;
486528

529+
if( in_idx == STORE_IN_IDX ) {
530+
FD_LOG_WARNING((" RECEIVE STORE MESSAGE: slot %lu", fd_disco_replay_old_sig_slot( sig )));
531+
}
532+
487533
if( in_idx == SHRED_IN_IDX ) {
488534
// FD_LOG_NOTICE(( "shred in idx: %lu, seq: %lu, sig: %lu", in_idx, seq, sig ));
489535

@@ -505,7 +551,8 @@ before_frag( fd_replay_tile_ctx_t * ctx,
505551
fd_replay_idxs_t * idxs = fd_replay_idxs_map_query( ctx->replay->idxs_map, slot, NULL );
506552
if ( FD_UNLIKELY( !idxs ) ) {
507553
idxs = fd_replay_idxs_map_insert( ctx->replay->idxs_map, slot );
508-
idxs->wmark = 0;
554+
idxs->wmark = ULONG_MAX;
555+
idxs->slot = slot;
509556
fd_replay_idxs_set_null( idxs->shred_received_idxs );
510557
fd_replay_idxs_set_null( idxs->data_completes_idxs );
511558
}
@@ -519,7 +566,10 @@ before_frag( fd_replay_tile_ctx_t * ctx,
519566

520567
fd_replay_fec_remove( ctx->replay, slot, fec_set_idx );
521568
ctx->fecs_removed++;
522-
slice_poll( ctx, slice_deque, slot );
569+
if( FD_UNLIKELY( data_completes ) ) {
570+
/* Batch complete flag, potential to get an executable slice. */
571+
slice_poll_shred_idxs( ctx, slice_deque, slot );
572+
}
523573
return 0; /* don't skip - contains merkle root and chained merkle root */
524574
}
525575

@@ -531,7 +581,7 @@ before_frag( fd_replay_tile_ctx_t * ctx,
531581

532582
fd_replay_fec_t * fec = fd_replay_fec_query( ctx->replay, slot, fec_set_idx );
533583
if( FD_UNLIKELY( !fec ) ) { /* first time receiving a shred for this FEC set */
534-
FD_LOG_NOTICE(( "inserting FEC set %u from slot %lu", fec_set_idx, slot ));
584+
FD_LOG_INFO(( "inserting FEC set %u into slot %lu", fec_set_idx, slot ));
535585
fec = fd_replay_fec_insert( ctx->replay, slot, fec_set_idx );
536586
ctx->fecs_inserted++;
537587
/* TODO implement eviction */
@@ -557,8 +607,6 @@ during_frag( fd_replay_tile_ctx_t * ctx,
557607
ulong chunk,
558608
ulong sz,
559609
ulong ctl FD_PARAM_UNUSED ) {
560-
return;
561-
562610
ctx->skip_frag = 0;
563611

564612
if( in_idx == STORE_IN_IDX ) {
@@ -572,6 +620,7 @@ during_frag( fd_replay_tile_ctx_t * ctx,
572620
Microblock as a list of fd_txn_p_t (sz * sizeof(fd_txn_p_t)) */
573621

574622
ctx->curr_slot = fd_disco_replay_old_sig_slot( sig );
623+
FD_LOG_WARNING(("store sent slot %lu", ctx->curr_slot));
575624
/* slot changes */
576625
if( FD_UNLIKELY( ctx->curr_slot < fd_fseq_query( ctx->published_wmark ) ) ) {
577626
FD_LOG_WARNING(( "store sent slot %lu before our root.", ctx->curr_slot ));
@@ -631,8 +680,8 @@ during_frag( fd_replay_tile_ctx_t * ctx,
631680
if( FD_UNLIKELY( chunk<shred_in->chunk0 || chunk>shred_in->wmark || sz > sizeof(fd_shred34_t) ) ) {
632681
FD_LOG_ERR(( "chunk %lu %lu corrupt, not in range [%lu,%lu]", chunk, sz, shred_in->chunk0 , shred_in->wmark ));
633682
}
634-
// uchar * src = (uchar *)fd_chunk_to_laddr( shred_in->mem, chunk );
635-
// fd_memcpy( (uchar *)ctx->shred, src, sz ); /* copy the hdr to read the code_cnt & data_cnt */
683+
uchar * src = (uchar *)fd_chunk_to_laddr( shred_in->mem, chunk );
684+
fd_memcpy( (uchar *)ctx->shred, src, sz ); /* copy the hdr to read the code_cnt & data_cnt */
636685

637686
ctx->skip_frag = 1;
638687

@@ -1690,7 +1739,7 @@ exec_slices( fd_replay_tile_ctx_t * ctx,
16901739

16911740
if( ctx->last_completed_slot != slot && fd_replay_slice_deque_cnt( slice->deque ) == 0 ) {
16921741
FD_LOG_INFO(( "Failed to query slice deque for slot %lu. Likely shreds were recieved through repair. Manually adding.", slot ));
1693-
slice_poll( ctx, slice, slot );
1742+
slice_poll_block_info( ctx, slice, slot );
16941743
}
16951744

16961745
//ulong free_exec_tiles = ctx->exec_cnt;
@@ -1889,12 +1938,10 @@ after_frag( fd_replay_tile_ctx_t * ctx,
18891938
(void)sig;
18901939
(void)sz;
18911940
(void)seq;
1892-
return;
1941+
//return;
18931942

1894-
/*if( FD_LIKELY( in_idx == SHRED_IN_IDX ) ) {
1895-
1896-
after_frag only called if it's the first code shred we're
1897-
receiving for the FEC set
1943+
if( FD_LIKELY( in_idx == SHRED_IN_IDX ) ) {
1944+
/* We are here if any of the slot / shred idx numbers have been overrun */
18981945

18991946
ulong slot = fd_disco_shred_replay_sig_slot( sig );
19001947
uint fec_set_idx = fd_disco_shred_replay_sig_fec_set_idx( sig );
@@ -1904,7 +1951,7 @@ after_frag( fd_replay_tile_ctx_t * ctx,
19041951
fec->data_cnt = ctx->shred->code.data_cnt;
19051952

19061953
return;
1907-
}*/
1954+
}
19081955

19091956
if( FD_UNLIKELY( ctx->skip_frag ) ) return;
19101957
if( FD_UNLIKELY( in_idx == STORE_IN_IDX ) ) {
@@ -2445,9 +2492,9 @@ after_credit( fd_replay_tile_ctx_t * ctx,
24452492
}
24462493
}
24472494

2448-
// exec_slices( ctx, stem, ctx->curr_slot );
2495+
exec_slices( ctx, stem, ctx->curr_slot );
24492496

2450-
return;
2497+
//return;
24512498

24522499
ulong curr_slot = ctx->curr_slot;
24532500
ulong parent_slot = ctx->parent_slot;
@@ -2710,7 +2757,7 @@ after_credit( fd_replay_tile_ctx_t * ctx,
27102757

27112758
static void
27122759
during_housekeeping( void * _ctx ) {
2713-
return;
2760+
//return;
27142761

27152762
fd_replay_tile_ctx_t * ctx = (fd_replay_tile_ctx_t *)_ctx;
27162763

0 commit comments

Comments
 (0)