Refactor per-plugin dynamic tuning configuration

Add a new global option "dynamic_plugins" which can be
used to globally enable dynamic tuning only for specific
plugins.

Also unify the behavior of the "dynamic" profile option
for plugins with dynamic capabilities. All such plugins
now have this option and it is set to True by default.
Dynamic tuning is then enabled for a specific plugin
if it is allowed both globally and locally.

Author: zacikpa

tests/unit/plugins/test_base.py

@@ -169,6 +169,14 @@ def __init__(self,*args,**kwargs):
 		super(DummyPlugin,self).__init__(*args,**kwargs)
 		self.cleaned_instances = []
 
+	@classmethod
+	def supports_static_tuning(cls):
+		return True
+
+	@classmethod
+	def supports_dynamic_tuning(cls):
+		return False
+
 	@classmethod
 	def _get_config_options(self):
 		return {'default_option1':'default_value1',\
@@ -205,6 +213,14 @@ def __init__(self,*args,**kwargs):
 		super(CommandsPlugin,self).__init__(*args,**kwargs)
 		self._size = 'S'
 
+	@classmethod
+	def supports_static_tuning(cls):
+		return True
+
+	@classmethod
+	def supports_dynamic_tuning(cls):
+		return False
+
 	@classmethod
 	def _get_config_options(self):
 		"""Default configuration options for the plugin."""

tuned/consts.py

@@ -103,6 +103,7 @@
 # (see configobj for methods, default is get for string)
 CFG_DAEMON = "daemon"
 CFG_DYNAMIC_TUNING = "dynamic_tuning"
+CFG_DYNAMIC_PLUGINS = "dynamic_plugins"
 CFG_SLEEP_INTERVAL = "sleep_interval"
 CFG_UPDATE_INTERVAL = "update_interval"
 CFG_RECOMMEND_COMMAND = "recommend_command"

tuned/daemon/application.py

@@ -28,10 +28,6 @@ def __init__(self, profile_name = None, config = None):
 		storage_factory = storage.Factory(storage_provider)
 
 		self.config = GlobalConfig() if config is None else config
-		if self.config.get_bool(consts.CFG_DYNAMIC_TUNING):
-			log.info("dynamic tuning is enabled (can be overridden in plugins)")
-		else:
-			log.info("dynamic tuning is globally disabled")
 
 		monitors_repository = monitors.Repository()
 		udev_buffer_size = self.config.get_size("udev_buffer_size", consts.CFG_DEF_UDEV_BUFFER_SIZE)
@@ -53,6 +49,8 @@ def __init__(self, profile_name = None, config = None):
 		profile_locator = profiles.Locator(self.config.get_list(consts.CFG_PROFILE_DIRS, consts.CFG_DEF_PROFILE_DIRS))
 		profile_loader = profiles.Loader(profile_locator, profile_factory, profile_merger, self.config, self.variables)
 
+		self._configure_dynamic_tuning(plugins_repository)
+
 		self._daemon = daemon.Daemon(unit_manager, profile_loader, profile_name, self.config, self)
 		self._controller = controller.Controller(self._daemon, self.config)
 
@@ -71,6 +69,35 @@ def _init_signals(self):
 		self._handle_signal(signal.SIGINT, self._controller.terminate)
 		self._handle_signal(signal.SIGTERM, self._controller.terminate)
 
+	def _configure_dynamic_tuning(self, plugins_repository):
+		# First check if the global `dynamic_tuning` option is set to False,
+		# disabling dynamic tuning for all plugins
+		if not self.config.get(consts.CFG_DYNAMIC_TUNING, consts.CFG_DEF_DYNAMIC_TUNING):
+			log.info("dynamic tuning is globally disabled")
+			self.config.set(consts.CFG_DYNAMIC_PLUGINS, [])
+			return
+		# If the global `dynamic_tuning` is True, check the `dynamic_plugins` option, which
+		# restricts the dynamic tuning to selected plugins only (if present)
+		all_plugins = {p.name(): p for p in plugins_repository.load_all_plugins()}
+		all_dynamic_plugins = {name: p for name, p in all_plugins.items() if p.supports_dynamic_tuning()}
+		# If it's not present, we enable dynamic tuning where possible
+		if self.config.get(consts.CFG_DYNAMIC_PLUGINS) is None:
+			self.config.set(consts.CFG_DYNAMIC_PLUGINS, all_dynamic_plugins.values())
+			log.info("dynamic tuning is enabled for all plugins which support it")
+			return
+		# Otherwise only to the specified plugins
+		enabled_dynamic_plugins = {}
+		for name in self.config.get_list(consts.CFG_DYNAMIC_PLUGINS):
+			if name not in all_plugins:
+				log.warn("Configuring dynamic tuning: Plugin '%s' does not exist" % name)
+				continue
+			if name not in all_dynamic_plugins:
+				log.warn("Configuring dynamic tuning: Plugin '%s' does not support dynamic tuning" % name)
+				continue
+			enabled_dynamic_plugins[name] = all_plugins[name]
+		self.config.set(consts.CFG_DYNAMIC_PLUGINS, enabled_dynamic_plugins.values())
+		log.info("dynamic tuning is enabled for plugins: %s" % ", ".join(enabled_dynamic_plugins.keys()))
+
 	def attach_to_dbus(self, bus_name, object_name, interface_name, namespace):
 		if self._dbus_exporter is not None:
 			raise TunedException("DBus interface is already initialized.")

tuned/daemon/controller.py

@@ -297,7 +297,7 @@ def get_all_plugins(self, caller = None):
 			return False
 		plugins = {}
 		for plugin_class in self._daemon.get_all_plugins():
-			plugin_name = plugin_class.__module__.split(".")[-1].split("_", 1)[1]
+			plugin_name = plugin_class.name()
 			conf_options = plugin_class._get_config_options()
 			plugins[plugin_name] = {}
 			for key, val in conf_options.items():
@@ -371,10 +371,10 @@ def instance_acquire_devices(self, devices, instance_name, caller = None):
 				devs -= devs_moving
 				log.info("Moving devices '%s' from instance '%s' to instance '%s'." % (str(devs_moving),
 					instance.name, instance_target.name))
-				if (instance.plugin.name != instance_target.plugin.name):
+				if (instance.plugin.name() != instance_target.plugin.name()):
 					rets = "Target instance '%s' is of type '%s', but devices '%s' are currently handled by " \
 						"instance '%s' which is of type '%s'." % (instance_target.name,
-						instance_target.plugin.name, str(devs_moving), instance.name, instance.plugin.name)
+						instance_target.plugin.name(), str(devs_moving), instance.name, instance.plugin.name())
 					log.error(rets)
 					return (False, rets)
 				instance.plugin._remove_devices_nocheck(instance, devs_moving)
