smfc 4.0.0__py3-none-any.whl

smfc/__init__.py

@@ -0,0 +1,17 @@
+#
+#    __init__.py (C) 2020-2025, Peter Sulyok
+#   smfc package: Super Micro fan control for Linux (home) servers.
+#
+from smfc.log import Log
+from smfc.ipmi import Ipmi
+from smfc.fancontroller import FanController
+from smfc.cpuzone import CpuZone
+from smfc.hdzone import HdZone
+from smfc.gpuzone import GpuZone
+from smfc.constzone import ConstZone
+from smfc.service import Service
+from smfc.cmd import main
+
+__all__ = [ "Log", "Ipmi", "FanController", "CpuZone", "HdZone", "GpuZone", "ConstZone", "Service", "main"]
+
+# End.

smfc/cmd.py

@@ -0,0 +1,18 @@
+#
+#   cmd.py (C) 2020-2025, Peter Sulyok
+#   smfc package: Super Micro fan control for Linux (home) servers.
+#   smfc.main() function implementation, command-line interface.
+#
+from smfc.service import Service
+
+
+def main() -> None:
+    """Entry point of the `smfc` program."""
+    service = Service()
+    service.run()
+
+
+if __name__ == '__main__':
+    main()
+
+# End.

smfc/constzone.py

@@ -0,0 +1,95 @@
+#
+#   constzone.py (C) 2020-2025, Peter Sulyok
+#   smfc package: Super Micro fan control for Linux (home) servers.
+#   smfc.ConstZone() class implementation.
+#
+import re
+import time
+from configparser import ConfigParser
+from smfc.fancontroller import FanController
+from smfc.ipmi import Ipmi
+from smfc.log import Log
+
+
+class ConstZone(FanController):
+    """Constant zone fan control."""
+
+    # Constant values for the configuration parameters.
+    CS_CONST_ZONE: str = 'CONST zone'
+    CV_CONST_ZONE_ENABLED: str = 'enabled'
+    CV_CONST_IPMI_ZONE: str = 'ipmi_zone'
+    CV_CONST_ZONE_POLLING: str = 'polling'
+    CV_CONST_ZONE_LEVEL: str = 'level'
+
+    # Constant level for the zone.
+    level: int
+
+    #pylint: disable=super-init-not-called
+    def __init__(self, log: Log, ipmi: Ipmi, config:ConfigParser) -> None:
+        """Initialize the ConstZone class and raise exception in case invalid configuration items.
+        Args:
+            log (Log): reference to a Log class instance
+            ipmi (Ipmi): reference to an Ipmi class instance
+            config (ConfigParser): reference to the configuration (default=None)
+        Raises:
+            ValueError: invalid configuration parameters
+        """
+        # Initialize ConstZone class.
+        self.log = log
+        self.ipmi = ipmi
+
+        # Read the list of IPMI zones from a string (trim and remove multiple spaces, convert strings to integers)
+        ipmi_zone_str = config[ConstZone.CS_CONST_ZONE].get(ConstZone.CV_CONST_IPMI_ZONE, fallback=f'{Ipmi.HD_ZONE}')
+        ipmi_zone_str = re.sub(' +', ' ', ipmi_zone_str.strip())
+        try:
+            self.ipmi_zone = [int(s) for s in ipmi_zone_str.split(',' if ',' in ipmi_zone_str else ' ')]
+        except ValueError as e:
+            raise e
+        for zone in self.ipmi_zone:
+            if zone not in range(0, 101):
+                raise ValueError(f'invalid value: ipmi_zone={ipmi_zone_str}.')
+
+        self.name = ConstZone.CS_CONST_ZONE
+        self.polling = config[ConstZone.CS_CONST_ZONE].getfloat(ConstZone.CV_CONST_ZONE_POLLING, fallback=30.0)
+        if self.polling < 0:
+            raise ValueError('polling < 0')
+        self.level = config[ConstZone.CS_CONST_ZONE].getint(ConstZone.CV_CONST_ZONE_LEVEL, fallback=50)
+        if self.level not in range(0, 101):
+            raise ValueError('invalid level')
+        self.last_time = 0
+
+        # Print configuration at DEBUG log level.
+        if self.log.log_level >= Log.LOG_CONFIG:
+            self.log.msg(Log.LOG_CONFIG, f'{self.name} fan controller was initialized with:')
+            self.log.msg(Log.LOG_CONFIG, f'   ipmi zone = {self.ipmi_zone}')
+            self.log.msg(Log.LOG_CONFIG, f'   polling = {self.polling}')
+            self.log.msg(Log.LOG_CONFIG, f'   level = {self.level}')
+    # pylint: enable=super-init-not-called
+
+    def run(self) -> None:
+        """Run IPMI zone controller function with the following steps:
+
+            * Step 1: Read current time. If the elapsed time is bigger than the polling time period,
+              then go to step 2, otherwise return.
+            * Step 2: Loop through IPMI zones: read current fan level in the zone, if the level is different from the
+              expected one then we set fan level in the zone again, otherwise return.
+            * Step 3: Log the fan level.
+        """
+        current_time: float     # Current system timestamp (measured)
+
+        # Step 1: check the elapsed time.
+        current_time = time.monotonic()
+        if (time.monotonic() - self.last_time) >= self.polling:
+            self.last_time = current_time
+
+            # Check in all IPMI zones if the current fan level is the expected one,
+            # otherwise set the fan level again.
+            for zone in self.ipmi_zone:
+                level = self.ipmi.get_fan_level(zone)
+                if level != self.level:
+                    self.ipmi.set_fan_level(zone, self.level)
+                    self.log.msg(Log.LOG_INFO, f'{self.name}: set fan level > {self.level}% '
+                                               f'@ IPMI {self.ipmi_zone} zone(s).')
+
+
+# End.

