resourced/src/arch/x86_64.rs - third_party/platform2 - Git at Google

 // Copyright 2024 The ChromiumOS Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 mod auto_epp;
 mod auto_epp_config;
 mod borealis;
 mod cgroup_x86_64;
 mod cpu_scaling;
 mod globals;
 mod gpu_freq_scaling;

 use std::path::Path;
 use std::path::PathBuf;

 use anyhow::Context;
 use anyhow::Result;
 pub use borealis::apply_borealis_tuning;
 use log::error;

 use self::cgroup_x86_64::media_dynamic_cgroup;
 use self::cgroup_x86_64::MediaDynamicCgroupAction;
 use self::globals::BSM_SIGNAL;
 use self::globals::DYNAMIC_EPP;
 use self::globals::MEDIA_CGROUP_SIGNAL;
 use self::globals::RTC_FS_SIGNAL;
 use self::gpu_freq_scaling::intel_device;
 use crate::common::BatterySaverMode;
 use crate::common::FullscreenVideo;
 use crate::common::RTCAudioActive;
 use crate::config::EnergyPerformancePreference;
 use crate::config::PowerPreferences;
 use crate::config::PowerSourceType;
 use crate::cpu_utils::write_to_cpu_policy_patterns;

 fn has_epp(root_path: &Path) -> Result<bool> {
     const CPU0_EPP_PATH: &str =
         "sys/devices/system/cpu/cpufreq/policy0/energy_performance_preference";
     let pattern = root_path
         .join(CPU0_EPP_PATH)
         .to_str()
         .context("Cannot convert cpu0 epp path to string")?
         .to_owned();
     Ok(Path::new(&pattern).exists())
 }

 fn set_epp(root_path: &Path, epp: EnergyPerformancePreference) -> Result<()> {
     const EPP_PATTERN: &str =
         "sys/devices/system/cpu/cpufreq/policy*/energy_performance_preference";
     let epp_str = match epp {
         EnergyPerformancePreference::Default => "default",
         EnergyPerformancePreference::Performance => "performance",
         EnergyPerformancePreference::BalancePerformance => "balance_performance",
         EnergyPerformancePreference::BalancePower => "balance_power",
         EnergyPerformancePreference::Power => "power",
     };
     if has_epp(root_path)? {
         let pattern = root_path
             .join(EPP_PATTERN)
             .to_str()
             .context("Cannot convert epp path to string")?
             .to_owned();
         return write_to_cpu_policy_patterns(&pattern, epp_str);
     }
     Ok(())
 }

 fn get_first_scaling_governor(root_path: &Path) -> Result<String> {
     const FIRST_GOVERNOR_PATTERN: &str = "sys/devices/system/cpu/cpufreq/policy0/scaling_governor";
     let governor = std::fs::read_to_string(root_path.join(FIRST_GOVERNOR_PATTERN))?;
     Ok(governor)
 }

 // Intel only tuning to limit GPU frequency (i.e. power draw) during video conference
 fn set_gt_boost_freq_mhz(mode: RTCAudioActive) -> Result<()> {
     if intel_device::is_intel_device(PathBuf::from("/")) {
         set_gt_boost_freq_mhz_impl(Path::new("/"), mode)
     } else {
         /* AMD */
         Ok(())
     }
 }

 // Extract the impl function for unittest.
 fn set_gt_boost_freq_mhz_impl(root: &Path, mode: RTCAudioActive) -> Result<()> {
     let mut gpu_config = intel_device::IntelGpuDeviceConfig::new(root.to_owned(), 100)?;
     gpu_config.set_rtc_audio_active(mode == RTCAudioActive::Active)
 }

 fn set_default_epp(root_path: &Path) -> Result<()> {
     // When scaling_governor is performance, energy_performance_preference can only be
     // performance.
     //
     // Reference:
     //   https://source.chromium.org/chromiumos/chromiumos/codesearch/+/main:src/third_party/kernel/v6.6/drivers/cpufreq/intel_pstate.c;drc=1a868273760040b746518aca7fea4f8c07366884;l=795
     match get_first_scaling_governor(root_path) {
         Ok(governor) if governor.trim() == "performance" => Ok(()),
         _ => {
             // Default EPP
             set_epp(root_path, EnergyPerformancePreference::BalancePerformance)
         }
     }
 }

 pub fn apply_platform_power_settings(
     root_path: &Path,
     power_source: PowerSourceType,
     rtc: RTCAudioActive,
     fullscreen: FullscreenVideo,
     bsm: BatterySaverMode,
     need_default_epp: bool,
 ) -> Result<()> {
     let fullscreen_video_efficiency_mode = power_source == PowerSourceType::DC
         && (rtc == RTCAudioActive::Active || fullscreen == FullscreenVideo::Active);
     if DYNAMIC_EPP.read_value() {
         RTC_FS_SIGNAL.set_value(fullscreen_video_efficiency_mode);
         MEDIA_CGROUP_SIGNAL.set_value(fullscreen == FullscreenVideo::Active);
         BSM_SIGNAL.set_value(bsm == BatterySaverMode::Active);
     } else if bsm == BatterySaverMode::Inactive {
         if fullscreen_video_efficiency_mode {
             if let Err(err) = set_epp(root_path, EnergyPerformancePreference::BalancePower) {
                 error!("Failed to set energy performance preference: {:#}", err);
             }
         } else if need_default_epp {
             set_default_epp(root_path)?;
         }
     } else if need_default_epp {
         set_default_epp(root_path)?;
     }

     match fullscreen {
         FullscreenVideo::Active => media_dynamic_cgroup(MediaDynamicCgroupAction::Start)?,
         FullscreenVideo::Inactive => media_dynamic_cgroup(MediaDynamicCgroupAction::Stop)?,
     }

     if let Err(err) = set_gt_boost_freq_mhz(rtc) {
         error!("Set boost freq not supported: {:#}", err)
     }

     Ok(())
 }

 pub fn apply_platform_power_preferences(
     root_path: &Path,
     preferences: &PowerPreferences,
 ) -> Result<()> {
     if !DYNAMIC_EPP.read_value() {
         if let Some(epp) = preferences.epp {
             set_epp(root_path, epp)?;
         }
     }
     Ok(())
 }

 pub fn init() {
     cgroup_x86_64::register_feature();

     auto_epp::init();
 }

 #[cfg(test)]
 mod tests {
     use std::fs;

     use tempfile::tempdir;

     use super::*;
     use crate::common;
     use crate::config::Governor;
     use crate::config::PowerPreferencesType;
     use crate::power::DirectoryPowerPreferencesManager;
     use crate::power::PowerPreferencesManager;
     use crate::test_utils::*;

     #[test]
     #[cfg(target_arch = "x86_64")]
     fn test_set_gt_boost_freq_mhz() {
         let tmp_root = tempdir().unwrap();
         let root = tmp_root.path();

         setup_mock_intel_gpu_dev_dirs(root);
         setup_mock_intel_gpu_files(root);
         write_mock_cpuinfo(
             root,
             "filter_out",
             "Intel(R) Core(TM) i3-10110U CPU @ 2.10GHz",
         );
         set_gt_boost_freq_mhz_impl(root, RTCAudioActive::Active)
             .expect_err("Should return error on non-intel CPUs");

         write_mock_cpuinfo(
             root,
             "GenuineIntel",
             "Intel(R) Core(TM) i3-10110U CPU @ 2.10GHz",
         );
         set_intel_gpu_min(root, 300);
         set_intel_gpu_max(root, 1100);

         set_intel_gpu_boost(root, 0);
         set_gt_boost_freq_mhz_impl(root, RTCAudioActive::Active)
             .expect_err("Should return error when gpu_boost is 0");

         set_intel_gpu_boost(root, 500);
         set_gt_boost_freq_mhz_impl(root, RTCAudioActive::Active).unwrap();

         assert_eq!(get_intel_gpu_boost(root), 300);

         set_gt_boost_freq_mhz_impl(root, RTCAudioActive::Inactive).unwrap();

         assert_eq!(get_intel_gpu_boost(root), 1100);
     }

     fn read_epp(root: &Path) -> Result<String> {
         let epp_path = root
             .join("sys/devices/system/cpu/cpufreq/policy0/")
             .join("energy_performance_preference");

         let epp = std::fs::read_to_string(epp_path)?;

         Ok(epp)
     }

     fn write_epp(root: &Path, value: &str, affected_cpus: &str) -> Result<()> {
         let policy_path = root.join("sys/devices/system/cpu/cpufreq/policy0");
         fs::create_dir_all(&policy_path)?;

         std::fs::write(policy_path.join("energy_performance_preference"), value)?;
         std::fs::write(policy_path.join("affected_cpus"), affected_cpus)?;

         Ok(())
     }

     #[test]
     /// Tests the various EPP permutations
     fn test_power_update_power_preferences_epp() {
         let root = tempdir().unwrap();

         test_write_cpuset_root_cpus(root.path(), "0-3");

         let tests = [
             (
                 FakePowerSourceProvider {
                     power_source: PowerSourceType::DC,
                 },
                 RTCAudioActive::Active,
                 FullscreenVideo::Inactive,
                 "balance_power",
             ),
             (
                 FakePowerSourceProvider {
                     power_source: PowerSourceType::DC,
                 },
                 RTCAudioActive::Inactive,
                 FullscreenVideo::Active,
                 "balance_power",
             ),
             (
                 FakePowerSourceProvider {
                     power_source: PowerSourceType::DC,
                 },
                 RTCAudioActive::Active,
                 FullscreenVideo::Active,
                 "balance_power",
             ),
             (
                 FakePowerSourceProvider {
                     power_source: PowerSourceType::DC,
                 },
                 RTCAudioActive::Inactive,
                 FullscreenVideo::Inactive,
                 "balance_performance",
             ),
             (
                 FakePowerSourceProvider {
                     power_source: PowerSourceType::AC,
                 },
                 RTCAudioActive::Inactive,
                 FullscreenVideo::Active,
                 "balance_performance",
             ),
             (
                 FakePowerSourceProvider {
                     power_source: PowerSourceType::AC,
                 },
                 RTCAudioActive::Active,
                 FullscreenVideo::Active,
                 "balance_performance",
             ),
             (
                 FakePowerSourceProvider {
                     power_source: PowerSourceType::AC,
                 },
                 RTCAudioActive::Active,
                 FullscreenVideo::Inactive,
                 "balance_performance",
             ),
         ];

         for test in tests {
             write_epp(root.path(), "balance_performance", AFFECTED_CPU0).unwrap();
             let mut fake_config = FakeConfig::new();
             fake_config.write_power_preference(
                 PowerSourceType::AC,
                 PowerPreferencesType::Default,
                 &PowerPreferences {
                     governor: Some(Governor::Schedutil),
                     epp: None,
                     cpu_offline: None,
                     cpufreq_disable_boost: false,
                 },
             );
             let config_provider = fake_config.provider();

             let manager =
                 DirectoryPowerPreferencesManager::new(root.path(), config_provider, test.0);

             manager
                 .update_power_preferences(
                     test.1,
                     test.2,
                     common::GameMode::Off,
                     common::VmBootMode::Inactive,
                     common::BatterySaverMode::Inactive,
                 )
                 .unwrap();

             let epp = read_epp(root.path()).unwrap();

             assert_eq!(epp, test.3);
         }
     }

     #[test]
     fn test_power_update_power_preferences_battery_saver_active() {
         let temp_dir = tempdir().unwrap();
         let root = temp_dir.path();

         test_write_cpuset_root_cpus(root, "0-3");

         let power_source_provider = FakePowerSourceProvider {
             power_source: PowerSourceType::AC,
         };

         let mut fake_config = FakeConfig::new();
         fake_config.write_power_preference(
             PowerSourceType::AC,
             PowerPreferencesType::ArcvmGaming,
             &PowerPreferences {
                 governor: Some(Governor::Schedutil),
                 epp: None,
                 cpu_offline: None,
                 cpufreq_disable_boost: false,
             },
         );
         fake_config.write_power_preference(
             PowerSourceType::AC,
             PowerPreferencesType::BatterySaver,
             &PowerPreferences {
                 governor: Some(Governor::Conservative),
                 epp: None,
                 cpu_offline: None,
                 cpufreq_disable_boost: false,
             },
         );
         fake_config.write_power_preference(
             PowerSourceType::AC,
             PowerPreferencesType::Default,
             &PowerPreferences {
                 governor: Some(Governor::Schedutil),
                 epp: None,
                 cpu_offline: None,
                 cpufreq_disable_boost: false,
             },
         );
         let config_provider = fake_config.provider();

         let manager =
             DirectoryPowerPreferencesManager::new(root, config_provider, power_source_provider);

         let tests = [
             (
                 BatterySaverMode::Active,
                 "balance_performance",
                 Governor::Conservative,
                 AFFECTED_CPU0, // policy0 affected_cpus
                 AFFECTED_CPU1, // policy1 affected_cpus
             ),
             (
                 BatterySaverMode::Inactive,
                 "balance_performance",
                 Governor::Schedutil,
                 AFFECTED_CPU0, // policy0 affected_cpus
                 AFFECTED_CPU1, // policy1 affected_cpus
             ),
             (
                 BatterySaverMode::Active,
                 "balance_performance",
                 Governor::Conservative,
                 AFFECTED_CPU_NONE, // policy0 affected_cpus, which has no affected cpus
                 AFFECTED_CPU1,     // policy1 affected_cpus
             ),
         ];

         // Test device without EPP path
         for test in tests {
             let orig_governor = Governor::Performance;
             let policy0 = PolicyConfigs {
                 policy_path: TEST_CPUFREQ_POLICIES[0],
                 governor: &orig_governor,
                 affected_cpus: test.3,
             };
             let policy1 = PolicyConfigs {
                 policy_path: TEST_CPUFREQ_POLICIES[1],
                 governor: &orig_governor,
                 affected_cpus: test.4,
             };
             let policies = vec![policy0, policy1];
             write_per_policy_scaling_governor(root, policies);
             manager
                 .update_power_preferences(
                     common::RTCAudioActive::Inactive,
                     common::FullscreenVideo::Inactive,
                     common::GameMode::Arc,
                     common::VmBootMode::Inactive,
                     test.0,
                 )
                 .unwrap();

             let mut expected_governors = vec![test.2, test.2];
             if test.3.is_empty() {
                 expected_governors[0] = orig_governor;
             }
             check_per_policy_scaling_governor(root, expected_governors);
         }

         // Test device with EPP path
         let orig_epp = "balance_performance";
         for test in tests {
             write_epp(root, orig_epp, test.3).unwrap();
             manager
                 .update_power_preferences(
                     common::RTCAudioActive::Inactive,
                     common::FullscreenVideo::Inactive,
                     common::GameMode::Arc,
                     common::VmBootMode::Inactive,
                     test.0,
                 )
                 .unwrap();

             let epp = read_epp(root).unwrap();
             let mut expected_epp = test.1;
             if test.3.is_empty() {
                 expected_epp = orig_epp;
             }
             assert_eq!(epp, expected_epp);
         }
     }
 }
	// Copyright 2024 The ChromiumOS Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	mod auto_epp;
	mod auto_epp_config;
	mod borealis;
	mod cgroup_x86_64;
	mod cpu_scaling;
	mod globals;
	mod gpu_freq_scaling;

	use std::path::Path;
	use std::path::PathBuf;

	use anyhow::Context;
	use anyhow::Result;
	pub use borealis::apply_borealis_tuning;
	use log::error;

	use self::cgroup_x86_64::media_dynamic_cgroup;
	use self::cgroup_x86_64::MediaDynamicCgroupAction;
	use self::globals::BSM_SIGNAL;
	use self::globals::DYNAMIC_EPP;
	use self::globals::MEDIA_CGROUP_SIGNAL;
	use self::globals::RTC_FS_SIGNAL;
	use self::gpu_freq_scaling::intel_device;
	use crate::common::BatterySaverMode;
	use crate::common::FullscreenVideo;
	use crate::common::RTCAudioActive;
	use crate::config::EnergyPerformancePreference;
	use crate::config::PowerPreferences;
	use crate::config::PowerSourceType;
	use crate::cpu_utils::write_to_cpu_policy_patterns;

	fn has_epp(root_path: &Path) -> Result<bool> {
	const CPU0_EPP_PATH: &str =
	"sys/devices/system/cpu/cpufreq/policy0/energy_performance_preference";
	let pattern = root_path
	.join(CPU0_EPP_PATH)
	.to_str()
	.context("Cannot convert cpu0 epp path to string")?
	.to_owned();
	Ok(Path::new(&pattern).exists())
	}

	fn set_epp(root_path: &Path, epp: EnergyPerformancePreference) -> Result<()> {
	const EPP_PATTERN: &str =
	"sys/devices/system/cpu/cpufreq/policy*/energy_performance_preference";
	let epp_str = match epp {
	EnergyPerformancePreference::Default => "default",
	EnergyPerformancePreference::Performance => "performance",
	EnergyPerformancePreference::BalancePerformance => "balance_performance",
	EnergyPerformancePreference::BalancePower => "balance_power",
	EnergyPerformancePreference::Power => "power",
	};
	if has_epp(root_path)? {
	let pattern = root_path
	.join(EPP_PATTERN)
	.to_str()
	.context("Cannot convert epp path to string")?
	.to_owned();
	return write_to_cpu_policy_patterns(&pattern, epp_str);
	}
	Ok(())
	}

	fn get_first_scaling_governor(root_path: &Path) -> Result<String> {
	const FIRST_GOVERNOR_PATTERN: &str = "sys/devices/system/cpu/cpufreq/policy0/scaling_governor";
	let governor = std::fs::read_to_string(root_path.join(FIRST_GOVERNOR_PATTERN))?;
	Ok(governor)
	}

	// Intel only tuning to limit GPU frequency (i.e. power draw) during video conference
	fn set_gt_boost_freq_mhz(mode: RTCAudioActive) -> Result<()> {
	if intel_device::is_intel_device(PathBuf::from("/")) {
	set_gt_boost_freq_mhz_impl(Path::new("/"), mode)
	} else {
	/* AMD */
	Ok(())
	}
	}

	// Extract the impl function for unittest.
	fn set_gt_boost_freq_mhz_impl(root: &Path, mode: RTCAudioActive) -> Result<()> {
	let mut gpu_config = intel_device::IntelGpuDeviceConfig::new(root.to_owned(), 100)?;
	gpu_config.set_rtc_audio_active(mode == RTCAudioActive::Active)
	}

	fn set_default_epp(root_path: &Path) -> Result<()> {
	// When scaling_governor is performance, energy_performance_preference can only be
	// performance.
	//
	// Reference:
	// https://source.chromium.org/chromiumos/chromiumos/codesearch/+/main:src/third_party/kernel/v6.6/drivers/cpufreq/intel_pstate.c;drc=1a868273760040b746518aca7fea4f8c07366884;l=795
	match get_first_scaling_governor(root_path) {
	Ok(governor) if governor.trim() == "performance" => Ok(()),
	_ => {
	// Default EPP
	set_epp(root_path, EnergyPerformancePreference::BalancePerformance)
	}
	}
	}

	pub fn apply_platform_power_settings(
	root_path: &Path,
	power_source: PowerSourceType,
	rtc: RTCAudioActive,
	fullscreen: FullscreenVideo,
	bsm: BatterySaverMode,
	need_default_epp: bool,
	) -> Result<()> {
	let fullscreen_video_efficiency_mode = power_source == PowerSourceType::DC
	&& (rtc == RTCAudioActive::Active \|\| fullscreen == FullscreenVideo::Active);
	if DYNAMIC_EPP.read_value() {
	RTC_FS_SIGNAL.set_value(fullscreen_video_efficiency_mode);
	MEDIA_CGROUP_SIGNAL.set_value(fullscreen == FullscreenVideo::Active);
	BSM_SIGNAL.set_value(bsm == BatterySaverMode::Active);
	} else if bsm == BatterySaverMode::Inactive {
	if fullscreen_video_efficiency_mode {
	if let Err(err) = set_epp(root_path, EnergyPerformancePreference::BalancePower) {
	error!("Failed to set energy performance preference: {:#}", err);
	}
	} else if need_default_epp {
	set_default_epp(root_path)?;
	}
	} else if need_default_epp {
	set_default_epp(root_path)?;
	}

	match fullscreen {
	FullscreenVideo::Active => media_dynamic_cgroup(MediaDynamicCgroupAction::Start)?,
	FullscreenVideo::Inactive => media_dynamic_cgroup(MediaDynamicCgroupAction::Stop)?,
	}

	if let Err(err) = set_gt_boost_freq_mhz(rtc) {
	error!("Set boost freq not supported: {:#}", err)
	}

	Ok(())
	}

	pub fn apply_platform_power_preferences(
	root_path: &Path,
	preferences: &PowerPreferences,
	) -> Result<()> {
	if !DYNAMIC_EPP.read_value() {
	if let Some(epp) = preferences.epp {
	set_epp(root_path, epp)?;
	}
	}
	Ok(())
	}

	pub fn init() {
	cgroup_x86_64::register_feature();

	auto_epp::init();
	}

	#[cfg(test)]
	mod tests {
	use std::fs;

	use tempfile::tempdir;

	use super::*;
	use crate::common;
	use crate::config::Governor;
	use crate::config::PowerPreferencesType;
	use crate::power::DirectoryPowerPreferencesManager;
	use crate::power::PowerPreferencesManager;
	use crate::test_utils::*;

	#[test]
	#[cfg(target_arch = "x86_64")]
	fn test_set_gt_boost_freq_mhz() {
	let tmp_root = tempdir().unwrap();
	let root = tmp_root.path();

	setup_mock_intel_gpu_dev_dirs(root);
	setup_mock_intel_gpu_files(root);
	write_mock_cpuinfo(
	root,
	"filter_out",
	"Intel(R) Core(TM) i3-10110U CPU @ 2.10GHz",
	);
	set_gt_boost_freq_mhz_impl(root, RTCAudioActive::Active)
	.expect_err("Should return error on non-intel CPUs");

	write_mock_cpuinfo(
	root,
	"GenuineIntel",
	"Intel(R) Core(TM) i3-10110U CPU @ 2.10GHz",
	);
	set_intel_gpu_min(root, 300);
	set_intel_gpu_max(root, 1100);

	set_intel_gpu_boost(root, 0);
	set_gt_boost_freq_mhz_impl(root, RTCAudioActive::Active)
	.expect_err("Should return error when gpu_boost is 0");

	set_intel_gpu_boost(root, 500);
	set_gt_boost_freq_mhz_impl(root, RTCAudioActive::Active).unwrap();

	assert_eq!(get_intel_gpu_boost(root), 300);

	set_gt_boost_freq_mhz_impl(root, RTCAudioActive::Inactive).unwrap();

	assert_eq!(get_intel_gpu_boost(root), 1100);
	}

	fn read_epp(root: &Path) -> Result<String> {
	let epp_path = root
	.join("sys/devices/system/cpu/cpufreq/policy0/")
	.join("energy_performance_preference");

	let epp = std::fs::read_to_string(epp_path)?;

	Ok(epp)
	}

	fn write_epp(root: &Path, value: &str, affected_cpus: &str) -> Result<()> {
	let policy_path = root.join("sys/devices/system/cpu/cpufreq/policy0");
	fs::create_dir_all(&policy_path)?;

	std::fs::write(policy_path.join("energy_performance_preference"), value)?;
	std::fs::write(policy_path.join("affected_cpus"), affected_cpus)?;

	Ok(())
	}

	#[test]
	/// Tests the various EPP permutations
	fn test_power_update_power_preferences_epp() {
	let root = tempdir().unwrap();

	test_write_cpuset_root_cpus(root.path(), "0-3");

	let tests = [
	(
	FakePowerSourceProvider {
	power_source: PowerSourceType::DC,
	},
	RTCAudioActive::Active,
	FullscreenVideo::Inactive,
	"balance_power",
	),
	(
	FakePowerSourceProvider {
	power_source: PowerSourceType::DC,
	},
	RTCAudioActive::Inactive,
	FullscreenVideo::Active,
	"balance_power",
	),
	(
	FakePowerSourceProvider {
	power_source: PowerSourceType::DC,
	},
	RTCAudioActive::Active,
	FullscreenVideo::Active,
	"balance_power",
	),
	(
	FakePowerSourceProvider {
	power_source: PowerSourceType::DC,
	},
	RTCAudioActive::Inactive,
	FullscreenVideo::Inactive,
	"balance_performance",
	),
	(
	FakePowerSourceProvider {
	power_source: PowerSourceType::AC,
	},
	RTCAudioActive::Inactive,
	FullscreenVideo::Active,
	"balance_performance",
	),
	(
	FakePowerSourceProvider {
	power_source: PowerSourceType::AC,
	},
	RTCAudioActive::Active,
	FullscreenVideo::Active,
	"balance_performance",
	),
	(
	FakePowerSourceProvider {
	power_source: PowerSourceType::AC,
	},
	RTCAudioActive::Active,
	FullscreenVideo::Inactive,
	"balance_performance",
	),
	];

	for test in tests {
	write_epp(root.path(), "balance_performance", AFFECTED_CPU0).unwrap();
	let mut fake_config = FakeConfig::new();
	fake_config.write_power_preference(
	PowerSourceType::AC,
	PowerPreferencesType::Default,
	&PowerPreferences {
	governor: Some(Governor::Schedutil),
	epp: None,
	cpu_offline: None,
	cpufreq_disable_boost: false,
	},
	);
	let config_provider = fake_config.provider();

	let manager =
	DirectoryPowerPreferencesManager::new(root.path(), config_provider, test.0);

	manager
	.update_power_preferences(
	test.1,
	test.2,
	common::GameMode::Off,
	common::VmBootMode::Inactive,
	common::BatterySaverMode::Inactive,
	)
	.unwrap();

	let epp = read_epp(root.path()).unwrap();

	assert_eq!(epp, test.3);
	}
	}

	#[test]
	fn test_power_update_power_preferences_battery_saver_active() {
	let temp_dir = tempdir().unwrap();
	let root = temp_dir.path();

	test_write_cpuset_root_cpus(root, "0-3");

	let power_source_provider = FakePowerSourceProvider {
	power_source: PowerSourceType::AC,
	};

	let mut fake_config = FakeConfig::new();
	fake_config.write_power_preference(
	PowerSourceType::AC,
	PowerPreferencesType::ArcvmGaming,
	&PowerPreferences {
	governor: Some(Governor::Schedutil),
	epp: None,
	cpu_offline: None,
	cpufreq_disable_boost: false,
	},
	);
	fake_config.write_power_preference(
	PowerSourceType::AC,
	PowerPreferencesType::BatterySaver,
	&PowerPreferences {
	governor: Some(Governor::Conservative),
	epp: None,
	cpu_offline: None,
	cpufreq_disable_boost: false,
	},
	);
	fake_config.write_power_preference(
	PowerSourceType::AC,
	PowerPreferencesType::Default,
	&PowerPreferences {
	governor: Some(Governor::Schedutil),
	epp: None,
	cpu_offline: None,
	cpufreq_disable_boost: false,
	},
	);
	let config_provider = fake_config.provider();

	let manager =
	DirectoryPowerPreferencesManager::new(root, config_provider, power_source_provider);

	let tests = [
	(
	BatterySaverMode::Active,
	"balance_performance",
	Governor::Conservative,
	AFFECTED_CPU0, // policy0 affected_cpus
	AFFECTED_CPU1, // policy1 affected_cpus
	),
	(
	BatterySaverMode::Inactive,
	"balance_performance",
	Governor::Schedutil,
	AFFECTED_CPU0, // policy0 affected_cpus
	AFFECTED_CPU1, // policy1 affected_cpus
	),
	(
	BatterySaverMode::Active,
	"balance_performance",
	Governor::Conservative,
	AFFECTED_CPU_NONE, // policy0 affected_cpus, which has no affected cpus
	AFFECTED_CPU1, // policy1 affected_cpus
	),
	];

	// Test device without EPP path
	for test in tests {
	let orig_governor = Governor::Performance;
	let policy0 = PolicyConfigs {
	policy_path: TEST_CPUFREQ_POLICIES[0],
	governor: &orig_governor,
	affected_cpus: test.3,
	};
	let policy1 = PolicyConfigs {
	policy_path: TEST_CPUFREQ_POLICIES[1],
	governor: &orig_governor,
	affected_cpus: test.4,
	};
	let policies = vec![policy0, policy1];
	write_per_policy_scaling_governor(root, policies);
	manager
	.update_power_preferences(
	common::RTCAudioActive::Inactive,
	common::FullscreenVideo::Inactive,
	common::GameMode::Arc,
	common::VmBootMode::Inactive,
	test.0,
	)
	.unwrap();

	let mut expected_governors = vec![test.2, test.2];
	if test.3.is_empty() {
	expected_governors[0] = orig_governor;
	}
	check_per_policy_scaling_governor(root, expected_governors);
	}

	// Test device with EPP path
	let orig_epp = "balance_performance";
	for test in tests {
	write_epp(root, orig_epp, test.3).unwrap();
	manager
	.update_power_preferences(
	common::RTCAudioActive::Inactive,
	common::FullscreenVideo::Inactive,
	common::GameMode::Arc,
	common::VmBootMode::Inactive,
	test.0,
	)
	.unwrap();

	let epp = read_epp(root).unwrap();
	let mut expected_epp = test.1;
	if test.3.is_empty() {
	expected_epp = orig_epp;
	}
	assert_eq!(epp, expected_epp);
	}
	}
	}