@@ -405,8 +405,8 @@ def get_instances(self, plugin_name, caller = None):
 			return (False, rets, [])
 		instances = filter(lambda instance: instance.active, self._daemon._unit_manager.instances)
 		if plugin_name != "":
-			instances = filter(lambda instance: instance.plugin.name == plugin_name, instances)
-		return (True, "OK", list(map(lambda instance: (instance.name, instance.plugin.name), instances)))
+			instances = filter(lambda instance: instance.plugin.name() == plugin_name, instances)
+		return (True, "OK", list(map(lambda instance: (instance.name, instance.plugin.name()), instances)))
 
 	@exports.export("s", "(bsas)")
 	def instance_get_devices(self, instance_name, caller = None):

tuned/plugins/base.py

@@ -49,9 +49,17 @@ def init_devices(self):
 			self._init_devices()
 			self._devices_inited = True
 
-	@property
-	def name(self):
-		return self.__class__.__module__.split(".")[-1].split("_", 1)[1]
+	@classmethod
+	def name(cls):
+		return cls.__module__.split(".")[-1].split("_", 1)[1]
+
+	@classmethod
+	def supports_static_tuning(cls):
+		raise NotImplementedError()
+
+	@classmethod
+	def supports_dynamic_tuning(cls):
+		raise NotImplementedError()
 
 	#
 	# Plugin configuration manipulation and helpers.
@@ -74,8 +82,10 @@ def _get_config_options_used_by_dynamic(self):
 
 	def _get_effective_options(self, options):
 		"""Merge provided options with plugin default options."""
-		# TODO: _has_dynamic_options is a hack
 		effective = self._get_config_options().copy()
+		if self.supports_dynamic_tuning():
+			effective["dynamic"] = True
+		# TODO: _has_dynamic_options is a hack
 		for key in options:
 			if key in effective or self._has_dynamic_options:
 				effective[key] = options[key]
@@ -119,13 +129,13 @@ def destroy_instance(self, instance):
 
 	def initialize_instance(self, instance):
 		"""Initialize an instance."""
-		log.debug("initializing instance %s (%s)" % (instance.name, self.name))
+		log.debug("initializing instance %s (%s)" % (instance.name, self.name()))
 		self._instance_init(instance)
 
 	def destroy_instances(self):
 		"""Destroy all instances."""
 		for instance in list(self._instances.values()):
-			log.debug("destroying instance %s (%s)" % (instance.name, self.name))
+			log.debug("destroying instance %s (%s)" % (instance.name, self.name()))
 			self._destroy_instance(instance)
 		self._instances.clear()
 
