flamenco, program-cache: remove end-of-slot iterations

Author: mjain-jump

src/flamenco/runtime/context/fd_exec_txn_ctx.c

@@ -180,6 +180,8 @@ fd_exec_txn_ctx_setup_basic( fd_exec_txn_ctx_t * ctx ) {
   ctx->instr_stack_sz            = 0;
   ctx->accounts_cnt              = 0UL;
   ctx->executable_cnt            = 0UL;
+  ctx->programs_to_reverify_cnt  = 0UL;
+
   ctx->paid_fees                 = 0UL;
   ctx->loaded_accounts_data_size = 0UL;
   ctx->accounts_resize_delta     = 0UL;

src/flamenco/runtime/context/fd_exec_txn_ctx.h

@@ -106,6 +106,15 @@ struct fd_exec_txn_ctx {
   fd_txn_account_t                executable_accounts[ MAX_TX_ACCOUNT_LOCKS ]; /* Array of BPF upgradeable loader program data accounts */
   fd_txn_account_t                accounts[ MAX_TX_ACCOUNT_LOCKS ];            /* Array of borrowed accounts accessed by this transaction. */
 
+  /* When a program is deployed or upgraded, we must queue it to be
+     updated in the program cache (if it exists already) so that
+     the cache entry's ELF / sBPF information can be updated for future
+     executions. We keep an array of pubkeys for the transaction to
+     track which programs need to be reverified. The actual queueing
+     for reverification is done in the transaction finalization step. */
+  uchar                           programs_to_reverify_cnt;
+  fd_pubkey_t                     programs_to_reverify[ MAX_TX_ACCOUNT_LOCKS ];
+
   /* The next three fields describe Agave's "rollback" accounts, which
      are copies of the fee payer and (if applicable) nonce account. If the
      transaction fails to load, the fee payer is still debited the transaction fee,

src/flamenco/runtime/fd_executor.c

@@ -20,6 +20,7 @@
 #include "program/fd_vote_program.h"
 #include "program/fd_zk_elgamal_proof_program.h"
 #include "sysvar/fd_sysvar_cache.h"
+#include "program/fd_program_cache.h"
 #include "sysvar/fd_sysvar_epoch_schedule.h"
 #include "sysvar/fd_sysvar_instructions.h"
 #include "sysvar/fd_sysvar_rent.h"

src/flamenco/runtime/fd_runtime.c

@@ -25,7 +25,7 @@
 #include "program/fd_stake_program.h"
 #include "program/fd_builtin_programs.h"
 #include "program/fd_vote_program.h"
-#include "program/fd_bpf_program_util.h"
+#include "program/fd_program_cache.h"
 #include "program/fd_bpf_loader_program.h"
 #include "program/fd_address_lookup_table_program.h"
 
@@ -1027,12 +1027,6 @@ fd_runtime_block_execute_finalize_start( fd_exec_slot_ctx_t *             slot_c
   /* This slot is now "frozen" and can't be changed anymore. */
   fd_runtime_freeze( slot_ctx );
 
-  int result = fd_bpf_scan_and_create_bpf_program_cache_entry( slot_ctx, runtime_spad );
-  if( FD_UNLIKELY( result ) ) {
-    FD_LOG_WARNING(( "update bpf program cache failed" ));
-    return;
-  }
-
   /* Collect list of changed accounts to be added to bank hash */
   *task_data = fd_spad_alloc( runtime_spad,
                               alignof(fd_accounts_hash_task_data_t),
@@ -1390,6 +1384,16 @@ fd_runtime_finalize_txn( fd_funk_t *                  funk,
 
       fd_txn_account_save( &txn_ctx->accounts[i], funk, funk_txn, txn_ctx->spad_wksp );
     }
+
+    /* We need to queue any existing program accounts that may have
+       been deployed / upgraded for reverification in the program
+       cache since their programdata may have changed. ELF / sBPF
+       metadata will need to be updated. */
+      ulong current_slot = fd_bank_slot_get( bank );
+      for( uchar i=0; i<txn_ctx->programs_to_reverify_cnt; i++ ) {
+        fd_pubkey_t const * program_key = &txn_ctx->programs_to_reverify[i];
+        fd_program_cache_queue_program_for_reverification( funk, funk_txn, program_key, current_slot );
+      }
   }
 
   int is_vote = fd_txn_is_simple_vote_transaction( txn_ctx->txn_descriptor, txn_ctx->_txn_raw->raw );
@@ -1889,6 +1893,7 @@ fd_migrate_builtin_to_core_bpf( fd_exec_slot_ctx_t * slot_ctx,
   /* Deploy the new target Core BPF program.
      https://github.com/anza-xyz/agave/blob/v2.1.0/runtime/src/bank/builtins/core_bpf_migration/mod.rs#L268-L271 */
   err = fd_directly_invoke_loader_v3_deploy( slot_ctx,
+                                             builtin_program_id,
                                              new_target_program_data_account->vt->get_data( new_target_program_data_account ) + PROGRAMDATA_METADATA_SIZE,
                                              new_target_program_data_account->vt->get_data_len( new_target_program_data_account ) - PROGRAMDATA_METADATA_SIZE,
                                              runtime_spad );
@@ -2222,7 +2227,7 @@ fd_runtime_update_program_cache( fd_exec_slot_ctx_t * slot_ctx,
   fd_acct_addr_t const * acc_addrs = fd_txn_get_acct_addrs( txn_descriptor, txn_p );
   for( ushort acc_idx=0; acc_idx<txn_descriptor->acct_addr_cnt; acc_idx++ ) {
     fd_pubkey_t const * account = fd_type_pun_const( &acc_addrs[acc_idx] );
-    fd_bpf_program_update_program_cache( slot_ctx, account, runtime_spad );
+    fd_program_cache_update_program( slot_ctx, account, runtime_spad );
   }
 
   if( txn_descriptor->transaction_version==FD_TXN_V0 ) {
@@ -2236,6 +2241,11 @@ fd_runtime_update_program_cache( fd_exec_slot_ctx_t * slot_ctx,
 
     fd_slot_hash_t * slot_hash = deq_fd_slot_hash_t_join( (uchar *)slot_hashes_global + slot_hashes_global->hashes_offset );
 
+    /* TODO: This is done twice, once in the replay tile and once in the
+       exec tile. We should consolidate the account resolution into a
+       single place, but also keep in mind from a conformance
+       perspective that these ALUT resolution checks happen after some
+       things like compute budget instruction parsing */
     if( FD_UNLIKELY( fd_runtime_load_txn_address_lookup_tables(
           txn_descriptor,
           txn_p->payload,
@@ -2249,7 +2259,7 @@ fd_runtime_update_program_cache( fd_exec_slot_ctx_t * slot_ctx,
 
     for( ushort alut_idx=0; alut_idx<txn_descriptor->addr_table_adtl_cnt; alut_idx++ ) {
       fd_pubkey_t const * account = fd_type_pun_const( &alut_accounts[alut_idx] );
-      fd_bpf_program_update_program_cache( slot_ctx, account, runtime_spad );
+      fd_program_cache_update_program( slot_ctx, account, runtime_spad );
     }
   }
 

src/flamenco/runtime/fd_runtime.h

@@ -619,21 +619,15 @@ fd_runtime_block_pre_execute_process_new_epoch( fd_exec_slot_ctx_t * slot_ctx,
                                                 fd_spad_t *          runtime_spad,
                                                 int *                is_epoch_boundary );
 
-/* This function is responsible for inserting fresh entries or updating existing entries in the program cache.
-   When the client boots up, the program cache is empty. As programs get invoked, this function is responsible
-   for verifying and inserting these programs into the cache. Additionally, this function performs reverification
-   checks for every existing program that is invoked after an epoch boundary once per program per epoch, and invalidates
-   any programs that fail reverification.
-
-   When the cluster's feature set changes at an epoch, there is a possibility that existing programs
-   fail new SBPF / ELF header checks. Therefore, after every epoch, we should reverify all programs
-   and update our program cache so that users cannot invoke those old programs. Since iterating through
-   all programs every single epoch is expensive, we adopt a lazy approach where we reverify programs as they
-   are referenced in transactions, since only a small subset of all programs are actually referenced at any
-   time. We also make sure each program is only verified once per epoch, so repeated executions of a
-   program within the same epoch will only trigger verification once at the very first invocation.
-
-   Note that ALUTs must be resolved because programs referenced in ALUTs can be invoked via CPI. */
+/* `fd_runtime_update_program_cache()` is responsible for updating the
+   program cache with any programs referenced in the current
+   transaction. See fd_program_cache.h for more details.
+
+   Note that ALUTs must be resolved because programs referenced in ALUTs
+   can be invoked via CPI.
+
+   TODO: We need to remove the ALUT resolution from this function
+   because it is redundant (ALUTs get resolved again in the exec tile). */
 void
 fd_runtime_update_program_cache( fd_exec_slot_ctx_t * slot_ctx,
                                  fd_txn_p_t const *   txn_p,

src/flamenco/runtime/program/Local.mk

@@ -8,8 +8,8 @@ $(call add-objs,fd_builtin_programs,fd_flamenco)
 $(call add-hdrs,fd_bpf_loader_serialization.h)
 $(call add-objs,fd_bpf_loader_serialization,fd_flamenco)
 
-$(call add-hdrs,fd_bpf_program_util.h)
-$(call add-objs,fd_bpf_program_util,fd_flamenco)
+$(call add-hdrs,fd_program_cache.h)
+$(call add-objs,fd_program_cache,fd_flamenco)
 
 ### Precompiles