Add handling for missing nvml lib

.gitignore

@@ -3,6 +3,6 @@ compile_commands.json
 .cache/
 pkg/
 rel_oot/
-src/
+./src
 *.pkg.tar.zst
 *.tar.gz

PKGBUILD

@@ -1,5 +1,5 @@
 pkgname=fantasize
-pkgver=0.1.3
+pkgver=0.1.7
 pkgrel=1
 pkgdesc='C++ fan control for Linux'
 url='https://github.com/Tabascl/fantasize.git'

app/.clang-format

@@ -0,0 +1 @@
+BasedOnStyle: Google

app/CMakeLists.txt

@@ -1,18 +1,32 @@
 cmake_minimum_required(VERSION 3.0)
 
-project(fantasize VERSION 0.1.3)
+project(fantasize VERSION 0.1.7)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-find_package(nlohmann_json 3.11.2 REQUIRED)
+find_package(nlohmann_json 3.7 REQUIRED)
 find_package(Boost 1.80 COMPONENTS program_options log log_setup date_time REQUIRED)
 
+find_library(NVML_LIB nvidia-ml)
+
+set(ADDITIONAL_LIBS)
+
+if (NVML_LIB)
+    set(HAVE_NVML)
+
+    add_library(nvidia-sensor-lib STATIC
+      src/sensor/NvidiaSensor.cxx
+      src/sensor/GPUSensorsFacade.cxx)
+
+    target_link_libraries(nvidia-sensor-lib PUBLIC NVML_LIB)
+
+    list(APPEND ADDITIONAL_LIBS nvidia-sensor-lib)
+endif()
+
 add_executable(${PROJECT_NAME}
   src/main.cxx
   src/sensor/LMSensorsFacade.cxx
-  src/sensor/GPUSensorsFacade.cxx
   src/sensor/Sensor.cxx
-  src/sensor/NvidiaSensor.cxx
   src/sensor/LMSensor.cxx
   src/pwm/PWMControl.cxx
   src/pwm/PWMControlFacade.cxx
@@ -23,13 +37,15 @@ add_executable(${PROJECT_NAME}
   src/Serializer.cxx
   src/sensor/SensorManager.cxx
   src/Controller.cxx
+  src/Settings.cxx
   src/App.cxx
 )
 
 set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 20)
 
 target_include_directories(${PROJECT_NAME} PUBLIC include /opt/cuda)
-target_link_libraries(${PROJECT_NAME} PUBLIC sensors nvidia-ml nlohmann_json::nlohmann_json tbb ${Boost_LIBRARIES})
+
+target_link_libraries(${PROJECT_NAME} PUBLIC sensors nlohmann_json::nlohmann_json tbb ${Boost_LIBRARIES} ${ADDITIONAL_LIBS})
 
 install(TARGETS ${PROJECT_NAME} DESTINATION usr/local/bin)
 install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/unit/fantasize.service DESTINATION usr/lib/systemd/system)

app/include/App.h

@@ -26,6 +26,8 @@ private:
   FanLabeler mFanLabeler;
   FanGenerator mFanGenerator;
 
+  std::shared_ptr<Settings> mSettings;
+
   std::unique_ptr<Controller> mController;
 
   std::vector<std::shared_ptr<Fan>> mFans;

app/include/Controller.h

@@ -5,11 +5,13 @@
 #include <thread>
 #include <vector>
 
