Cleanup - Removes the CLI option "no-bpf-jit"

ledger-tool/src/main.rs

@@ -1462,10 +1462,6 @@ fn main() {
         .long("no-snapshot")
         .takes_value(false)
         .help("Do not start from a local snapshot if present");
-    let no_bpf_jit_arg = Arg::with_name("no_bpf_jit")
-        .long("no-bpf-jit")
-        .takes_value(false)
-        .help("Disable the just-in-time compiler and instead use the interpreter for BP");
     let accounts_index_bins = Arg::with_name("accounts_index_bins")
         .long("accounts-index-bins")
         .value_name("BINS")
@@ -1960,7 +1956,6 @@ fn main() {
             .arg(&hard_forks_arg)
             .arg(&accounts_db_test_hash_calculation_arg)
             .arg(&no_os_memory_stats_reporting_arg)
-            .arg(&no_bpf_jit_arg)
             .arg(&allow_dead_slots_arg)
             .arg(&max_genesis_archive_unpacked_size_arg)
             .arg(&debug_key_arg)
@@ -2948,10 +2943,7 @@ fn main() {
                     accounts_db_test_hash_calculation: arg_matches
                         .is_present("accounts_db_test_hash_calculation"),
                     accounts_db_skip_shrink: arg_matches.is_present("accounts_db_skip_shrink"),
-                    runtime_config: RuntimeConfig {
-                        bpf_jit: !arg_matches.is_present("no_bpf_jit"),
-                        ..RuntimeConfig::default()
-                    },
+                    runtime_config: RuntimeConfig::default(),
                     ..ProcessOptions::default()
                 };
                 let print_accounts_stats = arg_matches.is_present("print_accounts_stats");

ledger/src/bank_forks_utils.rs

@@ -213,9 +213,7 @@ fn bank_forks_from_snapshot(
             genesis_config,
             &process_options.runtime_config,
             process_options.debug_keys.clone(),
-            Some(&crate::builtins::get(
-                process_options.runtime_config.bpf_jit,
-            )),
+            Some(&crate::builtins::get()),
             process_options.account_indexes.clone(),
             process_options.limit_load_slot_count_from_snapshot,
             process_options.shrink_ratio,

ledger/src/blockstore_processor.rs

@@ -45,6 +45,7 @@ use {
         genesis_config::GenesisConfig,
         hash::Hash,
         pubkey::Pubkey,
+        saturating_add_assign,
         signature::{Keypair, Signature},
         timing,
         transaction::{
@@ -712,7 +713,7 @@ pub(crate) fn process_blockstore_for_bank_0(
         Arc::new(opts.runtime_config.clone()),
         account_paths,
         opts.debug_keys.clone(),
-        Some(&crate::builtins::get(opts.runtime_config.bpf_jit)),
+        Some(&crate::builtins::get()),
         opts.account_indexes.clone(),
         opts.shrink_ratio,
         false,

ledger/src/builtins.rs

@@ -1,42 +1,26 @@
 use {
     solana_program_runtime::builtin_program::BuiltinProgram,
     solana_runtime::builtins::{BuiltinFeatureTransition, Builtins},
+    solana_sdk::{bpf_loader, bpf_loader_deprecated, bpf_loader_upgradeable},
 };
 
-macro_rules! to_builtin {
-    ($b:expr) => {
-        BuiltinProgram {
-            name: $b.0.to_string(),
-            program_id: $b.1,
-            process_instruction: $b.2,
-        }
-    };
-}
-
 /// Builtin programs that are always available
-fn genesis_builtins(bpf_jit: bool) -> Vec<BuiltinProgram> {
-    // Currently JIT is not supported on the SBF VM:
-    // !x86_64: https://github.com/qmonnet/rbpf/issues/48
-    // Windows: https://github.com/solana-labs/rbpf/issues/217
-    #[cfg(any(not(target_arch = "x86_64"), target_family = "windows"))]
-    let bpf_jit = {
-        if bpf_jit {
-            info!("SBF JIT is not supported on this target");
-        }
-        false
-    };
-
+fn genesis_builtins() -> Vec<BuiltinProgram> {
     vec![
-        to_builtin!(solana_bpf_loader_deprecated_program!()),
-        if bpf_jit {
-            to_builtin!(solana_bpf_loader_program_with_jit!())
-        } else {
-            to_builtin!(solana_bpf_loader_program!())
+        BuiltinProgram {
+            name: "solana_bpf_loader_deprecated_program".to_string(),
+            program_id: bpf_loader_deprecated::id(),
+            process_instruction: solana_bpf_loader_program::process_instruction,
+        },
+        BuiltinProgram {
+            name: "solana_bpf_loader_program".to_string(),
+            program_id: bpf_loader::id(),
+            process_instruction: solana_bpf_loader_program::process_instruction,
         },
-        if bpf_jit {
-            to_builtin!(solana_bpf_loader_upgradeable_program_with_jit!())
-        } else {
-            to_builtin!(solana_bpf_loader_upgradeable_program!())
+        BuiltinProgram {
+            name: "solana_bpf_loader_upgradeable_program".to_string(),
+            program_id: bpf_loader_upgradeable::id(),
+            process_instruction: solana_bpf_loader_program::process_instruction,
         },
     ]
 }
@@ -46,9 +30,9 @@ fn builtin_feature_transitions() -> Vec<BuiltinFeatureTransition> {
     vec![]
 }
 
-pub(crate) fn get(bpf_jit: bool) -> Builtins {
+pub(crate) fn get() -> Builtins {
     Builtins {
-        genesis_builtins: genesis_builtins(bpf_jit),
+        genesis_builtins: genesis_builtins(),
         feature_transitions: builtin_feature_transitions(),
     }
 }

ledger/src/lib.rs

@@ -1,7 +1,5 @@
 #![cfg_attr(RUSTC_WITH_SPECIALIZATION, feature(min_specialization))]
 #![allow(clippy::integer_arithmetic)]
-#[macro_use]
-extern crate solana_bpf_loader_program;
 
 pub mod bank_forks_utils;
 pub mod bigtable_delete;

program-runtime/src/loaded_programs.rs

@@ -157,7 +157,6 @@ impl LoadedProgram {
         maybe_expiration_slot: Option<Slot>,
         elf_bytes: &[u8],
         account_size: usize,
-        use_jit: bool,
         metrics: &mut LoadProgramMetrics,
     ) -> Result<Self, Box<dyn std::error::Error>> {
         let mut load_elf_time = Measure::start("load_elf_time");
@@ -181,19 +180,17 @@ impl LoadedProgram {
         verify_code_time.stop();
         metrics.verify_code_us = verify_code_time.as_us();
 
-        if use_jit {
-            #[cfg(all(not(target_os = "windows"), target_arch = "x86_64"))]
-            {
-                let mut jit_compile_time = Measure::start("jit_compile_time");
-                match &mut program {
-                    LoadedProgramType::LegacyV0(executable) => executable.jit_compile(),
-                    LoadedProgramType::LegacyV1(executable) => executable.jit_compile(),
-                    LoadedProgramType::Typed(executable) => executable.jit_compile(),
-                    _ => Err(EbpfError::JitNotCompiled),
-                }?;
-                jit_compile_time.stop();
-                metrics.jit_compile_us = jit_compile_time.as_us();
-            }
+        #[cfg(all(not(target_os = "windows"), target_arch = "x86_64"))]
+        {
+            let mut jit_compile_time = Measure::start("jit_compile_time");
+            match &mut program {
+                LoadedProgramType::LegacyV0(executable) => executable.jit_compile(),
+                LoadedProgramType::LegacyV1(executable) => executable.jit_compile(),
+                LoadedProgramType::Typed(executable) => executable.jit_compile(),
+                _ => Err(EbpfError::JitNotCompiled),
+            }?;
+            jit_compile_time.stop();
+            metrics.jit_compile_us = jit_compile_time.as_us();
         }
 
         Ok(Self {

program-test/src/lib.rs

@@ -440,7 +440,6 @@ pub struct ProgramTest {
     builtin_programs: BuiltinPrograms,
     compute_max_units: Option<u64>,
     prefer_bpf: bool,
-    use_bpf_jit: bool,
     deactivate_feature_set: HashSet<Pubkey>,
     transaction_account_lock_limit: Option<usize>,
 }
@@ -478,7 +477,6 @@ impl Default for ProgramTest {
             builtin_programs: BuiltinPrograms::default(),
             compute_max_units: None,
             prefer_bpf,
-            use_bpf_jit: false,
             deactivate_feature_set,
             transaction_account_lock_limit: None,
         }
@@ -525,11 +523,6 @@ impl ProgramTest {
         self.compute_max_units = Some(bpf_compute_max_units);
     }
 
-    /// Execute the SBF program with JIT if true, interpreted if false
-    pub fn use_bpf_jit(&mut self, use_bpf_jit: bool) {
-        self.use_bpf_jit = use_bpf_jit;
-    }
-
     /// Add an account to the test environment
     pub fn add_account(&mut self, address: Pubkey, account: Account) {
         self.accounts
@@ -785,7 +778,6 @@ impl ProgramTest {
         let mut bank = Bank::new_with_runtime_config_for_tests(
             &genesis_config,
             Arc::new(RuntimeConfig {
-                bpf_jit: self.use_bpf_jit,
                 compute_budget: self.compute_max_units.map(|max_units| ComputeBudget {
                     compute_unit_limit: max_units,
                     ..ComputeBudget::default()
@@ -802,13 +794,8 @@ impl ProgramTest {
             };
         }
         add_builtin!(solana_bpf_loader_deprecated_program!());
-        if self.use_bpf_jit {
-            add_builtin!(solana_bpf_loader_program_with_jit!());
-            add_builtin!(solana_bpf_loader_upgradeable_program_with_jit!());
-        } else {
-            add_builtin!(solana_bpf_loader_program!());
-            add_builtin!(solana_bpf_loader_upgradeable_program!());
-        }
+        add_builtin!(solana_bpf_loader_program!());
+        add_builtin!(solana_bpf_loader_upgradeable_program!());
 
         // Add commonly-used SPL programs as a convenience to the user
         for (program_id, account) in programs::spl_programs(&Rent::default()).iter() {