LCOV - code coverage report
Current view: top level - disco/gui - fd_gui.c (source / functions) Hit Total Coverage
Test: cov.lcov Lines: 1044 2912 35.9 %
Date: 2026-11-15 04:25:17 Functions: 54 100 54.0 %

          Line data    Source code
       1             : #include "fd_gui.h"
       2             : #include "fd_gui_printf.h"
       3             : #include "fd_gui_metrics.h"
       4             : #include "fd_gui_hist.h"
       5             : 
       6             : #include "../metrics/fd_metrics.h"
       7             : #include "../../discof/gossip/fd_gossip_tile.h"
       8             : #include "../bundle/fd_bundle_tile.h"
       9             : 
      10             : #include "../../ballet/base58/fd_base58.h"
      11             : #include "../../ballet/json/fd_jtok.h"
      12             : #include "../../ballet/shred/fd_shred.h"
      13             : #include "../../disco/genesis/fd_genesis_cluster.h"
      14             : #include "../../disco/pack/fd_pack.h"
      15             : #include "../../disco/pack/fd_pack_cost.h"
      16             : #include "../shred/fd_fec_set.h"
      17             : 
      18             : FD_STATIC_ASSERT( FD_FEC_SHRED_CNT==32UL, fec_shred_count );
      19             : 
      20             : #include <stdio.h>
      21             : 
      22             : FD_FN_CONST ulong
      23         621 : fd_gui_align( void ) {
      24         621 :   return 128UL;
      25         621 : }
      26             : 
      27             : ulong
      28             : fd_gui_footprint( ulong tile_cnt,
      29             :                   ulong max_live_slots,
      30         138 :                   ulong max_txn_per_slot ) {
      31         138 :   FD_TEST( tile_cnt && tile_cnt <=FD_DIAG_SYSTEM_TILE_MAX );
      32         138 :   FD_TEST( max_live_slots && max_live_slots<=ULONG_MAX/sizeof(fd_gui_ag_slot_t) );
      33         138 :   FD_TEST( max_txn_per_slot && max_txn_per_slot<=ULONG_MAX/sizeof(fd_gui_store_txn_start_t) );
      34             : 
      35         138 :   ulong l = FD_LAYOUT_INIT;
      36         138 :   l = FD_LAYOUT_APPEND( l, fd_gui_align(),                     sizeof(fd_gui_t) );
      37         138 :   l = FD_LAYOUT_APPEND( l, alignof(fd_gui_ag_slot_t),         max_live_slots*sizeof(fd_gui_ag_slot_t) );
      38         138 :   l = FD_LAYOUT_APPEND( l, fd_gui_rate_deque_align(),         fd_gui_rate_deque_footprint() ); /* ingress_maxq */
      39         138 :   l = FD_LAYOUT_APPEND( l, fd_gui_rate_deque_align(),         fd_gui_rate_deque_footprint() ); /* egress_maxq  */
      40         138 :   l = FD_LAYOUT_APPEND( l, fd_gui_hist_align(),               fd_gui_hist_footprint() );
      41         138 :   l = FD_LAYOUT_APPEND( l, alignof(fd_gui_store_txn_start_t), max_txn_per_slot*sizeof(fd_gui_store_txn_start_t) );
      42         138 :   l = FD_LAYOUT_APPEND( l, alignof(fd_gui_store_txn_end_t),   max_txn_per_slot*sizeof(fd_gui_store_txn_end_t)   );
      43         138 :   l = FD_LAYOUT_APPEND( l, alignof(fd_gui_slot_txn_join_t),   max_txn_per_slot*sizeof(fd_gui_slot_txn_join_t)   );
      44         138 :   l = FD_LAYOUT_APPEND( l, alignof(fd_gui_shred_scratch_t),   FD_GUI_SHRED_SCRATCH_MAX*sizeof(fd_gui_shred_scratch_t) );
      45         138 :   l = FD_LAYOUT_APPEND( l, alignof(long),                     FD_GUI_EXEC_DONE_SLOT_CNT*FD_SHRED_BLK_MAX*sizeof(long) );
      46         138 :   return FD_LAYOUT_FINI( l, fd_gui_align() );
      47         138 : }
      48             : 
      49             : static inline void
      50           0 : fd_gui_build_tile_order( fd_gui_t * gui ) {
      51           0 :   ulong tile_cnt   = gui->topo->tile_cnt;
      52           0 :   ulong order_cnt  = 0UL;
      53           0 :   uchar placed[ FD_DIAG_SYSTEM_TILE_MAX ] = {0};
      54             : 
      55           0 :   char const * const tile_display_order[] = {
      56           0 :     "gossvf", "gossip", "snapct", "snapld", "snapdc", "snapin",
      57           0 :     "net", "shred", "repair", "replay", "execrp", "votor", "sign",
      58           0 :     "quic", "verify", "dedup", "pack", "execle"
      59           0 :   };
      60             : 
      61           0 :   for( ulong n=0UL; n<sizeof(tile_display_order)/sizeof(tile_display_order[0]); n++ ) {
      62           0 :     for( ulong i=0UL; i<tile_cnt; i++ ) {
      63           0 :       if( FD_LIKELY( placed[ i ] ) ) continue;
      64           0 :       if( FD_UNLIKELY( !strcmp( gui->topo->tiles[ i ].name, tile_display_order[ n ] ) ) ) {
      65           0 :         gui->summary.tile[ order_cnt++ ] = i;
      66           0 :         placed[ i ] = 1;
      67           0 :       }
      68           0 :     }
      69           0 :   }
      70             : 
      71           0 :   for( ulong i=0UL; i<tile_cnt; i++ ) {
      72           0 :     if( FD_UNLIKELY( !placed[ i ] ) ) gui->summary.tile[ order_cnt++ ] = i;
      73           0 :   }
      74             : 
      75           0 :   gui->summary.tile_cnt = order_cnt;
      76           0 : }
      77             : 
      78             : void *
      79             : fd_gui_new( void *                   shmem,
      80             :             fd_http_server_t *       http,
      81             :             char const *             version,
      82             :             char const *             cluster,
      83             :             uchar const *            identity_key,
      84             :             int                      has_vote_key,
      85             :             uchar const *            vote_key,
      86             :             ulong                    max_live_slots,
      87             :             ulong                    max_txn_per_slot,
      88             :             int                      snapshots_enabled,
      89             :             int                      is_voting,
      90             :             int                      schedule_strategy,
      91             :             char const *             wfs_expected_bank_hash_cstr,
      92             :             ushort                   expected_shred_version,
      93             :             ulong                    wfs_slot,
      94             :             char const *             accounts_database_path,
      95             :             char const *             gui_database_path,
      96             :             void *                   db,
      97             :             fd_topo_t const *        topo,
      98             :             fd_accdb_shmem_t const * accdb_shmem,
      99           0 :             long                     now ) {
     100             : 
     101           0 :   if( FD_UNLIKELY( !shmem ) ) {
     102           0 :     FD_LOG_WARNING(( "NULL shmem" ));
     103           0 :     return NULL;
     104           0 :   }
     105             : 
     106           0 :   if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)shmem, fd_gui_align() ) ) ) {
     107           0 :     FD_LOG_WARNING(( "misaligned shmem" ));
     108           0 :     return NULL;
     109           0 :   }
     110             : 
     111           0 :   if( FD_UNLIKELY( topo->tile_cnt>FD_DIAG_SYSTEM_TILE_MAX ) ) {
     112           0 :     FD_LOG_WARNING(( "too many tiles" ));
     113           0 :     return NULL;
     114           0 :   }
     115             : 
     116           0 :   ulong tile_cnt = topo->tile_cnt;
     117             : 
     118           0 :   FD_SCRATCH_ALLOC_INIT( l, shmem );
     119           0 :   fd_gui_t * gui              = FD_SCRATCH_ALLOC_APPEND( l, fd_gui_align(),                    sizeof(fd_gui_t) );
     120           0 :   void *     ag_slot_mem      = FD_SCRATCH_ALLOC_APPEND( l, alignof(fd_gui_ag_slot_t),         max_live_slots*sizeof(fd_gui_ag_slot_t) );
     121           0 :   void *     ingress_maxq_mem = FD_SCRATCH_ALLOC_APPEND( l, fd_gui_rate_deque_align(),         fd_gui_rate_deque_footprint() );
     122           0 :   void *     egress_maxq_mem  = FD_SCRATCH_ALLOC_APPEND( l, fd_gui_rate_deque_align(),         fd_gui_rate_deque_footprint() );
     123           0 :   void *     hist_mem         = FD_SCRATCH_ALLOC_APPEND( l, fd_gui_hist_align(),               fd_gui_hist_footprint() );
     124           0 :   void *     txn_starts_mem   = FD_SCRATCH_ALLOC_APPEND( l, alignof(fd_gui_store_txn_start_t), max_txn_per_slot*sizeof(fd_gui_store_txn_start_t) );
     125           0 :   void *     txn_ends_mem     = FD_SCRATCH_ALLOC_APPEND( l, alignof(fd_gui_store_txn_end_t),   max_txn_per_slot*sizeof(fd_gui_store_txn_end_t)   );
     126           0 :   void *     txn_joined_mem   = FD_SCRATCH_ALLOC_APPEND( l, alignof(fd_gui_slot_txn_join_t),   max_txn_per_slot*sizeof(fd_gui_slot_txn_join_t)   );
     127           0 :   void *     shred_sc_mem     = FD_SCRATCH_ALLOC_APPEND( l, alignof(fd_gui_shred_scratch_t),   FD_GUI_SHRED_SCRATCH_MAX*sizeof(fd_gui_shred_scratch_t) );
     128           0 :   void *     exec_done_mem    = FD_SCRATCH_ALLOC_APPEND( l, alignof(long),                     FD_GUI_EXEC_DONE_SLOT_CNT*FD_SHRED_BLK_MAX*sizeof(long) );
     129             : 
     130           0 :   gui->slot_txn_scratch.max    = max_txn_per_slot;
     131           0 :   gui->slot_txn_scratch.starts = txn_starts_mem;
     132           0 :   gui->slot_txn_scratch.ends   = txn_ends_mem;
     133           0 :   gui->slot_txn_scratch.joined = txn_joined_mem;
     134           0 :   gui->shred_scratch.ev        = shred_sc_mem;
     135           0 :   gui->shred_scratch.max       = FD_GUI_SHRED_SCRATCH_MAX;
     136           0 :   gui->exec_done.ts            = exec_done_mem;
     137           0 :   for( ulong i=0UL; i<FD_GUI_EXEC_DONE_SLOT_CNT; i++ ) gui->exec_done.slot[ i ] = ULONG_MAX;
     138             : 
     139           0 :   gui->http        = http;
     140           0 :   gui->topo        = topo;
     141           0 :   gui->accdb_shmem = accdb_shmem;
     142           0 :   gui->tick_per_ns = fd_tempo_tick_per_ns( NULL );
     143           0 :   gui->tile_cnt    = tile_cnt;
     144             : 
     145           0 :   gui->db   = db;
     146           0 :   gui->hist = fd_gui_hist_join( fd_gui_hist_new( hist_mem, (fd_gui_store_t const *)db ) );
     147           0 :   if( FD_UNLIKELY( !gui->hist ) ) {
     148           0 :     FD_LOG_WARNING(( "fd_gui_hist_new failed" ));
     149           0 :     return NULL;
     150           0 :   }
     151             : 
     152           0 :   gui->summary.ingress_maxq = fd_gui_rate_deque_join( fd_gui_rate_deque_new( ingress_maxq_mem ) );
     153           0 :   gui->summary.egress_maxq  = fd_gui_rate_deque_join( fd_gui_rate_deque_new( egress_maxq_mem  ) );
     154             : 
     155           0 :   gui->summary.network_stats_has_prev = 0;
     156           0 :   gui->summary.net_rate_prev_ts       = 0L;
     157           0 :   for( ulong i=0UL; i<FD_GUI_NET_PROTO_CNT; i++ ) {
     158           0 :     fd_gui_ema_init( &gui->summary.ingress_ema[ i ], now, FD_GUI_NETWORK_EMA_HALF_LIFE_NS );
     159           0 :     fd_gui_ema_init( &gui->summary.egress_ema [ i ], now, FD_GUI_NETWORK_EMA_HALF_LIFE_NS );
     160           0 :   }
     161             : 
     162           0 :   gui->leader_begin_slot       = 0UL;
     163           0 :   gui->leader_end_slot         = 0UL;
     164           0 :   gui->leader_slot_pending     = ULONG_MAX;
     165           0 :   gui->leader_bank_seq_pending = ULONG_MAX;
     166             : 
     167           0 :   gui->system.valid  = 0;
     168             : 
     169           0 :   gui->summary.slot_tower  = ULONG_MAX;
     170           0 :   gui->summary.slot_tower_bank_seq = ULONG_MAX;
     171           0 :   gui->summary.schedule_strategy = schedule_strategy;
     172             : 
     173             : 
     174           0 :   gui->next_sample_1sec      = now;
     175           0 :   gui->next_sample_200millis = now;
     176           0 :   gui->next_sample_100millis = now;
     177           0 :   gui->next_sample_50millis  = now;
     178           0 :   gui->next_sample_40millis  = now;
     179           0 :   gui->next_sample_25millis  = now;
     180           0 :   gui->next_sample_10millis  = now;
     181             : 
     182           0 :   memcpy( gui->summary.identity_key->uc, identity_key, 32UL );
     183           0 :   fd_base58_encode_32( identity_key, NULL, gui->summary.identity_key_base58 );
     184           0 :   gui->summary.identity_key_base58[ FD_BASE58_ENCODED_32_SZ-1UL ] = '\0';
     185             : 
     186           0 :   if( FD_LIKELY( has_vote_key ) ) {
     187           0 :     gui->summary.has_vote_key = 1;
     188           0 :     memcpy( gui->summary.vote_key->uc, vote_key, 32UL );
     189           0 :     fd_base58_encode_32( vote_key, NULL, gui->summary.vote_key_base58 );
     190           0 :     gui->summary.vote_key_base58[ FD_BASE58_ENCODED_32_SZ-1UL ] = '\0';
     191           0 :   } else {
     192           0 :     gui->summary.has_vote_key = 0;
     193           0 :     memset( gui->summary.vote_key_base58, 0, sizeof(gui->summary.vote_key_base58) );
     194           0 :   }
     195             : 
     196           0 :   gui->summary.version                       = version;
     197           0 :   gui->summary.cluster                       = cluster;
     198           0 :   fd_cstr_ncpy( gui->summary.accounts_database_path, accounts_database_path, sizeof(gui->summary.accounts_database_path) );
     199           0 :   fd_cstr_ncpy( gui->summary.gui_database_path, gui_database_path, sizeof(gui->summary.gui_database_path) );
     200           0 :   gui->summary.startup_time_nanos            = gui->next_sample_200millis;
     201           0 :   gui->summary.expected_shred_version        = expected_shred_version;
     202           0 :   gui->summary.wfs_enabled          = 0;
     203           0 :   gui->summary.wfs_bank_hash[ 0UL ] = '\0';
     204           0 :   gui->summary.wfs_slot             = wfs_slot;
     205             : 
     206           0 :   {
     207           0 :     fd_cstr_ncpy( gui->summary.wfs_bank_hash, wfs_expected_bank_hash_cstr, sizeof(gui->summary.wfs_bank_hash) );
     208           0 :     gui->summary.wfs_enabled = !!strcmp( wfs_expected_bank_hash_cstr, "" );
     209             : 
     210           0 :     if( FD_UNLIKELY( snapshots_enabled ) ) {
     211           0 :       gui->summary.boot_progress.phase = FD_GUI_BOOT_PROGRESS_TYPE_JOINING_GOSSIP;
     212           0 :       gui->summary.boot_progress.joining_gossip_time_nanos = gui->next_sample_200millis;
     213           0 :       memset( gui->summary.boot_progress.loading_snapshot, 0, sizeof(gui->summary.boot_progress.loading_snapshot) );
     214           0 :       for( ulong i=0UL; i<FD_GUI_BOOT_PROGRESS_SNAPSHOT_CNT; i++ ) {
     215           0 :         gui->summary.boot_progress.loading_snapshot[ i ].reset_cnt = ULONG_MAX; /* ensures other fields are reset initially */
     216           0 :         gui->summary.boot_progress.loading_snapshot[ i ].slot = ULONG_MAX;
     217           0 :       }
     218           0 :       gui->summary.boot_progress.catching_up_time_nanos        = 0L;
     219           0 :       gui->summary.boot_progress.catching_up_first_replay_slot = ULONG_MAX;
     220           0 :       gui->summary.boot_progress.wfs_total_stake     = 0UL;
     221           0 :       gui->summary.boot_progress.wfs_connected_stake = 0UL;
     222           0 :       gui->summary.boot_progress.wfs_total_peers     = 0UL;
     223           0 :       gui->summary.boot_progress.wfs_connected_peers = 0UL;
     224           0 :       gui->summary.boot_progress.wfs_attempt         = 0UL;
     225           0 :     } else {
     226           0 :       fd_memset( &gui->summary.boot_progress, 0, sizeof(gui->summary.boot_progress) );
     227           0 :       gui->summary.boot_progress.phase = FD_GUI_BOOT_PROGRESS_TYPE_RUNNING;
     228           0 :     }
     229           0 :     gui->summary.boot_progress.boot_target_slot_duration_nanos = ULONG_MAX;
     230           0 :   }
     231             : 
     232           0 :   gui->summary.identity_account_balance      = 0UL;
     233           0 :   gui->summary.vote_account_balance          = 0UL;
     234           0 :   gui->summary.vote_commission               = USHORT_MAX;
     235           0 :   gui->summary.estimated_slot_duration_nanos = 0UL;
     236             : 
     237           0 :   gui->summary.is_voting  = !!is_voting;
     238           0 :   gui->summary.vote_state = is_voting ? FD_GUI_VOTE_STATE_VOTING : FD_GUI_VOTE_STATE_NON_VOTING;
     239             : 
     240           0 :   gui->summary.sock_tile_cnt   = fd_topo_tile_name_cnt( gui->topo, "sock"   );
     241           0 :   gui->summary.mlx5_tile_cnt   = fd_topo_tile_name_cnt( gui->topo, "mlx5"   );
     242           0 :   gui->summary.iavf_tile_cnt   = fd_topo_tile_name_cnt( gui->topo, "iavf"   );
     243           0 :   gui->summary.net_tile_cnt    = fd_topo_tile_name_cnt( gui->topo, "net"    );
     244           0 :   gui->summary.quic_tile_cnt   = fd_topo_tile_name_cnt( gui->topo, "quic"   );
     245           0 :   gui->summary.verify_tile_cnt = fd_topo_tile_name_cnt( gui->topo, "verify" );
     246           0 :   gui->summary.resolv_tile_cnt = fd_topo_tile_name_cnt( gui->topo, "resolv" );
     247           0 :   gui->summary.execle_tile_cnt = fd_topo_tile_name_cnt( gui->topo, "execle" );
     248           0 :   gui->summary.execrp_tile_cnt = fd_topo_tile_name_cnt( gui->topo, "execrp" );
     249           0 :   gui->summary.shred_tile_cnt  = fd_topo_tile_name_cnt( gui->topo, "shred"  );
     250             : 
     251           0 :   fd_gui_build_tile_order( gui );
     252             : 
     253           0 :   gui->summary.slot_rooted                   = ULONG_MAX;
     254           0 :   gui->summary.slot_finalized                = ULONG_MAX;
     255           0 :   gui->summary.slot_notarized                = ULONG_MAX;
     256           0 :   gui->summary.slot_estimated                = ULONG_MAX;
     257           0 :   gui->summary.slot_caught_up                = ULONG_MAX;
     258           0 :   gui->summary.slot_repair                   = ULONG_MAX;
     259           0 :   gui->summary.slot_turbine                  = ULONG_MAX;
     260           0 :   gui->summary.slot_reset                    = ULONG_MAX;
     261           0 :   gui->summary.slot_storage                  = ULONG_MAX;
     262           0 :   gui->summary.slot_voted                    = ULONG_MAX;
     263           0 :   gui->summary.active_fork_cnt               = 1UL;
     264             : 
     265           0 :   gui->ag.slot_cnt = max_live_slots;
     266           0 :   gui->max_consecutive_skips = fd_ulong_if( max_live_slots>FD_VOTOR_REWARD_SLOT_DELTA, max_live_slots-FD_VOTOR_REWARD_SLOT_DELTA, 1UL );
     267           0 :   gui->ag.slot     = (fd_gui_ag_slot_t *)ag_slot_mem;
     268           0 :   memset( gui->ag.slot, 0, max_live_slots*sizeof(fd_gui_ag_slot_t) );
     269           0 :   for( ulong i=0UL; i<gui->ag.slot_cnt; i++ ) {
     270           0 :     gui->ag.slot[ i ].slot     = ULONG_MAX;
     271           0 :     gui->ag.slot[ i ].bank_seq = ULONG_MAX;
     272           0 :   }
     273             : 
     274           0 :   memset( gui->cpu_util.total, 0, sizeof(gui->cpu_util.total) );
     275           0 :   memset( gui->cpu_util.idle,  0, sizeof(gui->cpu_util.idle)  );
     276           0 :   gui->cpu_util.last_slot = ULONG_MAX;
     277           0 :   gui->cpu_util.cur_day   = ULONG_MAX;
     278             : 
     279           0 :   memset( gui->summary.skip_rate, 0, sizeof(gui->summary.skip_rate) );
     280           0 :   gui->summary.skip_rate[ 0 ].epoch = ULONG_MAX;
     281           0 :   gui->summary.skip_rate[ 1 ].epoch = ULONG_MAX;
     282             : 
     283           0 :   for( ulong i=0UL; i < (FD_GUI_REPAIR_SLOT_HISTORY_SZ+1UL); i++ )  gui->summary.slots_max_repair[ i ].slot  = ULONG_MAX;
     284           0 :   for( ulong i=0UL; i < (FD_GUI_TURBINE_SLOT_HISTORY_SZ+1UL); i++ ) gui->summary.slots_max_turbine[ i ].slot = ULONG_MAX;
     285             : 
     286           0 :   for( ulong i=0UL; i < FD_GUI_TURBINE_RECV_TIMESTAMPS; i++ ) gui->turbine_slots[ i ].slot = ULONG_MAX;
     287             : 
     288           0 :   gui->summary.estimated_tps_history_idx = 0UL;
     289           0 :   memset( gui->summary.estimated_tps_history, 0, sizeof(gui->summary.estimated_tps_history) );
     290             : 
     291           0 :   memset( gui->summary.txn_waterfall_reference, 0, sizeof(gui->summary.txn_waterfall_reference) );
     292           0 :   memset( gui->summary.txn_waterfall_current,   0, sizeof(gui->summary.txn_waterfall_current)   );
     293             : 
     294           0 :   memset( gui->summary.tile_stats_reference, 0, sizeof(gui->summary.tile_stats_reference) );
     295           0 :   memset( gui->summary.tile_stats_current, 0, sizeof(gui->summary.tile_stats_current) );
     296             : 
     297           0 :   gui->summary.progcache_history_idx = 0UL;
     298           0 :   memset( gui->summary.progcache_hits_history,    0, sizeof(gui->summary.progcache_hits_history) );
     299           0 :   memset( gui->summary.progcache_lookups_history, 0, sizeof(gui->summary.progcache_lookups_history) );
     300           0 :   gui->summary.progcache_hits_1min    = 0UL;
     301           0 :   gui->summary.progcache_lookups_1min = 0UL;
     302             : 
     303           0 :   memset( gui->summary.accounts_stats_reference, 0, sizeof(gui->summary.accounts_stats_reference) );
     304           0 :   memset( gui->summary.accounts_stats_current,   0, sizeof(gui->summary.accounts_stats_current  ) );
     305           0 :   gui->summary.accounts_stats_have_reference = 0;
     306           0 :   gui->summary.accdb->accdb_win_idx   = 0UL;
     307           0 :   gui->summary.accdb->accdb_win_count = 0UL;
     308           0 :   memset( gui->summary.accdb->accdb_win_dt_nanos,           0, sizeof(gui->summary.accdb->accdb_win_dt_nanos)           );
     309           0 :   memset( gui->summary.accdb->agg_acquired_win,             0, sizeof(gui->summary.accdb->agg_acquired_win)             );
     310           0 :   memset( gui->summary.accdb->agg_acquired_writable_win,    0, sizeof(gui->summary.accdb->agg_acquired_writable_win)    );
     311           0 :   memset( gui->summary.accdb->agg_bytes_read_win,           0, sizeof(gui->summary.accdb->agg_bytes_read_win)           );
     312           0 :   memset( gui->summary.accdb->agg_bytes_copied_win,         0, sizeof(gui->summary.accdb->agg_bytes_copied_win)         );
     313           0 :   memset( gui->summary.accdb->agg_bytes_written_win,        0, sizeof(gui->summary.accdb->agg_bytes_written_win)        );
     314           0 :   memset( gui->summary.accdb->agg_bytes_written_accdb_win,  0, sizeof(gui->summary.accdb->agg_bytes_written_accdb_win)  );
     315           0 :   memset( gui->summary.accdb->agg_read_ops_win,             0, sizeof(gui->summary.accdb->agg_read_ops_win)             );
     316           0 :   memset( gui->summary.accdb->agg_write_ops_win,            0, sizeof(gui->summary.accdb->agg_write_ops_win)            );
     317           0 :   memset( gui->summary.accdb->agg_relocated_bytes_win,      0, sizeof(gui->summary.accdb->agg_relocated_bytes_win)      );
     318           0 :   memset( gui->summary.accdb->agg_misses_win,               0, sizeof(gui->summary.accdb->agg_misses_win)               );
     319           0 :   memset( gui->summary.accdb->class_acq_win,                0, sizeof(gui->summary.accdb->class_acq_win)                );
     320           0 :   memset( gui->summary.accdb->class_acq_wr_win,             0, sizeof(gui->summary.accdb->class_acq_wr_win)             );
     321           0 :   memset( gui->summary.accdb->class_not_found_win,          0, sizeof(gui->summary.accdb->class_not_found_win)          );
     322           0 :   memset( gui->summary.accdb->class_evicted_win,            0, sizeof(gui->summary.accdb->class_evicted_win)            );
     323           0 :   memset( gui->summary.accdb->class_preevicted_win,         0, sizeof(gui->summary.accdb->class_preevicted_win)         );
     324           0 :   memset( gui->summary.accdb->class_commit_new_win,         0, sizeof(gui->summary.accdb->class_commit_new_win)         );
     325           0 :   memset( gui->summary.accdb->class_commit_over_win,        0, sizeof(gui->summary.accdb->class_commit_over_win)        );
     326             : 
     327           0 :   gui->summary.accdb->partition_cnt = 0UL;
     328           0 :   memset( gui->summary.accdb->partition_read_ops_win,        0, sizeof(gui->summary.accdb->partition_read_ops_win)        );
     329           0 :   memset( gui->summary.accdb->partition_bytes_read_win,      0, sizeof(gui->summary.accdb->partition_bytes_read_win)      );
     330           0 :   memset( gui->summary.accdb->partition_write_ops_win,       0, sizeof(gui->summary.accdb->partition_write_ops_win)       );
     331           0 :   memset( gui->summary.accdb->partition_bytes_written_win,   0, sizeof(gui->summary.accdb->partition_bytes_written_win)   );
     332           0 :   memset( gui->summary.accdb->partitions,                    0, sizeof(gui->summary.accdb->partitions)                    );
     333           0 :   memset( gui->summary.accdb->partition_prev_read_ops,       0, sizeof(gui->summary.accdb->partition_prev_read_ops)       );
     334           0 :   memset( gui->summary.accdb->partition_prev_bytes_read,     0, sizeof(gui->summary.accdb->partition_prev_bytes_read)     );
     335           0 :   memset( gui->summary.accdb->partition_prev_write_ops,      0, sizeof(gui->summary.accdb->partition_prev_write_ops)      );
     336           0 :   memset( gui->summary.accdb->partition_prev_bytes_written,  0, sizeof(gui->summary.accdb->partition_prev_bytes_written)  );
     337           0 :   for( ulong k=0UL; k<FD_ACCDB_COMPACTION_LAYER_CNT; k++ ) {
     338           0 :     fd_gui_ema_init( &gui->summary.accdb->tier_fill_bps_ema[ k ], now, FD_GUI_ACCDB_EMA_HALF_LIFE_NS );
     339           0 :     fd_gui_ema_init( &gui->summary.accdb->tier_free_bps_ema[ k ], now, FD_GUI_ACCDB_EMA_HALF_LIFE_NS );
     340           0 :   }
     341           0 :   gui->summary.accdb->tier_sample_nanos              = LONG_MAX;
     342           0 :   gui->summary.accdb->next_compaction_remaining_secs = 0.0;
     343           0 :   gui->summary.accdb->next_compaction_partition_idx  = ULONG_MAX;
     344             : 
     345             :   /* Build the per-tile accdb slot table from the topology.  Order
     346             :      matters only for stable JSON ordering: RW joiners first, RO
     347             :      joiners, then snapin and accdb. */
     348           0 :   gui->summary.accdb->accdb_tile_cnt = 0UL;
     349           0 :   static const struct { char const * name; uchar kind; } accdb_kinds[] = {
     350           0 :     { "execle", FD_GUI_ACCDB_TILE_KIND_RW     },
     351           0 :     { "execrp", FD_GUI_ACCDB_TILE_KIND_RW     },
     352           0 :     { "replay", FD_GUI_ACCDB_TILE_KIND_RW     },
     353           0 :     { "rpc",    FD_GUI_ACCDB_TILE_KIND_RO     },
     354           0 :     { "resolv", FD_GUI_ACCDB_TILE_KIND_RO     },
     355           0 :     { "snapin", FD_GUI_ACCDB_TILE_KIND_SNAPIN },
     356           0 :     { "accdb",  FD_GUI_ACCDB_TILE_KIND_ACCDB  },
     357           0 :   };
     358           0 :   for( ulong k=0UL; k<sizeof(accdb_kinds)/sizeof(accdb_kinds[0]); k++ ) {
     359           0 :     ulong cnt = fd_topo_tile_name_cnt( gui->topo, accdb_kinds[ k ].name );
     360           0 :     for( ulong i=0UL; i<cnt; i++ ) {
     361           0 :       ulong t_idx = fd_topo_find_tile( gui->topo, accdb_kinds[ k ].name, i );
     362           0 :       if( FD_UNLIKELY( t_idx==ULONG_MAX ) ) continue;
     363           0 :       ulong slot = gui->summary.accdb->accdb_tile_cnt++;
     364           0 :       gui->summary.accdb->accdb_tile_topo_idx[ slot ] = (ushort)t_idx;
     365           0 :       gui->summary.accdb->accdb_tile_kind    [ slot ] = accdb_kinds[ k ].kind;
     366           0 :     }
     367           0 :   }
     368           0 :   memset( gui->summary.accdb->tile_cur_acquired,           0, sizeof(gui->summary.accdb->tile_cur_acquired)           );
     369           0 :   memset( gui->summary.accdb->tile_cur_acquired_writable,  0, sizeof(gui->summary.accdb->tile_cur_acquired_writable)  );
     370           0 :   memset( gui->summary.accdb->tile_cur_bytes_read,         0, sizeof(gui->summary.accdb->tile_cur_bytes_read)         );
     371           0 :   memset( gui->summary.accdb->tile_cur_bytes_copied,       0, sizeof(gui->summary.accdb->tile_cur_bytes_copied)       );
     372           0 :   memset( gui->summary.accdb->tile_cur_bytes_written,      0, sizeof(gui->summary.accdb->tile_cur_bytes_written)      );
     373           0 :   memset( gui->summary.accdb->tile_cur_read_ops,           0, sizeof(gui->summary.accdb->tile_cur_read_ops)           );
     374           0 :   memset( gui->summary.accdb->tile_cur_write_ops,          0, sizeof(gui->summary.accdb->tile_cur_write_ops)          );
     375           0 :   memset( gui->summary.accdb->tile_cur_misses,             0, sizeof(gui->summary.accdb->tile_cur_misses)             );
     376           0 :   memset( gui->summary.accdb->tile_cur_evicted,            0, sizeof(gui->summary.accdb->tile_cur_evicted)            );
     377           0 :   memset( gui->summary.accdb->tile_cur_committed,          0, sizeof(gui->summary.accdb->tile_cur_committed)          );
     378           0 :   memset( gui->summary.accdb->tile_cur_acquire_calls,      0, sizeof(gui->summary.accdb->tile_cur_acquire_calls)      );
     379           0 :   memset( gui->summary.accdb->tile_cur_status,             0, sizeof(gui->summary.accdb->tile_cur_status)             );
     380           0 :   memset( gui->summary.accdb->tile_prev_acquired,          0, sizeof(gui->summary.accdb->tile_prev_acquired)          );
     381           0 :   memset( gui->summary.accdb->tile_prev_acquired_writable, 0, sizeof(gui->summary.accdb->tile_prev_acquired_writable) );
     382           0 :   memset( gui->summary.accdb->tile_prev_bytes_read,        0, sizeof(gui->summary.accdb->tile_prev_bytes_read)        );
     383           0 :   memset( gui->summary.accdb->tile_prev_bytes_copied,      0, sizeof(gui->summary.accdb->tile_prev_bytes_copied)      );
     384           0 :   memset( gui->summary.accdb->tile_prev_bytes_written,     0, sizeof(gui->summary.accdb->tile_prev_bytes_written)     );
     385           0 :   memset( gui->summary.accdb->tile_prev_read_ops,          0, sizeof(gui->summary.accdb->tile_prev_read_ops)          );
     386           0 :   memset( gui->summary.accdb->tile_prev_write_ops,         0, sizeof(gui->summary.accdb->tile_prev_write_ops)         );
     387           0 :   memset( gui->summary.accdb->tile_prev_misses,            0, sizeof(gui->summary.accdb->tile_prev_misses)            );
     388           0 :   memset( gui->summary.accdb->tile_prev_evicted,           0, sizeof(gui->summary.accdb->tile_prev_evicted)           );
     389           0 :   memset( gui->summary.accdb->tile_prev_committed,         0, sizeof(gui->summary.accdb->tile_prev_committed)         );
     390           0 :   memset( gui->summary.accdb->tile_prev_acquire_calls,     0, sizeof(gui->summary.accdb->tile_prev_acquire_calls)     );
     391           0 :   memset( gui->summary.accdb->tile_acquired_win,           0, sizeof(gui->summary.accdb->tile_acquired_win)           );
     392           0 :   memset( gui->summary.accdb->tile_acquired_writable_win,  0, sizeof(gui->summary.accdb->tile_acquired_writable_win)  );
     393           0 :   memset( gui->summary.accdb->tile_bytes_read_win,         0, sizeof(gui->summary.accdb->tile_bytes_read_win)         );
     394           0 :   memset( gui->summary.accdb->tile_bytes_copied_win,       0, sizeof(gui->summary.accdb->tile_bytes_copied_win)       );
     395           0 :   memset( gui->summary.accdb->tile_bytes_written_win,      0, sizeof(gui->summary.accdb->tile_bytes_written_win)      );
     396           0 :   memset( gui->summary.accdb->tile_read_ops_win,           0, sizeof(gui->summary.accdb->tile_read_ops_win)           );
     397           0 :   memset( gui->summary.accdb->tile_write_ops_win,          0, sizeof(gui->summary.accdb->tile_write_ops_win)          );
     398           0 :   memset( gui->summary.accdb->tile_misses_win,             0, sizeof(gui->summary.accdb->tile_misses_win)             );
     399           0 :   memset( gui->summary.accdb->tile_evicted_win,            0, sizeof(gui->summary.accdb->tile_evicted_win)            );
     400           0 :   memset( gui->summary.accdb->tile_committed_win,          0, sizeof(gui->summary.accdb->tile_committed_win)          );
     401           0 :   memset( gui->summary.accdb->tile_acquire_calls_win,      0, sizeof(gui->summary.accdb->tile_acquire_calls_win)      );
     402             : 
     403           0 :   memset( gui->summary.accdb->tile_sparkline_bucket_start_nanos, 0, sizeof(gui->summary.accdb->tile_sparkline_bucket_start_nanos) );
     404           0 :   memset( gui->summary.accdb->tile_sparkline_acq_bucket,         0, sizeof(gui->summary.accdb->tile_sparkline_acq_bucket)         );
     405           0 :   memset( gui->summary.accdb->tile_sparkline_acq_wr_bucket,      0, sizeof(gui->summary.accdb->tile_sparkline_acq_wr_bucket)      );
     406           0 :   memset( gui->summary.accdb->tile_sparkline_acq_text_len,       0, sizeof(gui->summary.accdb->tile_sparkline_acq_text_len)       );
     407           0 :   memset( gui->summary.accdb->tile_sparkline_acq_wr_text_len,    0, sizeof(gui->summary.accdb->tile_sparkline_acq_wr_text_len)    );
     408           0 :   memset( gui->summary.accdb->tile_sparkline_count,              0, sizeof(gui->summary.accdb->tile_sparkline_count)              );
     409             : 
     410           0 :   memset( gui->summary.tile_timers_reference, 0, sizeof(gui->summary.tile_timers_reference) );
     411           0 :   memset( gui->summary.tile_timers_current,   0, sizeof(gui->summary.tile_timers_current)   );
     412           0 :   memset( gui->summary.tile_timers_packed,    0, sizeof(gui->summary.tile_timers_packed)    );
     413             : 
     414           0 :   gui->block_engine.has_block_engine = 0;
     415             : 
     416           0 :   gui->epoch.current_epoch             = ULONG_MAX;
     417           0 :   gui->epoch.has_epoch_schedule        = 0;
     418           0 :   gui->epoch.missed_vote_history_dirty = ULONG_MAX;
     419             : 
     420           0 :   gui->shreds.leader_shred_cnt        = 0UL;
     421           0 :   gui->shreds.leader_shred_slot       = ULONG_MAX;
     422           0 :   gui->shreds.dropped_event_cnt       = 0UL;
     423           0 :   fd_memset( &gui->shreds.builder, 0, sizeof(gui->shreds.builder) );
     424           0 :   gui->shreds.closed_slot_wmark       = 0UL;
     425           0 :   gui->shreds.fec_marker_sequence     = 0UL;
     426           0 :   gui->shreds.fec_insert_time_ns      = 0L;
     427           0 :   gui->shreds.dropped_fec_event_cnt   = 0UL;
     428           0 :   gui->shreds.clamped_fec_event_cnt   = 0UL;
     429           0 :   gui->shreds.broadcast_watermark_ns  = now;
     430           0 :   gui->summary.catch_up_repair_sz     = 0UL;
     431           0 :   gui->summary.catch_up_turbine_sz    = 0UL;
     432             : 
     433           0 :   fd_memset( &gui->snapsv, 0, sizeof(gui->snapsv) );
     434             : 
     435           0 :   return gui;
     436           0 : }
     437             : 
     438             : fd_gui_t *
     439           0 : fd_gui_join( void * shmem ) {
     440           0 :   return (fd_gui_t *)shmem;
     441           0 : }
     442             : 
     443             : void
     444             : fd_gui_set_identity( fd_gui_t *    gui,
     445           0 :                      uchar const * identity_pubkey ) {
     446           0 :   memcpy( gui->summary.identity_key->uc, identity_pubkey, 32UL );
     447           0 :   fd_base58_encode_32( identity_pubkey, NULL, gui->summary.identity_key_base58 );
     448           0 :   gui->summary.identity_key_base58[ FD_BASE58_ENCODED_32_SZ-1UL ] = '\0';
     449             : 
     450           0 :   if( FD_LIKELY( gui->summary.is_voting ) ) gui->summary.vote_state = FD_GUI_VOTE_STATE_VOTING;
     451             : 
     452           0 :   gui->summary.slot_voted = ULONG_MAX;
     453             : 
     454           0 :   fd_gui_printf_identity_key( gui );
     455           0 :   fd_http_server_ws_broadcast( gui->http );
     456           0 :   fd_gui_printf_vote_slot( gui );
     457           0 :   fd_http_server_ws_broadcast( gui->http );
     458           0 :   fd_gui_printf_vote_state( gui );
     459           0 :   fd_http_server_ws_broadcast( gui->http );
     460           0 :   fd_gui_printf_missed_vote_history( gui, gui->epoch.current_epoch );
     461           0 :   fd_http_server_ws_broadcast( gui->http );
     462           0 : }
     463             : 
     464             : void
     465             : fd_gui_handle_diag_snapshot( fd_gui_t *   gui,
     466             :                              void const * data,
     467           0 :                              ulong        data_sz ) {
     468           0 :   if( FD_UNLIKELY( !data ) ) return;
     469             : 
     470           0 :   if( FD_UNLIKELY( data_sz!=sizeof(fd_diag_system_resources_t) ) ) return;
     471             : 
     472           0 :   fd_diag_system_resources_t snapshot[ 1 ];
     473           0 :   fd_memcpy( snapshot, data, sizeof(snapshot) );
     474           0 :   if( FD_UNLIKELY( snapshot->cpu_cnt     >FD_DIAG_SYSTEM_CPU_MAX  ||
     475           0 :                    snapshot->numa_mem_cnt>FD_DIAG_SYSTEM_NUMA_MAX ||
     476           0 :                    snapshot->tile_mem_cnt>FD_DIAG_SYSTEM_TILE_MEM_MAX ||
     477           0 :                    snapshot->mount_cnt   >FD_DIAG_SYSTEM_FILE_MAX ||
     478           0 :                    snapshot->file_cnt    >FD_DIAG_SYSTEM_FILE_MAX ) ) return;
     479           0 :   for( ulong i=0UL; i<(ulong)snapshot->cpu_cnt; i++ ) {
     480           0 :     fd_diag_system_cpu_t const * cpu = &snapshot->cpu[ i ];
     481           0 :     if( FD_UNLIKELY( cpu->cpu_idx>=FD_DIAG_SYSTEM_CPU_MAX ) ) return;
     482           0 :     if( FD_UNLIKELY( cpu->die_idx!=USHORT_MAX && cpu->die_idx>=snapshot->cpu_cnt ) ) return;
     483           0 :   }
     484           0 :   for( ulong i=0UL; i<(ulong)snapshot->tile_mem_cnt; i++ ) {
     485           0 :     fd_diag_system_tile_mem_t const * tile = &snapshot->tile_mem[ i ];
     486           0 :     if( FD_UNLIKELY( tile->tile_idx>=gui->topo->tile_cnt ) ) return;
     487           0 :   }
     488           0 :   for( ulong i=0UL; i<(ulong)snapshot->mount_cnt; i++ ) {
     489           0 :     if( FD_UNLIKELY( !memchr( snapshot->mount[ i ].path, '\0', sizeof(snapshot->mount[ i ].path) ) ) ) return;
     490           0 :   }
     491           0 :   for( ulong i=0UL; i<(ulong)snapshot->file_cnt; i++ ) {
     492           0 :     fd_diag_system_file_t const * file = &snapshot->file[ i ];
     493           0 :     if( FD_UNLIKELY( file->mount_idx>=snapshot->mount_cnt ||
     494           0 :                      file->path[ 0 ]!='/' ||
     495           0 :                      !memchr( file->path, '\0', sizeof(file->path) ) ) ) return;
     496           0 :   }
     497             : 
     498           0 :   gui->system.resources = *snapshot;
     499           0 :   gui->system.valid     = 1;
     500           0 :   fd_gui_printf_system_resources( gui );
     501           0 :   fd_http_server_ws_broadcast( gui->http );
     502           0 : }
     503             : 
     504             : void
     505             : fd_gui_ws_open( fd_gui_t * gui,
     506             :                 ulong      ws_conn_id,
     507           0 :                 long now ) {
     508           0 :   fd_gui_printf_is_alpenglow( gui );
     509           0 :   FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     510             : 
     511           0 :   void (* printers[] )( fd_gui_t * gui ) = {
     512           0 :     fd_gui_printf_boot_progress,
     513           0 :     fd_gui_printf_version,
     514           0 :     fd_gui_printf_cluster,
     515           0 :     fd_gui_printf_commit_hash,
     516           0 :     fd_gui_printf_identity_key,
     517           0 :     fd_gui_printf_vote_key,
     518           0 :     fd_gui_printf_startup_time_nanos,
     519           0 :     fd_gui_printf_vote_state,
     520           0 :     fd_gui_printf_turbine_slot,
     521           0 :     fd_gui_printf_repair_slot,
     522           0 :     fd_gui_printf_slot_caught_up,
     523           0 :     fd_gui_printf_tps_history,
     524           0 :     fd_gui_printf_estimated_tps,
     525           0 :     fd_gui_printf_tiles,
     526           0 :     fd_gui_printf_schedule_strategy,
     527           0 :     fd_gui_printf_identity_balance,
     528           0 :     fd_gui_printf_vote_balance,
     529           0 :     fd_gui_printf_vote_commission,
     530           0 :     fd_gui_printf_estimated_slot_duration_nanos,
     531           0 :     fd_gui_printf_root_slot,
     532           0 :     fd_gui_printf_storage_slot,
     533           0 :     fd_gui_printf_reset_slot,
     534           0 :     fd_gui_printf_active_fork_cnt,
     535           0 :     fd_gui_printf_completed_slot,
     536           0 :     fd_gui_printf_estimated_slot,
     537           0 :     fd_gui_printf_live_tile_timers,
     538           0 :     fd_gui_printf_live_tile_metrics,
     539           0 :     fd_gui_printf_catch_up_history,
     540           0 :     fd_gui_printf_health
     541           0 :   };
     542             : 
     543           0 :   ulong printers_len = sizeof(printers) / sizeof(printers[0]);
     544           0 :   for( ulong i=0UL; i<printers_len; i++ ) {
     545           0 :     printers[ i ]( gui );
     546           0 :     FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     547           0 :   }
     548             : 
     549           0 :   fd_gui_printf_finalized_slot( gui );
     550           0 :   FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     551           0 :   fd_gui_printf_notarized_slot( gui );
     552           0 :   FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     553           0 :   fd_gui_printf_vote_slot( gui );
     554           0 :   FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     555             : 
     556           0 :   if( FD_LIKELY( gui->system.valid ) ) {
     557           0 :     fd_gui_printf_system_resources( gui );
     558           0 :     FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     559           0 :   }
     560             : 
     561           0 :   {
     562           0 :     fd_gui_printf_live_program_cache( gui );
     563           0 :     FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     564             : 
     565           0 :     if( FD_LIKELY( gui->summary.accounts_stats_have_reference ) ) {
     566           0 :       fd_gui_printf_accounts_stats( gui );
     567           0 :       FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     568           0 :     }
     569           0 :   }
     570             : 
     571           0 :   if( FD_LIKELY( gui->block_engine.has_block_engine ) ) {
     572           0 :     fd_gui_printf_block_engine( gui );
     573           0 :     FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     574           0 :   }
     575             : 
     576           0 :   if( FD_LIKELY( gui->epoch.current_epoch!=ULONG_MAX ) ) {
     577           0 :     for( ulong e=gui->epoch.current_epoch; e<=gui->epoch.current_epoch+1UL; e++ ) {
     578           0 :       if( FD_LIKELY( fd_gui_epoch( gui, e ) ) ) {
     579           0 :         fd_gui_printf_skip_rate( gui, e );
     580           0 :         FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     581           0 :         fd_gui_printf_epoch( gui, e );
     582           0 :         FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     583           0 :       }
     584           0 :     }
     585             : 
     586           0 :     fd_gui_printf_skipped_history( gui, gui->epoch.current_epoch );
     587           0 :     FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     588           0 :     fd_gui_printf_skipped_history_cluster( gui, gui->epoch.current_epoch );
     589           0 :     FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     590             : 
     591           0 :     fd_gui_printf_missed_vote_history( gui, gui->epoch.current_epoch );
     592           0 :     FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     593           0 :   }
     594             : 
     595             :   /* rebroadcast 10s of historical shred data */
     596           0 :   long const shred_history_start = now-10L*1000L*1000L*1000L;
     597           0 :   if( FD_LIKELY( !fd_gui_shred_window_is_empty( gui, shred_history_start, now ) ) ) {
     598           0 :     fd_gui_printf_shred_rebroadcast( gui, shred_history_start, now );
     599           0 :     FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
     600           0 :   }
     601           0 : }
     602             : 
     603             : 
     604             : 
     605             : static inline ushort
     606           0 : fd_gui_tile_timers_pct( ulong delta, ulong total ) {
     607           0 :   if( FD_UNLIKELY( !total ) ) return USHORT_MAX;
     608           0 :   double percent = ( (double)delta / (double)total ) * 100.0;
     609           0 :   long   hundredths = (long)( percent * 100.0 );
     610           0 :   if( FD_UNLIKELY( hundredths<0L ) ) hundredths = 0L;
     611           0 :   if( FD_UNLIKELY( hundredths>(USHORT_MAX-1U) ) ) hundredths = (USHORT_MAX-1U);
     612           0 :   return (ushort)hundredths;
     613           0 : }
     614             : 
     615             : void
     616             : fd_gui_tile_timers_diff( fd_gui_tile_timers_hist_t *  out,
     617             :                          fd_gui_tile_timers_t const * prev,
     618             :                          fd_gui_tile_timers_t const * cur,
     619             :                          ulong                        tile_idx,
     620           0 :                          long                         sample_time_nanos ) {
     621           0 :   memset( out, 0, sizeof(*out) );
     622           0 :   out->sample_time_nanos = sample_time_nanos;
     623           0 :   out->tile_idx = (ushort)tile_idx;
     624             : 
     625           0 :   ulong cur_total = 0UL, prev_total = 0UL;
     626           0 :   for( ulong j=0UL; j<FD_METRICS_ENUM_TILE_REGIME_CNT; j++ ) {
     627           0 :     cur_total += cur->timers[ j ]; prev_total += prev->timers[ j ];
     628           0 :   }
     629           0 :   ulong busy = cur_total - prev_total;
     630           0 :   for( ulong j=0UL; j<FD_METRICS_ENUM_TILE_REGIME_CNT; j++ ) {
     631           0 :     out->timers[ j ] = fd_gui_tile_timers_pct( cur->timers[ j ] - prev->timers[ j ], busy );
     632           0 :   }
     633           0 :   if( FD_UNLIKELY( !busy ) ) {
     634           0 :     out->idle_ratio = USHORT_MAX;
     635           0 :   } else {
     636           0 :     ulong mask = FD_METRICS_ENUM_TILE_REGIME_G_IDLE_MASK | FD_METRICS_ENUM_TILE_REGIME_G_BACKPRESSURE_MASK;
     637           0 :     ulong idle = fd_metrics_enum_group_sum( cur->timers, mask ) - fd_metrics_enum_group_sum( prev->timers, mask );
     638           0 :     out->idle_ratio = fd_gui_tile_timers_pct( idle, busy );
     639           0 :   }
     640             : 
     641           0 :   ulong cur_ctot = 0UL, prev_ctot = 0UL;
     642           0 :   for( ulong j=0UL; j<FD_METRICS_ENUM_THREAD_REGIME_CNT; j++ ) { cur_ctot += cur->sched_timers[ j ]; prev_ctot += prev->sched_timers[ j ]; }
     643           0 :   ulong cbusy = cur_ctot - prev_ctot;
     644           0 :   for( ulong j=0UL; j<FD_METRICS_ENUM_THREAD_REGIME_CNT; j++ ) {
     645           0 :     out->sched_timers[ j ] = fd_gui_tile_timers_pct( cur->sched_timers[ j ] - prev->sched_timers[ j ], cbusy );
     646           0 :   }
     647             : 
     648           0 :   out->alive    = (uchar)fd_ulong_if( cur->status==2U, 2UL, (ulong)( cur->heartbeat>prev->heartbeat ) );
     649           0 :   out->in_backp = (uchar)( !!cur->in_backp );
     650           0 :   out->last_cpu = cur->last_cpu;
     651             : 
     652           0 :   out->backp_msgs     = cur->backp_cnt;
     653           0 :   out->nvcsw          = cur->nvcsw;
     654           0 :   out->nivcsw         = cur->nivcsw;
     655           0 :   out->minflt         = cur->minflt;
     656           0 :   out->majflt         = cur->majflt;
     657           0 :   out->interrupts     = cur->interrupts;
     658           0 :   out->tlb_shootdowns = cur->tlb_shootdowns;
     659           0 :   out->timer_ticks    = cur->timer_ticks;
     660           0 : }
     661             : 
     662             : static void
     663           0 : fd_gui_tile_timers_snap( fd_gui_t * gui, long now ) {
     664           0 :   fd_gui_tile_timers_t * cur = gui->summary.tile_timers_current;
     665           0 :   fd_memcpy( gui->summary.tile_timers_reference, cur, gui->tile_cnt * sizeof(fd_gui_tile_timers_t) );
     666           0 :   for( ulong i=0UL; i<gui->topo->tile_cnt; i++ ) {
     667           0 :     fd_topo_tile_t const * tile = &gui->topo->tiles[ i ];
     668             :     /* NULL when the tile's metrics live in a workspace not mapped to
     669             :        this tile (e.g. bench tiles use the "bench" workspace, not
     670             :        "metric_in"). */
     671           0 :     if( FD_UNLIKELY( !tile->metrics ) ) continue;
     672           0 :     volatile ulong const * tile_metrics = fd_metrics_tile( tile->metrics );
     673             : 
     674           0 :     cur[ i ].sample_time_nanos = now;
     675             : 
     676           0 :     cur[ i ].timers[ FD_METRICS_ENUM_TILE_REGIME_V_CAUGHT_UP_HOUSEKEEPING_IDX    ] = tile_metrics[ MIDX( COUNTER, TILE, REGIME_DURATION_NANOS_CAUGHT_UP_HOUSEKEEPING )    ];
     677           0 :     cur[ i ].timers[ FD_METRICS_ENUM_TILE_REGIME_V_PROCESSING_HOUSEKEEPING_IDX   ] = tile_metrics[ MIDX( COUNTER, TILE, REGIME_DURATION_NANOS_PROCESSING_HOUSEKEEPING )   ];
     678           0 :     cur[ i ].timers[ FD_METRICS_ENUM_TILE_REGIME_V_BACKPRESSURE_HOUSEKEEPING_IDX ] = tile_metrics[ MIDX( COUNTER, TILE, REGIME_DURATION_NANOS_BACKPRESSURE_HOUSEKEEPING ) ];
     679           0 :     cur[ i ].timers[ FD_METRICS_ENUM_TILE_REGIME_V_CAUGHT_UP_PREFRAG_IDX         ] = tile_metrics[ MIDX( COUNTER, TILE, REGIME_DURATION_NANOS_CAUGHT_UP_PREFRAG )         ];
     680           0 :     cur[ i ].timers[ FD_METRICS_ENUM_TILE_REGIME_V_PROCESSING_PREFRAG_IDX        ] = tile_metrics[ MIDX( COUNTER, TILE, REGIME_DURATION_NANOS_PROCESSING_PREFRAG )        ];
     681           0 :     cur[ i ].timers[ FD_METRICS_ENUM_TILE_REGIME_V_BACKPRESSURE_PREFRAG_IDX      ] = tile_metrics[ MIDX( COUNTER, TILE, REGIME_DURATION_NANOS_BACKPRESSURE_PREFRAG )      ];
     682           0 :     cur[ i ].timers[ FD_METRICS_ENUM_TILE_REGIME_V_CAUGHT_UP_POSTFRAG_IDX        ] = tile_metrics[ MIDX( COUNTER, TILE, REGIME_DURATION_NANOS_CAUGHT_UP_POSTFRAG )        ];
     683           0 :     cur[ i ].timers[ FD_METRICS_ENUM_TILE_REGIME_V_PROCESSING_POSTFRAG_IDX       ] = tile_metrics[ MIDX( COUNTER, TILE, REGIME_DURATION_NANOS_PROCESSING_POSTFRAG )       ];
     684           0 :     cur[ i ].timers[ FD_METRICS_ENUM_TILE_REGIME_V_CAUGHT_UP_SLEEPING_IDX        ] = tile_metrics[ MIDX( COUNTER, TILE, REGIME_DURATION_NANOS_CAUGHT_UP_SLEEPING )        ];
     685           0 :     cur[ i ].timers[ FD_METRICS_ENUM_TILE_REGIME_V_BACKPRESSURE_SLEEPING_IDX     ] = tile_metrics[ MIDX( COUNTER, TILE, REGIME_DURATION_NANOS_BACKPRESSURE_SLEEPING )     ];
     686             : 
     687           0 :     cur[ i ].sched_timers[ FD_METRICS_ENUM_THREAD_REGIME_V_WAIT_IDX      ] = tile_metrics[ MIDX( COUNTER, TILE, THREAD_DURATION_NANOS_WAIT )      ];
     688           0 :     cur[ i ].sched_timers[ FD_METRICS_ENUM_THREAD_REGIME_V_USER_IDX      ] = tile_metrics[ MIDX( COUNTER, TILE, THREAD_DURATION_NANOS_USER )      ];
     689           0 :     cur[ i ].sched_timers[ FD_METRICS_ENUM_THREAD_REGIME_V_SYSTEM_IDX    ] = tile_metrics[ MIDX( COUNTER, TILE, THREAD_DURATION_NANOS_SYSTEM )    ];
     690           0 :     cur[ i ].sched_timers[ FD_METRICS_ENUM_THREAD_REGIME_V_IDLE_IDX      ] = tile_metrics[ MIDX( COUNTER, TILE, THREAD_DURATION_NANOS_IDLE )      ];
     691           0 :     cur[ i ].sched_timers[ FD_METRICS_ENUM_THREAD_REGIME_V_INTERRUPT_IDX ] = tile_metrics[ MIDX( COUNTER, TILE, THREAD_DURATION_NANOS_INTERRUPT ) ];
     692             : 
     693           0 :     cur[ i ].in_backp  = (int)tile_metrics[ MIDX(GAUGE, TILE, IS_BACKPRESSURED) ];
     694           0 :     cur[ i ].status    = (uchar)tile_metrics[ MIDX( GAUGE, TILE, STATE ) ];
     695           0 :     cur[ i ].heartbeat = tile_metrics[ MIDX( GAUGE, TILE, HEARTBEAT_TIME ) ];
     696           0 :     cur[ i ].backp_cnt = tile_metrics[ MIDX( COUNTER, TILE, BACKPRESSURE ) ];
     697           0 :     cur[ i ].nvcsw     = tile_metrics[ MIDX( COUNTER, TILE, CONTEXT_SWITCH_VOLUNTARY ) ];
     698           0 :     cur[ i ].nivcsw    = tile_metrics[ MIDX( COUNTER, TILE, CONTEXT_SWITCH_INVOLUNTARY ) ];
     699           0 :     cur[ i ].minflt    = tile_metrics[ MIDX( COUNTER, TILE, PAGE_FAULT_MINOR ) ];
     700           0 :     cur[ i ].majflt    = tile_metrics[ MIDX( COUNTER, TILE, PAGE_FAULT_MAJOR ) ];
     701           0 :     cur[ i ].last_cpu  = (ushort)tile_metrics[ MIDX( GAUGE, TILE, LAST_CPU_INDEX ) ];
     702           0 :     cur[ i ].interrupts     = tile_metrics[ MIDX( COUNTER, TILE, DEVICE_IRQ ) ];
     703           0 :     cur[ i ].tlb_shootdowns = tile_metrics[ MIDX( COUNTER, TILE, TLB_SHOOTDOWN ) ];
     704           0 :     cur[ i ].timer_ticks    = tile_metrics[ MIDX( COUNTER, TILE, TIMER_IRQ ) ];
     705           0 :   }
     706             : 
     707           0 :   for( ulong i=0UL; i<gui->tile_cnt; i++ ) {
     708           0 :     cur[ i ].tile_idx = i;
     709           0 :     fd_gui_tile_timers_diff( &gui->summary.tile_timers_packed[ i ], &gui->summary.tile_timers_reference[ i ], &cur[ i ], i, now );
     710           0 :   }
     711           0 : }
     712             : 
     713             : static void
     714           0 : fd_gui_scheduler_counts_snap( fd_gui_t * gui, long now ) {
     715           0 :   ulong pack_tile_idx = fd_topo_find_tile( gui->topo, "pack", 0UL );
     716           0 :   if( FD_UNLIKELY( pack_tile_idx==ULONG_MAX ) ) return;
     717             : 
     718           0 :   fd_gui_scheduler_counts_t cur[ 1 ];
     719             : 
     720           0 :   fd_topo_tile_t const * pack = &gui->topo->tiles[ fd_topo_find_tile( gui->topo, "pack", 0UL ) ];
     721           0 :   volatile ulong const * pack_metrics = fd_metrics_tile( pack->metrics );
     722             : 
     723           0 :   cur->sample_time_ns = now;
     724             : 
     725           0 :   cur->regular      = pack_metrics[ MIDX( GAUGE, PACK, TXN_PENDING_USED_REGULAR ) ];
     726           0 :   cur->votes        = pack_metrics[ MIDX( GAUGE, PACK, TXN_PENDING_USED_VOTE ) ];
     727           0 :   cur->conflicting  = pack_metrics[ MIDX( GAUGE, PACK, TXN_PENDING_USED_CONFLICTING ) ];
     728           0 :   cur->bundles      = pack_metrics[ MIDX( GAUGE, PACK, TXN_PENDING_USED_BUNDLE ) ];
     729           0 :   cur->next_auction = pack_metrics[ MIDX( GAUGE, PACK, TXN_PENDING_USED_NEXT_AUCTION ) ];
     730             : 
     731           0 :   fd_gui_hist_ts_append( gui, FD_GUI_HIST_SCHEDULER_COUNTS, cur );
     732           0 : }
     733             : 
     734             : static void
     735           0 : fd_gui_estimated_tps_snap( fd_gui_t * gui ) {
     736           0 :   ulong vote_failed     = 0UL;
     737           0 :   ulong vote_success    = 0UL;
     738           0 :   ulong nonvote_success = 0UL;
     739           0 :   ulong nonvote_failed  = 0UL;
     740             : 
     741           0 :   if( FD_LIKELY( gui->summary.slot_tower==ULONG_MAX ) ) return;
     742           0 :   ulong first_replay_slot = fd_gui_first_replay_slot( gui );
     743           0 :   for( ulong i=0UL; i<fd_ulong_min( gui->summary.slot_tower+1UL, MAX_SLOTS_PER_EPOCH ); i++ ) {
     744           0 :     ulong _slot = gui->summary.slot_tower-i;
     745           0 :     if( FD_UNLIKELY( first_replay_slot!=ULONG_MAX && _slot<first_replay_slot ) ) break;
     746           0 :     fd_gui_slot_t const * slot = fd_gui_slot_get_canon( gui, _slot );
     747           0 :     if( FD_UNLIKELY( !slot ) ) continue;
     748           0 :     if( FD_UNLIKELY( slot->completed_time==LONG_MAX ) ) continue; /* Slot is on this fork but was never completed, must have been in root path on boot. */
     749           0 :     if( FD_UNLIKELY( slot->completed_time+FD_GUI_TPS_HISTORY_WINDOW_DURATION_SECONDS*1000L*1000L*1000L<gui->next_sample_200millis ) ) break; /* Slot too old. */
     750           0 :     if( FD_UNLIKELY( slot->skip!=FD_GUI_SKIP_STATUS_NOT_SKIPPED ) ) continue; /* Skipped slots don't count to TPS. */
     751           0 :     if( FD_UNLIKELY( slot->vote_failed==UINT_MAX ) ) continue; /* Slot transaction counts not yet populated. */
     752           0 :     vote_failed     += slot->vote_failed;
     753           0 :     vote_success    += slot->vote_success;
     754           0 :     nonvote_success += slot->nonvote_success;
     755           0 :     nonvote_failed  += slot->nonvote_failed;
     756           0 :   }
     757             : 
     758           0 :   gui->summary.estimated_tps_history[ gui->summary.estimated_tps_history_idx ].vote_failed = vote_failed;
     759           0 :   gui->summary.estimated_tps_history[ gui->summary.estimated_tps_history_idx ].vote_success = vote_success;
     760           0 :   gui->summary.estimated_tps_history[ gui->summary.estimated_tps_history_idx ].nonvote_success = nonvote_success;
     761           0 :   gui->summary.estimated_tps_history[ gui->summary.estimated_tps_history_idx ].nonvote_failed = nonvote_failed;
     762           0 :   gui->summary.estimated_tps_history_idx = (gui->summary.estimated_tps_history_idx+1UL) % FD_GUI_TPS_HISTORY_SAMPLE_CNT;
     763           0 : }
     764             : 
     765             : static void
     766             : fd_gui_network_stats_snap_egress( fd_topo_t const *        topo,
     767             :                                   char const *             tile_name,
     768           0 :                                   fd_gui_network_stats_t * cur ) {
     769           0 :   ulong tile_cnt = fd_topo_tile_name_cnt( topo, tile_name );
     770           0 :   for( ulong i=0UL; i<tile_cnt; i++ ) {
     771           0 :     ulong tile_idx = fd_topo_find_tile( topo, tile_name, i );
     772           0 :     if( FD_UNLIKELY( tile_idx==ULONG_MAX ) ) continue;
     773           0 :     fd_topo_tile_t const * tile = &topo->tiles[ tile_idx ];
     774           0 :     for( ulong j=0UL; j<tile->in_cnt; j++ ) {
     775           0 :       ulong bytes = fd_metrics_link_in( tile->metrics, j )[ FD_METRICS_COUNTER_LINK_FRAG_CONSUMED_BYTES_OFF ];
     776           0 :       char const * link_name = topo->links[ tile->in_link_id[ j ] ].name;
     777           0 :       if( FD_UNLIKELY( !strcmp( link_name, "shred_net"  ) ) ) cur->out.turbine += bytes;
     778           0 :       if( FD_UNLIKELY( !strcmp( link_name, "repair_net" ) ) ) cur->out.repair  += bytes;
     779           0 :       if( FD_UNLIKELY( !strcmp( link_name, "rserve_net" ) ) ) cur->out.rserve  += bytes;
     780           0 :       if( FD_UNLIKELY( !strcmp( link_name, "votor_net"  ) ) ) cur->out.votor   += bytes;
     781           0 :     }
     782           0 :   }
     783           0 : }
     784             : 
     785             : static void
     786             : fd_gui_network_stats_snap( fd_gui_t *               gui,
     787           0 :                            fd_gui_network_stats_t * cur ) {
     788           0 :   fd_topo_t const * topo = gui->topo;
     789           0 :   ulong gossvf_tile_cnt = fd_topo_tile_name_cnt( topo, "gossvf" );
     790           0 :   ulong gossip_tile_cnt = fd_topo_tile_name_cnt( topo, "gossip" );
     791           0 :   ulong shred_tile_cnt  = fd_topo_tile_name_cnt( topo, "shred" );
     792           0 :   ulong quic_tile_cnt   = fd_topo_tile_name_cnt( topo, "quic" );
     793             : 
     794           0 :   cur->in.gossip   = fd_gui_metrics_gossip_total_ingress_bytes( topo, gossvf_tile_cnt );
     795           0 :   cur->out.gossip  = fd_gui_metrics_gossip_total_egress_bytes( topo, gossip_tile_cnt );
     796           0 :   cur->in.turbine  = fd_gui_metrics_sum_tiles_counter( topo, "shred", shred_tile_cnt, MIDX( COUNTER, SHRED, TURBINE_RX_BYTES ) );
     797             : 
     798           0 :   cur->out.turbine = 0UL;
     799           0 :   cur->out.repair  = 0UL;
     800           0 :   cur->out.rserve  = 0UL;
     801           0 :   cur->out.tpu     = 0UL;
     802           0 :   cur->out.votor   = 0UL;
     803           0 :   cur->in.votor    = 0UL;
     804           0 :   fd_gui_network_stats_snap_egress( topo, "net",  cur );
     805           0 :   fd_gui_network_stats_snap_egress( topo, "mlx5", cur );
     806           0 :   fd_gui_network_stats_snap_egress( topo, "iavf", cur );
     807             : 
     808           0 :   ulong votor_tile_idx = fd_topo_find_tile( topo, "votor", 0UL );
     809           0 :   if( FD_UNLIKELY( votor_tile_idx!=ULONG_MAX ) ) {
     810           0 :     fd_topo_tile_t const * votor = &topo->tiles[ votor_tile_idx ];
     811           0 :     for( ulong i=0UL; i<votor->in_cnt; i++ ) {
     812           0 :       if( FD_UNLIKELY( !strcmp( topo->links[ votor->in_link_id[ i ] ].name, "net_votor" ) ) ) {
     813           0 :           cur->in.votor += fd_metrics_link_in( votor->metrics, i )[ FD_METRICS_COUNTER_LINK_FRAG_CONSUMED_BYTES_OFF ];
     814           0 :       }
     815           0 :     }
     816           0 :   }
     817             : 
     818           0 :   cur->in.repair = fd_gui_metrics_sum_tiles_counter( topo, "shred", shred_tile_cnt, MIDX( COUNTER, SHRED, REPAIR_RX_BYTES ) );
     819           0 :   ulong repair_tile_idx = fd_topo_find_tile( topo, "repair", 0UL );
     820           0 :   if( FD_LIKELY( repair_tile_idx!=ULONG_MAX ) ) {
     821           0 :     fd_topo_tile_t const * repair = &topo->tiles[ repair_tile_idx ];
     822             : 
     823           0 :     for( ulong i=0UL; i<repair->in_cnt; i++ ) {
     824           0 :       if( FD_UNLIKELY( !strcmp( topo->links[ repair->in_link_id[ i ] ].name, "shred_repair" ) ) ) {
     825           0 :           cur->in.repair += fd_metrics_link_in( repair->metrics, i )[ FD_METRICS_COUNTER_LINK_FRAG_CONSUMED_BYTES_OFF ];
     826           0 :       }
     827           0 :     }
     828           0 :   }
     829             : 
     830           0 :   cur->in.rserve = 0UL;
     831           0 :   ulong rserve_tile_idx = fd_topo_find_tile( topo, "rserve", 0UL );
     832           0 :   if( FD_LIKELY( rserve_tile_idx!=ULONG_MAX ) ) {
     833           0 :     fd_topo_tile_t const * rserve = &topo->tiles[ rserve_tile_idx ];
     834             : 
     835           0 :     for( ulong i=0UL; i<rserve->in_cnt; i++ ) {
     836           0 :       if( FD_UNLIKELY( !strcmp( topo->links[ rserve->in_link_id[ i ] ].name, "net_rserve" ) ) ) {
     837           0 :           cur->in.rserve += fd_metrics_link_in( rserve->metrics, i )[ FD_METRICS_COUNTER_LINK_FRAG_CONSUMED_BYTES_OFF ];
     838           0 :       }
     839           0 :     }
     840           0 :   }
     841             : 
     842           0 :   cur->in.tpu = 0UL;
     843           0 :   for( ulong i=0UL; i<quic_tile_cnt; i++ ) {
     844           0 :     ulong quic_tile_idx = fd_topo_find_tile( topo, "quic", i );
     845           0 :     if( FD_UNLIKELY( quic_tile_idx==ULONG_MAX ) ) continue;
     846           0 :     fd_topo_tile_t const * quic = &topo->tiles[ quic_tile_idx ];
     847           0 :     volatile ulong * quic_metrics = fd_metrics_tile( quic->metrics );
     848           0 :     cur->in.tpu += quic_metrics[ MIDX( COUNTER, QUIC, PKT_RX_BYTES ) ];
     849           0 :   }
     850             : 
     851           0 :   ulong bundle_tile_idx = fd_topo_find_tile( topo, "bundle", 0UL );
     852           0 :   if( FD_LIKELY( bundle_tile_idx!=ULONG_MAX ) ) {
     853           0 :     fd_topo_tile_t const * bundle = &topo->tiles[ bundle_tile_idx ];
     854           0 :     volatile ulong * bundle_metrics = fd_metrics_tile( bundle->metrics );
     855           0 :     cur->in.tpu += bundle_metrics[ MIDX( COUNTER, BUNDLE, PROTOBUF_RX_BYTES ) ];
     856           0 :   }
     857             : 
     858           0 :   ulong metric_tile_idx = fd_topo_find_tile( topo, "metric", 0UL );
     859           0 :   if( FD_LIKELY( metric_tile_idx!=ULONG_MAX ) ) {
     860           0 :     fd_topo_tile_t const * metric = &topo->tiles[ metric_tile_idx ];
     861           0 :     volatile ulong * metric_metrics = fd_metrics_tile( metric->metrics );
     862           0 :     cur->in.metric  = metric_metrics[ MIDX( COUNTER, METRIC, CONN_RX_BYTES ) ];
     863           0 :     cur->out.metric = metric_metrics[ MIDX( COUNTER, METRIC, CONN_TX_BYTES ) ];
     864           0 :   } else {
     865           0 :     cur->in.metric  = 0UL;
     866           0 :     cur->out.metric = 0UL;
     867           0 :   }
     868           0 : }
     869             : 
     870             : static void
     871             : fd_gui_network_rate_max_update( fd_gui_t * gui,
     872           0 :                                 long       now ) {
     873           0 :   fd_gui_network_stats_t * cur  = gui->summary.network_stats_current;
     874           0 :   fd_gui_network_stats_t * prev = gui->summary.network_stats_prev;
     875             : 
     876             :   /* On the first sample we have no previous value. */
     877           0 :   if( FD_UNLIKELY( !gui->summary.network_stats_has_prev ) ) {
     878           0 :     *prev = *cur;
     879           0 :     gui->summary.network_stats_has_prev = 1;
     880           0 :     gui->summary.net_rate_prev_ts       = now;
     881           0 :     return;
     882           0 :   }
     883             : 
     884           0 :   ulong d_in[ FD_GUI_NET_PROTO_CNT ];
     885           0 :   d_in[ 0 ] = fd_ulong_sat_sub( cur->in.turbine, prev->in.turbine );
     886           0 :   d_in[ 1 ] = fd_ulong_sat_sub( cur->in.gossip,  prev->in.gossip  );
     887           0 :   d_in[ 2 ] = fd_ulong_sat_sub( cur->in.tpu,     prev->in.tpu     );
     888           0 :   d_in[ 3 ] = fd_ulong_sat_sub( cur->in.repair,  prev->in.repair  );
     889           0 :   d_in[ 4 ] = fd_ulong_sat_sub( cur->in.rserve,  prev->in.rserve  );
     890           0 :   d_in[ 5 ] = fd_ulong_sat_sub( cur->in.metric,  prev->in.metric  );
     891           0 :   d_in[ 6 ] = fd_ulong_sat_sub( cur->in.votor,   prev->in.votor   );
     892             : 
     893           0 :   ulong d_out[ FD_GUI_NET_PROTO_CNT ];
     894           0 :   d_out[ 0 ] = fd_ulong_sat_sub( cur->out.turbine, prev->out.turbine );
     895           0 :   d_out[ 1 ] = fd_ulong_sat_sub( cur->out.gossip,  prev->out.gossip  );
     896           0 :   d_out[ 2 ] = fd_ulong_sat_sub( cur->out.tpu,     prev->out.tpu     );
     897           0 :   d_out[ 3 ] = fd_ulong_sat_sub( cur->out.repair,  prev->out.repair  );
     898           0 :   d_out[ 4 ] = fd_ulong_sat_sub( cur->out.rserve,  prev->out.rserve  );
     899           0 :   d_out[ 5 ] = fd_ulong_sat_sub( cur->out.metric,  prev->out.metric  );
     900           0 :   d_out[ 6 ] = fd_ulong_sat_sub( cur->out.votor,   prev->out.votor   );
     901             : 
     902             :   /* Compute per-protocol instantaneous bytes/sec rate and feed the EMA. */
     903           0 :   long dt_ns = now - gui->summary.net_rate_prev_ts;
     904           0 :   if( FD_LIKELY( dt_ns>0L ) ) {
     905           0 :     double dt_sec = (double)dt_ns / 1.0e9;
     906             : 
     907           0 :     for( ulong i=0UL; i<FD_GUI_NET_PROTO_CNT; i++ ) {
     908           0 :       double rate_in  = (double)d_in[ i ]  / dt_sec;
     909           0 :       double rate_out = (double)d_out[ i ] / dt_sec;
     910             : 
     911           0 :       fd_gui_ema_advance( &gui->summary.ingress_ema[ i ], now, rate_in  );
     912           0 :       fd_gui_ema_advance( &gui->summary.egress_ema [ i ], now, rate_out );
     913           0 :     }
     914           0 :   }
     915           0 :   gui->summary.net_rate_prev_ts = now;
     916             : 
     917             :   /* Track max total EMA in a rolling 5-minute window using monotonic
     918             :      deques.
     919             : 
     920             :      Invariant: deque entries are strictly decreasing in value from
     921             :      head to tail.  The head is always the current window maximum.
     922             : 
     923             :      Insert:  pop tail entries whose value <= new value (they can
     924             :               never become the maximum), then push the new entry.
     925             :      Expire:  pop head entries older than 5 minutes. */
     926           0 :   if( FD_LIKELY( gui->summary.ingress_ema[ 0 ].last_update_nanos ) ) {
     927           0 :     double sum_in  = 0.0;
     928           0 :     double sum_out = 0.0;
     929           0 :     for( ulong i=0UL; i<FD_GUI_NET_PROTO_CNT; i++ ) {
     930           0 :       sum_in  += gui->summary.ingress_ema[ i ].value;
     931           0 :       sum_out += gui->summary.egress_ema[ i ].value;
     932           0 :     }
     933             : 
     934           0 :     while( !fd_gui_rate_deque_empty( gui->summary.ingress_maxq ) && fd_gui_rate_deque_peek_head_const( gui->summary.ingress_maxq )->ts_nanos<now-FD_GUI_NET_RATE_MAX_WINDOW_NS ) {
     935           0 :       fd_gui_rate_deque_pop_head( gui->summary.ingress_maxq );
     936           0 :     }
     937           0 :     while( !fd_gui_rate_deque_empty( gui->summary.ingress_maxq ) && fd_gui_rate_deque_peek_tail_const( gui->summary.ingress_maxq )->value<=sum_in ) {
     938           0 :       fd_gui_rate_deque_pop_tail( gui->summary.ingress_maxq );
     939           0 :     }
     940           0 :     if( FD_UNLIKELY( fd_gui_rate_deque_full( gui->summary.ingress_maxq ) ) ) {
     941           0 :       fd_gui_rate_deque_pop_tail( gui->summary.ingress_maxq );
     942           0 :     }
     943           0 :     fd_gui_rate_deque_push_tail( gui->summary.ingress_maxq, (fd_gui_rate_entry_t){ .ts_nanos=now, .value=sum_in } );
     944             : 
     945           0 :     while( !fd_gui_rate_deque_empty( gui->summary.egress_maxq ) && fd_gui_rate_deque_peek_head_const( gui->summary.egress_maxq )->ts_nanos<now-FD_GUI_NET_RATE_MAX_WINDOW_NS ) {
     946           0 :       fd_gui_rate_deque_pop_head( gui->summary.egress_maxq );
     947           0 :     }
     948           0 :     while( !fd_gui_rate_deque_empty( gui->summary.egress_maxq ) && fd_gui_rate_deque_peek_tail_const( gui->summary.egress_maxq )->value<=sum_out ) {
     949           0 :       fd_gui_rate_deque_pop_tail( gui->summary.egress_maxq );
     950           0 :     }
     951           0 :     if( FD_UNLIKELY( fd_gui_rate_deque_full( gui->summary.egress_maxq ) ) ) {
     952           0 :       fd_gui_rate_deque_pop_tail( gui->summary.egress_maxq );
     953           0 :     }
     954           0 :     fd_gui_rate_deque_push_tail( gui->summary.egress_maxq, (fd_gui_rate_entry_t){ .ts_nanos=now, .value=sum_out } );
     955           0 :   }
     956             : 
     957           0 :   *prev = *cur;
     958           0 : }
     959             : 
     960             : /* Snapshot accdb statistics by reading the accdb tile's metric page
     961             :    (for gauges) and summing counters across all tiles that join accdb
     962             :    (executors, replay, rpc, resolv, plus the accdb tile itself).
     963             :    The result feeds the GUI "Accounts" page. */
     964             : 
     965             : static void
     966             : fd_gui_accounts_stats_snap( fd_gui_t *                gui,
     967           0 :                             fd_gui_accounts_stats_t * cur ) {
     968           0 :   fd_topo_t const * topo = gui->topo;
     969             : 
     970           0 :   memset( cur, 0, sizeof(*cur) );
     971           0 :   cur->sample_time_nanos = fd_log_wallclock();
     972             : 
     973           0 :   ulong accdb_tile_idx = fd_topo_find_tile( topo, "accdb", 0UL );
     974           0 :   if( FD_UNLIKELY( accdb_tile_idx==ULONG_MAX ) ) return;
     975             : 
     976             :   /* Gauges + accdb-tile-only counters. */
     977           0 :   fd_topo_tile_t const * accdb = &topo->tiles[ accdb_tile_idx ];
     978           0 :   volatile ulong const * am    = fd_metrics_tile( accdb->metrics );
     979             : 
     980           0 :   cur->accounts_total           = am[ MIDX( GAUGE,   ACCDB, ACCOUNT_USED            ) ];
     981           0 :   cur->accounts_capacity        = am[ MIDX( GAUGE,   ACCDB, ACCOUNT_CAPACITY        ) ];
     982           0 :   cur->disk_allocated_bytes     = am[ MIDX( GAUGE,   ACCDB, DISK_ALLOCATED_BYTES    ) ];
     983           0 :   cur->disk_current_bytes       = am[ MIDX( GAUGE,   ACCDB, DISK_CONSUMED_BYTES     ) ];
     984           0 :   cur->disk_used_bytes          = am[ MIDX( GAUGE,   ACCDB, DISK_USED_BYTES         ) ];
     985           0 :   cur->in_compaction            = am[ MIDX( GAUGE,   ACCDB, IS_COMPACTING           ) ];
     986           0 :   cur->compactions_requested    = am[ MIDX( COUNTER, ACCDB, COMPACTION_REQUESTED    ) ];
     987           0 :   cur->compactions_completed    = am[ MIDX( COUNTER, ACCDB, COMPACTION_COMPLETED    ) ];
     988           0 :   cur->accounts_relocated_bytes = am[ MIDX( COUNTER, ACCDB, ACCOUNT_RELOCATED_BYTES ) ];
     989           0 :   cur->bytes_written_accdb      = am[ MIDX( COUNTER, ACCDB, DISK_WRITTEN_BYTES      ) ];
     990             : 
     991             :   /* The accdb tile owns the prewrite and compaction writes; include
     992             :      those in the aggregate bytes_written / write_ops so the IO panel
     993             :      reflects all on-disk write activity, not just consumer-driven
     994             :      commits. */
     995           0 :   cur->bytes_written += am[ MIDX( COUNTER, ACCDB, DISK_WRITTEN_BYTES  ) ];
     996           0 :   cur->write_ops     += am[ MIDX( COUNTER, ACCDB, WRITEBACK_WRITTEN   ) ];
     997             : 
     998           0 :   for( ulong c=0UL; c<FD_ACCDB_CACHE_CLASS_CNT; c++ ) {
     999           0 :     cur->cache_class_used         [ c ] = am[ MIDX( GAUGE, ACCDB, CACHE_CLASS_USED            ) + c ];
    1000           0 :     cur->cache_class_max          [ c ] = am[ MIDX( GAUGE, ACCDB, CACHE_CLASS_CAPACITY        ) + c ];
    1001           0 :     int   tracked                       = !!am[ MIDX( GAUGE, ACCDB, IS_CACHE_CLASS_RESERVATION_TRACKED ) + c ];
    1002           0 :     cur->cache_class_reserved     [ c ] = fd_ulong_if( tracked, am[ MIDX( GAUGE, ACCDB, CACHE_CLASS_RESERVED ) + c ], ULONG_MAX );
    1003           0 :     ulong free_target                   = am[ MIDX( GAUGE, ACCDB, CACHE_CLASS_FREE_TARGET     ) + c ];
    1004           0 :     ulong free_low_water                = am[ MIDX( GAUGE, ACCDB, CACHE_CLASS_FREE_LOW_WATER  ) + c ];
    1005           0 :     cur->cache_class_target_used  [ c ] = fd_ulong_sat_sub( cur->cache_class_max[ c ], free_target    );
    1006           0 :     cur->cache_class_low_water_used[c ] = fd_ulong_sat_sub( cur->cache_class_max[ c ], free_low_water );
    1007           0 :     cur->preevicted_per_class     [ c ] = am[ MIDX( COUNTER, ACCDB, ACCOUNT_PREEVICTED        ) + c ];
    1008           0 :   }
    1009             : 
    1010             :   /* Walk the per-tile slot table built at init.  Each slot reads its
    1011             :      tile's accdb counters according to its kind (RW, RO, or ACCDB),
    1012             :      accumulates into the aggregate (cur->*), and stashes the per-tile
    1013             :      cumulative values into gui->summary.accdb->tile_cur_* for the
    1014             :      per-tile rate window pushes done later in
    1015             :      fd_gui_accounts_stats_window_push. */
    1016           0 :   for( ulong s=0UL; s<gui->summary.accdb->accdb_tile_cnt; s++ ) {
    1017           0 :     ulong t_idx = (ulong)gui->summary.accdb->accdb_tile_topo_idx[ s ];
    1018           0 :     uchar kind  = gui->summary.accdb->accdb_tile_kind[ s ];
    1019           0 :     volatile ulong const * m = fd_metrics_tile( topo->tiles[ t_idx ].metrics );
    1020             : 
    1021           0 :     gui->summary.accdb->tile_cur_status[ s ] = (uchar)m[ MIDX( GAUGE, TILE, STATE ) ];
    1022             : 
    1023           0 :     ulong t_acq=0UL, t_acw=0UL, t_misses=0UL, t_evicted=0UL, t_committed=0UL;
    1024           0 :     ulong t_bytes_read=0UL, t_bytes_copied=0UL, t_bytes_written=0UL;
    1025           0 :     ulong t_read_ops=0UL, t_write_ops=0UL;
    1026           0 :     ulong t_acquire_calls=0UL;
    1027             : 
    1028           0 :     switch( kind ) {
    1029           0 : #   define DO_RW( TILE_UPPER )                                                                                                    \
    1030           0 :         t_bytes_read    = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_DISK_READ_BYTES    ) ];                                             \
    1031           0 :         t_bytes_copied  = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_COPIED_BYTES       ) ];                                             \
    1032           0 :         t_bytes_written = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_DISK_WRITTEN_BYTES ) ];                                             \
    1033           0 :         t_read_ops      = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_DISK_READ          ) ];                                             \
    1034           0 :         t_write_ops     = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_DISK_WRITTEN       ) ];                                             \
    1035           0 :         t_acquire_calls = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_BATCH_ACQUIRED     ) ];                                             \
    1036           0 :         for( ulong c=0UL; c<FD_ACCDB_CACHE_CLASS_CNT; c++ ) {                                                                     \
    1037           0 :           ulong _acq = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_ACCOUNT_READONLY_ACQUIRED ) + c ];                                     \
    1038           0 :           ulong _acw = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_ACCOUNT_WRITABLE_ACQUIRED ) + c ];                                     \
    1039           0 :           ulong _nf  = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_ACCOUNT_CACHE_MISSED      ) + c ];                                     \
    1040           0 :           ulong _ev  = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_ACCOUNT_EVICTED           ) + c ];                                     \
    1041           0 :           ulong _cn  = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_ACCOUNT_NEW_COMMITTED        ) + c ];                                  \
    1042           0 :           ulong _co  = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_ACCOUNT_OVERWRITE_COMMITTED  ) + c ];                                  \
    1043           0 :           t_acq+=_acq; t_acw+=_acw; t_misses+=_nf; t_evicted+=_ev; t_committed+=_cn+_co;                                          \
    1044           0 :           cur->acquired_per_class            [ c ] += _acq;                                                                       \
    1045           0 :           cur->acquired_writable_per_class   [ c ] += _acw;                                                                       \
    1046           0 :           cur->not_found_per_class           [ c ] += _nf;                                                                        \
    1047           0 :           cur->evicted_per_class             [ c ] += _ev;                                                                        \
    1048           0 :           cur->committed_new_per_class       [ c ] += _cn;                                                                        \
    1049           0 :           cur->committed_overwrite_per_class [ c ] += _co;                                                                        \
    1050           0 :         }
    1051           0 :       case FD_GUI_ACCDB_TILE_KIND_RW:
    1052           0 :         if(      !strcmp( topo->tiles[ t_idx ].name, "execle" ) ) { DO_RW( EXECLE ); }
    1053           0 :         else if( !strcmp( topo->tiles[ t_idx ].name, "execrp" ) ) { DO_RW( EXECRP ); }
    1054           0 :         else if( !strcmp( topo->tiles[ t_idx ].name, "replay" ) ) { DO_RW( REPLAY ); }
    1055           0 :         cur->acquired          += t_acq;
    1056           0 :         cur->acquired_writable += t_acw;
    1057           0 :         cur->bytes_read        += t_bytes_read;
    1058           0 :         cur->bytes_copied      += t_bytes_copied;
    1059           0 :         cur->bytes_written     += t_bytes_written;
    1060           0 :         cur->read_ops          += t_read_ops;
    1061           0 :         cur->write_ops         += t_write_ops;
    1062           0 :         break;
    1063           0 : #   undef DO_RW
    1064             : 
    1065           0 : #   define DO_RO( TILE_UPPER )                                                                \
    1066           0 :         t_bytes_read    = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_DISK_READ_BYTES ) ];            \
    1067           0 :         t_bytes_copied  = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_COPIED_BYTES    ) ];            \
    1068           0 :         t_read_ops      = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_DISK_READ       ) ];            \
    1069           0 :         for( ulong c=0UL; c<FD_ACCDB_CACHE_CLASS_CNT; c++ ) {                                 \
    1070           0 :           ulong _acq = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_ACCOUNT_READONLY_ACQUIRED ) + c ]; \
    1071           0 :           ulong _nf  = m[ MIDX( COUNTER, TILE_UPPER, ACCDB_ACCOUNT_CACHE_MISSED      ) + c ]; \
    1072           0 :           t_acq+=_acq; t_misses+=_nf;                                                         \
    1073           0 :           cur->acquired_per_class [ c ] += _acq;                                              \
    1074           0 :           cur->not_found_per_class[ c ] += _nf;                                               \
    1075           0 :         }
    1076           0 :       case FD_GUI_ACCDB_TILE_KIND_RO:
    1077           0 :         if( !strcmp( topo->tiles[ t_idx ].name, "rpc"    ) ) { DO_RO( RPC    ); }
    1078           0 :         else if( !strcmp( topo->tiles[ t_idx ].name, "resolv" ) ) { DO_RO( RESOLV ); }
    1079           0 :         cur->acquired     += t_acq;
    1080           0 :         cur->bytes_read   += t_bytes_read;
    1081           0 :         cur->bytes_copied += t_bytes_copied;
    1082           0 :         cur->read_ops     += t_read_ops;
    1083           0 :         break;
    1084           0 : #   undef DO_RO
    1085             : 
    1086           0 :       case FD_GUI_ACCDB_TILE_KIND_SNAPIN:
    1087             :         /* snapin writes account data to disk directly during snapshot
    1088             :            load. */
    1089           0 :         t_bytes_written = m[ MIDX( COUNTER, SNAPIN, DISK_WRITTEN_BYTES ) ];
    1090           0 :         cur->bytes_written += t_bytes_written;
    1091           0 :         break;
    1092             : 
    1093           0 :       case FD_GUI_ACCDB_TILE_KIND_ACCDB:
    1094             :         /* The accdb tile owns prewrite and compaction writes.  Its own
    1095             :            bytes_written/write_ops were already folded into the aggregate
    1096             :            above (see ACCDB_DISK_WRITTEN_BYTES / ACCDB_WRITE_OPS reads).  Here
    1097             :            we only stash per-slot values so the per-tile row reflects
    1098             :            them; do not re-add to cur->* or we'd double-count.  The accdb
    1099             :            tile does not expose acquired/not_found/committed (no account
    1100             :            joiner) or read_ops/bytes_copied.  Preevicts are owned by the
    1101             :            accdb tile's background preevict pass, so map them to the
    1102             :            per-tile evicted column for this row. */
    1103           0 :         t_bytes_read    = m[ MIDX( COUNTER, ACCDB, DISK_READ_BYTES    ) ];
    1104           0 :         t_bytes_written = m[ MIDX( COUNTER, ACCDB, DISK_WRITTEN_BYTES ) ];
    1105           0 :         t_write_ops     = m[ MIDX( COUNTER, ACCDB, WRITEBACK_WRITTEN  ) ];
    1106           0 :         for( ulong c=0UL; c<FD_ACCDB_CACHE_CLASS_CNT; c++ ) {
    1107           0 :           t_evicted += m[ MIDX( COUNTER, ACCDB, ACCOUNT_PREEVICTED ) + c ];
    1108           0 :         }
    1109           0 :         break;
    1110           0 :     }
    1111             : 
    1112           0 :     gui->summary.accdb->tile_cur_acquired         [ s ] = t_acq;
    1113           0 :     gui->summary.accdb->tile_cur_acquired_writable[ s ] = t_acw;
    1114           0 :     gui->summary.accdb->tile_cur_bytes_read       [ s ] = t_bytes_read;
    1115           0 :     gui->summary.accdb->tile_cur_bytes_copied     [ s ] = t_bytes_copied;
    1116           0 :     gui->summary.accdb->tile_cur_bytes_written    [ s ] = t_bytes_written;
    1117           0 :     gui->summary.accdb->tile_cur_read_ops         [ s ] = t_read_ops;
    1118           0 :     gui->summary.accdb->tile_cur_write_ops        [ s ] = t_write_ops;
    1119           0 :     gui->summary.accdb->tile_cur_misses           [ s ] = t_misses;
    1120           0 :     gui->summary.accdb->tile_cur_evicted          [ s ] = t_evicted;
    1121           0 :     gui->summary.accdb->tile_cur_committed        [ s ] = t_committed;
    1122           0 :     gui->summary.accdb->tile_cur_acquire_calls    [ s ] = t_acquire_calls;
    1123           0 :   }
    1124             : 
    1125           0 :   if( FD_UNLIKELY( !gui->accdb_shmem ) ) return;
    1126             : 
    1127             :   /* Snapshot per-partition utilization and fragmentation and also
    1128             :      their respective per-tier rate of growth. Actively-compacting
    1129             :      partitions excluded so relocation churn does not degrade estimates. */
    1130           0 :   ulong pcnt = fd_ulong_min( fd_accdb_shmem_partition_max( gui->accdb_shmem ), FD_GUI_MAX_PARTITIONS );
    1131           0 :   gui->summary.accdb->partition_cnt = pcnt;
    1132             : 
    1133           0 :   double tier_fill_delta[ FD_ACCDB_COMPACTION_LAYER_CNT ] = { 0.0 };
    1134           0 :   double tier_free_delta[ FD_ACCDB_COMPACTION_LAYER_CNT ] = { 0.0 };
    1135           0 :   ulong  compaction_idx   = ULONG_MAX;
    1136           0 :   ulong  compaction_layer = FD_ACCDB_COMPACTION_LAYER_CNT;
    1137           0 :   ulong  compaction_state = 0UL;
    1138           0 :   for( ulong p=0UL; p<pcnt; p++ ) {
    1139           0 :     fd_accdb_shmem_partition_info_t   prev_info =  gui->summary.accdb->partitions[ p ];
    1140           0 :     fd_accdb_shmem_partition_info_t * info      = &gui->summary.accdb->partitions[ p ];
    1141           0 :     fd_accdb_shmem_partition_info( gui->accdb_shmem, p, info );
    1142             : 
    1143           0 :     if( FD_UNLIKELY( info->compaction_state && ( compaction_state<info->compaction_state || ( compaction_state==info->compaction_state && info->layer<compaction_layer ) ) ) ) {
    1144           0 :       compaction_idx   = p;
    1145           0 :       compaction_layer = info->layer;
    1146           0 :       compaction_state = info->compaction_state;
    1147           0 :     }
    1148             : 
    1149           0 :     if( FD_LIKELY( info->layer<FD_ACCDB_COMPACTION_LAYER_CNT ) ) {
    1150             :       /* Only the <=3 write-head partitions advance, and freed bytes
    1151             :          land in a handful of partitions per 100ms snap. */
    1152           0 :       if( FD_UNLIKELY( info->write_offset>prev_info.write_offset ) )
    1153           0 :         tier_fill_delta[ info->layer ] += (double)(info->write_offset-prev_info.write_offset);
    1154           0 :       if( FD_UNLIKELY( info->compaction_state!=2 && info->bytes_freed>prev_info.bytes_freed ) )
    1155           0 :         tier_free_delta[ info->layer ] += (double)(info->bytes_freed-prev_info.bytes_freed);
    1156           0 :     }
    1157           0 :   }
    1158             : 
    1159             :   /* First snap has no valid deltas. */
    1160           0 :   if( FD_LIKELY( gui->summary.accdb->tier_sample_nanos!=LONG_MAX ) ) {
    1161           0 :     double dt_sec = (double)(cur->sample_time_nanos-gui->summary.accdb->tier_sample_nanos)/1e9;
    1162           0 :     if( FD_LIKELY( dt_sec>0.0 ) ) {
    1163           0 :       for( ulong k=0UL; k<FD_ACCDB_COMPACTION_LAYER_CNT; k++ ) {
    1164           0 :         fd_gui_ema_advance( &gui->summary.accdb->tier_fill_bps_ema[ k ], cur->sample_time_nanos, tier_fill_delta[ k ]/dt_sec );
    1165           0 :         fd_gui_ema_advance( &gui->summary.accdb->tier_free_bps_ema[ k ], cur->sample_time_nanos, tier_free_delta[ k ]/dt_sec );
    1166           0 :       }
    1167           0 :     }
    1168           0 :   }
    1169           0 :   gui->summary.accdb->tier_sample_nanos = cur->sample_time_nanos;
    1170             : 
    1171             :   /* Estimate next compaction time/partition. */
    1172           0 :   double next_secs = 0.0;
    1173           0 :   ulong  next_idx  = ULONG_MAX;
    1174           0 :   double partition_sz = (double)fd_accdb_shmem_partition_sz( gui->accdb_shmem );
    1175           0 :   double tier_live_bytes[ FD_ACCDB_COMPACTION_LAYER_CNT ] = { 0.0 };
    1176           0 :   for( ulong p=0UL; p<pcnt; p++ ) {
    1177           0 :     fd_accdb_shmem_partition_info_t const * info = &gui->summary.accdb->partitions[ p ];
    1178           0 :     if( info->layer<FD_ACCDB_COMPACTION_LAYER_CNT && info->compaction_state!=2 && info->write_offset>info->bytes_freed && info->compaction_offset<info->write_offset )
    1179           0 :       tier_live_bytes[ info->layer ] += (double)(info->write_offset-info->bytes_freed);
    1180           0 :   }
    1181           0 :   for( ulong p=0UL; p<pcnt; p++ ) {
    1182           0 :     fd_accdb_shmem_partition_info_t const * info = &gui->summary.accdb->partitions[ p ];
    1183           0 :     if( FD_LIKELY( info->compaction_state || !info->write_offset ) ) continue;
    1184           0 :     if( FD_UNLIKELY( info->layer>=FD_ACCDB_COMPACTION_LAYER_CNT ) ) continue;
    1185           0 :     if( FD_UNLIKELY( info->compaction_offset>=info->write_offset ) ) continue; /* compacted, awaiting reclaim */
    1186             : 
    1187           0 :     double free_bps  = gui->summary.accdb->tier_free_bps_ema[ info->layer ].value;
    1188           0 :     double live      = info->write_offset>info->bytes_freed ? (double)(info->write_offset-info->bytes_freed) : 0.0;
    1189           0 :     double frag_rate = tier_live_bytes[ info->layer ]>0.0 ? free_bps*live/tier_live_bytes[ info->layer ] : 0.0;
    1190           0 :     double deficit   = (double)FD_ACCDB_COMPACTION_THRESHOLD_PCT/100.0*partition_sz - (double)info->bytes_freed;
    1191           0 :     double frag_secs = deficit<=0.0 ? 0.0 : ( frag_rate>0.0 ? deficit/frag_rate : -1.0 );
    1192           0 :     double fill_secs = 0.0;
    1193           0 :     if( FD_UNLIKELY( info->is_write_head ) ) {
    1194           0 :       double fill_bps = gui->summary.accdb->tier_fill_bps_ema[ info->layer ].value;
    1195           0 :       fill_secs = fill_bps>0.0 ? (partition_sz-(double)info->write_offset)/fill_bps : -1.0;
    1196           0 :     }
    1197             : 
    1198           0 :     if( FD_UNLIKELY( frag_secs<0.0 || fill_secs<0.0 ) ) continue; /* no usable rate estimate (EMA warm-up) */
    1199           0 :     double est = fmax( frag_secs, fill_secs );
    1200           0 :     if( next_idx==ULONG_MAX || est<next_secs ) {
    1201           0 :       next_secs = est;
    1202           0 :       next_idx  = p;
    1203           0 :     }
    1204           0 :   }
    1205             : 
    1206           0 :   int has_compaction = compaction_idx!=ULONG_MAX;
    1207           0 :   gui->summary.accdb->next_compaction_remaining_secs = fd_double_if( has_compaction, 0.0,            next_secs );
    1208           0 :   gui->summary.accdb->next_compaction_partition_idx  = fd_ulong_if(  has_compaction, compaction_idx, next_idx  );
    1209           0 : }
    1210             : 
    1211             : /* Snapshot all of the data from metrics to construct a view of the
    1212             :    transaction waterfall.
    1213             : 
    1214             :    Tiles are sampled in reverse pipeline order: this helps prevent data
    1215             :    discrepancies where a later tile has "seen" more transactions than an
    1216             :    earlier tile, which shouldn't typically happen. */
    1217             : 
    1218             : static void
    1219             : fd_gui_txn_waterfall_snap( fd_gui_t *               gui,
    1220           6 :                            fd_gui_txn_waterfall_t * cur ) {
    1221           6 :   memset( cur, 0, sizeof(fd_gui_txn_waterfall_t) );
    1222           6 :   fd_topo_t const * topo = gui->topo;
    1223             : 
    1224           6 :   for( ulong i=0UL; i<gui->summary.execle_tile_cnt; i++ ) {
    1225           0 :     fd_topo_tile_t const * execle = &topo->tiles[ fd_topo_find_tile( topo, "execle", i ) ];
    1226             : 
    1227           0 :     volatile ulong const * execle_metrics = fd_metrics_tile( execle->metrics );
    1228             : 
    1229           0 :     cur->out.block_success += execle_metrics[ MIDX( COUNTER, EXECLE, TXN_PROCESSED_BY_LANDING_SUCCESS ) ];
    1230           0 :     cur->out.block_fail    +=
    1231           0 :         execle_metrics[ MIDX( COUNTER, EXECLE, TXN_PROCESSED_BY_LANDING_FEES_ONLY ) ]
    1232           0 :       + execle_metrics[ MIDX( COUNTER, EXECLE, TXN_PROCESSED_BY_LANDING_FAILED ) ];
    1233           0 :     cur->out.bank_invalid  += execle_metrics[ MIDX( COUNTER, EXECLE, TXN_PROCESSED_BY_LANDING_DROPPED ) ];
    1234             : 
    1235           0 :     cur->out.bank_nonce_already_advanced += execle_metrics[ MIDX( COUNTER, EXECLE, TXN_PROCESSED_NONCE_ALREADY_ADVANCED ) ];
    1236           0 :     cur->out.bank_nonce_advance_failed   += execle_metrics[ MIDX( COUNTER, EXECLE, TXN_PROCESSED_NONCE_ADVANCE_FAILED ) ];
    1237           0 :     cur->out.bank_nonce_wrong_blockhash  += execle_metrics[ MIDX( COUNTER, EXECLE, TXN_PROCESSED_NONCE_WRONG_BLOCKHASH ) ];
    1238           0 :   }
    1239             : 
    1240           6 :   ulong pack_tile_idx = fd_topo_find_tile( topo, "pack", 0UL );
    1241           6 :   if( pack_tile_idx!=ULONG_MAX ) {
    1242           0 :     fd_topo_tile_t const * pack = &topo->tiles[ pack_tile_idx ];
    1243           0 :     volatile ulong const * pack_metrics = fd_metrics_tile( pack->metrics );
    1244             : 
    1245           0 :     cur->out.pack_invalid_bundle =
    1246           0 :         pack_metrics[ MIDX( COUNTER, PACK, TXN_DROPPED_PARTIAL_BUNDLE ) ]
    1247           0 :       + pack_metrics[ MIDX( COUNTER, PACK, BUNDLE_CRANK_ATTEMPTED_INSERTION_FAILED ) ]
    1248           0 :       + pack_metrics[ MIDX( COUNTER, PACK, BUNDLE_CRANK_ATTEMPTED_CREATION_FAILED ) ];
    1249             : 
    1250           0 :     cur->out.pack_invalid =
    1251           0 :         pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_INSTR_TOO_MANY_ACCOUNTS ) ]
    1252           0 :       + pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_NONCE_CONFLICT ) ]
    1253           0 :       + pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_BUNDLE_BLOCKLISTED ) ]
    1254           0 :       + pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_INVALID_NONCE ) ]
    1255           0 :       + pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_WRITE_SYSVAR ) ]
    1256           0 :       + pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_ESTIMATION_FAILED ) ]
    1257           0 :       + pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_DUPLICATE_ACCOUNT ) ]
    1258           0 :       + pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_TOO_MANY_ACCOUNTS ) ]
    1259           0 :       + pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_TOO_MANY_CU ) ]
    1260           0 :       + pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_LUT_UNSUPPORTED ) ]
    1261           0 :       + pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_UNAFFORDABLE ) ]
    1262           0 :       + pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_DUPLICATE ) ]
    1263           0 :       - pack_metrics[ MIDX( COUNTER, PACK, BUNDLE_CRANK_ATTEMPTED_INSERTION_FAILED ) ]; /* so we don't double count this, since its already accounted for in invalid_bundle */
    1264             : 
    1265           0 :     cur->out.pack_expired = pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_EXPIRED ) ] +
    1266           0 :                             pack_metrics[ MIDX( COUNTER, PACK, TXN_DROPPED_EXPIRED ) ] +
    1267           0 :                             pack_metrics[ MIDX( COUNTER, PACK, TXN_EVICTED ) ] +
    1268           0 :                             pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_NONCE_PRIORITY_TOO_LOW ) ];
    1269             : 
    1270           0 :     cur->out.pack_already_executed = pack_metrics[ MIDX( COUNTER, PACK, TXN_DROPPED_ALREADY_EXECUTED ) ];
    1271             : 
    1272           0 :     cur->out.pack_leader_slow = pack_metrics[ MIDX( COUNTER, PACK, TXN_INSERT_ATTEMPTED_PRIORITY_TOO_LOW ) ];
    1273             : 
    1274           0 :     cur->out.pack_retained = fd_metrics_enum_group_sum( pack_metrics+MIDX( GAUGE, PACK, TXN_PENDING_USED ), FD_METRICS_ENUM_PENDING_TXN_TYPE_G_ALL_MASK );
    1275             : 
    1276           0 :     cur->in.pack_cranked =
    1277           0 :         pack_metrics[ MIDX( COUNTER, PACK, BUNDLE_CRANK_ATTEMPTED_INSERTED ) ]
    1278           0 :       + pack_metrics[ MIDX( COUNTER, PACK, BUNDLE_CRANK_ATTEMPTED_INSERTION_FAILED ) ]
    1279           0 :       + pack_metrics[ MIDX( COUNTER, PACK, BUNDLE_CRANK_ATTEMPTED_CREATION_FAILED ) ];
    1280           0 :   }
    1281             : 
    1282           6 :   for( ulong i=0UL; i<gui->summary.resolv_tile_cnt; i++ ) {
    1283           0 :     fd_topo_tile_t const * resolv = &topo->tiles[ fd_topo_find_tile( topo, "resolv", i ) ];
    1284           0 :     volatile ulong const * resolv_metrics = fd_metrics_tile( resolv->metrics );
    1285             : 
    1286           0 :     cur->out.resolv_no_ledger += resolv_metrics[ MIDX( COUNTER, RESOLV, TXN_DROPPED_NO_BANK ) ];
    1287           0 :     cur->out.resolv_expired += resolv_metrics[ MIDX( COUNTER, RESOLV, TXN_DROPPED_BLOCKHASH_EXPIRED  ) ]
    1288           0 :                                 + resolv_metrics[ MIDX( COUNTER, RESOLV, TXN_DROPPED_BUNDLE_PEER_FAILED ) ];
    1289           0 :     cur->out.resolv_lut_failed += resolv_metrics[ MIDX( COUNTER, RESOLV, TXN_LUT_RESOLVE_ATTEMPTED_ACCOUNT_NOT_FOUND ) ]
    1290           0 :                                 + resolv_metrics[ MIDX( COUNTER, RESOLV, TXN_LUT_RESOLVE_ATTEMPTED_INVALID_ACCOUNT_OWNER ) ]
    1291           0 :                                 + resolv_metrics[ MIDX( COUNTER, RESOLV, TXN_LUT_RESOLVE_ATTEMPTED_INVALID_ACCOUNT_DATA ) ]
    1292           0 :                                 + resolv_metrics[ MIDX( COUNTER, RESOLV, TXN_LUT_RESOLVE_ATTEMPTED_ACCOUNT_UNINITIALIZED ) ]
    1293           0 :                                 + resolv_metrics[ MIDX( COUNTER, RESOLV, TXN_LUT_RESOLVE_ATTEMPTED_INVALID_LOOKUP_INDEX ) ];
    1294           0 :     cur->out.resolv_ancient += resolv_metrics[ MIDX( COUNTER, RESOLV, STASH_TXN_REMOVED_EVICTED ) ];
    1295             : 
    1296           0 :     ulong inserted_to_resolv = resolv_metrics[ MIDX( COUNTER, RESOLV, STASH_TXN_INSERTED ) ];
    1297           0 :     ulong removed_from_resolv = resolv_metrics[ MIDX( COUNTER, RESOLV, STASH_TXN_REMOVED_EVICTED ) ]
    1298           0 :                               + resolv_metrics[ MIDX( COUNTER, RESOLV, STASH_TXN_REMOVED_PUBLISHED ) ]
    1299           0 :                               + resolv_metrics[ MIDX( COUNTER, RESOLV, STASH_TXN_REMOVED_FAILED ) ];
    1300           0 :     cur->out.resolv_retained += fd_ulong_if( inserted_to_resolv>=removed_from_resolv, inserted_to_resolv-removed_from_resolv, 0UL );
    1301           0 :   }
    1302             : 
    1303           6 :   ulong dedup_tile_idx = fd_topo_find_tile( topo, "dedup", 0UL );
    1304           6 :   if( FD_UNLIKELY( dedup_tile_idx!=ULONG_MAX ) ) {
    1305           0 :     fd_topo_tile_t const * dedup = &topo->tiles[ dedup_tile_idx ];
    1306           0 :     volatile ulong const * dedup_metrics = fd_metrics_tile( dedup->metrics );
    1307             : 
    1308           0 :     cur->out.dedup_duplicate = dedup_metrics[ MIDX( COUNTER, DEDUP, TXN_PROCESSED_DUPLICATE ) ]
    1309           0 :                              + dedup_metrics[ MIDX( COUNTER, DEDUP, TXN_PROCESSED_BUNDLE_PEER_FAILED ) ];
    1310           0 :   }
    1311             : 
    1312           6 :   for( ulong i=0UL; i<gui->summary.verify_tile_cnt; i++ ) {
    1313           0 :     fd_topo_tile_t const * verify = &topo->tiles[ fd_topo_find_tile( topo, "verify", i ) ];
    1314           0 :     volatile ulong const * verify_metrics = fd_metrics_tile( verify->metrics );
    1315             : 
    1316           0 :     for( ulong j=0UL; j<gui->summary.quic_tile_cnt; j++ ) {
    1317             :       /* TODO: Not precise... even if 1 frag gets skipped, it could have been for this verify tile. */
    1318           0 :       cur->out.verify_overrun += fd_metrics_link_in( verify->metrics, j )[ FD_METRICS_COUNTER_LINK_FRAG_POLLING_OVERRUN_OFF ] / gui->summary.verify_tile_cnt;
    1319           0 :       cur->out.verify_overrun += fd_metrics_link_in( verify->metrics, j )[ FD_METRICS_COUNTER_LINK_FRAG_READING_OVERRUN_OFF ];
    1320           0 :     }
    1321             : 
    1322           0 :     cur->out.verify_failed    += verify_metrics[ MIDX( COUNTER, VERIFY, TXN_PROCESSED_SIGNATURE_FAILED ) ] +
    1323           0 :                                  verify_metrics[ MIDX( COUNTER, VERIFY, TXN_PROCESSED_BUNDLE_PEER_FAILED ) ];
    1324           0 :     cur->out.verify_parse     += verify_metrics[ MIDX( COUNTER, VERIFY, TXN_PROCESSED_PARSE_FAILED ) ];
    1325           0 :     cur->out.verify_duplicate += verify_metrics[ MIDX( COUNTER, VERIFY, TXN_PROCESSED_DUPLICATE ) ];
    1326           0 :   }
    1327             : 
    1328           6 :   for( ulong i=0UL; i<gui->summary.quic_tile_cnt; i++ ) {
    1329           0 :     fd_topo_tile_t const * quic = &topo->tiles[ fd_topo_find_tile( topo, "quic", i ) ];
    1330           0 :     volatile ulong * quic_metrics = fd_metrics_tile( quic->metrics );
    1331             : 
    1332           0 :     cur->out.tpu_udp_invalid  += quic_metrics[ MIDX( COUNTER, QUIC, UDP_TXN_UNDERSIZE_DROPPED  ) ];
    1333           0 :     cur->out.tpu_udp_invalid  += quic_metrics[ MIDX( COUNTER, QUIC, UDP_TXN_OVERSIZE_DROPPED   ) ];
    1334           0 :     cur->out.tpu_quic_invalid += quic_metrics[ MIDX( COUNTER, QUIC, PKT_DROPPED                )+FD_METRICS_ENUM_QUIC_PKT_DROP_REASON_V_UNDERSIZE_IDX ];
    1335           0 :     cur->out.tpu_quic_invalid += quic_metrics[ MIDX( COUNTER, QUIC, PKT_DROPPED                )+FD_METRICS_ENUM_QUIC_PKT_DROP_REASON_V_OVERSIZE_IDX ];
    1336           0 :     cur->out.tpu_quic_invalid += quic_metrics[ MIDX( COUNTER, QUIC, TXN_OVERSIZE_DROPPED       ) ];
    1337           0 :     cur->out.tpu_quic_invalid += quic_metrics[ MIDX( COUNTER, QUIC, PKT_DECRYPT_FAILED         ) ];
    1338           0 :     cur->out.tpu_quic_invalid += quic_metrics[ MIDX( COUNTER, QUIC, PKT_NO_CONN_DROPPED        ) ];
    1339           0 :     cur->out.tpu_quic_invalid += quic_metrics[ MIDX( COUNTER, QUIC, PKT_DROPPED                )+FD_METRICS_ENUM_QUIC_PKT_DROP_REASON_V_SRC_IP_MISMATCH_IDX ];
    1340           0 :     cur->out.tpu_quic_invalid += quic_metrics[ MIDX( COUNTER, QUIC, PKT_DROPPED                )+FD_METRICS_ENUM_QUIC_PKT_DROP_REASON_V_NET_HEADER_INVALID_IDX ];
    1341           0 :     cur->out.tpu_quic_invalid += quic_metrics[ MIDX( COUNTER, QUIC, PKT_DROPPED                )+FD_METRICS_ENUM_QUIC_PKT_DROP_REASON_V_HEADER_INVALID_IDX ];
    1342           0 :     cur->out.quic_abandoned   += quic_metrics[ MIDX( COUNTER, QUIC, TXN_REASSEMBLY_ABANDONED   ) ];
    1343           0 :     cur->out.quic_frag_drop   += quic_metrics[ MIDX( COUNTER, QUIC, TXN_REASSEMBLY_EVICTED     ) ];
    1344             : 
    1345           0 :     for( ulong j=0UL; j<gui->summary.sock_tile_cnt+gui->summary.net_tile_cnt+gui->summary.mlx5_tile_cnt+gui->summary.iavf_tile_cnt; j++ ) {
    1346             :       /* TODO: Not precise... net frags that were skipped might not have been destined for QUIC tile */
    1347             :       /* TODO: Not precise... even if 1 frag gets skipped, it could have been for this QUIC tile */
    1348           0 :       cur->out.quic_overrun += fd_metrics_link_in( quic->metrics, j )[ FD_METRICS_COUNTER_LINK_FRAG_POLLING_OVERRUN_OFF ] / gui->summary.quic_tile_cnt;
    1349           0 :       cur->out.quic_overrun += fd_metrics_link_in( quic->metrics, j )[ FD_METRICS_COUNTER_LINK_FRAG_READING_OVERRUN_OFF ];
    1350           0 :     }
    1351           0 :   }
    1352             : 
    1353           6 :   for( ulong i=0UL; i<gui->summary.net_tile_cnt; i++ ) {
    1354           0 :     fd_topo_tile_t const * net = &topo->tiles[ fd_topo_find_tile( topo, "net", i ) ];
    1355           0 :     volatile ulong * net_metrics = fd_metrics_tile( net->metrics );
    1356             : 
    1357           0 :     cur->out.net_overrun += net_metrics[ MIDX( COUNTER, NET, XDP_RX_RING_FULL_DROPPED ) ];
    1358           0 :     cur->out.net_overrun += net_metrics[ MIDX( COUNTER, NET, XDP_RX_OTHER_DROPPED ) ];
    1359           0 :     cur->out.net_overrun += net_metrics[ MIDX( COUNTER, NET, XDP_RX_FILL_RING_EMPTY ) ];
    1360           0 :   }
    1361           6 :   ulong bundle_txns_received = 0UL;
    1362           6 :   ulong bundle_tile_idx = fd_topo_find_tile( topo, "bundle", 0UL );
    1363           6 :   if( FD_LIKELY( bundle_tile_idx!=ULONG_MAX ) ) {
    1364           0 :     fd_topo_tile_t const * bundle = &topo->tiles[ bundle_tile_idx ];
    1365           0 :     volatile ulong const * bundle_metrics = fd_metrics_tile( bundle->metrics );
    1366             : 
    1367           0 :     bundle_txns_received = bundle_metrics[ MIDX( COUNTER, BUNDLE, TXN_RX ) ];
    1368           0 :   }
    1369             : 
    1370           6 :   cur->in.quic     = cur->out.tpu_quic_invalid +
    1371           6 :                      cur->out.quic_overrun +
    1372           6 :                      cur->out.quic_frag_drop +
    1373           6 :                      cur->out.quic_abandoned +
    1374           6 :                      cur->out.net_overrun;
    1375           6 :   cur->in.udp      = cur->out.tpu_udp_invalid;
    1376           6 :   cur->in.block_engine = bundle_txns_received;
    1377           6 :   for( ulong i=0UL; i<gui->summary.quic_tile_cnt; i++ ) {
    1378           0 :     fd_topo_tile_t const * quic = &topo->tiles[ fd_topo_find_tile( topo, "quic", i ) ];
    1379           0 :     volatile ulong * quic_metrics = fd_metrics_tile( quic->metrics );
    1380             : 
    1381           0 :     cur->in.quic += quic_metrics[ MIDX( COUNTER, QUIC, TXN_RX_QUIC_FAST ) ];
    1382           0 :     cur->in.quic += quic_metrics[ MIDX( COUNTER, QUIC, TXN_RX_QUIC_FRAG ) ];
    1383           0 :     cur->in.udp  += quic_metrics[ MIDX( COUNTER, QUIC, TXN_RX_UDP       ) ];
    1384           0 :   }
    1385           6 : }
    1386             : 
    1387             : static void
    1388             : fd_gui_tile_stats_snap( fd_gui_t *                     gui,
    1389             :                         fd_gui_txn_waterfall_t const * waterfall,
    1390             :                         fd_gui_tile_stats_t *          stats,
    1391           0 :                         long                           now ) {
    1392           0 :   memset( stats, 0, sizeof(fd_gui_tile_stats_t) );
    1393           0 :   fd_topo_t const * topo = gui->topo;
    1394             : 
    1395           0 :   stats->sample_time_nanos = now;
    1396             : 
    1397           0 :   for( ulong i=0UL; i<gui->summary.net_tile_cnt; i++ ) {
    1398           0 :     fd_topo_tile_t const * net = &topo->tiles[ fd_topo_find_tile( topo, "net", i ) ];
    1399           0 :     volatile ulong * net_metrics = fd_metrics_tile( net->metrics );
    1400             : 
    1401           0 :     stats->net_in_rx_bytes  += net_metrics[ MIDX( COUNTER, NET, PKT_RX_BYTES ) ];
    1402           0 :     stats->net_out_tx_bytes += net_metrics[ MIDX( COUNTER, NET, PKT_TX_SUBMITTED_BYTES ) ];
    1403           0 :   }
    1404             : 
    1405           0 :   for( ulong i=0UL; i<gui->summary.sock_tile_cnt; i++ ) {
    1406           0 :     fd_topo_tile_t const * sock = &topo->tiles[ fd_topo_find_tile( topo, "sock", i ) ];
    1407           0 :     volatile ulong * sock_metrics = fd_metrics_tile( sock->metrics );
    1408             : 
    1409           0 :     stats->net_in_rx_bytes  += sock_metrics[ MIDX( COUNTER, SOCK, PKT_RX_BYTES ) ];
    1410           0 :     stats->net_out_tx_bytes += sock_metrics[ MIDX( COUNTER, SOCK, PKT_TX_BYTES ) ];
    1411           0 :   }
    1412             : 
    1413           0 :   for( ulong i=0UL; i<gui->summary.mlx5_tile_cnt; i++ ) {
    1414           0 :     fd_topo_tile_t const * mlx5 = &topo->tiles[ fd_topo_find_tile( topo, "mlx5", i ) ];
    1415           0 :     volatile ulong * mlx5_metrics = fd_metrics_tile( mlx5->metrics );
    1416             : 
    1417           0 :     stats->net_in_rx_bytes  += mlx5_metrics[ MIDX( COUNTER, MLX5, PKT_RX_BYTES ) ];
    1418           0 :     stats->net_out_tx_bytes += mlx5_metrics[ MIDX( COUNTER, MLX5, PKT_TX_COMPLETED_BYTES ) ];
    1419           0 :   }
    1420             : 
    1421           0 :   for( ulong i=0UL; i<gui->summary.iavf_tile_cnt; i++ ) {
    1422           0 :     fd_topo_tile_t const * iavf = &topo->tiles[ fd_topo_find_tile( topo, "iavf", i ) ];
    1423           0 :     volatile ulong * iavf_metrics = fd_metrics_tile( iavf->metrics );
    1424           0 :     stats->net_in_rx_bytes  += iavf_metrics[ MIDX( COUNTER, IAVF, PKT_RX_BYTES ) ];
    1425           0 :     stats->net_out_tx_bytes += iavf_metrics[ MIDX( COUNTER, IAVF, PKT_TX_COMPLETED_BYTES ) ];
    1426           0 :   }
    1427             : 
    1428           0 :   for( ulong i=0UL; i<gui->summary.quic_tile_cnt; i++ ) {
    1429           0 :     fd_topo_tile_t const * quic = &topo->tiles[ fd_topo_find_tile( topo, "quic", i ) ];
    1430           0 :     volatile ulong * quic_metrics = fd_metrics_tile( quic->metrics );
    1431             : 
    1432           0 :     for( ulong s=0UL; s<FD_METRICS_ENUM_QUIC_CONN_STATE_CNT; s++ ) stats->quic_conn_cnt += quic_metrics[ MIDX( GAUGE, QUIC, CONN_USED )+s ];
    1433           0 :   }
    1434             : 
    1435           0 :   ulong bundle_tile_idx = fd_topo_find_tile( topo, "bundle", 0UL );
    1436           0 :   if( FD_LIKELY( bundle_tile_idx!=ULONG_MAX ) ) {
    1437           0 :     fd_topo_tile_t const * bundle = &topo->tiles[ bundle_tile_idx ];
    1438           0 :     volatile ulong * bundle_metrics = fd_metrics_tile( bundle->metrics );
    1439           0 :     stats->bundle_rtt_smoothed_nanos = bundle_metrics[ MIDX( GAUGE, BUNDLE, RTT_SMOOTHED_NANOS ) ];
    1440             : 
    1441           0 :     fd_histf_new( &stats->bundle_rx_delay_hist, FD_MHIST_MIN( BUNDLE, MESSAGE_RX_DELAY_NANOS ), FD_MHIST_MAX( BUNDLE, MESSAGE_RX_DELAY_NANOS ) );
    1442           0 :     stats->bundle_rx_delay_hist.sum = bundle_metrics[ MIDX( HISTOGRAM, BUNDLE, MESSAGE_RX_DELAY_NANOS ) + FD_HISTF_BUCKET_CNT ];
    1443           0 :     for( ulong b=0; b<FD_HISTF_BUCKET_CNT; b++ ) stats->bundle_rx_delay_hist.counts[ b ] = bundle_metrics[ MIDX( HISTOGRAM, BUNDLE, MESSAGE_RX_DELAY_NANOS ) + b ];
    1444           0 :   }
    1445             : 
    1446           0 :   stats->verify_drop_cnt = waterfall->out.verify_duplicate +
    1447           0 :                            waterfall->out.verify_parse +
    1448           0 :                            waterfall->out.verify_failed;
    1449           0 :   stats->verify_total_cnt = waterfall->in.quic +
    1450           0 :                             waterfall->in.udp -
    1451           0 :                             waterfall->out.net_overrun -
    1452           0 :                             waterfall->out.tpu_quic_invalid -
    1453           0 :                             waterfall->out.tpu_udp_invalid -
    1454           0 :                             waterfall->out.quic_abandoned -
    1455           0 :                             waterfall->out.quic_frag_drop -
    1456           0 :                             waterfall->out.quic_overrun -
    1457           0 :                             waterfall->out.verify_overrun;
    1458           0 :   stats->dedup_drop_cnt = waterfall->out.dedup_duplicate;
    1459           0 :   stats->dedup_total_cnt = stats->verify_total_cnt -
    1460           0 :                            waterfall->out.verify_duplicate -
    1461           0 :                             waterfall->out.verify_parse -
    1462           0 :                             waterfall->out.verify_failed;
    1463             : 
    1464           0 :   ulong pack_tile_idx = fd_topo_find_tile( topo, "pack", 0UL );
    1465           0 :   if( pack_tile_idx!=ULONG_MAX ) {
    1466           0 :     fd_topo_tile_t const * pack  = &topo->tiles[ pack_tile_idx ];
    1467           0 :     volatile ulong const * pack_metrics = fd_metrics_tile( pack->metrics );
    1468           0 :     stats->pack_buffer_cnt      = fd_metrics_enum_group_sum( pack_metrics+MIDX( GAUGE, PACK, TXN_PENDING_USED ), FD_METRICS_ENUM_PENDING_TXN_TYPE_G_ALL_MASK );
    1469           0 :     stats->pack_buffer_capacity = pack->pack.max_pending_transactions;
    1470           0 :   }
    1471             : 
    1472           0 :   stats->bank_txn_exec_cnt = waterfall->out.block_fail + waterfall->out.block_success;
    1473             : 
    1474           0 :   fd_gui_hist_ts_append( gui, FD_GUI_HIST_TILE_STATS, stats );
    1475           0 : }
    1476             : 
    1477             : static void
    1478           0 : fd_gui_run_boot_progress( fd_gui_t * gui, long now ) {
    1479           0 :   fd_topo_tile_t const * snapct = &gui->topo->tiles[ fd_topo_find_tile( gui->topo, "snapct", 0UL ) ];
    1480           0 :   volatile ulong * snapct_metrics = fd_metrics_tile( snapct->metrics );
    1481             : 
    1482           0 :   ulong snapdc_tile_cnt = fd_topo_tile_name_cnt( gui->topo, "snapdc" );
    1483           0 :   ulong snapin_tile_cnt = fd_topo_tile_name_cnt( gui->topo, "snapin" );
    1484             : 
    1485             :   /* Backtest topologies have no gossip tile; treat wait-for-supermajority
    1486             :      as done. */
    1487           0 :   ulong            wfs_state       = FD_GOSSIP_WFS_STATE_DONE;
    1488           0 :   volatile ulong * gossip_metrics  = NULL;
    1489           0 :   ulong            gossip_tile_idx = fd_topo_find_tile( gui->topo, "gossip", 0UL );
    1490           0 :   if( FD_LIKELY( gossip_tile_idx!=ULONG_MAX ) ) {
    1491           0 :     fd_topo_tile_t const * gossip = &gui->topo->tiles[ gossip_tile_idx ];
    1492           0 :     gossip_metrics = fd_metrics_tile( gossip->metrics );
    1493           0 :     wfs_state = gossip_metrics[ MIDX( GAUGE, GOSSIP, WAIT_FOR_SUPERMAJORITY_STATE ) ];
    1494           0 :   }
    1495             : 
    1496           0 :   ulong snapshot_phase = snapct_metrics[ MIDX( GAUGE, SNAPCT, LOAD_STATE ) ];
    1497             : 
    1498             :   /* Backtest topologies have no turbine, so the regular catch-up
    1499             :      detection (turbine slot vs. replayed slot) can never trigger.
    1500             :      Consider replay caught up at the first reset slot after the
    1501             :      snapshot finishes loading. */
    1502           0 :   if( FD_UNLIKELY( gui->summary.slot_caught_up==ULONG_MAX &&
    1503           0 :                    snapshot_phase==FD_SNAPCT_STATE_SHUTDOWN &&
    1504           0 :                    gui->summary.slot_tower!=ULONG_MAX &&
    1505           0 :                    fd_topo_find_tile( gui->topo, "backt", 0UL )!=ULONG_MAX ) ) {
    1506           0 :     gui->summary.slot_caught_up = gui->summary.slot_tower;
    1507           0 :     gui->summary.boot_progress.catching_up_time_nanos = now;
    1508             : 
    1509           0 :     fd_gui_printf_slot_caught_up( gui );
    1510           0 :     fd_http_server_ws_broadcast( gui->http );
    1511           0 :   }
    1512             : 
    1513             :   /* state transitions */
    1514           0 :   if( FD_UNLIKELY( gui->summary.slot_caught_up!=ULONG_MAX ) ) {
    1515           0 :     gui->summary.boot_progress.phase = FD_GUI_BOOT_PROGRESS_TYPE_RUNNING;
    1516           0 :     for( ulong k=0UL; k<FD_ACCDB_COMPACTION_LAYER_CNT; k++ ) {
    1517           0 :       fd_gui_ema_init( &gui->summary.accdb->tier_fill_bps_ema[ k ], now, FD_GUI_ACCDB_EMA_HALF_LIFE_NS );
    1518           0 :       fd_gui_ema_init( &gui->summary.accdb->tier_free_bps_ema[ k ], now, FD_GUI_ACCDB_EMA_HALF_LIFE_NS );
    1519           0 :     }
    1520           0 :   } else if( FD_LIKELY( snapshot_phase == FD_SNAPCT_STATE_SHUTDOWN && wfs_state==FD_GOSSIP_WFS_STATE_DONE && ( gui->summary.slots_max_turbine[ 0 ].slot!=ULONG_MAX || gui->summary.slot_turbine!=ULONG_MAX ) && gui->summary.slot_tower!=ULONG_MAX ) ) {
    1521           0 :     if( FD_UNLIKELY( fd_gui_wfs_mode( gui )==FD_WFS_MODE_MATCH ) ) {
    1522           0 :       if( FD_UNLIKELY( gui->summary.slot_caught_up==ULONG_MAX ) ) {
    1523           0 :         gui->summary.slot_caught_up = fd_gui_boot_snapshot_slot( gui );
    1524           0 :         gui->summary.boot_progress.catching_up_time_nanos = now;
    1525             : 
    1526           0 :         fd_gui_printf_slot_caught_up( gui );
    1527           0 :         fd_http_server_ws_broadcast( gui->http );
    1528           0 :       }
    1529           0 :       gui->summary.boot_progress.phase = FD_GUI_BOOT_PROGRESS_TYPE_RUNNING;
    1530           0 :       for( ulong k=0UL; k<FD_ACCDB_COMPACTION_LAYER_CNT; k++ ) {
    1531           0 :         fd_gui_ema_init( &gui->summary.accdb->tier_fill_bps_ema[ k ], now, FD_GUI_ACCDB_EMA_HALF_LIFE_NS );
    1532           0 :         fd_gui_ema_init( &gui->summary.accdb->tier_free_bps_ema[ k ], now, FD_GUI_ACCDB_EMA_HALF_LIFE_NS );
    1533           0 :       }
    1534           0 :     } else {
    1535           0 :       gui->summary.boot_progress.phase = FD_GUI_BOOT_PROGRESS_TYPE_CATCHING_UP;
    1536           0 :     }
    1537           0 :   } else if( FD_UNLIKELY( snapshot_phase == FD_SNAPCT_STATE_SHUTDOWN && wfs_state==FD_GOSSIP_WFS_STATE_WAIT ) ) {
    1538           0 :     gui->summary.boot_progress.phase = FD_GUI_BOOT_PROGRESS_TYPE_WAITING_FOR_SUPERMAJORITY;
    1539           0 :   } else if( FD_LIKELY( snapshot_phase==FD_SNAPCT_STATE_READING_FULL_FILE
    1540           0 :                      || snapshot_phase==FD_SNAPCT_STATE_FLUSHING_FULL_FILE_FINI
    1541           0 :                      || snapshot_phase==FD_SNAPCT_STATE_FLUSHING_FULL_FILE_DONE
    1542           0 :                      || snapshot_phase==FD_SNAPCT_STATE_READING_FULL_HTTP
    1543           0 :                      || snapshot_phase==FD_SNAPCT_STATE_FLUSHING_FULL_HTTP_FINI
    1544           0 :                      || snapshot_phase==FD_SNAPCT_STATE_FLUSHING_FULL_HTTP_DONE ) ) {
    1545           0 :     gui->summary.boot_progress.phase = FD_GUI_BOOT_PROGRESS_TYPE_LOADING_FULL_SNAPSHOT;
    1546           0 :   } else if( FD_LIKELY( snapshot_phase==FD_SNAPCT_STATE_READING_INCREMENTAL_FILE
    1547           0 :                      || snapshot_phase==FD_SNAPCT_STATE_FLUSHING_INCREMENTAL_FILE_FINI
    1548           0 :                      || snapshot_phase==FD_SNAPCT_STATE_FLUSHING_INCREMENTAL_FILE_DONE
    1549           0 :                      || snapshot_phase==FD_SNAPCT_STATE_READING_INCREMENTAL_HTTP
    1550           0 :                      || snapshot_phase==FD_SNAPCT_STATE_FLUSHING_INCREMENTAL_HTTP_FINI
    1551           0 :                      || snapshot_phase==FD_SNAPCT_STATE_FLUSHING_INCREMENTAL_HTTP_DONE ) ) {
    1552           0 :     gui->summary.boot_progress.phase = FD_GUI_BOOT_PROGRESS_TYPE_LOADING_INCREMENTAL_SNAPSHOT;
    1553           0 :   }
    1554             : 
    1555             :   /* It's possible for the incremental snapshot phase to be skipped, or
    1556             :      complete before we can sample it.  This ensures we always get at
    1557             :      least one pass of the metrics. */
    1558           0 :   if( FD_UNLIKELY( gui->summary.boot_progress.phase==FD_GUI_BOOT_PROGRESS_TYPE_CATCHING_UP
    1559           0 :                 && gui->summary.boot_progress.loading_snapshot[ FD_GUI_BOOT_PROGRESS_INCREMENTAL_SNAPSHOT_IDX ].reset_cnt==ULONG_MAX ) ) {
    1560           0 :     gui->summary.boot_progress.phase = FD_GUI_BOOT_PROGRESS_TYPE_LOADING_INCREMENTAL_SNAPSHOT;
    1561           0 :   }
    1562             : 
    1563           0 :   switch ( gui->summary.boot_progress.phase ) {
    1564           0 :     case FD_GUI_BOOT_PROGRESS_TYPE_JOINING_GOSSIP: {
    1565           0 :       gui->summary.boot_progress.joining_gossip_time_nanos = now;
    1566           0 :       break;
    1567           0 :     }
    1568           0 :     case FD_GUI_BOOT_PROGRESS_TYPE_LOADING_FULL_SNAPSHOT:
    1569           0 :     case FD_GUI_BOOT_PROGRESS_TYPE_LOADING_INCREMENTAL_SNAPSHOT: {
    1570           0 :       ulong snapshot_idx = fd_ulong_if( gui->summary.boot_progress.phase==FD_GUI_BOOT_PROGRESS_TYPE_LOADING_FULL_SNAPSHOT, FD_GUI_BOOT_PROGRESS_FULL_SNAPSHOT_IDX, FD_GUI_BOOT_PROGRESS_INCREMENTAL_SNAPSHOT_IDX );
    1571           0 :       ulong _retry_cnt = fd_ulong_if( snapshot_idx==FD_GUI_BOOT_PROGRESS_FULL_SNAPSHOT_IDX, snapct_metrics[ MIDX( COUNTER, SNAPCT, LOAD_RETRIED_FULL ) ], snapct_metrics[ MIDX( COUNTER, SNAPCT, LOAD_RETRIED_INCREMENTAL ) ]);
    1572             : 
    1573             :       /* reset boot state if necessary */
    1574           0 :       if( FD_UNLIKELY( gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].reset_cnt!=_retry_cnt ) ) {
    1575           0 :         gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].reset_time_nanos = now;
    1576           0 :         gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].reset_cnt = _retry_cnt;
    1577           0 :       }
    1578             : 
    1579           0 :       ulong _total_bytes                   = fd_ulong_if( snapshot_idx==FD_GUI_BOOT_PROGRESS_FULL_SNAPSHOT_IDX, snapct_metrics[ MIDX( GAUGE, SNAPCT, READ_EXPECTED_BYTES_FULL ) ],        snapct_metrics[ MIDX( GAUGE, SNAPCT, READ_EXPECTED_BYTES_INCREMENTAL ) ]                );
    1580           0 :       ulong _read_bytes                    = fd_ulong_if( snapshot_idx==FD_GUI_BOOT_PROGRESS_FULL_SNAPSHOT_IDX, snapct_metrics[ MIDX( GAUGE, SNAPCT, READ_PROGRESS_BYTES_FULL ) ],        snapct_metrics[ MIDX( GAUGE, SNAPCT, READ_PROGRESS_BYTES_INCREMENTAL ) ]                 );
    1581           0 :       ulong _decompress_decompressed_bytes = fd_gui_metrics_sum_tiles_counter( gui->topo, "snapdc", snapdc_tile_cnt, fd_ulong_if( snapshot_idx==FD_GUI_BOOT_PROGRESS_FULL_SNAPSHOT_IDX, MIDX( GAUGE, SNAPDC, DECOMPRESSED_PROGRESS_BYTES_FULL ), MIDX( GAUGE, SNAPDC, DECOMPRESSED_PROGRESS_BYTES_INCREMENTAL ) ) );
    1582           0 :       ulong _decompress_compressed_bytes   = fd_gui_metrics_sum_tiles_counter( gui->topo, "snapdc", snapdc_tile_cnt, fd_ulong_if( snapshot_idx==FD_GUI_BOOT_PROGRESS_FULL_SNAPSHOT_IDX, MIDX( GAUGE, SNAPDC, COMPRESSED_PROGRESS_BYTES_FULL ),   MIDX( GAUGE, SNAPDC, COMPRESSED_PROGRESS_BYTES_INCREMENTAL )   ) );
    1583           0 :       ulong _insert_metric                 = fd_ulong_if( snapshot_idx==FD_GUI_BOOT_PROGRESS_FULL_SNAPSHOT_IDX, MIDX( GAUGE, SNAPIN, PARSE_PROGRESS_BYTES_FULL ), MIDX( GAUGE, SNAPIN, PARSE_PROGRESS_BYTES_INCREMENTAL ) );
    1584           0 :       ulong _insert_bytes                  = ULONG_MAX;
    1585           0 :       for( ulong i=0UL; i<snapin_tile_cnt; i++ ) {
    1586           0 :         fd_topo_tile_t const * snapin = &gui->topo->tiles[ fd_topo_find_tile( gui->topo, "snapin", i ) ];
    1587           0 :         volatile ulong const * snapin_metrics = fd_metrics_tile( snapin->metrics );
    1588           0 :         _insert_bytes = fd_ulong_min( _insert_bytes, snapin_metrics[ _insert_metric ] );
    1589           0 :       }
    1590             : 
    1591           0 :       ulong _insert_accounts_total         = fd_gui_metrics_sum_tiles_counter( gui->topo, "snapin", snapin_tile_cnt, MIDX( GAUGE, SNAPIN, ACCOUNT_PROGRESS_NEW ) );
    1592           0 :       ulong _insert_accounts_baseline      = fd_ulong_if( snapshot_idx==FD_GUI_BOOT_PROGRESS_FULL_SNAPSHOT_IDX, 0UL, gui->summary.boot_progress.loading_snapshot[ FD_GUI_BOOT_PROGRESS_FULL_SNAPSHOT_IDX ].insert_accounts_current );
    1593           0 :       ulong _insert_accounts               = fd_ulong_sat_sub( _insert_accounts_total, _insert_accounts_baseline );
    1594             : 
    1595             :       /* metadata */
    1596           0 :       gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].total_bytes_compressed = _total_bytes;
    1597           0 :       gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].sample_time_nanos = now;
    1598             : 
    1599             :       /* read stage */
    1600           0 :       gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].read_bytes_compressed = _read_bytes;
    1601             : 
    1602             :       /* decompress stage */
    1603           0 :       gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].decompress_bytes_compressed   = _decompress_compressed_bytes;
    1604           0 :       gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].decompress_bytes_decompressed = _decompress_decompressed_bytes;
    1605             : 
    1606             :       /* insert stage */
    1607           0 :       gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].insert_bytes_decompressed = _insert_bytes;
    1608           0 :       gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].insert_accounts_current   = _insert_accounts;
    1609             : 
    1610           0 :       break;
    1611           0 :     }
    1612           0 :     case FD_GUI_BOOT_PROGRESS_TYPE_WAITING_FOR_SUPERMAJORITY: {
    1613             :       /* Only reachable when the topology has a gossip tile. */
    1614           0 :       gui->summary.boot_progress.wfs_total_stake     = gossip_metrics[ MIDX( GAUGE, GOSSIP, WAIT_FOR_SUPERMAJORITY_STAKE_TRACKED_LAMPORTS ) ];
    1615           0 :       gui->summary.boot_progress.wfs_connected_stake = gossip_metrics[ MIDX( GAUGE, GOSSIP, WAIT_FOR_SUPERMAJORITY_STAKE_ONLINE_LAMPORTS ) ];
    1616           0 :       gui->summary.boot_progress.wfs_total_peers     = gossip_metrics[ MIDX( GAUGE, GOSSIP, WAIT_FOR_SUPERMAJORITY_STAKED_PEER_COUNT ) ];
    1617           0 :       gui->summary.boot_progress.wfs_connected_peers = gossip_metrics[ MIDX( GAUGE, GOSSIP, WAIT_FOR_SUPERMAJORITY_STAKED_PEER_ONLINE ) ];
    1618           0 :       break;
    1619           0 :     }
    1620           0 :     case FD_GUI_BOOT_PROGRESS_TYPE_CATCHING_UP: {
    1621           0 :       gui->summary.boot_progress.catching_up_time_nanos = now;
    1622           0 :       break;
    1623           0 :     }
    1624           0 :     case FD_GUI_BOOT_PROGRESS_TYPE_RUNNING: break;
    1625           0 :     default: FD_LOG_ERR(( "unknown boot progress phase: %d", gui->summary.boot_progress.phase ));
    1626           0 :   }
    1627           0 : }
    1628             : 
    1629             : static inline int
    1630          27 : fd_gui_ephemeral_slots_contains( fd_gui_ephemeral_slot_t * slots, ulong slots_sz, ulong slot ) {
    1631         120 :   for( ulong i=0UL; i<slots_sz; i++ ) {
    1632         114 :     if( FD_UNLIKELY( slots[ i ].slot==ULONG_MAX ) ) break;
    1633         102 :     if( FD_UNLIKELY( slots[ i ].slot==slot ) ) return 1;
    1634         102 :   }
    1635          18 :   return 0;
    1636          27 : }
    1637             : 
    1638             : #define SORT_NAME fd_gui_ephemeral_slot_sort
    1639         525 : #define SORT_KEY_T fd_gui_ephemeral_slot_t
    1640         345 : #define SORT_BEFORE(a,b) fd_int_if( (a).slot==ULONG_MAX, 0, fd_int_if( (b).slot==ULONG_MAX, 1, fd_int_if( (a).slot==(b).slot, (a).timestamp_arrival_nanos>(b).timestamp_arrival_nanos, (a).slot>(b).slot ) ) )
    1641             : #include "../../util/tmpl/fd_sort.c"
    1642             : 
    1643             : static inline void
    1644          21 : fd_gui_try_insert_ephemeral_slot( fd_gui_ephemeral_slot_t * slots, ulong slots_sz, ulong slot, long now ) {
    1645          21 :   int already_present = 0;
    1646         273 :   for( ulong i=0UL; i<slots_sz; i++ ) {
    1647             :     /* evict any slots older than 4.8 seconds */
    1648         252 :     if( FD_UNLIKELY( slots[ i ].slot!=ULONG_MAX && now-slots[ i ].timestamp_arrival_nanos>4800000000L ) ) {
    1649          72 :       slots[ i ].slot = ULONG_MAX;
    1650          72 :       continue;
    1651          72 :     }
    1652             : 
    1653             :     /* if we've already seen this slot, just update the timestamp */
    1654         180 :     if( FD_UNLIKELY( slots[ i ].slot==slot ) ) {
    1655           6 :       slots[ i ].timestamp_arrival_nanos = now;
    1656           6 :       already_present = 1;
    1657           6 :     }
    1658         180 :   }
    1659          21 :   if( FD_LIKELY( already_present ) ) return;
    1660             : 
    1661             :   /* Insert the new slot number, evicting a smaller slot if necessary */
    1662          15 :   slots[ slots_sz ].timestamp_arrival_nanos = now;
    1663          15 :   slots[ slots_sz ].slot = slot;
    1664          15 :   fd_gui_ephemeral_slot_sort_insert( slots, slots_sz+1UL );
    1665          15 : }
    1666             : 
    1667             : static inline void
    1668           0 : fd_gui_try_insert_run_length_slot( ulong * slots, ulong capacity, ulong * slots_sz, ulong slot ) {
    1669             :   /* catch up history is run-length encoded */
    1670           0 :   ulong range_idx = fd_sort_up_ulong_split( slots, *slots_sz, slot );
    1671           0 :   if( FD_UNLIKELY( range_idx<(*slots_sz)-1UL              && range_idx%2UL==0UL && slots[ range_idx ]<=slot && slots[ range_idx+1UL ]>=slot ) ) return;
    1672           0 :   if( FD_UNLIKELY( range_idx<(*slots_sz) && range_idx>0UL && range_idx%2UL==1UL && slots[ range_idx-1UL ]<=slot && slots[ range_idx ]>=slot ) ) return;
    1673             : 
    1674           0 :   slots[ (*slots_sz)++ ] = slot;
    1675           0 :   slots[ (*slots_sz)++ ] = slot;
    1676             : 
    1677           0 :   fd_sort_up_ulong_insert( slots, (*slots_sz) );
    1678             : 
    1679             :   /* colesce ranges */
    1680           0 :   ulong removed = 0UL;
    1681           0 :   for( ulong i=1UL; i<(*slots_sz)-1UL; i+=2 ) {
    1682           0 :     if( FD_UNLIKELY( slots[ i ]+1UL==slots[ i+1UL ] ) ) {
    1683           0 :       slots[ i ]     = ULONG_MAX;
    1684           0 :       slots[ i+1UL ] = ULONG_MAX;
    1685           0 :       removed += 2;
    1686           0 :     }
    1687           0 :   }
    1688             : 
    1689           0 :   if( FD_UNLIKELY( (*slots_sz)>=removed+capacity-2UL && (*slots_sz)>=4UL ) ) {
    1690             :     /* We are at capacity, start coalescing earlier intervals. */
    1691           0 :     slots[ 1 ] = ULONG_MAX;
    1692           0 :     slots[ 2 ] = ULONG_MAX;
    1693           0 :     removed += 2;
    1694           0 :   }
    1695             : 
    1696           0 :   fd_sort_up_ulong_insert( slots, (*slots_sz) );
    1697           0 :   (*slots_sz) -= removed;
    1698           0 : }
    1699             : 
    1700             : void
    1701           0 : fd_gui_handle_repair_slot( fd_gui_t * gui, ulong slot, long now ) {
    1702           0 :   int was_sent = fd_gui_ephemeral_slots_contains( gui->summary.slots_max_repair, FD_GUI_REPAIR_SLOT_HISTORY_SZ, slot );
    1703           0 :   fd_gui_try_insert_ephemeral_slot( gui->summary.slots_max_repair, FD_GUI_REPAIR_SLOT_HISTORY_SZ, slot, now );
    1704             : 
    1705           0 :   if( FD_UNLIKELY( !was_sent && slot!=gui->summary.slot_repair ) ) {
    1706           0 :     gui->summary.slot_repair = slot;
    1707             : 
    1708           0 :     fd_gui_printf_repair_slot( gui );
    1709           0 :     fd_http_server_ws_broadcast( gui->http );
    1710             : 
    1711           0 :     if( FD_UNLIKELY( gui->summary.slot_caught_up==ULONG_MAX ) ) fd_gui_try_insert_run_length_slot( gui->summary.catch_up_repair, FD_GUI_REPAIR_CATCH_UP_HISTORY_SZ, &gui->summary.catch_up_repair_sz, slot );
    1712           0 :   }
    1713           0 : }
    1714             : 
    1715             : static void
    1716           0 : fd_gui_sample_repair_slot( fd_gui_t * gui, long now ) {
    1717           0 :   ulong slot;
    1718             : 
    1719           0 :     ulong repair_tile_idx = fd_topo_find_tile( gui->topo, "repair", 0UL );
    1720           0 :     if( FD_UNLIKELY( repair_tile_idx==ULONG_MAX ) ) return;
    1721           0 :     fd_topo_tile_t const * repair = &gui->topo->tiles[ repair_tile_idx ];
    1722           0 :     volatile ulong const * repair_metrics = fd_metrics_tile( repair->metrics );
    1723           0 :     slot = repair_metrics[ MIDX( GAUGE, REPAIR, HIGHEST_DELIVERED_SLOT ) ];
    1724             : 
    1725           0 :   fd_gui_handle_repair_slot( gui, slot, now );
    1726           0 : }
    1727             : 
    1728             : static void
    1729           0 : fd_gui_sample_catchup_slot( fd_gui_t * gui ) {
    1730           0 :   if( FD_LIKELY( gui->summary.slot_caught_up!=ULONG_MAX ) ) return;
    1731           0 :   ulong repair_tile_idx = fd_topo_find_tile( gui->topo, "repair", 0UL );
    1732           0 :   if( FD_UNLIKELY( repair_tile_idx==ULONG_MAX ) ) return;
    1733           0 :   fd_topo_tile_t const * repair        = &gui->topo->tiles[ repair_tile_idx ];
    1734           0 :   volatile ulong const * repair_metrics = fd_metrics_tile( repair->metrics );
    1735           0 :   ulong                  slot          = repair_metrics[ MIDX( GAUGE, REPAIR, CATCHUP_SLOT ) ];
    1736           0 :   if( FD_LIKELY( !slot || ( gui->summary.slot_turbine!=ULONG_MAX && slot<=gui->summary.slot_turbine ) ) ) return;
    1737             : 
    1738           0 :   gui->summary.slot_turbine = slot;
    1739           0 :   fd_gui_printf_turbine_slot( gui );
    1740           0 :   fd_http_server_ws_broadcast( gui->http );
    1741           0 :   fd_gui_try_insert_run_length_slot( gui->summary.catch_up_turbine, FD_GUI_TURBINE_CATCH_UP_HISTORY_SZ, &gui->summary.catch_up_turbine_sz, slot );
    1742           0 : }
    1743             : 
    1744             : void
    1745           6 : fd_gui_handle_repair_request( fd_gui_t * gui, ulong slot, ulong shred_idx, long tsorig, long now ) {
    1746           6 :   fd_gui_shred_event_append( gui, slot, shred_idx, FD_GUI_SLOT_SHRED_REPAIR_REQUEST, tsorig, now );
    1747           6 :   fd_gui_fec_event_append( gui, slot, shred_idx/FD_FEC_SHRED_CNT, FD_GUI_SLOT_SHRED_REPAIR_REQUEST, tsorig, now );
    1748           6 : }
    1749             : 
    1750             : static void
    1751           0 : fd_gui_progcache_sample( fd_gui_t * gui ) {
    1752           0 :   fd_topo_t const * topo = gui->topo;
    1753             : 
    1754           0 :   ulong hits    = 0UL;
    1755           0 :   ulong lookups = 0UL;
    1756             : 
    1757           0 :   for( ulong i=0UL; i<gui->summary.execrp_tile_cnt; i++ ) {
    1758           0 :     fd_topo_tile_t const * execrp = &topo->tiles[ fd_topo_find_tile( topo, "execrp", i ) ];
    1759           0 :     volatile ulong const * metrics = fd_metrics_tile( execrp->metrics );
    1760             : 
    1761           0 :     lookups += metrics[ MIDX( COUNTER, EXECRP, PROGCACHE_LOOKED_UP ) ];
    1762           0 :     hits    += fd_metrics_enum_group_sum( metrics+MIDX( COUNTER, EXECRP, PROGCACHE_HIT ), FD_METRICS_ENUM_PROGCACHE_CLASS_G_ALL_MASK );
    1763           0 :   }
    1764             : 
    1765             :   /* The execrp tile writes lookups before hits in metrics_write, so
    1766             :      reading lookups first then hits here means we may observe the
    1767             :      new hits before the new lookups, giving hits > lookups
    1768             :      momentarily.  Clamp to maintain the invariant hits <= lookups. */
    1769             : 
    1770           0 :   hits = fd_ulong_min( hits, lookups );
    1771             : 
    1772           0 :   ulong ring_idx       = gui->summary.progcache_history_idx % FD_GUI_PROGCACHE_HISTORY_CNT;
    1773           0 :   ulong oldest_hits    = gui->summary.progcache_hits_history   [ ring_idx ];
    1774           0 :   ulong oldest_lookups = gui->summary.progcache_lookups_history[ ring_idx ];
    1775             : 
    1776           0 :   gui->summary.progcache_hits_history   [ ring_idx ] = hits;
    1777           0 :   gui->summary.progcache_lookups_history[ ring_idx ] = lookups;
    1778           0 :   gui->summary.progcache_history_idx = gui->summary.progcache_history_idx + 1UL;
    1779             : 
    1780           0 :   ulong hits_1min    = hits    - oldest_hits;
    1781           0 :   ulong lookups_1min = lookups - oldest_lookups;
    1782           0 :   hits_1min = fd_ulong_min( hits_1min, lookups_1min );
    1783             : 
    1784           0 :   gui->summary.progcache_hits_1min    = hits_1min;
    1785           0 :   gui->summary.progcache_lookups_1min = lookups_1min;
    1786           0 : }
    1787             : 
    1788             : long
    1789           0 : fd_gui_next_deadline( fd_gui_t const * gui ) {
    1790           0 :   long due = gui->next_sample_1sec;
    1791           0 :   due = fd_long_min( due, gui->next_sample_200millis );
    1792           0 :   due = fd_long_min( due, gui->next_sample_100millis );
    1793           0 :   due = fd_long_min( due, gui->next_sample_50millis  );
    1794           0 :   due = fd_long_min( due, gui->next_sample_40millis  );
    1795           0 :   due = fd_long_min( due, gui->next_sample_25millis  );
    1796           0 :   due = fd_long_min( due, gui->next_sample_10millis  );
    1797           0 :   return due+1L; /* the samplers fire on now>next */
    1798           0 : }
    1799             : 
    1800             : int
    1801           0 : fd_gui_poll( fd_gui_t * gui, long now ) {
    1802           0 :   if( FD_LIKELY( now>gui->next_sample_1sec ) ) {
    1803           0 :     for( ulong i=0UL; i<gui->tile_cnt; i++ ) {
    1804           0 :       fd_gui_hist_ts_append( gui, FD_GUI_HIST_TILE_TIMERS, &gui->summary.tile_timers_packed[ i ] );
    1805           0 :     }
    1806             : 
    1807           0 :     gui->next_sample_1sec += 1000L*1000L*1000L;
    1808           0 :     return 1;
    1809           0 :   }
    1810             : 
    1811           0 :   if( FD_LIKELY( now>gui->next_sample_200millis ) ) {
    1812           0 :     fd_gui_estimated_tps_snap( gui );
    1813           0 :     fd_gui_printf_estimated_tps( gui );
    1814           0 :     fd_http_server_ws_broadcast( gui->http );
    1815             : 
    1816           0 :     if( FD_LIKELY( gui->leader_begin_slot<=gui->leader_end_slot ) ) {
    1817           0 :       for( ulong i=0UL; i<gui->tile_cnt; i++ ) {
    1818           0 :         fd_gui_hist_ts_append( gui, FD_GUI_HIST_TILE_TIMERS, &gui->summary.tile_timers_packed[ i ] );
    1819           0 :       }
    1820           0 :     }
    1821             : 
    1822           0 :     gui->next_sample_200millis += 200L*1000L*1000L;
    1823           0 :     return 1;
    1824           0 :   }
    1825             : 
    1826           0 :   if( FD_LIKELY( now>gui->next_sample_100millis ) ) {
    1827           0 :     fd_gui_txn_waterfall_snap( gui, gui->summary.txn_waterfall_current );
    1828           0 :     fd_gui_printf_live_txn_waterfall( gui, gui->summary.txn_waterfall_reference, gui->summary.txn_waterfall_current, 0UL /* TODO: REAL NEXT LEADER SLOT */ );
    1829           0 :     fd_http_server_ws_broadcast( gui->http );
    1830             : 
    1831           0 :     if( FD_LIKELY( gui->leader_begin_slot>gui->leader_end_slot ) ) {
    1832           0 :       gui->summary.txn_waterfall_current->sample_time_nanos = now;
    1833           0 :       fd_gui_hist_ts_append( gui, FD_GUI_HIST_TXN_WATERFALL, gui->summary.txn_waterfall_current );
    1834           0 :     }
    1835             : 
    1836           0 :     fd_gui_network_stats_snap( gui, gui->summary.network_stats_current );
    1837           0 :     fd_gui_network_rate_max_update( gui, now );
    1838           0 :     fd_gui_printf_live_network_metrics( gui, gui->summary.network_stats_current );
    1839           0 :     fd_http_server_ws_broadcast( gui->http );
    1840             : 
    1841           0 :     *gui->summary.tile_stats_reference = *gui->summary.tile_stats_current;
    1842           0 :     fd_gui_tile_stats_snap( gui, gui->summary.txn_waterfall_current, gui->summary.tile_stats_current, now );
    1843           0 :     fd_gui_printf_live_tile_stats( gui, gui->summary.tile_stats_reference, gui->summary.tile_stats_current );
    1844           0 :     fd_http_server_ws_broadcast( gui->http );
    1845             : 
    1846           0 :     {
    1847           0 :       fd_gui_progcache_sample( gui );
    1848           0 :       fd_gui_printf_live_program_cache( gui );
    1849           0 :       fd_http_server_ws_broadcast( gui->http );
    1850             : 
    1851           0 :       *gui->summary.accounts_stats_reference = *gui->summary.accounts_stats_current;
    1852           0 :       fd_gui_accounts_stats_snap( gui, gui->summary.accounts_stats_current );
    1853           0 :       fd_gui_accounts_stats_window_push( gui );
    1854           0 :       fd_gui_printf_accounts_stats( gui );
    1855           0 :       fd_http_server_ws_broadcast( gui->http );
    1856           0 :       gui->summary.accounts_stats_have_reference = 1;
    1857           0 :     }
    1858             : 
    1859           0 :     if( FD_UNLIKELY( gui->summary.boot_progress.phase!=FD_GUI_BOOT_PROGRESS_TYPE_RUNNING ) ) {
    1860           0 :       fd_gui_sample_catchup_slot( gui );
    1861           0 :       fd_gui_run_boot_progress( gui, now );
    1862           0 :       if( FD_UNLIKELY( memcmp( &gui->summary.boot_progress, &gui->summary.prev_boot_progress, sizeof(fd_gui_boot_progress_t) ) ) ) {
    1863           0 :         gui->summary.prev_boot_progress = gui->summary.boot_progress;
    1864           0 :         fd_gui_printf_boot_progress( gui );
    1865           0 :         fd_http_server_ws_broadcast( gui->http );
    1866           0 :       }
    1867           0 :     }
    1868             : 
    1869           0 :     ulong bundle_tile_idx = fd_topo_find_tile( gui->topo, "bundle", 0UL );
    1870           0 :     if( FD_LIKELY( bundle_tile_idx!=ULONG_MAX ) ) {
    1871           0 :       volatile ulong const * bundle_metrics = fd_metrics_tile( gui->topo->tiles[ bundle_tile_idx ].metrics );
    1872           0 :       int cur_state = (int)bundle_metrics[ MIDX( GAUGE, BUNDLE, CONN_STATE ) ];
    1873           0 :       if( FD_UNLIKELY( cur_state != gui->block_engine.status ) ) {
    1874           0 :         gui->block_engine.status = cur_state;
    1875           0 :         fd_gui_printf_block_engine( gui );
    1876           0 :         fd_http_server_ws_broadcast( gui->http );
    1877           0 :       }
    1878           0 :     }
    1879             : 
    1880           0 :     fd_gui_printf_health( gui );
    1881           0 :     fd_http_server_ws_broadcast( gui->http );
    1882             : 
    1883           0 :     if( FD_UNLIKELY( gui->epoch.missed_vote_history_dirty!=ULONG_MAX ) ) {
    1884           0 :       fd_gui_printf_missed_vote_history( gui, gui->epoch.missed_vote_history_dirty );
    1885           0 :       fd_http_server_ws_broadcast( gui->http );
    1886           0 :       gui->epoch.missed_vote_history_dirty = ULONG_MAX;
    1887           0 :     }
    1888             : 
    1889           0 :     gui->next_sample_100millis += 100L*1000L*1000L;
    1890           0 :     return 1;
    1891           0 :   }
    1892             : 
    1893           0 :   if( FD_LIKELY( now>gui->next_sample_50millis ) ) {
    1894           0 :     fd_gui_shred_flush( gui, now );
    1895           0 :     if( FD_LIKELY( !fd_gui_shred_window_is_empty( gui, gui->shreds.broadcast_watermark_ns, now-1L ) ) ) {
    1896           0 :       fd_gui_printf_shred_updates( gui, gui->shreds.broadcast_watermark_ns, now-1L );
    1897           0 :       fd_http_server_ws_broadcast( gui->http );
    1898           0 :     }
    1899           0 :     gui->shreds.broadcast_watermark_ns = now;
    1900             : 
    1901             :     /* We get the repair slot from the sampled metric after catching up
    1902             :        and from incoming shred data before catchup. This makes the
    1903             :        catchup progress bar look complete while also keeping the
    1904             :        overview slots vis correct.  TODO: do this properly using frags
    1905             :        sent over a link */
    1906           0 :     if( FD_LIKELY( gui->summary.slot_caught_up!=ULONG_MAX ) ) fd_gui_sample_repair_slot( gui, now );
    1907             : 
    1908           0 :     if( FD_UNLIKELY( gui->snapsv.pending_cnt ) ) {
    1909           0 :       fd_gui_printf_snapshot_transfers( gui );
    1910           0 :       fd_http_server_ws_broadcast( gui->http );
    1911           0 :       gui->snapsv.pending_cnt = 0UL;
    1912           0 :     }
    1913             : 
    1914           0 :     gui->next_sample_50millis += 50L*1000L*1000L;
    1915           0 :     return 1;
    1916           0 :   }
    1917             : 
    1918           0 :   if( FD_LIKELY( now>gui->next_sample_40millis ) ) {
    1919           0 :     fd_gui_tile_timers_snap( gui, now );
    1920             : 
    1921           0 :     fd_gui_printf_live_tile_timers( gui );
    1922           0 :     fd_http_server_ws_broadcast( gui->http );
    1923             : 
    1924           0 :     fd_gui_printf_live_tile_metrics( gui );
    1925           0 :     fd_http_server_ws_broadcast( gui->http );
    1926             : 
    1927           0 :     if( FD_LIKELY( gui->leader_begin_slot>gui->leader_end_slot ) ) {
    1928           0 :       for( ulong i=0UL; i<gui->tile_cnt; i++ ) {
    1929           0 :         fd_gui_hist_ts_append( gui, FD_GUI_HIST_TILE_TIMERS, &gui->summary.tile_timers_packed[ i ] );
    1930           0 :       }
    1931           0 :     }
    1932             : 
    1933           0 :     gui->next_sample_40millis += 40L*1000L*1000L;
    1934           0 :     return 1;
    1935           0 :   }
    1936             : 
    1937           0 :   if( FD_LIKELY( now>gui->next_sample_25millis ) ) {
    1938           0 :     fd_gui_cpu_util_snap( gui, now );
    1939           0 :     gui->next_sample_25millis += 25L*1000L*1000L;
    1940           0 :     return 1;
    1941           0 :   }
    1942             : 
    1943           0 :   if( FD_LIKELY( now>gui->next_sample_10millis ) ) {
    1944           0 :     if( FD_UNLIKELY( gui->leader_begin_slot>gui->leader_end_slot ) ) fd_gui_scheduler_counts_snap( gui, now );
    1945             : 
    1946           0 :     fd_gui_printf_server_time_nanos( gui, now );
    1947           0 :     fd_http_server_ws_broadcast( gui->http );
    1948             : 
    1949             :     /* Lazy eviction must outpace ingest: ~1 ms of batches per tick */
    1950           0 :     long evict_end = fd_tickcount() + (long)( 1e6*gui->tick_per_ns );
    1951           0 :     for(;;) {
    1952           0 :       ulong archived = fd_gui_fec_archive( gui, 512UL );
    1953           0 :       int   evicted  = fd_gui_hist_evict_step( gui );
    1954           0 :       if( (!archived && !evicted) || fd_tickcount()>=evict_end ) break;
    1955           0 :     }
    1956             : 
    1957           0 :     gui->next_sample_10millis += 10L*1000L*1000L;
    1958           0 :     return 1;
    1959           0 :   }
    1960             : 
    1961           0 :   return 0;
    1962           0 : }
    1963             : 
    1964             : int
    1965             : fd_gui_request_slot( fd_gui_t *    gui,
    1966             :                      ulong         ws_conn_id,
    1967             :                      ulong         request_id,
    1968             :                      char const *  params,
    1969           0 :                      ulong         params_sz ) {
    1970           0 :   ulong _slot = 0UL; int has_slot = 0;
    1971           0 :   fd_jtok_t j[1]; fd_jtok_init( j, params, params_sz );
    1972           0 :   fd_jtok_str_t key;
    1973           0 :   fd_jtok_obj_enter( j );
    1974           0 :   while( fd_jtok_obj_next( j, &key ) ) {
    1975           0 :     if( fd_jtok_str_eq( &key, "slot" ) ) { fd_jtok_ulong( j, &_slot ); has_slot = 1; }
    1976           0 :   }
    1977           0 :   if( FD_UNLIKELY( fd_jtok_fini( j ) || !has_slot ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    1978             : 
    1979           0 :   fd_gui_slot_t const * slot = fd_gui_slot_get_canon_safe( gui, _slot );
    1980           0 :   int known = slot && ( slot->skip!=FD_GUI_SKIP_STATUS_UNKNOWN || fd_gui_ag_slot_is_skip_notarized( gui, _slot ) );
    1981           0 :   if( FD_UNLIKELY( !known ) ) {
    1982           0 :     fd_gui_printf_null_query_response( gui->http, "slot", "query", request_id );
    1983           0 :     FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
    1984           0 :     return 0;
    1985           0 :   }
    1986             : 
    1987           0 :   fd_gui_printf_slot_request( gui, _slot, request_id, slot );
    1988           0 :   FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
    1989           0 :   return 0;
    1990           0 : }
    1991             : 
    1992             : int
    1993             : fd_gui_request_slot_transactions( fd_gui_t *    gui,
    1994             :                                   ulong         ws_conn_id,
    1995             :                                   ulong         request_id,
    1996             :                                   char const *  params,
    1997           0 :                                   ulong         params_sz ) {
    1998           0 :   ulong _slot = 0UL; int has_slot = 0;
    1999           0 :   fd_jtok_t j[1]; fd_jtok_init( j, params, params_sz );
    2000           0 :   fd_jtok_str_t key;
    2001           0 :   fd_jtok_obj_enter( j );
    2002           0 :   while( fd_jtok_obj_next( j, &key ) ) {
    2003           0 :     if( fd_jtok_str_eq( &key, "slot" ) ) { fd_jtok_ulong( j, &_slot ); has_slot = 1; }
    2004           0 :   }
    2005           0 :   if( FD_UNLIKELY( fd_jtok_fini( j ) || !has_slot ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2006             : 
    2007           0 :   fd_gui_slot_t const * slot = fd_gui_slot_get_canon_safe( gui, _slot );
    2008           0 :   if( FD_UNLIKELY( !slot || slot->skip==FD_GUI_SKIP_STATUS_UNKNOWN ) ) {
    2009           0 :     fd_gui_printf_null_query_response( gui->http, "slot", "query_transactions", request_id );
    2010           0 :     FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
    2011           0 :     return 0;
    2012           0 :   }
    2013             : 
    2014           0 :   fd_gui_printf_slot_transactions_request( gui, _slot, request_id, slot );
    2015           0 :   FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
    2016           0 :   return 0;
    2017           0 : }
    2018             : 
    2019             : int
    2020             : fd_gui_request_slot_detailed( fd_gui_t *    gui,
    2021             :                               ulong         ws_conn_id,
    2022             :                               ulong         request_id,
    2023             :                               char const *  params,
    2024           0 :                               ulong         params_sz ) {
    2025           0 :   ulong _slot = 0UL; int has_slot = 0;
    2026           0 :   fd_jtok_t j[1]; fd_jtok_init( j, params, params_sz );
    2027           0 :   fd_jtok_str_t key;
    2028           0 :   fd_jtok_obj_enter( j );
    2029           0 :   while( fd_jtok_obj_next( j, &key ) ) {
    2030           0 :     if( fd_jtok_str_eq( &key, "slot" ) ) { fd_jtok_ulong( j, &_slot ); has_slot = 1; }
    2031           0 :   }
    2032           0 :   if( FD_UNLIKELY( fd_jtok_fini( j ) || !has_slot ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2033             : 
    2034           0 :   fd_gui_slot_t const * slot = fd_gui_slot_get_canon_safe( gui, _slot );
    2035           0 :   int known = slot && ( slot->skip!=FD_GUI_SKIP_STATUS_UNKNOWN || fd_gui_ag_slot_is_skip_notarized( gui, _slot ) );
    2036           0 :   if( FD_UNLIKELY( !known ) ) {
    2037           0 :     fd_gui_printf_null_query_response( gui->http, "slot", "query_detailed", request_id );
    2038           0 :     FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
    2039           0 :     return 0;
    2040           0 :   }
    2041             : 
    2042           0 :   fd_gui_printf_slot_request_detailed( gui, _slot, request_id, slot );
    2043           0 :   FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
    2044           0 :   return 0;
    2045           0 : }
    2046             : 
    2047             : static inline ulong
    2048           0 : fd_gui_slot_duration( fd_gui_t * gui, fd_gui_slot_t const * cur ) {
    2049           0 :   if( FD_UNLIKELY( cur->skip==FD_GUI_SKIP_STATUS_FINALIZED || cur->completed_time==LONG_MAX ) ) return ULONG_MAX;
    2050           0 :   fd_gui_slot_t const * prev = fd_gui_slot_get_any( gui, cur->slot-1UL );
    2051           0 :   long parent_completed_time = LONG_MAX;
    2052           0 :   if( FD_LIKELY( prev && prev->skip!=FD_GUI_SKIP_STATUS_FINALIZED ) ) parent_completed_time = prev->completed_time;
    2053           0 :   if( FD_UNLIKELY( parent_completed_time==LONG_MAX ) ) return ULONG_MAX;
    2054             : 
    2055           0 :   return (ulong)(cur->completed_time - parent_completed_time);
    2056           0 : }
    2057             : 
    2058             : /* All rankings are initialized / reset to ULONG_MAX.  These sentinels
    2059             :    sort AFTER non-sentinel ranking entries.  Equal slots are sorted by
    2060             :    oldest slot AFTER.  Otherwise sort by value according to ranking
    2061             :    type. */
    2062           0 : #define RANKING_BEFORE(a,b) fd_int_if( (a).slot==ULONG_MAX, 0, fd_int_if( (b).slot==ULONG_MAX, 1, fd_int_if( (a).value==(b).value, (a).slot>(b).slot, fd_int_if( (a).type==FD_GUI_SLOT_RANKING_TYPE_DESC, (a).value>(b).value, (a).value<(b).value ) ) ) )
    2063             : 
    2064             : /* ranking_insert places e in the sorted top FD_GUI_SLOT_RANKINGS_SZ of
    2065             :    arr, or drops it if it sorts after the last entry. */
    2066             : 
    2067             : static inline void
    2068             : ranking_insert( fd_gui_slot_ranking_t * arr,
    2069           0 :                 fd_gui_slot_ranking_t   e ) {
    2070           0 :   if( FD_LIKELY( !RANKING_BEFORE( e, arr[ FD_GUI_SLOT_RANKINGS_SZ-1UL ] ) ) ) return;
    2071           0 :   ulong i = FD_GUI_SLOT_RANKINGS_SZ-1UL;
    2072           0 :   while( i && RANKING_BEFORE( e, arr[ i-1UL ] ) ) { arr[ i ] = arr[ i-1UL ]; i--; }
    2073           0 :   arr[ i ] = e;
    2074           0 : }
    2075             : 
    2076             : static inline void
    2077             : fd_gui_try_insert_ranking( fd_gui_t               * gui,
    2078             :                            fd_gui_slot_rankings_t * rankings,
    2079           0 :                            fd_gui_slot_t const    * slot ) {
    2080           0 : #define TRY_INSERT_SLOT( ranking_name, ranking_slot, ranking_value ) \
    2081           0 :   do { \
    2082           0 :     ranking_insert( rankings->FD_CONCAT2(largest_,  ranking_name), (fd_gui_slot_ranking_t){ .slot = (ranking_slot), .value = (ranking_value), .type = FD_GUI_SLOT_RANKING_TYPE_DESC } ); \
    2083           0 :     ranking_insert( rankings->FD_CONCAT2(smallest_, ranking_name), (fd_gui_slot_ranking_t){ .slot = (ranking_slot), .value = (ranking_value), .type = FD_GUI_SLOT_RANKING_TYPE_ASC  } ); \
    2084           0 :   } while (0)
    2085             : 
    2086           0 :     if( slot->skip==FD_GUI_SKIP_STATUS_FINALIZED ) {
    2087           0 :       TRY_INSERT_SLOT( skipped, slot->slot, slot->slot );
    2088           0 :       return;
    2089           0 :     }
    2090             : 
    2091           0 :     ulong dur = fd_gui_slot_duration( gui, slot );
    2092           0 :     if( FD_LIKELY( dur!=ULONG_MAX ) ) TRY_INSERT_SLOT( duration, slot->slot, dur                         );
    2093           0 :     if( FD_LIKELY( slot->tips!=ULONG_MAX ) ) TRY_INSERT_SLOT( tips, slot->slot, slot->tips );
    2094           0 :     if( FD_LIKELY( slot->priority_fee!=ULONG_MAX && slot->transaction_fee!=ULONG_MAX ) ) {
    2095           0 :       ulong fees = slot->priority_fee + slot->transaction_fee;
    2096           0 :       TRY_INSERT_SLOT( fees, slot->slot, fees );
    2097           0 :       if( FD_LIKELY( slot->tips!=ULONG_MAX ) ) {
    2098           0 :         ulong rewards = slot->tips + fees;
    2099           0 :         TRY_INSERT_SLOT( rewards,        slot->slot, rewards );
    2100           0 :         TRY_INSERT_SLOT( rewards_per_cu, slot->slot, slot->compute_units==0UL ? 0UL : rewards / slot->compute_units );
    2101           0 :       }
    2102           0 :     }
    2103           0 :     TRY_INSERT_SLOT( compute_units,  slot->slot, slot->compute_units                                     );
    2104           0 : #undef TRY_INSERT_SLOT
    2105           0 : }
    2106             : 
    2107             : static void
    2108           0 : fd_gui_update_slot_rankings( fd_gui_t * gui ) {
    2109           0 :   if( FD_UNLIKELY( gui->summary.slot_caught_up==ULONG_MAX ) ) return;
    2110           0 :   ulong first_replay_slot = fd_gui_first_replay_slot( gui );
    2111           0 :   if( FD_UNLIKELY( first_replay_slot==ULONG_MAX ) ) return;
    2112           0 :   if( FD_UNLIKELY( gui->summary.slot_rooted==ULONG_MAX ) ) return;
    2113             : 
    2114           0 :   fd_gui_epoch_t * epoch = fd_gui_get_epoch_by_slot( gui, gui->summary.slot_rooted );
    2115           0 :   if( FD_UNLIKELY( !epoch ) ) return;
    2116             : 
    2117             :   /* No new slots since the last update */
    2118           0 :   if( FD_UNLIKELY( epoch->rankings_slot>gui->summary.slot_rooted ) ) return;
    2119             : 
    2120             :   /* Slots before first_replay_slot are unavailable. */
    2121           0 :   epoch->rankings_slot = fd_ulong_max( epoch->rankings_slot, first_replay_slot );
    2122             : 
    2123             :   /* Update the rankings. Only look through slots we haven't already. */
    2124           0 :   for( ulong s = gui->summary.slot_rooted; s>=epoch->rankings_slot; s--) {
    2125           0 :     fd_gui_slot_t const * slot = fd_gui_slot_get_canon_safe( gui, s );
    2126           0 :     if( FD_UNLIKELY( slot->skip==FD_GUI_SKIP_STATUS_UNKNOWN ) ) break;
    2127             : 
    2128           0 :     fd_gui_try_insert_ranking( gui, epoch->rankings, slot );
    2129           0 :     if( FD_UNLIKELY( slot->mine ) ) fd_gui_try_insert_ranking( gui, epoch->my_rankings, slot );
    2130           0 :   }
    2131             : 
    2132           0 :   epoch->rankings_slot = gui->summary.slot_rooted + 1UL;
    2133           0 : }
    2134             : 
    2135             : int
    2136             : fd_gui_request_slot_rankings( fd_gui_t *    gui,
    2137             :                               ulong         ws_conn_id,
    2138             :                               ulong         request_id,
    2139             :                               char const *  params,
    2140           0 :                               ulong         params_sz ) {
    2141           0 :   int mine = 0; int has_mine = 0;
    2142           0 :   fd_jtok_t j[1]; fd_jtok_init( j, params, params_sz );
    2143           0 :   fd_jtok_str_t key;
    2144           0 :   fd_jtok_obj_enter( j );
    2145           0 :   while( fd_jtok_obj_next( j, &key ) ) {
    2146           0 :     if( fd_jtok_str_eq( &key, "mine" ) ) { fd_jtok_bool( j, &mine ); has_mine = 1; }
    2147           0 :   }
    2148           0 :   if( FD_UNLIKELY( fd_jtok_fini( j ) || !has_mine ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2149             : 
    2150           0 :   fd_gui_update_slot_rankings( gui );
    2151           0 :   fd_gui_printf_slot_rankings_request( gui, request_id, mine );
    2152           0 :   FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
    2153           0 :   return 0;
    2154           0 : }
    2155             : 
    2156             : /* fd_gui_jtok_parse_ns consumes a canonical nonnegative decimal string
    2157             :    into *out.  Returns 0 on success, -1 for invalid values or values at
    2158             :    or above LONG_MAX. */
    2159             : 
    2160             : static inline int
    2161             : fd_gui_jtok_parse_ns( fd_jtok_t * j,
    2162         204 :                       long *      out ) {
    2163         204 :   char value[ 20UL ];
    2164         204 :   fd_jtok_cstr( j, value, sizeof(value) );
    2165         204 :   if( FD_UNLIKELY( fd_jtok_err( j ) ) ) return -1;
    2166             : 
    2167         204 :   ulong value_len = strlen( value );
    2168         204 :   if( FD_UNLIKELY( !value_len ) ) return -1;
    2169         204 :   if( FD_UNLIKELY( value_len>1UL && value[ 0 ]=='0' ) ) return -1;
    2170             : 
    2171        1140 :   for( ulong i=0UL; i<value_len; i++ ) {
    2172         936 :     if( FD_UNLIKELY( value[ i ]<'0' || value[ i ]>'9' ) ) return -1;
    2173         936 :   }
    2174             : 
    2175         204 :   long parsed = fd_cstr_to_long( value );
    2176         204 :   if( FD_UNLIKELY( parsed==LONG_MAX ) ) return -1;
    2177         204 :   *out = parsed;
    2178         204 :   return 0;
    2179         204 : }
    2180             : 
    2181             : static int
    2182             : fd_gui_request_timeline( fd_gui_t *   gui,
    2183             :                          ulong        ws_conn_id,
    2184             :                          char const * key,
    2185             :                          ulong        id,
    2186             :                          char const * params,
    2187         102 :                          ulong        params_sz ) {
    2188         102 :   long start_ns = 0L; int has_start = 0;
    2189         102 :   long end_ns   = 0L; int has_end   = 0;
    2190         102 :   char name[ 32UL ] = {0};
    2191         102 :   ulong tiles[ FD_TOPO_MAX_TILES ]; ulong tile_cnt = 0UL;
    2192         102 :   fd_jtok_t j[1]; fd_jtok_init( j, params, params_sz );
    2193         102 :   fd_jtok_str_t member;
    2194         102 :   fd_jtok_obj_enter( j );
    2195         435 :   while( fd_jtok_obj_next( j, &member ) ) {
    2196         336 :     if( fd_jtok_str_eq( &member, "start_ns" ) ) {
    2197         102 :       if( FD_UNLIKELY( fd_gui_jtok_parse_ns( j, &start_ns ) ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2198         102 :       has_start = 1;
    2199         234 :     } else if( fd_jtok_str_eq( &member, "end_ns" ) ) {
    2200         102 :       if( FD_UNLIKELY( fd_gui_jtok_parse_ns( j, &end_ns ) ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2201         102 :       has_end = 1;
    2202         132 :     } else if( fd_jtok_str_eq( &member, "granularity" ) ) {
    2203          90 :       fd_jtok_cstr( j, name, sizeof(name) );
    2204          90 :     } else if( fd_jtok_str_eq( &member, "tiles" ) ) {
    2205          42 :       fd_jtok_arr_enter( j );
    2206         855 :       while( fd_jtok_arr_next( j ) ) {
    2207         816 :         if( FD_UNLIKELY( tile_cnt>=FD_TOPO_MAX_TILES ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2208         813 :         fd_jtok_ulong( j, &tiles[ tile_cnt++ ] );
    2209         813 :       }
    2210          42 :     }
    2211         336 :   }
    2212          99 :   if( FD_UNLIKELY( fd_jtok_fini( j ) || !has_start || !has_end || end_ns<=start_ns ) ) {
    2213          12 :     return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2214          12 :   }
    2215          87 :   int err;
    2216          87 :   if( !strcmp( key, "query_slots" ) ) {
    2217           0 :     err = fd_gui_printf_timeline_query_slots( gui, start_ns, end_ns, id );
    2218          87 :   } else if( !strcmp( key, "query_events" ) ) {
    2219           0 :     err = fd_gui_printf_timeline_query_events( gui, start_ns, end_ns, id );
    2220          87 :   } else if( !strcmp( key, "query_shreds" ) ) {
    2221           0 :     if(      !strcmp( name, "shred" ) ) err = fd_gui_printf_timeline_query_shreds( gui, start_ns, end_ns, id );
    2222           0 :     else if( !strcmp( name, "fec"   ) ) err = fd_gui_printf_timeline_query_fec_events( gui, start_ns, end_ns, id );
    2223           0 :     else return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2224          87 :   } else {
    2225          87 :     ulong g = 0UL;
    2226        1008 :     while( g<FD_GUI_TIMELINE_GRANULARITY_CNT && strcmp( name, fd_gui_timeline_granularities[ g ].name ) ) g++;
    2227          87 :     if( FD_UNLIKELY( g==FD_GUI_TIMELINE_GRANULARITY_CNT ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2228          54 :     int   stored;
    2229          54 :     ulong merge_cnt;
    2230          54 :     if( FD_UNLIKELY( fd_gui_timeline_tier( key, g, &stored, &merge_cnt ) ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2231          42 :     ulong ns        = fd_gui_timeline_granularity_ns( g );
    2232          42 :     ulong first     = (ulong)start_ns / ns;
    2233          42 :     ulong reference = first*ns;
    2234          42 :     ulong count     = ((ulong)end_ns-1UL)/ns - first + 1UL;
    2235          42 :     if( FD_UNLIKELY( count>FD_GUI_TIMELINE_QUERY_MAX_BUCKETS || count*ns>=(ulong)LONG_MAX-reference ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2236          30 :     if( !strcmp( key, "query_agg_cpu" ) ) err = fd_gui_printf_timeline_query_agg_cpu( gui, name, g, (long)reference, count, tiles, tile_cnt, id );
    2237          24 :     else                                  err = fd_gui_printf_timeline_query_agg( gui, key, name, g, (long)reference, count, id );
    2238          30 :   }
    2239          30 :   if( FD_UNLIKELY( err ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2240          27 :   FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
    2241          27 :   return 0;
    2242          27 : }
    2243             : 
    2244             : int
    2245             : fd_gui_ws_message( fd_gui_t *    gui,
    2246             :                    ulong         ws_conn_id,
    2247             :                    uchar const * data,
    2248         102 :                    ulong         data_len ) {
    2249         102 :   ulong         id        = 0UL; int has_id = 0;
    2250         102 :   fd_jtok_str_t topic     = {0};
    2251         102 :   fd_jtok_str_t key       = {0};
    2252         102 :   char const *  params    = NULL;
    2253         102 :   ulong         params_sz = 0UL;
    2254             : 
    2255         102 :   fd_jtok_t j[1]; fd_jtok_init( j, data, data_len );
    2256         102 :   fd_jtok_str_t member;
    2257         102 :   fd_jtok_obj_enter( j );
    2258         510 :   while( fd_jtok_obj_next( j, &member ) ) {
    2259         408 :     if(      fd_jtok_str_eq( &member, "id"     ) ) { fd_jtok_ulong( j, &id ); has_id = 1; }
    2260         306 :     else if( fd_jtok_str_eq( &member, "topic"  ) ) fd_jtok_str( j, &topic );
    2261         204 :     else if( fd_jtok_str_eq( &member, "key"    ) ) fd_jtok_str( j, &key );
    2262         102 :     else if( fd_jtok_str_eq( &member, "params" ) ) {
    2263         102 :       if( FD_UNLIKELY( fd_jtok_peek( j )!=FD_JTOK_OBJ ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2264         102 :       fd_jtok_raw( j, &params, &params_sz );
    2265         102 :     }
    2266         408 :   }
    2267         102 :   if( FD_UNLIKELY( fd_jtok_fini( j ) || !has_id || !topic.ptr || !key.ptr ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2268             : 
    2269         102 :   if( FD_LIKELY( fd_jtok_str_eq( &topic, "slot" ) && fd_jtok_str_eq( &key, "query" ) ) ) {
    2270           0 :     if( FD_UNLIKELY( !params ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2271           0 :     return fd_gui_request_slot( gui, ws_conn_id, id, params, params_sz );
    2272         102 :   } else if( FD_LIKELY( fd_jtok_str_eq( &topic, "slot" ) && fd_jtok_str_eq( &key, "query_detailed" ) ) ) {
    2273           0 :     if( FD_UNLIKELY( !params ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2274           0 :     return fd_gui_request_slot_detailed( gui, ws_conn_id, id, params, params_sz );
    2275         102 :   } else if( FD_LIKELY( fd_jtok_str_eq( &topic, "slot" ) && fd_jtok_str_eq( &key, "query_transactions" ) ) ) {
    2276           0 :     if( FD_UNLIKELY( !params ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2277           0 :     return fd_gui_request_slot_transactions( gui, ws_conn_id, id, params, params_sz );
    2278         102 :   } else if( FD_LIKELY( fd_jtok_str_eq( &topic, "slot" ) && fd_jtok_str_eq( &key, "query_rankings" ) ) ) {
    2279           0 :     if( FD_UNLIKELY( !params ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2280           0 :     return fd_gui_request_slot_rankings( gui, ws_conn_id, id, params, params_sz );
    2281         102 :   } else if( FD_LIKELY( fd_jtok_str_eq( &topic, "timeline" ) &&
    2282         102 :       (fd_jtok_str_eq( &key, "query_shreds" ) ||
    2283         102 :        fd_jtok_str_eq( &key, "query_slots" ) ||
    2284         102 :        fd_jtok_str_eq( &key, "query_events" ) ||
    2285         102 :        fd_jtok_str_eq( &key, "query_agg_slots" ) ||
    2286         102 :        fd_jtok_str_eq( &key, "query_agg_shreds" ) ||
    2287         102 :        fd_jtok_str_eq( &key, "query_agg_compute" ) ||
    2288         102 :        fd_jtok_str_eq( &key, "query_agg_revenue" ) ||
    2289         102 :        fd_jtok_str_eq( &key, "query_agg_txn" ) ||
    2290         102 :        fd_jtok_str_eq( &key, "query_agg_cpu" )) ) ) {
    2291         102 :     if( FD_UNLIKELY( !params ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2292         102 :     char name[ 32UL ];
    2293         102 :     if( FD_UNLIKELY( fd_jtok_str_decode( &key, name, sizeof(name) )<0L ) ) return FD_HTTP_SERVER_CONNECTION_CLOSE_BAD_REQUEST;
    2294         102 :     return fd_gui_request_timeline( gui, ws_conn_id, name, id, params, params_sz );
    2295         102 :   } else if( FD_LIKELY( fd_jtok_str_eq( &topic, "summary" ) && fd_jtok_str_eq( &key, "ping" ) ) ) {
    2296           0 :     fd_gui_printf_summary_ping( gui, id );
    2297           0 :     FD_TEST( !fd_http_server_ws_send( gui->http, ws_conn_id ) );
    2298           0 :     return 0;
    2299           0 :   }
    2300             : 
    2301           0 :   return FD_HTTP_SERVER_CONNECTION_CLOSE_UNKNOWN_METHOD;
    2302         102 : }
    2303             : 
    2304             : static inline uchar
    2305          18 : slot_get_skip_status( fd_gui_t * gui, ulong _slot ) {
    2306          18 :   ulong tower_slot = gui->summary.slot_tower;
    2307          18 :   if( FD_UNLIKELY( tower_slot==ULONG_MAX || _slot>=tower_slot ) ) return FD_GUI_SKIP_STATUS_UNKNOWN;
    2308             : 
    2309           6 :   ulong const max_consecutive_skips = gui->max_consecutive_skips;
    2310             : 
    2311             :   /* Find the nearest landed canonical descendant and walk its lineage
    2312             :      down to obtain positive skip proof. */
    2313           6 :   ulong anchor_slot     = ULONG_MAX;
    2314           6 :   ulong anchor_bank_seq = ULONG_MAX;
    2315           6 :   ulong search_hi       = fd_ulong_min( _slot+max_consecutive_skips, tower_slot );
    2316           6 :   for( ulong s=_slot+1UL; s<=search_hi; s++ ) {
    2317           6 :     fd_gui_hist_kv_slot_iter_t it[ 1 ];
    2318             :     /* Equivocation-safe */
    2319           6 :     for( fd_gui_hist_kv_iter_begin( gui, it, FD_GUI_HIST_SLOT, s ); it->rec; fd_gui_hist_kv_iter_next( it ) ) {
    2320           6 :       fd_gui_slot_t const * rec = (fd_gui_slot_t const *)it->rec;
    2321           6 :       if( FD_LIKELY( rec->skip==FD_GUI_SKIP_STATUS_NOT_SKIPPED ) ) {
    2322           6 :         anchor_slot     = s;
    2323           6 :         anchor_bank_seq = it->bank_seq;
    2324           6 :         break;
    2325           6 :       }
    2326           6 :     }
    2327           6 :     if( FD_UNLIKELY( anchor_slot!=ULONG_MAX ) ) break;
    2328           6 :   }
    2329           6 :   if( FD_UNLIKELY( anchor_slot==ULONG_MAX ) ) return FD_GUI_SKIP_STATUS_UNKNOWN; /* no descendant found */
    2330             : 
    2331             :   /* Walk the canonical fork back up. */
    2332           6 :   ulong cur_slot     = anchor_slot;
    2333           6 :   ulong cur_bank_seq = anchor_bank_seq;
    2334           6 :   for( ulong steps=0UL; steps<max_consecutive_skips; steps++ ) {
    2335           6 :     fd_gui_hist_slot_key_t key;
    2336           6 :     key.slot = cur_slot; key.bank_seq = cur_bank_seq;
    2337           6 :     fd_gui_slot_t const * cmeta = (fd_gui_slot_t const *)fd_gui_hist_kv_get( gui, FD_GUI_HIST_SLOT, &key );
    2338           6 :     if( FD_UNLIKELY( !cmeta ) ) return FD_GUI_SKIP_STATUS_UNKNOWN; /* lineage broken / aged out */
    2339             : 
    2340           6 :     ulong parent_slot     = cmeta->parent_slot;
    2341           6 :     ulong parent_bank_seq = cmeta->parent_bank_seq;
    2342           6 :     if( FD_UNLIKELY( parent_slot==ULONG_MAX ) ) return FD_GUI_SKIP_STATUS_UNKNOWN; /* Couldn't find _slot */
    2343           6 :     if( FD_LIKELY( parent_slot==_slot ) ) return FD_GUI_SKIP_STATUS_NOT_SKIPPED;   /* _slot is on this lineage */
    2344           6 :     if( FD_LIKELY( parent_slot< _slot ) ) return FD_GUI_SKIP_STATUS_FINALIZED;     /* lineage steps over _slot: skipped */
    2345           0 :     cur_slot     = parent_slot;
    2346           0 :     cur_bank_seq = parent_bank_seq;
    2347           0 :   }
    2348           0 :   return FD_GUI_SKIP_STATUS_UNKNOWN;
    2349           6 : }
    2350             : 
    2351             : fd_gui_slot_t *
    2352          27 : fd_gui_slot_get_canon_safe( fd_gui_t * gui, ulong _slot ) {
    2353          27 :   fd_gui_slot_t * slot = fd_gui_slot_get_canon( gui, _slot );
    2354             : 
    2355          27 :   if( FD_LIKELY( slot ) ) {
    2356           9 :     return slot;
    2357          18 :   } else {
    2358          18 :     uchar level = FD_GUI_SLOT_LEVEL_COMPLETED;
    2359          18 :     if( FD_LIKELY( gui->summary.slot_rooted!=ULONG_MAX && _slot<gui->summary.slot_rooted ) ) level = FD_GUI_SLOT_LEVEL_ROOTED;
    2360             : 
    2361          18 :     *gui->skipped_scratch = (fd_gui_slot_t){
    2362          18 :       .slot             = _slot,
    2363          18 :       .bank_seq         = ULONG_MAX,
    2364          18 :       .parent_bank_seq  = ULONG_MAX,
    2365          18 :       .parent_slot      = ULONG_MAX,
    2366          18 :       .vote_slot        = ULONG_MAX,
    2367          18 :       .completed_time   = LONG_MAX,
    2368          18 :       .parent_completed_time = LONG_MAX,
    2369          18 :       .max_compute_units= UINT_MAX,
    2370          18 :       .mine             = (uchar)(fd_gui_slot_is_mine( gui, _slot ) & 1),
    2371          18 :       .skip             = slot_get_skip_status( gui, _slot ),
    2372          18 :       .level            = level,
    2373          18 :       .compute_units    = UINT_MAX,
    2374          18 :       .transaction_fee  = ULONG_MAX,
    2375          18 :       .priority_fee     = ULONG_MAX,
    2376          18 :       .tips             = ULONG_MAX,
    2377          18 :       .shred_cnt        = UINT_MAX,
    2378          18 :       .is_voter         = FD_GUI_IS_VOTER_UNKNOWN,
    2379          18 :       .vote_rewarded    = fd_gui_slot_vote_rewarded_state( gui, _slot ),
    2380          18 :       .vote_count       = fd_gui_slot_vote_count( gui, _slot ),
    2381          18 :       .vote_success     = UINT_MAX,
    2382          18 :       .vote_failed      = UINT_MAX,
    2383          18 :       .nonvote_success  = UINT_MAX,
    2384          18 :       .nonvote_failed   = UINT_MAX,
    2385          18 :     };
    2386          18 :     fd_gui_slot_set_voter_state( gui->skipped_scratch, fd_gui_slot_voter_state( gui, _slot ) );
    2387          18 :     return gui->skipped_scratch;
    2388          18 :   }
    2389          27 : }
    2390             : 
    2391             : static void
    2392           0 : fd_gui_update_boot_epoch_duration( fd_gui_t * gui ) {
    2393           0 :   ulong prev = gui->summary.boot_progress.boot_target_slot_duration_nanos;
    2394             : 
    2395           0 :   ulong slot = fd_gui_boot_snapshot_slot( gui );
    2396           0 :   if( FD_LIKELY( slot!=ULONG_MAX ) ) {
    2397           0 :     fd_gui_epoch_t const * epoch = fd_gui_get_epoch_by_slot( gui, slot );
    2398           0 :     if( FD_LIKELY( epoch && epoch->target_slot_duration_ns>0L ) ) {
    2399           0 :       gui->summary.boot_progress.boot_target_slot_duration_nanos = (ulong)epoch->target_slot_duration_ns;
    2400           0 :     }
    2401           0 :   }
    2402             : 
    2403           0 :   if( FD_UNLIKELY( prev!=gui->summary.boot_progress.boot_target_slot_duration_nanos ) ) {
    2404           0 :     gui->summary.prev_boot_progress = gui->summary.boot_progress;
    2405           0 :     fd_gui_printf_boot_progress( gui );
    2406           0 :     fd_http_server_ws_broadcast( gui->http );
    2407           0 :   }
    2408           0 : }
    2409             : 
    2410             : void
    2411             : fd_gui_handle_epoch_info( fd_gui_t *                  gui,
    2412             :                           fd_epoch_info_msg_t const * epoch_info,
    2413           0 :                           long                        now ) {
    2414           0 :   FD_TEST( epoch_info->staked_vote_cnt<=MAX_STAKE_WEIGHTS );
    2415           0 :   FD_TEST( epoch_info->slot_cnt<=MAX_SLOTS_PER_EPOCH );
    2416           0 :   FD_TEST( epoch_info->staked_vote_cnt );
    2417             : 
    2418           0 :   if( FD_UNLIKELY( !gui->epoch.has_epoch_schedule ) ) {
    2419           0 :     gui->epoch.epoch_schedule     = epoch_info->epoch_schedule;
    2420           0 :     gui->epoch.has_epoch_schedule = 1;
    2421           0 :   }
    2422             : 
    2423           0 :   fd_vote_stake_weight_t const * stake_weights = fd_epoch_info_msg_stake_weights( epoch_info );
    2424           0 :   fd_memcpy( gui->epoch.stakes_scratch, stake_weights, epoch_info->staked_vote_cnt*sizeof(fd_vote_stake_weight_t) );
    2425             : 
    2426           0 :   fd_epoch_leaders_t * lsched = fd_epoch_leaders_join( fd_epoch_leaders_new( gui->epoch.lsched_scratch,
    2427           0 :                                                                              epoch_info->epoch,
    2428           0 :                                                                              epoch_info->start_slot,
    2429           0 :                                                                              epoch_info->slot_cnt,
    2430           0 :                                                                              epoch_info->staked_vote_cnt,
    2431           0 :                                                                              gui->epoch.stakes_scratch,
    2432           0 :                                                                              fd_epoch_leaders_use_geo_aware( &epoch_info->features, &epoch_info->epoch_schedule, epoch_info->epoch ) ) );
    2433           0 :   FD_TEST( lsched );
    2434             : 
    2435           0 :   int created = 0;
    2436           0 :   fd_gui_epoch_t * epoch = fd_gui_epoch_get_or_create( gui, epoch_info->epoch, &created );
    2437           0 :   FD_TEST( epoch );
    2438             : 
    2439           0 :   if( FD_LIKELY( created ) ) {
    2440           0 :     epoch->epoch          = epoch_info->epoch;
    2441           0 :     epoch->start_slot     = epoch_info->start_slot;
    2442           0 :     epoch->slot_cnt       = epoch_info->slot_cnt;
    2443           0 :     epoch->start_time     = LONG_MAX;
    2444           0 :     epoch->end_time       = LONG_MAX;
    2445           0 :     epoch->my_total_slots = 0UL;
    2446           0 :     epoch->my_skipped_slots = 0UL;
    2447           0 :     epoch->rankings_slot  = epoch_info->start_slot;
    2448           0 :     epoch->timeline_slot_lo_idx = ULONG_MAX;
    2449           0 :     epoch->timeline_slot_hi_idx = ULONG_MAX;
    2450           0 :     epoch->timeline_slot_min_start_ns = LONG_MAX;
    2451           0 :     epoch->timeline_slot_max_end_ns   = LONG_MIN;
    2452           0 :     memset( epoch->timeline_slot_state, 0, sizeof(epoch->timeline_slot_state) );
    2453           0 :     memset( epoch->timeline_slot_shred_cnt, 0xFF, sizeof(epoch->timeline_slot_shred_cnt) );
    2454           0 :     memset( epoch->rankings,    (int)(UINT_MAX), sizeof(epoch->rankings)    );
    2455           0 :     memset( epoch->my_rankings, (int)(UINT_MAX), sizeof(epoch->my_rankings) );
    2456           0 :     memset( epoch->is_voter,      FD_GUI_IS_VOTER_UNKNOWN,           sizeof(epoch->is_voter)      );
    2457           0 :     memset( epoch->skipped,       0,                                 sizeof(epoch->skipped)       );
    2458           0 :     memset( epoch->vote_rewarded, FD_GUI_VOTE_REWARDED_UNKNOWN,      sizeof(epoch->vote_rewarded) );
    2459           0 :     memset( epoch->vote_count,    UCHAR_MAX,                         sizeof(epoch->vote_count)    );
    2460           0 :     epoch->epoch_schedule = epoch_info->epoch_schedule;
    2461           0 :     epoch->pub_cnt        = lsched->pub_cnt;
    2462           0 :     epoch->stakes_cnt     = epoch_info->staked_vote_cnt;
    2463           0 :     fd_memcpy( epoch->pub,    lsched->pub,   epoch->pub_cnt*sizeof(fd_pubkey_t) );
    2464           0 :     fd_memcpy( epoch->sched,  lsched->sched, fd_ulong_min( lsched->sched_cnt, FD_GUI_EPOCH_SCHED_CNT )*sizeof(uint) );
    2465           0 :     fd_memcpy( epoch->stakes, gui->epoch.stakes_scratch, epoch->stakes_cnt*sizeof(fd_vote_stake_weight_t) );
    2466           0 :   }
    2467             : 
    2468           0 :   epoch->target_slot_duration_ns = (long)epoch_info->ns_per_slot;
    2469             : 
    2470           0 :   fd_epoch_leaders_delete( fd_epoch_leaders_leave( lsched ) );
    2471             : 
    2472           0 :   if( FD_UNLIKELY( gui->epoch.current_epoch==ULONG_MAX ) ) {
    2473           0 :     gui->epoch.current_epoch = epoch_info->epoch;
    2474           0 :   } else {
    2475           0 :     gui->epoch.current_epoch = fd_ulong_max( gui->epoch.current_epoch, epoch_info->epoch>0UL ? epoch_info->epoch-1UL : 0UL );
    2476           0 :   }
    2477             : 
    2478           0 :   epoch->start_time = now;
    2479           0 :   for( ulong i=0UL; i<fd_ulong_min( fd_ulong_sat_sub( epoch_info->start_slot, 1UL ), MAX_SLOTS_PER_EPOCH ); i++ ) {
    2480           0 :     fd_gui_slot_t const * slot = fd_gui_slot_get_any( gui, epoch_info->start_slot-i );
    2481           0 :     if( FD_UNLIKELY( !slot ) ) break;
    2482           0 :     else if( FD_UNLIKELY( slot->skip==FD_GUI_SKIP_STATUS_FINALIZED ) ) continue;
    2483           0 :     epoch->start_time = slot->parent_completed_time;
    2484           0 :     break;
    2485           0 :   }
    2486             : 
    2487           0 :   fd_gui_update_boot_epoch_duration( gui );
    2488             : 
    2489           0 :   fd_gui_printf_epoch( gui, epoch_info->epoch );
    2490           0 :   fd_http_server_ws_broadcast( gui->http );
    2491           0 : }
    2492             : 
    2493             : void
    2494             : fd_gui_handle_shred( fd_gui_t * gui,
    2495             :                      ulong      slot,
    2496             :                      ulong      shred_idx,
    2497             :                      ulong      fec_set_idx,
    2498             :                      int        is_turbine,
    2499             :                      long       tsorig,
    2500          27 :                      long       now ) {
    2501          27 :   int was_sent = fd_gui_ephemeral_slots_contains( gui->summary.slots_max_turbine, FD_GUI_TURBINE_SLOT_HISTORY_SZ, slot );
    2502          27 :   if( FD_LIKELY( is_turbine ) ) fd_gui_try_insert_ephemeral_slot( gui->summary.slots_max_turbine, FD_GUI_TURBINE_SLOT_HISTORY_SZ, slot, tsorig );
    2503             : 
    2504             :   /* If we haven't caught up yet, update repair slot using received
    2505             :      shreds. This is not technically correct, but close enough and will
    2506             :      make the progress bar look correct. */
    2507          27 :   if( FD_UNLIKELY( !is_turbine && gui->summary.slot_caught_up==ULONG_MAX ) ) fd_gui_handle_repair_slot( gui, slot, tsorig );
    2508             : 
    2509          27 :   if( FD_UNLIKELY( !was_sent && is_turbine && slot!=gui->summary.slot_turbine ) ) {
    2510          15 :     gui->summary.slot_turbine = slot;
    2511             : 
    2512          15 :     fd_gui_printf_turbine_slot( gui );
    2513          15 :     fd_http_server_ws_broadcast( gui->http );
    2514             : 
    2515          15 :     gui->turbine_slots[ slot % FD_GUI_TURBINE_RECV_TIMESTAMPS ].slot = slot;
    2516          15 :     gui->turbine_slots[ slot % FD_GUI_TURBINE_RECV_TIMESTAMPS ].timestamp = tsorig;
    2517             : 
    2518          15 :     ulong duration_sum = 0UL;
    2519          15 :     ulong slot_cnt = 0UL;
    2520             : 
    2521       11265 :     for( ulong i=0UL; i<FD_GUI_TURBINE_RECV_TIMESTAMPS; i++ ) {
    2522       11250 :       fd_gui_turbine_slot_t * cur = &gui->turbine_slots[ i ];
    2523       11250 :       fd_gui_turbine_slot_t * prev = &gui->turbine_slots[ (i+FD_GUI_TURBINE_RECV_TIMESTAMPS-1UL) % FD_GUI_TURBINE_RECV_TIMESTAMPS ];
    2524       11250 :       if( FD_UNLIKELY( cur->slot==ULONG_MAX || prev->slot==ULONG_MAX || cur->slot!=prev->slot+1UL ) ) continue;
    2525             : 
    2526           0 :       long slot_duration = cur->timestamp - prev->timestamp;
    2527           0 :       duration_sum += (ulong)fd_long_max( slot_duration, 0UL );
    2528           0 :       slot_cnt++;
    2529           0 :     }
    2530             : 
    2531          15 :     if( FD_LIKELY( slot_cnt>0 ) ) {
    2532           0 :       gui->summary.estimated_slot_duration_nanos = (ulong)(duration_sum / slot_cnt);
    2533           0 :       fd_gui_printf_estimated_slot_duration_nanos( gui );
    2534           0 :       fd_http_server_ws_broadcast( gui->http );
    2535           0 :     }
    2536             : 
    2537          15 :     if( FD_UNLIKELY( gui->summary.slot_caught_up==ULONG_MAX ) ) fd_gui_try_insert_run_length_slot( gui->summary.catch_up_turbine, FD_GUI_TURBINE_CATCH_UP_HISTORY_SZ, &gui->summary.catch_up_turbine_sz, slot );
    2538          15 :   }
    2539             : 
    2540          27 :   uchar event = fd_uchar_if( is_turbine, FD_GUI_SLOT_SHRED_SHRED_RECEIVED_TURBINE, FD_GUI_SLOT_SHRED_SHRED_RECEIVED_REPAIR );
    2541          27 :   fd_gui_shred_event_append( gui, slot, shred_idx, event, tsorig, now );
    2542          27 :   fd_gui_fec_event_append( gui, slot, fec_set_idx/FD_FEC_SHRED_CNT, event, tsorig, now );
    2543          27 : }
    2544             : 
    2545             : void
    2546             : fd_gui_handle_leader_fec( fd_gui_t * gui,
    2547             :                           ulong      slot,
    2548             :                           ulong      fec_shred_cnt,
    2549             :                           int        is_end_of_slot,
    2550             :                           long       tsorig,
    2551           6 :                           long       now ) {
    2552             :   /* Abandoned block detected */
    2553           6 :   if( FD_UNLIKELY( gui->shreds.leader_shred_slot!=slot ) ) {
    2554           3 :     gui->shreds.leader_shred_cnt  = 0UL;
    2555           3 :     gui->shreds.leader_shred_slot = slot;
    2556           3 :   }
    2557             : 
    2558         198 :   for( ulong i=gui->shreds.leader_shred_cnt; i<gui->shreds.leader_shred_cnt+fec_shred_cnt; i++ ) {
    2559         192 :     fd_gui_shred_event_append( gui, slot, i, FD_GUI_SLOT_SHRED_SHRED_PUBLISHED, tsorig, now );
    2560             :     /* Every shred of a FEC set maps to the same FEC event. */
    2561         192 :     if( i==gui->shreds.leader_shred_cnt || !(i%FD_FEC_SHRED_CNT) ) {
    2562           6 :       fd_gui_fec_event_append( gui, slot, i/FD_FEC_SHRED_CNT, FD_GUI_SLOT_SHRED_SHRED_PUBLISHED, tsorig, now );
    2563           6 :     }
    2564         192 :   }
    2565           6 :   gui->shreds.leader_shred_cnt += fec_shred_cnt;
    2566           6 :   if( FD_UNLIKELY( is_end_of_slot ) ) gui->shreds.leader_shred_cnt = 0UL;
    2567           6 : }
    2568             : 
    2569             : void
    2570             : fd_gui_handle_exec_txn_done( fd_gui_t * gui,
    2571             :                              ulong      slot,
    2572             :                              ulong      start_shred_idx,
    2573             :                              ulong      end_shred_idx,
    2574             :                              long       tsorig_ns FD_PARAM_UNUSED,
    2575             :                              long       tspub_ns,
    2576       12000 :                              long       now ) {
    2577             :   /* The frontend keeps the earliest exec done per shred: drop reports
    2578             :      that do not improve on the minimum seen so far. */
    2579       12000 :   ulong  ring = slot%FD_GUI_EXEC_DONE_SLOT_CNT;
    2580       12000 :   long * ts   = gui->exec_done.ts+ring*FD_SHRED_BLK_MAX;
    2581       12000 :   if( FD_UNLIKELY( gui->exec_done.slot[ ring ]!=slot ) ) {
    2582         147 :     gui->exec_done.slot[ ring ] = slot;
    2583     2408595 :     for( ulong i=0UL; i<FD_SHRED_BLK_MAX; i++ ) ts[ i ] = LONG_MAX;
    2584         147 :   }
    2585             : 
    2586       12000 :   ulong fec = ULONG_MAX;
    2587       41553 :   for( ulong i = start_shred_idx; i<end_shred_idx; i++ ) {
    2588             :     /*
    2589             :       We're leaving this state transition out due to its proximity to
    2590             :       FD_GUI_SLOT_SHRED_SHRED_REPLAY_EXEC_DONE, but if we ever wanted
    2591             :       to send this data to the frontend we could.
    2592             : 
    2593             :       fd_gui_shred_event_append( gui, slot, i, FD_GUI_SLOT_SHRED_SHRED_REPLAY_EXEC_START, tsorig_ns, now );
    2594             :     */
    2595             : 
    2596       29553 :     if( FD_LIKELY( i<FD_SHRED_BLK_MAX ) ) {
    2597       29553 :       if( FD_LIKELY( tspub_ns>=ts[ i ] ) ) continue;
    2598       10599 :       ts[ i ] = tspub_ns;
    2599       10599 :     }
    2600       10599 :     fd_gui_shred_event_append( gui, slot, i, FD_GUI_SLOT_SHRED_SHRED_REPLAY_EXEC_DONE, tspub_ns, now );
    2601             :     /* Every shred of a FEC set maps to the same FEC event, and all
    2602             :        carry the same timestamp, so one update per FEC set suffices. */
    2603       10599 :     if( fec!=i/FD_FEC_SHRED_CNT ) {
    2604        5634 :       fec = i/FD_FEC_SHRED_CNT;
    2605        5634 :       fd_gui_fec_event_append( gui, slot, fec, FD_GUI_SLOT_SHRED_SHRED_REPLAY_EXEC_DONE, tspub_ns, now );
    2606        5634 :     }
    2607       10599 :   }
    2608       12000 : }
    2609             : 
    2610             : static void
    2611             : fd_gui_timeline_root_block( fd_gui_t *            gui,
    2612             :                             fd_gui_slot_t const * c,
    2613             :                             ulong                 prev_rooted,
    2614             :                             long                  now );
    2615             : 
    2616             : static void
    2617             : fd_gui_persist_slot_skip( fd_gui_t * gui,
    2618             :                           ulong      slot,
    2619          72 :                           ulong      bank_seq ) {
    2620          72 :   fd_gui_hist_kv_slot_iter_t it[ 1 ];
    2621         126 :   for( fd_gui_hist_kv_iter_begin( gui, it, FD_GUI_HIST_SLOT, slot ); it->rec; fd_gui_hist_kv_iter_next( it ) ) {
    2622          54 :     ((fd_gui_slot_t *)it->rec)->skip = fd_uchar_if( it->bank_seq==bank_seq, FD_GUI_SKIP_STATUS_NOT_SKIPPED, FD_GUI_SKIP_STATUS_FINALIZED );
    2623          54 :   }
    2624          72 : }
    2625             : 
    2626             : void
    2627             : fd_gui_handle_root_advanced( fd_gui_t * gui,
    2628             :                              ulong      _slot,
    2629             :                              ulong      bank_seq,
    2630          15 :                              long       now ) {
    2631          15 :   fd_gui_slot_t * root = fd_gui_slot_get( gui, _slot, bank_seq );
    2632          15 :   if( FD_UNLIKELY( !root ) ) return;
    2633             : 
    2634             :   /* Rooting only ever advances. */
    2635          15 :   if( FD_UNLIKELY( gui->summary.slot_rooted!=ULONG_MAX && _slot<=gui->summary.slot_rooted ) ) return;
    2636             : 
    2637          15 :   ulong prev_rooted = gui->summary.slot_rooted;
    2638             : 
    2639          15 :   gui->summary.slot_rooted = _slot;
    2640             :   /* Slots below the root can no longer change, so their FEC events can
    2641             :      be archived.  Close one slot behind the root so events for older
    2642             :      slots still queued on other inputs (which are polled independently
    2643             :      of replay_out) are not dropped. */
    2644          15 :   fd_gui_event_closed_slot_wmark_advance( gui, fd_ulong_sat_sub( _slot, 1UL ) );
    2645          15 :   fd_gui_printf_root_slot( gui );
    2646          15 :   fd_http_server_ws_broadcast( gui->http );
    2647             : 
    2648          48 :   for( ulong cslot=_slot, cbank_seq=bank_seq; ; ) {
    2649          48 :     fd_gui_slot_t * c = fd_gui_slot_get( gui, cslot, cbank_seq );
    2650          48 :     if( FD_UNLIKELY( !c || c->level>=FD_GUI_SLOT_LEVEL_ROOTED ) ) break;
    2651             : 
    2652          42 :     c->level = FD_GUI_SLOT_LEVEL_ROOTED;
    2653          42 :     fd_gui_persist_slot_skip( gui, cslot, cbank_seq );
    2654             : 
    2655          42 :     if( FD_UNLIKELY( c->finalization_kind==FD_GUI_AG_FINAL_NONE ) ) {
    2656          42 :       c->finalization_kind = FD_GUI_AG_FINAL_IMPLICIT;
    2657          42 :     }
    2658             : 
    2659          42 :     fd_gui_printf_slot( gui, cslot, c );
    2660          42 :     fd_http_server_ws_broadcast( gui->http );
    2661             : 
    2662          42 :     fd_gui_epoch_t * epoch = fd_gui_get_epoch_by_slot( gui, cslot );
    2663          42 :     if( FD_LIKELY( epoch ) ) {
    2664          42 :       ulong cidx = cslot - epoch->start_slot;
    2665          42 :       if( FD_LIKELY( cidx<epoch->slot_cnt ) ) {
    2666          42 :         if( FD_UNLIKELY( epoch->is_voter[ cidx ]!=FD_GUI_IS_VOTER_UNKNOWN ) )
    2667           0 :           fd_gui_slot_set_voter_state( c, epoch->is_voter[ cidx ] );
    2668          42 :         epoch->is_voter[ cidx ] = c->is_voter;
    2669          42 :         epoch->vote_count[ cidx ] = c->vote_count;
    2670             : 
    2671             :         /* This slot is on the rooted fork, so it was not skipped. */
    2672          42 :         epoch->skipped[ cidx ] = 0;
    2673          42 :       }
    2674          42 :     }
    2675             : 
    2676          42 :     ulong pslot = c->parent_slot, pseq = c->parent_bank_seq;
    2677          42 :     fd_gui_slot_t cc = *c; /* the timeline write below can evict c */
    2678          42 :     if( FD_UNLIKELY( pslot==ULONG_MAX || pslot>=cslot ) ) break;
    2679             : 
    2680             :     /* Record and republish newly rooted skipped slots. */
    2681          63 :     for( ulong s=pslot+1UL; s<cslot; s++ ) {
    2682          30 :       if( FD_UNLIKELY( prev_rooted!=ULONG_MAX && s<=prev_rooted ) ) continue; /* already rooted earlier */
    2683             : 
    2684          30 :       fd_gui_persist_slot_skip( gui, s, ULONG_MAX );
    2685             : 
    2686          30 :       fd_gui_epoch_t * sepoch = fd_gui_get_epoch_by_slot( gui, s );
    2687          30 :       if( FD_LIKELY( sepoch ) ) {
    2688          30 :         ulong sidx = s - sepoch->start_slot;
    2689          30 :         if( FD_LIKELY( sidx<sepoch->slot_cnt ) ) sepoch->skipped[ sidx ] = 1;
    2690          30 :       }
    2691             : 
    2692          30 :       if( FD_UNLIKELY( prev_rooted==ULONG_MAX ) ) continue;
    2693             : 
    2694           9 :       fd_gui_slot_t const * skipped = fd_gui_slot_get_canon_safe( gui, s );
    2695           9 :       if( FD_UNLIKELY( skipped->skip!=FD_GUI_SKIP_STATUS_FINALIZED ) ) continue;
    2696           0 :       fd_gui_printf_slot( gui, s, skipped );
    2697           0 :       fd_http_server_ws_broadcast( gui->http );
    2698           0 :     }
    2699             : 
    2700          33 :     fd_gui_timeline_root_block( gui, &cc, prev_rooted, now );
    2701             : 
    2702          33 :     cslot = pslot; cbank_seq = pseq;
    2703          33 :   }
    2704          15 : }
    2705             : 
    2706             : static fd_gui_ag_slot_t *
    2707             : fd_gui_ag_slot_entry( fd_gui_t * gui,
    2708          57 :                       ulong      slot ) {
    2709             :   /* TODO: correctly handle equivocating slots */
    2710          57 :   fd_gui_ag_slot_t * ent = &gui->ag.slot[ slot % gui->ag.slot_cnt ];
    2711          57 :   if( FD_UNLIKELY( ent->slot!=slot ) ) {
    2712          24 :     ent->slot              = slot;
    2713          24 :     memset( ent->block_id.uc, 0, sizeof(fd_hash_t) );
    2714          24 :     ent->bank_seq          = ULONG_MAX;
    2715          24 :     ent->notarization_kind = FD_GUI_AG_NOTAR_NONE;
    2716          24 :     ent->finalization_kind = FD_GUI_AG_FINAL_NONE;
    2717          24 :     ent->skip              = FD_GUI_SKIP_STATUS_UNKNOWN;
    2718          24 :   }
    2719          57 :   return ent;
    2720          57 : }
    2721             : 
    2722             : static int
    2723          57 : fd_gui_ag_slot_has_proof( fd_gui_ag_slot_t const * ent ) {
    2724          57 :   return ent->notarization_kind!=FD_GUI_AG_NOTAR_NONE || ent->finalization_kind!=FD_GUI_AG_FINAL_NONE;
    2725          57 : }
    2726             : 
    2727             : static fd_gui_ag_slot_t *
    2728             : fd_gui_ag_slot_for_certificate( fd_gui_t *        gui,
    2729             :                                 ulong             slot,
    2730           0 :                                 fd_hash_t const * block_id ) {
    2731           0 :   fd_gui_ag_slot_t * ent = fd_gui_ag_slot_entry( gui, slot );
    2732           0 :   if( FD_UNLIKELY( !fd_hash_eq( &ent->block_id, block_id ) ) ) {
    2733           0 :     ent->block_id          = *block_id;
    2734           0 :     ent->bank_seq          = ULONG_MAX;
    2735           0 :     ent->notarization_kind = FD_GUI_AG_NOTAR_NONE;
    2736           0 :     ent->finalization_kind = FD_GUI_AG_FINAL_NONE;
    2737           0 :   }
    2738           0 :   return ent;
    2739           0 : }
    2740             : 
    2741             : static void
    2742             : fd_gui_ag_slot_publish( fd_gui_t *               gui,
    2743          57 :                         fd_gui_ag_slot_t const * ent ) {
    2744          57 :   if( FD_UNLIKELY( ent->bank_seq==ULONG_MAX ) ) return; /* not replayed yet, applied when it is */
    2745             : 
    2746          57 :   fd_gui_slot_t * slot = fd_gui_slot_get( gui, ent->slot, ent->bank_seq );
    2747          57 :   if( FD_UNLIKELY( !slot ) ) return;
    2748             : 
    2749          57 :   uchar notar = fd_uchar_if( ent->notarization_kind>slot->notarization_kind, ent->notarization_kind, slot->notarization_kind );
    2750          57 :   uchar final = fd_uchar_if( ent->finalization_kind>slot->finalization_kind, ent->finalization_kind, slot->finalization_kind );
    2751          57 :   uchar level = slot->level;
    2752             : 
    2753             :   /* Increase confirmation, but don't root yet since that's handled by
    2754             :      fd_gui_handle_root_advanced. */
    2755          57 :   if( FD_LIKELY( notar!=FD_GUI_AG_NOTAR_NONE || final!=FD_GUI_AG_FINAL_NONE ) ) {
    2756           0 :     level = fd_uchar_if( level<FD_GUI_SLOT_LEVEL_OPTIMISTICALLY_CONFIRMED, FD_GUI_SLOT_LEVEL_OPTIMISTICALLY_CONFIRMED, level );
    2757           0 :   }
    2758             : 
    2759          57 :   if( FD_LIKELY( notar==slot->notarization_kind && final==slot->finalization_kind && level==slot->level ) ) return;
    2760             : 
    2761           0 :   slot->notarization_kind = notar;
    2762           0 :   slot->finalization_kind = final;
    2763           0 :   slot->level             = level;
    2764             : 
    2765           0 :   fd_gui_slot_t * canon = fd_gui_slot_get_canon( gui, ent->slot );
    2766           0 :   fd_gui_printf_slot( gui, ent->slot, fd_ptr_if( !!canon, canon, slot ) );
    2767           0 :   fd_http_server_ws_broadcast( gui->http );
    2768           0 : }
    2769             : 
    2770             : static void
    2771             : fd_gui_ag_update_notarized_slot( fd_gui_t * gui,
    2772           0 :                                  ulong      slot ) {
    2773           0 :   if( FD_LIKELY( gui->summary.slot_notarized!=ULONG_MAX && slot<=gui->summary.slot_notarized ) ) return;
    2774             : 
    2775           0 :   gui->summary.slot_notarized = slot;
    2776           0 :   fd_gui_printf_notarized_slot( gui );
    2777           0 :   fd_http_server_ws_broadcast( gui->http );
    2778           0 : }
    2779             : 
    2780             : void
    2781             : fd_gui_ag_register_block( fd_gui_t *        gui,
    2782             :                           ulong             slot,
    2783             :                           fd_hash_t const * block_id,
    2784          57 :                           ulong             bank_seq ) {
    2785          57 :   if( FD_UNLIKELY( !block_id ) ) return;
    2786             : 
    2787          57 :   fd_gui_ag_slot_t * ent = fd_gui_ag_slot_entry( gui, slot );
    2788          57 :   if( FD_UNLIKELY( fd_gui_ag_slot_has_proof( ent ) && !fd_hash_eq( &ent->block_id, block_id ) ) ) return;
    2789             : 
    2790          57 :   ent->block_id = *block_id;
    2791          57 :   ent->bank_seq = bank_seq;
    2792          57 :   fd_gui_ag_slot_publish( gui, ent );
    2793          57 : }
    2794             : 
    2795             : void
    2796             : fd_gui_handle_ag_notarized( fd_gui_t *        gui,
    2797             :                             ulong             slot,
    2798             :                             fd_hash_t const * block_id,
    2799           0 :                             uchar             notarization_kind ) {
    2800           0 :   if( FD_UNLIKELY( !block_id ) ) return;
    2801             : 
    2802           0 :   fd_gui_ag_slot_t * ent = fd_gui_ag_slot_for_certificate( gui, slot, block_id );
    2803           0 :   ent->notarization_kind = fd_uchar_if( notarization_kind>ent->notarization_kind, notarization_kind, ent->notarization_kind );
    2804           0 :   fd_gui_ag_slot_publish( gui, ent );
    2805           0 :   fd_gui_ag_update_notarized_slot( gui, slot );
    2806           0 : }
    2807             : 
    2808             : void
    2809             : fd_gui_handle_ag_finalized( fd_gui_t *        gui,
    2810             :                             ulong             slot,
    2811             :                             fd_hash_t const * block_id,
    2812           0 :                             uchar             finalization_kind ) {
    2813           0 :   if( FD_UNLIKELY( !block_id ) ) return;
    2814             : 
    2815           0 :   fd_gui_ag_slot_t * ent = fd_gui_ag_slot_for_certificate( gui, slot, block_id );
    2816           0 :   ent->finalization_kind = fd_uchar_if( finalization_kind>ent->finalization_kind, finalization_kind, ent->finalization_kind );
    2817             : 
    2818             :   /* Finalization implies regular notarization. */
    2819           0 :   ent->notarization_kind = FD_GUI_AG_NOTAR_REGULAR;
    2820             : 
    2821           0 :   fd_gui_ag_slot_publish( gui, ent );
    2822           0 :   fd_gui_ag_update_notarized_slot( gui, slot );
    2823             : 
    2824           0 :   if( FD_LIKELY( gui->summary.slot_finalized==ULONG_MAX || slot>gui->summary.slot_finalized ) ) {
    2825           0 :     gui->summary.slot_finalized = slot;
    2826           0 :     fd_gui_printf_finalized_slot( gui );
    2827           0 :     fd_http_server_ws_broadcast( gui->http );
    2828           0 :   }
    2829           0 : }
    2830             : 
    2831             : void
    2832             : fd_gui_handle_ag_skip_cert( fd_gui_t * gui,
    2833           0 :                             ulong      slot ) {
    2834             : 
    2835           0 :   fd_gui_ag_slot_t * ent = fd_gui_ag_slot_entry( gui, slot );
    2836           0 :   if( FD_LIKELY( ent->skip>=FD_GUI_SKIP_STATUS_NOTARIZED ) ) return;
    2837           0 :   ent->skip = FD_GUI_SKIP_STATUS_NOTARIZED;
    2838             : 
    2839           0 :   fd_gui_printf_slot( gui, slot, fd_gui_slot_get_canon_safe( gui, slot ) );
    2840           0 :   fd_http_server_ws_broadcast( gui->http );
    2841           0 :   fd_gui_ag_update_notarized_slot( gui, slot );
    2842           0 : }
    2843             : 
    2844             : void
    2845             : fd_gui_handle_ag_leader( fd_gui_t * gui,
    2846           0 :                          ulong      parent_slot ) {
    2847           0 :   if( FD_UNLIKELY( gui->summary.slot_reset==parent_slot ) ) return;
    2848             : 
    2849           0 :   gui->summary.slot_reset = parent_slot;
    2850           0 :   fd_gui_printf_reset_slot( gui );
    2851           0 :   fd_http_server_ws_broadcast( gui->http );
    2852           0 : }
    2853             : 
    2854             : int
    2855             : fd_gui_ag_slot_is_skip_notarized( fd_gui_t const * gui,
    2856           9 :                                   ulong            slot ) {
    2857           9 :   if( FD_UNLIKELY( slot==ULONG_MAX ) ) return 0;
    2858             : 
    2859           9 :   fd_gui_ag_slot_t const * ent = &gui->ag.slot[ slot % gui->ag.slot_cnt ];
    2860           9 :   return ent->slot==slot && ent->skip>=FD_GUI_SKIP_STATUS_NOTARIZED;
    2861           9 : }
    2862             : 
    2863             : static void
    2864             : fd_gui_handle_ag_reward( fd_gui_t * gui,
    2865             :                          ulong      slot,
    2866             :                          int        voted,
    2867          57 :                          ushort     voted_rank ) {
    2868             : 
    2869          57 :   uchar vote_rewarded = fd_uchar_if( !!voted, FD_GUI_VOTE_REWARDED_YES, FD_GUI_VOTE_REWARDED_NO );
    2870          57 :   uchar is_voter = fd_uchar_if( voted_rank!=USHORT_MAX, FD_GUI_IS_VOTER_YES, FD_GUI_IS_VOTER_NO );
    2871             : 
    2872          57 :   int epoch_changed = 0;
    2873          57 :   fd_gui_epoch_t * epoch = fd_gui_get_epoch_by_slot( gui, slot );
    2874          57 :   if( FD_LIKELY( epoch ) ) {
    2875           6 :     ulong idx = slot - epoch->start_slot;
    2876           6 :     if( FD_LIKELY( idx<epoch->slot_cnt && ( epoch->vote_rewarded[ idx ]!=vote_rewarded || epoch->is_voter[ idx ]!=is_voter ) ) ) {
    2877           3 :       int was_missed = epoch->vote_rewarded[ idx ]==FD_GUI_VOTE_REWARDED_NO && epoch->is_voter[ idx ]==FD_GUI_IS_VOTER_YES;
    2878           3 :       epoch_changed = 1;
    2879           3 :       epoch->vote_rewarded[ idx ] = vote_rewarded;
    2880           3 :       epoch->is_voter[ idx ]      = is_voter;
    2881           3 :       int is_missed = vote_rewarded==FD_GUI_VOTE_REWARDED_NO && is_voter==FD_GUI_IS_VOTER_YES;
    2882             : 
    2883           3 :       if( FD_UNLIKELY( was_missed!=is_missed ) ) gui->epoch.missed_vote_history_dirty = epoch->epoch; /* coalesced into one broadcast per poll */
    2884           3 :     }
    2885           6 :   }
    2886             : 
    2887          57 :   fd_gui_slot_t * rec = fd_gui_slot_get_canon( gui, slot );
    2888          57 :   if( FD_UNLIKELY( !rec ) ) {
    2889          57 :     if( FD_UNLIKELY( epoch_changed ) ) {
    2890           3 :       fd_gui_slot_t const * skipped = fd_gui_slot_get_canon_safe( gui, slot );
    2891           3 :       if( FD_LIKELY( skipped->skip==FD_GUI_SKIP_STATUS_FINALIZED || fd_gui_ag_slot_is_skip_notarized( gui, slot ) ) ) {
    2892           0 :         fd_gui_printf_slot( gui, slot, skipped );
    2893           0 :         fd_http_server_ws_broadcast( gui->http );
    2894           0 :       }
    2895           3 :     }
    2896          57 :     return;
    2897          57 :   }
    2898             : 
    2899           0 :   int changed = rec->vote_rewarded!=vote_rewarded || rec->is_voter!=is_voter || epoch_changed;
    2900           0 :   rec->vote_rewarded = vote_rewarded;
    2901           0 :   fd_gui_slot_set_voter_state( rec, is_voter );
    2902           0 :   if( FD_UNLIKELY( !changed ) ) return;
    2903           0 :   fd_gui_printf_slot( gui, slot, rec );
    2904           0 :   fd_http_server_ws_broadcast( gui->http );
    2905           0 : }
    2906             : 
    2907             : fd_gui_timeline_granularity_t const fd_gui_timeline_granularities[ FD_GUI_TIMELINE_GRANULARITY_CNT ] = {
    2908             :   { "25ms",  25000000UL       },
    2909             :   { "50ms",  50000000UL       },
    2910             :   { "100ms", 100000000UL      },
    2911             :   { "250ms", 250000000UL      },
    2912             :   { "500ms", 500000000UL      },
    2913             :   { "1s",    1000000000UL     },
    2914             :   { "2s",    2000000000UL     },
    2915             :   { "4s",    4000000000UL     },
    2916             :   { "8s",    8000000000UL     },
    2917             :   { "15s",   15000000000UL    },
    2918             :   { "30s",   30000000000UL    },
    2919             :   { "1m",    60000000000UL    },
    2920             :   { "2m",    120000000000UL   },
    2921             :   { "4m",    240000000000UL   },
    2922             :   { "8m",    480000000000UL   },
    2923             :   { "15m",   900000000000UL   },
    2924             :   { "30m",   1800000000000UL  },
    2925             :   { "1h",    3600000000000UL  },
    2926             :   { "2h",    7200000000000UL  },
    2927             :   { "4h",    14400000000000UL },
    2928             :   { "8h",    28800000000000UL },
    2929             :   { "12h",   43200000000000UL },
    2930             :   { "1d",    86400000000000UL }
    2931             : };
    2932             : 
    2933             : ulong const fd_gui_timeline_stored_granularity_ns[ FD_GUI_TIMELINE_STORED_GRANULARITY_CNT ] = {
    2934             :   [ FD_GUI_TIMELINE_GRANULARITY_25MS  ] = 25000000UL,
    2935             :   [ FD_GUI_TIMELINE_GRANULARITY_250MS ] = 250000000UL,
    2936             :   [ FD_GUI_TIMELINE_GRANULARITY_2S    ] = 2000000000UL,
    2937             :   [ FD_GUI_TIMELINE_GRANULARITY_15S   ] = 15000000000UL,
    2938             :   [ FD_GUI_TIMELINE_GRANULARITY_2M    ] = 120000000000UL,
    2939             :   [ FD_GUI_TIMELINE_GRANULARITY_15M   ] = 900000000000UL,
    2940             :   [ FD_GUI_TIMELINE_GRANULARITY_2H    ] = 7200000000000UL,
    2941             :   [ FD_GUI_TIMELINE_GRANULARITY_12H   ] = 43200000000000UL
    2942             : };
    2943             : 
    2944             : /* Stored tiers available to each aggregate query.  The shortest tier
    2945             :    is the query's minimum granularity.  FD_GUI_TIMELINE_TIERS_DAY are
    2946             :    the tiers held by the day record. */
    2947             : 
    2948         420 : #define FD_GUI_TIMELINE_TIERS_DAY ( (1UL<<FD_GUI_TIMELINE_GRANULARITY_250MS) | (1UL<<FD_GUI_TIMELINE_GRANULARITY_2S)  | \
    2949         420 :                                    (1UL<<FD_GUI_TIMELINE_GRANULARITY_15S)   | (1UL<<FD_GUI_TIMELINE_GRANULARITY_2M)  | \
    2950         420 :                                    (1UL<<FD_GUI_TIMELINE_GRANULARITY_15M)   | (1UL<<FD_GUI_TIMELINE_GRANULARITY_2H)  | \
    2951         420 :                                    (1UL<<FD_GUI_TIMELINE_GRANULARITY_12H) )
    2952             : 
    2953             : static ulong
    2954         423 : fd_gui_timeline_tiers( char const * key ) {
    2955         423 :   if( !strcmp( key, "query_agg_cpu" ) ) return FD_GUI_TIMELINE_TIERS_DAY | (1UL<<FD_GUI_TIMELINE_GRANULARITY_25MS);
    2956         294 :   if( !strcmp( key, "query_agg_compute" ) ||
    2957         294 :       !strcmp( key, "query_agg_revenue" ) ||
    2958         294 :       !strcmp( key, "query_agg_txn"     ) ||
    2959         294 :       !strcmp( key, "query_agg_shreds"  ) ||
    2960         294 :       !strcmp( key, "query_agg_slots"   ) ) return FD_GUI_TIMELINE_TIERS_DAY;
    2961           3 :   return 0UL;
    2962         294 : }
    2963             : 
    2964             : int
    2965             : fd_gui_timeline_tier( char const * key,
    2966             :                       ulong        g,
    2967             :                       int *        stored,
    2968         426 :                       ulong *      merge_cnt ) {
    2969         426 :   if( FD_UNLIKELY( g>=FD_GUI_TIMELINE_GRANULARITY_CNT ) ) return -1;
    2970         423 :   ulong tiers = fd_gui_timeline_tiers( key );
    2971         423 :   if( FD_UNLIKELY( !tiers ) ) return -1;
    2972         420 :   ulong ns = fd_gui_timeline_granularity_ns( g );
    2973         420 :   if( FD_UNLIKELY( ns<fd_gui_timeline_stored_granularity_ns[ fd_ulong_find_lsb( tiers ) ] ) ) return -1;
    2974        2121 :   for( int t=(int)FD_GUI_TIMELINE_STORED_GRANULARITY_CNT-1; t>=0; t-- ) {
    2975        2121 :     if( !(tiers & (1UL<<t)) ) continue;
    2976        2121 :     ulong tier_ns = fd_gui_timeline_stored_granularity_ns[ t ];
    2977        2121 :     if( tier_ns>ns || ns%tier_ns ) continue;
    2978         396 :     *stored    = t;
    2979         396 :     *merge_cnt = ns/tier_ns;
    2980         396 :     return 0;
    2981        2121 :   }
    2982           0 :   return -1;
    2983         396 : }
    2984             : 
    2985             : /* fd_gui_timeline_day_end_ns returns the end timestamp of the calendar
    2986             :    day day_idx. */
    2987             : 
    2988             : static inline long
    2989         417 : fd_gui_timeline_day_end_ns( ulong day_idx ) {
    2990         417 :   if( FD_UNLIKELY( day_idx>=(ulong)LONG_MAX/(ulong)FD_GUI_TIMELINE_DAY_NS ) ) return LONG_MAX;
    2991         417 :   return (long)((day_idx+1UL)*(ulong)FD_GUI_TIMELINE_DAY_NS);
    2992         417 : }
    2993             : 
    2994             : fd_gui_timeline_day_t *
    2995             : fd_gui_timeline_day_get( fd_gui_t * gui,
    2996         348 :                          ulong      day_idx ) {
    2997         348 :   long end_time_ns = fd_gui_timeline_day_end_ns( day_idx );
    2998         348 :   if( FD_UNLIKELY( !gui->db || !gui->hist || end_time_ns==LONG_MAX ) ) return NULL;
    2999             : 
    3000         348 :   fd_gui_hist_iter_t it;
    3001         348 :   if( FD_UNLIKELY( fd_gui_hist_range_begin( gui, &it, FD_GUI_HIST_TIMELINE_DAY, end_time_ns, end_time_ns, NULL, NULL ) ) ) return NULL;
    3002         348 :   fd_gui_timeline_day_t * day = fd_gui_hist_range_next( &it ) ? (fd_gui_timeline_day_t *)it.rec : NULL;
    3003         348 :   fd_gui_hist_range_end( &it );
    3004         348 :   return day;
    3005         348 : }
    3006             : 
    3007             : /* fd_gui_timeline_cur_day returns the index of the newest day record
    3008             :    in the store, or ULONG_MAX if there is none. */
    3009             : 
    3010             : static ulong
    3011          36 : fd_gui_timeline_cur_day( fd_gui_t * gui ) {
    3012          36 :   long first, last;
    3013          36 :   if( FD_UNLIKELY( !fd_gui_store_ts_live_timestamp_bounds( gui->db, FD_GUI_HIST_TIMELINE_DAY, &first, &last ) ) ) return ULONG_MAX;
    3014           6 :   return (ulong)last/(ulong)FD_GUI_TIMELINE_DAY_NS-1UL;
    3015          36 : }
    3016             : 
    3017             : /* fd_gui_timeline_day_create_ok returns 1 if a new day record may be
    3018             :    created for day_idx, 0 otherwise. */
    3019             : 
    3020             : static inline int
    3021             : fd_gui_timeline_day_create_ok( ulong day_idx,
    3022             :                                ulong cur_day,
    3023          51 :                                long  now ) {
    3024          51 :   if( FD_UNLIKELY( fd_gui_timeline_day_end_ns( day_idx )==LONG_MAX ) ) return 0;
    3025          51 :   if( FD_UNLIKELY( now<0L || day_idx>(ulong)now/(ulong)FD_GUI_TIMELINE_DAY_NS+1UL ) ) return 0;
    3026          51 :   return cur_day==ULONG_MAX || day_idx>cur_day;
    3027          51 : }
    3028             : 
    3029             : /* fd_gui_timeline_day_create returns the record for day_idx, creating
    3030             :    an empty one if it does not exist yet. Returns NULL if the
    3031             :    day cannot be created. */
    3032             : 
    3033             : static fd_gui_timeline_day_t *
    3034             : fd_gui_timeline_day_create( fd_gui_t * gui,
    3035             :                             ulong      day_idx,
    3036          18 :                             long       now ) {
    3037          18 :   long end_time_ns = fd_gui_timeline_day_end_ns( day_idx );
    3038          18 :   if( FD_UNLIKELY( !gui->db || !gui->hist || end_time_ns==LONG_MAX ) ) return NULL;
    3039          18 :   if( FD_UNLIKELY( !fd_gui_timeline_day_create_ok( day_idx, ULONG_MAX, now ) ) ) return NULL;
    3040             : 
    3041          18 :   fd_gui_timeline_day_t * day = fd_gui_timeline_day_get( gui, day_idx );
    3042          18 :   if( day ) return day;
    3043          18 :   if( FD_UNLIKELY( !fd_gui_timeline_day_create_ok( day_idx, fd_gui_timeline_cur_day( gui ), now ) ) ) return NULL;
    3044             : 
    3045          18 :   fd_gui_timeline_day_t * seed = fd_gui_hist_ts_emplace( gui, FD_GUI_HIST_TIMELINE_DAY, end_time_ns );
    3046          18 :   if( FD_UNLIKELY( !seed ) ) return NULL;
    3047          18 :   memset( seed, 0xFF, sizeof(fd_gui_timeline_day_t) );
    3048             : 
    3049          18 :   seed->insert_time_ns  = now;
    3050          18 :   seed->end_time_ns     = end_time_ns;
    3051          18 :   return fd_gui_timeline_day_get( gui, day_idx );
    3052          18 : }
    3053             : 
    3054             : /* fd_gui_timeline_day_for_event returns the record for the day an event
    3055             :    belongs to, creating it if needed. Returns NULL if the day is unavailable. */
    3056             : 
    3057             : static fd_gui_timeline_day_t *
    3058             : fd_gui_timeline_day_for_event( fd_gui_t * gui,
    3059             :                                ulong      day_idx,
    3060          93 :                                long       now ) {
    3061          93 :   fd_gui_timeline_day_t * day = fd_gui_timeline_day_get( gui, day_idx );
    3062          93 :   if( FD_LIKELY( day ) ) return day;
    3063          18 :   if( FD_UNLIKELY( !gui->db || !gui->hist ) ) return NULL;
    3064          18 :   ulong cur_day = fd_gui_timeline_cur_day( gui );
    3065          18 :   if( FD_UNLIKELY( day_idx && (cur_day==ULONG_MAX || day_idx>cur_day+1UL) ) ) {
    3066           0 :     fd_gui_timeline_day_create( gui, day_idx-1UL, now );
    3067           0 :   }
    3068          18 :   return fd_gui_timeline_day_create( gui, day_idx, now );
    3069          18 : }
    3070             : 
    3071             : /* fd_gui_timeline_count_add adds 1 to field in the bucket containing
    3072             :    ts_ns, at every stored granularity of day. */
    3073             : 
    3074             : static void
    3075             : fd_gui_timeline_count_add( fd_gui_timeline_day_t * day,
    3076             :                            int                     field,
    3077          39 :                            long                    ts_ns ) {
    3078          39 :   ulong day_ns = (ulong)ts_ns % (ulong)FD_GUI_TIMELINE_DAY_NS;
    3079         312 :   for( int g=FD_GUI_TIMELINE_GRANULARITY_250MS; g<(int)FD_GUI_TIMELINE_STORED_GRANULARITY_CNT; g++ ) {
    3080         273 :     fd_gui_timeline_field_accum( day, g, field, day_ns/fd_gui_timeline_stored_granularity_ns[ g ], 1UL );
    3081         273 :   }
    3082          39 : }
    3083             : 
    3084             : /* fd_gui_timeline_root_block records the timeline interval of newly
    3085             :    rooted block c and of the skipped slots between c and its parent.
    3086             :    Skipped slots at or below prev_rooted were recorded by an earlier
    3087             :    root.  c must be a copy: creating day records can evict slot
    3088             :    records. */
    3089             : 
    3090             : static void
    3091             : fd_gui_timeline_root_block( fd_gui_t *            gui,
    3092             :                             fd_gui_slot_t const * c,
    3093             :                             ulong                 prev_rooted,
    3094          33 :                             long                  now ) {
    3095          33 :   long ct = c->completed_time;
    3096          33 :   long pt = c->parent_completed_time;
    3097          33 :   if( FD_UNLIKELY( ct<0L || ct==LONG_MAX || c->parent_slot>=c->slot ) ) return;
    3098          33 :   int   have_pt = pt>=0L && pt<=ct;
    3099          33 :   ulong count   = c->slot - c->parent_slot;       /* slots advanced: count-1 skipped, then c */
    3100          33 :   ulong dur     = fd_ulong_if( have_pt, (ulong)(ct-pt), 0UL );
    3101             : 
    3102          96 :   for( ulong k=1UL; k<=count; k++ ) {
    3103          63 :     ulong s = c->parent_slot + k;
    3104          63 :     if( prev_rooted!=ULONG_MAX && s<=prev_rooted ) continue;
    3105          63 :     fd_gui_epoch_t * epoch = fd_gui_get_epoch_by_slot( gui, s );
    3106          63 :     if( FD_UNLIKELY( !epoch || s<epoch->start_slot || s-epoch->start_slot>=fd_ulong_min( epoch->slot_cnt, MAX_SLOTS_PER_EPOCH ) ) ) continue;
    3107          63 :     ulong idx   = s - epoch->start_slot;
    3108          63 :     uchar state = epoch->timeline_slot_state[ idx ];
    3109          63 :     uchar flags = (uchar)(FD_GUI_TIMELINE_SLOT_STATE_VALID | (state & FD_GUI_TIMELINE_SLOT_STATE_STARTED));
    3110          63 :     long  first = (state & FD_GUI_TIMELINE_SLOT_STATE_STARTED) ? epoch->timeline_slot_first_shred_ns[ idx ] : LONG_MAX;
    3111             : 
    3112          63 :     if( k==count ) {
    3113             :       /* c landed: first shred arrival to replay completion. */
    3114          33 :       epoch->timeline_slot_start_ns[ idx ]  = first;
    3115          33 :       epoch->timeline_slot_end_ns[ idx ]    = ct;
    3116          33 :       epoch->timeline_slot_shred_cnt[ idx ] = c->shred_cnt;
    3117          33 :       epoch->timeline_slot_state[ idx ]     = (uchar)(flags | (c->mine ? FD_GUI_TIMELINE_SLOT_STATE_MINE : 0U));
    3118          33 :       fd_gui_epoch_timeline_slot_note( epoch, idx );
    3119          33 :       continue;
    3120          33 :     }
    3121             : 
    3122             :     /* s was skipped.  If a fork of it replayed, use the earliest
    3123             :        completion; otherwise give it an even share of the parent -> c
    3124             :        gap. */
    3125          30 :     long end_ns    = LONG_MAX;
    3126          30 :     uint shred_cnt = UINT_MAX;
    3127          30 :     fd_gui_hist_kv_slot_iter_t it[ 1 ];
    3128          42 :     for( fd_gui_hist_kv_iter_begin( gui, it, FD_GUI_HIST_SLOT, s ); it->rec; fd_gui_hist_kv_iter_next( it ) ) {
    3129          12 :       fd_gui_slot_t const * fork = (fd_gui_slot_t const *)it->rec;
    3130          12 :       if( fork->completed_time>=0L && fork->completed_time<end_ns ) { end_ns = fork->completed_time; shred_cnt = fork->shred_cnt; }
    3131          12 :     }
    3132          30 :     int  replayed = end_ns!=LONG_MAX;
    3133          30 :     long lo       = pt + (long)(((uint128)(k-1UL)*dur)/count);
    3134          30 :     long hi       = pt + (long)(((uint128)k*dur)/count);
    3135          30 :     epoch->timeline_slot_start_ns[ idx ]  = replayed ? first     : (have_pt ? lo : LONG_MAX);
    3136          30 :     epoch->timeline_slot_end_ns[ idx ]    = replayed ? end_ns    : (have_pt ? hi : LONG_MAX);
    3137          30 :     epoch->timeline_slot_shred_cnt[ idx ] = replayed ? shred_cnt : UINT_MAX;
    3138             :     /* Our block for s replayed but did not land.  Uses the current
    3139             :        identity, like query_events. */
    3140          30 :     int mine = replayed && fd_gui_slot_is_mine( gui, s );
    3141          30 :     epoch->timeline_slot_state[ idx ] = (uchar)(flags | FD_GUI_TIMELINE_SLOT_STATE_SKIPPED | (mine ? FD_GUI_TIMELINE_SLOT_STATE_MINE : 0U));
    3142          30 :     fd_gui_epoch_timeline_slot_note( epoch, idx );
    3143             : 
    3144             :     /* Day aggregates last, since creating a day can evict records.  A
    3145             :        skip with no parent time has no midpoint and is not counted. */
    3146          30 :     if( have_pt ) {
    3147          30 :       long mid = lo+(hi-lo)/2L;
    3148          30 :       fd_gui_timeline_day_t * day = fd_gui_timeline_day_for_event( gui, (ulong)mid/(ulong)FD_GUI_TIMELINE_DAY_NS, now );
    3149          30 :       if( day ) fd_gui_timeline_count_add( day, FD_GUI_TIMELINE_FIELD_SKIPPED, mid );
    3150          30 :     }
    3151          30 :     if( mine ) {
    3152           6 :       fd_gui_timeline_day_t * day = fd_gui_timeline_day_for_event( gui, (ulong)end_ns/(ulong)FD_GUI_TIMELINE_DAY_NS, now );
    3153           6 :       if( day ) fd_gui_timeline_count_add( day, FD_GUI_TIMELINE_FIELD_MINE_SKIPPED, end_ns );
    3154           6 :     }
    3155          30 :   }
    3156          33 : }
    3157             : 
    3158             : 
    3159             : void
    3160             : fd_gui_timeline_handle_fec( fd_gui_t * gui,
    3161             :                             ulong      slot,
    3162             :                             int        published,
    3163             :                             long       timestamp_ns,
    3164             :                             ulong      turbine,
    3165             :                             ulong      repair,
    3166             :                             ulong      reconstructed,
    3167          30 :                             long       now ) {
    3168          30 :   if( FD_UNLIKELY( slot==ULONG_MAX || timestamp_ns<0L || timestamp_ns==LONG_MAX ||
    3169          30 :                    turbine>2UL*FD_FEC_SHRED_CNT || repair>2UL*FD_FEC_SHRED_CNT ||
    3170          30 :                    reconstructed>2UL*FD_FEC_SHRED_CNT ) ) return;
    3171          12 :   fd_gui_timeline_day_t * day = fd_gui_timeline_day_for_event( gui, (ulong)timestamp_ns/(ulong)FD_GUI_TIMELINE_DAY_NS, now );
    3172          12 :   if( FD_UNLIKELY( !day ) ) return;
    3173          12 :   ulong day_ns = (ulong)timestamp_ns % (ulong)FD_GUI_TIMELINE_DAY_NS;
    3174          96 :   for( int g=FD_GUI_TIMELINE_GRANULARITY_250MS; g<(int)FD_GUI_TIMELINE_STORED_GRANULARITY_CNT; g++ ) {
    3175          84 :     ulong idx = day_ns / fd_gui_timeline_stored_granularity_ns[ g ];
    3176          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_START_SLOT,    idx, slot );
    3177          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_END_SLOT,      idx, slot );
    3178          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_TURBINE,       idx, turbine );
    3179          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_REPAIR,        idx, repair );
    3180          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_RECONSTRUCTED, idx, reconstructed );
    3181          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_PUBLISHED,     idx, published ? 2UL*FD_FEC_SHRED_CNT : 0UL );
    3182          84 :   }
    3183          12 : }
    3184             : 
    3185             : /* fd_gui_timeline_duration_credit credits one block interval to the
    3186             :    buckets of one calendar day.  The block interval is [parent,parent+gap)
    3187             :    and advances slot_units/FD_GUI_TIMELINE_SLOT_UNIT slots.  [lo,hi) is the
    3188             :    part of the interval in this day. */
    3189             : 
    3190             : static void
    3191             : fd_gui_timeline_duration_credit( fd_gui_timeline_day_t * day,
    3192             :                                  ulong                   day_start,
    3193             :                                  ulong                   lo,
    3194             :                                  ulong                   hi,
    3195             :                                  ulong                   parent,
    3196             :                                  ulong                   gap,
    3197          33 :                                  ulong                   slot_units ) {
    3198             :   /* If gap*slot_units does not fit into ulong, the function shifts the
    3199             :      time offsets and gap right by the same amount. */
    3200          33 :   int sh = 0;
    3201          69 :   while( FD_UNLIKELY( (gap>>sh)>ULONG_MAX/slot_units ) ) sh++;
    3202       29808 : #define SLOTS_AT(t) ( (((t)-parent)>>sh)*slot_units / (gap>>sh) )
    3203         264 :   for( int g=FD_GUI_TIMELINE_GRANULARITY_250MS; g<(int)FD_GUI_TIMELINE_STORED_GRANULARITY_CNT; g++ ) {
    3204         231 :     ulong w = fd_gui_timeline_stored_granularity_ns[ g ];
    3205       15135 :     for( ulong idx=(lo-day_start)/w; day_start+idx*w<hi; idx++ ) {
    3206       14904 :       ulong b0 = fd_ulong_max( lo, day_start+idx*w );
    3207       14904 :       ulong b1 = fd_ulong_min( hi, day_start+(idx+1UL)*w );
    3208       14904 :       fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_DURATION_WALL,  idx, b1-b0 );
    3209       14904 :       fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_DURATION_SLOTS, idx, SLOTS_AT( b1 )-SLOTS_AT( b0 ) );
    3210       14904 :     }
    3211         231 :   }
    3212          33 : #undef SLOTS_AT
    3213          33 : }
    3214             : 
    3215             : /* fd_gui_timeline_slot_duration spreads the slot progress of a replayed
    3216             :    block over the wall time since the completion of its parent.  If the
    3217             :    day of the block completion does not exist, the function creates it.
    3218             :    It credits earlier days in the interval only if the store keeps them.
    3219             :    If a block advances more than gui->max_consecutive_skips slots, the
    3220             :    function credits only gui->max_consecutive_skips slots.  The buckets
    3221             :    then show a slot duration that is too long, but the value is
    3222             :    finite. */
    3223             : 
    3224             : static void
    3225             : fd_gui_timeline_slot_duration( fd_gui_t *            gui,
    3226             :                                fd_gui_slot_t const * slot,
    3227          57 :                                long                  now ) {
    3228          57 :   if( FD_UNLIKELY( slot->slot==ULONG_MAX || slot->parent_slot>=slot->slot ||
    3229          57 :                   slot->parent_completed_time<0L || slot->parent_completed_time==LONG_MAX ||
    3230          57 :                   slot->completed_time==LONG_MAX || slot->completed_time<=slot->parent_completed_time ) ) return;
    3231          30 :   if( FD_UNLIKELY( !gui->db || !gui->hist ) ) return;
    3232             :   /* Store operations can evict slot.  After this point, use only local
    3233             :      copies. */
    3234          30 :   ulong parent    = (ulong)slot->parent_completed_time;
    3235          30 :   ulong completed = (ulong)slot->completed_time;
    3236          30 :   ulong slot_units = fd_ulong_min( slot->slot-slot->parent_slot, gui->max_consecutive_skips )*FD_GUI_TIMELINE_SLOT_UNIT;
    3237          30 :   ulong last_day  = (completed-1UL)/(ulong)FD_GUI_TIMELINE_DAY_NS;
    3238          30 :   if( FD_UNLIKELY( !fd_gui_timeline_day_for_event( gui, last_day, now ) ) ) return;
    3239             : 
    3240             :   /* Do not look up days that are older than the oldest retained day. */
    3241          30 :   long first, last;
    3242          30 :   if( FD_UNLIKELY( !fd_gui_store_ts_live_timestamp_bounds( gui->db, FD_GUI_HIST_TIMELINE_DAY, &first, &last ) ) ) return;
    3243          30 :   ulong first_day = fd_ulong_max( parent/(ulong)FD_GUI_TIMELINE_DAY_NS, (ulong)first/(ulong)FD_GUI_TIMELINE_DAY_NS-1UL );
    3244          63 :   for( ulong d=first_day; d<=last_day; d++ ) {
    3245          33 :     fd_gui_timeline_day_t * day = fd_gui_timeline_day_get( gui, d );
    3246          33 :     if( FD_UNLIKELY( !day ) ) continue;
    3247          33 :     ulong day_start = d*(ulong)FD_GUI_TIMELINE_DAY_NS;
    3248          33 :     ulong lo        = fd_ulong_max( parent,    day_start );
    3249          33 :     ulong hi        = fd_ulong_min( completed, day_start+(ulong)FD_GUI_TIMELINE_DAY_NS );
    3250          33 :     fd_gui_timeline_duration_credit( day, day_start, lo, hi, parent, completed-parent, slot_units );
    3251          33 :   }
    3252          30 : }
    3253             : 
    3254             : static void
    3255             : fd_gui_timeline_handle_txn( fd_gui_t * gui,
    3256             :                             ulong      slot,
    3257             :                             long       timestamp_ns,
    3258             :                             ulong      compute_units,
    3259             :                             ulong      max_compute_units,
    3260             :                             ulong      transaction_fee,
    3261             :                             ulong      priority_fee,
    3262             :                             ulong      tips,
    3263             :                             int        txn_succeeded,
    3264          12 :                             long       now ) {
    3265          12 :   if( FD_UNLIKELY( slot==ULONG_MAX || timestamp_ns<0L || timestamp_ns==LONG_MAX ) ) return;
    3266          12 :   fd_gui_timeline_day_t * day = fd_gui_timeline_day_for_event( gui, (ulong)timestamp_ns/(ulong)FD_GUI_TIMELINE_DAY_NS, now );
    3267          12 :   if( FD_UNLIKELY( !day ) ) return;
    3268          12 :   ulong day_ns = (ulong)timestamp_ns % (ulong)FD_GUI_TIMELINE_DAY_NS;
    3269          96 :   for( int g=FD_GUI_TIMELINE_GRANULARITY_250MS; g<(int)FD_GUI_TIMELINE_STORED_GRANULARITY_CNT; g++ ) {
    3270          84 :     ulong idx = day_ns / fd_gui_timeline_stored_granularity_ns[ g ];
    3271          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_START_SLOT,       idx, slot );
    3272          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_END_SLOT,         idx, slot );
    3273          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_COMPUTE_UNITS,    idx, compute_units );
    3274          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_MAX_COMPUTE,      idx, max_compute_units );
    3275          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_TXN_FEES,         idx, transaction_fee );
    3276          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_PRIO_FEES,        idx, priority_fee );
    3277          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_TIPS,             idx, tips );
    3278          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_NONVOTE_SUCCESS,  idx, !!txn_succeeded );
    3279          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_NONVOTE_FAILED,   idx, !txn_succeeded );
    3280          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_VOTE_SUCCESS,     idx, 0UL );
    3281          84 :     fd_gui_timeline_field_accum( day, g, FD_GUI_TIMELINE_FIELD_VOTE_FAILED,      idx, 0UL );
    3282          84 :   }
    3283          12 : }
    3284             : 
    3285             : static int
    3286             : fd_gui_timeline_mine_add( fd_gui_t * gui,
    3287             :                           long       timestamp_ns,
    3288           3 :                           long       now ) {
    3289           3 :   if( FD_UNLIKELY( timestamp_ns<0L || timestamp_ns==LONG_MAX ) ) return 0;
    3290           3 :   fd_gui_timeline_day_t * day = fd_gui_timeline_day_for_event( gui, (ulong)timestamp_ns/(ulong)FD_GUI_TIMELINE_DAY_NS, now );
    3291           3 :   if( FD_UNLIKELY( !day ) ) return 0;
    3292           3 :   fd_gui_timeline_count_add( day, FD_GUI_TIMELINE_FIELD_MINE, timestamp_ns );
    3293           3 :   return 1;
    3294           3 : }
    3295             : 
    3296             : fd_gui_timeline_tile_day_t *
    3297             : fd_gui_timeline_tile_day_get( fd_gui_t * gui,
    3298             :                               ulong      day_idx,
    3299        1590 :                               ulong      tile_idx ) {
    3300        1590 :   if( FD_UNLIKELY( !gui->db || !gui->hist ) ) return NULL;
    3301        1590 :   fd_gui_hist_tile_day_key_t key = { .day_idx=day_idx, .tile_idx=tile_idx };
    3302        1590 :   return fd_gui_hist_kv_get( gui, FD_GUI_HIST_TIMELINE_TILE_DAY, &key );
    3303        1590 : }
    3304             : 
    3305             : int
    3306             : fd_gui_timeline_tile_day_bounds( fd_gui_t * gui,
    3307             :                                  ulong *    lo_day,
    3308          42 :                                  ulong *    hi_day ) {
    3309          42 :   if( FD_UNLIKELY( !gui->db || !gui->hist ) ) return 0;
    3310          42 :   ulong lo = ULONG_MAX;
    3311          42 :   ulong hi = 0UL;
    3312          42 :   fd_gui_store_kv_scan_t it;
    3313          42 :   fd_gui_store_kv_scan_begin( gui->db, &it, FD_GUI_HIST_TIMELINE_TILE_DAY );
    3314         147 :   while( fd_gui_store_kv_scan_next( &it ) ) {
    3315         105 :     fd_gui_hist_tile_day_key_t const * key = it.rec; /* records start with their key */
    3316         105 :     lo = fd_ulong_min( lo, key->day_idx );
    3317         105 :     hi = fd_ulong_max( hi, key->day_idx );
    3318         105 :   }
    3319          42 :   if( lo==ULONG_MAX ) return 0;
    3320          39 :   *lo_day = lo;
    3321          39 :   *hi_day = hi;
    3322          39 :   return 1;
    3323          42 : }
    3324             : 
    3325             : /* fd_gui_timeline_tile_day_create creates the empty CPU record of
    3326             :    tile_idx for day_idx, which must not exist yet, under the same day
    3327             :    rules as the timeline day records.  Returns NULL if the day is
    3328             :    unavailable.  The ring's base regions hold today's and yesterday's
    3329             :    record for every tile, so today's records are never evicted (see
    3330             :    fd_gui_hist_base_regions). */
    3331             : 
    3332             : static fd_gui_timeline_tile_day_t *
    3333             : fd_gui_timeline_tile_day_create( fd_gui_t * gui,
    3334             :                                  ulong      day_idx,
    3335             :                                  ulong      tile_idx,
    3336          15 :                                  long       now ) {
    3337          15 :   if( FD_UNLIKELY( !gui->db || !gui->hist ) ) return NULL;
    3338          15 :   ulong * cur_day = &gui->cpu_util.cur_day;
    3339          15 :   if( FD_UNLIKELY( *cur_day==ULONG_MAX ) ) {
    3340           3 :     ulong lo;
    3341           3 :     if( !fd_gui_timeline_tile_day_bounds( gui, &lo, cur_day ) ) *cur_day = ULONG_MAX;
    3342           3 :   }
    3343             :   /* Other tiles may still join the newest day; earlier days are closed. */
    3344          15 :   ulong closed_day = *cur_day==ULONG_MAX || !*cur_day ? ULONG_MAX : *cur_day-1UL;
    3345          15 :   if( FD_UNLIKELY( !fd_gui_timeline_day_create_ok( day_idx, closed_day, now ) ) ) return NULL;
    3346             : 
    3347          15 :   fd_gui_hist_tile_day_key_t key = { .day_idx=day_idx, .tile_idx=tile_idx };
    3348          15 :   fd_gui_timeline_tile_day_t * rec = fd_gui_hist_kv_get_or_create( gui, FD_GUI_HIST_TIMELINE_TILE_DAY, &key );
    3349          15 :   if( FD_UNLIKELY( !rec ) ) return NULL;
    3350             :   /* Creation can evict records, but never the newly reserved one.  The
    3351             :      store sets the key; every other byte is written once. */
    3352          15 :   rec->insert_time_ns = now;
    3353          15 :   memset( rec->util_25ms, FD_GUI_CPU_UTIL_UNKNOWN, sizeof(rec->util_25ms) );
    3354          15 :   memset( rec->sum_250MS, 0, sizeof(fd_gui_timeline_tile_day_t)-offsetof( fd_gui_timeline_tile_day_t, sum_250MS ) );
    3355          15 :   *cur_day = fd_ulong_max( *cur_day==ULONG_MAX ? 0UL : *cur_day, day_idx );
    3356          15 :   return rec;
    3357          15 : }
    3358             : 
    3359             : void
    3360         492 : fd_gui_cpu_util_snap( fd_gui_t * gui, long now ) {
    3361         492 :   if( FD_UNLIKELY( now<FD_GUI_CPU_UTIL_SAMPLE_NS ) ) return;
    3362         492 :   ulong slot = (ulong)now/(ulong)FD_GUI_CPU_UTIL_SAMPLE_NS - 1UL;
    3363         492 :   if( FD_UNLIKELY( gui->cpu_util.last_slot!=ULONG_MAX && slot<=gui->cpu_util.last_slot ) ) return;
    3364         492 :   gui->cpu_util.last_slot = slot;
    3365             : 
    3366         492 :   ulong start_ns = slot*(ulong)FD_GUI_CPU_UTIL_SAMPLE_NS;
    3367         492 :   ulong day_idx  = start_ns/(ulong)FD_GUI_TIMELINE_DAY_NS;
    3368         492 :   ulong day_ns   = start_ns%(ulong)FD_GUI_TIMELINE_DAY_NS;
    3369         492 :   ulong create_cnt = 0UL;
    3370       22140 :   for( ulong i=0UL; i<gui->tile_cnt; i++ ) {
    3371       21648 :     fd_topo_tile_t const * tile = &gui->topo->tiles[ i ];
    3372       21648 :     if( FD_UNLIKELY( !tile->metrics ) ) continue;
    3373         984 :     volatile ulong const * live = fd_metrics_tile( tile->metrics ) + MIDX( COUNTER, TILE, REGIME_DURATION_NANOS );
    3374         984 :     ulong timers[ FD_METRICS_ENUM_TILE_REGIME_CNT ];
    3375       10824 :     for( ulong j=0UL; j<FD_METRICS_ENUM_TILE_REGIME_CNT; j++ ) timers[ j ] = live[ j ];
    3376         984 :     ulong total = fd_metrics_enum_group_sum( timers, (1UL<<FD_METRICS_ENUM_TILE_REGIME_CNT)-1UL );
    3377         984 :     ulong idle  = fd_metrics_enum_group_sum( timers, FD_METRICS_ENUM_TILE_REGIME_G_IDLE_MASK | FD_METRICS_ENUM_TILE_REGIME_G_BACKPRESSURE_MASK );
    3378         984 :     ulong dt    = total - gui->cpu_util.total[ i ];
    3379         984 :     ulong di    = idle  - gui->cpu_util.idle [ i ];
    3380             :     /* A tile that has not published since the last sample keeps its
    3381             :        reference, so its next sample covers the whole gap. */
    3382         984 :     if( FD_UNLIKELY( !dt ) ) continue;
    3383         741 :     if( FD_UNLIKELY( !gui->cpu_util.total[ i ] ) ) {
    3384           6 :       gui->cpu_util.total[ i ] = total;
    3385           6 :       gui->cpu_util.idle [ i ] = idle;
    3386           6 :       continue;
    3387           6 :     }
    3388             : 
    3389             :     /* Creating a record writes several MiB, so a day rollover is
    3390             :        spread over ticks. */
    3391         735 :     fd_gui_timeline_tile_day_t * rec = fd_gui_timeline_tile_day_get( gui, day_idx, i );
    3392         735 :     if( FD_UNLIKELY( !rec ) ) {
    3393          21 :       if( FD_UNLIKELY( create_cnt>=FD_GUI_CPU_UTIL_CREATE_MAX ) ) continue;
    3394          15 :       create_cnt++;
    3395          15 :       rec = fd_gui_timeline_tile_day_create( gui, day_idx, i, now );
    3396          15 :     }
    3397         729 :     gui->cpu_util.total[ i ] = total;
    3398         729 :     gui->cpu_util.idle [ i ] = idle;
    3399         729 :     if( FD_UNLIKELY( !rec ) ) continue;
    3400         729 :     ulong busy = dt - fd_ulong_min( di, dt );
    3401         729 :     uchar util = (uchar)( ( busy*FD_GUI_CPU_UTIL_MAX + dt/2UL )/dt );
    3402         729 :     ulong idx = day_ns/(ulong)FD_GUI_CPU_UTIL_SAMPLE_NS;
    3403         729 :     if( FD_UNLIKELY( rec->util_25ms[ idx ]!=FD_GUI_CPU_UTIL_UNKNOWN ) ) continue; /* already sampled */
    3404         729 :     rec->util_25ms[ idx ] = util;
    3405         729 :     fd_gui_timeline_cpu_add( rec, day_ns, util );
    3406         729 :   }
    3407         492 : }
    3408             : 
    3409             : void
    3410             : fd_gui_handle_genesis_hash( fd_gui_t *        gui,
    3411           0 :                             fd_hash_t const * msg ) {
    3412           0 :   FD_BASE58_ENCODE_32_BYTES( msg->uc, hash_cstr );
    3413           0 :   ulong cluster = fd_genesis_cluster_identify(hash_cstr);
    3414           0 :   char const * cluster_name = fd_genesis_cluster_name(cluster);
    3415             : 
    3416           0 :   if( FD_LIKELY( strcmp( gui->summary.cluster, cluster_name ) ) ) {
    3417           0 :     gui->summary.cluster = fd_genesis_cluster_name(cluster);
    3418           0 :     fd_gui_printf_cluster( gui );
    3419           0 :     fd_http_server_ws_broadcast( gui->http );
    3420           0 :   }
    3421           0 : }
    3422             : 
    3423             : void
    3424             : fd_gui_handle_block_engine_update( fd_gui_t *                              gui,
    3425           0 :                                    fd_bundle_block_engine_update_t const * update ) {
    3426           0 :   gui->block_engine.has_block_engine = 1;
    3427             : 
    3428             :   /* copy strings and ensure null termination within bounds */
    3429           0 :   FD_TEST( fd_cstr_nlen( update->name,    sizeof(gui->block_engine.name   ) ) < sizeof(gui->block_engine.name   ) );
    3430           0 :   FD_TEST( fd_cstr_nlen( update->url,     sizeof(gui->block_engine.url    ) ) < sizeof(gui->block_engine.url    ) );
    3431           0 :   FD_TEST( fd_cstr_nlen( update->ip_cstr, sizeof(gui->block_engine.ip_cstr) ) < sizeof(gui->block_engine.ip_cstr) );
    3432           0 :   ulong name_len    = fd_cstr_nlen( update->name,    sizeof(gui->block_engine.name   ) );
    3433           0 :   ulong url_len     = fd_cstr_nlen( update->url,     sizeof(gui->block_engine.url    ) );
    3434           0 :   ulong ip_cstr_len = fd_cstr_nlen( update->ip_cstr, sizeof(gui->block_engine.ip_cstr) );
    3435           0 :   fd_memcpy( gui->block_engine.name,    update->name,    name_len+1UL );
    3436           0 :   fd_memcpy( gui->block_engine.url,     update->url,     url_len+1UL );
    3437           0 :   fd_memcpy( gui->block_engine.ip_cstr, update->ip_cstr, ip_cstr_len+1UL );
    3438             : 
    3439           0 :   fd_gui_printf_block_engine( gui );
    3440           0 :   fd_http_server_ws_broadcast( gui->http );
    3441           0 : }
    3442             : 
    3443             : void
    3444             : fd_gui_handle_snapshot_update( fd_gui_t *                 gui,
    3445           0 :                                fd_snapct_update_t const * msg ) {
    3446           0 :   FD_TEST( msg && fd_cstr_nlen( msg->read_path, 1 ) );
    3447             : 
    3448           0 :   ulong prev_slot = fd_gui_boot_snapshot_slot( gui );
    3449           0 :   if( msg->type==FD_SNAPCT_SNAPSHOT_TYPE_FULL ) {
    3450           0 :     gui->summary.boot_progress.loading_snapshot[ FD_GUI_BOOT_PROGRESS_INCREMENTAL_SNAPSHOT_IDX ].slot = ULONG_MAX;
    3451           0 :     gui->summary.boot_progress.loading_snapshot[ FD_GUI_BOOT_PROGRESS_INCREMENTAL_SNAPSHOT_IDX ].read_path[ 0 ] = '\0';
    3452           0 :   }
    3453             : 
    3454           0 :   ulong snapshot_idx = fd_ulong_if( msg->type==FD_SNAPCT_SNAPSHOT_TYPE_FULL, FD_GUI_BOOT_PROGRESS_FULL_SNAPSHOT_IDX, FD_GUI_BOOT_PROGRESS_INCREMENTAL_SNAPSHOT_IDX );
    3455             : 
    3456           0 :   char const * filename = strrchr( msg->read_path, '/' );
    3457             : 
    3458             :   /* Skip the '/'  */
    3459           0 :   if( FD_LIKELY( filename ) ) filename++;
    3460           0 :   else                        filename = msg->read_path;
    3461             : 
    3462           0 :   if (msg->type == FD_SNAPCT_SNAPSHOT_TYPE_INCREMENTAL) {
    3463           0 :       ulong slot1, slot2;
    3464           0 :       if ( FD_LIKELY( sscanf( filename, "incremental-snapshot-%lu-%lu-", &slot1, &slot2 )==2 ) )
    3465           0 :         gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].slot = slot2;
    3466           0 :       else FD_LOG_ERR(("failed to scan filename: %s parsed from %s", filename, msg->read_path ));
    3467           0 :   } else if (msg->type == FD_SNAPCT_SNAPSHOT_TYPE_FULL) {
    3468           0 :       ulong slot1;
    3469           0 :       if ( FD_LIKELY( sscanf( filename, "snapshot-%lu-", &slot1 )==1 ) )
    3470           0 :         gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].slot = slot1;
    3471           0 :       else FD_LOG_ERR(("failed to scan filename: %s parsed from %s", filename, msg->read_path ));
    3472           0 :   }
    3473             : 
    3474           0 :   if( prev_slot!=fd_gui_boot_snapshot_slot( gui ) ) gui->summary.boot_progress.boot_target_slot_duration_nanos = ULONG_MAX;
    3475             : 
    3476           0 :   fd_cstr_printf_check( gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].read_path, sizeof(gui->summary.boot_progress.loading_snapshot[ snapshot_idx ].read_path), NULL, "%s", msg->read_path );
    3477           0 :   fd_gui_update_boot_epoch_duration( gui );
    3478           0 : }
    3479             : 
    3480             : void
    3481             : fd_gui_handle_snapsv_update( fd_gui_t *              gui,
    3482             :                              ulong                   sig,
    3483             :                              fd_snapsv_msg_t const * msg,
    3484             :                              ulong                   sz,
    3485             :                              int                     eom,
    3486           0 :                              long                    now ) {
    3487           0 :   if( FD_UNLIKELY( sig!=FD_SNAPSV_MSG_SNAP || sz!=sizeof(fd_snapsv_msg_snap_t) ) ) return;
    3488           0 :   if( FD_UNLIKELY( gui->snapsv.pending_cnt>=FD_GUI_SNAPSV_PENDING_MAX ) ) return;
    3489           0 :   fd_gui_snapsv_pending_t * pending = &gui->snapsv.pending[ gui->snapsv.pending_cnt++ ];
    3490           0 :   pending->msg               = msg->snap;
    3491           0 :   pending->sample_time_nanos = now;
    3492           0 :   pending->closed            = eom;
    3493           0 : }
    3494             : 
    3495             : void
    3496             : fd_gui_stage_snapshot_manifest( fd_gui_t *                    gui,
    3497           0 :                                  fd_snapshot_manifest_t const * manifest ) {
    3498           0 :   ulong attempt = 0UL;
    3499           0 :   for( ulong i=0UL; i<manifest->hard_fork_cnt; i++ ) {
    3500           0 :     if( FD_UNLIKELY( manifest->hard_forks[ i ].slot==manifest->slot ) ) {
    3501           0 :       attempt = manifest->hard_forks[ i ].cnt;
    3502           0 :       break;
    3503           0 :     }
    3504           0 :   }
    3505           0 :   gui->summary.boot_progress.wfs_attempt = attempt;
    3506           0 : }
    3507             : 
    3508             : static void
    3509             : fd_gui_broadcast_skip_rate( fd_gui_t * gui,
    3510          60 :                             ulong      epoch ) {
    3511          60 :   fd_gui_epoch_t const * rec = fd_gui_epoch( gui, epoch );
    3512          60 :   if( FD_UNLIKELY( !rec ) ) return;
    3513             : 
    3514           9 :   ulong slot = epoch % 2UL;
    3515           9 :   if( FD_LIKELY( gui->summary.skip_rate[ slot ].epoch  ==epoch
    3516           9 :               && gui->summary.skip_rate[ slot ].skipped==rec->my_skipped_slots
    3517           9 :               && gui->summary.skip_rate[ slot ].total  ==rec->my_total_slots ) ) return;
    3518             : 
    3519           3 :   gui->summary.skip_rate[ slot ].epoch   = epoch;
    3520           3 :   gui->summary.skip_rate[ slot ].skipped = rec->my_skipped_slots;
    3521           3 :   gui->summary.skip_rate[ slot ].total   = rec->my_total_slots;
    3522             : 
    3523           3 :   fd_gui_printf_skip_rate( gui, epoch );
    3524           3 :   fd_http_server_ws_broadcast( gui->http );
    3525           3 : }
    3526             : 
    3527             : /* Returns 1 if the frontier was updated, and 0 otherwise. */
    3528             : 
    3529             : static int
    3530          57 : handle_tower_slot( fd_gui_t * gui, ulong reset_slot, ulong reset_bank_seq, long now FD_PARAM_UNUSED ) {
    3531          57 :   FD_TEST( reset_slot!=ULONG_MAX );
    3532             : 
    3533          57 :   ulong prev_reset_slot     = gui->summary.slot_tower;
    3534          57 :   ulong prev_reset_bank_seq = gui->summary.slot_tower_bank_seq;
    3535             : 
    3536             :   /* Alpenglow drives this from replay completion rather than a
    3537             :      consensus-derived reset slot, so the record is not guaranteed. */
    3538          57 :   if( FD_UNLIKELY( !fd_gui_slot_get( gui, reset_slot, reset_bank_seq ) ) ) return 0;
    3539             : 
    3540             :   /* reset_slot has not changed */
    3541          57 :   if( FD_UNLIKELY( prev_reset_slot!=ULONG_MAX && reset_slot==prev_reset_slot && reset_bank_seq==prev_reset_bank_seq ) ) return 0;
    3542             : 
    3543             :   /* Alpenglow can complete a descendant before one of its ancestors.
    3544             :      Keep advertising the highest completed block on that fork. */
    3545          27 :   if( FD_UNLIKELY( prev_reset_slot!=ULONG_MAX && fd_gui_slot_is_ancestor( gui, reset_slot, reset_bank_seq, prev_reset_slot, prev_reset_bank_seq ) ) ) return 0;
    3546             : 
    3547          27 :   gui->summary.slot_tower          = reset_slot;
    3548          27 :   gui->summary.slot_tower_bank_seq = reset_bank_seq;
    3549             : 
    3550          27 :   fd_gui_printf_completed_slot( gui );
    3551          27 :   fd_http_server_ws_broadcast( gui->http );
    3552             : 
    3553             :   /* ensure a history exists */
    3554          27 :   if( FD_UNLIKELY( prev_reset_slot==ULONG_MAX || gui->summary.slot_rooted==ULONG_MAX ) ) return 1;
    3555             : 
    3556             :   /* Switch forks. */
    3557          27 :   fd_gui_slot_t const * oc = fd_gui_slot_get( gui, prev_reset_slot, prev_reset_bank_seq );
    3558          27 :   fd_gui_slot_t const * nc = fd_gui_slot_get( gui, reset_slot,      reset_bank_seq      );
    3559          30 :   for( ulong slot=fd_ulong_max( gui->summary.slot_tower, prev_reset_slot ); slot>gui->summary.slot_rooted; slot-- ) {
    3560           3 :     while( oc && oc->slot>slot ) oc = fd_gui_slot_parent_get( gui, oc );
    3561           3 :     while( nc && nc->slot>slot ) nc = fd_gui_slot_parent_get( gui, nc );
    3562           3 :     ulong obank = oc && oc->slot==slot ? oc->bank_seq : ULONG_MAX;
    3563           3 :     ulong nbank = nc && nc->slot==slot ? nc->bank_seq : ULONG_MAX;
    3564             : 
    3565           3 :     int skipped_old = slot<=prev_reset_slot && fd_gui_slot_is_skipped( gui, gui->summary.slot_rooted, prev_reset_slot, prev_reset_bank_seq, slot );
    3566           3 :     int skipped_new = slot<=gui->summary.slot_tower && fd_gui_slot_is_skipped( gui, gui->summary.slot_rooted, gui->summary.slot_tower, reset_bank_seq, slot );
    3567           3 :     if( FD_LIKELY( skipped_old!=skipped_new ) ) {
    3568           0 :       fd_gui_epoch_t * epoch = fd_gui_get_epoch_by_slot( gui, slot );
    3569           0 :       if( FD_LIKELY( epoch && fd_gui_slot_is_mine( gui, slot ) ) ) {
    3570           0 :         if( skipped_new ) epoch->my_skipped_slots = fd_ulong_sat_add( epoch->my_skipped_slots, 1UL );
    3571           0 :         else              epoch->my_skipped_slots = fd_ulong_sat_sub( epoch->my_skipped_slots, 1UL );
    3572           0 :       }
    3573           0 :     }
    3574             : 
    3575             :     /* Publish new/changed slots */
    3576           3 :     if( FD_LIKELY( skipped_old!=skipped_new || slot>prev_reset_slot || obank!=nbank ) ) {
    3577           3 :       fd_gui_printf_slot( gui, slot, fd_gui_slot_get_canon_safe( gui, slot ) );
    3578           3 :       fd_http_server_ws_broadcast( gui->http );
    3579           3 :     }
    3580             : 
    3581             :     /* Persist skip status */
    3582           3 :     fd_gui_slot_t * canon = fd_gui_slot_get_canon( gui, slot );
    3583           3 :     ulong canon_bank_seq = canon ? canon->bank_seq : ULONG_MAX; /* canon, if any, IS slot */
    3584           3 :     fd_gui_hist_kv_slot_iter_t it[ 1 ];
    3585           6 :     for( fd_gui_hist_kv_iter_begin( gui, it, FD_GUI_HIST_SLOT, slot ); it->rec; fd_gui_hist_kv_iter_next( it ) ) {
    3586           3 :       ((fd_gui_slot_t *)it->rec)->skip = fd_uchar_if( it->bank_seq==canon_bank_seq, FD_GUI_SKIP_STATUS_NOT_SKIPPED, FD_GUI_SKIP_STATUS_FINALIZED );
    3587           3 :     }
    3588           3 :   }
    3589             : 
    3590          81 :   for( ulong e=gui->epoch.current_epoch; e<=gui->epoch.current_epoch+1UL; e++ ) fd_gui_broadcast_skip_rate( gui, e );
    3591          27 :   return 1;
    3592          27 : }
    3593             : 
    3594             : static inline void
    3595             : set_vote_state( fd_gui_t * gui,
    3596           0 :                 int        vote_state ) {
    3597           0 :   if( FD_UNLIKELY( gui->summary.vote_state!=vote_state ) ) {
    3598           0 :     gui->summary.vote_state = vote_state;
    3599           0 :     fd_gui_printf_vote_state( gui );
    3600           0 :     fd_http_server_ws_broadcast( gui->http );
    3601           0 :   }
    3602           0 : }
    3603             : 
    3604             : static long
    3605             : fd_gui_tick_to_nanos( fd_gui_t const * gui,
    3606             :                       long             now,
    3607             :                       long             tick_now,
    3608          99 :                       long             tick ) {
    3609          99 :   if( tick==LONG_MAX ) return LONG_MAX;
    3610          63 :   return fd_long_sat_add( now, (long)((double)fd_long_sat_sub( tick, tick_now )/gui->tick_per_ns) );
    3611          99 : }
    3612             : 
    3613             : static void
    3614             : fd_gui_record_replay_txn( fd_gui_t *                        gui,
    3615          15 :                           fd_gui_store_replay_txn_t const * rec ) {
    3616          15 :   int   landed     = !!rec->is_committable;
    3617          15 :   int   fees_paid  = landed && rec->error_code!=5U && rec->error_code!=6U;
    3618          15 :   int   tips_paid  = landed && !rec->error_code;
    3619          15 :   ulong txn_fee    = fees_paid ? rec->transaction_fee : 0UL;
    3620          15 :   ulong prio_fee   = fees_paid ? rec->priority_fee    : 0UL;
    3621          15 :   ulong tips       = tips_paid ? rec->tips            : 0UL;
    3622             : 
    3623          15 :   if( FD_LIKELY( landed ) ) fd_gui_timeline_handle_txn( gui, rec->slot, rec->commit_end_ns, rec->compute_units_consumed,
    3624          12 :                                                         rec->block_compute_unit_limit, txn_fee, prio_fee,
    3625          12 :                                                         tips, !rec->error_code, rec->insert_time_ns );
    3626          15 :   fd_gui_hist_ts_append( gui, FD_GUI_HIST_REPLAY_TXN, rec );
    3627          15 : }
    3628             : 
    3629             : void
    3630             : fd_gui_handle_replay_txn( fd_gui_t *                       gui,
    3631             :                           fd_replay_txn_executed_t const * txn,
    3632          15 :                           long                             now ) {
    3633          15 :   if( FD_UNLIKELY( !gui->db || !gui->hist || txn->tick_sigverify_done==LONG_MAX || txn->tick_commit_end==LONG_MAX ) ) return;
    3634          12 :   long  tick_now   = fd_tickcount();
    3635          12 :   ulong requested  = fd_pack_compute_cost( TXN( txn->txn ), txn->txn->payload, NULL, NULL, NULL, NULL, NULL );
    3636          12 :   fd_gui_store_replay_txn_t rec = {
    3637          12 :     .insert_time_ns           = now,
    3638          12 :     .completion_time_ns       = fd_gui_tick_to_nanos( gui, now, tick_now, fd_long_max( txn->tick_sigverify_done, txn->tick_commit_end ) ),
    3639          12 :     .block_compute_unit_limit = txn->max_compute_units,
    3640          12 :     .slot                     = txn->slot,
    3641          12 :     .txn_idx                  = txn->index_in_slot,
    3642          12 :     .txn_exec_idx             = txn->exec_tile_idx,
    3643          12 :     .txn_sigverify_exec_idx   = txn->sigverify_exec_tile_idx,
    3644          12 :     .txn_start_shred_idx      = txn->txn->start_shred_idx,
    3645          12 :     .txn_end_shred_idx        = txn->txn->end_shred_idx,
    3646          12 :     .sigverify_start_ns       = fd_gui_tick_to_nanos( gui, now, tick_now, txn->tick_sigverify_disp ),
    3647          12 :     .sigverify_end_ns         = fd_gui_tick_to_nanos( gui, now, tick_now, txn->tick_sigverify_done ),
    3648          12 :     .load_start_ns            = fd_gui_tick_to_nanos( gui, now, tick_now, txn->tick_load_start ),
    3649          12 :     .check_start_ns           = fd_gui_tick_to_nanos( gui, now, tick_now, txn->tick_check_start ),
    3650          12 :     .exec_start_ns            = fd_gui_tick_to_nanos( gui, now, tick_now, txn->tick_exec_start ),
    3651          12 :     .commit_start_ns          = fd_gui_tick_to_nanos( gui, now, tick_now, txn->tick_commit_start ),
    3652          12 :     .commit_end_ns            = fd_gui_tick_to_nanos( gui, now, tick_now, txn->tick_commit_end ),
    3653          12 :     .transaction_fee          = txn->transaction_fee,
    3654          12 :     .priority_fee             = txn->priority_fee,
    3655          12 :     .tips                     = txn->tips,
    3656          12 :     .compute_units_requested  = (uint)requested,
    3657          12 :     .compute_units_consumed   = txn->compute_units_consumed,
    3658          12 :     .error_code               = (uint)(-(long)txn->txn_err),
    3659          12 :     .is_committable           = (uchar)!!txn->is_committable,
    3660          12 :     .is_fees_only             = (uchar)!!txn->is_fees_only,
    3661          12 :   };
    3662          12 :   fd_memcpy( rec.signature, txn->txn->payload+TXN( txn->txn )->signature_off, FD_TXN_SIGNATURE_SZ );
    3663          12 :   fd_gui_record_replay_txn( gui, &rec );
    3664          12 : }
    3665             : 
    3666             : void
    3667             : fd_gui_handle_replay_update( fd_gui_t *                         gui,
    3668             :                              fd_replay_slot_completed_t const * slot_completed,
    3669          57 :                              long                               now ) {
    3670          57 :   fd_gui_shred_event_slot_complete( gui, slot_completed->slot, slot_completed->completion_time_nanos, now );
    3671             : 
    3672          57 :   if( FD_LIKELY( gui->summary.slot_storage!=slot_completed->storage_slot ) ) {
    3673           0 :     gui->summary.slot_storage = slot_completed->storage_slot;
    3674           0 :     fd_gui_printf_storage_slot( gui );
    3675           0 :     fd_http_server_ws_broadcast( gui->http );
    3676           0 :   }
    3677             : 
    3678          57 :   if( FD_UNLIKELY( slot_completed->identity_balance!=ULONG_MAX && gui->summary.identity_account_balance!=slot_completed->identity_balance ) ) {
    3679           0 :     gui->summary.identity_account_balance = slot_completed->identity_balance;
    3680             : 
    3681           0 :     fd_gui_printf_identity_balance( gui );
    3682           0 :     fd_http_server_ws_broadcast( gui->http );
    3683           0 :   }
    3684             : 
    3685          57 :   if( FD_UNLIKELY( gui->summary.boot_progress.catching_up_first_replay_slot==ULONG_MAX ) ) {
    3686           0 :     gui->summary.boot_progress.catching_up_first_replay_slot = slot_completed->slot;
    3687           0 :   }
    3688             : 
    3689          57 :   fd_gui_slot_t * slot = fd_gui_slot_get_or_create( gui,
    3690          57 :                                                     slot_completed->slot,
    3691          57 :                                                     slot_completed->parent_slot,
    3692          57 :                                                     slot_completed->bank_seq,
    3693          57 :                                                     slot_completed->parent_bank_seq );
    3694          57 :   if( FD_UNLIKELY( !slot ) ) return; /* record could not be created / was evicted */
    3695             : 
    3696          57 :   slot->completed_time    = slot_completed->completion_time_nanos;
    3697          57 :   slot->parent_slot       = slot_completed->parent_slot;
    3698          57 :   slot->max_compute_units = fd_uint_if( slot_completed->cost_tracker.block_cost_limit==ULONG_MAX, slot->max_compute_units, (uint)slot_completed->cost_tracker.block_cost_limit );
    3699             : 
    3700          57 :   fd_gui_slot_t const * parent = fd_gui_slot_parent_get( gui, slot );
    3701          57 :   slot->parent_completed_time = parent ? parent->completed_time : LONG_MAX;
    3702             : 
    3703          57 :   fd_gui_timeline_slot_duration( gui, slot, now );
    3704          57 :   slot = fd_gui_slot_get( gui, slot_completed->slot, slot_completed->bank_seq );
    3705          57 :   if( FD_UNLIKELY( !slot ) ) return;
    3706             : 
    3707          57 :   ulong vote_slot;
    3708          57 :   if( FD_UNLIKELY( slot_completed->voted && slot_completed->slot>=FD_NUM_SLOTS_FOR_REWARD ) ) {
    3709           0 :     vote_slot = slot_completed->slot-FD_NUM_SLOTS_FOR_REWARD;
    3710          57 :   } else {
    3711          57 :     vote_slot = gui->summary.slot_voted; /* TODO: inherit from parent so it's fork-correct. Requires tracking identity changes to be correct. */
    3712          57 :   }
    3713             : 
    3714             :   /* A slot may already be notarized by the time we replay it. */
    3715          57 :   if( FD_LIKELY( slot->level<FD_GUI_SLOT_LEVEL_COMPLETED ) ) slot->level = FD_GUI_SLOT_LEVEL_COMPLETED;
    3716          57 :   slot->vote_failed     = fd_uint_if( slot_completed->vote_failed==ULONG_MAX,     slot->vote_failed,     (uint)slot_completed->vote_failed     );
    3717          57 :   slot->vote_success    = fd_uint_if( slot_completed->vote_success==ULONG_MAX,    slot->vote_success,    (uint)slot_completed->vote_success    );
    3718          57 :   slot->nonvote_success = fd_uint_if( slot_completed->nonvote_success==ULONG_MAX, slot->nonvote_success, (uint)slot_completed->nonvote_success );
    3719          57 :   slot->nonvote_failed  = fd_uint_if( slot_completed->nonvote_failed==ULONG_MAX,  slot->nonvote_failed,  (uint)slot_completed->nonvote_failed  );
    3720             : 
    3721          57 :   slot->transaction_fee   = slot_completed->transaction_fee;
    3722          57 :   slot->priority_fee      = slot_completed->priority_fee;
    3723          57 :   slot->tips              = slot_completed->tips;
    3724          57 :   slot->compute_units     = fd_uint_if( slot_completed->cost_tracker.block_cost==ULONG_MAX, slot->compute_units, (uint)slot_completed->cost_tracker.block_cost );
    3725          57 :   slot->shred_cnt         = fd_uint_if( slot_completed->shred_cnt==ULONG_MAX, slot->shred_cnt, (uint)slot_completed->shred_cnt );
    3726          57 :   slot->vote_slot         = vote_slot;
    3727          57 :   slot->block_hash        = slot_completed->block_hash;
    3728             : 
    3729          57 :   fd_gui_epoch_t * epoch = fd_gui_get_epoch_by_slot( gui, slot_completed->slot );
    3730          57 :   if( FD_UNLIKELY( epoch && slot_completed->slot==epoch->start_slot+epoch->slot_cnt-1UL ) ) epoch->end_time = slot->completed_time;
    3731             : 
    3732          57 :   if( FD_UNLIKELY( slot->mine ) ) {
    3733           6 :     fd_gui_leader_slot_t * lmeta = fd_gui_slot_leader_get_or_create( gui, slot_completed->slot, slot_completed->bank_seq );
    3734           6 :     if( FD_LIKELY( lmeta ) ) lmeta->block_hash = slot_completed->block_hash;
    3735             : 
    3736           6 :     fd_gui_epoch_t const * epoch = fd_gui_get_epoch_by_slot( gui, slot_completed->slot );
    3737           6 :     if( FD_LIKELY( epoch ) ) fd_gui_broadcast_skip_rate( gui, epoch->epoch );
    3738           6 :   }
    3739             : 
    3740          57 :   slot = fd_gui_slot_get( gui, slot_completed->slot, slot_completed->bank_seq );
    3741          57 :   if( FD_UNLIKELY( !slot ) ) return;
    3742          57 :   if( slot->mine && !slot->timeline_mine_accounted ) {
    3743           3 :     int accounted = fd_gui_timeline_mine_add( gui, slot->completed_time, now );
    3744           3 :     slot = fd_gui_slot_get( gui, slot_completed->slot, slot_completed->bank_seq );
    3745           3 :     if( FD_UNLIKELY( !slot ) ) return;
    3746           3 :     slot->timeline_mine_accounted = (uchar)!!accounted;
    3747           3 :   }
    3748             : 
    3749             :   /* Set skip status based on the current canonical fork. */
    3750          57 :   fd_gui_slot_t * canon = fd_gui_slot_get_canon( gui, slot_completed->slot );
    3751          57 :   slot->skip = fd_uchar_if( canon && canon->bank_seq==slot_completed->bank_seq, FD_GUI_SKIP_STATUS_NOT_SKIPPED, FD_GUI_SKIP_STATUS_UNKNOWN );
    3752             : 
    3753             :   /* vote_count is keyed by the cert slot.  The epoch copy is written
    3754             :      only on rooting, so it never holds a non-canonical bank's count. */
    3755          57 :   slot->vote_count = slot_completed->vote_count;
    3756             : 
    3757             :   /* fixes race if we just sample right after replay's SLOT_COMPLETE */
    3758          57 :   if( FD_LIKELY( gui->summary.slot_caught_up!=ULONG_MAX ) ) fd_gui_sample_repair_slot( gui, now );
    3759             : 
    3760             :   /* Update slot_turbine when we are leader. */
    3761          57 :   if( FD_UNLIKELY( gui->summary.slots_max_turbine[ 0 ].slot!=ULONG_MAX && slot_completed->slot > gui->summary.slots_max_turbine[ 0 ].slot ) ) {
    3762           0 :     fd_gui_try_insert_ephemeral_slot( gui->summary.slots_max_turbine, FD_GUI_TURBINE_SLOT_HISTORY_SZ, slot_completed->slot, now );
    3763           0 :   }
    3764             : 
    3765          57 :   int slot_turbine_hist_full = gui->summary.slots_max_turbine[ FD_GUI_TURBINE_SLOT_HISTORY_SZ-1UL ].slot!=ULONG_MAX;
    3766          57 :   if( FD_UNLIKELY( gui->summary.slot_caught_up==ULONG_MAX && slot_turbine_hist_full && gui->summary.slots_max_turbine[ 0 ].slot < (slot_completed->slot + 3UL) ) ) {
    3767           0 :     gui->summary.slot_caught_up = slot_completed->slot + 4UL;
    3768             : 
    3769           0 :     fd_gui_printf_slot_caught_up( gui );
    3770           0 :     fd_http_server_ws_broadcast( gui->http );
    3771           0 :   }
    3772             : 
    3773          57 :   if( FD_UNLIKELY( slot_completed->voted && slot_completed->slot>=FD_NUM_SLOTS_FOR_REWARD && ( gui->summary.slot_voted==ULONG_MAX || vote_slot>gui->summary.slot_voted ) ) ) {
    3774           0 :     gui->summary.slot_voted = vote_slot;
    3775           0 :     fd_gui_printf_vote_slot( gui );
    3776           0 :     fd_http_server_ws_broadcast( gui->http );
    3777           0 :   }
    3778             : 
    3779             :   /* Bind this bank only to certificates for the same block. */
    3780          57 :   fd_gui_ag_register_block( gui, slot_completed->slot, &slot_completed->block_id, slot_completed->bank_seq );
    3781             : 
    3782          57 :   if( FD_UNLIKELY( slot_completed->vote_balance!=ULONG_MAX && gui->summary.vote_account_balance!=slot_completed->vote_balance ) ) {
    3783           0 :     gui->summary.vote_account_balance = slot_completed->vote_balance;
    3784           0 :     fd_gui_printf_vote_balance( gui );
    3785           0 :     fd_http_server_ws_broadcast( gui->http );
    3786           0 :   }
    3787          57 :   if( FD_UNLIKELY( slot_completed->vote_commission!=USHORT_MAX && gui->summary.vote_commission!=slot_completed->vote_commission ) ) {
    3788           0 :     gui->summary.vote_commission = slot_completed->vote_commission;
    3789           0 :     fd_gui_printf_vote_commission( gui );
    3790           0 :     fd_http_server_ws_broadcast( gui->http );
    3791           0 :   }
    3792             : 
    3793          57 :   if( FD_LIKELY( slot_completed->slot>=FD_NUM_SLOTS_FOR_REWARD ) ) {
    3794          57 :     fd_gui_handle_ag_reward( gui, slot_completed->slot-FD_NUM_SLOTS_FOR_REWARD, slot_completed->voted, slot_completed->voted_rank );
    3795          57 :   }
    3796             : 
    3797          57 :   int frontier_updated = handle_tower_slot( gui, slot_completed->slot, slot_completed->bank_seq, now );
    3798             : 
    3799          57 :   if( FD_LIKELY( gui->summary.is_voting && slot_completed->slot>=FD_NUM_SLOTS_FOR_REWARD ) ) {
    3800           0 :     if( FD_UNLIKELY( slot_completed->voted_rank==USHORT_MAX ) ) {
    3801           0 :       set_vote_state( gui, FD_GUI_VOTE_STATE_NON_VOTING );
    3802           0 :     } else {
    3803           0 :       ulong s         = gui->summary.slot_tower;
    3804           0 :       ulong voted     = gui->summary.slot_voted;
    3805           0 :       int   current   = voted!=ULONG_MAX && fd_int_if( s>=128UL, voted+128UL>s, voted>0UL );
    3806           0 :       set_vote_state( gui, fd_int_if( current, FD_GUI_VOTE_STATE_VOTING, FD_GUI_VOTE_STATE_DELINQUENT ) );
    3807           0 :     }
    3808           0 :   }
    3809             : 
    3810          57 :   if( FD_UNLIKELY( frontier_updated && gui->summary.slot_estimated!=slot_completed->slot ) ) {
    3811          24 :     gui->summary.slot_estimated = slot_completed->slot;
    3812          24 :     fd_gui_printf_estimated_slot( gui );
    3813          24 :     fd_http_server_ws_broadcast( gui->http );
    3814          24 :   }
    3815          57 : }
    3816             : 
    3817             : void
    3818             : fd_gui_became_leader( fd_gui_t * gui,
    3819             :                       ulong      _slot,
    3820             :                       long       start_time_nanos,
    3821             :                       long       end_time_nanos,
    3822             :                       ulong      max_compute_units,
    3823             :                       ulong      max_microblocks,
    3824          15 :                       ulong      bank_seq ) {
    3825          15 :   gui->leader_begin_slot = fd_ulong_max( gui->leader_begin_slot, _slot );
    3826             : 
    3827          15 :   fd_gui_leader_slot_t * lslot = fd_gui_slot_leader_get_or_create( gui, _slot, bank_seq );
    3828          15 :   if( FD_UNLIKELY( !lslot ) ) return;
    3829             : 
    3830          15 :   lslot->leader_start_time = fd_long_if( lslot->leader_start_time==LONG_MAX, start_time_nanos, lslot->leader_start_time );
    3831          15 :   lslot->leader_end_time   = end_time_nanos;
    3832          15 :   lslot->max_microblocks   = max_microblocks;
    3833          15 :   lslot->max_compute_units = max_compute_units;
    3834          15 :   if( FD_LIKELY( lslot->microblocks_upper_bound==UINT_MAX ) ) lslot->microblocks_upper_bound = (uint)max_microblocks;
    3835          15 : }
    3836             : 
    3837             : void
    3838             : fd_gui_unbecame_leader( fd_gui_t *                gui,
    3839             :                         ulong                     _slot,
    3840          21 :                         fd_done_packing_t const * done_packing ) {
    3841          21 :   gui->leader_end_slot = fd_ulong_max( gui->leader_end_slot, _slot ); /* may arrive before its became_leader */
    3842             : 
    3843          21 :   fd_gui_leader_slot_t * lslot = fd_gui_slot_leader_get_any( gui, _slot );
    3844          21 :   if( FD_UNLIKELY( !lslot ) ) return;
    3845          18 :   lslot->microblocks_upper_bound = (uint)done_packing->microblocks_in_slot;
    3846          18 :   fd_memcpy( lslot->scheduler_stats, done_packing, sizeof(fd_done_packing_t) );
    3847          18 :   lslot->unbecame_leader = 1;
    3848             : 
    3849          18 :   if( FD_LIKELY( !lslot->has_waterfall ) ) {
    3850          15 :     gui->leader_slot_pending     = lslot->slot;
    3851          15 :     gui->leader_bank_seq_pending = lslot->bank_seq;
    3852          15 :   }
    3853          18 : }
    3854             : 
    3855             : void
    3856             : fd_gui_done_draining( fd_gui_t * gui,
    3857           9 :                       long       now ) {
    3858           9 :   if( FD_UNLIKELY( gui->leader_slot_pending==ULONG_MAX ) ) return;
    3859             : 
    3860           6 :   fd_gui_leader_slot_t * lslot = fd_gui_slot_leader_get( gui, gui->leader_slot_pending, gui->leader_bank_seq_pending );
    3861           6 :   gui->leader_slot_pending     = ULONG_MAX;
    3862           6 :   gui->leader_bank_seq_pending = ULONG_MAX;
    3863           6 :   if( FD_UNLIKELY( !lslot || lslot->has_waterfall ) ) return;
    3864             : 
    3865           6 :   fd_gui_txn_waterfall_t waterfall[ 1 ];
    3866           6 :   fd_gui_txn_waterfall_snap( gui, waterfall );
    3867           6 :   waterfall->sample_time_nanos = now;
    3868             : 
    3869           6 :   fd_memcpy( lslot->waterfall_reference, gui->summary.txn_waterfall_reference, sizeof(fd_gui_txn_waterfall_t) );
    3870           6 :   fd_memcpy( lslot->waterfall,           waterfall,                             sizeof(fd_gui_txn_waterfall_t) );
    3871           6 :   lslot->has_waterfall = 1;
    3872             : 
    3873           6 :   fd_memcpy( gui->summary.txn_waterfall_reference, waterfall, sizeof(fd_gui_txn_waterfall_t) );
    3874           6 : }
    3875             : 
    3876             : void
    3877             : fd_gui_microblock_execution_begin( fd_gui_t *   gui,
    3878             :                                    long         tspub_ns,
    3879             :                                    ulong        _slot,
    3880             :                                    fd_txn_e_t * txns,
    3881             :                                    ulong        txn_cnt,
    3882             :                                    uint         microblock_idx,
    3883             :                                    ulong        pack_txn_idx,
    3884             :                                    ulong        bank_seq,
    3885          15 :                                    long         now ) {
    3886          15 :   fd_gui_leader_slot_t * lslot = fd_gui_slot_leader_get_or_create( gui, _slot, bank_seq );
    3887          15 :   if( FD_UNLIKELY( !lslot ) ) return;
    3888             : 
    3889          15 :   lslot->leader_start_time = fd_long_if( lslot->leader_start_time==LONG_MAX, tspub_ns, lslot->leader_start_time );
    3890             : 
    3891          30 :   for( ulong i=0UL; i<txn_cnt; i++ ) {
    3892          15 :     fd_txn_p_t * txn_payload = txns[ i ].txnp;
    3893          15 :     fd_txn_t * txn = TXN( txn_payload );
    3894             : 
    3895          15 :     ulong sig_rewards = FD_PACK_FEE_PER_SIGNATURE * txn->signature_cnt;
    3896          15 :     ulong priority_rewards                    = ULONG_MAX;
    3897          15 :     ulong requested_execution_cus             = ULONG_MAX;
    3898          15 :     ulong precompile_sigs                     = ULONG_MAX;
    3899          15 :     ulong requested_loaded_accounts_data_cost = ULONG_MAX;
    3900          15 :     ulong allocated_data                      = ULONG_MAX;
    3901          15 :     ulong cost_estimate = fd_pack_compute_cost( txn, txn_payload->payload, &requested_execution_cus, &priority_rewards, &precompile_sigs, &requested_loaded_accounts_data_cost, &allocated_data );
    3902          15 :     sig_rewards += FD_PACK_FEE_PER_SIGNATURE * precompile_sigs;
    3903          15 :     sig_rewards = sig_rewards * FD_PACK_TXN_FEE_BURN_PCT / 100UL;
    3904             : 
    3905          15 :     ulong txn_idx = pack_txn_idx + i;
    3906          15 :     uchar flags = (uchar)FD_GUI_TXN_FLAGS_STARTED;
    3907          15 :     flags |= (uchar)fd_uint_if( (txn_payload->flags & FD_TXN_P_FLAGS_BUNDLE) || (txn_payload->flags & FD_TXN_P_FLAGS_INITIALIZER_BUNDLE), FD_GUI_TXN_FLAGS_FROM_BUNDLE, 0U );
    3908             : 
    3909          15 :     fd_gui_store_txn_start_t rec = {
    3910          15 :       .slot                    = _slot,
    3911          15 :       .bank_seq                = bank_seq,
    3912          15 :       .insert_time_ns          = now,
    3913          15 :       .txn_idx                 = txn_idx,
    3914          15 :       .transaction_fee         = sig_rewards,
    3915          15 :       .priority_fee            = priority_rewards,
    3916          15 :       .timestamp_arrival_nanos = txn_payload->scheduler_arrival_time_nanos,
    3917          15 :       .microblock_start_ns     = tspub_ns,
    3918          15 :       .compute_units_requested = (uint)(cost_estimate & 0x1FFFFFU),
    3919          15 :       .microblock_idx          = microblock_idx,
    3920          15 :       .source_ipv4             = txn_payload->source_ipv4,
    3921          15 :       .source_tpu              = txn_payload->source_tpu,
    3922          15 :       .flags                   = flags
    3923          15 :     };
    3924          15 :     fd_memcpy( rec.signature, txn_payload->payload + txn->signature_off, FD_SHA512_HASH_SZ );
    3925          15 :     if( FD_LIKELY( !fd_gui_hist_ts_append( gui, FD_GUI_HIST_TXN_START, &rec ) ) ) {
    3926           9 :       lslot = fd_gui_slot_leader_get( gui, _slot, bank_seq );
    3927           9 :       if( FD_LIKELY( lslot ) ) {
    3928           9 :         lslot->txn_insert_time_min_ns = fd_long_min( lslot->txn_insert_time_min_ns, now );
    3929           9 :         lslot->txn_insert_time_max_ns = fd_long_max( lslot->txn_insert_time_max_ns, now );
    3930           9 :       }
    3931           9 :     }
    3932          15 :   }
    3933             : 
    3934             :   /* At the moment, bank publishes at most 1 transaction per microblock,
    3935             :      even if it received microblocks with multiple transactions
    3936             :      (i.e. a bundle). This means that we need to calculate microblock
    3937             :      count here based on the transaction count. */
    3938          15 :   lslot = fd_gui_slot_leader_get( gui, _slot, bank_seq );
    3939          15 :   if( FD_LIKELY( lslot ) ) lslot->begin_microblocks += (uint)txn_cnt;
    3940          15 : }
    3941             : 
    3942             : static inline long
    3943          15 : fd_gui_ns_dt_float_to_long( float dt ) {
    3944          15 :   return (long)((double)dt+0.5);
    3945          15 : }
    3946             : 
    3947             : /* fd_gui_record_leader_txn converts a transaction executed by the
    3948             :    leader pipeline into a replay record, so leader and replayed
    3949             :    transactions are served from the same store. */
    3950             : 
    3951             : static void
    3952             : fd_gui_record_leader_txn( fd_gui_t *     gui,
    3953             :                           fd_txn_p_t *   txn_p,
    3954             :                           ulong          txn_idx,
    3955             :                           ulong          bank_idx,
    3956             :                           ulong          slot,
    3957             :                           ulong          block_compute_unit_limit,
    3958             :                           fd_txn_ns_dt_t txn_ns_dt,
    3959             :                           long           exec_end_ticks,
    3960             :                           ulong          tips,
    3961             :                           uint           error_code,
    3962           3 :                           long           now ) {
    3963           3 :   ulong priority_fee       = 0UL;
    3964           3 :   ulong precompile_sig_cnt = 0UL;
    3965           3 :   ulong requested = fd_pack_compute_cost( TXN( txn_p ), txn_p->payload, NULL,
    3966           3 :                                           &priority_fee, &precompile_sig_cnt, NULL, NULL );
    3967           3 :   long commit_end_ns = fd_gui_tick_to_nanos( gui, now, fd_tickcount(), exec_end_ticks );
    3968           3 :   long start_ns      = fd_long_sat_sub( commit_end_ns, fd_gui_ns_dt_float_to_long( txn_ns_dt.commit_end ) );
    3969           3 :   fd_gui_store_replay_txn_t replay = {
    3970           3 :     .insert_time_ns           = now,
    3971           3 :     .completion_time_ns       = commit_end_ns,
    3972           3 :     .block_compute_unit_limit = block_compute_unit_limit,
    3973           3 :     .slot                     = slot,
    3974           3 :     .txn_idx                  = txn_idx, /* pack index, not position in the produced block */
    3975           3 :     .txn_exec_idx             = bank_idx,
    3976           3 :     .txn_sigverify_exec_idx   = ULONG_MAX,
    3977           3 :     .txn_start_shred_idx      = UINT_MAX, /* execle's union holds pack_alloc, not shred indices */
    3978           3 :     .txn_end_shred_idx        = UINT_MAX,
    3979           3 :     .sigverify_start_ns       = LONG_MAX,
    3980           3 :     .sigverify_end_ns         = LONG_MAX,
    3981           3 :     .load_start_ns            = fd_long_sat_add( start_ns, fd_gui_ns_dt_float_to_long( txn_ns_dt.load_start ) ),
    3982           3 :     .check_start_ns           = fd_long_sat_add( start_ns, fd_gui_ns_dt_float_to_long( txn_ns_dt.check_start ) ),
    3983           3 :     .exec_start_ns            = fd_long_sat_add( start_ns, fd_gui_ns_dt_float_to_long( txn_ns_dt.exec_start ) ),
    3984           3 :     .commit_start_ns          = fd_long_sat_add( start_ns, fd_gui_ns_dt_float_to_long( txn_ns_dt.commit_start ) ),
    3985           3 :     .commit_end_ns            = commit_end_ns,
    3986           3 :     .transaction_fee          = FD_PACK_FEE_PER_SIGNATURE*(TXN( txn_p )->signature_cnt+precompile_sig_cnt), /* before burn, like replay */
    3987           3 :     .priority_fee             = priority_fee,
    3988           3 :     .tips                     = tips,
    3989           3 :     .compute_units_requested  = (uint)requested,
    3990           3 :     .compute_units_consumed   = txn_p->execle_cu.actual_consumed_cus,
    3991           3 :     .error_code               = error_code,
    3992           3 :     .is_committable           = 1U,
    3993           3 :     .is_fees_only             = (uchar)!!(txn_p->flags & FD_TXN_P_FLAGS_FEES_ONLY),
    3994           3 :   };
    3995           3 :   fd_memcpy( replay.signature, txn_p->payload+TXN( txn_p )->signature_off, FD_TXN_SIGNATURE_SZ );
    3996           3 :   fd_gui_record_replay_txn( gui, &replay );
    3997           3 : }
    3998             : 
    3999             : void
    4000             : fd_gui_microblock_execution_end( fd_gui_t *     gui,
    4001             :                                  long           tspub_ns,
    4002             :                                  ulong          bank_idx,
    4003             :                                  ulong          _slot,
    4004             :                                  ulong          txn_cnt,
    4005             :                                  fd_txn_p_t *   txns,
    4006             :                                  ulong          pack_txn_idx,
    4007             :                                  fd_txn_ns_dt_t txn_ns_dt,
    4008             :                                  long           exec_end_ticks,
    4009             :                                  ulong          tips,
    4010             :                                  ulong          bank_seq,
    4011          21 :                                  long           now ) {
    4012          21 :   if( FD_UNLIKELY( 1UL!=txn_cnt ) ) FD_LOG_ERR(( "gui expects 1 txn per microblock from bank, found %lu", txn_cnt ));
    4013             : 
    4014          21 :   fd_gui_leader_slot_t * lslot = fd_gui_slot_leader_get_or_create( gui, _slot, bank_seq );
    4015          21 :   if( FD_UNLIKELY( !lslot ) ) return;
    4016             : 
    4017          21 :   lslot->leader_start_time = fd_long_if( lslot->leader_start_time==LONG_MAX, tspub_ns, lslot->leader_start_time );
    4018             : 
    4019          21 :   ulong block_compute_unit_limit = lslot->max_compute_units;
    4020          42 :   for( ulong i=0UL; i<txn_cnt; i++ ) {
    4021          21 :     fd_txn_p_t * txn_p = &txns[ i ];
    4022          21 :     ulong txn_idx = pack_txn_idx + i;
    4023             : 
    4024          21 :     uint  error_code = (txn_p->flags>>24) & 0xFFU;
    4025          21 :     uchar flags      = (uchar)FD_GUI_TXN_FLAGS_ENDED;
    4026          21 :     flags |= (uchar)fd_uint_if( !!(txn_p->flags & FD_TXN_P_FLAGS_EXECUTE_SUCCESS), FD_GUI_TXN_FLAGS_LANDED_IN_BLOCK, 0U );
    4027             : 
    4028          21 :     fd_gui_store_txn_end_t rec = {
    4029          21 :       .slot                    = _slot,
    4030          21 :       .bank_seq                = bank_seq,
    4031          21 :       .insert_time_ns          = now,
    4032          21 :       .txn_idx                 = txn_idx,
    4033          21 :       .timestamp_arrival_nanos = txn_p->scheduler_arrival_time_nanos,
    4034          21 :       .microblock_end_ns       = tspub_ns,
    4035          21 :       .txn_ns_dt               = txn_ns_dt,
    4036          21 :       .tips                    = tips,
    4037          21 :       .compute_units_consumed  = (uint)(txn_p->execle_cu.actual_consumed_cus & 0x1FFFFFU),
    4038          21 :       .bank_idx                = (uint)(bank_idx & 0x3FU),
    4039          21 :       .error_code              = error_code,
    4040          21 :       .flags                   = flags
    4041          21 :     };
    4042          21 :     if( FD_LIKELY( !fd_gui_hist_ts_append( gui, FD_GUI_HIST_TXN_END, &rec ) ) ) {
    4043          15 :       lslot = fd_gui_slot_leader_get( gui, _slot, bank_seq );
    4044          15 :       if( FD_LIKELY( lslot ) ) {
    4045          15 :         lslot->txn_insert_time_min_ns = fd_long_min( lslot->txn_insert_time_min_ns, now );
    4046          15 :         lslot->txn_insert_time_max_ns = fd_long_max( lslot->txn_insert_time_max_ns, now );
    4047          15 :       }
    4048          15 :     }
    4049             : 
    4050          21 :     if( FD_LIKELY( gui->db && gui->hist && (txn_p->flags & FD_TXN_P_FLAGS_EXECUTE_SUCCESS) && exec_end_ticks!=LONG_MAX ) ) {
    4051           3 :       fd_gui_record_leader_txn( gui, txn_p, txn_idx, bank_idx, _slot, block_compute_unit_limit, txn_ns_dt, exec_end_ticks, tips, error_code, now );
    4052           3 :     }
    4053          21 :   }
    4054             : 
    4055          21 :   lslot = fd_gui_slot_leader_get( gui, _slot, bank_seq );
    4056          21 :   if( FD_LIKELY( lslot ) ) lslot->end_microblocks += (uint)txn_cnt;
    4057          21 : }

Generated by: LCOV version 1.14