LCOV - code coverage report
Current view: top level - flamenco/leaders - fd_leaders.h (source / functions) Hit Total Coverage
Test: cov.lcov Lines: 21 21 100.0 %
Date: 2024-11-13 11:58:15 Functions: 4 114 3.5 %

          Line data    Source code
       1             : #ifndef HEADER_fd_src_flamenco_leaders_fd_leaders_h
       2             : #define HEADER_fd_src_flamenco_leaders_fd_leaders_h
       3             : 
       4             : /* fd_leaders provides APIs for the Solana leader schedule.
       5             :    Logic is compatible with Solana mainnet as of 2023-Jul.
       6             : 
       7             :    Every slot is assigned a leader (identified by a "node identity"
       8             :    public key).  The sequence of leaders for all slots in an epoch is
       9             :    called the "leader schedule".  The main responsibility of the leader
      10             :    is to produce a block for the slot.
      11             : 
      12             :    The leader schedule is divided into sched_cnt rotations.  Each
      13             :    rotation spans one or more slots, such that
      14             : 
      15             :      slots_per_epoch = sched_cnt * slots_per_rotation
      16             : 
      17             :    The leader can only change between rotations.  An example leader
      18             :    schedule looks as follows (where A, B, C are node identities and each
      19             :    column is a slot, with 4 slots per rotation)
      20             : 
      21             :      A  A  A  A  B  B  B  B  B  B  B  B  C  C  C  C  A  A  A  A
      22             :      ^           ^           ^           ^           ^
      23             :      rotation    rotation    rotation    rotation    rotation
      24             : 
      25             :    The mainnet epoch duration is quite long (currently 432000 slots, for
      26             :    more information see fd_sysvar_epoch_schedule.h).  To save space, we
      27             :    dedup pubkeys into a lookup table and only store an index for each
      28             :    rotation. */
      29             : 
      30             : #include "../fd_flamenco_base.h"
      31             : #include "../types/fd_types.h"
      32             : #include "../../ballet/wsample/fd_wsample.h"
      33             : 
      34      217572 : #define MAX_SLOTS_CNT         432000UL
      35      217572 : #define MAX_PUB_CNT           50000UL
      36             : 
      37             : #define FD_ULONG_MAX(  a, b ) (__builtin_choose_expr( __builtin_constant_p( a ) & __builtin_constant_p( b ),        \
      38             :                                                       ((ulong )(a))>=((ulong )(b)) ? ((ulong )(a)) : ((ulong )(b)), \
      39             :                                                       fd_ulong_max( (a), (b) ) ))
      40             : 
      41             : /* FD_EPOCH_LEADERS_{ALIGN,FOOTPRINT} are compile-time-friendly versions
      42             :    of the fd_epoch_leaders_{align,footprint} functions. */
      43             : 
      44      217572 : #define FD_EPOCH_LEADERS_ALIGN (64UL)
      45             : #define FD_EPOCH_LEADERS_FOOTPRINT( pub_cnt, slot_cnt )                                              \
      46      223767 :   ( FD_LAYOUT_FINI( FD_LAYOUT_APPEND( FD_LAYOUT_APPEND(                                              \
      47      223767 :     FD_LAYOUT_INIT,                                                                                  \
      48      223767 :       alignof(fd_epoch_leaders_t), sizeof(fd_epoch_leaders_t)                            ),          \
      49      223767 :       alignof(uint),               (                                                                 \
      50      223767 :         (slot_cnt+FD_EPOCH_SLOTS_PER_ROTATION-1UL)/FD_EPOCH_SLOTS_PER_ROTATION*sizeof(uint)          \
      51      223767 :         )                                                                                ),          \
      52      223767 :       FD_EPOCH_LEADERS_ALIGN                                                             )  +        \
      53      223767 :       FD_ULONG_ALIGN_UP( FD_ULONG_MAX( 32UL*((pub_cnt)+1UL),                                         \
      54      223767 :                                        FD_WSAMPLE_FOOTPRINT( pub_cnt, 0 ) ), 64UL ) )
      55             : 
      56     6705537 : #define FD_EPOCH_SLOTS_PER_ROTATION (4UL)
      57             : 
      58             : /* fd_epoch_leaders_t contains the leader schedule of a Solana epoch. */
      59             : 
      60             : struct fd_epoch_leaders {
      61             :   /* This struct contains the schedule for epoch `epoch` which spans
      62             :      slots [slot0, slot0+slot_cnt). */
      63             :   ulong epoch;
      64             :   ulong slot0;
      65             :   ulong slot_cnt;
      66             : 
      67             :   /* pub is a lookup table for node public keys with length pub_cnt */
      68             :   fd_pubkey_t * pub;
      69             :   ulong         pub_cnt;
      70             : 
      71             :   /* sched contains the leader schedule in the form of indexes into
      72             :      the pub array.  For sched_cnt, refer to below. */
      73             :   uint *        sched;
      74             :   ulong         sched_cnt;
      75             : };
      76             : typedef struct fd_epoch_leaders fd_epoch_leaders_t;
      77             : 
      78             : FD_PROTOTYPES_BEGIN
      79             : 
      80             : /* fd_epoch_leaders_{align,footprint} describe the required footprint
      81             :    and alignment of the leader schedule object.  pub_cnt is the number
      82             :    of unique public keys.  slot_cnt is the number of slots in the
      83             :    epoch. */
      84             : 
      85             : FD_FN_CONST ulong
      86             : fd_epoch_leaders_align( void );
      87             : 
      88             : FD_FN_CONST ulong
      89             : fd_epoch_leaders_footprint( ulong pub_cnt,
      90             :                             ulong slot_cnt );
      91             : 
      92             : /* fd_epoch_leaders_new formats a memory region for use as a leader
      93             :    schedule object.  shmem points to the first byte of a memory region
      94             :    with matching alignment and footprint requirements.  The leader
      95             :    schedule object will contain the leader schedule for epoch `epoch`
      96             :    which spans slots [slot0, slot0+slot_cnt).  `slot0` must be the first
      97             :    slot in the epoch, but slot_cnt can be less than the length of the
      98             :    epoch to derive only the first portion of the leader schedule.
      99             :    pub_cnt is the number of unique public keys in this schedule.
     100             :    `stakes` points to the first entry of pub_cnt entries of stake
     101             :    weights sorted by tuple (stake, pubkey) in descending order.
     102             : 
     103             :    If `stakes` does not include all staked nodes, e.g. in the case of an
     104             :    attack that swamps the network with fake validators, `stakes` should
     105             :    contain the first `pub_cnt` of them in the normal sort order, and the
     106             :    sum of the remaining stake must be provided in excluded_stake,
     107             :    measured in lamports.
     108             : 
     109             :    Does NOT retain a read interest in stakes upon return.
     110             :    The caller is not joined to the object on return. */
     111             : void *
     112             : fd_epoch_leaders_new( void                    * shmem,
     113             :                       ulong                     epoch,
     114             :                       ulong                     slot0,
     115             :                       ulong                     slot_cnt,
     116             :                       ulong                     pub_cnt,
     117             :                       fd_stake_weight_t const * stakes, /* indexed [0, pub_cnt) */
     118             :                       ulong                     excluded_stake );
     119             : 
     120             : /* fd_epoch_leaders_join joins the caller to the leader schedule object.
     121             :    fd_epoch_leaders_leave undoes an existing join. */
     122             : 
     123             : fd_epoch_leaders_t *
     124             : fd_epoch_leaders_join( void * shleaders );
     125             : 
     126             : void *
     127             : fd_epoch_leaders_leave( fd_epoch_leaders_t * leaders );
     128             : 
     129             : /* fd_epoch_leaders_delete unformats a memory region and returns owner-
     130             :    ship back to the caller. */
     131             : 
     132             : void *
     133             : fd_epoch_leaders_delete( void * shleaders );
     134             : 
     135             : /* FD_INDETERMINATE_LEADER has base58 encoding
     136             :    1111111111indeterminateLeader9QSxFYNqsXA.  In hex, this pubkey ends
     137             :    with 0x0badf00d0badf00d. */
     138        6183 : #define FD_INDETERMINATE_LEADER 0x00U,0x00U,0x00U,0x00U,0x00U,0x00U,0x00U,0x00U,0x00U,0x00U,0x99U,0xf6U,0x0fU,0x96U,0x2cU,0xddU,\
     139        6183 :                                 0x38U,0x21U,0xf3U,0x0cU,0x16U,0x1dU,0xe3U,0x0aU,0x0bU,0xadU,0xf0U,0x0dU,0x0bU,0xadU,0xf0U,0x0dU
     140             : 
     141             : /* fd_epoch_leaders_get returns a pointer to the selected public key
     142             :    given a slot.  Returns NULL if slot is not in [slot0, slot0+slot_cnt)
     143             :    given the values supplied in fd_epoch_leaders_new.
     144             : 
     145             :    If a non-zero value was provided for excluded_stake in
     146             :    fd_epoch_leaders_new and a validator included in the excluded_stake
     147             :    is the leader for the requested slot, instead of returning the
     148             :    correct value (which is not known), fd_epoch_leaders_get will return
     149             :    a pointer to a pubkey with value FD_INDETERMINATE_LEADER. */
     150             : 
     151             : FD_FN_PURE static inline fd_pubkey_t const *
     152             : fd_epoch_leaders_get( fd_epoch_leaders_t const * leaders,
     153     6693489 :                       ulong                      slot ) {
     154     6693489 :   ulong slot_delta = slot - leaders->slot0;
     155     6693489 :   if( FD_UNLIKELY( slot      < leaders->slot0    ) ) return NULL;
     156     6693408 :   if( FD_UNLIKELY( slot_delta>=leaders->slot_cnt ) ) return NULL;
     157     6693177 :   return (fd_pubkey_t const *)( leaders->pub + leaders->sched[ slot_delta/FD_EPOCH_SLOTS_PER_ROTATION ] );
     158     6693408 : }
     159             : 
     160             : FD_PROTOTYPES_END
     161             : 
     162             : #endif /* HEADER_fd_src_flamenco_leaders_fd_leaders_h */

Generated by: LCOV version 1.14