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, ¶ms, ¶ms_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 : }
|