pack,poh: when pack in perf mode, end slot when poh is done

Author: ptaffet-jump

src/app/fdctl/topology.c

@@ -431,6 +431,7 @@ fd_topo_initialize( config_t * config ) {
       tile->poh.plugins_enabled = plugins_enabled;
       tile->poh.bank_cnt = config->layout.bank_tile_count;
       tile->poh.lagged_consecutive_leader_start = config->tiles.poh.lagged_consecutive_leader_start;
+      tile->poh.perf_mode = (config->tiles.pack.schedule_strategy_enum==0);
 
       if( FD_UNLIKELY( config->tiles.bundle.enabled ) ) {
         tile->poh.bundle.enabled = 1;

src/disco/fd_disco_base.h

@@ -18,7 +18,11 @@
 #define POH_PKT_TYPE_MICROBLOCK    (0UL)
 #define POH_PKT_TYPE_BECAME_LEADER (1UL)
 #define POH_PKT_TYPE_DONE_PACKING  (2UL)
+#define POH_PKT_TYPE_DONE_HASHING  (2UL)
 #define POH_PKT_TYPE_FEAT_ACT_SLOT (3UL)
+/* Since we're out of bits, alias DONE_PACKING and DONE_HASHING.
+   DONE_PACKING will be set from pack, but DONE_HASHING will only be
+   sent from poh to pack, so they don't actually conflict. */
 
 #define REPLAY_FLAG_FINISHED_BLOCK      (0x01UL)
 #define REPLAY_FLAG_PACKED_MICROBLOCK   (0x02UL)

src/disco/gui/fd_gui_tile.c

@@ -216,9 +216,10 @@ after_frag( fd_gui_ctx_t *      ctx,
 
   if( FD_LIKELY( ctx->in_kind[ in_idx ]==IN_KIND_PLUGIN ) ) fd_gui_plugin_message( ctx->gui, sig, ctx->buf );
   else if( FD_UNLIKELY( ctx->in_kind[ in_idx ]==IN_KIND_POH_PACK ) ) {
-    FD_TEST( fd_disco_poh_sig_pkt_type( sig )==POH_PKT_TYPE_BECAME_LEADER );
-    fd_became_leader_t * became_leader = (fd_became_leader_t *)ctx->buf;
-    fd_gui_became_leader( ctx->gui, fd_frag_meta_ts_decomp( tspub, fd_tickcount() ), fd_disco_poh_sig_slot( sig ), became_leader->slot_start_ns, became_leader->slot_end_ns, became_leader->limits.slot_max_cost, became_leader->max_microblocks_in_slot );
+    if( FD_LIKELY( fd_disco_poh_sig_pkt_type( sig )==POH_PKT_TYPE_BECAME_LEADER ) ) {
+      fd_became_leader_t * became_leader = (fd_became_leader_t *)ctx->buf;
+      fd_gui_became_leader( ctx->gui, fd_frag_meta_ts_decomp( tspub, fd_tickcount() ), fd_disco_poh_sig_slot( sig ), became_leader->slot_start_ns, became_leader->slot_end_ns, became_leader->limits.slot_max_cost, became_leader->max_microblocks_in_slot );
+    }
   } else if( FD_UNLIKELY( ctx->in_kind[ in_idx ]==IN_KIND_PACK_BANK ) ) {
     if( FD_LIKELY( fd_disco_poh_sig_pkt_type( sig )==POH_PKT_TYPE_MICROBLOCK ) ) {
       FD_TEST( sz<ULONG_MAX );

src/disco/pack/fd_pack_tile.c

@@ -128,6 +128,9 @@ typedef struct {
 
   /* One of the FD_PACK_STRATEGY_* values defined above */
   int      strategy;
+  /* Set to 1 when we get a message from PoH indicating it's pretty much
+     done with the slot.  Only matters if strategy==PERF */
+  int      poh_done;
 
   /* The value passed to fd_pack_new, etc. */
   ulong    max_pending_transactions;
@@ -544,6 +547,7 @@ after_credit( fd_pack_ctx_t *     ctx,
     ctx->drain_banks         = 1;
     ctx->leader_slot         = ULONG_MAX;
     ctx->slot_microblock_cnt = 0UL;
+    ctx->poh_done            = 0;
     fd_pack_end_block( ctx->pack );
     remove_ib( ctx );
 
@@ -583,6 +587,15 @@ after_credit( fd_pack_ctx_t *     ctx,
   if( FD_UNLIKELY( (ulong)(now-ctx->last_successful_insert) <
         ctx->wait_duration_ticks[ fd_ulong_min( fd_pack_avail_txn_cnt( ctx->pack ), MAX_TXN_PER_MICROBLOCK ) ] ) ) {
     update_metric_state( ctx, now, FD_PACK_METRIC_STATE_TRANSACTIONS, 0 );
+
+    if( FD_UNLIKELY( (ctx->strategy==FD_PACK_STRATEGY_PERF) &
+          (ctx->bank_idle_bitset==fd_ulong_mask_lsb( (int)bank_cnt )) &
+          ctx->poh_done ) ) {
+      FD_LOG_INFO(( "pack_end_early(ms=%li, reason=txn)", (ctx->slot_end_ns - ctx->approx_wallclock_ns)/1000000L ));
+      /* In perf mode, if PoH is done, we're out of transactions, and we
+         can't schedule anything, just try to end the block ASAP. */
+      ctx->slot_end_ns = ctx->approx_wallclock_ns;
+    }
     return;
   }
 
@@ -715,6 +728,14 @@ after_credit( fd_pack_ctx_t *     ctx,
 
       memcpy( ctx->last_sched_metrics->all, (ulong const *)fd_metrics_tl, sizeof(ctx->last_sched_metrics->all) );
       ctx->last_sched_metrics->time = now2;
+    } else if( FD_UNLIKELY( (ctx->strategy==FD_PACK_STRATEGY_PERF) &
+          (ctx->bank_idle_bitset==fd_ulong_mask_lsb( (int)bank_cnt )) &
+          ctx->poh_done ) ) {
+      FD_LOG_INFO(( "pack_end_early(ms=%li, reason=sched)", (ctx->slot_end_ns - ctx->approx_wallclock_ns)/1000000L ));
+      /* In perf mode, if PoH is done and we can't schedule anything
+         even though all the banks are idle, just schedule ending the
+         block ASAP. */
+      ctx->slot_end_ns = ctx->approx_wallclock_ns;
     }
   }
 
@@ -748,6 +769,7 @@ after_credit( fd_pack_ctx_t *     ctx,
     ctx->drain_banks         = 1;
     ctx->leader_slot         = ULONG_MAX;
     ctx->slot_microblock_cnt = 0UL;
+    ctx->poh_done            = 0;
     fd_pack_end_block( ctx->pack );
     remove_ib( ctx );
 
@@ -771,7 +793,13 @@ during_frag( fd_pack_ctx_t * ctx,
 
   switch( ctx->in_kind[ in_idx ] ) {
   case IN_KIND_POH: {
-      /* Not interested in stamped microblocks, only leader updates. */
+    /* Not interested in stamped microblocks, only leader updates and
+       possibly done hashing messages. */
+    if( FD_UNLIKELY( fd_disco_poh_sig_pkt_type( sig )==POH_PKT_TYPE_DONE_HASHING ) ) {
+      ctx->poh_done = ctx->leader_slot == fd_disco_poh_sig_slot( sig );
+      FD_LOG_INFO(( "PoH done %i hashing for slot %lu", ctx->poh_done, fd_disco_poh_sig_slot( sig ) ));
+    }
+
     if( fd_disco_poh_sig_pkt_type( sig )!=POH_PKT_TYPE_BECAME_LEADER ) return;
 
     /* There was a leader transition.  Handle it. */
@@ -787,6 +815,7 @@ during_frag( fd_pack_ctx_t * ctx,
       ctx->drain_banks         = 1;
       ctx->leader_slot         = ULONG_MAX;
       ctx->slot_microblock_cnt = 0UL;
+      ctx->poh_done            = 0;
       fd_pack_end_block( ctx->pack );
       remove_ib( ctx );
     }
@@ -796,6 +825,7 @@ during_frag( fd_pack_ctx_t * ctx,
     FD_MCNT_INC( PACK, TRANSACTION_EXPIRED, exp_cnt );
 
     fd_became_leader_t * became_leader = (fd_became_leader_t *)dcache_entry;
+    ctx->poh_done             = 0;
     ctx->leader_bank          = became_leader->bank;
     ctx->slot_max_microblocks = became_leader->max_microblocks_in_slot;
     /* Reserve some space in the block for ticks */
@@ -1175,6 +1205,7 @@ unprivileged_init( fd_topo_t *      topo,
   ctx->cur_spot                      = NULL;
   ctx->is_bundle                     = 0;
   ctx->strategy                      = tile->pack.schedule_strategy;
+  ctx->poh_done                      = 0;
   ctx->max_pending_transactions      = tile->pack.max_pending_transactions;
   ctx->leader_slot                   = ULONG_MAX;
   ctx->leader_bank                   = NULL;

src/disco/topo/fd_topo.h

@@ -234,6 +234,7 @@ struct fd_topo_tile {
     struct {
       int   lagged_consecutive_leader_start;
       int   plugins_enabled;
+      int   perf_mode;
       ulong bank_cnt;
       char  identity_key_path[ PATH_MAX ];
       struct {

src/discoh/poh/fd_poh_tile.c

@@ -387,6 +387,13 @@ typedef struct {
      microblocks that the pack tile can publish in each slot. */
   ulong max_microblocks_per_slot;
 
+  /* If perf_mode==1, then instead of using slot_duration_ns and
+     hashcnt_duration_ns to pace hashes during our leader slot, we just
+     hash as fast as possible.  In practice, this means we'll hardly mix
+     in any transactions for the first portion of the slot, which can
+     cause backpressure. */
+  int   perf_mode;
+
   /* Consensus-critical slot cost limits. */
   struct {
     ulong slot_max_cost;
@@ -483,6 +490,10 @@ typedef struct {
   /* If an in progress frag should be skipped */
   int skip_frag;
 
+  /* If the poh tile has sent a DONE_HASHING message to pack for this
+     slot. */
+  int sent_done_hashing;
+
   ulong max_active_descendant;
 
   /* If we currently are the leader according the clock AND we have
@@ -1096,6 +1107,7 @@ fd_ext_poh_begin_leader( void const * bank,
   ctx->microblocks_lower_bound = 0UL;
   ctx->cus_used                = 0UL;
   ctx->expect_microblock_idx   = 0UL;
+  ctx->sent_done_hashing       = 0;
 
   ctx->limits.slot_max_cost                = cus_block_limit;
   ctx->limits.slot_max_vote_cost           = cus_vote_cost_limit;
@@ -1243,9 +1255,10 @@ fd_ext_poh_reset( ulong         completed_bank_slot, /* The slot that successful
 
        But: if we were leader in the prior slot, and the block was our
        own we can do better.  We know that the next slot should start
-       exactly 400ms after the prior one started, so we can use that as
-       the reset slot start time instead. */
-    ctx->reset_slot_start_ns = ctx->reset_slot_start_ns + (long)((double)((completed_bank_slot+1UL)-ctx->reset_slot)*ctx->slot_duration_ns);
+       no later than 400ms after the prior one started, so we can use
+       that as the reset slot start time instead. */
+    ctx->reset_slot_start_ns = fd_long_min( ctx->reset_slot_start_ns + (long)((double)((completed_bank_slot+1UL)-ctx->reset_slot)*ctx->slot_duration_ns),
+                                            ctx->leader_bank_start_ns );
   } else {
     ctx->reset_slot_start_ns = ctx->leader_bank_start_ns;
   }
@@ -1631,7 +1644,7 @@ after_credit( fd_poh_ctx_t *      ctx,
   ulong target_hashcnt;
   if( FD_LIKELY( !is_leader ) ) {
     target_hashcnt = (ulong)((double)(now - ctx->reset_slot_start_ns) / ctx->hashcnt_duration_ns) - (ctx->slot-ctx->reset_slot)*ctx->hashcnt_per_slot;
-  } else {
+  } else if( FD_LIKELY( ctx->perf_mode==0 ) ) {
     /* We might have gotten very behind on hashes, but if we are leader
        we want to catch up gradually over the remainder of our leader
        slot, not all at once right now.  This helps keep the tile from
@@ -1641,7 +1654,10 @@ after_credit( fd_poh_ctx_t *      ctx,
     double actual_slot_duration_ns = ctx->slot_duration_ns<(double)(ctx->leader_bank_start_ns - expected_slot_start_ns) ? 0.0 : ctx->slot_duration_ns - (double)(ctx->leader_bank_start_ns - expected_slot_start_ns);
     double actual_hashcnt_duration_ns = actual_slot_duration_ns / (double)ctx->hashcnt_per_slot;
     target_hashcnt = fd_ulong_if( actual_hashcnt_duration_ns==0.0, restricted_hashcnt, (ulong)((double)(now - ctx->leader_bank_start_ns) / actual_hashcnt_duration_ns) );
+  } else {
+    target_hashcnt = ULONG_MAX; /* It gets clamped down immediately */
   }
+
   /* Clamp to [min_hashcnt, restricted_hashcnt] as above */
   target_hashcnt = fd_ulong_max( fd_ulong_min( target_hashcnt, restricted_hashcnt ), min_hashcnt );
 
@@ -1689,9 +1705,13 @@ after_credit( fd_poh_ctx_t *      ctx,
 
   *charge_busy = 1;
 
-  if( FD_LIKELY( ctx->hashcnt<target_hashcnt ) ) {
-    fd_sha256_hash_32_repeated( ctx->hash, ctx->hash, target_hashcnt-ctx->hashcnt );
-    ctx->hashcnt = target_hashcnt;
+  fd_sha256_hash_32_repeated( ctx->hash, ctx->hash, target_hashcnt-ctx->hashcnt );
+  ctx->hashcnt = target_hashcnt;
+
+  if( FD_UNLIKELY( (ctx->hashcnt==restricted_hashcnt) && (!ctx->sent_done_hashing) ) ) {
+    ulong sig = fd_disco_poh_sig( ctx->slot, POH_PKT_TYPE_DONE_HASHING, 0UL );
+    fd_stem_publish( ctx->stem, ctx->pack_out->idx, sig, ctx->pack_out->chunk, 0UL, 0UL, 0UL, 0UL );
+    ctx->sent_done_hashing = 1;
   }
 
   if( FD_UNLIKELY( ctx->hashcnt==ctx->hashcnt_per_slot ) ) {
@@ -2241,6 +2261,8 @@ unprivileged_init( fd_topo_t *      topo,
   ctx->highwater_leader_slot = ULONG_MAX;
   ctx->next_leader_slot      = ULONG_MAX;
   ctx->reset_slot            = ULONG_MAX;
+  ctx->sent_done_hashing     = 0;
+  ctx->perf_mode             = tile->poh.perf_mode;
 
   ctx->lagged_consecutive_leader_start = tile->poh.lagged_consecutive_leader_start;
   ctx->expect_sequential_leader_slot = ULONG_MAX;