smfc/cpuzone.py

@@ -0,0 +1,90 @@
+#
+#   cpuzone.py (C) 2020-2025, Peter Sulyok
+#   smfc package: Super Micro fan control for Linux (home) servers.
+#   smfc.CpuZone() class implementation.
+#
+from configparser import ConfigParser
+from pyudev import Context
+from smfc.fancontroller import FanController
+from smfc.ipmi import Ipmi
+from smfc.log import Log
+
+
+class CpuZone(FanController):
+    """CPU zone fan control."""
+
+    # Constant values for the configuration parameters.
+    CS_CPU_ZONE: str = 'CPU zone'
+    CV_CPU_ZONE_ENABLED: str = 'enabled'
+    CV_CPU_IPMI_ZONE: str = 'ipmi_zone'
+    CV_CPU_ZONE_TEMP_CALC: str = 'temp_calc'
+    CV_CPU_ZONE_STEPS: str = 'steps'
+    CV_CPU_ZONE_SENSITIVITY: str = 'sensitivity'
+    CV_CPU_ZONE_POLLING: str = 'polling'
+    CV_CPU_ZONE_MIN_TEMP: str = 'min_temp'
+    CV_CPU_ZONE_MAX_TEMP: str = 'max_temp'
+    CV_CPU_ZONE_MIN_LEVEL: str = 'min_level'
+    CV_CPU_ZONE_MAX_LEVEL: str = 'max_level'
+
+    def __init__(self, log: Log, udevc: Context, ipmi: Ipmi, config:ConfigParser) -> None:
+        """Initialize the CpuZone class and raise exception in case of invalid configuration.
+        Args:
+            log (Log): reference to a Log class instance
+            udevc (Context): reference to an udev database connection (instance of Context from pyudev)
+            ipmi (Ipmi): reference to an Ipmi class instance
+            config (ConfigParser): reference to the configuration (default=None)
+        Raises:
+            ValueError: multiple hwmon devices reported, one expected
+            RuntimeError: No HWMON device found for CPU(s)
+        """
+        count: int  # CPU count.
+
+        # Build the list of paths for hwmon devices.
+        self.hwmon_path = []
+        # We are looking for either Intel (coretemp) or AMD (k10temp) CPUs.
+        for dev_filter in [{'MODALIAS':'platform:coretemp'}, {'DRIVER':'k10temp'}]:
+            self.hwmon_path = [self.get_hwmon_path(udevc, dev) for dev in udevc.list_devices(**dev_filter)]
+            # If we found results.
+            if self.hwmon_path:
+                break
+        if not self.hwmon_path:
+            raise RuntimeError('pyudev: No HWMON device(s) can be found for the CPU.')
+        # Calculate count.
+        count = len(self.hwmon_path)
+
+        # Initialize FanController class.
+        super().__init__(log, ipmi,
+            config[CpuZone.CS_CPU_ZONE].get(CpuZone.CV_CPU_IPMI_ZONE, fallback=f'{Ipmi.CPU_ZONE}'),
+            CpuZone.CS_CPU_ZONE, count,
+            config[CpuZone.CS_CPU_ZONE].getint(CpuZone.CV_CPU_ZONE_TEMP_CALC, fallback=FanController.CALC_AVG),
+            config[CpuZone.CS_CPU_ZONE].getint(CpuZone.CV_CPU_ZONE_STEPS, fallback=6),
+            config[CpuZone.CS_CPU_ZONE].getfloat(CpuZone.CV_CPU_ZONE_SENSITIVITY, fallback=3.0),
+            config[CpuZone.CS_CPU_ZONE].getfloat(CpuZone.CV_CPU_ZONE_POLLING, fallback=2),
+            config[CpuZone.CS_CPU_ZONE].getfloat(CpuZone.CV_CPU_ZONE_MIN_TEMP, fallback=30.0),
+            config[CpuZone.CS_CPU_ZONE].getfloat(CpuZone.CV_CPU_ZONE_MAX_TEMP, fallback=60.0),
+            config[CpuZone.CS_CPU_ZONE].getint(CpuZone.CV_CPU_ZONE_MIN_LEVEL, fallback=35),
+            config[CpuZone.CS_CPU_ZONE].getint(CpuZone.CV_CPU_ZONE_MAX_LEVEL, fallback=100)
+        )
+
+    def _get_nth_temp(self, index: int) -> float:
+        """Get the temperature of the 'nth' element in the hwmon list.
+           Args:
+               index (int): index in hwmon list
+           Returns:
+               float: temperature value
+           Raises:
+               FileNotFoundError:   file not found
+               IOError:             file cannot be opened
+               ValueError:          invalid value read from file
+               IndexError:          invalid index
+           """
+        value: float  # Temperature value
+
+        try:
+            with open(self.hwmon_path[index], "r", encoding="UTF-8") as f:
+                value = float(f.read()) / 1000
+        except (IOError, FileNotFoundError, ValueError) as e:
+            raise e
+        return value
+
+# End.