+#include <Settings.h>
 #include <fan/FanCurve.h>
 
 class Controller {
 public:
-  Controller(std::vector<std::shared_ptr<FanCurve>> curves);
+  Controller(std::shared_ptr<Settings> settings,
+             std::vector<std::shared_ptr<FanCurve>> curves);
   ~Controller();
 
   void StartFanControlLoop();
@@ -18,6 +20,8 @@ public:
 private:
   void Loop();
 
+  int mTimeout;
+
   std::vector<std::shared_ptr<FanCurve>> mFanCurves;
   std::atomic<bool> mRun;
 

app/include/Serializer.h

@@ -1,12 +1,12 @@
 #ifndef SERIALIZER_H_
 #define SERIALIZER_H_
 
-#include "fan/HwmonFan.h"
 #include <memory>
 #include <vector>
 
 #include <nlohmann/json.hpp>
 
+#include <Settings.h>
 #include <fan/Fan.h>
 #include <fan/FanCurve.h>
 #include <sensor/Sensor.h>
@@ -25,6 +25,7 @@ public:
   std::vector<std::shared_ptr<FanCurve>>
   DeserializeFanCurves(std::vector<std::shared_ptr<Sensor>> availableSensors,
                        std::vector<std::shared_ptr<Fan>> availableFans);
+  std::shared_ptr<Settings> DeserializeSettings();
 
 private:
   void WriteJson(json o);

app/include/Settings.h

@@ -0,0 +1,17 @@
+#ifndef SETTINGS_H_
+#define SETTINGS_H_
+
+#define FREQUENCY_DEFAULT 1
+
+class Settings {
+public:
+  Settings(int frequency);
+
+  int Frequency() const;
+
+private:
+  void LogSettings();
+  int mFrequency;
+};
+
+#endif // SETTINGS_H_

app/include/fan/Fan.h

@@ -18,6 +18,7 @@ public:
   virtual int StartPWM() = 0;
 
   virtual void FindPWMLimits() = 0;
+  virtual void AdjustPWMLimits() = 0;
 };
 
 #endif // FAN_H_

app/include/fan/HwmonFan.h

@@ -1,9 +1,11 @@
 #ifndef HWMONFAN_H_
 #define HWMONFAN_H_
 
-#include <boost/json/object.hpp>
+#include <chrono>
 #include <memory>
 
+#include <boost/json/object.hpp>
+
 #include <fan/Fan.h>
 #include <pwm/PWMControl.h>
 #include <sensor/Sensor.h>
@@ -25,6 +27,7 @@ public:
   int StartPWM() override;
 
   void FindPWMLimits() override;
+  void AdjustPWMLimits() override;
 
   json toJson() const override;
 
@@ -37,6 +40,7 @@ private:
 
   int mMinPWM;
   int mStartPWM;
+  std::chrono::time_point<std::chrono::steady_clock> mLastAdjustmentTime;
 };
 
 #endif // HWMONFAN_H_

app/src/App.cxx

@@ -10,7 +10,9 @@ void App::Init() {
   auto fanCurves = mSerializer.DeserializeFanCurves(
       mSensorManager.TemperatureSensors(), mFans);
 
-  mController = make_unique<Controller>(fanCurves);
+  mSettings = mSerializer.DeserializeSettings();
+
+  mController = make_unique<Controller>(mSettings, fanCurves);
 }
 
 void App::InitialSetup() {
@@ -33,6 +35,7 @@ void App::NormalOperation() {
 }
 
 void App::Shutdown() {
-  mController.reset();
   mSerializer.SerializeFans(mFans);
+  mFans.clear();
+  mController.reset();
 }

app/src/Controller.cxx

@@ -6,10 +6,10 @@
 
 using namespace std;
 
-#define TIMEOUT 500
-
-Controller::Controller(vector<shared_ptr<FanCurve>> curves)
-    : mFanCurves(curves), mRun(false) {}
+Controller::Controller(shared_ptr<Settings> settings,
+                       vector<shared_ptr<FanCurve>> curves)
+    : mTimeout((1 / settings->Frequency()) * 1000), mFanCurves(curves),
+      mRun(false) {}
 
 Controller::~Controller() { StopFanControlLoop(); }
 
@@ -32,6 +32,6 @@ void Controller::Loop() {
       c->DoFanControl();
     }
 
-    this_thread::sleep_for(chrono::milliseconds(TIMEOUT));
+    this_thread::sleep_for(chrono::milliseconds(mTimeout));
   }
 }

app/src/Serializer.cxx

@@ -1,5 +1,4 @@
-#include "fan/FanCurve.h"
-#include "sensor/Sensor.h"
+#include "Settings.h"
 #include <filesystem>
 #include <fstream>
 #include <iostream>
@@ -124,3 +123,18 @@ vector<shared_ptr<FanCurve>> Serializer::DeserializeFanCurves(
 
   return curves;
 }
