refactor: move process_compute_budget_instructions to reduce dependen…

…cy (solana-labs#2392) refactor: move process_compute_budget_instructions from solana_compute_budget to solana_runtime_transaction, to break circular dependencies. Issue solana-labs#2169
behzadnouri · Aug 1, 2024 · c7192d3 · c7192d3
1 parent 1958871
commit c7192d3
Show file tree

Hide file tree

Showing 28 changed files with 122 additions and 98 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/cli/src/compute_budget.rs b/cli/src/compute_budget.rs
@@ -1,6 +1,6 @@
 use {
     solana_clap_utils::compute_budget::ComputeUnitLimit,
-    solana_compute_budget::compute_budget_processor::MAX_COMPUTE_UNIT_LIMIT,
+    solana_compute_budget::compute_budget_limits::MAX_COMPUTE_UNIT_LIMIT,
     solana_rpc_client::rpc_client::RpcClient,
     solana_rpc_client_api::config::RpcSimulateTransactionConfig,
     solana_sdk::{

diff --git a/compute-budget/src/compute_budget.rs b/compute-budget/src/compute_budget.rs
@@ -1,4 +1,4 @@
-use crate::compute_budget_processor::{self, ComputeBudgetLimits, DEFAULT_HEAP_COST};
+use crate::compute_budget_limits::{self, ComputeBudgetLimits, DEFAULT_HEAP_COST};
 
 #[cfg(all(RUSTC_WITH_SPECIALIZATION, feature = "frozen-abi"))]
 impl ::solana_frozen_abi::abi_example::AbiExample for ComputeBudget {
@@ -127,7 +127,7 @@ pub struct ComputeBudget {
 
 impl Default for ComputeBudget {
     fn default() -> Self {
-        Self::new(compute_budget_processor::MAX_COMPUTE_UNIT_LIMIT as u64)
+        Self::new(compute_budget_limits::MAX_COMPUTE_UNIT_LIMIT as u64)
     }
 }
 

diff --git a/compute-budget/src/compute_budget_limits.rs b/compute-budget/src/compute_budget_limits.rs
@@ -0,0 +1,54 @@
+use {
+    crate::prioritization_fee::{PrioritizationFeeDetails, PrioritizationFeeType},
+    solana_sdk::{entrypoint::HEAP_LENGTH, fee::FeeBudgetLimits},
+    std::num::NonZeroU32,
+};
+
+/// Roughly 0.5us/page, where page is 32K; given roughly 15CU/us, the
+/// default heap page cost = 0.5 * 15 ~= 8CU/page
+pub const DEFAULT_HEAP_COST: u64 = 8;
+pub const DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT: u32 = 200_000;
+pub const MAX_COMPUTE_UNIT_LIMIT: u32 = 1_400_000;
+pub const MAX_HEAP_FRAME_BYTES: u32 = 256 * 1024;
+pub const MIN_HEAP_FRAME_BYTES: u32 = HEAP_LENGTH as u32;
+
+/// The total accounts data a transaction can load is limited to 64MiB to not break
+/// anyone in Mainnet-beta today. It can be set by set_loaded_accounts_data_size_limit instruction
+pub const MAX_LOADED_ACCOUNTS_DATA_SIZE_BYTES: NonZeroU32 =
+    unsafe { NonZeroU32::new_unchecked(64 * 1024 * 1024) };
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ComputeBudgetLimits {
+    pub updated_heap_bytes: u32,
+    pub compute_unit_limit: u32,
+    pub compute_unit_price: u64,
+    pub loaded_accounts_bytes: NonZeroU32,
+}
+
+impl Default for ComputeBudgetLimits {
+    fn default() -> Self {
+        ComputeBudgetLimits {
+            updated_heap_bytes: MIN_HEAP_FRAME_BYTES,
+            compute_unit_limit: MAX_COMPUTE_UNIT_LIMIT,
+            compute_unit_price: 0,
+            loaded_accounts_bytes: MAX_LOADED_ACCOUNTS_DATA_SIZE_BYTES,
+        }
+    }
+}
+
+impl From<ComputeBudgetLimits> for FeeBudgetLimits {
+    fn from(val: ComputeBudgetLimits) -> Self {
+        let prioritization_fee_details = PrioritizationFeeDetails::new(
+            PrioritizationFeeType::ComputeUnitPrice(val.compute_unit_price),
+            u64::from(val.compute_unit_limit),
+        );
+        let prioritization_fee = prioritization_fee_details.get_fee();
+
+        FeeBudgetLimits {
+            loaded_accounts_data_size_limit: val.loaded_accounts_bytes,
+            heap_cost: DEFAULT_HEAP_COST,
+            compute_unit_limit: u64::from(val.compute_unit_limit),
+            prioritization_fee,
+        }
+    }
+}
diff --git a/compute-budget/src/lib.rs b/compute-budget/src/lib.rs
@@ -2,5 +2,5 @@
 #![cfg_attr(RUSTC_WITH_SPECIALIZATION, feature(min_specialization))]
 
 pub mod compute_budget;
-pub mod compute_budget_processor;
+pub mod compute_budget_limits;
 pub mod prioritization_fee;
diff --git a/core/Cargo.toml b/core/Cargo.toml
@@ -68,6 +68,7 @@ solana-rayon-threadlimit = { workspace = true }
 solana-rpc = { workspace = true }
 solana-rpc-client-api = { workspace = true }
 solana-runtime = { workspace = true }
+solana-runtime-transaction = { workspace = true }
 solana-sanitize = { workspace = true }
 solana-sdk = { workspace = true }
 solana-send-transaction-service = { workspace = true }

diff --git a/core/src/banking_stage/consumer.rs b/core/src/banking_stage/consumer.rs
@@ -9,7 +9,6 @@ use {
         BankingStageStats,
     },
     itertools::Itertools,
-    solana_compute_budget::compute_budget_processor::process_compute_budget_instructions,
     solana_ledger::token_balances::collect_token_balances,
     solana_measure::{measure::Measure, measure_us},
     solana_poh::poh_recorder::{
@@ -20,6 +19,7 @@ use {
         bank::{Bank, LoadAndExecuteTransactionsOutput},
         transaction_batch::TransactionBatch,
     },
+    solana_runtime_transaction::instructions_processor::process_compute_budget_instructions,
     solana_sdk::{
         clock::{Slot, FORWARD_TRANSACTIONS_TO_LEADER_AT_SLOT_OFFSET, MAX_PROCESSING_AGE},
         feature_set,

diff --git a/core/src/banking_stage/immutable_deserialized_packet.rs b/core/src/banking_stage/immutable_deserialized_packet.rs
@@ -1,9 +1,8 @@
 use {
     super::packet_filter::PacketFilterFailure,
-    solana_compute_budget::compute_budget_processor::{
-        process_compute_budget_instructions, ComputeBudgetLimits,
-    },
+    solana_compute_budget::compute_budget_limits::ComputeBudgetLimits,
     solana_perf::packet::Packet,
+    solana_runtime_transaction::instructions_processor::process_compute_budget_instructions,
     solana_sanitize::SanitizeError,
     solana_sdk::{
         hash::Hash,

diff --git a/core/src/banking_stage/transaction_scheduler/scheduler_controller.rs b/core/src/banking_stage/transaction_scheduler/scheduler_controller.rs
@@ -23,10 +23,10 @@ use {
     },
     arrayvec::ArrayVec,
     crossbeam_channel::RecvTimeoutError,
-    solana_compute_budget::compute_budget_processor::process_compute_budget_instructions,
     solana_cost_model::cost_model::CostModel,
     solana_measure::measure_us,
     solana_runtime::{bank::Bank, bank_forks::BankForks},
+    solana_runtime_transaction::instructions_processor::process_compute_budget_instructions,
     solana_sdk::{
         self,
         clock::{FORWARD_TRANSACTIONS_TO_LEADER_AT_SLOT_OFFSET, MAX_PROCESSING_AGE},

diff --git a/cost-model/Cargo.toml b/cost-model/Cargo.toml
@@ -18,6 +18,7 @@ solana-compute-budget = { workspace = true }
 solana-frozen-abi = { workspace = true, optional = true }
 solana-frozen-abi-macro = { workspace = true, optional = true }
 solana-metrics = { workspace = true }
+solana-runtime-transaction = { workspace = true }
 solana-sdk = { workspace = true }
 solana-vote-program = { workspace = true }
 

diff --git a/cost-model/src/cost_model.rs b/cost-model/src/cost_model.rs
@@ -9,10 +9,10 @@ use {
     crate::{block_cost_limits::*, transaction_cost::*},
     log::*,
     solana_builtins_default_costs::BUILTIN_INSTRUCTION_COSTS,
-    solana_compute_budget::compute_budget_processor::{
-        process_compute_budget_instructions, DEFAULT_HEAP_COST,
-        DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT, MAX_COMPUTE_UNIT_LIMIT,
+    solana_compute_budget::compute_budget_limits::{
+        DEFAULT_HEAP_COST, DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT, MAX_COMPUTE_UNIT_LIMIT,
     },
+    solana_runtime_transaction::instructions_processor::process_compute_budget_instructions,
     solana_sdk::{
         borsh1::try_from_slice_unchecked,
         compute_budget::{self, ComputeBudgetInstruction},
@@ -628,8 +628,8 @@ mod tests {
             .unwrap();
         const DEFAULT_PAGE_COST: u64 = 8;
         let expected_loaded_accounts_data_size_cost =
-            solana_compute_budget::compute_budget_processor::MAX_LOADED_ACCOUNTS_DATA_SIZE_BYTES
-                .get() as u64
+            solana_compute_budget::compute_budget_limits::MAX_LOADED_ACCOUNTS_DATA_SIZE_BYTES.get()
+                as u64
                 / ACCOUNT_DATA_COST_PAGE_SIZE
                 * DEFAULT_PAGE_COST;
 

diff --git a/program-runtime/src/invoke_context.rs b/program-runtime/src/invoke_context.rs
@@ -815,7 +815,7 @@ mod tests {
     use {
         super::*,
         serde::{Deserialize, Serialize},
-        solana_compute_budget::compute_budget_processor,
+        solana_compute_budget::compute_budget_limits,
         solana_sdk::{account::WritableAccount, instruction::Instruction, rent::Rent},
     };
 
@@ -1143,7 +1143,7 @@ mod tests {
 
         with_mock_invoke_context!(invoke_context, transaction_context, transaction_accounts);
         invoke_context.compute_budget = ComputeBudget::new(
-            compute_budget_processor::DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT as u64,
+            compute_budget_limits::DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT as u64,
         );
 
         invoke_context
@@ -1155,7 +1155,7 @@ mod tests {
         assert_eq!(
             *invoke_context.get_compute_budget(),
             ComputeBudget::new(
-                compute_budget_processor::DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT as u64
+                compute_budget_limits::DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT as u64
             )
         );
         invoke_context.pop().unwrap();

diff --git a/program-runtime/src/mem_pool.rs b/program-runtime/src/mem_pool.rs
@@ -1,7 +1,7 @@
 use {
     solana_compute_budget::{
         compute_budget::{MAX_CALL_DEPTH, MAX_INSTRUCTION_STACK_DEPTH, STACK_FRAME_SIZE},
-        compute_budget_processor::{MAX_HEAP_FRAME_BYTES, MIN_HEAP_FRAME_BYTES},
+        compute_budget_limits::{MAX_HEAP_FRAME_BYTES, MIN_HEAP_FRAME_BYTES},
     },
     solana_rbpf::{aligned_memory::AlignedMemory, ebpf::HOST_ALIGN},
     std::array,

diff --git a/programs/sbf/Cargo.lock b/programs/sbf/Cargo.lock
diff --git a/programs/sbf/Cargo.toml b/programs/sbf/Cargo.toml
@@ -42,6 +42,7 @@ solana-poseidon = { path = "../../poseidon/", version = "=2.1.0" }
 solana-program = { path = "../../sdk/program", version = "=2.1.0" }
 solana-program-runtime = { path = "../../program-runtime", version = "=2.1.0" }
 solana-runtime = { path = "../../runtime", version = "=2.1.0" }
+solana-runtime-transaction = { path = "../../runtime-transaction", version = "=2.1.0" }
 solana-sbf-rust-128bit-dep = { path = "rust/128bit_dep", version = "=2.1.0" }
 solana-sbf-rust-invoke-dep = { path = "rust/invoke_dep", version = "=2.1.0" }
 solana-sbf-rust-invoked-dep = { path = "rust/invoked_dep", version = "=2.1.0" }
@@ -108,6 +109,7 @@ solana-measure = { workspace = true }
 solana-program = { workspace = true }
 solana-program-runtime = { workspace = true }
 solana-runtime = { workspace = true, features = ["dev-context-only-utils"] }
+solana-runtime-transaction = { workspace = true }
 solana-sbf-rust-invoke-dep = { workspace = true }
 solana-sbf-rust-realloc-dep = { workspace = true }
 solana-sbf-rust-realloc-invoke-dep = { workspace = true }

diff --git a/programs/sbf/tests/programs.rs b/programs/sbf/tests/programs.rs
@@ -13,10 +13,7 @@ use {
     solana_account_decoder::parse_bpf_loader::{
         parse_bpf_upgradeable_loader, BpfUpgradeableLoaderAccountType,
     },
-    solana_compute_budget::{
-        compute_budget::ComputeBudget,
-        compute_budget_processor::process_compute_budget_instructions,
-    },
+    solana_compute_budget::compute_budget::ComputeBudget,
     solana_ledger::token_balances::collect_token_balances,
     solana_program_runtime::invoke_context::mock_process_instruction,
     solana_rbpf::vm::ContextObject,
@@ -34,6 +31,7 @@ use {
             load_upgradeable_program_wrapper, set_upgrade_authority, upgrade_program,
         },
     },
+    solana_runtime_transaction::instructions_processor::process_compute_budget_instructions,
     solana_sbf_rust_invoke_dep::*,
     solana_sbf_rust_realloc_dep::*,
     solana_sbf_rust_realloc_invoke_dep::*,

diff --git a/programs/zk-token-proof-tests/tests/process_transaction.rs b/programs/zk-token-proof-tests/tests/process_transaction.rs
@@ -1717,7 +1717,7 @@ impl WithMaxComputeUnitLimit for Vec<solana_sdk::instruction::Instruction> {
     fn with_max_compute_unit_limit(mut self) -> Self {
         self.push(
             solana_sdk::compute_budget::ComputeBudgetInstruction::set_compute_unit_limit(
-                solana_compute_budget::compute_budget_processor::MAX_COMPUTE_UNIT_LIMIT,
+                solana_compute_budget::compute_budget_limits::MAX_COMPUTE_UNIT_LIMIT,
             ),
         );
         self