@@ -134,10 +144,13 @@ def _destroy_instance(self, instance):
 		self._instance_cleanup(instance)
 
 	def _instance_init(self, instance):
-		raise NotImplementedError()
+		instance._static_tuning_enabled = self.supports_static_tuning()
+		instance._dynamic_tuning_enabled = self.supports_dynamic_tuning() \
+			and self.__class__ in self._global_cfg.get(consts.CFG_DYNAMIC_PLUGINS) \
+			and self._option_bool(instance.options["dynamic"])
 
 	def _instance_cleanup(self, instance):
-		raise NotImplementedError()
+		pass
 
 	#
 	# Devices handling
@@ -159,7 +172,7 @@ def _get_matching_devices(self, instance, devices):
 		else:
 			udev_devices = self._get_device_objects(devices)
 			if udev_devices is None:
-				log.error("Plugin '%s' does not support the 'devices_udev_regex' option", self.name)
+				log.error("Plugin '%s' does not support the 'devices_udev_regex' option", self.name())
 				return set()
 			udev_devices = self._device_matcher_udev.match_list(instance.devices_udev_regex, udev_devices)
 			return set([x.sys_name for x in udev_devices])
@@ -175,8 +188,8 @@ def assign_free_devices(self, instance):
 			log.warn("instance %s: no matching devices available" % instance.name)
 		else:
 			name = instance.name
-			if instance.name != self.name:
-				name += " (%s)" % self.name
+			if instance.name != self.name():
+				name += " (%s)" % self.name()
 			log.info("instance %s: assigning devices %s" % (name, ", ".join(to_assign)))
 			instance.assigned_devices.update(to_assign) # cannot use |=
 			self._assigned_devices |= to_assign
@@ -255,15 +268,15 @@ def instance_apply_tuning(self, instance):
 		if not instance.active:
 			return
 
-		if instance.has_static_tuning:
+		if instance.static_tuning_enabled:
 			self._call_device_script(instance, instance.script_pre,
 					"apply", instance.assigned_devices)
 			self._instance_pre_static(instance, True)
 			self._instance_apply_static(instance)
 			self._instance_post_static(instance, True)
 			self._call_device_script(instance, instance.script_post,
 					"apply", instance.assigned_devices)
-		if instance.has_dynamic_tuning and self._global_cfg.get(consts.CFG_DYNAMIC_TUNING, consts.CFG_DEF_DYNAMIC_TUNING):
+		if instance.dynamic_tuning_enabled:
 			self._instance_init_dynamic(instance)
 			self._run_for_each_device(instance, self._instance_apply_dynamic, instance.assigned_devices)
 		instance.processed_devices.update(instance.assigned_devices)
@@ -280,7 +293,7 @@ def instance_verify_tuning(self, instance, ignore_missing):
 			log.error("BUG: Some devices have not been tuned: %s"
 					% ", ".join(instance.assigned_devices))
 		devices = instance.processed_devices.copy()
-		if instance.has_static_tuning:
+		if instance.static_tuning_enabled:
 			if self._call_device_script(instance, instance.script_pre, "verify", devices) == False:
 				return False
 			if self._instance_verify_static(instance, ignore_missing, devices) == False:
