cleanup cleanup

Author: ibhatt-jumptrading

src/discof/bank/fd_bank_tile.c

@@ -179,11 +179,12 @@ handle_microblock( fd_bank_ctx_t *     ctx,
     txn->flags &= ~FD_TXN_P_FLAGS_EXECUTE_SUCCESS;
 
     txn_ctx->exec_err = fd_runtime_prepare_and_execute_txn( ctx->banks, ctx->_bank_idx, txn_ctx, txn, NULL, &ctx->exec_stack, NULL, NULL );
+    int to_pack = txn_ctx->exec_err==FD_RUNTIME_EXECUTE_SUCCESS || txn_ctx->exec_err==FD_RUNTIME_TXN_ERR_INSTRUCTION_ERROR || txn_ctx->is_fees_only;
 
     /* Stash the result in the flags value so that pack can inspect it. */
     txn->flags = (txn->flags & 0x00FFFFFFU) | ((uint)(-txn_ctx->exec_err)<<24);
 
-    if( FD_UNLIKELY( !(txn_ctx->flags & FD_TXN_P_FLAGS_SANITIZE_SUCCESS ) ) ) {
+    if( FD_UNLIKELY( !to_pack ) ) {
       fd_pack_rebate_sum_add_txn( ctx->rebater, txn, NULL, 1UL );
       ctx->metrics.txn_result[ fd_bank_err_from_runtime_err( txn_ctx->exec_err ) ]++;
       continue;
@@ -192,7 +193,6 @@ handle_microblock( fd_bank_ctx_t *     ctx,
     /* TXN_P_FLAGS_EXECUTE_SUCCESS means that it should be included in
        the block.  It's a bit of a misnomer now that there are fee-only
        transactions. */
-    FD_TEST( txn_ctx->flags & FD_TXN_P_FLAGS_EXECUTE_SUCCESS );
     txn->flags |= FD_TXN_P_FLAGS_EXECUTE_SUCCESS | FD_TXN_P_FLAGS_SANITIZE_SUCCESS;
 
     ctx->metrics.txn_result[ fd_bank_err_from_runtime_err( txn_ctx->exec_err ) ]++;
@@ -211,7 +211,7 @@ handle_microblock( fd_bank_ctx_t *     ctx,
        in finalize anyway. */
     fd_runtime_finalize_txn( ctx->txn_ctx->funk, ctx->txn_ctx->progcache, txn_ctx->status_cache, txn_ctx->xid, txn_ctx, bank, NULL, &tips );
 
-    if( FD_UNLIKELY( !txn_ctx->flags ) ) {
+    if( FD_UNLIKELY( !txn_ctx->exec_err ) ) {
       /* If the transaction failed to fit into the block, we need to
          updated the transaction flag with the error code. */
       txn->flags = (txn->flags & 0x00FFFFFFU) | ((uint)(-txn_ctx->exec_err)<<24);
@@ -356,7 +356,7 @@ handle_bundle( fd_bank_ctx_t *     ctx,
 
     txn_ctx->exec_err = fd_runtime_prepare_and_execute_txn( ctx->banks, ctx->_bank_idx, txn_ctx, txn, NULL, &ctx->exec_stack_bundle[ i ], NULL, NULL );
     txn->flags = (txn->flags & 0x00FFFFFFU) | ((uint)(-txn_ctx->exec_err)<<24);
-    if( FD_UNLIKELY( !(txn_ctx->flags & FD_TXN_P_FLAGS_SANITIZE_SUCCESS ) || txn_ctx->exec_err ) ) {
+    if( FD_UNLIKELY( txn_ctx->exec_err ) ) {
       execution_success = 0;
       continue;
     }
@@ -377,7 +377,10 @@ handle_bundle( fd_bank_ctx_t *     ctx,
 
       txns[ i ].flags |= FD_TXN_P_FLAGS_EXECUTE_SUCCESS | FD_TXN_P_FLAGS_SANITIZE_SUCCESS;
       fd_runtime_finalize_txn( txn_ctx->funk, txn_ctx->progcache, txn_ctx->status_cache, txn_ctx->xid, txn_ctx, bank, NULL, &tips[ i ] );
-      if( FD_UNLIKELY( !txn_ctx->flags ) ) {
+      if( FD_UNLIKELY( txn_ctx->exec_err==FD_RUNTIME_TXN_ERR_WOULD_EXCEED_MAX_BLOCK_COST_LIMIT     ||
+                       txn_ctx->exec_err==FD_RUNTIME_TXN_ERR_WOULD_EXCEED_MAX_VOTE_COST_LIMIT      ||
+                       txn_ctx->exec_err==FD_RUNTIME_TXN_ERR_WOULD_EXCEED_ACCOUNT_DATA_BLOCK_LIMIT ||
+                       txn_ctx->exec_err==FD_RUNTIME_TXN_ERR_WOULD_EXCEED_ACCOUNT_DATA_TOTAL_LIMIT ) ) {
         txns[ i ].flags = (txns[ i ].flags & 0x00FFFFFFU) | ((uint)(-txn_ctx->exec_err)<<24);
         fd_cost_tracker_t * cost_tracker = fd_bank_cost_tracker_locking_modify( bank );
         int res = fd_cost_tracker_calculate_cost_and_add( cost_tracker, txn_ctx );
@@ -390,6 +393,7 @@ handle_bundle( fd_bank_ctx_t *     ctx,
                       cost_tracker->block_cost_limit, cost_tracker->vote_cost_limit,
                       cost_tracker->account_cost_limit ));
       }
+      FD_TEST( txn_ctx->exec_err==FD_RUNTIME_EXECUTE_SUCCESS );
 
       uint actual_execution_cus = (uint)(txn_ctx->compute_budget_details.compute_unit_limit - txn_ctx->compute_budget_details.compute_meter);
       uint actual_acct_data_cus = (uint)(txn_ctx->loaded_accounts_data_size_cost);

src/discof/exec/fd_exec_tile.c

@@ -138,7 +138,9 @@ returnable_frag( fd_exec_tile_ctx_t * ctx,
 
         /* Commit. */
         fd_bank_t * bank = fd_banks_bank_query( ctx->banks, msg->bank_idx );
-        if( FD_LIKELY( ctx->txn_ctx->flags & FD_TXN_P_FLAGS_EXECUTE_SUCCESS ) ) {
+        if( FD_LIKELY( ctx->txn_ctx->exec_err==FD_RUNTIME_EXECUTE_SUCCESS ||
+                       ctx->txn_ctx->exec_err==FD_RUNTIME_TXN_ERR_INSTRUCTION_ERROR ||
+                       ctx->txn_ctx->is_fees_only ) ) {
           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 );
         }
@@ -383,7 +385,7 @@ publish_txn_finalized_msg( fd_exec_tile_ctx_t * ctx,
   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->txn_exec->txn_idx = ctx->txn_idx;
-  msg->txn_exec->err     = !(ctx->txn_ctx->flags&FD_TXN_P_FLAGS_EXECUTE_SUCCESS);
+  msg->txn_exec->err     = ctx->txn_ctx->exec_err!=FD_RUNTIME_EXECUTE_SUCCESS && ctx->txn_ctx->exec_err!=FD_RUNTIME_TXN_ERR_INSTRUCTION_ERROR;
   if( FD_UNLIKELY( msg->txn_exec->err ) ) {
     FD_LOG_WARNING(( "txn failed to execute, bad block detected err=%d", ctx->txn_ctx->exec_err ));
   }

src/flamenco/runtime/context/fd_exec_txn_ctx.h

@@ -46,8 +46,6 @@ struct fd_exec_txn_ctx {
      could be refactored even further. Currently these fields are not
      all valid local joins within the scope of txn execution. */
 
-  uint flags;
-
   fd_bank_t * bank;
 
   fd_exec_stack_t * exec_stack;
@@ -72,7 +70,6 @@ struct fd_exec_txn_ctx {
   ulong                                paid_fees;
   ulong                                loaded_accounts_data_size;                   /* The actual transaction loaded data size */
   ulong                                loaded_accounts_data_size_cost;              /* The cost of the loaded accounts data size in CUs */
-  uint                                 custom_err;                                  /* When a custom error is returned, this is where the numeric value gets stashed */
   uchar                                instr_stack_sz;                              /* Current depth of the instruction execution stack. */
   fd_exec_instr_ctx_t                  instr_stack[FD_MAX_INSTRUCTION_STACK_DEPTH]; /* Instruction execution stack. */
   fd_exec_instr_ctx_t *                failed_instr;
@@ -149,6 +146,8 @@ struct fd_exec_txn_ctx {
   /* Execution error and type, to match Agave. */
   int exec_err;
   int exec_err_kind;
+  uint custom_err;
+  int is_fees_only;
 
    /* The current instruction index being executed */
   int current_instr_idx;

src/flamenco/runtime/fd_runtime.c

@@ -616,14 +616,12 @@ fd_runtime_pre_execute_check( fd_exec_txn_ctx_t * txn_ctx ) {
      the compute budget instructions. */
   err = fd_executor_verify_transaction( txn_ctx );
   if( FD_UNLIKELY( err!=FD_RUNTIME_EXECUTE_SUCCESS ) ) {
-    txn_ctx->flags = 0U;
     return err;
   }
 
   /* Resolve and verify ALUT-referenced account keys, if applicable */
   err = fd_executor_setup_txn_alut_account_keys( txn_ctx );
   if( FD_UNLIKELY( err!=FD_RUNTIME_EXECUTE_SUCCESS ) ) {
-    txn_ctx->flags = 0U;
     return err;
   }
 
@@ -636,15 +634,13 @@ fd_runtime_pre_execute_check( fd_exec_txn_ctx_t * txn_ctx ) {
      https://github.com/anza-xyz/agave/blob/838c1952595809a31520ff1603a13f2c9123aa51/accounts-db/src/account_locks.rs#L118 */
   err = fd_executor_validate_account_locks( txn_ctx );
   if( FD_UNLIKELY( err!=FD_RUNTIME_EXECUTE_SUCCESS ) ) {
-    txn_ctx->flags = 0U;
     return err;
   }
 
   /* load_and_execute_transactions() -> check_transactions()
      https://github.com/anza-xyz/agave/blob/ced98f1ebe73f7e9691308afa757323003ff744f/runtime/src/bank.rs#L3667-L3672 */
   err = fd_executor_check_transactions( txn_ctx );
   if( FD_UNLIKELY( err!=FD_RUNTIME_EXECUTE_SUCCESS ) ) {
-    txn_ctx->flags = 0U;
     return err;
   }
 
@@ -653,7 +649,6 @@ fd_runtime_pre_execute_check( fd_exec_txn_ctx_t * txn_ctx ) {
      https://github.com/anza-xyz/agave/blob/ced98f1ebe73f7e9691308afa757323003ff744f/svm/src/transaction_processor.rs#L236-L249 */
   err = fd_executor_validate_transaction_fee_payer( txn_ctx );
   if( FD_UNLIKELY( err!=FD_RUNTIME_EXECUTE_SUCCESS ) ) {
-    txn_ctx->flags = 0U;
     return err;
   }
 
@@ -663,7 +658,7 @@ fd_runtime_pre_execute_check( fd_exec_txn_ctx_t * txn_ctx ) {
     /* Regardless of whether transaction accounts were loaded successfully, the transaction is
        included in the block and transaction fees are collected.
        https://github.com/anza-xyz/agave/blob/v2.1.6/svm/src/transaction_processor.rs#L341-L357 */
-    txn_ctx->flags |= FD_TXN_P_FLAGS_FEES_ONLY;
+    txn_ctx->is_fees_only = 1;
 
     /* If the transaction fails to load, the "rollback" accounts will include one of the following:
         1. Nonce account only
@@ -1007,10 +1002,11 @@ fd_runtime_finalize_txn( fd_funk_t *               funk,
   /* Update the cost tracker */
   fd_cost_tracker_t * cost_tracker = fd_bank_cost_tracker_locking_modify( bank );
   int res = fd_cost_tracker_calculate_cost_and_add( cost_tracker, txn_ctx );
+  fd_bank_cost_tracker_end_locking_modify( bank );
   if( FD_UNLIKELY( res!=FD_COST_TRACKER_SUCCESS ) ) {
-    txn_ctx->flags = 0U;
+    txn_ctx->exec_err = fd_cost_tracker_err_to_runtime_err( res );
+    return;
   }
-  fd_bank_cost_tracker_end_locking_modify( bank );
 
   txn_ctx->loaded_accounts_data_size_cost = fd_cost_tracker_calculate_loaded_accounts_data_size_cost( txn_ctx );
 
@@ -1055,9 +1051,9 @@ fd_runtime_prepare_and_execute_txn( fd_banks_t *        banks,
   txn_ctx->exec_stack            = exec_stack;
   txn_ctx->dumping_mem           = dumping_mem;
   txn_ctx->tracing_mem           = tracing_mem;
-  txn_ctx->flags                 = FD_TXN_P_FLAGS_SANITIZE_SUCCESS;
   fd_exec_txn_ctx_setup_basic( txn_ctx );
   txn_ctx->capture_ctx           = capture_ctx;
+  txn_ctx->is_fees_only          = 0;
 
   /* Set up the core account keys. These are the account keys directly
      passed in via the serialized transaction, represented as an array.
@@ -1067,18 +1063,13 @@ fd_runtime_prepare_and_execute_txn( fd_banks_t *        banks,
 
   /* Pre-execution checks */
   exec_res = fd_runtime_pre_execute_check( txn_ctx );
-  if( FD_UNLIKELY( !( txn_ctx->flags & FD_TXN_P_FLAGS_SANITIZE_SUCCESS ) ) ) {
+  if( FD_UNLIKELY( exec_res!=FD_RUNTIME_EXECUTE_SUCCESS ) ) {
     return exec_res;
   }
 
   /* Execute the transaction. Note that fees-only transactions are still
      marked as "executed". */
-  txn_ctx->flags |= FD_TXN_P_FLAGS_EXECUTE_SUCCESS;
-  if( FD_LIKELY( !( txn_ctx->flags & FD_TXN_P_FLAGS_FEES_ONLY ) ) ) {
-    exec_res = fd_execute_txn( txn_ctx );
-  }
-
-  return exec_res;
+  return fd_execute_txn( txn_ctx );
 }
 
 /* fd_executor_txn_verify and fd_runtime_pre_execute_check are responisble

src/flamenco/runtime/tests/fd_block_harness.c

@@ -473,7 +473,7 @@ fd_solfuzz_block_ctx_exec( fd_solfuzz_runner_t *     runner,
       fd_exec_txn_ctx_t * txn_ctx = fd_solfuzz_txn_ctx_exec( runner, xid, txn, &res );
       txn_ctx->exec_err           = res;
 
-      if( FD_UNLIKELY( !(txn_ctx->flags & FD_TXN_P_FLAGS_EXECUTE_SUCCESS) ) ) {
+      if( FD_UNLIKELY( res!=FD_RUNTIME_EXECUTE_SUCCESS && res!=FD_RUNTIME_TXN_ERR_INSTRUCTION_ERROR && !txn_ctx->is_fees_only ) ) {
         break;
       }
 
@@ -488,11 +488,9 @@ fd_solfuzz_block_ctx_exec( fd_solfuzz_runner_t *     runner,
           capture_ctx,
           NULL );
 
-      if( FD_UNLIKELY( !(txn_ctx->flags & FD_TXN_P_FLAGS_EXECUTE_SUCCESS) ) ) {
-        break;
-      }
 
-      res = FD_RUNTIME_EXECUTE_SUCCESS;
+
+      res = txn_ctx->exec_err;
     }
 
     /* Finalize the block */

src/flamenco/runtime/tests/fd_txn_harness.c

@@ -342,7 +342,6 @@ fd_solfuzz_txn_ctx_exec( fd_solfuzz_runner_t *     runner,
   /* Setup the spad for account allocation */
   uchar *             txn_ctx_mem = fd_spad_alloc_check( runner->spad, FD_EXEC_TXN_CTX_ALIGN, FD_EXEC_TXN_CTX_FOOTPRINT );
   fd_exec_txn_ctx_t * txn_ctx     = fd_exec_txn_ctx_join( fd_exec_txn_ctx_new( txn_ctx_mem ) );
-  txn_ctx->flags                  = FD_TXN_P_FLAGS_SANITIZE_SUCCESS;
   if( FD_UNLIKELY( !fd_funk_join( txn_ctx->funk, runner->accdb->funk->shmem ) ) ) {
     FD_LOG_CRIT(( "fd_funk_join failed" ));
   }
@@ -417,8 +416,8 @@ fd_solfuzz_pb_txn_run( fd_solfuzz_runner_t * runner,
     }
 
     /* Capture basic results fields */
-    txn_result->executed                          = txn_ctx->flags & FD_TXN_P_FLAGS_EXECUTE_SUCCESS;
-    txn_result->sanitization_error                = !(txn_ctx->flags & FD_TXN_P_FLAGS_SANITIZE_SUCCESS);
+    txn_result->executed                          = exec_res==FD_RUNTIME_EXECUTE_SUCCESS || exec_res==FD_RUNTIME_TXN_ERR_INSTRUCTION_ERROR;
+    txn_result->sanitization_error                = exec_res!=FD_RUNTIME_EXECUTE_SUCCESS && exec_res!=FD_RUNTIME_TXN_ERR_INSTRUCTION_ERROR;
     txn_result->has_resulting_state               = false;
     txn_result->resulting_state.acct_states_count = 0;
     txn_result->is_ok                             = !exec_res;
@@ -431,7 +430,7 @@ fd_solfuzz_pb_txn_run( fd_solfuzz_runner_t * runner,
 
     if( txn_result->sanitization_error ) {
       /* Collect fees for transactions that failed to load */
-      if( txn_ctx->flags & FD_TXN_P_FLAGS_FEES_ONLY ) {
+      if( txn_ctx->is_fees_only ) {
         txn_result->has_fee_details                = true;
         txn_result->fee_details.prioritization_fee = txn_ctx->priority_fee;
         txn_result->fee_details.transaction_fee    = txn_ctx->execution_fee;
@@ -502,7 +501,7 @@ fd_solfuzz_pb_txn_run( fd_solfuzz_runner_t * runner,
     /* If the transaction is a fees-only transaction, we have to create rollback accounts to iterate over and save. */
     fd_txn_account_t * accounts_to_save = txn_ctx->accounts;
     ulong              accounts_cnt     = txn_ctx->accounts_cnt;
-    if( txn_ctx->flags & FD_TXN_P_FLAGS_FEES_ONLY ) {
+    if( txn_ctx->is_fees_only ) {
       accounts_to_save = fd_spad_alloc( runner->spad, alignof(fd_txn_account_t), sizeof(fd_txn_account_t) * 2 );
       accounts_cnt     = 0UL;