runtime: refactor pt 2

Author: ibhatt-jumptrading

contrib/test/run_unit_tests.sh

@@ -8,7 +8,7 @@ set -euo pipefail
 JOBS=0
 NUMA_IDX=0
 PAGE_SZ=gigantic
-JOB_MEM=$((1<<31))  # 2GiB
+JOB_MEM=$((1<<32))  # 4GiB
 PAGE_CNT=
 TESTS=
 VERBOSE=0

src/disco/bundle/fd_bundle_crank.c

@@ -200,7 +200,8 @@ fd_bundle_crank_gen_init( void                 * mem,
 
   uint  cerr[1];
   do {
-    char seed[13] = "TIP_ACCOUNT_0"; /* Not NUL terminated */
+    char seed[13];
+    fd_memcpy( seed, "TIP_ACCOUNT_0", 13 ); /* Not NUL terminated */
     uchar const * seed_ptr[1] = { (uchar const *)seed };
     ulong seed_len = 13;
     for( ulong i=0UL; i<8UL; i++ ) {
@@ -213,7 +214,8 @@ fd_bundle_crank_gen_init( void                 * mem,
   } while( 0 );
 
   do {
-    char seed[14] = "CONFIG_ACCOUNT"; /* Not NUL terminated */
+    char seed[14];
+    fd_memcpy( seed, "CONFIG_ACCOUNT", 14 ); /* Not NUL terminated */
     ulong seed_len = 14;
     uchar out_bump[1];
     uchar const * seed_ptr[1] = { (uchar const *)seed };
@@ -265,10 +267,10 @@ fd_bundle_crank_update_epoch( fd_bundle_crank_gen_t * g,
     uchar vote_pubkey  [32];
     ulong epoch;
   } seeds[1] = {{
-    .tip_distr_acct = "TIP_DISTRIBUTION_ACCOUNT",
-    .vote_pubkey    = { EXPAND_ARR32( g->crank3->validator_vote_account, 0 ) },
-    .epoch          = epoch
+    .vote_pubkey = { EXPAND_ARR32( g->crank3->validator_vote_account, 0 ) },
+    .epoch       = epoch
   }};
+  memcpy( seeds->tip_distr_acct, "TIP_DISTRIBUTION_ACCOUNT", 24 );
   FD_STATIC_ASSERT( sizeof(seeds)==24UL+32UL+8UL, seed_struct );
   ulong seed_len = sizeof(seeds);
   uint custom_err[1];

src/discof/bank/fd_bank_tile.c

@@ -3,10 +3,12 @@
 
 #include "../../util/pod/fd_pod_format.h"
 #include "../../discof/replay/fd_exec.h"
+#include "../../flamenco/fd_flamenco.h"
 #include "../../flamenco/runtime/context/fd_capture_ctx.h"
 #include "../../flamenco/runtime/fd_bank.h"
-#include "../../flamenco/runtime/fd_exec_stack.h"
 #include "../../flamenco/runtime/fd_runtime.h"
+#include "../../flamenco/progcache/fd_progcache_user.h"
+#include "../../flamenco/log_collector/fd_log_collector.h"
 #include "../../disco/metrics/fd_metrics.h"
 
 #include "../../funk/fd_funk.h"
@@ -38,14 +40,6 @@ typedef struct fd_exec_tile_ctx {
   fd_sha512_t           sha_mem[ FD_TXN_ACTUAL_SIG_MAX ];
   fd_sha512_t *         sha_lj[ FD_TXN_ACTUAL_SIG_MAX ];
 
-  /* Data structures related to managing and executing the transaction.
-     The fd_txn_p_t is refreshed with every transaction and is sent
-     from the dispatch/replay tile.  The fd_exec_txn_ctx_t * is a valid
-     local join that lives in the top-most frame of the spad that is
-     setup when the exec tile is booted; its members are refreshed on
-     the slot/epoch boundary. */
-  fd_exec_txn_ctx_t     txn_ctx[1];
-
   /* Capture context for debugging runtime execution. */
   fd_capture_ctx_t *    capture_ctx;
   uchar *               solcap_publish_buffer_ptr;
@@ -67,8 +61,13 @@ typedef struct fd_exec_tile_ctx {
   ulong                 slot;
   ulong                 dispatch_time_comp;
 
-  fd_exec_stack_t       exec_stack;
   fd_exec_accounts_t    exec_accounts;
+  fd_log_collector_t    log_collector;
+
+  fd_bank_t *           bank;
+
+  fd_txn_in_t           txn_in;
+  fd_txn_out_t          txn_out;
 
   /* tracing_mem is staging memory to dump instructions/transactions
      into protobuf files.  tracing_mem is staging memory to output vm
@@ -77,6 +76,8 @@ typedef struct fd_exec_tile_ctx {
   uchar                 dumping_mem[ FD_SPAD_FOOTPRINT( 1UL<<28UL ) ] __attribute__((aligned(FD_SPAD_ALIGN)));
   uchar                 tracing_mem[ FD_MAX_INSTRUCTION_STACK_DEPTH ][ FD_RUNTIME_VM_TRACE_STATIC_FOOTPRINT ] __attribute__((aligned(FD_RUNTIME_VM_TRACE_STATIC_ALIGN)));
 
+  fd_runtime_t runtime;
+
 } fd_exec_tile_ctx_t;
 
 FD_FN_CONST static inline ulong
@@ -127,37 +128,32 @@ returnable_frag( fd_exec_tile_ctx_t * ctx,
       case FD_EXEC_TT_TXN_EXEC: {
         /* Execute. */
         fd_exec_txn_exec_msg_t * msg = fd_chunk_to_laddr( ctx->replay_in->mem, chunk );
-        fd_bank_t * bank = fd_banks_bank_query( ctx->banks, msg->bank_idx );
-        FD_TEST( bank );
-        ctx->txn_ctx->err.exec_err = fd_runtime_prepare_and_execute_txn( bank,
-                                                                         ctx->txn_ctx,
-                                                                         &msg->txn,
-                                                                         ctx->capture_ctx,
-                                                                         &ctx->exec_stack,
-                                                                         &ctx->exec_accounts,
-                                                                         ctx->dumping_mem,
-                                                                         &ctx->tracing_mem[0][0] );
+        ctx->bank = fd_banks_bank_query( ctx->banks, msg->bank_idx );
+        FD_TEST( ctx->bank );
+        ctx->txn_in.txn           = &msg->txn;
+        ctx->txn_in.exec_accounts = &ctx->exec_accounts;
+
+        fd_runtime_prepare_and_execute_txn( &ctx->runtime, ctx->bank, &ctx->txn_in, &ctx->txn_out );
 
         /* Commit. */
-        if( FD_LIKELY( ctx->txn_ctx->err.is_committable ) ) {
-          fd_funk_txn_xid_t xid = (fd_funk_txn_xid_t){ .ul = { fd_bank_slot_get( bank ), bank->idx } };
-          fd_runtime_finalize_txn( ctx->funk, ctx->progcache, ctx->txncache, &xid, ctx->txn_ctx, bank, ctx->capture_ctx, NULL );
+        if( FD_LIKELY( ctx->txn_out.err.is_committable ) ) {
+          fd_runtime_commit_txn( &ctx->runtime, ctx->bank, &ctx->txn_in, &ctx->txn_out );
         }
 
         if( FD_LIKELY( ctx->exec_sig_out->idx!=ULONG_MAX ) ) {
           /* Copy the txn signature to the signature out link so the
              dedup/pack tiles can drop already executed transactions. */
           memcpy( fd_chunk_to_laddr( ctx->exec_sig_out->mem, ctx->exec_sig_out->chunk ),
-                  (uchar *)ctx->txn_ctx->txn.payload + TXN( &ctx->txn_ctx->txn )->signature_off,
+                  (uchar *)ctx->txn_in.txn->payload + TXN( ctx->txn_in.txn )->signature_off,
                   64UL );
           fd_stem_publish( stem, ctx->exec_sig_out->idx, 0UL, ctx->exec_sig_out->chunk, 64UL, 0UL, 0UL, 0UL );
           ctx->exec_sig_out->chunk = fd_dcache_compact_next( ctx->exec_sig_out->chunk, 64UL, ctx->exec_sig_out->chunk0, ctx->exec_sig_out->wmark );
         }
 
         /* Notify replay. */
-        ctx->txn_idx = msg->txn_idx;
-        ctx->dispatch_time_comp = tspub;
-        ctx->slot = fd_bank_slot_get( bank );
+        ctx->txn_idx                   = msg->txn_idx;
+        ctx->dispatch_time_comp        = tspub;
+        ctx->slot                      = fd_bank_slot_get( ctx->bank );
         ctx->pending_txn_finalized_msg = 1;
 
         break;
@@ -274,21 +270,7 @@ unprivileged_init( fd_topo_t *      topo,
   ctx->txncache = fd_txncache_join( fd_txncache_new( _txncache, txncache_shmem ) );
   FD_TEST( ctx->txncache );
 
-  /********************************************************************/
-  /* setup txn ctx                                                    */
-  /********************************************************************/
-
-  FD_TEST( fd_exec_txn_ctx_join( fd_exec_txn_ctx_new( ctx->txn_ctx ) ) );
-
-  if( FD_UNLIKELY( !fd_funk_join( ctx->txn_ctx->funk, shfunk ) ) ) {
-    FD_LOG_CRIT(( "fd_funk_join(accdb) failed" ));
-  }
-  ctx->txn_ctx->progcache = fd_progcache_join( ctx->txn_ctx->_progcache, shprogcache, pc_scratch, FD_PROGCACHE_SCRATCH_FOOTPRINT );
-  if( FD_UNLIKELY( !ctx->txn_ctx->progcache ) ) {
-    FD_LOG_CRIT(( "fd_progcache_join() failed" ));
-  }
-  ctx->txn_ctx->status_cache     = ctx->txncache;
-  ctx->txn_ctx->bundle.is_bundle = 0;
+  ctx->txn_in.bundle.is_bundle = 0;
 
   /********************************************************************/
   /* Capture context                                                 */
@@ -318,6 +300,22 @@ unprivileged_init( fd_topo_t *      topo,
   }
 
   ctx->pending_txn_finalized_msg = 0;
+
+  /********************************************************************/
+  /* Runtime                                                          */
+  /********************************************************************/
+
+  ctx->runtime = (fd_runtime_t) {
+    .funk         = ctx->funk,
+    .status_cache = ctx->txncache,
+    .progcache    = ctx->progcache,
+    .log          = {
+      .dumping_mem   = ctx->dumping_mem,
+      .tracing_mem   = &ctx->tracing_mem[0][0],
+      .log_collector = &ctx->log_collector,
+      .capture_ctx   = ctx->capture_ctx,
+    }
+  };
 }
 
 /* Publish the next account update event buffered in the capture tile to the replay tile
@@ -370,14 +368,14 @@ static void
 publish_txn_finalized_msg( fd_exec_tile_ctx_t * ctx,
                            fd_stem_context_t *  stem ) {
   fd_exec_task_done_msg_t * msg  = fd_chunk_to_laddr( ctx->exec_replay_out->mem, ctx->exec_replay_out->chunk );
-  msg->bank_idx                  = ctx->txn_ctx->bank->idx;
+  msg->bank_idx                  = ctx->bank->idx;
   msg->txn_exec->txn_idx         = ctx->txn_idx;
-  msg->txn_exec->err             = !ctx->txn_ctx->err.is_committable;
+  msg->txn_exec->err             = !ctx->txn_out.err.is_committable;
   msg->txn_exec->slot            = ctx->slot;
-  msg->txn_exec->start_shred_idx = ctx->txn_ctx->txn.start_shred_idx;
-  msg->txn_exec->end_shred_idx   = ctx->txn_ctx->txn.end_shred_idx;
+  msg->txn_exec->start_shred_idx = ctx->txn_in.txn->start_shred_idx;
+  msg->txn_exec->end_shred_idx   = ctx->txn_in.txn->end_shred_idx;
   if( FD_UNLIKELY( msg->txn_exec->err ) ) {
-    FD_LOG_WARNING(( "txn failed to execute, bad block detected err=%d", ctx->txn_ctx->err.txn_err ));
+    FD_LOG_WARNING(( "txn failed to execute, bad block detected err=%d", ctx->txn_out.err.txn_err ));
   }
 
   fd_stem_publish( stem, ctx->exec_replay_out->idx, (FD_EXEC_TT_TXN_EXEC<<32)|ctx->tile_idx, ctx->exec_replay_out->chunk, sizeof(*msg), 0UL, ctx->dispatch_time_comp, fd_frag_meta_ts_comp( fd_tickcount() ) );

src/discof/exec/fd_exec_tile.c

@@ -35,6 +35,7 @@
 #include "../../flamenco/runtime/tests/fd_dump_pb.h"
 
 #include <errno.h>
+#include <stdio.h>
 
 /* Replay concepts:
 
@@ -615,17 +616,9 @@ replay_block_start( fd_replay_tile_t *  ctx,
   }
 
   int is_epoch_boundary = 0;
-  fd_runtime_block_pre_execute_process_new_epoch(
-      ctx->banks,
-      bank,
-      ctx->accdb,
-      &xid,
-      ctx->capture_ctx,
-      &ctx->runtime_stack,
-      &is_epoch_boundary );
+  fd_runtime_block_execute_prepare( ctx->banks, bank, ctx->accdb, &ctx->runtime_stack, ctx->capture_ctx, &is_epoch_boundary );
   if( FD_UNLIKELY( is_epoch_boundary ) ) publish_stake_weights( ctx, stem, bank, 1 );
 
-  FD_TEST( !fd_runtime_block_execute_prepare( bank, ctx->accdb, &xid, &ctx->runtime_stack, ctx->capture_ctx ) );
   return bank;
 }
 
@@ -753,9 +746,6 @@ replay_block_finalize( fd_replay_tile_t *  ctx,
 
   FD_TEST( !(bank->flags&FD_BANK_FLAGS_FROZEN) );
 
-  ulong             slot = fd_bank_slot_get( bank );
-  fd_funk_txn_xid_t xid  = { .ul = { slot, bank->idx } };
-
   /* Set poh hash in bank. */
   fd_hash_t * poh = fd_sched_get_poh( ctx->sched, bank->idx );
   fd_bank_poh_set( bank, *poh );
@@ -764,13 +754,15 @@ replay_block_finalize( fd_replay_tile_t *  ctx,
   fd_bank_shred_cnt_set( bank, fd_sched_get_shred_cnt( ctx->sched, bank->idx ) );
 
   /* Do hashing and other end-of-block processing. */
-  fd_runtime_block_execute_finalize( bank, ctx->accdb, &xid, ctx->capture_ctx, 1 );
+  fd_runtime_block_execute_finalize( bank, ctx->accdb, ctx->capture_ctx );
 
   /* Copy out cost tracker fields before freezing */
   fd_replay_slot_completed_t * slot_info = fd_chunk_to_laddr( ctx->replay_out->mem, ctx->replay_out->chunk );
   cost_tracker_snap( bank, slot_info );
 
   /* fetch identity / vote balance updates infrequently */
+  ulong slot = fd_bank_slot_get( bank );
+  fd_funk_txn_xid_t xid = { .ul = { slot, bank->idx } };
   slot_info->identity_balance = FD_UNLIKELY( slot%4096==0UL ) ? get_identity_balance( ctx, xid ) : ULONG_MAX;
 
   /* Mark the bank as frozen. */
@@ -863,18 +855,9 @@ prepare_leader_bank( fd_replay_tile_t *  ctx,
   }
 
   int is_epoch_boundary = 0;
-  fd_runtime_block_pre_execute_process_new_epoch(
-      ctx->banks,
-      ctx->leader_bank,
-      ctx->accdb,
-      &xid,
-      ctx->capture_ctx,
-      &ctx->runtime_stack,
-      &is_epoch_boundary );
+  fd_runtime_block_execute_prepare( ctx->banks, ctx->leader_bank, ctx->accdb, &ctx->runtime_stack, ctx->capture_ctx, &is_epoch_boundary );
   if( FD_UNLIKELY( is_epoch_boundary ) ) publish_stake_weights( ctx, stem, ctx->leader_bank, 1 );
 
-  FD_TEST( !fd_runtime_block_execute_prepare( ctx->leader_bank, ctx->accdb, &xid, &ctx->runtime_stack, ctx->capture_ctx ) );
-
   /* Now that a bank has been created for the leader slot, increment the
      reference count until we are done with the leader slot. */
   ctx->leader_bank->refcnt++;
@@ -902,12 +885,12 @@ fini_leader_bank( fd_replay_tile_t *  ctx,
   if( FD_UNLIKELY( !txn_map->map ) ) {
     FD_LOG_ERR(( "Could not find valid funk transaction map" ));
   }
-  fd_funk_txn_xid_t xid = { .ul = { curr_slot, ctx->leader_bank->idx } };
 
-  fd_runtime_block_execute_finalize( ctx->leader_bank, ctx->accdb, &xid, ctx->capture_ctx, 1 );
+  fd_runtime_block_execute_finalize( ctx->leader_bank, ctx->accdb, ctx->capture_ctx );
 
   fd_replay_slot_completed_t * slot_info = fd_chunk_to_laddr( ctx->replay_out->mem, ctx->replay_out->chunk );
   cost_tracker_snap( ctx->leader_bank, slot_info );
+  fd_funk_txn_xid_t xid = { .ul = { curr_slot, ctx->leader_bank->idx } };
   slot_info->identity_balance = FD_UNLIKELY( curr_slot%4096==0UL ) ? get_identity_balance( ctx, xid ) : ULONG_MAX;
 
   fd_banks_mark_bank_frozen( ctx->banks, ctx->leader_bank );
@@ -1043,8 +1026,10 @@ init_after_snapshot( fd_replay_tile_t * ctx ) {
       fd_sha256_hash( poh->hash, 32UL, poh->hash );
     }
 
-    FD_TEST( !fd_runtime_block_execute_prepare( bank, ctx->accdb, &xid, &ctx->runtime_stack, ctx->capture_ctx ) );
-    fd_runtime_block_execute_finalize( bank, ctx->accdb, &xid, ctx->capture_ctx, 1 );
+    int is_epoch_boundary = 0;
+    fd_runtime_block_execute_prepare( ctx->banks, bank, ctx->accdb, &ctx->runtime_stack, ctx->capture_ctx, &is_epoch_boundary );
+    FD_TEST( !is_epoch_boundary );
+    fd_runtime_block_execute_finalize( bank, ctx->accdb, ctx->capture_ctx );
 
     snapshot_slot = 0UL;
   }

src/discof/replay/fd_replay_tile.c

@@ -67,9 +67,6 @@ typedef struct fd_bank fd_bank_t;
 struct fd_banks;
 typedef struct fd_banks fd_banks_t;
 
-struct fd_exec_txn_ctx;
-typedef struct fd_exec_txn_ctx fd_exec_txn_ctx_t;
-
 struct fd_exec_instr_ctx;
 typedef struct fd_exec_instr_ctx fd_exec_instr_ctx_t;
 
@@ -97,8 +94,17 @@ typedef struct fd_progcache fd_progcache_t;
 union fd_runtime_stack;
 typedef union fd_runtime_stack fd_runtime_stack_t;
 
-struct fd_exec_stack;
-typedef struct fd_exec_stack fd_exec_stack_t;
+struct fd_runtime;
+typedef struct fd_runtime fd_runtime_t;
+
+struct fd_txn_in;
+typedef struct fd_txn_in fd_txn_in_t;
+
+struct fd_txn_out;
+typedef struct fd_txn_out fd_txn_out_t;
+
+struct fd_log_collector;
+typedef struct fd_log_collector fd_log_collector_t;
 
 struct fd_account_meta {
   uchar owner[32];
@@ -110,15 +116,6 @@ struct fd_account_meta {
 };
 typedef struct fd_account_meta fd_account_meta_t;
 
-/* fd_rawtxn_b_t is a convenience type to store a pointer to a
-   serialized transaction.  Should probably be removed in the future. */
-
-struct fd_rawtxn_b {
-  void * raw;
-  ushort txn_sz;
-};
-typedef struct fd_rawtxn_b fd_rawtxn_b_t;
-
 FD_PROTOTYPES_BEGIN
 
 /* fd_acct_addr_cstr converts the given Solana address into a base58-