Merge branch 'rumenov/scdfo' into 'master'

chore: remove the redundant SubnetConfigs type in favour of a SubnetConfig::new constructor

Also don't construct the SubnetConfig as soon as the replica starts but just before the components that require it. 

See merge request dfinity-lab/public/ic!12564

Author: rumenov

rs/config/src/subnet_config.rs

@@ -439,92 +439,46 @@ impl CyclesAccountManagerConfig {
     }
 }
 
-/// The per subnet type configuration for CoW Memory Manager
-#[derive(Clone)]
-pub struct CowMemoryManagerConfig {
-    /// Flag to enable or disable the feature
-    pub enabled: bool,
-}
-
-impl CowMemoryManagerConfig {
-    pub fn application_subnet() -> Self {
-        Self { enabled: false }
-    }
-
-    pub fn system_subnet() -> Self {
-        Self { enabled: false }
-    }
-
-    pub fn verified_application_subnet() -> Self {
-        Self { enabled: false }
-    }
-}
-
 /// If a component has at least one static configuration that is different for
 /// different subnet types, then it is included in this struct.
 #[derive(Clone)]
 pub struct SubnetConfig {
     pub scheduler_config: SchedulerConfig,
     pub cycles_account_manager_config: CyclesAccountManagerConfig,
-    pub cow_memory_manager_config: CowMemoryManagerConfig,
 }
 
 impl SubnetConfig {
+    pub fn new(own_subnet_type: SubnetType) -> Self {
+        match own_subnet_type {
+            SubnetType::Application => Self::default_application_subnet(),
+            SubnetType::System => Self::default_system_subnet(),
+            SubnetType::VerifiedApplication => Self::default_verified_application_subnet(),
+        }
+    }
+
     /// Returns the subnet configuration for the application subnet type.
-    pub fn default_application_subnet() -> Self {
+    fn default_application_subnet() -> Self {
         Self {
             scheduler_config: SchedulerConfig::application_subnet(),
             cycles_account_manager_config: CyclesAccountManagerConfig::application_subnet(),
-            cow_memory_manager_config: CowMemoryManagerConfig::application_subnet(),
         }
     }
 
     /// Returns the subnet configuration for the system subnet type.
-    pub fn default_system_subnet() -> Self {
+    fn default_system_subnet() -> Self {
         Self {
             scheduler_config: SchedulerConfig::system_subnet(),
             cycles_account_manager_config: CyclesAccountManagerConfig::system_subnet(),
-            cow_memory_manager_config: CowMemoryManagerConfig::system_subnet(),
         }
     }
 
     /// Returns the subnet configuration for the verified application subnet
     /// type.
-    pub fn default_verified_application_subnet() -> Self {
+    fn default_verified_application_subnet() -> Self {
         Self {
             scheduler_config: SchedulerConfig::verified_application_subnet(),
             cycles_account_manager_config: CyclesAccountManagerConfig::verified_application_subnet(
             ),
-            cow_memory_manager_config: CowMemoryManagerConfig::verified_application_subnet(),
-        }
-    }
-}
-
-/// A struct that holds the per subnet configuration for all the subnet types on
-/// the internet computer.
-pub struct SubnetConfigs {
-    system_subnet: SubnetConfig,
-    application_subnet: SubnetConfig,
-    verified_application_subnet: SubnetConfig,
-}
-
-impl Default for SubnetConfigs {
-    fn default() -> Self {
-        Self {
-            system_subnet: SubnetConfig::default_system_subnet(),
-            application_subnet: SubnetConfig::default_application_subnet(),
-            verified_application_subnet: SubnetConfig::default_verified_application_subnet(),
-        }
-    }
-}
-
-impl SubnetConfigs {
-    /// Returns the appropriate subnet configuration based on the subnet type.
-    pub fn own_subnet_config(&self, own_subnet_type: SubnetType) -> SubnetConfig {
-        match own_subnet_type {
-            SubnetType::Application => self.application_subnet.clone(),
-            SubnetType::System => self.system_subnet.clone(),
-            SubnetType::VerifiedApplication => self.verified_application_subnet.clone(),
         }
     }
 }

rs/cycles_account_manager/tests/cycles_account_manager.rs

@@ -1,5 +1,5 @@
 use ic_base_types::NumSeconds;
-use ic_config::subnet_config::SubnetConfigs;
+use ic_config::subnet_config::SubnetConfig;
 use ic_constants::SMALL_APP_SUBNET_MAX_SIZE;
 use ic_cycles_account_manager::IngressInductionCost;
 use ic_ic00_types::{CanisterIdRecord, Payload, IC_00};
@@ -296,9 +296,7 @@ fn canister_charge_for_memory_until_zero_works() {
     let subnet_size = SMALL_APP_SUBNET_MAX_SIZE;
     let mut system_state = SystemStateBuilder::new().build();
     let subnet_type = SubnetType::Application;
-    let config = SubnetConfigs::default()
-        .own_subnet_config(subnet_type)
-        .cycles_account_manager_config;
+    let config = SubnetConfig::new(subnet_type).cycles_account_manager_config;
     let gib_stored_per_second_fee = config.gib_storage_per_second_fee;
     let cycles_account_manager = CyclesAccountManagerBuilder::new()
         .with_subnet_type(subnet_type)

rs/determinism_test/src/setup.rs

@@ -1,7 +1,4 @@
-use ic_config::{
-    subnet_config::{SubnetConfig, SubnetConfigs},
-    Config,
-};
+use ic_config::{subnet_config::SubnetConfig, Config};
 use ic_cycles_account_manager::CyclesAccountManager;
 use ic_execution_environment::ExecutionServices;
 use ic_interfaces::execution_environment::IngressHistoryReader;
@@ -100,7 +97,7 @@ pub(crate) fn setup() -> (
     let subnet_id = subnet_test_id(1);
     let root_subnet_id = subnet_test_id(2);
     let (config, _) = Config::temp_config();
-    let subnet_config = SubnetConfigs::default().own_subnet_config(subnet_type);
+    let subnet_config = SubnetConfig::new(subnet_type);
     let replica_config = ReplicaConfig {
         node_id: NodeId::from(PrincipalId::new_node_test_id(27)),
         subnet_id,

rs/drun/src/lib.rs

@@ -2,7 +2,7 @@
 
 use crate::message::{msg_stream_from_file, Message};
 use hex::encode;
-use ic_config::{subnet_config::SubnetConfigs, Config};
+use ic_config::{subnet_config::SubnetConfig, Config};
 use ic_cycles_account_manager::CyclesAccountManager;
 use ic_error_types::{ErrorCode, UserError};
 use ic_execution_environment::ExecutionServices;
@@ -163,7 +163,7 @@ pub fn run_drun(uo: DrunOptions) -> Result<(), String> {
         subnet_type,
     } = uo;
     // Hardcoded magic values to create a ReplicaConfig that parses.
-    let mut subnet_config = SubnetConfigs::default().own_subnet_config(subnet_type);
+    let mut subnet_config = SubnetConfig::new(subnet_type);
 
     // If an intruction limit was specified, update the config with the provided instruction limit.
     if let Some(instruction_limit) = instruction_limit {

rs/execution_environment/benchmarks/common.rs

@@ -4,7 +4,7 @@
 use criterion::{BatchSize, Criterion};
 use ic_config::execution_environment::Config;
 use ic_config::flag_status::FlagStatus;
-use ic_config::subnet_config::{SchedulerConfig, SubnetConfigs};
+use ic_config::subnet_config::{SchedulerConfig, SubnetConfig};
 use ic_constants::SMALL_APP_SUBNET_MAX_SIZE;
 use ic_cycles_account_manager::CyclesAccountManager;
 use ic_error_types::RejectCode;
@@ -225,7 +225,7 @@ where
     let log = no_op_logger();
     let own_subnet_id = subnet_test_id(1);
     let own_subnet_type = SubnetType::Application;
-    let subnet_configs = SubnetConfigs::default().own_subnet_config(own_subnet_type);
+    let subnet_configs = SubnetConfig::new(own_subnet_type);
     let cycles_account_manager = Arc::new(CyclesAccountManager::new(
         subnet_configs.scheduler_config.max_instructions_per_message,
         own_subnet_type,

rs/execution_environment/src/scheduler/test_utilities.rs

@@ -8,7 +8,7 @@ use std::{
 use ic_base_types::{CanisterId, NumBytes, SubnetId};
 use ic_config::{
     flag_status::FlagStatus,
-    subnet_config::{SchedulerConfig, SubnetConfigs},
+    subnet_config::{SchedulerConfig, SubnetConfig},
 };
 use ic_cycles_account_manager::CyclesAccountManager;
 use ic_embedders::{
@@ -606,9 +606,7 @@ pub(crate) struct SchedulerTestBuilder {
 impl Default for SchedulerTestBuilder {
     fn default() -> Self {
         let subnet_type = SubnetType::Application;
-        let scheduler_config = SubnetConfigs::default()
-            .own_subnet_config(subnet_type)
-            .scheduler_config;
+        let scheduler_config = SubnetConfig::new(subnet_type).scheduler_config;
         let config = ic_config::execution_environment::Config::default();
         let subnet_total_memory = config.subnet_memory_capacity.get();
         let max_canister_memory_size = config.max_canister_memory_size.get();
@@ -643,9 +641,7 @@ impl SchedulerTestBuilder {
     }
 
     pub fn with_subnet_type(self, subnet_type: SubnetType) -> Self {
-        let scheduler_config = SubnetConfigs::default()
-            .own_subnet_config(subnet_type)
-            .scheduler_config;
+        let scheduler_config = SubnetConfig::new(subnet_type).scheduler_config;
         Self {
             subnet_type,
             scheduler_config,
@@ -743,9 +739,7 @@ impl SchedulerTestBuilder {
         state.metadata.network_topology.nns_subnet_id = self.nns_subnet_id;
         state.metadata.batch_time = self.batch_time;
 
-        let config = SubnetConfigs::default()
-            .own_subnet_config(self.subnet_type)
-            .cycles_account_manager_config;
+        let config = SubnetConfig::new(self.subnet_type).cycles_account_manager_config;
         if let Some(ecdsa_key) = &self.ecdsa_key {
             state
                 .metadata

rs/execution_environment/src/scheduler/tests.rs

@@ -11,7 +11,7 @@ use ic00::{
 use ic_base_types::PrincipalId;
 use ic_config::{
     execution_environment::Config as HypervisorConfig,
-    subnet_config::{CyclesAccountManagerConfig, SchedulerConfig, SubnetConfig, SubnetConfigs},
+    subnet_config::{CyclesAccountManagerConfig, SchedulerConfig, SubnetConfig},
 };
 use ic_embedders::wasmtime_embedder::system_api_complexity::{cpu, overhead};
 use ic_error_types::RejectCode;
@@ -78,7 +78,7 @@ fn complexity_env(
         system_calls_per_message,
     }: SystemCallLimits,
 ) -> StateMachine {
-    let subnet_config = SubnetConfigs::default().own_subnet_config(subnet_type);
+    let subnet_config = SubnetConfig::new(subnet_type);
     let performance_counter_complexity = cpu::PERFORMANCE_COUNTER.get() as u64;
     StateMachineBuilder::new()
         .with_subnet_type(subnet_type)
@@ -4342,7 +4342,7 @@ fn scheduler_resets_accumulated_priorities() {
         // There must twice more canisters than the scheduler cores
         let num_canisters = scheduler_cores * 2;
 
-        let subnet_config = SubnetConfigs::default().own_subnet_config(SubnetType::Application);
+        let subnet_config = SubnetConfig::new(SubnetType::Application);
         let mut test = SchedulerTestBuilder::new()
             .with_scheduler_config(SchedulerConfig {
                 scheduler_cores,

rs/execution_environment/tests/canister_history.rs

@@ -1,4 +1,4 @@
-use ic_config::{execution_environment::Config as HypervisorConfig, subnet_config::SubnetConfigs};
+use ic_config::{execution_environment::Config as HypervisorConfig, subnet_config::SubnetConfig};
 use ic_crypto_sha::Sha256;
 use ic_ic00_types::CanisterInstallMode::{Install, Reinstall, Upgrade};
 use ic_ic00_types::{
@@ -64,7 +64,7 @@ fn test_setup(
     let test_canister_sha256 = hasher.finish();
 
     // set up StateMachine
-    let subnet_config = SubnetConfigs::default().own_subnet_config(subnet_type);
+    let subnet_config = SubnetConfig::new(subnet_type);
     let env = StateMachine::new_with_config(StateMachineConfig::new(
         subnet_config,
         HypervisorConfig::default(),
@@ -589,7 +589,7 @@ fn canister_history_cleared_if_canister_out_of_cycles() {
     ));
 
     // drain cycle balance of test_canister to trigger code uninstall from system
-    let subnet_config = SubnetConfigs::default().own_subnet_config(subnet_type);
+    let subnet_config = SubnetConfig::new(subnet_type);
     let compute_percent_allocated_per_second_fee = subnet_config
         .cycles_account_manager_config
         .compute_percent_allocated_per_second_fee;

rs/execution_environment/tests/dts.rs

@@ -5,7 +5,7 @@ use ic_config::{
     embedders::Config as EmbeddersConfig,
     execution_environment::Config as HypervisorConfig,
     flag_status::FlagStatus,
-    subnet_config::{SchedulerConfig, SubnetConfig, SubnetConfigs},
+    subnet_config::{SchedulerConfig, SubnetConfig},
 };
 use ic_ic00_types::{
     CanisterIdRecord, CanisterSettingsArgsBuilder, EmptyBlob, InstallCodeArgs, Method, Payload,
@@ -109,7 +109,7 @@ fn dts_subnet_config(
     message_instruction_limit: NumInstructions,
     slice_instruction_limit: NumInstructions,
 ) -> SubnetConfig {
-    let subnet_config = SubnetConfigs::default().own_subnet_config(SubnetType::Application);
+    let subnet_config = SubnetConfig::new(SubnetType::Application);
     SubnetConfig {
         scheduler_config: SchedulerConfig {
             max_instructions_per_install_code: message_instruction_limit,
@@ -151,7 +151,7 @@ fn dts_install_code_env(
     message_instruction_limit: NumInstructions,
     slice_instruction_limit: NumInstructions,
 ) -> StateMachine {
-    let subnet_config = SubnetConfigs::default().own_subnet_config(SubnetType::Application);
+    let subnet_config = SubnetConfig::new(SubnetType::Application);
     StateMachine::new_with_config(StateMachineConfig::new(
         SubnetConfig {
             scheduler_config: SchedulerConfig {

rs/execution_environment/tests/execution_test.rs

@@ -1,6 +1,6 @@
 use ic_config::{
     execution_environment::Config as HypervisorConfig,
-    subnet_config::{CyclesAccountManagerConfig, SubnetConfigs},
+    subnet_config::{CyclesAccountManagerConfig, SubnetConfig},
 };
 use ic_ic00_types::CanisterSettingsArgsBuilder;
 use ic_registry_subnet_type::SubnetType;
@@ -323,7 +323,7 @@ fn test_canister_stable_memory_upgrade_restart() {
 #[test]
 fn test_canister_out_of_cycles() {
     // Start a node with a config where all computation/storage is free.
-    let mut subnet_config = SubnetConfigs::default().own_subnet_config(SubnetType::System);
+    let mut subnet_config = SubnetConfig::new(SubnetType::System);
     let env = StateMachine::new_with_config(StateMachineConfig::new(
         subnet_config.clone(),
         HypervisorConfig::default(),
@@ -381,7 +381,7 @@ fn test_canister_out_of_cycles() {
 
 #[test]
 fn canister_has_zero_balance_when_uninstalled_due_to_low_cycles() {
-    let subnet_config = SubnetConfigs::default().own_subnet_config(SubnetType::Application);
+    let subnet_config = SubnetConfig::new(SubnetType::Application);
     let compute_percent_allocated_per_second_fee = subnet_config
         .cycles_account_manager_config
         .compute_percent_allocated_per_second_fee;
@@ -623,7 +623,7 @@ fn can_query_cycle_balance_and_top_up_canisters() {
 
 #[test]
 fn exceeding_memory_capacity_fails_when_memory_allocation_changes() {
-    let subnet_config = SubnetConfigs::default().own_subnet_config(SubnetType::Application);
+    let subnet_config = SubnetConfig::new(SubnetType::Application);
     let env = StateMachine::new_with_config(StateMachineConfig::new(
         subnet_config,
         HypervisorConfig {
@@ -686,7 +686,7 @@ fn assert_replied(result: Result<WasmResult, UserError>, expected: i64) {
 
 #[test]
 fn exceeding_memory_capacity_fails_during_message_execution() {
-    let subnet_config = SubnetConfigs::default().own_subnet_config(SubnetType::Application);
+    let subnet_config = SubnetConfig::new(SubnetType::Application);
     let env = StateMachine::new_with_config(StateMachineConfig::new(
         subnet_config,
         HypervisorConfig {
@@ -745,7 +745,7 @@ fn exceeding_memory_capacity_fails_during_message_execution() {
 
 #[test]
 fn max_canister_memory_respected_even_when_no_memory_allocation_is_set() {
-    let subnet_config = SubnetConfigs::default().own_subnet_config(SubnetType::Application);
+    let subnet_config = SubnetConfig::new(SubnetType::Application);
     let env = StateMachine::new_with_config(StateMachineConfig::new(
         subnet_config,
         HypervisorConfig {