@@ -297,7 +310,7 @@ def instance_update_tuning(self, instance):
 		"""
 		if not instance.active:
 			return
-		if instance.has_dynamic_tuning and self._global_cfg.get(consts.CFG_DYNAMIC_TUNING, consts.CFG_DEF_DYNAMIC_TUNING):
+		if instance.dynamic_tuning_enabled:
 			self._run_for_each_device(instance, self._instance_update_dynamic, instance.processed_devices.copy())
 
 	def instance_unapply_tuning(self, instance, rollback = consts.ROLLBACK_SOFT):
@@ -307,9 +320,9 @@ def instance_unapply_tuning(self, instance, rollback = consts.ROLLBACK_SOFT):
 		if rollback == consts.ROLLBACK_NONE:
 			return
 
-		if instance.has_dynamic_tuning and self._global_cfg.get(consts.CFG_DYNAMIC_TUNING, consts.CFG_DEF_DYNAMIC_TUNING):
+		if instance.dynamic_tuning_enabled:
 			self._run_for_each_device(instance, self._instance_unapply_dynamic, instance.processed_devices)
-		if instance.has_static_tuning:
+		if instance.static_tuning_enabled:
 			self._call_device_script(instance, instance.script_post,
 					"unapply", instance.processed_devices,
 					rollback = rollback)
@@ -345,7 +358,7 @@ def _instance_apply_dynamic(self, instance, device):
 		self._instance_update_dynamic(instance, device)
 
 	def _instance_unapply_dynamic(self, instance, device):
-		raise NotImplementedError()
+		pass
 
 	def _instance_update_dynamic(self, instance, device):
 		raise NotImplementedError()

tuned/plugins/hotplug.py

@@ -103,10 +103,10 @@ def _remove_devices_nocheck(self, instance, device_names):
 
 	def _added_device_apply_tuning(self, instance, device_name):
 		self._execute_all_device_commands(instance, [device_name])
-		if instance.has_dynamic_tuning and self._global_cfg.get(consts.CFG_DYNAMIC_TUNING, consts.CFG_DEF_DYNAMIC_TUNING):
+		if instance.dynamic_tuning_enabled:
 			self._instance_apply_dynamic(instance, device_name)
 
 	def _removed_device_unapply_tuning(self, instance, device_name):
-		if instance.has_dynamic_tuning and self._global_cfg.get(consts.CFG_DYNAMIC_TUNING, consts.CFG_DEF_DYNAMIC_TUNING):
+		if instance.dynamic_tuning_enabled:
 			self._instance_unapply_dynamic(instance, device_name)
 		self._cleanup_all_device_commands(instance, [device_name], remove = True)

tuned/plugins/instance/instance.py

@@ -15,8 +15,8 @@ def __init__(self, plugin, name, priority, devices_expression, devices_udev_rege
 
 		self._active = True
 		self._priority = priority
-		self._has_static_tuning = False
-		self._has_dynamic_tuning = False
+		self._static_tuning_enabled = False
+		self._dynamic_tuning_enabled = False
 		self._assigned_devices = set()
 		self._processed_devices = set()
 
@@ -72,12 +72,12 @@ def options(self):
 		return self._options
 
 	@property
-	def has_static_tuning(self):
-		return self._has_static_tuning
+	def static_tuning_enabled(self):
+		return self._static_tuning_enabled
 
 	@property
-	def has_dynamic_tuning(self):
-		return self._has_dynamic_tuning
+	def dynamic_tuning_enabled(self):
+		return self._dynamic_tuning_enabled
 
 	# methods
 

tuned/plugins/plugin_acpi.py

@@ -33,19 +33,18 @@ class ACPIPlugin(base.Plugin):
 	====
 	--
 	"""
-	def __init__(self, *args, **kwargs):
-		super(ACPIPlugin, self).__init__(*args, **kwargs)
 
 	@classmethod
-	def _get_config_options(cls):
-		return {"platform_profile": None}
+	def supports_static_tuning(cls):
+		return True
 
-	def _instance_init(self, instance):
-		instance._has_static_tuning = True
-		instance._has_dynamic_tuning = False
+	@classmethod
+	def supports_dynamic_tuning(cls):
+		return False
 
-	def _instance_cleanup(self, instance):
-		pass
+	@classmethod
+	def _get_config_options(cls):
+		return {"platform_profile": None}
 
 	@classmethod
 	def _platform_profile_choices_path(cls):

tuned/plugins/plugin_audio.py

@@ -37,6 +37,14 @@ class AudioPlugin(hotplug.Plugin):
 	====
 	"""
 
+	@classmethod
+	def supports_static_tuning(cls):
+		return True
+
+	@classmethod
+	def supports_dynamic_tuning(cls):
+		return False
+
 	def _init_devices(self):
 		self._devices_supported = True
 		self._assigned_devices = set()
@@ -47,13 +55,6 @@ def _init_devices(self):
 			if module_name in ["snd_hda_intel", "snd_ac97_codec"]:
 				self._free_devices.add(module_name)
 
-	def _instance_init(self, instance):
-		instance._has_static_tuning = True
-		instance._has_dynamic_tuning = False
-
-	def _instance_cleanup(self, instance):
-		pass
-
 	def _device_module_name(self, device):
 		try:
 			return device.parent.driver

tuned/plugins/plugin_bootloader.py

@@ -193,9 +193,16 @@ def __init__(self, *args, **kwargs):
 		super(BootloaderPlugin, self).__init__(*args, **kwargs)
 		self._cmd = commands()
 
+	@classmethod
+	def supports_static_tuning(cls):
+		return True
+
+	@classmethod
+	def supports_dynamic_tuning(cls):
+		return False
+
 	def _instance_init(self, instance):
-		instance._has_dynamic_tuning = False
-		instance._has_static_tuning = True
+		super(BootloaderPlugin, self)._instance_init(instance)
 		# controls grub2_cfg rewrites in _instance_post_static
 		self.update_grub2_cfg = False
 		self._skip_grub_config_val = False
@@ -208,9 +215,6 @@ def _instance_init(self, instance):
 
 		self._rpm_ostree = self._rpm_ostree_status() is not None
 
-	def _instance_cleanup(self, instance):
-		pass
-
 	@classmethod
 	def _get_config_options(cls):
 		return {