runtime: clean up dead executor code

Author: ibhatt-jumptrading

src/discof/exec/fd_exec_tile.c

@@ -95,12 +95,9 @@ scratch_footprint( fd_topo_tile_t const * tile FD_PARAM_UNUSED ) {
   /* clang-format on */
 }
 
-static void
-execute_txn( fd_exec_tile_ctx_t * ctx ) {
-
-  FD_SPAD_FRAME_BEGIN( ctx->exec_spad ) {
-
-  /* Query the funk transaction for the given slot. */
+static fd_funk_txn_t *
+funk_txn_get( fd_exec_tile_ctx_t * ctx ) {
+/* Query the funk transaction for the given slot. */
   fd_funk_txn_map_t * txn_map = fd_funk_txn_map( ctx->funk );
   if( FD_UNLIKELY( !txn_map->map ) ) {
     FD_LOG_ERR(( "Could not find valid funk transaction map" ));
@@ -112,33 +109,45 @@ execute_txn( fd_exec_tile_ctx_t * ctx ) {
     FD_LOG_ERR(( "Could not find valid funk transaction" ));
   }
   fd_funk_txn_end_read( ctx->funk );
-  ctx->txn_ctx->funk_txn = funk_txn;
+  return funk_txn;
+}
+
+static fd_bank_t *
+bank_get( fd_exec_tile_ctx_t * ctx ) {
+  return fd_banks_get_bank( ctx->banks, ctx->slot );
+}
+
+static void
+execute_txn( fd_exec_tile_ctx_t * ctx ) {
+
+  FD_SPAD_FRAME_BEGIN( ctx->exec_spad ) {
+
+  ctx->exec_res = 0;
+
+  ctx->txn_ctx->funk_txn = funk_txn_get( ctx );
+  if( FD_UNLIKELY( !ctx->txn_ctx->funk_txn ) ) {
+    FD_LOG_CRIT(( "Could not get funk transaction for slot %lu", ctx->slot ));
+  }
 
   /* Get the bank for the given slot. */
   fd_banks_lock( ctx->banks );
-  ctx->bank = fd_banks_get_bank( ctx->banks, ctx->slot );
+  ctx->bank = bank_get( ctx );
   if( FD_UNLIKELY( !ctx->bank ) ) {
-    FD_LOG_ERR(( "Could not get bank for slot %lu", ctx->slot ));
+    FD_LOG_CRIT(( "Could not get bank for slot %lu", ctx->slot ));
   }
 
-  /* Setup and execute the transaction.*/
+  /* Setup and execute the transaction. */
   ctx->txn_ctx->bank     = ctx->bank;
   ctx->txn_ctx->slot     = fd_bank_slot_get( ctx->bank );
   ctx->txn_ctx->features = fd_bank_features_get( ctx->bank );
 
-  fd_execute_txn_task_info_t task_info = {
-    .txn_ctx  = ctx->txn_ctx,
-    .exec_res = 0,
-    .txn      = &ctx->txn,
-  };
-
-  fd_txn_t const * txn_descriptor = TXN( task_info.txn );
+  fd_txn_t const * txn_descriptor = TXN( &ctx->txn );
   fd_rawtxn_b_t    raw_txn        = {
-    .raw    = task_info.txn->payload,
-    .txn_sz = (ushort)task_info.txn->payload_sz
+    .raw    = ctx->txn.payload,
+    .txn_sz = (ushort)ctx->txn.payload_sz
   };
 
-  task_info.txn->flags = FD_TXN_P_FLAGS_SANITIZE_SUCCESS;
+  ctx->txn.flags = FD_TXN_P_FLAGS_SANITIZE_SUCCESS;
 
   fd_exec_txn_ctx_setup( ctx->txn_ctx, txn_descriptor, &raw_txn );
   ctx->txn_ctx->capture_ctx = ctx->capture_ctx;
@@ -151,24 +160,27 @@ execute_txn( fd_exec_tile_ctx_t * ctx ) {
 
   if( FD_UNLIKELY( fd_executor_txn_verify( ctx->txn_ctx )!=0 ) ) {
     FD_LOG_WARNING(( "sigverify failed: %s", FD_BASE58_ENC_64_ALLOCA( (uchar *)ctx->txn_ctx->_txn_raw->raw+ctx->txn_ctx->txn_descriptor->signature_off ) ));
-    task_info.txn->flags = 0U;
-    task_info.exec_res   = FD_RUNTIME_TXN_ERR_SIGNATURE_FAILURE;
+    ctx->txn.flags = 0U;
+    ctx->exec_res  = FD_RUNTIME_TXN_ERR_SIGNATURE_FAILURE;
     fd_banks_unlock( ctx->banks );
     return;
   }
 
-  fd_runtime_pre_execute_check( &task_info );
-  if( FD_UNLIKELY( !( task_info.txn->flags & FD_TXN_P_FLAGS_SANITIZE_SUCCESS ) ) ) {
+  ctx->exec_res = fd_runtime_pre_execute_check( &ctx->txn, ctx->txn_ctx );
+  if( FD_UNLIKELY( !( ctx->txn.flags & FD_TXN_P_FLAGS_SANITIZE_SUCCESS ) ) ) {
     fd_banks_unlock( ctx->banks );
     return;
   }
 
   /* Execute */
-  task_info.txn->flags |= FD_TXN_P_FLAGS_EXECUTE_SUCCESS;
-  ctx->exec_res         = fd_execute_txn( &task_info );
+  ctx->txn.flags |= FD_TXN_P_FLAGS_EXECUTE_SUCCESS;
+
+  if( FD_LIKELY( !(ctx->txn.flags & FD_TXN_P_FLAGS_FEES_ONLY) ) ) {
+    ctx->exec_res = fd_execute_txn( ctx->txn_ctx );
+  }
 
   if( FD_LIKELY( ctx->exec_res==FD_EXECUTOR_INSTR_SUCCESS ) ) {
-    fd_txn_reclaim_accounts( task_info.txn_ctx );
+    fd_txn_reclaim_accounts( ctx->txn_ctx );
   }
   fd_banks_unlock( ctx->banks );
 
@@ -233,33 +245,6 @@ hash_accounts( fd_exec_tile_ctx_t *                ctx,
   fd_banks_unlock( ctx->banks );
 }
 
-static void
-snap_hash_count( fd_exec_tile_ctx_t * ctx ) {
-  ctx->pairs_len = fd_accounts_sorted_subrange_count( ctx->funk, (uint)ctx->tile_idx, (uint)ctx->tile_cnt );
-}
-
-static void
-snap_hash_gather( fd_exec_tile_ctx_t *                ctx,
-                  fd_runtime_public_snap_hash_msg_t * msg ) {
-
-  ulong * num_pairs = fd_wksp_laddr_fast( ctx->runtime_public_wksp, msg->num_pairs_out_gaddr );
-  if( FD_UNLIKELY( !num_pairs ) ) {
-    FD_LOG_ERR(( "Unable to join num_pairs" ));
-  }
-  fd_pubkey_hash_pair_t * pairs = fd_wksp_laddr_fast( ctx->runtime_public_wksp, msg->pairs_gaddr );
-  if( FD_UNLIKELY( !pairs ) ) {
-    FD_LOG_ERR(( "Unable to join pairs" ));
-  }
-  fd_lthash_value_t * lthash_value = fd_wksp_laddr_fast( ctx->runtime_public_wksp, msg->lt_hash_value_out_gaddr );
-  if( FD_UNLIKELY( !lthash_value ) ) {
-    FD_LOG_ERR(( "Unable to join lthash values" ));
-  }
-
-  fd_accounts_sorted_subrange_gather( ctx->funk, (uint)ctx->tile_idx, (uint)ctx->tile_cnt,
-                                      num_pairs, lthash_value,
-                                      pairs, &ctx->runtime_public->features );
-}
-
 static void
 during_frag( fd_exec_tile_ctx_t * ctx,
              ulong                in_idx,
@@ -289,15 +274,8 @@ during_frag( fd_exec_tile_ctx_t * ctx,
       FD_LOG_DEBUG(( "hash accs=%lu msg recvd", msg->end_idx - msg->start_idx ));
       hash_accounts( ctx, msg );
       return;
-    } else if( sig==EXEC_SNAP_HASH_ACCS_CNT_SIG ) {
-      FD_LOG_DEBUG(( "snap hash count msg recvd" ));
-      snap_hash_count( ctx );
-    } else if( sig==EXEC_SNAP_HASH_ACCS_GATHER_SIG ) {
-      fd_runtime_public_snap_hash_msg_t * msg = fd_chunk_to_laddr( ctx->replay_in_mem, chunk );
-      FD_LOG_DEBUG(( "snap hash gather msg recvd" ));
-      snap_hash_gather( ctx, msg );
     } else {
-      FD_LOG_ERR(( "Unknown signature" ));
+      FD_LOG_CRIT(( "Unknown signature" ));
     }
   }
 }
@@ -326,14 +304,15 @@ after_frag( fd_exec_tile_ctx_t * ctx,
     msg->exec_tile_id = (uchar)ctx->tile_idx;
     msg->txn_id       = ctx->txn_id;
 
-    fd_stem_publish( stem,
-                     exec_out->idx,
-                     FD_WRITER_TXN_SIG,
-                     exec_out->chunk,
-                     sizeof(*msg),
-                     0UL,
-                     tsorig,
-                     tspub );
+    fd_stem_publish(
+        stem,
+        exec_out->idx,
+        FD_WRITER_TXN_SIG,
+        exec_out->chunk,
+        sizeof(*msg),
+        0UL,
+        tsorig,
+        tspub );
     exec_out->chunk = fd_dcache_compact_next( exec_out->chunk, sizeof(*msg), exec_out->chunk0, exec_out->wmark );
 
     /* Make sure that the txn/bpf id can never be equal to the sentinel
@@ -345,22 +324,11 @@ after_frag( fd_exec_tile_ctx_t * ctx,
   } else if( sig==EXEC_HASH_ACCS_SIG ) {
     FD_LOG_DEBUG(( "Sending ack for hash accs msg" ));
     fd_fseq_update( ctx->exec_fseq, fd_exec_fseq_set_hash_done( ctx->slot ) );
-  } else if( sig==EXEC_SNAP_HASH_ACCS_CNT_SIG ) {
-    FD_LOG_NOTICE(( "Sending ack for snap hash count msg pairs_len=%lu", ctx->pairs_len ));
-    fd_fseq_update( ctx->exec_fseq, fd_exec_fseq_set_snap_hash_cnt_done( (uint)ctx->pairs_len ) );
-  } else if( sig==EXEC_SNAP_HASH_ACCS_GATHER_SIG ) {
-    FD_LOG_NOTICE(("Sending ack for snap hash gather msg" ));
-    fd_fseq_update( ctx->exec_fseq, fd_exec_fseq_set_snap_hash_gather_done() );
   } else {
     FD_LOG_ERR(( "Unknown message signature" ));
   }
 }
 
-static void
-privileged_init( fd_topo_t *      topo FD_PARAM_UNUSED,
-                 fd_topo_tile_t * tile FD_PARAM_UNUSED ) {
-}
-
 static void
 unprivileged_init( fd_topo_t *      topo,
                    fd_topo_tile_t * tile ) {
@@ -629,8 +597,6 @@ populate_allowed_fds( fd_topo_t const *      topo,
   return out_cnt;
 }
 
-/* The stem burst is bound by the max number of exec tiles that are
-   posible. */
 #define STEM_BURST (1UL)
 
 #define STEM_CALLBACK_CONTEXT_TYPE  fd_exec_tile_ctx_t
@@ -649,7 +615,6 @@ fd_topo_run_tile_t fd_tile_execor = {
     .populate_allowed_fds     = populate_allowed_fds,
     .scratch_align            = scratch_align,
     .scratch_footprint        = scratch_footprint,
-    .privileged_init          = privileged_init,
     .unprivileged_init        = unprivileged_init,
     .run                      = stem_run,
 };

src/discof/writer/fd_writer_tile.c

@@ -104,9 +104,9 @@ before_frag( fd_writer_tile_ctx_t * ctx,
      until transaction finalization has been done.  In other words, exec
      tiles block on writer tiles, rather than truly pipelining.  As a
      result, when all the exec tiles publish to seq 0, the 0th writer
-     tile becomes busy, and all exec tiles block on it.  Then writer tile
-     1 becomes busy, while all other writer tiles sit idle.  So on and so
-     forth.
+     tile becomes busy, and all exec tiles block on it.  Then writer
+     tile 1 becomes busy, while all other writer tiles sit idle.  So on
+     and so forth.
 
      So we offset by in_idx to try to mitigate this.
    */
@@ -116,17 +116,14 @@ before_frag( fd_writer_tile_ctx_t * ctx,
 static void
 during_frag( fd_writer_tile_ctx_t * ctx,
              ulong                  in_idx,
-             ulong                  seq,
+             ulong                  seq FD_PARAM_UNUSED,
              ulong                  sig,
              ulong                  chunk,
              ulong                  sz,
-             ulong                  ctl ) {
-
-  (void)seq;
-  (void)ctl;
+             ulong                  ctl FD_PARAM_UNUSED ) {
 
-  /* exec_writer is a reliable flow controlled link so we are not gonna
-     bother with copying the incoming frag. */
+  /* exec_writer is a reliable flow controlled link so we are not going
+     to bother with copying the incoming frag. */
 
   fd_writer_tile_in_ctx_t * in_ctx = &(ctx->exec_writer_in[ in_idx ]);
 
@@ -159,17 +156,16 @@ during_frag( fd_writer_tile_ctx_t * ctx,
     if( FD_UNLIKELY( msg->exec_tile_id!=in_idx ) ) {
       FD_LOG_CRIT(( "exec_tile_id %u should be == in_idx %lu", msg->exec_tile_id, in_idx ));
     }
-    fd_execute_txn_task_info_t info = {0};
-    info.txn_ctx  = ctx->txn_ctx[ in_idx ];
-    info.exec_res = info.txn_ctx->exec_err;
+    fd_exec_txn_ctx_t * txn_ctx  = ctx->txn_ctx[ in_idx ];
+    int                 exec_res = txn_ctx->exec_err;
 
     fd_banks_lock( ctx->banks );
-    ctx->bank = fd_banks_get_bank( ctx->banks, info.txn_ctx->slot );
+    ctx->bank = fd_banks_get_bank( ctx->banks, txn_ctx->slot );
     if( FD_UNLIKELY( !ctx->bank ) ) {
-      FD_LOG_CRIT(( "Could not find bank for slot %lu", info.txn_ctx->slot ));
+      FD_LOG_CRIT(( "Could not find bank for slot %lu", txn_ctx->slot ));
     }
 
-    if( !ctx->funk_txn || info.txn_ctx->slot != ctx->funk_txn->xid.ul[0] ) {
+    if( !ctx->funk_txn || txn_ctx->slot != ctx->funk_txn->xid.ul[0] ) {
       fd_funk_txn_map_t * txn_map = fd_funk_txn_map( ctx->funk );
       if( FD_UNLIKELY( !txn_map->map ) ) {
         FD_LOG_CRIT(( "Could not find valid funk transaction map" ));
@@ -183,18 +179,23 @@ during_frag( fd_writer_tile_ctx_t * ctx,
       fd_funk_txn_end_read( ctx->funk );
     }
 
-    if( FD_LIKELY( info.txn_ctx->flags & FD_TXN_P_FLAGS_EXECUTE_SUCCESS ) ) {
+    if( FD_LIKELY( txn_ctx->flags & FD_TXN_P_FLAGS_EXECUTE_SUCCESS ) ) {
       FD_SPAD_FRAME_BEGIN( ctx->spad ) {
         if( FD_UNLIKELY( !ctx->bank ) ) {
-          FD_LOG_CRIT(( "No bank for slot %lu", info.txn_ctx->slot ));
+          FD_LOG_CRIT(( "No bank for slot %lu", txn_ctx->slot ));
         }
 
-        fd_runtime_finalize_txn( ctx->funk, ctx->funk_txn, &info, ctx->spad, ctx->bank );
+        fd_runtime_finalize_txn(
+            ctx->funk,
+            ctx->funk_txn,
+            txn_ctx,
+            exec_res,
+            ctx->spad,
+            ctx->bank );
       } FD_SPAD_FRAME_END;
       fd_banks_unlock( ctx->banks );
       while( fd_writer_fseq_get_state( fd_fseq_query( ctx->fseq ) )!=FD_WRITER_STATE_READY ) {
-        /* Spin to wait for the replay tile to ack the previous txn
-           done. */
+        /* Spin for the replay tile to ack the previous txn done. */
         FD_SPIN_PAUSE();
       }
     }
@@ -206,13 +207,6 @@ during_frag( fd_writer_tile_ctx_t * ctx,
   FD_LOG_CRIT(( "Unknown sig %lu", sig ));
 }
 
-static void
-privileged_init( fd_topo_t *      topo,
-                 fd_topo_tile_t * tile ) {
-  (void)topo;
-  (void)tile;
-}
-
 static void
 unprivileged_init( fd_topo_t *      topo,
                    fd_topo_tile_t * tile ) {
@@ -387,7 +381,6 @@ fd_topo_run_tile_t fd_tile_writer = {
     .populate_allowed_fds     = populate_allowed_fds,
     .scratch_align            = scratch_align,
     .scratch_footprint        = scratch_footprint,
-    .privileged_init          = privileged_init,
     .unprivileged_init        = unprivileged_init,
     .run                      = stem_run,
 };

src/flamenco/runtime/context/fd_exec_txn_ctx.h

@@ -132,8 +132,6 @@ struct fd_exec_txn_ctx {
 
   uint                            num_instructions;                            /* Counter for number of instructions in txn */
   fd_txn_return_data_t            return_data;                                 /* Data returned from `return_data` syscalls */
-  fd_vote_account_cache_t *       vote_accounts_map;                           /* Cache of bank's deserialized vote accounts to support fork choice */
-  fd_vote_account_cache_entry_t * vote_accounts_pool;                          /* Memory pool for deserialized vote account cache */
   ulong                           accounts_resize_delta;                       /* Transaction level tracking for account resizing */
   fd_hash_t                       blake_txn_msg_hash;                          /* Hash of raw transaction message used by the status cache */
   ulong                           execution_fee;                               /* Execution fee paid by the fee payer in the transaction */

src/flamenco/runtime/fd_executor.c

@@ -1621,16 +1621,9 @@ fd_executor_txn_verify( fd_exec_txn_ctx_t * txn_ctx ) {
 }
 
 int
-fd_execute_txn( fd_execute_txn_task_info_t * task_info ) {
-  /* Don't execute transactions that are fee only.
-     https://github.com/anza-xyz/agave/blob/v2.1.6/svm/src/transaction_processor.rs#L341-L357 */
-  if( FD_UNLIKELY( task_info->txn->flags & FD_TXN_P_FLAGS_FEES_ONLY ) ) {
-    /* return the existing error */
-    return task_info->exec_res;
-  }
+fd_execute_txn( fd_exec_txn_ctx_t * txn_ctx ) {
 
-  fd_exec_txn_ctx_t * txn_ctx   = task_info->txn_ctx;
-  bool                dump_insn = txn_ctx->capture_ctx && txn_ctx->slot >= txn_ctx->capture_ctx->dump_proto_start_slot && txn_ctx->capture_ctx->dump_instr_to_pb;
+  bool dump_insn = txn_ctx->capture_ctx && txn_ctx->slot >= txn_ctx->capture_ctx->dump_proto_start_slot && txn_ctx->capture_ctx->dump_instr_to_pb;
 
   /* Initialize log collection */
   fd_log_collector_init( &txn_ctx->log_collector, txn_ctx->enable_exec_recording );

src/flamenco/runtime/fd_executor.h

@@ -84,7 +84,7 @@ fd_execute_txn_prepare_start( fd_exec_slot_ctx_t const * slot_ctx,
 
   Makes changes to the Funk accounts DB. */
 int
-fd_execute_txn( fd_execute_txn_task_info_t * task_info );
+fd_execute_txn( fd_exec_txn_ctx_t * txn_ctx );
 
 int
 fd_executor_validate_transaction_fee_payer( fd_exec_txn_ctx_t * txn_ctx );