LCOV - code coverage report
Current view: top level - disco/pack - fd_pack_tile.c (source / functions) Hit Total Coverage
Test: cov.lcov Lines: 0 632 0.0 %
Date: 2025-07-01 05:00:49 Functions: 0 15 0.0 %

          Line data    Source code
       1             : #include "../tiles.h"
       2             : 
       3             : #include "generated/fd_pack_tile_seccomp.h"
       4             : 
       5             : #include "../../util/pod/fd_pod_format.h"
       6             : #include "../keyguard/fd_keyload.h"
       7             : #include "../keyguard/fd_keyswitch.h"
       8             : #include "../keyguard/fd_keyguard.h"
       9             : #include "../metrics/fd_metrics.h"
      10             : #include "../pack/fd_pack.h"
      11             : #include "../pack/fd_pack_pacing.h"
      12             : 
      13             : #include <linux/unistd.h>
      14             : 
      15             : /* fd_pack is responsible for taking verified transactions, and
      16             :    arranging them into "microblocks" (groups) of transactions to
      17             :    be executed serially.  It can try to do clever things so that
      18             :    multiple microblocks can execute in parallel, if they don't
      19             :    write to the same accounts. */
      20             : 
      21           0 : #define IN_KIND_RESOLV       (0UL)
      22           0 : #define IN_KIND_POH          (1UL)
      23           0 : #define IN_KIND_BANK         (2UL)
      24           0 : #define IN_KIND_SIGN         (3UL)
      25           0 : #define IN_KIND_EXECUTED_TXN (4UL)
      26             : 
      27             : /* Pace microblocks, but only slightly.  This helps keep performance
      28             :    more stable.  This limit is 2,000 microblocks/second/bank.  At 31
      29             :    transactions/microblock, that's 62k txn/sec/bank. */
      30           0 : #define MICROBLOCK_DURATION_NS  (0L)
      31             : 
      32             : /* There are 151 accepted blockhashes, but those don't include skips.
      33             :    This check is neither precise nor accurate, but just good enough.
      34             :    The bank tile does the final check.  We give a little margin for a
      35             :    few percent skip rate. */
      36           0 : #define TRANSACTION_LIFETIME_SLOTS 160UL
      37             : 
      38             : /* Time is normally a long, but pack expects a ulong.  Add -LONG_MIN to
      39             :    the time values so that LONG_MIN maps to 0, LONG_MAX maps to
      40             :    ULONG_MAX, and everything in between maps linearly with a slope of 1.
      41             :    Just subtracting LONG_MIN results in signed integer overflow, which
      42             :    is U.B. */
      43             : #define TIME_OFFSET 0x8000000000000000UL
      44             : FD_STATIC_ASSERT( (ulong)LONG_MIN+TIME_OFFSET==0UL,       time_offset );
      45             : FD_STATIC_ASSERT( (ulong)LONG_MAX+TIME_OFFSET==ULONG_MAX, time_offset );
      46             : 
      47             : /* Optionally allow a larger limit for benchmarking */
      48           0 : #define LARGER_MAX_COST_PER_BLOCK (18UL*FD_PACK_MAX_COST_PER_BLOCK_LOWER_BOUND)
      49             : 
      50             : /* 1.6 M cost units, enough for 1 max size transaction */
      51             : const ulong CUS_PER_MICROBLOCK = 1600000UL;
      52             : 
      53             : #define SMALL_MICROBLOCKS 1
      54             : 
      55             : #if SMALL_MICROBLOCKS
      56             : const float VOTE_FRACTION = 1.0f; /* schedule all available votes first */
      57           0 : #define EFFECTIVE_TXN_PER_MICROBLOCK 1UL
      58             : #else
      59             : const float VOTE_FRACTION = 0.75f; /* TODO: Is this the right value? */
      60             : #define EFFECTIVE_TXN_PER_MICROBLOCK MAX_TXN_PER_MICROBLOCK
      61             : #endif
      62             : 
      63             : /* There's overhead associated with each microblock the bank tile tries
      64             :    to execute it, so the optimal strategy is not to produce a microblock
      65             :    with a single transaction as soon as we receive it.  Basically, if we
      66             :    have less than 31 transactions, we want to wait a little to see if we
      67             :    receive additional transactions before we schedule a microblock.  We
      68             :    can model the optimum amount of time to wait, but the equation is
      69             :    complicated enough that we want to compute it before compile time.
      70             :    wait_duration[i] for i in [0, 31] gives the time in nanoseconds pack
      71             :    should wait after receiving its most recent transaction before
      72             :    scheduling if it has i transactions available.  Unsurprisingly,
      73             :    wait_duration[31] is 0.  wait_duration[0] is ULONG_MAX, so we'll
      74             :    always wait if we have 0 transactions. */
      75             : FD_IMPORT( wait_duration, "src/disco/pack/pack_delay.bin", ulong, 6, "" );
      76             : 
      77             : 
      78             : 
      79             : #if FD_PACK_USE_EXTRA_STORAGE
      80             : /* When we are done being leader for a slot and we are leader in the
      81             :    very next slot, it can still take some time to transition.  This is
      82             :    because the bank has to be finalized, a hash calculated, and various
      83             :    other things done in the replay stage to create the new child bank.
      84             : 
      85             :    During that time, pack cannot send transactions to banks so it needs
      86             :    to be able to buffer.  Typically, these so called "leader
      87             :    transitions" are short (<15 millis), so a low value here would
      88             :    suffice.  However, in some cases when there is memory pressure on the
      89             :    NUMA node or when the operating system context switches relevant
      90             :    threads out, it can take significantly longer.
      91             : 
      92             :    To prevent drops in these cases and because we assume banks are fast
      93             :    enough to drain this buffer once we do become leader, we set this
      94             :    buffer size to be quite large. */
      95             : 
      96             : #define DEQUE_NAME extra_txn_deq
      97             : #define DEQUE_T    fd_txn_e_t
      98             : #define DEQUE_MAX  (128UL*1024UL)
      99             : #include "../../../../util/tmpl/fd_deque.c"
     100             : 
     101             : #endif
     102             : 
     103             : /* Sync with src/app/shared/fd_config.c */
     104           0 : #define FD_PACK_STRATEGY_PERF     0
     105           0 : #define FD_PACK_STRATEGY_BALANCED 1
     106           0 : #define FD_PACK_STRATEGY_BUNDLE   2
     107             : 
     108             : static char const * const schedule_strategy_strings[3] = { "PRF", "BAL", "BUN" };
     109             : 
     110             : 
     111             : typedef struct {
     112             :   fd_acct_addr_t commission_pubkey[1];
     113             :   ulong          commission;
     114             : } block_builder_info_t;
     115             : 
     116             : typedef struct {
     117             :   fd_wksp_t * mem;
     118             :   ulong       chunk0;
     119             :   ulong       wmark;
     120             : } fd_pack_in_ctx_t;
     121             : 
     122             : typedef struct {
     123             :   fd_pack_t *  pack;
     124             :   fd_txn_e_t * cur_spot;
     125             :   int          is_bundle; /* is the current transaction a bundle */
     126             : 
     127             :   uchar executed_txn_sig[ 64UL ];
     128             : 
     129             :   /* One of the FD_PACK_STRATEGY_* values defined above */
     130             :   int      strategy;
     131             : 
     132             :   /* The value passed to fd_pack_new, etc. */
     133             :   ulong    max_pending_transactions;
     134             : 
     135             :   /* The leader slot we are currently packing for, or ULONG_MAX if we
     136             :      are not the leader. */
     137             :   ulong  leader_slot;
     138             :   void const * leader_bank;
     139             : 
     140             :   /* The number of microblocks we have packed for the current leader
     141             :      slot.  Will always be <= slot_max_microblocks.  We must track
     142             :      this so that when we are done we can tell the PoH tile how many
     143             :      microblocks to expect in the slot. */
     144             :   ulong slot_microblock_cnt;
     145             : 
     146             :   ulong pack_txn_cnt; /* total num transactions packed since startup */
     147             : 
     148             :   /* The maximum number of microblocks that can be packed in this slot.
     149             :      Provided by the PoH tile when we become leader.*/
     150             :   ulong slot_max_microblocks;
     151             : 
     152             :   /* Cap (in bytes) of the amount of transaction data we produce in each
     153             :      block to avoid hitting the shred limits.  See where this is set for
     154             :      more explanation. */
     155             :   ulong slot_max_data;
     156             :   int   larger_shred_limits_per_block;
     157             : 
     158             :   /* Consensus critical slot cost limits. */
     159             :   struct {
     160             :     ulong slot_max_cost;
     161             :     ulong slot_max_vote_cost;
     162             :     ulong slot_max_write_cost_per_acct;
     163             :   } limits;
     164             : 
     165             :   /* If drain_banks is non-zero, then the pack tile must wait until all
     166             :      banks are idle before scheduling any more microblocks.  This is
     167             :      primarily helpful in irregular leader transitions, e.g. while being
     168             :      leader for slot N, we switch forks to a slot M (!=N+1) in which we
     169             :      are also leader.  We don't want to execute microblocks for
     170             :      different slots concurrently. */
     171             :   int drain_banks;
     172             : 
     173             :   /* Updated during housekeeping and used only for checking if the
     174             :      leader slot has ended.  Might be off by one housekeeping duration,
     175             :      but that should be small relative to a slot duration. */
     176             :   long  approx_wallclock_ns;
     177             : 
     178             :   /* approx_tickcount is updated in during_housekeeping() with
     179             :      fd_tickcount() and will match approx_wallclock_ns.  This is done
     180             :      because we need to include an accurate nanosecond timestamp in
     181             :      every fd_txn_p_t but don't want to have to call the expensive
     182             :      fd_log_wallclock() in in the critical path. We can use
     183             :      fd_tempo_tick_per_ns() to convert from ticks to nanoseconds over
     184             :      small periods of time. */
     185             :   long  approx_tickcount;
     186             : 
     187             :   fd_rng_t * rng;
     188             : 
     189             :   /* The end wallclock time of the leader slot we are currently packing
     190             :      for, if we are currently packing for a slot.
     191             : 
     192             :      _slot_end_ns is used as a temporary between during_frag and
     193             :      after_frag in case the tile gets overrun. */
     194             :   long _slot_end_ns;
     195             :   long slot_end_ns;
     196             : 
     197             :   /* pacer and ticks_per_ns are used for pacing CUs through the slot,
     198             :      i.e. deciding when to schedule a microblock given the number of CUs
     199             :      that have been consumed so far.  pacer is an opaque pacing object,
     200             :      which is initialized when the pack tile is packing a slot.
     201             :      ticks_per_ns is the cached value from tempo. */
     202             :   fd_pack_pacing_t pacer[1];
     203             :   double           ticks_per_ns;
     204             : 
     205             :   /* last_successful_insert stores the tickcount of the last
     206             :      successful transaction insert. */
     207             :   long last_successful_insert;
     208             : 
     209             :   /* highest_observed_slot stores the highest slot number we've seen
     210             :      from any transaction coming from the resolv tile.  When this
     211             :      increases, we expire old transactions. */
     212             :   ulong highest_observed_slot;
     213             : 
     214             :   /* microblock_duration_ns, and wait_duration
     215             :      respectively scaled to be in ticks instead of nanoseconds */
     216             :   ulong microblock_duration_ticks;
     217             :   ulong wait_duration_ticks[ MAX_TXN_PER_MICROBLOCK+1UL ];
     218             : 
     219             : #if FD_PACK_USE_EXTRA_STORAGE
     220             :   /* In addition to the available transactions that pack knows about, we
     221             :      also store a larger ring buffer for handling cases when pack is
     222             :      full.  This is an fd_deque. */
     223             :   fd_txn_e_t * extra_txn_deq;
     224             :   int          insert_to_extra; /* whether the last insert was into pack or the extra deq */
     225             : #endif
     226             : 
     227             :   fd_pack_in_ctx_t in[ 32 ];
     228             :   int              in_kind[ 32 ];
     229             : 
     230             :   ulong    bank_cnt;
     231             :   ulong    bank_idle_bitset; /* bit i is 1 if we've observed *bank_current[i]==bank_expect[i] */
     232             :   int      poll_cursor; /* in [0, bank_cnt), the next bank to poll */
     233             :   int      use_consumed_cus;
     234             :   long     skip_cnt;
     235             :   ulong *  bank_current[ FD_PACK_MAX_BANK_TILES ];
     236             :   ulong    bank_expect[ FD_PACK_MAX_BANK_TILES  ];
     237             :   /* bank_ready_at[x] means don't check bank x until tickcount is at
     238             :      least bank_ready_at[x]. */
     239             :   long     bank_ready_at[ FD_PACK_MAX_BANK_TILES  ];
     240             : 
     241             :   fd_wksp_t * out_mem;
     242             :   ulong       out_chunk0;
     243             :   ulong       out_wmark;
     244             :   ulong       out_chunk;
     245             : 
     246             :   ulong      insert_result[ FD_PACK_INSERT_RETVAL_CNT ];
     247             :   fd_histf_t schedule_duration[ 1 ];
     248             :   fd_histf_t no_sched_duration[ 1 ];
     249             :   fd_histf_t insert_duration  [ 1 ];
     250             :   fd_histf_t complete_duration[ 1 ];
     251             : 
     252             :   struct {
     253             :     uint metric_state;
     254             :     long metric_state_begin;
     255             :     long metric_timing[ 16 ];
     256             :   };
     257             : 
     258             :   struct {
     259             :     long time;
     260             :     ulong all[ FD_METRICS_TOTAL_SZ ];
     261             :   } last_sched_metrics[1];
     262             : 
     263             :   struct {
     264             :     ulong id;
     265             :     ulong txn_cnt;
     266             :     ulong txn_received;
     267             :     ulong min_blockhash_slot;
     268             :     fd_txn_e_t * _txn[ FD_PACK_MAX_TXN_PER_BUNDLE ];
     269             :     fd_txn_e_t * const * bundle; /* points to _txn when non-NULL */
     270             :   } current_bundle[1];
     271             : 
     272             :   block_builder_info_t blk_engine_cfg[1];
     273             : 
     274             :   struct {
     275             :     int                   enabled;
     276             :     int                   ib_inserted; /* in this slot */
     277             :     fd_acct_addr_t        vote_pubkey[1];
     278             :     fd_acct_addr_t        identity_pubkey[1];
     279             :     fd_bundle_crank_gen_t gen[1];
     280             :     fd_acct_addr_t        tip_receiver_owner[1];
     281             :     ulong                 epoch;
     282             :     fd_bundle_crank_tip_payment_config_t prev_config[1]; /* as of start of slot, then updated */
     283             :     uchar                 recent_blockhash[32];
     284             :     fd_ed25519_sig_t      last_sig[1];
     285             : 
     286             :     fd_keyswitch_t *      keyswitch;
     287             :     fd_keyguard_client_t  keyguard_client[1];
     288             : 
     289             :     ulong                 metrics[4];
     290             :   } crank[1];
     291             : 
     292             : 
     293             :   /* Used between during_frag and after_frag */
     294             :   ulong pending_rebate_sz;
     295             :   union{ fd_pack_rebate_t rebate[1]; uchar footprint[USHORT_MAX]; } rebate[1];
     296             : } fd_pack_ctx_t;
     297             : 
     298           0 : #define BUNDLE_META_SZ 40UL
     299             : FD_STATIC_ASSERT( sizeof(block_builder_info_t)==BUNDLE_META_SZ, blk_engine_cfg );
     300             : 
     301           0 : #define FD_PACK_METRIC_STATE_TRANSACTIONS 0
     302           0 : #define FD_PACK_METRIC_STATE_BANKS        1
     303           0 : #define FD_PACK_METRIC_STATE_LEADER       2
     304           0 : #define FD_PACK_METRIC_STATE_MICROBLOCKS  3
     305             : 
     306             : /* Updates one component of the metric state.  If the state has changed,
     307             :    records the change. */
     308             : static inline void
     309             : update_metric_state( fd_pack_ctx_t * ctx,
     310             :                      long            effective_as_of,
     311             :                      int             type,
     312           0 :                      int             status ) {
     313           0 :   uint current_state = fd_uint_insert_bit( ctx->metric_state, type, status );
     314           0 :   if( FD_UNLIKELY( current_state!=ctx->metric_state ) ) {
     315           0 :     ctx->metric_timing[ ctx->metric_state ] += effective_as_of - ctx->metric_state_begin;
     316           0 :     ctx->metric_state_begin = effective_as_of;
     317           0 :     ctx->metric_state = current_state;
     318           0 :   }
     319           0 : }
     320             : 
     321             : static inline void
     322           0 : remove_ib( fd_pack_ctx_t * ctx ) {
     323             :   /* It's likely the initializer bundle is long scheduled, but we want to
     324             :      try deleting it just in case. */
     325           0 :   if( FD_UNLIKELY( ctx->crank->enabled & ctx->crank->ib_inserted ) ) {
     326           0 :     int deleted = fd_pack_delete_transaction( ctx->pack, (fd_ed25519_sig_t const *)ctx->crank->last_sig );
     327           0 :     FD_MCNT_INC( PACK, TRANSACTION_DELETED, (ulong)deleted );
     328           0 :   }
     329           0 :   ctx->crank->ib_inserted = 0;
     330           0 : }
     331             : 
     332             : 
     333             : FD_FN_CONST static inline ulong
     334           0 : scratch_align( void ) {
     335           0 :   return 4096UL;
     336           0 : }
     337             : 
     338             : FD_FN_PURE static inline ulong
     339           0 : scratch_footprint( fd_topo_tile_t const * tile ) {
     340           0 :   fd_pack_limits_t limits[1] = {{
     341           0 :     .max_cost_per_block        = tile->pack.larger_max_cost_per_block ? LARGER_MAX_COST_PER_BLOCK : FD_PACK_MAX_COST_PER_BLOCK_UPPER_BOUND,
     342           0 :     .max_vote_cost_per_block   = FD_PACK_MAX_VOTE_COST_PER_BLOCK_UPPER_BOUND,
     343           0 :     .max_write_cost_per_acct   = FD_PACK_MAX_WRITE_COST_PER_ACCT_UPPER_BOUND,
     344           0 :     .max_data_bytes_per_block  = tile->pack.larger_shred_limits_per_block ? LARGER_MAX_DATA_PER_BLOCK : FD_PACK_MAX_DATA_PER_BLOCK,
     345           0 :     .max_txn_per_microblock    = EFFECTIVE_TXN_PER_MICROBLOCK,
     346           0 :     .max_microblocks_per_block = (ulong)UINT_MAX, /* Limit not known yet */
     347           0 :   }};
     348             : 
     349           0 :   ulong l = FD_LAYOUT_INIT;
     350           0 :   l = FD_LAYOUT_APPEND( l, alignof( fd_pack_ctx_t ), sizeof( fd_pack_ctx_t )                                   );
     351           0 :   l = FD_LAYOUT_APPEND( l, fd_rng_align(),           fd_rng_footprint()                                        );
     352           0 :   l = FD_LAYOUT_APPEND( l, fd_pack_align(),          fd_pack_footprint( tile->pack.max_pending_transactions,
     353           0 :                                                                         BUNDLE_META_SZ,
     354           0 :                                                                         tile->pack.bank_tile_count,
     355           0 :                                                                         limits                               ) );
     356             : #if FD_PACK_USE_EXTRA_STORAGE
     357             :   l = FD_LAYOUT_APPEND( l, extra_txn_deq_align(),    extra_txn_deq_footprint()                                 );
     358             : #endif
     359           0 :   return FD_LAYOUT_FINI( l, scratch_align() );
     360           0 : }
     361             : 
     362             : static inline void
     363             : log_end_block_metrics( fd_pack_ctx_t * ctx,
     364             :                        long            now,
     365           0 :                        char const    * reason ) {
     366           0 : #define DELTA( m ) (fd_metrics_tl[ MIDX(COUNTER, PACK, TRANSACTION_SCHEDULE_##m) ] - ctx->last_sched_metrics->all[ MIDX(COUNTER, PACK, TRANSACTION_SCHEDULE_##m) ])
     367           0 : #define AVAIL( m ) (fd_metrics_tl[ MIDX(GAUGE, PACK, AVAILABLE_TRANSACTIONS_##m) ])
     368           0 :     FD_LOG_INFO(( "pack_end_block(slot=%lu,%s,%lx,ticks_since_last_schedule=%ld,reasons=%lu,%lu,%lu,%lu,%lu,%lu,%lu;remaining=%lu+%lu+%lu+%lu;smallest=%lu;cus=%lu->%lu)",
     369           0 :           ctx->leader_slot, reason, ctx->bank_idle_bitset, now-ctx->last_sched_metrics->time,
     370           0 :           DELTA( TAKEN ), DELTA( CU_LIMIT ), DELTA( FAST_PATH ), DELTA( BYTE_LIMIT ), DELTA( WRITE_COST ), DELTA( SLOW_PATH ), DELTA( DEFER_SKIP ),
     371           0 :           AVAIL(REGULAR), AVAIL(VOTES), AVAIL(BUNDLES), AVAIL(CONFLICTING),
     372           0 :           (fd_metrics_tl[ MIDX(GAUGE, PACK, SMALLEST_PENDING_TRANSACTION) ]),
     373           0 :           (ctx->last_sched_metrics->all[ MIDX(GAUGE, PACK, CUS_CONSUMED_IN_BLOCK) ]),
     374           0 :           (fd_metrics_tl               [ MIDX(GAUGE, PACK, CUS_CONSUMED_IN_BLOCK) ])
     375           0 :     ));
     376           0 : #undef AVAIL
     377           0 : #undef DELTA
     378           0 : }
     379             : 
     380             : static inline void
     381           0 : metrics_write( fd_pack_ctx_t * ctx ) {
     382           0 :   FD_MCNT_ENUM_COPY( PACK, TRANSACTION_INSERTED,          ctx->insert_result  );
     383           0 :   FD_MCNT_ENUM_COPY( PACK, METRIC_TIMING,        ((ulong*)ctx->metric_timing) );
     384           0 :   FD_MCNT_ENUM_COPY( PACK, BUNDLE_CRANK_STATUS,           ctx->crank->metrics );
     385           0 :   FD_MHIST_COPY( PACK, SCHEDULE_MICROBLOCK_DURATION_SECONDS, ctx->schedule_duration );
     386           0 :   FD_MHIST_COPY( PACK, NO_SCHED_MICROBLOCK_DURATION_SECONDS, ctx->no_sched_duration );
     387           0 :   FD_MHIST_COPY( PACK, INSERT_TRANSACTION_DURATION_SECONDS,  ctx->insert_duration   );
     388           0 :   FD_MHIST_COPY( PACK, COMPLETE_MICROBLOCK_DURATION_SECONDS, ctx->complete_duration );
     389             : 
     390           0 :   fd_pack_metrics_write( ctx->pack );
     391           0 : }
     392             : 
     393             : static inline void
     394           0 : during_housekeeping( fd_pack_ctx_t * ctx ) {
     395           0 :   ctx->approx_wallclock_ns = fd_log_wallclock();
     396           0 :   ctx->approx_tickcount = fd_tickcount();
     397             : 
     398           0 :   if( FD_UNLIKELY( ctx->crank->enabled && fd_keyswitch_state_query( ctx->crank->keyswitch )==FD_KEYSWITCH_STATE_SWITCH_PENDING ) ) {
     399           0 :     fd_memcpy( ctx->crank->identity_pubkey, ctx->crank->keyswitch->bytes, 32UL );
     400           0 :     fd_keyswitch_state( ctx->crank->keyswitch, FD_KEYSWITCH_STATE_COMPLETED );
     401           0 :   }
     402           0 : }
     403             : 
     404             : static inline void
     405             : before_credit( fd_pack_ctx_t *     ctx,
     406             :                fd_stem_context_t * stem,
     407           0 :                int *               charge_busy ) {
     408           0 :   (void)stem;
     409             : 
     410           0 :   if( FD_UNLIKELY( (ctx->cur_spot!=NULL) & !ctx->is_bundle ) ) {
     411           0 :     *charge_busy = 1;
     412             : 
     413             :     /* If we were overrun while processing a frag from an in, then
     414             :        cur_spot is left dangling and not cleaned up, so clean it up here
     415             :        (by returning the slot to the pool of free slots).  If the last
     416             :        transaction was a bundle, then we don't want to return it.  When
     417             :        we try to process the first transaction in the next bundle, we'll
     418             :        see we never got the full bundle and cancel the whole last
     419             :        bundle, returning all the storage to the pool. */
     420             : #if FD_PACK_USE_EXTRA_STORAGE
     421             :     if( FD_LIKELY( !ctx->insert_to_extra ) ) fd_pack_insert_txn_cancel( ctx->pack, ctx->cur_spot );
     422             :     else                                     extra_txn_deq_remove_tail( ctx->extra_txn_deq       );
     423             : #else
     424           0 :     fd_pack_insert_txn_cancel( ctx->pack, ctx->cur_spot );
     425           0 : #endif
     426           0 :     ctx->cur_spot = NULL;
     427           0 :   }
     428           0 : }
     429             : 
     430             : #if FD_PACK_USE_EXTRA_STORAGE
     431             : /* insert_from_extra: helper method to pop the transaction at the head
     432             :    off the extra txn deque and insert it into pack.  Requires that
     433             :    ctx->extra_txn_deq is non-empty, but it's okay to call it if pack is
     434             :    full.  Returns the result of fd_pack_insert_txn_fini. */
     435             : static inline int
     436             : insert_from_extra( fd_pack_ctx_t * ctx ) {
     437             :   fd_txn_e_t       * spot       = fd_pack_insert_txn_init( ctx->pack );
     438             :   fd_txn_e_t const * insert     = extra_txn_deq_peek_head( ctx->extra_txn_deq );
     439             :   fd_txn_t   const * insert_txn = TXN(insert->txnp);
     440             :   fd_memcpy( spot->txnp->payload, insert->txnp->payload, insert->txnp->payload_sz                                                     );
     441             :   fd_memcpy( TXN(spot->txnp),     insert_txn,            fd_txn_footprint( insert_txn->instr_cnt, insert_txn->addr_table_lookup_cnt ) );
     442             :   fd_memcpy( spot->alt_accts,     insert->alt_accts,     insert_txn->addr_table_adtl_cnt*sizeof(fd_acct_addr_t)                       );
     443             :   spot->txnp->payload_sz = insert->txnp->payload_sz;
     444             :   extra_txn_deq_remove_head( ctx->extra_txn_deq );
     445             : 
     446             :   ulong blockhash_slot = insert->txnp->blockhash_slot;
     447             : 
     448             :   long insert_duration = -fd_tickcount();
     449             :   int result = fd_pack_insert_txn_fini( ctx->pack, spot, blockhash_slot );
     450             :   insert_duration      += fd_tickcount();
     451             :   ctx->insert_result[ result + FD_PACK_INSERT_RETVAL_OFF ]++;
     452             :   fd_histf_sample( ctx->insert_duration, (ulong)insert_duration );
     453             :   FD_MCNT_INC( PACK, TRANSACTION_INSERTED_FROM_EXTRA, 1UL );
     454             :   return result;
     455             : }
     456             : #endif
     457             : 
     458             : static inline void
     459             : after_credit( fd_pack_ctx_t *     ctx,
     460             :               fd_stem_context_t * stem,
     461             :               int *               opt_poll_in,
     462           0 :               int *               charge_busy ) {
     463           0 :   (void)opt_poll_in;
     464             : 
     465           0 :   if( FD_UNLIKELY( (ctx->skip_cnt--)>0L ) ) return; /* It would take ages for this to hit LONG_MIN */
     466             : 
     467           0 :   long now = fd_tickcount();
     468             : 
     469           0 :   int pacing_bank_cnt = (int)fd_pack_pacing_enabled_bank_cnt( ctx->pacer, now );
     470             : 
     471           0 :   ulong bank_cnt = ctx->bank_cnt;
     472             : 
     473             :   /* If we're using CU rebates, then we have one in for each bank in
     474             :      addition to the two normal ones.  That means that after_credit will
     475             :      be called about (bank_cnt/2) times more frequently per transaction
     476             :      we receive. */
     477           0 :   fd_long_store_if( ctx->use_consumed_cus, &(ctx->skip_cnt), (long)(bank_cnt/2UL) );
     478             : 
     479             :   /* If any banks are busy, check one of the busy ones see if it is
     480             :      still busy. */
     481           0 :   if( FD_LIKELY( ctx->bank_idle_bitset!=fd_ulong_mask_lsb( (int)bank_cnt ) ) ) {
     482           0 :     int   poll_cursor = ctx->poll_cursor;
     483           0 :     ulong busy_bitset = (~ctx->bank_idle_bitset) & fd_ulong_mask_lsb( (int)bank_cnt );
     484             : 
     485             :     /* Suppose bank_cnt is 4 and idle_bitset looks something like this
     486             :        (pretending it's a uchar):
     487             :                 0000 1001
     488             :                        ^ busy cursor is 1
     489             :        Then busy_bitset is
     490             :                 0000 0110
     491             :        Rotate it right by 2 bits
     492             :                 1000 0001
     493             :        Find lsb returns 0, so busy cursor remains 2, and we poll bank 2.
     494             : 
     495             :        If instead idle_bitset were
     496             :                 0000 1110
     497             :                        ^
     498             :        The rotated version would be
     499             :                 0100 0000
     500             :        Find lsb will return 6, so busy cursor would be set to 0, and
     501             :        we'd poll bank 0, which is the right one. */
     502           0 :     poll_cursor++;
     503           0 :     poll_cursor = (poll_cursor + fd_ulong_find_lsb( fd_ulong_rotate_right( busy_bitset, (poll_cursor&63) ) )) & 63;
     504             : 
     505           0 :     if( FD_UNLIKELY(
     506             :         /* if microblock duration is 0, bypass the bank_ready_at check
     507             :            to avoid a potential cache miss.  Can't use an ifdef here
     508             :            because FD_UNLIKELY is a macro, but the compiler should
     509             :            eliminate the check easily. */
     510           0 :         ( (MICROBLOCK_DURATION_NS==0L) || (ctx->bank_ready_at[poll_cursor]<now) ) &&
     511           0 :         (fd_fseq_query( ctx->bank_current[poll_cursor] )==ctx->bank_expect[poll_cursor]) ) ) {
     512           0 :       *charge_busy = 1;
     513           0 :       ctx->bank_idle_bitset |= 1UL<<poll_cursor;
     514             : 
     515           0 :       long complete_duration = -fd_tickcount();
     516           0 :       int completed = fd_pack_microblock_complete( ctx->pack, (ulong)poll_cursor );
     517           0 :       complete_duration      += fd_tickcount();
     518           0 :       if( FD_LIKELY( completed ) ) fd_histf_sample( ctx->complete_duration, (ulong)complete_duration );
     519           0 :     }
     520             : 
     521           0 :     ctx->poll_cursor = poll_cursor;
     522           0 :   }
     523             : 
     524             : 
     525             :   /* If we time out on our slot, then stop being leader.  This can only
     526             :      happen in the first after_credit after a housekeeping. */
     527           0 :   if( FD_UNLIKELY( ctx->approx_wallclock_ns>=ctx->slot_end_ns && ctx->leader_slot!=ULONG_MAX ) ) {
     528           0 :     *charge_busy = 1;
     529             : 
     530           0 :     if( FD_UNLIKELY( ctx->slot_microblock_cnt<ctx->slot_max_microblocks )) {
     531             :       /* As an optimization, The PoH tile will automatically end a slot
     532             :          if it receives the maximum allowed microblocks, since it knows
     533             :          there is nothing left to receive.  In that case, we don't need
     534             :          to send a DONE_PACKING notification, since they are already on
     535             :          the next slot.  If we did send one it would just get dropped. */
     536           0 :       fd_done_packing_t * done_packing = fd_chunk_to_laddr( ctx->out_mem, ctx->out_chunk );
     537           0 :       done_packing->microblocks_in_slot = ctx->slot_microblock_cnt;
     538             : 
     539           0 :       fd_stem_publish( stem, 0UL, fd_disco_poh_sig( ctx->leader_slot, POH_PKT_TYPE_DONE_PACKING, ULONG_MAX ), ctx->out_chunk, sizeof(fd_done_packing_t), 0UL, 0UL, fd_frag_meta_ts_comp( fd_tickcount() ) );
     540           0 :       ctx->out_chunk = fd_dcache_compact_next( ctx->out_chunk, sizeof(fd_done_packing_t), ctx->out_chunk0, ctx->out_wmark );
     541           0 :     }
     542             : 
     543           0 :     log_end_block_metrics( ctx, now, "time" );
     544           0 :     ctx->drain_banks         = 1;
     545           0 :     ctx->leader_slot         = ULONG_MAX;
     546           0 :     ctx->slot_microblock_cnt = 0UL;
     547           0 :     fd_pack_end_block( ctx->pack );
     548           0 :     remove_ib( ctx );
     549             : 
     550           0 :     update_metric_state( ctx, now, FD_PACK_METRIC_STATE_LEADER,       0 );
     551           0 :     update_metric_state( ctx, now, FD_PACK_METRIC_STATE_BANKS,        0 );
     552           0 :     update_metric_state( ctx, now, FD_PACK_METRIC_STATE_MICROBLOCKS,  0 );
     553           0 :     return;
     554           0 :   }
     555             : 
     556             :   /* Am I leader? If not, see about inserting at most one transaction
     557             :      from extra storage.  It's important not to insert too many
     558             :      transactions here, or we won't end up servicing dedup_pack enough.
     559             :      If extra storage is empty or pack is full, do nothing. */
     560           0 :   if( FD_UNLIKELY( ctx->leader_slot==ULONG_MAX ) ) {
     561             : #if FD_PACK_USE_EXTRA_STORAGE
     562             :     if( FD_UNLIKELY( !extra_txn_deq_empty( ctx->extra_txn_deq ) &&
     563             :          fd_pack_avail_txn_cnt( ctx->pack )<ctx->max_pending_transactions ) ) {
     564             :       *charge_busy = 1;
     565             : 
     566             :       int result = insert_from_extra( ctx );
     567             :       if( FD_LIKELY( result>=0 ) ) ctx->last_successful_insert = now;
     568             :     }
     569             : #endif
     570           0 :     return;
     571           0 :   }
     572             : 
     573             :   /* Am I in drain mode?  If so, check if I can exit it */
     574           0 :   if( FD_UNLIKELY( ctx->drain_banks ) ) {
     575           0 :     if( FD_LIKELY( ctx->bank_idle_bitset==fd_ulong_mask_lsb( (int)bank_cnt ) ) ) ctx->drain_banks = 0;
     576           0 :     else                                                                         return;
     577           0 :   }
     578             : 
     579             :   /* Have I sent the max allowed microblocks? Nothing to do. */
     580           0 :   if( FD_UNLIKELY( ctx->slot_microblock_cnt>=ctx->slot_max_microblocks ) ) return;
     581             : 
     582             :   /* Do I have enough transactions and/or have I waited enough time? */
     583           0 :   if( FD_UNLIKELY( (ulong)(now-ctx->last_successful_insert) <
     584           0 :         ctx->wait_duration_ticks[ fd_ulong_min( fd_pack_avail_txn_cnt( ctx->pack ), MAX_TXN_PER_MICROBLOCK ) ] ) ) {
     585           0 :     update_metric_state( ctx, now, FD_PACK_METRIC_STATE_TRANSACTIONS, 0 );
     586           0 :     return;
     587           0 :   }
     588             : 
     589           0 :   int any_ready     = 0;
     590           0 :   int any_scheduled = 0;
     591             : 
     592           0 :   *charge_busy = 1;
     593             : 
     594           0 :   if( FD_LIKELY( ctx->crank->enabled ) ) {
     595           0 :     block_builder_info_t const * top_meta = fd_pack_peek_bundle_meta( ctx->pack );
     596           0 :     if( FD_UNLIKELY( top_meta ) ) {
     597             :       /* Have bundles, in a reasonable state to crank. */
     598             : 
     599           0 :       fd_txn_e_t * _bundle[ 1UL ];
     600           0 :       fd_txn_e_t * const * bundle = fd_pack_insert_bundle_init( ctx->pack, _bundle, 1UL );
     601             : 
     602           0 :       ulong txn_sz = fd_bundle_crank_generate( ctx->crank->gen, ctx->crank->prev_config, top_meta->commission_pubkey,
     603           0 :           ctx->crank->identity_pubkey, ctx->crank->tip_receiver_owner, ctx->crank->epoch, top_meta->commission,
     604           0 :           bundle[0]->txnp->payload, TXN( bundle[0]->txnp ) );
     605             : 
     606           0 :       if( FD_LIKELY( txn_sz==0UL ) ) { /* Everything in good shape! */
     607           0 :         fd_pack_insert_bundle_cancel( ctx->pack, bundle, 1UL );
     608           0 :         fd_pack_set_initializer_bundles_ready( ctx->pack );
     609           0 :         ctx->crank->metrics[ 0 ]++;
     610           0 :       }
     611           0 :       else if( FD_LIKELY( txn_sz<ULONG_MAX ) ) {
     612           0 :         bundle[0]->txnp->payload_sz = (ushort)txn_sz;
     613           0 :         memcpy( bundle[0]->txnp->payload+TXN(bundle[0]->txnp)->recent_blockhash_off, ctx->crank->recent_blockhash, 32UL );
     614             : 
     615           0 :         fd_keyguard_client_sign( ctx->crank->keyguard_client, bundle[0]->txnp->payload+1UL,
     616           0 :             bundle[0]->txnp->payload+65UL, txn_sz-65UL, FD_KEYGUARD_SIGN_TYPE_ED25519 );
     617             : 
     618           0 :         memcpy( ctx->crank->last_sig, bundle[0]->txnp->payload+1UL, 64UL );
     619             : 
     620           0 :         ctx->crank->ib_inserted = 1;
     621           0 :         int retval = fd_pack_insert_bundle_fini( ctx->pack, bundle, 1UL, ctx->leader_slot-1UL, 1, NULL );
     622           0 :         ctx->insert_result[ retval + FD_PACK_INSERT_RETVAL_OFF ]++;
     623           0 :         if( FD_UNLIKELY( retval<0 ) ) {
     624           0 :           ctx->crank->metrics[ 3 ]++;
     625           0 :           FD_LOG_WARNING(( "inserting initializer bundle returned %i", retval ));
     626           0 :         } else {
     627             :           /* Update the cached copy of the on-chain state.  This seems a
     628             :              little dangerous, since we're updating it as if the bundle
     629             :              succeeded without knowing if that's true, but here's why
     630             :              it's safe:
     631             : 
     632             :              From now until we get the rebate call for this initializer
     633             :              bundle (which lets us know if it succeeded or failed), pack
     634             :              will be in [Pending] state, which means peek_bundle_meta
     635             :              will return NULL, so we won't read this state.
     636             : 
     637             :              Then, if the initializer bundle failed, we'll go into
     638             :              [Failed] IB state until the end of the block, which will
     639             :              cause top_meta to remain NULL so we don't read these values
     640             :              again.
     641             : 
     642             :              Otherwise, the initializer bundle succeeded, which means
     643             :              that these are the right values to use. */
     644           0 :           fd_bundle_crank_apply( ctx->crank->gen, ctx->crank->prev_config, top_meta->commission_pubkey,
     645           0 :                                  ctx->crank->tip_receiver_owner, ctx->crank->epoch, top_meta->commission );
     646           0 :           ctx->crank->metrics[ 1 ]++;
     647           0 :         }
     648           0 :       } else {
     649             :         /* Already logged a warning in this case */
     650           0 :         fd_pack_insert_bundle_cancel( ctx->pack, bundle, 1UL );
     651           0 :         ctx->crank->metrics[ 2 ]++;
     652           0 :       }
     653           0 :     }
     654           0 :   }
     655             : 
     656             :   /* Try to schedule the next microblock. */
     657           0 :   if( FD_LIKELY( ctx->bank_idle_bitset ) ) { /* Optimize for schedule */
     658           0 :     any_ready = 1;
     659             : 
     660           0 :     int i = fd_ulong_find_lsb( ctx->bank_idle_bitset );
     661             : 
     662           0 :     int flags;
     663             : 
     664           0 :     switch( ctx->strategy ) {
     665           0 :       default:
     666           0 :       case FD_PACK_STRATEGY_PERF:
     667           0 :         flags = FD_PACK_SCHEDULE_VOTE | FD_PACK_SCHEDULE_BUNDLE | FD_PACK_SCHEDULE_TXN;
     668           0 :         break;
     669           0 :       case FD_PACK_STRATEGY_BALANCED:
     670             :         /* We want to exempt votes from pacing, so we always allow
     671             :            scheduling votes.  It doesn't really make much sense to pace
     672             :            bundles, because they get scheduled in FIFO order.  However,
     673             :            we keep pacing for normal transactions.  For example, if
     674             :            pacing_bank_cnt is 0, then pack won't schedule normal
     675             :            transactions to any bank tile. */
     676           0 :         flags = FD_PACK_SCHEDULE_VOTE | fd_int_if( i==0,              FD_PACK_SCHEDULE_BUNDLE, 0 )
     677           0 :                                       | fd_int_if( i<pacing_bank_cnt, FD_PACK_SCHEDULE_TXN,    0 );
     678           0 :         break;
     679           0 :       case FD_PACK_STRATEGY_BUNDLE:
     680           0 :         flags = FD_PACK_SCHEDULE_VOTE | FD_PACK_SCHEDULE_BUNDLE
     681           0 :                                       | fd_int_if( ctx->slot_end_ns - ctx->approx_wallclock_ns<50000000L, FD_PACK_SCHEDULE_TXN,  0 );
     682           0 :         break;
     683           0 :     }
     684             : 
     685           0 :     fd_txn_p_t * microblock_dst = fd_chunk_to_laddr( ctx->out_mem, ctx->out_chunk );
     686           0 :     long schedule_duration = -fd_tickcount();
     687           0 :     ulong schedule_cnt = fd_pack_schedule_next_microblock( ctx->pack, CUS_PER_MICROBLOCK, VOTE_FRACTION, (ulong)i, flags, microblock_dst );
     688           0 :     schedule_duration      += fd_tickcount();
     689           0 :     fd_histf_sample( (schedule_cnt>0UL) ? ctx->schedule_duration : ctx->no_sched_duration, (ulong)schedule_duration );
     690             : 
     691           0 :     if( FD_LIKELY( schedule_cnt ) ) {
     692           0 :       any_scheduled = 1;
     693           0 :       long  now2   = fd_tickcount();
     694           0 :       ulong tsorig = (ulong)fd_frag_meta_ts_comp( now  ); /* A bound on when we observed bank was idle */
     695           0 :       ulong tspub  = (ulong)fd_frag_meta_ts_comp( now2 );
     696           0 :       ulong chunk  = ctx->out_chunk;
     697           0 :       ulong msg_sz = schedule_cnt*sizeof(fd_txn_p_t);
     698           0 :       fd_microblock_bank_trailer_t * trailer = (fd_microblock_bank_trailer_t*)(microblock_dst+schedule_cnt);
     699           0 :       trailer->bank = ctx->leader_bank;
     700           0 :       trailer->microblock_idx = ctx->slot_microblock_cnt;
     701           0 :       trailer->pack_txn_idx = ctx->pack_txn_cnt;
     702           0 :       trailer->is_bundle = !!(microblock_dst->flags & FD_TXN_P_FLAGS_BUNDLE);
     703             : 
     704           0 :       ulong sig = fd_disco_poh_sig( ctx->leader_slot, POH_PKT_TYPE_MICROBLOCK, (ulong)i );
     705           0 :       fd_stem_publish( stem, 0UL, sig, chunk, msg_sz+sizeof(fd_microblock_bank_trailer_t), 0UL, tsorig, tspub );
     706           0 :       ctx->bank_expect[ i ] = stem->seqs[0]-1UL;
     707           0 :       ctx->bank_ready_at[i] = now2 + (long)ctx->microblock_duration_ticks;
     708           0 :       ctx->out_chunk = fd_dcache_compact_next( ctx->out_chunk, msg_sz+sizeof(fd_microblock_bank_trailer_t), ctx->out_chunk0, ctx->out_wmark );
     709           0 :       ctx->slot_microblock_cnt += fd_ulong_if( trailer->is_bundle, schedule_cnt, 1UL );
     710           0 :       ctx->pack_txn_cnt += schedule_cnt;
     711             : 
     712           0 :       ctx->bank_idle_bitset = fd_ulong_pop_lsb( ctx->bank_idle_bitset );
     713           0 :       ctx->skip_cnt         = (long)schedule_cnt * fd_long_if( ctx->use_consumed_cus, (long)bank_cnt/2L, 1L );
     714           0 :       fd_pack_pacing_update_consumed_cus( ctx->pacer, fd_pack_current_block_cost( ctx->pack ), now2 );
     715             : 
     716           0 :       memcpy( ctx->last_sched_metrics->all, (ulong const *)fd_metrics_tl, sizeof(ctx->last_sched_metrics->all) );
     717           0 :       ctx->last_sched_metrics->time = now2;
     718           0 :     }
     719           0 :   }
     720             : 
     721           0 :   update_metric_state( ctx, now, FD_PACK_METRIC_STATE_BANKS,       any_ready     );
     722           0 :   update_metric_state( ctx, now, FD_PACK_METRIC_STATE_MICROBLOCKS, any_scheduled );
     723           0 :   now = fd_tickcount();
     724           0 :   update_metric_state( ctx, now, FD_PACK_METRIC_STATE_TRANSACTIONS, fd_pack_avail_txn_cnt( ctx->pack )>0 );
     725             : 
     726             : #if FD_PACK_USE_EXTRA_STORAGE
     727             :   if( FD_UNLIKELY( !extra_txn_deq_empty( ctx->extra_txn_deq ) ) ) {
     728             :     /* Don't start pulling from the extra storage until the available
     729             :        transaction count drops below half. */
     730             :     ulong avail_space   = (ulong)fd_long_max( 0L, (long)(ctx->max_pending_transactions>>1)-(long)fd_pack_avail_txn_cnt( ctx->pack ) );
     731             :     ulong qty_to_insert = fd_ulong_min( 10UL, fd_ulong_min( extra_txn_deq_cnt( ctx->extra_txn_deq ), avail_space ) );
     732             :     int any_successes = 0;
     733             :     for( ulong i=0UL; i<qty_to_insert; i++ ) any_successes |= (0<=insert_from_extra( ctx ));
     734             :     if( FD_LIKELY( any_successes ) ) ctx->last_successful_insert = now;
     735             :   }
     736             : #endif
     737             : 
     738             :   /* Did we send the maximum allowed microblocks? Then end the slot. */
     739           0 :   if( FD_UNLIKELY( ctx->slot_microblock_cnt==ctx->slot_max_microblocks )) {
     740           0 :     update_metric_state( ctx, now, FD_PACK_METRIC_STATE_LEADER,       0 );
     741           0 :     update_metric_state( ctx, now, FD_PACK_METRIC_STATE_BANKS,        0 );
     742           0 :     update_metric_state( ctx, now, FD_PACK_METRIC_STATE_MICROBLOCKS,  0 );
     743             :     /* The pack object also does this accounting and increases this
     744             :        metric, but we end the slot early so won't see it unless we also
     745             :        increment it here. */
     746           0 :     FD_MCNT_INC( PACK, MICROBLOCK_PER_BLOCK_LIMIT, 1UL );
     747           0 :     log_end_block_metrics( ctx, now, "microblock" );
     748           0 :     ctx->drain_banks         = 1;
     749           0 :     ctx->leader_slot         = ULONG_MAX;
     750           0 :     ctx->slot_microblock_cnt = 0UL;
     751           0 :     fd_pack_end_block( ctx->pack );
     752           0 :     remove_ib( ctx );
     753             : 
     754           0 :   }
     755           0 : }
     756             : 
     757             : 
     758             : /* At this point, we have started receiving frag seq with details in
     759             :     mline at time now.  Speculatively process it here. */
     760             : 
     761             : static inline void
     762             : during_frag( fd_pack_ctx_t * ctx,
     763             :              ulong           in_idx,
     764             :              ulong           seq FD_PARAM_UNUSED,
     765             :              ulong           sig,
     766             :              ulong           chunk,
     767             :              ulong           sz,
     768           0 :              ulong           ctl FD_PARAM_UNUSED ) {
     769             : 
     770           0 :   uchar const * dcache_entry = fd_chunk_to_laddr_const( ctx->in[ in_idx ].mem, chunk );
     771             : 
     772           0 :   switch( ctx->in_kind[ in_idx ] ) {
     773           0 :   case IN_KIND_POH: {
     774             :       /* Not interested in stamped microblocks, only leader updates. */
     775           0 :     if( fd_disco_poh_sig_pkt_type( sig )!=POH_PKT_TYPE_BECAME_LEADER ) return;
     776             : 
     777             :     /* There was a leader transition.  Handle it. */
     778           0 :     if( FD_UNLIKELY( chunk<ctx->in[ in_idx ].chunk0 || chunk>ctx->in[ in_idx ].wmark || sz!=sizeof(fd_became_leader_t) ) )
     779           0 :       FD_LOG_ERR(( "chunk %lu %lu corrupt, not in range [%lu,%lu]", chunk, sz, ctx->in[ in_idx ].chunk0, ctx->in[ in_idx ].wmark ));
     780             : 
     781           0 :     long now_ticks = fd_tickcount();
     782           0 :     long now_ns    = fd_log_wallclock();
     783             : 
     784           0 :     if( FD_UNLIKELY( ctx->leader_slot!=ULONG_MAX ) ) {
     785           0 :       FD_LOG_WARNING(( "switching to slot %lu while packing for slot %lu. Draining bank tiles.", fd_disco_poh_sig_slot( sig ), ctx->leader_slot ));
     786           0 :       log_end_block_metrics( ctx, now_ticks, "switch" );
     787           0 :       ctx->drain_banks         = 1;
     788           0 :       ctx->leader_slot         = ULONG_MAX;
     789           0 :       ctx->slot_microblock_cnt = 0UL;
     790           0 :       fd_pack_end_block( ctx->pack );
     791           0 :       remove_ib( ctx );
     792           0 :     }
     793           0 :     ctx->leader_slot = fd_disco_poh_sig_slot( sig );
     794             : 
     795           0 :     ulong exp_cnt = fd_pack_expire_before( ctx->pack, fd_ulong_max( ctx->leader_slot, TRANSACTION_LIFETIME_SLOTS )-TRANSACTION_LIFETIME_SLOTS );
     796           0 :     FD_MCNT_INC( PACK, TRANSACTION_EXPIRED, exp_cnt );
     797             : 
     798           0 :     fd_became_leader_t * became_leader = (fd_became_leader_t *)dcache_entry;
     799           0 :     ctx->leader_bank          = became_leader->bank;
     800           0 :     ctx->slot_max_microblocks = became_leader->max_microblocks_in_slot;
     801             :     /* Reserve some space in the block for ticks */
     802           0 :     ctx->slot_max_data        = (ctx->larger_shred_limits_per_block ? LARGER_MAX_DATA_PER_BLOCK : FD_PACK_MAX_DATA_PER_BLOCK)
     803           0 :                                       - 48UL*(became_leader->ticks_per_slot+became_leader->total_skipped_ticks);
     804             : 
     805           0 :     ctx->limits.slot_max_cost                = became_leader->limits.slot_max_cost;
     806           0 :     ctx->limits.slot_max_vote_cost           = became_leader->limits.slot_max_vote_cost;
     807           0 :     ctx->limits.slot_max_write_cost_per_acct = became_leader->limits.slot_max_write_cost_per_acct;
     808             : 
     809             :     /* ticks_per_ns is probably relatively stable over 400ms, but not
     810             :        over several hours, so we need to compute the slot duration in
     811             :        milliseconds first and then convert to ticks.  This doesn't need
     812             :        to be super accurate, but we don't want it to vary wildly. */
     813           0 :     long end_ticks = now_ticks + (long)((double)fd_long_max( became_leader->slot_end_ns - now_ns, 1L )*ctx->ticks_per_ns);
     814             :     /* We may still get overrun, but then we'll never use this and just
     815             :        reinitialize it the next time when we actually become leader. */
     816           0 :     fd_pack_pacing_init( ctx->pacer, now_ticks, end_ticks, (float)ctx->ticks_per_ns, ctx->limits.slot_max_cost );
     817             : 
     818           0 :     if( FD_UNLIKELY( ctx->crank->enabled ) ) {
     819             :       /* If we get overrun, we'll just never use these values, but the
     820             :          old values aren't really useful either. */
     821           0 :       ctx->crank->epoch = became_leader->epoch;
     822           0 :       *(ctx->crank->prev_config) = *(became_leader->bundle->config);
     823           0 :       memcpy( ctx->crank->recent_blockhash,   became_leader->bundle->last_blockhash,     32UL );
     824           0 :       memcpy( ctx->crank->tip_receiver_owner, became_leader->bundle->tip_receiver_owner, 32UL );
     825           0 :     }
     826             : 
     827           0 :     FD_LOG_INFO(( "pack_became_leader(slot=%lu,ends_at=%ld)", ctx->leader_slot, became_leader->slot_end_ns ));
     828             : 
     829             :     /* The dcache might get overrun, so set slot_end_ns to 0, so if it does
     830             :        the slot will get skipped.  Then update it in the `after_frag` case
     831             :        below to the correct value. */
     832           0 :     ctx->slot_end_ns = 0L;
     833           0 :     ctx->_slot_end_ns = became_leader->slot_end_ns;
     834             : 
     835           0 :     update_metric_state( ctx, fd_tickcount(), FD_PACK_METRIC_STATE_LEADER, 1 );
     836           0 :     return;
     837           0 :   }
     838           0 :   case IN_KIND_BANK: {
     839           0 :     FD_TEST( ctx->use_consumed_cus );
     840             :       /* For a previous slot */
     841           0 :     if( FD_UNLIKELY( sig!=ctx->leader_slot ) ) return;
     842             : 
     843           0 :     if( FD_UNLIKELY( chunk<ctx->in[ in_idx ].chunk0 || chunk>ctx->in[ in_idx ].wmark || sz<FD_PACK_REBATE_MIN_SZ
     844           0 :           || sz>FD_PACK_REBATE_MAX_SZ ) )
     845           0 :       FD_LOG_ERR(( "chunk %lu %lu corrupt, not in range [%lu,%lu]", chunk, sz, ctx->in[ in_idx ].chunk0, ctx->in[ in_idx ].wmark ));
     846             : 
     847           0 :     ctx->pending_rebate_sz = sz;
     848           0 :     fd_memcpy( ctx->rebate, dcache_entry, sz );
     849           0 :     return;
     850           0 :   }
     851           0 :   case IN_KIND_RESOLV: {
     852           0 :     if( FD_UNLIKELY( chunk<ctx->in[ in_idx ].chunk0 || chunk>ctx->in[ in_idx ].wmark || sz>FD_TPU_RESOLVED_MTU ) )
     853           0 :       FD_LOG_ERR(( "chunk %lu %lu corrupt, not in range [%lu,%lu]", chunk, sz, ctx->in[ in_idx ].chunk0, ctx->in[ in_idx ].wmark ));
     854             : 
     855           0 :     fd_txn_m_t * txnm = (fd_txn_m_t *)dcache_entry;
     856           0 :     ulong payload_sz = txnm->payload_sz;
     857           0 :     ulong txn_t_sz   = txnm->txn_t_sz;
     858           0 :     FD_TEST( payload_sz<=FD_TPU_MTU    );
     859           0 :     FD_TEST( txn_t_sz  <=FD_TXN_MAX_SZ );
     860           0 :     fd_txn_t * txn  = fd_txn_m_txn_t( txnm );
     861             : 
     862           0 :     ulong addr_table_sz = 32UL*txn->addr_table_adtl_cnt;
     863           0 :     FD_TEST( addr_table_sz<=32UL*FD_TXN_ACCT_ADDR_MAX );
     864             : 
     865           0 :     if( FD_UNLIKELY( (ctx->leader_slot==ULONG_MAX) & (sig>ctx->highest_observed_slot) ) ) {
     866             :       /* Using the resolv tile's knowledge of the current slot is a bit
     867             :          of a hack, since we don't get any info if there are no
     868             :          transactions and we're not leader.  We're actually in exactly
     869             :          the case where that's okay though.  The point of calling
     870             :          expire_before long before we become leader is so that we don't
     871             :          drop new but low-fee-paying transactions when pack is clogged
     872             :          with expired but high-fee-paying transactions.  That can only
     873             :          happen if we are getting transactions. */
     874           0 :       ctx->highest_observed_slot = sig;
     875           0 :       ulong exp_cnt = fd_pack_expire_before( ctx->pack, fd_ulong_max( ctx->highest_observed_slot, TRANSACTION_LIFETIME_SLOTS )-TRANSACTION_LIFETIME_SLOTS );
     876           0 :       FD_MCNT_INC( PACK, TRANSACTION_EXPIRED, exp_cnt );
     877           0 :     }
     878             : 
     879             : 
     880           0 :     ulong bundle_id = txnm->block_engine.bundle_id;
     881           0 :     if( FD_UNLIKELY( bundle_id ) ) {
     882           0 :       ctx->is_bundle = 1;
     883           0 :       if( FD_LIKELY( bundle_id!=ctx->current_bundle->id ) ) {
     884           0 :         if( FD_UNLIKELY( ctx->current_bundle->bundle ) ) {
     885           0 :           FD_MCNT_INC( PACK, TRANSACTION_DROPPED_PARTIAL_BUNDLE, ctx->current_bundle->txn_received );
     886           0 :           fd_pack_insert_bundle_cancel( ctx->pack, ctx->current_bundle->bundle, ctx->current_bundle->txn_cnt );
     887           0 :         }
     888           0 :         ctx->current_bundle->id                 = bundle_id;
     889           0 :         ctx->current_bundle->txn_cnt            = txnm->block_engine.bundle_txn_cnt;
     890           0 :         ctx->current_bundle->min_blockhash_slot = ULONG_MAX;
     891           0 :         ctx->current_bundle->txn_received       = 0UL;
     892             : 
     893           0 :         if( FD_UNLIKELY( ctx->current_bundle->txn_cnt==0UL ) ) {
     894           0 :           FD_MCNT_INC( PACK, TRANSACTION_DROPPED_PARTIAL_BUNDLE, 1UL );
     895           0 :           ctx->current_bundle->id = 0UL;
     896           0 :           return;
     897           0 :         }
     898           0 :         ctx->blk_engine_cfg->commission = txnm->block_engine.commission;
     899           0 :         memcpy( ctx->blk_engine_cfg->commission_pubkey->b, txnm->block_engine.commission_pubkey, 32UL );
     900             : 
     901           0 :         ctx->current_bundle->bundle = fd_pack_insert_bundle_init( ctx->pack, ctx->current_bundle->_txn, ctx->current_bundle->txn_cnt );
     902           0 :       }
     903           0 :       ctx->cur_spot                           = ctx->current_bundle->bundle[ ctx->current_bundle->txn_received ];
     904           0 :       ctx->current_bundle->min_blockhash_slot = fd_ulong_min( ctx->current_bundle->min_blockhash_slot, sig );
     905           0 :     } else {
     906           0 :       ctx->is_bundle = 0;
     907             : #if FD_PACK_USE_EXTRA_STORAGE
     908             :       if( FD_LIKELY( ctx->leader_slot!=ULONG_MAX || fd_pack_avail_txn_cnt( ctx->pack )<ctx->max_pending_transactions ) ) {
     909             :         ctx->cur_spot = fd_pack_insert_txn_init( ctx->pack );
     910             :         ctx->insert_to_extra = 0;
     911             :       } else {
     912             :         if( FD_UNLIKELY( extra_txn_deq_full( ctx->extra_txn_deq ) ) ) {
     913             :           extra_txn_deq_remove_head( ctx->extra_txn_deq );
     914             :           FD_MCNT_INC( PACK, TRANSACTION_DROPPED_FROM_EXTRA, 1UL );
     915             :         }
     916             :         ctx->cur_spot = extra_txn_deq_peek_tail( extra_txn_deq_insert_tail( ctx->extra_txn_deq ) );
     917             :         /* We want to store the current time in cur_spot so that we can
     918             :            track its expiration better.  We just stash it in the CU
     919             :            fields, since those aren't important right now. */
     920             :         ctx->cur_spot->txnp->blockhash_slot = sig;
     921             :         ctx->insert_to_extra                = 1;
     922             :         FD_MCNT_INC( PACK, TRANSACTION_INSERTED_TO_EXTRA, 1UL );
     923             :       }
     924             : #else
     925           0 :       ctx->cur_spot = fd_pack_insert_txn_init( ctx->pack );
     926           0 : #endif
     927           0 :     }
     928             : 
     929             :     /* We get transactions from the resolv tile.
     930             :        The transactions should have been parsed and verified. */
     931           0 :     FD_MCNT_INC( PACK, NORMAL_TRANSACTION_RECEIVED, 1UL );
     932             : 
     933           0 :     fd_memcpy( ctx->cur_spot->txnp->payload, fd_txn_m_payload( txnm ), payload_sz    );
     934           0 :     fd_memcpy( TXN(ctx->cur_spot->txnp),     txn,                      txn_t_sz      );
     935           0 :     fd_memcpy( ctx->cur_spot->alt_accts,     fd_txn_m_alut( txnm ),    addr_table_sz );
     936           0 :     ctx->cur_spot->txnp->payload_sz = payload_sz;
     937           0 :     ctx->cur_spot->txnp->scheduler_arrival_time_nanos = ctx->approx_wallclock_ns + (long)((double)(fd_tickcount() - ctx->approx_tickcount) / ctx->ticks_per_ns);
     938             : 
     939           0 :     break;
     940           0 :   }
     941           0 :   case IN_KIND_EXECUTED_TXN: {
     942           0 :     FD_TEST( sz==64UL );
     943           0 :     fd_memcpy( ctx->executed_txn_sig, dcache_entry, sz );
     944           0 :     break;
     945           0 :   }
     946           0 :   }
     947           0 : }
     948             : 
     949             : 
     950             : /* After the transaction has been fully received, and we know we were
     951             :    not overrun while reading it, insert it into pack. */
     952             : 
     953             : static inline void
     954             : after_frag( fd_pack_ctx_t *     ctx,
     955             :             ulong               in_idx,
     956             :             ulong               seq,
     957             :             ulong               sig,
     958             :             ulong               sz,
     959             :             ulong               tsorig,
     960             :             ulong               tspub,
     961           0 :             fd_stem_context_t * stem ) {
     962           0 :   (void)seq;
     963           0 :   (void)sz;
     964           0 :   (void)tsorig;
     965           0 :   (void)tspub;
     966           0 :   (void)stem;
     967             : 
     968           0 :   long now = fd_tickcount();
     969             : 
     970           0 :   switch( ctx->in_kind[ in_idx ] ) {
     971           0 :   case IN_KIND_POH: {
     972           0 :     if( fd_disco_poh_sig_pkt_type( sig )!=POH_PKT_TYPE_BECAME_LEADER ) return;
     973             : 
     974           0 :     ctx->slot_end_ns = ctx->_slot_end_ns;
     975           0 :     fd_pack_limits_t limits[ 1 ];
     976           0 :     limits->max_cost_per_block = ctx->limits.slot_max_cost;
     977           0 :     limits->max_data_bytes_per_block = ctx->slot_max_data;
     978           0 :     limits->max_microblocks_per_block = ctx->slot_max_microblocks;
     979           0 :     limits->max_vote_cost_per_block = ctx->limits.slot_max_vote_cost;
     980           0 :     limits->max_write_cost_per_acct = ctx->limits.slot_max_write_cost_per_acct;
     981           0 :     limits->max_txn_per_microblock = ULONG_MAX; /* unused */
     982           0 :     fd_pack_set_block_limits( ctx->pack, limits );
     983           0 :     fd_pack_pacing_update_consumed_cus( ctx->pacer, fd_pack_current_block_cost( ctx->pack ), now );
     984             : 
     985           0 :     break;
     986           0 :   }
     987           0 :   case IN_KIND_BANK: {
     988             :     /* For a previous slot */
     989           0 :     if( FD_UNLIKELY( sig!=ctx->leader_slot ) ) return;
     990             : 
     991           0 :     fd_pack_rebate_cus( ctx->pack, ctx->rebate->rebate );
     992           0 :     ctx->pending_rebate_sz = 0UL;
     993           0 :     fd_pack_pacing_update_consumed_cus( ctx->pacer, fd_pack_current_block_cost( ctx->pack ), now );
     994           0 :     break;
     995           0 :   }
     996           0 :   case IN_KIND_RESOLV: {
     997             :     /* Normal transaction case */
     998             : #if FD_PACK_USE_EXTRA_STORAGE
     999             :     if( FD_LIKELY( !ctx->insert_to_extra ) ) {
    1000             : #else
    1001           0 :     if( 1 ) {
    1002           0 : #endif
    1003           0 :     if( FD_UNLIKELY( ctx->is_bundle ) ) {
    1004           0 :       if( FD_UNLIKELY( ctx->current_bundle->txn_cnt==0UL ) ) return;
    1005           0 :       if( FD_UNLIKELY( ++(ctx->current_bundle->txn_received)==ctx->current_bundle->txn_cnt ) ) {
    1006           0 :         long insert_duration = -fd_tickcount();
    1007           0 :         int result = fd_pack_insert_bundle_fini( ctx->pack, ctx->current_bundle->bundle, ctx->current_bundle->txn_cnt, ctx->current_bundle->min_blockhash_slot, 0, ctx->blk_engine_cfg );
    1008           0 :         insert_duration      += fd_tickcount();
    1009           0 :         ctx->insert_result[ result + FD_PACK_INSERT_RETVAL_OFF ] += ctx->current_bundle->txn_received;
    1010           0 :         fd_histf_sample( ctx->insert_duration, (ulong)insert_duration );
    1011           0 :         ctx->current_bundle->bundle = NULL;
    1012           0 :       }
    1013           0 :     } else {
    1014           0 :       ulong blockhash_slot = sig;
    1015           0 :       long insert_duration = -fd_tickcount();
    1016           0 :       int result = fd_pack_insert_txn_fini( ctx->pack, ctx->cur_spot, blockhash_slot );
    1017           0 :       insert_duration      += fd_tickcount();
    1018           0 :       ctx->insert_result[ result + FD_PACK_INSERT_RETVAL_OFF ]++;
    1019           0 :       fd_histf_sample( ctx->insert_duration, (ulong)insert_duration );
    1020           0 :       if( FD_LIKELY( result>=0 ) ) ctx->last_successful_insert = now;
    1021           0 :     }
    1022           0 :     }
    1023             : 
    1024           0 :     ctx->cur_spot = NULL;
    1025           0 :     break;
    1026           0 :   }
    1027           0 :   case IN_KIND_EXECUTED_TXN: {
    1028           0 :     int deleted = fd_pack_delete_transaction( ctx->pack, fd_type_pun( ctx->executed_txn_sig ) );
    1029           0 :     FD_MCNT_INC( PACK, TRANSACTION_DELETED, (ulong)deleted );
    1030           0 :     break;
    1031           0 :   }
    1032           0 :   }
    1033             : 
    1034           0 :   update_metric_state( ctx, now, FD_PACK_METRIC_STATE_TRANSACTIONS, fd_pack_avail_txn_cnt( ctx->pack )>0 );
    1035           0 : }
    1036             : 
    1037             : static void
    1038             : privileged_init( fd_topo_t *      topo,
    1039           0 :                  fd_topo_tile_t * tile ) {
    1040           0 :   if( FD_LIKELY( !tile->pack.bundle.enabled ) ) return;
    1041           0 :   if( FD_UNLIKELY( !tile->pack.bundle.vote_account_path[0] ) ) {
    1042           0 :     FD_LOG_WARNING(( "Disabling bundle crank because no vote account was specified" ));
    1043           0 :     return;
    1044           0 :   }
    1045             : 
    1046           0 :   void * scratch = fd_topo_obj_laddr( topo, tile->tile_obj_id );
    1047             : 
    1048           0 :   FD_SCRATCH_ALLOC_INIT( l, scratch );
    1049           0 :   fd_pack_ctx_t * ctx = FD_SCRATCH_ALLOC_APPEND( l, alignof( fd_pack_ctx_t ), sizeof( fd_pack_ctx_t ) );
    1050             : 
    1051           0 :   if( FD_UNLIKELY( !strcmp( tile->pack.bundle.identity_key_path, "" ) ) )
    1052           0 :     FD_LOG_ERR(( "identity_key_path not set" ));
    1053             : 
    1054           0 :   const uchar * identity_key = fd_keyload_load( tile->pack.bundle.identity_key_path, /* pubkey only: */ 1 );
    1055           0 :   fd_memcpy( ctx->crank->identity_pubkey->b, identity_key, 32UL );
    1056             : 
    1057           0 :   if( FD_UNLIKELY( !fd_base58_decode_32( tile->pack.bundle.vote_account_path, ctx->crank->vote_pubkey->b ) ) ) {
    1058           0 :     const uchar * vote_key = fd_keyload_load( tile->pack.bundle.vote_account_path, /* pubkey only: */ 1 );
    1059           0 :     fd_memcpy( ctx->crank->vote_pubkey->b, vote_key, 32UL );
    1060           0 :   }
    1061           0 : }
    1062             : 
    1063             : static void
    1064             : unprivileged_init( fd_topo_t *      topo,
    1065           0 :                    fd_topo_tile_t * tile ) {
    1066           0 :   void * scratch = fd_topo_obj_laddr( topo, tile->tile_obj_id );
    1067             : 
    1068           0 :   if( FD_UNLIKELY( tile->pack.max_pending_transactions >= USHORT_MAX-10UL ) ) FD_LOG_ERR(( "pack tile supports up to %lu pending transactions", USHORT_MAX-11UL ));
    1069             : 
    1070           0 :   fd_pack_limits_t limits_upper[1] = {{
    1071           0 :     .max_cost_per_block        = tile->pack.larger_max_cost_per_block ? LARGER_MAX_COST_PER_BLOCK : FD_PACK_MAX_COST_PER_BLOCK_UPPER_BOUND,
    1072           0 :     .max_vote_cost_per_block   = FD_PACK_MAX_VOTE_COST_PER_BLOCK_UPPER_BOUND,
    1073           0 :     .max_write_cost_per_acct   = FD_PACK_MAX_WRITE_COST_PER_ACCT_UPPER_BOUND,
    1074           0 :     .max_data_bytes_per_block  = tile->pack.larger_shred_limits_per_block ? LARGER_MAX_DATA_PER_BLOCK : FD_PACK_MAX_DATA_PER_BLOCK,
    1075           0 :     .max_txn_per_microblock    = EFFECTIVE_TXN_PER_MICROBLOCK,
    1076           0 :     .max_microblocks_per_block = (ulong)UINT_MAX, /* Limit not known yet */
    1077           0 :   }};
    1078             : 
    1079           0 :   ulong pack_footprint = fd_pack_footprint( tile->pack.max_pending_transactions, BUNDLE_META_SZ, tile->pack.bank_tile_count, limits_upper );
    1080             : 
    1081           0 :   FD_SCRATCH_ALLOC_INIT( l, scratch );
    1082           0 :   fd_pack_ctx_t * ctx = FD_SCRATCH_ALLOC_APPEND( l, alignof( fd_pack_ctx_t ), sizeof( fd_pack_ctx_t ) );
    1083           0 :   fd_rng_t *      rng = fd_rng_join( fd_rng_new( FD_SCRATCH_ALLOC_APPEND( l, fd_rng_align(), fd_rng_footprint() ), 0U, 0UL ) );
    1084           0 :   if( FD_UNLIKELY( !rng ) ) FD_LOG_ERR(( "fd_rng_new failed" ));
    1085             : 
    1086           0 :   fd_pack_limits_t limits_lower[1] = {{
    1087           0 :     .max_cost_per_block        = tile->pack.larger_max_cost_per_block ? LARGER_MAX_COST_PER_BLOCK : FD_PACK_MAX_COST_PER_BLOCK_LOWER_BOUND,
    1088           0 :     .max_vote_cost_per_block   = FD_PACK_MAX_VOTE_COST_PER_BLOCK_LOWER_BOUND,
    1089           0 :     .max_write_cost_per_acct   = FD_PACK_MAX_WRITE_COST_PER_ACCT_LOWER_BOUND,
    1090           0 :     .max_data_bytes_per_block  = tile->pack.larger_shred_limits_per_block ? LARGER_MAX_DATA_PER_BLOCK : FD_PACK_MAX_DATA_PER_BLOCK,
    1091           0 :     .max_txn_per_microblock    = EFFECTIVE_TXN_PER_MICROBLOCK,
    1092           0 :     .max_microblocks_per_block = (ulong)UINT_MAX, /* Limit not known yet */
    1093           0 :   }};
    1094             : 
    1095           0 :   ctx->pack = fd_pack_join( fd_pack_new( FD_SCRATCH_ALLOC_APPEND( l, fd_pack_align(), pack_footprint ),
    1096           0 :                                          tile->pack.max_pending_transactions, BUNDLE_META_SZ, tile->pack.bank_tile_count,
    1097           0 :                                          limits_lower, rng ) );
    1098           0 :   if( FD_UNLIKELY( !ctx->pack ) ) FD_LOG_ERR(( "fd_pack_new failed" ));
    1099             : 
    1100           0 :   if( FD_UNLIKELY( tile->in_cnt>32UL ) ) FD_LOG_ERR(( "Too many input links (%lu>32) to pack tile", tile->in_cnt ));
    1101             : 
    1102           0 :   for( ulong i=0UL; i<tile->in_cnt; i++ ) {
    1103           0 :     fd_topo_link_t const * link = &topo->links[ tile->in_link_id[ i ] ];
    1104             : 
    1105           0 :     if( FD_LIKELY(      !strcmp( link->name, "resolv_pack"  ) ) ) ctx->in_kind[ i ] = IN_KIND_RESOLV;
    1106           0 :     else if( FD_LIKELY( !strcmp( link->name, "dedup_pack"   ) ) ) ctx->in_kind[ i ] = IN_KIND_RESOLV;
    1107           0 :     else if( FD_LIKELY( !strcmp( link->name, "poh_pack"     ) ) ) ctx->in_kind[ i ] = IN_KIND_POH;
    1108           0 :     else if( FD_LIKELY( !strcmp( link->name, "bank_pack"    ) ) ) ctx->in_kind[ i ] = IN_KIND_BANK;
    1109           0 :     else if( FD_LIKELY( !strcmp( link->name, "sign_pack"    ) ) ) ctx->in_kind[ i ] = IN_KIND_SIGN;
    1110           0 :     else if( FD_LIKELY( !strcmp( link->name, "executed_txn" ) ) ) ctx->in_kind[ i ] = IN_KIND_EXECUTED_TXN;
    1111           0 :     else FD_LOG_ERR(( "pack tile has unexpected input link %lu %s", i, link->name ));
    1112           0 :   }
    1113             : 
    1114           0 :   ulong bank_cnt = 0UL;
    1115           0 :   for( ulong i=0UL; i<topo->tile_cnt; i++ ) {
    1116           0 :     fd_topo_tile_t const * consumer_tile = &topo->tiles[ i ];
    1117           0 :     if( FD_UNLIKELY( strcmp( consumer_tile->name, "bank" ) && strcmp( consumer_tile->name, "replay" ) ) ) continue;
    1118           0 :     for( ulong j=0UL; j<consumer_tile->in_cnt; j++ ) {
    1119           0 :       if( FD_UNLIKELY( consumer_tile->in_link_id[ j ]==tile->out_link_id[ 0 ] ) ) bank_cnt++;
    1120           0 :     }
    1121           0 :   }
    1122             : 
    1123           0 :   if( FD_UNLIKELY( !bank_cnt                            ) ) FD_LOG_ERR(( "pack tile connects to no banking tiles" ));
    1124           0 :   if( FD_UNLIKELY( bank_cnt>FD_PACK_MAX_BANK_TILES      ) ) FD_LOG_ERR(( "pack tile connects to too many banking tiles" ));
    1125           0 :   if( FD_UNLIKELY( bank_cnt!=tile->pack.bank_tile_count ) ) FD_LOG_ERR(( "pack tile connects to %lu banking tiles, but tile->pack.bank_tile_count is %lu", bank_cnt, tile->pack.bank_tile_count ));
    1126             : 
    1127           0 :   FD_TEST( (tile->pack.schedule_strategy>=0) & (tile->pack.schedule_strategy<=FD_PACK_STRATEGY_BUNDLE) );
    1128             : 
    1129           0 :   ctx->crank->enabled = tile->pack.bundle.enabled;
    1130           0 :   if( FD_UNLIKELY( tile->pack.bundle.enabled ) ) {
    1131           0 :     if( FD_UNLIKELY( !fd_bundle_crank_gen_init( ctx->crank->gen, (fd_acct_addr_t const *)tile->pack.bundle.tip_distribution_program_addr,
    1132           0 :             (fd_acct_addr_t const *)tile->pack.bundle.tip_payment_program_addr,
    1133           0 :             (fd_acct_addr_t const *)ctx->crank->vote_pubkey->b,
    1134           0 :             (fd_acct_addr_t const *)tile->pack.bundle.tip_distribution_authority,
    1135           0 :             schedule_strategy_strings[ tile->pack.schedule_strategy ],
    1136           0 :             tile->pack.bundle.commission_bps ) ) ) {
    1137           0 :       FD_LOG_ERR(( "constructing bundle generator failed" ));
    1138           0 :     }
    1139             : 
    1140           0 :     ulong sign_in_idx  = fd_topo_find_tile_in_link ( topo, tile, "sign_pack", tile->kind_id );
    1141           0 :     ulong sign_out_idx = fd_topo_find_tile_out_link( topo, tile, "pack_sign", tile->kind_id );
    1142           0 :     FD_TEST( sign_in_idx!=ULONG_MAX );
    1143           0 :     fd_topo_link_t * sign_in = &topo->links[ tile->in_link_id[ sign_in_idx ] ];
    1144           0 :     fd_topo_link_t * sign_out = &topo->links[ tile->out_link_id[ sign_out_idx ] ];
    1145           0 :     if( FD_UNLIKELY( !fd_keyguard_client_join( fd_keyguard_client_new( ctx->crank->keyguard_client,
    1146           0 :             sign_out->mcache,
    1147           0 :             sign_out->dcache,
    1148           0 :             sign_in->mcache,
    1149           0 :             sign_in->dcache ) ) ) ) {
    1150           0 :       FD_LOG_ERR(( "failed to construct keyguard" ));
    1151           0 :     }
    1152             :     /* Initialize enough of the prev config that it produces a
    1153             :        transaction */
    1154           0 :     ctx->crank->prev_config->discriminator       = 0x82ccfa1ee0aa0c9bUL;
    1155           0 :     ctx->crank->prev_config->tip_receiver->b[1]  = 1;
    1156           0 :     ctx->crank->prev_config->block_builder->b[2] = 1;
    1157             : 
    1158           0 :     memset( ctx->crank->tip_receiver_owner, '\0', 32UL );
    1159           0 :     memset( ctx->crank->recent_blockhash,   '\0', 32UL );
    1160           0 :     memset( ctx->crank->last_sig,           '\0', 64UL );
    1161           0 :     ctx->crank->ib_inserted    = 0;
    1162           0 :     ctx->crank->epoch          = 0UL;
    1163           0 :     ctx->crank->keyswitch = fd_keyswitch_join( fd_topo_obj_laddr( topo, tile->keyswitch_obj_id ) );
    1164           0 :     FD_TEST( ctx->crank->keyswitch );
    1165           0 :   } else {
    1166           0 :     memset( ctx->crank, '\0', sizeof(ctx->crank) );
    1167           0 :   }
    1168             : 
    1169             : 
    1170             : #if FD_PACK_USE_EXTRA_STORAGE
    1171             :   ctx->extra_txn_deq = extra_txn_deq_join( extra_txn_deq_new( FD_SCRATCH_ALLOC_APPEND( l, extra_txn_deq_align(),
    1172             :                                                                                           extra_txn_deq_footprint() ) ) );
    1173             : #endif
    1174             : 
    1175           0 :   ctx->cur_spot                      = NULL;
    1176           0 :   ctx->is_bundle                     = 0;
    1177           0 :   ctx->strategy                      = tile->pack.schedule_strategy;
    1178           0 :   ctx->max_pending_transactions      = tile->pack.max_pending_transactions;
    1179           0 :   ctx->leader_slot                   = ULONG_MAX;
    1180           0 :   ctx->leader_bank                   = NULL;
    1181           0 :   ctx->slot_microblock_cnt           = 0UL;
    1182           0 :   ctx->pack_txn_cnt                  = 0UL;
    1183           0 :   ctx->slot_max_microblocks          = 0UL;
    1184           0 :   ctx->slot_max_data                 = 0UL;
    1185           0 :   ctx->larger_shred_limits_per_block = tile->pack.larger_shred_limits_per_block;
    1186           0 :   ctx->drain_banks                   = 0;
    1187           0 :   ctx->approx_wallclock_ns           = fd_log_wallclock();
    1188           0 :   ctx->approx_tickcount              = fd_tickcount();
    1189           0 :   ctx->rng                           = rng;
    1190           0 :   ctx->ticks_per_ns                  = fd_tempo_tick_per_ns( NULL );
    1191           0 :   ctx->last_successful_insert        = 0L;
    1192           0 :   ctx->highest_observed_slot         = 0UL;
    1193           0 :   ctx->microblock_duration_ticks     = (ulong)(fd_tempo_tick_per_ns( NULL )*(double)MICROBLOCK_DURATION_NS  + 0.5);
    1194             : #if FD_PACK_USE_EXTRA_STORAGE
    1195             :   ctx->insert_to_extra               = 0;
    1196             : #endif
    1197           0 :   ctx->use_consumed_cus              = tile->pack.use_consumed_cus;
    1198           0 :   ctx->crank->enabled                = tile->pack.bundle.enabled;
    1199             : 
    1200           0 :   ctx->wait_duration_ticks[ 0 ] = ULONG_MAX;
    1201           0 :   for( ulong i=1UL; i<MAX_TXN_PER_MICROBLOCK+1UL; i++ ) {
    1202           0 :     ctx->wait_duration_ticks[ i ]=(ulong)(fd_tempo_tick_per_ns( NULL )*(double)wait_duration[ i ] + 0.5);
    1203           0 :   }
    1204             : 
    1205           0 :   ctx->limits.slot_max_cost                = limits_lower->max_cost_per_block;
    1206           0 :   ctx->limits.slot_max_vote_cost           = limits_lower->max_vote_cost_per_block;
    1207           0 :   ctx->limits.slot_max_write_cost_per_acct = limits_lower->max_write_cost_per_acct;
    1208             : 
    1209           0 :   ctx->bank_cnt         = tile->pack.bank_tile_count;
    1210           0 :   ctx->poll_cursor      = 0;
    1211           0 :   ctx->skip_cnt         = 0L;
    1212           0 :   ctx->bank_idle_bitset = fd_ulong_mask_lsb( (int)tile->pack.bank_tile_count );
    1213           0 :   for( ulong i=0UL; i<tile->pack.bank_tile_count; i++ ) {
    1214           0 :     ulong busy_obj_id = fd_pod_queryf_ulong( topo->props, ULONG_MAX, "bank_busy.%lu", i );
    1215           0 :     FD_TEST( busy_obj_id!=ULONG_MAX );
    1216           0 :     ctx->bank_current[ i ] = fd_fseq_join( fd_topo_obj_laddr( topo, busy_obj_id ) );
    1217           0 :     ctx->bank_expect[ i ] = ULONG_MAX;
    1218           0 :     if( FD_UNLIKELY( !ctx->bank_current[ i ] ) ) FD_LOG_ERR(( "banking tile %lu has no busy flag", i ));
    1219           0 :     ctx->bank_ready_at[ i ] = 0L;
    1220           0 :     FD_TEST( ULONG_MAX==fd_fseq_query( ctx->bank_current[ i ] ) );
    1221           0 :   }
    1222             : 
    1223           0 :   for( ulong i=0UL; i<tile->in_cnt; i++ ) {
    1224           0 :     fd_topo_link_t * link = &topo->links[ tile->in_link_id[ i ] ];
    1225           0 :     fd_topo_wksp_t * link_wksp = &topo->workspaces[ topo->objs[ link->dcache_obj_id ].wksp_id ];
    1226             : 
    1227           0 :     ctx->in[ i ].mem    = link_wksp->wksp;
    1228           0 :     ctx->in[ i ].chunk0 = fd_dcache_compact_chunk0( ctx->in[ i ].mem, link->dcache );
    1229           0 :     ctx->in[ i ].wmark  = fd_dcache_compact_wmark ( ctx->in[ i ].mem, link->dcache, link->mtu );
    1230           0 :   }
    1231             : 
    1232           0 :   ctx->out_mem    = topo->workspaces[ topo->objs[ topo->links[ tile->out_link_id[ 0 ] ].dcache_obj_id ].wksp_id ].wksp;
    1233           0 :   ctx->out_chunk0 = fd_dcache_compact_chunk0( ctx->out_mem, topo->links[ tile->out_link_id[ 0 ] ].dcache );
    1234           0 :   ctx->out_wmark  = fd_dcache_compact_wmark ( ctx->out_mem, topo->links[ tile->out_link_id[ 0 ] ].dcache, topo->links[ tile->out_link_id[ 0 ] ].mtu );
    1235           0 :   ctx->out_chunk  = ctx->out_chunk0;
    1236             : 
    1237             :   /* Initialize metrics storage */
    1238           0 :   memset( ctx->insert_result, '\0', FD_PACK_INSERT_RETVAL_CNT * sizeof(ulong) );
    1239           0 :   fd_histf_join( fd_histf_new( ctx->schedule_duration, FD_MHIST_SECONDS_MIN( PACK, SCHEDULE_MICROBLOCK_DURATION_SECONDS ),
    1240           0 :                                                        FD_MHIST_SECONDS_MAX( PACK, SCHEDULE_MICROBLOCK_DURATION_SECONDS ) ) );
    1241           0 :   fd_histf_join( fd_histf_new( ctx->no_sched_duration, FD_MHIST_SECONDS_MIN( PACK, NO_SCHED_MICROBLOCK_DURATION_SECONDS ),
    1242           0 :                                                        FD_MHIST_SECONDS_MAX( PACK, NO_SCHED_MICROBLOCK_DURATION_SECONDS ) ) );
    1243           0 :   fd_histf_join( fd_histf_new( ctx->insert_duration,   FD_MHIST_SECONDS_MIN( PACK, INSERT_TRANSACTION_DURATION_SECONDS  ),
    1244           0 :                                                        FD_MHIST_SECONDS_MAX( PACK, INSERT_TRANSACTION_DURATION_SECONDS  ) ) );
    1245           0 :   fd_histf_join( fd_histf_new( ctx->complete_duration, FD_MHIST_SECONDS_MIN( PACK, COMPLETE_MICROBLOCK_DURATION_SECONDS ),
    1246           0 :                                                        FD_MHIST_SECONDS_MAX( PACK, COMPLETE_MICROBLOCK_DURATION_SECONDS  ) ) );
    1247           0 :   ctx->metric_state = 0;
    1248           0 :   ctx->metric_state_begin = fd_tickcount();
    1249           0 :   memset( ctx->metric_timing,      '\0', 16*sizeof(long)                 );
    1250           0 :   memset( ctx->current_bundle,     '\0', sizeof(ctx->current_bundle)     );
    1251           0 :   memset( ctx->blk_engine_cfg,     '\0', sizeof(ctx->blk_engine_cfg)     );
    1252           0 :   memset( ctx->last_sched_metrics, '\0', sizeof(ctx->last_sched_metrics) );
    1253             : 
    1254           0 :   FD_LOG_INFO(( "packing microblocks of at most %lu transactions to %lu bank tiles using strategy %i", EFFECTIVE_TXN_PER_MICROBLOCK, tile->pack.bank_tile_count, ctx->strategy ));
    1255             : 
    1256           0 :   ulong scratch_top = FD_SCRATCH_ALLOC_FINI( l, 1UL );
    1257           0 :   if( FD_UNLIKELY( scratch_top > (ulong)scratch + scratch_footprint( tile ) ) )
    1258           0 :     FD_LOG_ERR(( "scratch overflow %lu %lu %lu", scratch_top - (ulong)scratch - scratch_footprint( tile ), scratch_top, (ulong)scratch + scratch_footprint( tile ) ));
    1259             : 
    1260           0 : }
    1261             : 
    1262             : static ulong
    1263             : populate_allowed_seccomp( fd_topo_t const *      topo,
    1264             :                           fd_topo_tile_t const * tile,
    1265             :                           ulong                  out_cnt,
    1266           0 :                           struct sock_filter *   out ) {
    1267           0 :   (void)topo;
    1268           0 :   (void)tile;
    1269             : 
    1270           0 :   populate_sock_filter_policy_fd_pack_tile( out_cnt, out, (uint)fd_log_private_logfile_fd() );
    1271           0 :   return sock_filter_policy_fd_pack_tile_instr_cnt;
    1272           0 : }
    1273             : 
    1274             : static ulong
    1275             : populate_allowed_fds( fd_topo_t const *      topo,
    1276             :                       fd_topo_tile_t const * tile,
    1277             :                       ulong                  out_fds_cnt,
    1278           0 :                       int *                  out_fds ) {
    1279           0 :   (void)topo;
    1280           0 :   (void)tile;
    1281             : 
    1282           0 :   if( FD_UNLIKELY( out_fds_cnt<2UL ) ) FD_LOG_ERR(( "out_fds_cnt %lu", out_fds_cnt ));
    1283             : 
    1284           0 :   ulong out_cnt = 0UL;
    1285           0 :   out_fds[ out_cnt++ ] = 2; /* stderr */
    1286           0 :   if( FD_LIKELY( -1!=fd_log_private_logfile_fd() ) )
    1287           0 :     out_fds[ out_cnt++ ] = fd_log_private_logfile_fd(); /* logfile */
    1288           0 :   return out_cnt;
    1289           0 : }
    1290             : 
    1291           0 : #define STEM_BURST (1UL)
    1292             : 
    1293             : /* We want lazy (measured in ns) to be small enough that the producer
    1294             :     and the consumer never have to wait for credits.  For most tango
    1295             :     links, we use a default worst case speed coming from 100 Gbps
    1296             :     Ethernet.  That's not very suitable for microblocks that go from
    1297             :     pack to bank.  Instead we manually estimate the very aggressive
    1298             :     1000ns per microblock, and then reduce it further (in line with the
    1299             :     default lazy value computation) to ensure the random value chosen
    1300             :     based on this won't lead to credit return stalls. */
    1301           0 : #define STEM_LAZY  (128L*3000L)
    1302             : 
    1303           0 : #define STEM_CALLBACK_CONTEXT_TYPE  fd_pack_ctx_t
    1304           0 : #define STEM_CALLBACK_CONTEXT_ALIGN alignof(fd_pack_ctx_t)
    1305             : 
    1306           0 : #define STEM_CALLBACK_DURING_HOUSEKEEPING during_housekeeping
    1307           0 : #define STEM_CALLBACK_BEFORE_CREDIT       before_credit
    1308           0 : #define STEM_CALLBACK_AFTER_CREDIT        after_credit
    1309           0 : #define STEM_CALLBACK_DURING_FRAG         during_frag
    1310           0 : #define STEM_CALLBACK_AFTER_FRAG          after_frag
    1311           0 : #define STEM_CALLBACK_METRICS_WRITE       metrics_write
    1312             : 
    1313             : #include "../stem/fd_stem.c"
    1314             : 
    1315             : fd_topo_run_tile_t fd_tile_pack = {
    1316             :   .name                     = "pack",
    1317             :   .populate_allowed_seccomp = populate_allowed_seccomp,
    1318             :   .populate_allowed_fds     = populate_allowed_fds,
    1319             :   .scratch_align            = scratch_align,
    1320             :   .scratch_footprint        = scratch_footprint,
    1321             :   .privileged_init          = privileged_init,
    1322             :   .unprivileged_init        = unprivileged_init,
    1323             :   .run                      = stem_run,
    1324             : };

Generated by: LCOV version 1.14