+
+shared_ptr<Settings> Serializer::DeserializeSettings() {
+  int frequency = FREQUENCY_DEFAULT;
+
+  auto data = ReadJson();
+
+  if (data.contains("settings")) {
+    auto items = data["settings"];
+
+    if (items.contains("frequency"))
+      frequency = items["frequency"];
+  }
+
+  return make_shared<Settings>(frequency);
+}

app/src/Settings.cxx

@@ -0,0 +1,17 @@
+#include <iostream>
+
+#include <boost/log/attributes/named_scope.hpp>
+#include <boost/log/trivial.hpp>
+
+#include <Settings.h>
+
+Settings::Settings(int frequency) : mFrequency(frequency) { LogSettings(); }
+
+int Settings::Frequency() const { return mFrequency; }
+
+void Settings::LogSettings() {
+  BOOST_LOG_FUNCTION();
+
+  BOOST_LOG_TRIVIAL(info) << "### Settings";
+  BOOST_LOG_TRIVIAL(info) << "Frequency: " << mFrequency << "Hz";
+}

app/src/fan/FanCurve.cxx

@@ -1,10 +1,9 @@
-#include <boost/log/attributes/named_scope.hpp>
-#include <iostream>
-
-#include <boost/log/trivial.hpp>
-
 #include <fan/FanCurve.h>
 
