Add handling for missing nvml lib

PKGBUILD

@@ -1,5 +1,5 @@
 pkgname=fantasize
-pkgver=0.1.9
+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,25 +1,38 @@
 cmake_minimum_required(VERSION 3.0)
 
-project(fantasize VERSION 0.1.8)
+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.74 COMPONENTS program_options log log_setup date_time 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
   src/fan/HwmonFan.cxx
   src/fan/FanCurve.cxx
   src/fan/FanLabeler.cxx
-  src/fan/Aggregators.cxx
   src/FanGenerator.cxx
   src/Serializer.cxx
   src/sensor/SensorManager.cxx
@@ -31,7 +44,8 @@ add_executable(${PROJECT_NAME}
 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/Serializer.h

@@ -7,7 +7,6 @@
 #include <nlohmann/json.hpp>
 
 #include <Settings.h>
-#include <fan/Aggregators.h>
 #include <fan/Fan.h>
 #include <fan/FanCurve.h>
 #include <sensor/Sensor.h>
@@ -17,22 +16,20 @@
 
 using json = nlohmann::json;
 
-class Serializer
+class Serializer {
-{
 public:
   Serializer();
   void SerializeFans(std::vector<std::shared_ptr<Fan>> fans);
-  std::vector<std::shared_ptr<Fan>> DeserializeFans(
+  std::vector<std::shared_ptr<Fan>>
-    std::vector<std::shared_ptr<Sensor>> availableSensors);
+  DeserializeFans(std::vector<std::shared_ptr<Sensor>> availableSensors);
-  std::vector<std::shared_ptr<FanCurve>> DeserializeFanCurves(
+  std::vector<std::shared_ptr<FanCurve>>
-    std::vector<std::shared_ptr<Sensor>> availableSensors,
+  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);
   json ReadJson();
-  std::unique_ptr<Aggregator> aggregatorFromString(std::string str) const;
 };
 
 #endif // SERIALIZER_H_

app/include/fan/Aggregators.h

@@ -1,27 +0,0 @@
-#ifndef AGGREGATORS_H_
-#define AGGREGATORS_H_
-
-#include <sensor/Sensor.h>
-
-class Aggregator
-{
-public:
-  virtual int aggregate(std::vector<std::shared_ptr<Sensor>> sensors) const = 0;
-  virtual const std::string toString() const = 0;
-};
-
-class AverageAggregator : public Aggregator
-{
-public:
-  int aggregate(std::vector<std::shared_ptr<Sensor>> sensors) const override;
-  const std::string toString() const override;
-};
-
-class MaxAggregator : public Aggregator
-{
-public:
-  int aggregate(std::vector<std::shared_ptr<Sensor>> sensors) const override;
-  const std::string toString() const override;
-};
-
-#endif // AGGERGATORS_H_

app/include/fan/FanCurve.h

@@ -4,23 +4,19 @@
 #include <memory>
 #include <vector>
 
-#include <fan/Aggregators.h>
 #include <fan/HwmonFan.h>
 #include <sensor/Sensor.h>
 
-struct FanStep
+struct FanStep {
-{
   int Temp;
   int Percent;
 };
 
-class FanCurve
+class FanCurve {
-{
 public:
   FanCurve(std::vector<FanStep> steps,
            std::vector<std::shared_ptr<Sensor>> sensors,
-           std::vector<std::shared_ptr<Fan>> fans,
+           std::vector<std::shared_ptr<Fan>> fans);
-           std::unique_ptr<Aggregator> aggregator);
 
   void DoFanControl();
 
@@ -31,7 +27,6 @@ private:
   std::vector<FanStep> mSteps;
   std::vector<std::shared_ptr<Sensor>> mTempSensors;
   std::vector<std::shared_ptr<Fan>> mFans;
-  std::unique_ptr<Aggregator> mAggregator;
 };
 
 #endif // FANCURVE_H_

app/include/fan/HwmonFan.h

@@ -4,6 +4,8 @@
 #include <chrono>
 #include <memory>
 
+#include <boost/json/object.hpp>
+
 #include <fan/Fan.h>
 #include <pwm/PWMControl.h>
 #include <sensor/Sensor.h>

app/include/pwm/PWMControl.h

@@ -1,6 +1,7 @@
 #ifndef PWMCONTROL_H_
 #define PWMCONTROL_H_
 
+#include <boost/json/object.hpp>
 #include <string>
 
 #include <Printable.h>

app/src/Serializer.cxx

@@ -1,3 +1,4 @@
+#include "Settings.h"
 #include <filesystem>
 #include <fstream>
 #include <iostream>
@@ -8,21 +9,17 @@
 #include <fan/HwmonFan.h>
 #include <pwm/PWMControl.h>
 #include <sensor/LMSensor.h>
-#include <string>
 
 using namespace std;
 namespace fs = filesystem;
 
-Serializer::Serializer()
+Serializer::Serializer() {
-{
   if (!fs::exists(SERIALIZATION_DIR)) {
     fs::create_directory(SERIALIZATION_DIR);
   }
 }
 
-void
+void Serializer::SerializeFans(vector<shared_ptr<Fan>> fans) {
-Serializer::SerializeFans(vector<shared_ptr<Fan>> fans)
-{
   json obj;
 
   for (auto f : fans) {
@@ -33,8 +30,7 @@ Serializer::SerializeFans(vector<shared_ptr<Fan>> fans)
 }
 
 vector<shared_ptr<Fan>>
-Serializer::DeserializeFans(vector<shared_ptr<Sensor>> availableSensors)
+Serializer::DeserializeFans(vector<shared_ptr<Sensor>> availableSensors) {
-{
   vector<shared_ptr<Fan>> fans;
 
   // Create a for the sensors first, then searching becomes cheaper
@@ -66,9 +62,7 @@ Serializer::DeserializeFans(vector<shared_ptr<Sensor>> availableSensors)
   return fans;
 }
 
-void
+void Serializer::WriteJson(json o) {
-Serializer::WriteJson(json o)
-{
   json obj;
 
   if (fs::exists(fs::path(SERIALIZATION_DIR) / FANS_JSON_FILENAME)) {
@@ -83,18 +77,14 @@ Serializer::WriteJson(json o)
   ostrm << obj.dump(2) << "\n";
 }
 
-json
+json Serializer::ReadJson() {
-Serializer::ReadJson()
-{
   ifstream istrm(fs::path(SERIALIZATION_DIR) / FANS_JSON_FILENAME);
   return json::parse(istrm);
 }
 
-vector<shared_ptr<FanCurve>>
+vector<shared_ptr<FanCurve>> Serializer::DeserializeFanCurves(
-Serializer::DeserializeFanCurves(
     std::vector<std::shared_ptr<Sensor>> availableSensors,
-  std::vector<std::shared_ptr<Fan>> availableFans)
+    std::vector<std::shared_ptr<Fan>> availableFans) {
-{
   auto data = ReadJson();
 
   map<string, shared_ptr<Sensor>> sensorMap;
@@ -128,28 +118,13 @@ Serializer::DeserializeFanCurves(
         fans.push_back(fanMap[fan.value()]);
     }
 
-    std::unique_ptr<Aggregator> aggregator =
+    curves.push_back(make_shared<FanCurve>(steps, sensors, fans));
-      aggregatorFromString(el.value()["AggregateFunction"]);
-
-    curves.push_back(
-      make_shared<FanCurve>(steps, sensors, fans, std::move(aggregator)));
   }
 
   return curves;
 }
 
-std::unique_ptr<Aggregator>
+shared_ptr<Settings> Serializer::DeserializeSettings() {
-Serializer::aggregatorFromString(std::string str) const
-{
-  if (str == "max")
-    return std::make_unique<MaxAggregator>();
-  else
-    return std::make_unique<AverageAggregator>();
-}
-
-shared_ptr<Settings>
-Serializer::DeserializeSettings()
-{
   int frequency = FREQUENCY_DEFAULT;
 
   auto data = ReadJson();

app/src/fan/Aggregators.cxx

@@ -1,39 +0,0 @@
-#include <climits>
-#include <fan/Aggregators.h>
-
-int
-AverageAggregator::aggregate(std::vector<std::shared_ptr<Sensor>> sensors) const
-{
-  int sum = 0;
-
-  for (auto sensor : sensors) {
-    sum += sensor->value();
-  }
-
-  return sum / sensors.size();
-}
-
-const std::string
-AverageAggregator::toString() const
-{
-  return "Average";
-}
-
-int
-MaxAggregator::aggregate(std::vector<std::shared_ptr<Sensor>> sensors) const
-{
-  int max = INT_MIN;
-
-  for (auto sensor : sensors) {
-    if (sensor->value() > max)
-      max = sensor->value();
-  }
-
-  return max;
-}
-
-const std::string
-MaxAggregator::toString() const
-{
-  return "Max";
-}

app/src/fan/FanCurve.cxx

@@ -1,28 +1,19 @@
-#include <boost/log/attributes/named_scope.hpp>
-#include <iostream>
-
-#include <boost/log/trivial.hpp>
-
 #include <fan/FanCurve.h>
-#include <memory>
+
+#include <boost/log/attributes/named_scope.hpp>
+#include <boost/log/trivial.hpp>
+#include <sstream>
 
 using namespace std;
 
 FanCurve::FanCurve(std::vector<FanStep> steps,
                    std::vector<std::shared_ptr<Sensor>> sensors,
-                   std::vector<std::shared_ptr<Fan>> fans,
+                   std::vector<std::shared_ptr<Fan>> fans)
-                   std::unique_ptr<Aggregator> aggregator)
+    : mSteps(steps), mTempSensors(sensors), mFans(fans) {
-  : mSteps(steps)
-  , mTempSensors(sensors)
-  , mFans(fans)
-  , mAggregator(std::move(aggregator))
-{
   PrintInfo();
 }
 
-void
+void FanCurve::DoFanControl() {
-FanCurve::DoFanControl()
-{
   BOOST_LOG_FUNCTION();
 
   int temp = AggregateTemperature();
@@ -59,15 +50,17 @@ FanCurve::DoFanControl()
   }
 }
 
-int
+// Dummy Implementation using AVG
-FanCurve::AggregateTemperature()
+int FanCurve::AggregateTemperature() {
-{
+  int sum = 0;
-  return mAggregator->aggregate(mTempSensors);
+  for (auto s : mTempSensors) {
+    sum += s->value();
   }
 
-void
+  return sum / mTempSensors.size();
-FanCurve::PrintInfo()
+}
-{
+
+void FanCurve::PrintInfo() {
   BOOST_LOG_FUNCTION()
 
   BOOST_LOG_TRIVIAL(info) << "### Fan curve:";
@@ -96,10 +89,4 @@ FanCurve::PrintInfo()
   }
 
   BOOST_LOG_TRIVIAL(info) << sStream.str();
-
-  sStream.str(string());
-
-  sStream << "Aggregate function: " << mAggregator->toString();
-
-  BOOST_LOG_TRIVIAL(info) << sStream.str();
 }

app/src/main.cxx

@@ -20,7 +20,7 @@
 
 #include <App.h>
 
-#define PROJECT_VERSION "v0.1.9"
+#define PROJECT_VERSION "v0.1.6"
 
 namespace po = boost::program_options;
 namespace logging = boost::log;
@@ -29,15 +29,9 @@ App app;
 
 static int doInitialSetup = 0;
 
-void
+void signal_handler(int s) { app.Shutdown(); }
-signal_handler(int s)
-{
-  app.Shutdown();
-}
 
-void
+void InitLogging(bool verbose) {
-InitLogging(bool verbose)
-{
   logging::add_console_log(
       std::clog,
       logging::keywords::format =
@@ -66,9 +60,7 @@ InitLogging(bool verbose)
   }
 }
 
-int
+int main(int argc, char **argv) {
-main(int argc, char** argv)
-{
   BOOST_LOG_FUNCTION()
   BOOST_LOG_TRIVIAL(info) << "Version: " << PROJECT_VERSION;
 
@@ -77,8 +69,8 @@ main(int argc, char** argv)
 
   po::options_description desc("Allowed options");
   desc.add_options()("help,h", "produce help message")(
-    "setup,s", po::bool_switch(), "run initial setup")(
+      "setup,s", po::bool_switch(),
-    "verbose,v", po::bool_switch(), "print debug info");
+      "run initial setup")("verbose,v", po::bool_switch(), "print debug info");
 
   po::variables_map vm;
   po::store(po::parse_command_line(argc, argv, desc), vm);

app/src/pwm/PWMControl.cxx

@@ -15,9 +15,7 @@
 using namespace std;
 namespace fs = filesystem;
 
-PWMControl::PWMControl(string controlPath)
+PWMControl::PWMControl(string controlPath) : mControlPath(controlPath) {
-  : mControlPath(controlPath)
-{
   fs::path pathEnable(mControlPath + PWM_POSTFIX_ENABLE);
   fs::path pathMode(mControlPath + PWM_POSTFIX_MODE);
 
@@ -37,24 +35,21 @@ PWMControl::PWMControl(string controlPath)
   istrm.close();
 }
 
-PWMControl::~PWMControl()
+PWMControl::~PWMControl() {
-{
   BOOST_LOG_FUNCTION();
 
   BOOST_LOG_TRIVIAL(trace) << "Cleanup";
   Reset();
 }
 
-void
+void PWMControl::Power(int percent) {
-PWMControl::Power(int percent)
-{
   BOOST_LOG_FUNCTION();
 
   int pwmValue = (PWM_MAX_VALUE * percent) / 100;
 
   if (percent != mCurrentValue) {
-    BOOST_LOG_TRIVIAL(trace) << "Updating control value of " << toString()
+    BOOST_LOG_TRIVIAL(trace)
-                             << " to " << percent << "% (" << pwmValue << ")";
+        << "Updating control value to " << percent << "% (" << pwmValue << ")";
     ofstream ostrm(mControlPath, ios::trunc);
     ostrm << pwmValue;
     ostrm.close();
@@ -63,9 +58,7 @@ PWMControl::Power(int percent)
   }
 }
 
-int
+int PWMControl::Power() {
-PWMControl::Power()
-{
   int value;
   ifstream istrm;
 
@@ -75,17 +68,13 @@ PWMControl::Power()
   return (value * 100) / PWM_MAX_VALUE;
 }
 
-void
+void PWMControl::EnableManualControl() {
-PWMControl::EnableManualControl()
-{
   ofstream ostrm(mEnablePath, ios::trunc);
   ostrm << static_cast<int>(PWM_ENABLE::MANUAL_CONTROL);
   ostrm.close();
 }
 
-void
+void PWMControl::Reset() {
-PWMControl::Reset()
-{
   ofstream ostrm(mEnablePath, ios::trunc);
 
   ostrm << mInitialEnable;
@@ -97,15 +86,11 @@ PWMControl::Reset()
   ostrm.close();
 }
 
-const string
+const string PWMControl::toString() const {
-PWMControl::toString() const
-{
   return fs::path(mControlPath).filename();
 }
 
-json
+json PWMControl::toJson() const {
-PWMControl::toJson() const
-{
   json obj = {"PWMControl", mControlPath};
   return obj;
 }

app/src/sensor/NvidiaSensor.cxx

@@ -1,7 +1,10 @@
-#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(); }
@@ -24,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>()),
+    : mLMSensorsFacade(make_unique<LMSensorsFacade>())
-      mGPUSensorsFacade(make_unique<GPUSensorsFacade>()) {}
+    , mGPUSensorsFacade(make_unique<GPUSensorsFacade>())
+{
+}
 
-vector<shared_ptr<Sensor>> SensorManager::TemperatureSensors() {
+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() {
+vector<shared_ptr<Sensor>> SensorManager::RPMSensors()
+{
     return mLMSensorsFacade->RPMSensors();
 }

app/unit/fantasize.service

@@ -7,4 +7,4 @@ ExecStart=/usr/local/bin/fantasize
 Restart=always
 
 [Install]
-WantedBy=graphical.target
+WantedBy=multi-user.target