smfc/fancontroller.py

@@ -0,0 +1,278 @@
+#
+#   fancontroller.py (C) 2020-2025, Peter Sulyok
+#   smfc package: Super Micro fan control for Linux (home) servers.
+#   smfc.FanController() class implementation.
+#
+import os
+import time
+import re
+from typing import List, Callable
+from pyudev import Context, Device
+from smfc.ipmi import Ipmi
+from smfc.log import Log
+
+
+class FanController:
+    """Generic fan controller class for an IPMI zone."""
+
+    # Constant values for temperature calculation
+    CALC_MIN: int = 0
+    CALC_AVG: int = 1
+    CALC_MAX: int = 2
+
+    # Configuration parameters
+    log: Log                # Reference to a Log class instance
+    ipmi: Ipmi              # Reference to an Ipmi class instance
+    ipmi_zone: List[int]    # List of IPMI zones assigned to this fan controller
+    name: str               # Name of the controller
+    count: int              # Number of controlled entities
+    temp_calc: int          # Calculate of the temperature (0-min, 1-avg, 2-max)
+    steps: int              # Discrete steps in temperatures and fan levels
+    sensitivity: float      # Temperature change to activate fan controller (C)
+    polling: float          # Polling interval to read temperature (sec)
+    min_temp: float         # Minimum temperature value (C)
+    max_temp: float         # Maximum temperature value (C)
+    min_level: int          # Minimum fan level (0..100%)
+    max_level: int          # Maximum fan level (0..100%)
+    hwmon_path: List[str]   # List of paths for HWMON devices
+
+    # Measured or calculated attributes
+    temp_step: float        # A temperature steps value (C)
+    level_step: float       # A fan level step value (0..100%)
+    last_time: float        # Last system time we polled temperature (timestamp)
+    last_temp: float        # Last measured temperature value (C)
+    last_level: int         # Last configured fan level (0..100%)
+
+    # Function variable for selected temperature calculation method
+    get_temp_func: Callable[[], float]
+
+    def __init__(self, log: Log, ipmi: Ipmi, ipmi_zone: str, name: str, count: int, temp_calc: int,
+                 steps: int, sensitivity: float, polling: float, min_temp: float, max_temp: float, min_level: int,
+                 max_level: int) -> None:
+        """Initialize the FanController class. Will raise an exception in case of invalid parameters.
+        Args:
+            log (Log): reference to a Log class instance
+            ipmi (Ipmi): reference to an Ipmi class instance
+            ipmi_zone (str): IPMI zone(s) assigned to the controller
+            name (str): name of the controller
+            count (int): number of devices
+            temp_calc (int): calculation of temperature
+            steps (int): discrete steps in temperatures and fan levels
+            sensitivity (float): temperature change to activate fan controller (C)
+            polling (float): polling time interval for reading temperature (sec)
+            min_temp (float): minimum temperature value (C)
+            max_temp (float): maximum temperature value (C)
+            min_level (int): minimum fan level value [0..100%]
+            max_level (int): maximum fan level value [0..100%]
+        Raises:
+            ValueError: invalid input parameter
+        """
+        # Save and validate configuration parameters.
+        self.log = log
+        self.ipmi = ipmi
+        # Read the list of IPMI zones from a string (trim and remove multiple spaces, convert strings to integers)
+        zone_str = re.sub(' +', ' ', ipmi_zone.strip())
+        try:
+            self.ipmi_zone = [int(s) for s in zone_str.split(',' if ',' in ipmi_zone else ' ')]
+        except ValueError as e:
+            raise e
+        for zone in self.ipmi_zone:
+            if zone not in range(0, 101):
+                raise ValueError(f'invalid value: ipmi_zone={ipmi_zone}.')
+        self.name = name
+        self.count = count
+        if self.count <= 0:
+            raise ValueError('invalid value: count <= 0')
+        self.temp_calc = temp_calc
+        if self.temp_calc not in {self.CALC_MIN, self.CALC_AVG, self.CALC_MAX}:
+            raise ValueError(f'invalid value: temp_calc ({temp_calc}).')
+        self.steps = steps
+        if self.steps <= 0:
+            raise ValueError('invalid value: steps <= 0')
+        self.sensitivity = sensitivity
+        if self.sensitivity <= 0:
+            raise ValueError('invalid value: sensitivity <= 0')
+        self.polling = polling
+        if self.polling < 0:
+            raise ValueError('polling < 0')
+        if max_temp < min_temp:
+            raise ValueError('invalid value: max_temp < min_temp')
+        self.min_temp = min_temp
+        self.max_temp = max_temp
+        if max_level < min_level:
+            raise ValueError('invalid value: max_level < min_level')
+        self.min_level = min_level
+        self.max_level = max_level
+
+        # Set the proper temperature function.
+        if self.count == 1:
+            self.get_temp_func = self.get_1_temp
+        else:
+            self.get_temp_func = self.get_avg_temp
+            if self.temp_calc == self.CALC_MIN:
+                self.get_temp_func = self.get_min_temp
+            elif self.temp_calc == self.CALC_MAX:
+                self.get_temp_func = self.get_max_temp
+
+        # Try to read device temperature (the hwmon_path[] list has already been created by a child class).
+        # If there is any problem with reading temperature, the program will stop here with an exception.
+        self.get_temp_func()
+
+        # Initialize calculated values.
+        self.temp_step = (max_temp - min_temp) / steps
+        self.level_step = (max_level - min_level) / steps
+        self.last_temp = 0
+        self.last_level = 0
+        self.last_time = time.monotonic() - (polling + 1)
+        # Print configuration at DEBUG log level.
+        if self.log.log_level >= Log.LOG_CONFIG:
+            self.log.msg(Log.LOG_CONFIG, f'{self.name} fan controller was initialized with:')
+            self.log.msg(Log.LOG_CONFIG, f'   ipmi zone = {self.ipmi_zone}')
+            self.log.msg(Log.LOG_CONFIG, f'   count = {self.count}')
+            self.log.msg(Log.LOG_CONFIG, f'   temp_calc = {self.temp_calc}')
+            self.log.msg(Log.LOG_CONFIG, f'   steps = {self.steps}')
+            self.log.msg(Log.LOG_CONFIG, f'   sensitivity = {self.sensitivity}')
+            self.log.msg(Log.LOG_CONFIG, f'   polling = {self.polling}')
+            self.log.msg(Log.LOG_CONFIG, f'   min_temp = {self.min_temp}')
+            self.log.msg(Log.LOG_CONFIG, f'   max_temp = {self.max_temp}')
+            self.log.msg(Log.LOG_CONFIG, f'   min_level = {self.min_level}')
+            self.log.msg(Log.LOG_CONFIG, f'   max_level = {self.max_level}')
+            if hasattr(self, 'hwmon_path'):
+                self.log.msg(Log.LOG_CONFIG, f'   hwmon_path = {[p if p else "smartctl" for p in self.hwmon_path]}')
+            self.print_temp_level_mapping()
+
+    @staticmethod
+    def get_hwmon_path(udevc: Context, parent_dev: Device) -> str:
+        """A helper function to get HWMON path of a given parent device's associated hwmon
+
+        Args:
+            udevc (Context): pyudev Context
+            parent_dev (Device): parent device
+        Returns:
+            str: path for a HWMON device
+        """
+        try:
+            [hwmon_device] = udevc.list_devices(subsystem='hwmon', parent=parent_dev)
+        except ValueError:
+            # If parent_dev has zero (or more?) hwmon device in its subtree
+            hwmon_device = None
+        return os.path.join(hwmon_device.sys_path, 'temp1_input') if hwmon_device is not None else ''
+
+    def _get_nth_temp(self, index: int) -> float:
+        """Get the temperature of the 'nth' element in the hwmon list. This is an empty implementation."""
+
+    def get_1_temp(self) -> float:
+        """Get a single temperature of a controlled entity in the IPMI zone.
+
+        Returns:
+            float: single temperature of a controlled entity (C)
+        """
+        return self._get_nth_temp(0)
+
+    def get_min_temp(self) -> float:
+        """Get the minimum temperature of multiple controlled entities.
+
+        Returns:
+            float: minimum temperature of the controlled entities (C)
+        """
+        minimum: float      # Minimum temperature value
+
+        # Calculate minimum temperature.
+        minimum = 1000.0
+        for i in range(self.count):
+            minimum = min(self._get_nth_temp(i), minimum)
+        return minimum
+
+    def get_avg_temp(self):
+        """Get the average temperature of the controlled entities in the IPMI zone.
+
+           Returns:
+                float: average temperature of the controlled entities (C)
+        """
+        average: float      # Average temperature
+        counter: int        # Value counter
+
+        # Calculate average temperature.
+        average = 0.0
+        counter = 0
+        for i in range(self.count):
+            average += self._get_nth_temp(i)
+            counter += 1
+        return average / counter
+
+    def get_max_temp(self) -> float:
+        """Get the maximum temperature of the controlled entities in the IPMI zone.
+
+           Returns:
+                float: maximum temperature of the controlled entities (C)
+        """
+        maximum: float      # Maximum temperature value
+
+        # Calculate minimum temperature.
+        maximum = -1.0
+        for i in range(self.count):
+            maximum = max(self._get_nth_temp(i), maximum)
+        return maximum
+
+    def set_fan_level(self, level: int) -> None:
+        """Set the new fan level in all IPMI zones of the controller.
+
+        Args:
+            level (int): new fan level [0..100]
+        """
+        self.ipmi.set_multiple_fan_levels(self.ipmi_zone, level)
+
+    def callback_func(self) -> None:
+        """Call-back function for a child class."""
+
+    def run(self) -> None:
+        """Run IPMI zone controller function with the following steps:
+
+            * Step 1: Read current time. If the elapsed time is bigger than the polling time period
+              then go to step 2, otherwise return.
+            * Step 2: Read the current temperature. If the change of the temperature goes beyond
+              the sensitivity limit then go to step 3, otherwise return
+            * Step 3: Calculate the current gain and fan level based on the measured temperature
+            * Step 4: If the new fan level is different it will be set and logged
+        """
+        current_time: float     # Current system timestamp (measured)
+        current_temp: float     # Current temperature (measured)
+        current_level: int      # Current fan level (calculated)
+        current_gain: int       # Current gain (calculated)
+
+        # Step 1: check the elapsed time.
+        current_time = time.monotonic()
+        if (current_time - self.last_time) >= self.polling:
+            self.last_time = current_time
+
+            # Step 2: read the temperature and check the sensitivity gap.
+            self.callback_func()
+            current_temp = self.get_temp_func()
+            self.log.msg(Log.LOG_DEBUG, f'{self.name}: new temperature > {current_temp:.1f}C')
+            if abs(current_temp - self.last_temp) >= self.sensitivity:
+                self.last_temp = current_temp
+
+                # Step 3: calculate gain and fan level.
+                if current_temp <= self.min_temp:
+                    current_level = self.min_level
+                elif current_temp >= self.max_temp:
+                    current_level = self.max_level
+                else:
+                    current_gain = int(round((current_temp - self.min_temp) / self.temp_step))
+                    current_level = int(round(float(current_gain) * self.level_step)) + self.min_level
+
+                # Step 4: the new fan level will be set and logged.
+                if current_level != self.last_level:
+                    self.last_level = current_level
+                    self.set_fan_level(current_level)
+                    self.log.msg(Log.LOG_INFO, f'{self.name}: new fan level > {current_level}%/{current_temp:.1f}C'
+                                 f' @ IPMI {self.ipmi_zone} zone(s).')
+
+    def print_temp_level_mapping(self) -> None:
+        """Print out the user-defined temperature to level mapping value in log DEBUG level."""
+        self.log.msg(Log.LOG_CONFIG, '   User-defined control function:')
+        for i in range(self.steps + 1):
+            self.log.msg(Log.LOG_CONFIG, f'   {i}. [T:{self.min_temp+(i*self.temp_step):.1f}C - '
+                         f'L:{int(self.min_level + (i * self.level_step))}%]')
+
+# End.

