Add CPU and GPU performance level control (#3066)

* Set CPU performance level

* CPU and GPU perf levels

* Class migration and enable the required functions for performance control

* Remove old performance settings code

* Add log

* Fix extension activation

* Remove dedicated class for performance level settings

* Remove comments

* Move power saving setting location and remove unused imports

* Alphabetically order requested extensions.

* Add performance level setting

* Update text and default config

* Add realtime power mode setting and add boost level

* OpenXR Client performance level

* Formatting

* Remove commented code

* Performance level refactoring

* Remove powersavings performance level for lobby

* More accurate performance level help strings and hide Boost level.

* Combine duplicate strings.

* Update help string for performance level config

Author: Iemand005

alvr/client_openxr/src/lib.rs

@@ -15,7 +15,7 @@ use alvr_common::{
     parking_lot::RwLock,
 };
 use alvr_graphics::GraphicsContext;
-use alvr_session::{BodyTrackingBDConfig, BodyTrackingSourcesConfig};
+use alvr_session::{BodyTrackingBDConfig, BodyTrackingSourcesConfig, PerformanceLevel};
 use alvr_system_info::Platform;
 use extra_extensions::{
     BD_BODY_TRACKING_EXTENSION_NAME, BD_MOTION_TRACKING_EXTENSION_NAME,
@@ -95,6 +95,32 @@ fn to_xr_time(timestamp: Duration) -> xr::Time {
     xr::Time::from_nanos(timestamp.as_nanos() as _)
 }
 
+fn to_perf_settings_level(level: PerformanceLevel) -> xr::PerfSettingsLevelEXT {
+    match level {
+        PerformanceLevel::PowerSavings => xr::PerfSettingsLevelEXT::POWER_SAVINGS,
+        PerformanceLevel::SustainedLow => xr::PerfSettingsLevelEXT::SUSTAINED_LOW,
+        PerformanceLevel::SustainedHigh => xr::PerfSettingsLevelEXT::SUSTAINED_HIGH,
+        PerformanceLevel::Boost => xr::PerfSettingsLevelEXT::BOOST,
+    }
+}
+
+fn set_performance_level(
+    xr_instance: &xr::Instance,
+    xr_session: &xr::Session<xr::OpenGlEs>,
+    domain: xr::PerfSettingsDomainEXT,
+    level: PerformanceLevel,
+) {
+    if let Some(performance_settings) = xr_instance.exts().ext_performance_settings {
+        unsafe {
+            (performance_settings.perf_settings_set_performance_level)(
+                xr_session.as_raw(),
+                domain,
+                to_perf_settings_level(level),
+            );
+        }
+    }
+}
+
 fn default_view() -> xr::View {
     xr::View {
         pose: xr::Posef {
@@ -182,6 +208,7 @@ pub fn entry_point() {
     exts.ext_eye_gaze_interaction = available_extensions.ext_eye_gaze_interaction;
     exts.ext_hand_tracking = available_extensions.ext_hand_tracking;
     exts.ext_local_floor = available_extensions.ext_local_floor;
+    exts.ext_performance_settings = available_extensions.ext_performance_settings;
     exts.ext_user_presence = available_extensions.ext_user_presence;
     exts.fb_body_tracking = available_extensions.fb_body_tracking;
     exts.fb_color_space = available_extensions.fb_color_space;
@@ -514,6 +541,24 @@ pub fn entry_point() {
                             passthrough_layer = None;
                         }
 
+                        if let Some(cpu_performance_level) = &config.cpu_performance_level {
+                            set_performance_level(
+                                &xr_instance,
+                                &xr_session,
+                                xr::PerfSettingsDomainEXT::CPU,
+                                cpu_performance_level.clone(),
+                            );
+                        }
+
+                        if let Some(gpu_performance_level) = &config.gpu_performance_level {
+                            set_performance_level(
+                                &xr_instance,
+                                &xr_session,
+                                xr::PerfSettingsDomainEXT::GPU,
+                                gpu_performance_level.clone(),
+                            );
+                        }
+
                         if let Some(stream) = &mut stream_context {
                             stream.update_real_time_config(&config);
                         }

alvr/packets/src/lib.rs

@@ -5,7 +5,8 @@ use alvr_common::{
     semver::Version,
 };
 use alvr_session::{
-    ClientsidePostProcessingConfig, CodecType, PassthroughMode, SessionConfig, Settings,
+    ClientsidePostProcessingConfig, CodecType, PassthroughMode, PerformanceLevel, SessionConfig,
+    Settings,
 };
 use serde::{Deserialize, Serialize};
 use serde_json as json;
@@ -327,6 +328,8 @@ pub enum FirewallRulesAction {
 pub struct RealTimeConfig {
     pub passthrough: Option<PassthroughMode>,
     pub clientside_post_processing: Option<ClientsidePostProcessingConfig>,
+    pub cpu_performance_level: Option<PerformanceLevel>,
+    pub gpu_performance_level: Option<PerformanceLevel>,
     pub ext_str: String,
 }
 
@@ -339,6 +342,8 @@ impl RealTimeConfig {
                 .clientside_post_processing
                 .clone()
                 .into_option(),
+            cpu_performance_level: settings.headset.performance_level.clone().cpu.into_option(),
+            gpu_performance_level: settings.headset.performance_level.clone().gpu.into_option(),
             ext_str: String::new(), // No extensions for now
         }
     }

alvr/session/src/settings.rs

@@ -878,6 +878,34 @@ pub enum HeadsetEmulationMode {
     },
 }
 
+#[derive(SettingsSchema, Serialize, Deserialize, PartialEq, Clone)]
+pub enum PerformanceLevel {
+    #[schema(strings(display_name = "Power Saving"))]
+    PowerSavings,
+    #[schema(strings(display_name = "Sustained Low"))]
+    SustainedLow,
+    #[schema(strings(display_name = "Sustained High"))]
+    SustainedHigh,
+    #[schema(flag = "hidden")]
+    Boost,
+}
+
+#[derive(SettingsSchema, Serialize, Deserialize, PartialEq, Clone)]
+pub struct PerformanceLevelConfig {
+    #[schema(flag = "real-time")]
+    #[schema(strings(
+        display_name = "CPU",
+        help = "When disabling this, the client needs to be restarted for the change to be applied."
+    ))]
+    pub cpu: Switch<PerformanceLevel>,
+    #[schema(flag = "real-time")]
+    #[schema(strings(
+        display_name = "GPU",
+        help = "When disabling this, the client needs to be restarted for the change to be applied."
+    ))]
+    pub gpu: Switch<PerformanceLevel>,
+}
+
 #[derive(SettingsSchema, Serialize, Deserialize, Clone, PartialEq)]
 pub enum FaceTrackingSourcesConfig {
     PreferEyeTrackingOnly,
@@ -1274,6 +1302,14 @@ Tilted: the world gets tilted when long pressing the oculus button. This is usef
     #[schema(flag = "steamvr-restart")]
     pub emulation_mode: HeadsetEmulationMode,
 
+    #[schema(strings(
+        help = r#"Power Savings might increase latency or reduce framerate consistency but decreases temperatures and improves battery life.
+Sustained Low provides consistent framerates but might increase latency if necessary.
+Sustained High provides consistent framerates but increases temperature.
+This is mainly for Quest headsets, mileage may vary on other devices."#
+    ))]
+    pub performance_level: PerformanceLevelConfig,
+
     #[schema(flag = "steamvr-restart")]
     #[schema(strings(display_name = "Extra OpenVR properties"))]
     pub extra_openvr_props: Vec<OpenvrProperty>,
@@ -1923,6 +1959,20 @@ pub fn session_settings_default() -> SettingsDefault {
                 },
                 variant: HeadsetEmulationModeDefaultVariant::Quest2,
             },
+            performance_level: PerformanceLevelConfigDefault {
+                cpu: SwitchDefault {
+                    enabled: false,
+                    content: PerformanceLevelDefault {
+                        variant: PerformanceLevelDefaultVariant::PowerSavings,
+                    },
+                },
+                gpu: SwitchDefault {
+                    enabled: false,
+                    content: PerformanceLevelDefault {
+                        variant: PerformanceLevelDefaultVariant::PowerSavings,
+                    },
+                },
+            },
             extra_openvr_props: default_custom_openvr_props.clone(),
             tracking_ref_only: false,
             enable_vive_tracker_proxy: false,