walk back "minimum"ness of CPU platforms

Author: iximeow

common/src/api/external/mod.rs

@@ -1195,9 +1195,9 @@ pub struct Instance {
     #[serde(flatten)]
     pub auto_restart_status: InstanceAutoRestartStatus,
 
-    /// The minimum required CPU platform for this instance. If this is `null`,
-    /// the instance requires no particular CPU platform.
-    pub min_cpu_platform: Option<InstanceMinimumCpuPlatform>,
+    /// The CPU platform for this instance. If this is `null`, the instance
+    /// requires no particular CPU platform.
+    pub cpu_platform: Option<InstanceCpuPlatform>,
 }
 
 /// Status of control-plane driven automatic failure recovery for this instance.
@@ -1262,24 +1262,23 @@ pub enum InstanceAutoRestartPolicy {
     BestEffort,
 }
 
-/// A minimum required CPU platform for an instance.
+/// A required CPU platform for an instance.
 ///
-/// When an instance specifies a minimum required CPU platform:
+/// When an instance specifies a required CPU platform:
 ///
 /// - The system may expose (to the VM) new CPU features that are only present
 ///   on that platform (or on newer platforms of the same lineage that also
 ///   support those features).
 /// - The instance must run on hosts that have CPUs that support all the
-///   features of the supplied minimum platform.
+///   features of the supplied platform.
 ///
-/// That is, the instance is restricted to hosts that have the specified minimum
-/// host CPU type (or a more advanced, but still compatible, CPU), but in
-/// exchange the CPU features exposed by the minimum platform are available for
-/// the guest to use. Note that this may prevent an instance from starting (if
-/// the hosts it requires are full but there is capacity on other incompatible
-/// hosts).
+/// That is, the instance is restricted to hosts that have the CPUs which
+/// support all features of the required platform, but in exchange the CPU
+/// features exposed by the platform are available for the guest to use. Note
+/// that this may prevent an instance from starting (if the hosts that could run
+/// it are full but there is capacity on other incompatible hosts).
 ///
-/// If an instance does not specify a minimum required CPU platform, then when
+/// If an instance does not specify a required CPU platform, then when
 /// it starts, the control plane selects a host for the instance and then
 /// supplies the guest with the "minimum" CPU platform supported by that host.
 /// This maximizes the number of hosts that can run the VM if it later needs to
@@ -1294,7 +1293,7 @@ pub enum InstanceAutoRestartPolicy {
     Copy, Clone, Debug, Deserialize, Serialize, JsonSchema, Eq, PartialEq,
 )]
 #[serde(rename_all = "snake_case")]
