feat(tower): confirmed frag rework

Author: lidatong

src/app/firedancer/topology.c

@@ -595,15 +595,18 @@ fd_topo_initialize( config_t * config ) {
                        fd_topob_tile_in (   topo, "replay",  0UL,          "metric_in", "snapin_manif", 0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   }
 
-  /**/                 fd_topob_tile_in(    topo, "replay",  0UL,          "metric_in", "poh_replay",   0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
-  FOR(exec_tile_cnt)   fd_topob_tile_in(    topo, "exec",    i,            "metric_in", "replay_exec",  0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
+  /**/                 fd_topob_tile_in (   topo, "replay",  0UL,          "metric_in", "poh_replay",   0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
+  FOR(exec_tile_cnt)   fd_topob_tile_in (   topo, "exec",    i,            "metric_in", "replay_exec",  0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
+
+  /**/                 fd_topob_tile_in (   topo, "tower",   0UL,          "metric_in", "dedup_resolv", 0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   /**/                 fd_topob_tile_in (   topo, "tower",   0UL,          "metric_in", "genesi_out",   0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   /**/                 fd_topob_tile_in (   topo, "tower",   0UL,          "metric_in", "gossip_out",   0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   /**/                 fd_topob_tile_in (   topo, "tower",   0UL,          "metric_in", "replay_out",   0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   if( snapshots_enabled ) {
                        fd_topob_tile_in (   topo, "tower",   0UL,          "metric_in", "snapin_manif", 0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   }
   /**/                 fd_topob_tile_out(   topo, "tower",   0UL,                       "tower_out",    0UL                                                );
+
   /**/                 fd_topob_tile_in (   topo, "send",    0UL,          "metric_in", "replay_stake", 0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   /**/                 fd_topob_tile_in (   topo, "send",    0UL,          "metric_in", "gossip_out",   0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   /**/                 fd_topob_tile_in (   topo, "send",    0UL,          "metric_in", "tower_out",    0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );

src/choreo/notar/fd_notar.c

@@ -94,31 +94,23 @@ fd_notar_delete( void * notar ) {
   return notar;
 }
 
-int
+fd_notar_blk_t *
 fd_notar_count_vote( fd_notar_t *        notar,
                      ulong               total_stake,
                      fd_pubkey_t const * addr,
                      ulong               vote_slot,
                      fd_hash_t const *   vote_block_id ) {
 
-  if( FD_UNLIKELY( !notar ) ) {
-    FD_LOG_WARNING(( "NULL notar" ));
-    return 0;
-  }
+  if( FD_UNLIKELY( !notar ) ) { FD_LOG_WARNING(( "NULL notar" )); return NULL; }
 
   /* Ignore if this vote slot isn't in range. */
 
-  if( FD_UNLIKELY( vote_slot < notar->lo_wmark || vote_slot > notar->hi_wmark ) ) return 0;
+  if( FD_UNLIKELY( vote_slot < notar->lo_wmark || vote_slot > notar->hi_wmark ) ) return NULL;
 
   /* Ignore if this vote account isn't in the voter set. */
 
   fd_notar_vtr_t const * vtr = fd_notar_vtr_query( notar->vtr_map, *addr, NULL );
-  if( FD_UNLIKELY( !vtr ) ) return 0;
-
-  /* Ignore if this notar blk was already duplicate confirmed. */
-
-  fd_notar_blk_t * notar_blk = fd_notar_blk_query( notar->blk_map, *vote_block_id, NULL );
-  if( FD_LIKELY( notar_blk && notar_blk->dup_conf ) ) return 0;
+  if( FD_UNLIKELY( !vtr ) ) return NULL;
 
   /* Check we haven't already counted the voter's stake for this slot.
      If a voter voted for multiple block ids for the same slot, we only
@@ -138,12 +130,13 @@ fd_notar_count_vote( fd_notar_t *        notar,
     fd_notar_slot_vtrs_null( notar_slot->prev_vtrs );
     fd_notar_slot_vtrs_null( notar_slot->vtrs );
   }
-  if( FD_LIKELY( fd_notar_slot_vtrs_test( notar_slot->vtrs, vtr->bit ) ) ) return 0;
+  if( FD_LIKELY( fd_notar_slot_vtrs_test( notar_slot->vtrs, vtr->bit ) ) ) return NULL;
   fd_notar_slot_vtrs_insert( notar_slot->vtrs, vtr->bit );
   notar_slot->stake += vtr->stake;
 
   /* Get the actual block with the block_id. */
 
+  fd_notar_blk_t * notar_blk = fd_notar_blk_query( notar->blk_map, *vote_block_id, NULL );
   if( FD_UNLIKELY( !notar_blk ) ) {
     notar_blk        = fd_notar_blk_insert( notar->blk_map, *vote_block_id );
     notar_blk->slot  = vote_slot;
@@ -152,8 +145,9 @@ fd_notar_count_vote( fd_notar_t *        notar,
     notar_slot->block_ids[notar_slot->block_ids_cnt++] = *vote_block_id;
   }
   notar_blk->stake   += vtr->stake;
-  notar_blk->dup_conf = (double)notar_blk->stake / (double)total_stake > 0.52; /* duplicate confirmed if > 52% stake */
-  return notar_blk->dup_conf;
+  notar_blk->dup_conf = ((double)notar_blk->stake / (double)total_stake) > 0.52;
+  notar_blk->opt_conf = ((double)notar_blk->stake / (double)total_stake) > (2.0/3.0);
+  return notar_blk;
 }
 
 void

src/choreo/notar/fd_notar.h

@@ -10,16 +10,16 @@
      important in two contexts:
 
      1. When becoming leader, we need to check that our "previous"
-         leader block _as of_ the parent slot we're building on, has
-         propagated. If it's not propagated, we need to instead
-         retransmit our last block that failed to propagate.  "Previous"
-         is quoted, because there is a grace period of one leader
-         rotation for leader blocks to propagate.
+        leader block _as of_ the parent slot we're building on, has
+        propagated.  If it's not propagated, we need to instead
+        retransmit our last block that failed to propagate.  "Previous"
+        is quoted, because there is a grace period of one leader
+        rotation for leader blocks to propagate.
 
      2. When voting, we need to check our previous leader block _as of_
-         the slot we're voting for has propagated (unless we're voting
-         for one of our leader blocks).  We cannot vote for slots in
-         which our last leader block failed to propagate.
+        the slot we're voting for has propagated (unless we're voting
+        for one of our leader blocks).  We cannot vote for slots in
+        which our last leader block failed to propagate.
 
    - duplicate confirmed: a block is duplicate confirmed if it has
      received votes from at least 52% of stake in the cluster.  The
@@ -85,6 +85,10 @@
 #define FD_NOTAR_PARANOID 1
 #endif
 
+#define FD_NOTAR_FLAG_CONFIRMED_PROPAGATED (0)
+#define FD_NOTAR_FLAG_CONFIRMED_DUPLICATE  (1)
+#define FD_NOTAR_FLAG_CONFIRMED_OPTIMISTIC (2)
+
 #define SET_NAME fd_notar_slot_vtrs
 #define SET_MAX  FD_VOTER_MAX
 #include "../../util/tmpl/fd_set.c"
@@ -95,7 +99,7 @@ struct fd_notar_slot {
   ulong prev_leader_slot; /* previous slot in which we were leader */
   ulong stake;            /* amount of stake that has voted for this slot */
   int   is_leader;        /* whether this slot was our own leader slot */
-  int   is_propagated;    /* whether this slot has reached 33% of stake */
+  int   is_propagated;    /* whether this slot has reached 1/3 of stake */
 
   fd_hash_t block_ids[FD_VOTER_MAX]; /* one block id per voter per slot */
   ulong     block_ids_cnt;           /* count of block ids */
@@ -105,13 +109,13 @@ struct fd_notar_slot {
 };
 typedef struct fd_notar_slot fd_notar_slot_t;
 
-
 struct fd_notar_blk {
   fd_hash_t block_id; /* map key */
   uint      hash;     /* reserved for fd_map_dynamic */
   ulong     slot;     /* slot associated with this block */
   ulong     stake;    /* sum of stake that has voted for this block_id */
   int       dup_conf; /* whether this block has reached 52% of stake */
+  int       opt_conf; /* whether this block has reached 2/3 of stake */
 };
 typedef struct fd_notar_blk fd_notar_blk_t;
 
@@ -161,7 +165,7 @@ struct __attribute__((aligned(128UL))) fd_notar {
   ulong epoch;    /* highest replayed epoch */
   ulong lo_wmark; /* notar ignores votes < lo_wmark */
   ulong hi_wmark; /* notar ignores votes > hi_wmark */
-  ulong slot_max; /* maximum slot number */
+  ulong slot_max; /* maximum number of slots notar can track */
 
   fd_notar_slot_t * slot_map; /* tracks who has voted for a given slot */
   fd_notar_blk_t *  blk_map;  /* tracks amount of stake for a given block (keyed by block id) */
@@ -237,7 +241,7 @@ fd_notar_delete( void * notar );
    account in the current epoch, slot is slot being voted for, block_id
    is the voter's proposed block id for this vote slot. */
 
-int
+fd_notar_blk_t *
 fd_notar_count_vote( fd_notar_t *        notar,
                      ulong               total_stake,
                      fd_pubkey_t const * addr,

src/discof/repair/fd_repair_tile.c

@@ -774,7 +774,7 @@ after_frag( ctx_t * ctx,
         fd_policy_reset  ( ctx->policy, ctx->forest );
       }
     } else if( FD_LIKELY( sig == FD_TOWER_SIG_DUPLICATE_CONFIRMED ) ) {
-      fd_tower_duplicate_confirmed_t const * msg = (fd_tower_duplicate_confirmed_t const *)fd_type_pun_const( ctx->buffer );
+      fd_tower_slot_confirmed_t const * msg = (fd_tower_slot_confirmed_t const *)fd_type_pun_const( ctx->buffer );
       (void)msg;
     }
     return;