+#include <boost/log/attributes/named_scope.hpp>
+#include <boost/log/trivial.hpp>
+#include <sstream>
+
 using namespace std;
 
 FanCurve::FanCurve(std::vector<FanStep> steps,
@@ -44,9 +43,7 @@ void FanCurve::DoFanControl() {
     if (f->RPM() <= 0) {
       BOOST_LOG_TRIVIAL(warning) << "Fan stopped completely!";
       f->PWM(f->StartPWM());
-
-      BOOST_LOG_TRIVIAL(info) << "Adjusting minPWM of fan " << f->toString();
-      f->MinPWM(f->MinPWM() + 2);
+      f->AdjustPWMLimits();
     } else {
       f->PWM(targetFanPower);
     }

app/src/fan/HwmonFan.cxx

@@ -1,13 +1,15 @@
-#include <chrono>
 #include <iostream>
 #include <ostream>
 #include <thread>
 
-#include "pwm/PWMControl.h"
-#include <boost/json/object.hpp>
+#include <boost/log/attributes/named_scope.hpp>
+#include <boost/log/trivial.hpp>
+
 #include <fan/HwmonFan.h>
+#include <pwm/PWMControl.h>
 
 #define TIMEOUT 10
+#define STEP 2
 
 using namespace std;
 
@@ -33,22 +35,22 @@ void HwmonFan::MinPWM(int value) { mMinPWM = value; }
 
 int HwmonFan::MinPWM() { return mMinPWM; }
 
-int HwmonFan::StartPWM() { return mStartPWM; }
-
 void HwmonFan::StartPWM(int value) { mStartPWM = value; }
 
+int HwmonFan::StartPWM() { return mStartPWM; }
+
 void HwmonFan::FindPWMLimits() {
   cout << "Looking for minimal PWM" << endl;
   int minPWM = 0;
   mMinPWM = 0;
   mStartPWM = 0;
 
-  for (int curPWM = 100; curPWM > 0; curPWM -= 5) {
+  for (int curPWM = 100; curPWM > 0; curPWM -= STEP) {
     PWM(curPWM);
     this_thread::sleep_for(chrono::seconds(TIMEOUT));
 
     if (RPM() <= 0) {
-      minPWM = curPWM + 5;
+      minPWM = curPWM + STEP;
       break;
     }
   }
@@ -62,7 +64,7 @@ void HwmonFan::FindPWMLimits() {
     int startPWM = 0;
 
     cout << "Looking for start PWM!" << endl;
-    for (int curPWM = minPWM - 5; curPWM < 100; curPWM += 5) {
+    for (int curPWM = minPWM - STEP; curPWM < 100; curPWM += STEP) {
       PWM(curPWM);
       this_thread::sleep_for(chrono::seconds(TIMEOUT));
 
@@ -77,6 +79,20 @@ void HwmonFan::FindPWMLimits() {
   }
 }
 
+void HwmonFan::AdjustPWMLimits() {
+  BOOST_LOG_FUNCTION()
+
+  chrono::time_point now = chrono::steady_clock::now();
+
+  if ((now - mLastAdjustmentTime) >
+      chrono::duration(chrono::seconds(TIMEOUT))) {
+    BOOST_LOG_TRIVIAL(info) << "Increasing minimal fan speed";
+
+    mLastAdjustmentTime = now;
+    mMinPWM += 2;
+  }
+}
+
 json HwmonFan::toJson() const {
   json obj;
   obj = {mPWMControl->toJson(),

app/src/main.cxx

@@ -1,4 +1,3 @@
-#include <boost/log/expressions/formatters/named_scope.hpp>
 #include <csignal>
 #include <iostream>
 
@@ -6,6 +5,7 @@
 #include <boost/log/attributes/named_scope.hpp>
 #include <boost/log/core.hpp>
 #include <boost/log/expressions.hpp>
+#include <boost/log/expressions/formatters/named_scope.hpp>
 #include <boost/log/expressions/message.hpp>
 #include <boost/log/support/date_time.hpp>
 #include <boost/log/trivial.hpp>
@@ -20,6 +20,8 @@
 
 #include <App.h>
 
+#define PROJECT_VERSION "v0.1.6"
+
 namespace po = boost::program_options;
 namespace logging = boost::log;
 
@@ -59,7 +61,11 @@ void InitLogging(bool verbose) {
 }
 
 int main(int argc, char **argv) {
+  BOOST_LOG_FUNCTION()
+  BOOST_LOG_TRIVIAL(info) << "Version: " << PROJECT_VERSION;
+
   signal(SIGINT, signal_handler);
+  signal(SIGTERM, signal_handler);
 
   po::options_description desc("Allowed options");
   desc.add_options()("help,h", "produce help message")(

app/src/sensor/NvidiaSensor.cxx

@@ -1,8 +1,10 @@
-#include <boost/json/object.hpp>
-#include <include/nvml.h>
+#ifdef HAVE_NVML
 
+#include <include/nvml.h>
 #include <sensor/NvidiaSensor.h>
 
+#include <boost/json/object.hpp>
+
 using namespace std;
 
 NvidiaSensor::NvidiaSensor() { nvmlInit_v2(); }
@@ -25,3 +27,5 @@ json NvidiaSensor::toJson() const {
   json obj = {"NvidiaSensor", toString()};
   return obj;
 }
+
+#endif

app/src/sensor/SensorManager.cxx

@@ -3,20 +3,26 @@
 using namespace std;
 
 SensorManager::SensorManager()
-    : mLMSensorsFacade(make_unique<LMSensorsFacade>()),
-      mGPUSensorsFacade(make_unique<GPUSensorsFacade>()) {}
-
-vector<shared_ptr<Sensor>> SensorManager::TemperatureSensors() {
-  vector<shared_ptr<Sensor>> tempSensors;
-
-  tempSensors = mLMSensorsFacade->TemperatureSensors();
-
-  auto gpuSensors = mGPUSensorsFacade->TemperatureSensors();
-  tempSensors.insert(tempSensors.end(), gpuSensors.begin(), gpuSensors.end());
-
-  return tempSensors;
+    : mLMSensorsFacade(make_unique<LMSensorsFacade>())
+    , mGPUSensorsFacade(make_unique<GPUSensorsFacade>())
+{
 }
 
-vector<shared_ptr<Sensor>> SensorManager::RPMSensors() {
-  return mLMSensorsFacade->RPMSensors();
+vector<shared_ptr<Sensor>> SensorManager::TemperatureSensors()
+{
+    vector<shared_ptr<Sensor>> tempSensors;
+
+    tempSensors = mLMSensorsFacade->TemperatureSensors();
+
+#ifdef HAVE_NVML
+    auto gpuSensors = mGPUSensorsFacade->TemperatureSensors();
+    tempSensors.insert(tempSensors.end(), gpuSensors.begin(), gpuSensors.end());
+#endif
+
+    return tempSensors;
+}
+
+vector<shared_ptr<Sensor>> SensorManager::RPMSensors()
+{
+    return mLMSensorsFacade->RPMSensors();
 }