-pub enum InstanceMinimumCpuPlatform {
+pub enum InstanceCpuPlatform {
     /// An AMD Milan-like CPU platform.
     AmdMilan,
 

end-to-end-tests/src/instance_launch.rs

@@ -79,7 +79,7 @@ async fn instance_launch() -> Result<()> {
             start: true,
             auto_restart_policy: Default::default(),
             anti_affinity_groups: Vec::new(),
-            min_cpu_platform: None,
+            cpu_platform: None,
         })
         .send()
         .await?;

nexus/db-model/src/instance.rs

@@ -5,7 +5,7 @@
 use super::InstanceIntendedState as IntendedState;
 use super::{
     ByteCount, Disk, ExternalIp, Generation, InstanceAutoRestartPolicy,
-    InstanceCpuCount, InstanceMinimumCpuPlatform, InstanceState, Vmm, VmmState,
+    InstanceCpuCount, InstanceCpuPlatform, InstanceState, Vmm, VmmState,
 };
 use crate::collection::DatastoreAttachTargetConfig;
 use crate::serde_time_delta::optional_time_delta;
@@ -68,8 +68,8 @@ pub struct Instance {
     #[diesel(column_name = boot_disk_id)]
     pub boot_disk_id: Option<Uuid>,
 
-    /// The instance's minimum required CPU platform.
-    pub min_cpu_platform: Option<InstanceMinimumCpuPlatform>,
+    /// The instance's required CPU platform.
+    pub cpu_platform: Option<InstanceCpuPlatform>,
 
     #[diesel(embed)]
     pub runtime_state: InstanceRuntimeState,
@@ -142,7 +142,7 @@ impl Instance {
             // Intentionally ignore `params.boot_disk_id` here: we can't set
             // `boot_disk_id` until the referenced disk is attached.
             boot_disk_id: None,
-            min_cpu_platform: params.min_cpu_platform.map(Into::into),
+            cpu_platform: params.cpu_platform.map(Into::into),
 
             runtime_state,
             intended_state,
@@ -498,5 +498,5 @@ pub struct InstanceUpdate {
 
     pub memory: ByteCount,
 
-    pub min_cpu_platform: Option<InstanceMinimumCpuPlatform>,
+    pub cpu_platform: Option<InstanceCpuPlatform>,
 }

nexus/db-model/src/instance_minimum_cpu_platform.rs renamed to nexus/db-model/src/instance_cpu_platform.rs

@@ -8,7 +8,7 @@ use super::impl_enum_type;
 use serde::{Deserialize, Serialize};
 
 impl_enum_type!(
-    InstanceMinimumCpuPlatformEnum:
+    InstanceCpuPlatformEnum:
 
     #[derive(
         Copy,
@@ -20,15 +20,15 @@ impl_enum_type!(
         Serialize,
         Deserialize
     )]
-    pub enum InstanceMinimumCpuPlatform;
+    pub enum InstanceCpuPlatform;
 
     AmdMilan => b"amd_milan"
     AmdTurin => b"amd_turin"
 );
 
-impl InstanceMinimumCpuPlatform {
+impl InstanceCpuPlatform {
     /// Returns a slice containing the set of sled CPU families that can
-    /// accommodate an instance with this minimum CPU platform.
+    /// accommodate an instance with this CPU platform.
     pub fn compatible_sled_cpu_families(&self) -> &'static [SledCpuFamily] {
         match self {
             // Turin-based sleds have a superset of the features made available
@@ -41,27 +41,25 @@ impl InstanceMinimumCpuPlatform {
     }
 }
 
-impl From<omicron_common::api::external::InstanceMinimumCpuPlatform>
-    for InstanceMinimumCpuPlatform
+impl From<omicron_common::api::external::InstanceCpuPlatform>
+    for InstanceCpuPlatform
 {
-    fn from(
-        value: omicron_common::api::external::InstanceMinimumCpuPlatform,
-    ) -> Self {
-        use omicron_common::api::external::InstanceMinimumCpuPlatform as ApiPlatform;
+    fn from(value: omicron_common::api::external::InstanceCpuPlatform) -> Self {
+        use omicron_common::api::external::InstanceCpuPlatform as ApiPlatform;
         match value {
             ApiPlatform::AmdMilan => Self::AmdMilan,
             ApiPlatform::AmdTurin => Self::AmdTurin,
         }
     }
 }
 
-impl From<InstanceMinimumCpuPlatform>
-    for omicron_common::api::external::InstanceMinimumCpuPlatform
+impl From<InstanceCpuPlatform>
+    for omicron_common::api::external::InstanceCpuPlatform
 {
-    fn from(value: InstanceMinimumCpuPlatform) -> Self {
+    fn from(value: InstanceCpuPlatform) -> Self {
         match value {
-            InstanceMinimumCpuPlatform::AmdMilan => Self::AmdMilan,
-            InstanceMinimumCpuPlatform::AmdTurin => Self::AmdTurin,
+            InstanceCpuPlatform::AmdMilan => Self::AmdMilan,
+            InstanceCpuPlatform::AmdTurin => Self::AmdTurin,
         }
     }
 }

nexus/db-model/src/lib.rs

@@ -43,8 +43,8 @@ mod image;
 mod instance;
 mod instance_auto_restart_policy;
 mod instance_cpu_count;
+mod instance_cpu_platform;
 mod instance_intended_state;
-mod instance_minimum_cpu_platform;
 mod instance_state;
 mod internet_gateway;
 mod inventory;
@@ -182,8 +182,8 @@ pub use image::*;
 pub use instance::*;
 pub use instance_auto_restart_policy::*;
 pub use instance_cpu_count::*;
+pub use instance_cpu_platform::*;
 pub use instance_intended_state::*;
-pub use instance_minimum_cpu_platform::*;
 pub use instance_state::*;
 pub use internet_gateway::*;
 pub use inventory::*;

nexus/db-model/src/schema_versions.rs

@@ -28,7 +28,7 @@ static KNOWN_VERSIONS: LazyLock<Vec<KnownVersion>> = LazyLock::new(|| {
         // |  leaving the first copy as an example for the next person.
         // v
         // KnownVersion::new(next_int, "unique-dirname-with-the-sql-files"),
-        KnownVersion::new(175, "add-instance-minimum-cpu-platform"),
+        KnownVersion::new(175, "add-instance-cpu-platform"),
         KnownVersion::new(174, "sled-cpu-family"),
         KnownVersion::new(173, "inv-internal-dns"),
         KnownVersion::new(172, "add-zones-with-mupdate-override"),

nexus/db-model/src/vmm_cpu_platform.rs

@@ -2,7 +2,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use crate::{InstanceMinimumCpuPlatform, SledCpuFamily};
+use crate::{InstanceCpuPlatform, SledCpuFamily};
 
 use super::impl_enum_type;
 use serde::{Deserialize, Serialize};
@@ -50,11 +50,11 @@ impl VmmCpuPlatform {
     }
 }
 
-impl From<InstanceMinimumCpuPlatform> for VmmCpuPlatform {
-    fn from(value: InstanceMinimumCpuPlatform) -> Self {
+impl From<InstanceCpuPlatform> for VmmCpuPlatform {
+    fn from(value: InstanceCpuPlatform) -> Self {
         match value {
-            InstanceMinimumCpuPlatform::AmdMilan => Self::AmdMilan,
-            InstanceMinimumCpuPlatform::AmdTurin => Self::AmdTurin,
+            InstanceCpuPlatform::AmdMilan => Self::AmdMilan,
+            InstanceCpuPlatform::AmdTurin => Self::AmdTurin,
         }
     }
 }

nexus/db-queries/src/db/datastore/instance.rs

@@ -21,8 +21,8 @@ use crate::db::model::Instance;
 use crate::db::model::InstanceAutoRestart;
 use crate::db::model::InstanceAutoRestartPolicy;
 use crate::db::model::InstanceCpuCount;
+use crate::db::model::InstanceCpuPlatform;
 use crate::db::model::InstanceIntendedState;
-use crate::db::model::InstanceMinimumCpuPlatform;
 use crate::db::model::InstanceRuntimeState;
 use crate::db::model::InstanceState;
 use crate::db::model::InstanceUpdate;
@@ -266,7 +266,7 @@ impl From<InstanceAndActiveVmm> for external::Instance {
                 .parse()
                 .expect("found invalid hostname in the database"),
             boot_disk_id: value.instance.boot_disk_id,
-            min_cpu_platform: value.instance.min_cpu_platform.map(Into::into),
+            cpu_platform: value.instance.cpu_platform.map(Into::into),
             runtime: external::InstanceRuntimeState {
                 run_state: value.effective_state(),
                 time_run_state_updated,
@@ -1098,7 +1098,7 @@ impl DataStore {
                     auto_restart_policy,
                     ncpus,
                     memory,
-                    min_cpu_platform,
+                    cpu_platform,
                 } = update.clone();
                 async move {
                     // Set the auto-restart policy.
@@ -1118,7 +1118,7 @@ impl DataStore {
                         &authz_instance,
                         ncpus,
                         memory,
-                        min_cpu_platform,
+                        cpu_platform,
                     )
                     .await?;
 
@@ -1302,7 +1302,7 @@ impl DataStore {
         authz_instance: &authz::Instance,
         ncpus: InstanceCpuCount,
         memory: ByteCount,
-        min_cpu_platform: Option<InstanceMinimumCpuPlatform>,
+        cpu_platform: Option<InstanceCpuPlatform>,
     ) -> Result<(), diesel::result::Error> {
         use nexus_db_schema::schema::instance::dsl as instance_dsl;
 
@@ -1314,36 +1314,36 @@ impl DataStore {
                     .eq_any(InstanceState::NOT_INCARNATED_STATES),
             );
 
-        let query = if min_cpu_platform.is_some() {
+        let query = if cpu_platform.is_some() {
             query.filter(
                 instance_dsl::ncpus
                     .ne(ncpus)
                     .or(instance_dsl::memory.ne(memory))
-                    .or(instance_dsl::min_cpu_platform.ne(min_cpu_platform))
-                    .or(instance_dsl::min_cpu_platform.is_null()),
+                    .or(instance_dsl::cpu_platform.ne(cpu_platform))
+                    .or(instance_dsl::cpu_platform.is_null()),
             )
         } else {
             query.filter(
                 instance_dsl::ncpus
                     .ne(ncpus)
                     .or(instance_dsl::memory.ne(memory))
-                    .or(instance_dsl::min_cpu_platform.is_not_null()),
+                    .or(instance_dsl::cpu_platform.is_not_null()),
             )
         };
 
         let r = query
             .set((
                 instance_dsl::ncpus.eq(ncpus),
                 instance_dsl::memory.eq(memory),
-                instance_dsl::min_cpu_platform.eq(min_cpu_platform),
+                instance_dsl::cpu_platform.eq(cpu_platform),
             ))
             .check_if_exists::<Instance>(authz_instance.id())
             .execute_and_check(&conn)
             .await?;
         match r.status {
             UpdateStatus::NotUpdatedButExists => {
-                if (r.found.ncpus, r.found.memory, r.found.min_cpu_platform)
-                    == (ncpus, memory, min_cpu_platform)
+                if (r.found.ncpus, r.found.memory, r.found.cpu_platform)
+                    == (ncpus, memory, cpu_platform)
                 {
                     // Not updated, because the update is no change..
                     return Ok(());
@@ -1365,7 +1365,7 @@ impl DataStore {
                     "instance_id" => %r.found.id(),
                     "new ncpus" => ?ncpus,
                     "new memory" => ?memory,
-                    "new CPU platform" => ?min_cpu_platform,
+                    "new CPU platform" => ?cpu_platform,
                 );
                 return Err(err.bail(Error::internal_error(
                     "unable to change instance CPU or memory",
@@ -2255,7 +2255,7 @@ mod tests {
                         external_ips: Vec::new(),
                         disks: Vec::new(),
                         boot_disk: None,
-                        min_cpu_platform: None,
+                        cpu_platform: None,
                         ssh_public_keys: None,
                         start: false,
                         auto_restart_policy: Default::default(),

nexus/db-queries/src/db/datastore/migration.rs

@@ -235,7 +235,7 @@ mod tests {
                         external_ips: Vec::new(),
                         disks: Vec::new(),
                         boot_disk: None,
-                        min_cpu_platform: None,
+                        cpu_platform: None,
                         ssh_public_keys: None,
                         start: false,
                         auto_restart_policy: Default::default(),

nexus/db-queries/src/db/datastore/sled.rs

@@ -1087,7 +1087,7 @@ pub(in crate::db::datastore) mod test {
     use nexus_db_model::PhysicalDiskPolicy;
     use nexus_db_model::PhysicalDiskState;
     use nexus_db_model::{Generation, SledCpuFamily};
-    use nexus_db_model::{InstanceMinimumCpuPlatform, PhysicalDisk};
+    use nexus_db_model::{InstanceCpuPlatform, PhysicalDisk};
     use nexus_types::identity::Asset;
     use nexus_types::identity::Resource;
     use omicron_common::api::external;
@@ -1475,7 +1475,7 @@ pub(in crate::db::datastore) mod test {
         groups: Vec<GroupName>,
         force_onto_sled: Option<SledUuid>,
         resources: db::model::Resources,
-        min_cpu_platform: Option<db::model::InstanceMinimumCpuPlatform>,
+        cpu_platform: Option<db::model::InstanceCpuPlatform>,
     }
 
     struct FindTargetsOutput {
@@ -1492,7 +1492,7 @@ pub(in crate::db::datastore) mod test {
                 groups: vec![],
                 force_onto_sled: None,
                 resources: small_resource_request(),
-                min_cpu_platform: None,
+                cpu_platform: None,
             }
         }
 
@@ -1505,7 +1505,7 @@ pub(in crate::db::datastore) mod test {
             assert!(self.force_onto_sled.is_none());
 
             let families =
-                self.min_cpu_platform.map(|p| p.compatible_sled_cpu_families());
+                self.cpu_platform.map(|p| p.compatible_sled_cpu_families());
 
             sled_find_targets_query(self.id, &self.resources, families)
                 .get_results_async::<(
@@ -2673,14 +2673,13 @@ pub(in crate::db::datastore) mod test {
         }
 
         let mut test_instance = Instance::new();
-        for platform in [None, Some(InstanceMinimumCpuPlatform::AmdMilan)] {
-            test_instance.min_cpu_platform = platform;
+        for platform in [None, Some(InstanceCpuPlatform::AmdMilan)] {
+            test_instance.cpu_platform = platform;
             let possible_sleds = test_instance.find_targets(&datastore).await;
             assert_eq!(possible_sleds.len(), 4);
         }
 
-        test_instance.min_cpu_platform =
-            Some(InstanceMinimumCpuPlatform::AmdTurin);
+        test_instance.cpu_platform = Some(InstanceCpuPlatform::AmdTurin);
         let possible_sleds = test_instance.find_targets(&datastore).await;
         assert_eq!(possible_sleds.len(), 2);