fixes to get fd bench to boot

Author: ravyu-jump

src/app/fdctl/config/default.toml

@@ -31,7 +31,7 @@ name = "fd1"
 #  1. The `SUDO_USER`, `LOGNAME`, `USER`, `LNAME`, or `USERNAME`
 #     environment variables are checked in this order, and if one of
 #     them is set that user is used
-#  2. The `/proc/self/loginid` file is used to determine the UID, and
+#  2. The `/proc/self/loginuid` file is used to determine the UID, and
 #     the username is looked up in nss (the name service switch).
 #
 # This means if running as sudo, the user will be the terminal user

src/app/firedancer-dev/main.c

@@ -92,6 +92,10 @@ extern fd_topo_run_tile_t fd_tile_archiver_feeder;
 extern fd_topo_run_tile_t fd_tile_archiver_writer;
 extern fd_topo_run_tile_t fd_tile_archiver_playback;
 
+extern fd_topo_run_tile_t fd_tile_bencho;
+extern fd_topo_run_tile_t fd_tile_benchg;
+extern fd_topo_run_tile_t fd_tile_benchs;
+
 fd_topo_run_tile_t * TILES[] = {
   &fd_tile_net,
   &fd_tile_netlnk,
@@ -122,6 +126,9 @@ fd_topo_run_tile_t * TILES[] = {
   &fd_tile_archiver_feeder,
   &fd_tile_archiver_writer,
   &fd_tile_archiver_playback,
+  &fd_tile_bencho,
+  &fd_tile_benchg,
+  &fd_tile_benchs,
   NULL,
 };
 

src/app/ledger/main.c

@@ -1130,7 +1130,7 @@ ingest( fd_ledger_args_t * args ) {
   }
 
   if( args->genesis ) {
-    fd_runtime_read_genesis( slot_ctx, args->genesis, args->snapshot != NULL, NULL, args->tpool, args->runtime_spad );
+    fd_runtime_read_genesis( slot_ctx, args->genesis, args->snapshot != NULL, NULL, args->runtime_spad );
   }
 
   if( !args->snapshot && (args->restore_funk != NULL || args->restore != NULL) ) {
@@ -1320,7 +1320,7 @@ replay( fd_ledger_args_t * args ) {
   }
 
   if( args->genesis ) {
-    fd_runtime_read_genesis( args->slot_ctx, args->genesis, args->snapshot != NULL, NULL, args->tpool, args->runtime_spad );
+    fd_runtime_read_genesis( args->slot_ctx, args->genesis, args->snapshot != NULL, NULL, args->runtime_spad );
   }
 
   FD_LOG_NOTICE(( "Used memory in spad after loading in snapshot %lu", args->runtime_spad->mem_used ));

src/discof/replay/fd_replay_tile.c

@@ -2089,8 +2089,7 @@ read_snapshot( void *              _ctx,
     /* Funk already has a snapshot loaded */
     fd_runtime_recover_banks( ctx->slot_ctx, 1, 1, ctx->runtime_spad );
     base_slot = ctx->slot_ctx->slot_bank.slot;
-    publish_stake_weights( ctx, stem, ctx->slot_ctx );
-    fd_fseq_update( ctx->published_wmark, ctx->slot_ctx->slot_bank.slot );
+    kickoff_repair_orphans( ctx, stem );
   } else {
 
     /* If we have an incremental snapshot try to prefetch the snapshot slot
@@ -2342,13 +2341,17 @@ init_snapshot( fd_replay_tile_ctx_t * ctx,
                            ctx->genesis,
                            is_snapshot,
                            ctx->capture_ctx,
-                           NULL,
                            ctx->runtime_spad );
-  fd_blockstore_init( ctx->slot_ctx->blockstore,
-                      ctx->blockstore_fd,
-                      FD_BLOCKSTORE_ARCHIVE_MIN_SIZE,
-                      &ctx->slot_ctx->slot_bank );
-
+  if( !is_snapshot ) {
+    /* read_snapshot calls kickoff_repair_orphans which calls init_blockstore.
+       Thus we need to call init_blockstore here if snapshot isn't read.
+       We call this after fd_runtime_read_genesis, which sets up the
+       slot_bank needed in blockstore_init */
+    fd_blockstore_init( ctx->slot_ctx->blockstore,
+                        ctx->blockstore_fd,
+                        FD_BLOCKSTORE_ARCHIVE_MIN_SIZE,
+                        &ctx->slot_ctx->slot_bank );
+  }
   ctx->epoch_ctx->bank_hash_cmp  = ctx->bank_hash_cmp;
   ctx->epoch_ctx->runtime_public = ctx->runtime_public;
   init_after_snapshot( ctx, stem );
@@ -2367,6 +2370,33 @@ init_snapshot( fd_replay_tile_ctx_t * ctx,
 
   send_exec_epoch_msg( ctx, stem, ctx->slot_ctx );
 
+  /* Publish slot notifs */
+  ulong curr_slot = ctx->curr_slot;
+  ulong block_entry_height = 0;
+
+  if( is_snapshot ){
+    for(;;){
+      fd_block_map_query_t query[1] = { 0 };
+      int err = fd_block_map_query_try( ctx->blockstore->block_map, &curr_slot, NULL, query, 0 );
+      fd_block_info_t * block_info = fd_block_map_query_ele( query );
+      if( FD_UNLIKELY( err == FD_MAP_ERR_KEY   ) ) FD_LOG_ERR(( "Failed to query blockstore for slot %lu", curr_slot ));
+      if( FD_UNLIKELY( err == FD_MAP_ERR_AGAIN ) ) {
+        FD_LOG_WARNING(( "Waiting for block map query for slot %lu", curr_slot ));
+        continue;
+      };
+      block_entry_height = block_info->block_height;
+      if( FD_UNLIKELY( fd_block_map_query_test( query ) == FD_MAP_SUCCESS ) ) break;
+    }
+  } else {
+    /* Block after genesis has a height of 1.
+       TODO: We should be able to query slot 1 block_map entry to get this
+       (using the above for loop), but blockstore/fork setup on genesis is
+       broken for now. */
+    block_entry_height = 1UL;
+  }
+
+  publish_slot_notifications( ctx, stem, fork, block_entry_height, curr_slot );
+
 
   FD_TEST( ctx->slot_ctx );
 }

src/flamenco/runtime/fd_blockstore.c

@@ -66,6 +66,15 @@ fd_blockstore_new( void * shmem,
   memset( blocks, 0, sizeof(fd_block_info_t) * block_max );
   FD_TEST( fd_block_map_new ( block_map, block_max, lock_cnt, BLOCK_INFO_PROBE_CNT, seed ) );
 
+  /* Caller is in charge of freeing map_slot_para element store set.
+     We need to explicitly do this since blocks is memset to 0, which
+     is not a "freed" state in map_slot_para (slot 0 is a valid key). */
+  fd_block_info_t * blocks_ = (fd_block_info_t *)blocks;
+  for( ulong i=0UL; i<block_max; i++ ) {
+    fd_block_map_private_ele_free( NULL, /* Not needed, avoids a join on block_map */
+                                   &blocks_[i] );
+  }
+
   blockstore_shmem->block_idx_gaddr  = fd_wksp_gaddr( wksp, fd_block_idx_join( fd_block_idx_new( block_idx, lg_idx_max ) ) );
   blockstore_shmem->slot_deque_gaddr = fd_wksp_gaddr( wksp, fd_slot_deque_join (fd_slot_deque_new( slot_deque, block_max ) ) );
   blockstore_shmem->txn_map_gaddr    = fd_wksp_gaddr( wksp, fd_txn_map_join (fd_txn_map_new( txn_map, txn_max, seed ) ) );
@@ -1197,7 +1206,10 @@ fd_blockstore_block_height_update( fd_blockstore_t * blockstore, ulong slot, ulo
   // TODO make nonblocking
   int err = fd_block_map_prepare( blockstore->block_map, &slot, NULL, query, FD_MAP_FLAG_BLOCKING );
   fd_block_info_t * block_info = fd_block_map_query_ele( query );
-  if( FD_UNLIKELY( err || block_info->slot != slot ) ) return;
+  if( FD_UNLIKELY( err || block_info->slot != slot ) ) {
+    fd_block_map_cancel( query );
+    return;
+  };
   block_info->block_height = height;
   fd_block_map_publish( query );
 }

src/flamenco/runtime/fd_blockstore.h

@@ -330,8 +330,9 @@ typedef struct fd_block_info fd_block_info_t;
 #define MAP_NAME                  fd_block_map
 #define MAP_ELE_T                 fd_block_info_t
 #define MAP_KEY                   slot
-#define MAP_ELE_IS_FREE(ctx, ele) ((ele)->slot == 0)
-#define MAP_ELE_FREE(ctx, ele)    ((ele)->slot = 0)
+#define MAP_ELE_IS_FREE(ctx, ele) ((ele)->slot == ULONG_MAX)
+#define MAP_ELE_FREE(ctx, ele)    ((ele)->slot =  ULONG_MAX)
+#define MAP_ELE_MOVE(ctx,dst,src) do { MAP_ELE_T * _src = (src); (*(dst)) = *_src; _src->MAP_KEY = (MAP_KEY_T)ULONG_MAX; } while(0)
 #define MAP_KEY_HASH(key, seed)   (void)(seed), (*(key))
 #include "../../util/tmpl/fd_map_slot_para.c"
 
@@ -370,6 +371,7 @@ typedef struct fd_block_idx fd_block_idx_t;
 #define MAP_T             fd_block_idx_t
 #define MAP_KEY           slot
 #define MAP_KEY_HASH(key) ((uint)(key)) /* finalized slots are guaranteed to be unique so perfect hashing */
+#define MAP_KEY_INVAL(k)  (k == ULONG_MAX)
 #include "../../util/tmpl/fd_map_dynamic.c"
 
 struct fd_txn_key {

src/flamenco/runtime/fd_hashes.c

@@ -649,6 +649,46 @@ fd_update_hash_bank_tpool( fd_exec_slot_ctx_t * slot_ctx,
                                         runtime_spad );
 }
 
+int
+fd_update_hash_bank(  fd_exec_slot_ctx_t * slot_ctx,
+                      fd_capture_ctx_t *   capture_ctx,
+                      fd_hash_t *          hash,
+                      ulong                signature_cnt,
+                      fd_spad_t *          runtime_spad ) {
+
+  /* Collect list of changed accounts to be added to bank hash */
+  fd_accounts_hash_task_data_t * task_data = fd_spad_alloc( runtime_spad,
+                                                            alignof(fd_accounts_hash_task_data_t),
+                                                            sizeof(fd_accounts_hash_task_data_t) );
+
+  fd_collect_modified_accounts( slot_ctx, task_data, runtime_spad );
+
+  fd_lthash_value_t * lt_hash = fd_spad_alloc(  runtime_spad,
+                                                FD_LTHASH_VALUE_ALIGN,
+                                                FD_LTHASH_VALUE_FOOTPRINT );
+  fd_lthash_zero( lt_hash );
+
+  for( ulong i=0UL; i<task_data->info_sz; i++ ) {
+    fd_accounts_hash_task_info_t * task_info = &task_data->info[i];
+    fd_account_hash( slot_ctx->funk,
+                     slot_ctx->funk_txn,
+                     task_info,
+                     lt_hash,
+                     slot_ctx->slot_bank.slot,
+                     &slot_ctx->epoch_ctx->features );
+  }
+
+  return fd_update_hash_bank_exec_hash( slot_ctx,
+                                        hash,
+                                        capture_ctx,
+                                        task_data,
+                                        1UL,
+                                        lt_hash,
+                                        1UL,
+                                        signature_cnt,
+                                        runtime_spad );
+}
+
 void const *
 fd_hash_account( uchar                     hash[ static 32 ],
                  fd_lthash_value_t *       lthash,

src/flamenco/runtime/fd_hashes.h

@@ -110,6 +110,15 @@ fd_update_hash_bank_tpool( fd_exec_slot_ctx_t * slot_ctx,
                            fd_tpool_t *         tpool,
                            fd_spad_t *          runtime_spad );
 
+/* Single threaded version of fd_update_hash_bank_tpool
+   TODO: Use parallel execution APIs in fd_runtime_public  */
+int
+fd_update_hash_bank( fd_exec_slot_ctx_t * slot_ctx,
+                      fd_capture_ctx_t *   capture_ctx,
+                      fd_hash_t *          hash,
+                      ulong                signature_cnt,
+                      fd_spad_t *          runtime_spad );
+
 /* fd_hash_account is the method to compute the account
    hash.  It includes the following content:
     - lamports

src/flamenco/runtime/fd_runtime.c

@@ -3632,7 +3632,6 @@ fd_runtime_init_bank_from_genesis( fd_exec_slot_ctx_t *  slot_ctx,
 static int
 fd_runtime_process_genesis_block( fd_exec_slot_ctx_t * slot_ctx,
                                   fd_capture_ctx_t *   capture_ctx,
-                                  fd_tpool_t *         tpool,
                                   fd_spad_t *          runtime_spad ) {
   ulong hashcnt_per_slot = slot_ctx->epoch_ctx->epoch_bank.hashes_per_tick * slot_ctx->epoch_ctx->epoch_bank.ticks_per_slot;
   while( hashcnt_per_slot-- ) {
@@ -3654,7 +3653,11 @@ fd_runtime_process_genesis_block( fd_exec_slot_ctx_t * slot_ctx,
   fd_runtime_freeze( slot_ctx, runtime_spad );
 
   /* sort and update bank hash */
-  int result = fd_update_hash_bank_tpool( slot_ctx, capture_ctx, &slot_ctx->slot_bank.banks_hash, slot_ctx->signature_cnt, tpool,runtime_spad );
+  int result = fd_update_hash_bank( slot_ctx,
+                                    capture_ctx,
+                                    &slot_ctx->slot_bank.banks_hash,
+                                    slot_ctx->signature_cnt,
+                                   runtime_spad );
   if( FD_UNLIKELY( result != FD_EXECUTOR_INSTR_SUCCESS ) ) {
     FD_LOG_ERR(( "Failed to update bank hash with error=%d", result ));
   }
@@ -3671,7 +3674,6 @@ fd_runtime_read_genesis( fd_exec_slot_ctx_t * slot_ctx,
                          char const *         genesis_filepath,
                          uchar                is_snapshot,
                          fd_capture_ctx_t *   capture_ctx,
-                         fd_tpool_t *         tpool,
                          fd_spad_t *          runtime_spad ) {
 
   if( strlen( genesis_filepath ) == 0 ) {
@@ -3764,7 +3766,7 @@ fd_runtime_read_genesis( fd_exec_slot_ctx_t * slot_ctx,
 
       slot_ctx->slot_bank.slot = 0UL;
 
-      int err = fd_runtime_process_genesis_block( slot_ctx, capture_ctx, tpool, runtime_spad );
+      int err = fd_runtime_process_genesis_block( slot_ctx, capture_ctx, runtime_spad );
       if( FD_UNLIKELY( err ) ) {
         FD_LOG_ERR(( "Genesis slot 0 execute failed with error %d", err ));
       }

src/flamenco/runtime/fd_runtime.h

@@ -669,7 +669,6 @@ fd_runtime_read_genesis( fd_exec_slot_ctx_t * slot_ctx,
                          char const *         genesis_filepath,
                          uchar                is_snapshot,
                          fd_capture_ctx_t *   capture_ctx,
-                         fd_tpool_t *         tpool,
                          fd_spad_t *          spad );
 
 FD_PROTOTYPES_END