smfc/gpuzone.py

@@ -0,0 +1,130 @@
+#
+#   gpuzone.py (C) 2020-2025, Peter Sulyok
+#   smfc package: Super Micro fan control for Linux (home) servers.
+#   smfc.GpuZone() class implementation.
+#
+import subprocess
+import time
+import re
+from configparser import ConfigParser
+from typing import List
+from smfc.fancontroller import FanController
+from smfc.ipmi import Ipmi
+from smfc.log import Log
+
+
+class GpuZone(FanController):
+    """Class for GPU zone fan control."""
+
+    # GpuZone specific parameters.
+    gpu_device_ids: List[int]           # GPU device IDs (indexes)
+    nvidia_smi_path: str                # Path for `nvidia-smi` command
+    nvidia_smi_called: float            # Timestamp when `nvidia-smi` command executed
+    gpu_temperature: List[float]        # List of GPU temperatures
+
+    # Constant values for the configuration parameters.
+    CS_GPU_ZONE: str = 'GPU zone'
+    CV_GPU_ZONE_ENABLED: str = 'enabled'
+    CV_GPU_IPMI_ZONE: str = 'ipmi_zone'
+    CV_GPU_ZONE_TEMP_CALC: str = 'temp_calc'
+    CV_GPU_ZONE_STEPS: str = 'steps'
+    CV_GPU_ZONE_SENSITIVITY: str = 'sensitivity'
+    CV_GPU_ZONE_POLLING: str = 'polling'
+    CV_GPU_ZONE_MIN_TEMP: str = 'min_temp'
+    CV_GPU_ZONE_MAX_TEMP: str = 'max_temp'
+    CV_GPU_ZONE_MIN_LEVEL: str = 'min_level'
+    CV_GPU_ZONE_MAX_LEVEL: str = 'max_level'
+    CV_GPU_ZONE_GPU_IDS: str = 'gpu_device_ids'
+    CV_GPU_ZONE_NVIDIA_SMI_PATH: str = 'nvidia_smi_path'
+
+    def __init__(self, log: Log, ipmi: Ipmi, config: ConfigParser) -> None:
+        """Initialize the GpuZone class. Abort in case of configuration errors.
+        Args:
+            log (Log): reference to a Log class instance
+            ipmi (Ipmi): reference to an Ipmi class instance
+            config (configparser.ConfigParser): reference to the configuration (default=None)
+        Raises:
+            ValueError: invalid parameters
+        """
+        gpu_id_list: str    # String for gpu_device_ids=
+        count: int          # GPU count.
+
+        # Save and validate GpuZone class-specific parameters.
+        gpu_id_list = config[self.CS_GPU_ZONE].get(self.CV_GPU_ZONE_GPU_IDS, '0')
+        gpu_id_list = re.sub(' +', ' ', gpu_id_list.strip())
+        try:
+            self.gpu_device_ids = [int(s) for s in gpu_id_list.split(',' if ',' in gpu_id_list else ' ')]
+        except ValueError as e:
+            raise e
+        for gid in self.gpu_device_ids:
+            if gid not in range(0, 101):
+                raise ValueError(f'invalid value: {self.CV_GPU_ZONE_GPU_IDS}={gpu_id_list}.')
+        count = len(self.gpu_device_ids)
+        self.nvidia_smi_path = config[GpuZone.CS_GPU_ZONE].get(GpuZone.CV_GPU_ZONE_NVIDIA_SMI_PATH,
+                                                              '/usr/bin/nvidia-smi')
+        self.nvidia_smi_called = 0
+
+        # Initialize FanController class.
+        super().__init__(log, ipmi,
+            config[GpuZone.CS_GPU_ZONE].get(GpuZone.CV_GPU_IPMI_ZONE, fallback=f'{Ipmi.HD_ZONE}'),
+            GpuZone.CS_GPU_ZONE, count,
+            config[GpuZone.CS_GPU_ZONE].getint(GpuZone.CV_GPU_ZONE_TEMP_CALC, fallback=FanController.CALC_AVG),
+            config[GpuZone.CS_GPU_ZONE].getint(GpuZone.CV_GPU_ZONE_STEPS, fallback=5),
+            config[GpuZone.CS_GPU_ZONE].getfloat(GpuZone.CV_GPU_ZONE_SENSITIVITY, fallback=2),
+            config[GpuZone.CS_GPU_ZONE].getfloat(GpuZone.CV_GPU_ZONE_POLLING, fallback=2),
+            config[GpuZone.CS_GPU_ZONE].getfloat(GpuZone.CV_GPU_ZONE_MIN_TEMP, fallback=40),
+            config[GpuZone.CS_GPU_ZONE].getfloat(GpuZone.CV_GPU_ZONE_MAX_TEMP, fallback=70),
+            config[GpuZone.CS_GPU_ZONE].getint(GpuZone.CV_GPU_ZONE_MIN_LEVEL, fallback=35),
+            config[GpuZone.CS_GPU_ZONE].getint(GpuZone.CV_GPU_ZONE_MAX_LEVEL, fallback=100)
+        )
+
+        # Print configuration in CONFIG log level (or higher).
+        if self.log.log_level >= Log.LOG_CONFIG:
+            self.log.msg(Log.LOG_CONFIG, f'   {self.CV_GPU_ZONE_GPU_IDS} = {self.gpu_device_ids}')
+            self.log.msg(Log.LOG_CONFIG, f'   {self.CV_GPU_ZONE_NVIDIA_SMI_PATH} = {self.nvidia_smi_path}')
+
+    def _exec_nvidia_smi(self, arguments: List[str]) -> subprocess.CompletedProcess:
+        """Execution of the `nvidia-smi` command.
+            Args:
+                arguments (List[str]): list of argument of `nvidia-smi` command
+            Raises:
+                FileNotFoundError: command not found
+        """
+        r: subprocess.CompletedProcess  # Result of the executed process
+        args: List[str] = []            # List of arguments
+
+        # Execute `nvidia-smi` command.
+        try:
+            args.append(self.nvidia_smi_path)
+            args.extend(arguments)
+            r = subprocess.run(args, check=False, capture_output=True, text=True)
+        except FileNotFoundError as e:
+            raise e
+        return r
+
+    def _get_nth_temp(self, index: int) -> float:
+        """Get the temperature of the nth element in the GPU device list.
+        Args:
+            index (int): index in GPU device list
+        Returns:
+            float: temperature value
+        Raises:
+            FileNotFoundError:  file or command cannot be found
+            ValueError:         invalid temperature value
+            IndexError:         invalid index
+        """
+        current_time = time.monotonic()
+        if (current_time - self.nvidia_smi_called) >= self.polling:
+            r: subprocess.CompletedProcess  # result of the executed process
+
+            r = self._exec_nvidia_smi(['--query-gpu=temperature.gpu', '--format=csv,noheader,nounits'])
+            self.nvidia_smi_called = current_time
+            temp_list = r.stdout.splitlines()
+            self.gpu_temperature = []
+            for gid in self.gpu_device_ids:
+                self.gpu_temperature.append(int(temp_list[gid]))
+
+        return self.gpu_temperature[index]
+
+
+# End.