Remove NVIDIA stuff

PKGBUILD

@@ -1,12 +1,12 @@
 pkgname=fantasize
-pkgver=0.1.8
+pkgver=0.2.0
 pkgrel=1
 pkgdesc='C++ fan control for Linux'
 url='https://github.com/Tabascl/fantasize.git'
 source=("$pkgname-$pkgver.tar.gz::https://github.com/Tabascl/fantasize/archive/refs/tags/v$pkgver.tar.gz")
 arch=('x86_64')
 license=('GPL3')
-makedepends=('git' 'cmake' 'nlohmann-json' 'boost' 'cuda')
+makedepends=('git' 'cmake' 'nlohmann-json' 'boost')
 sha256sums=('SKIP')
 
 build() {

app/CMakeLists.txt

@@ -10,15 +10,16 @@ find_package(Boost 1.74 COMPONENTS program_options log log_setup date_time REQUI
 add_executable(${PROJECT_NAME}
   src/main.cxx
   src/sensor/LMSensorsFacade.cxx
-  src/sensor/GPUSensorsFacade.cxx
+#  src/sensor/GPUSensorsFacade.cxx
   src/sensor/Sensor.cxx
-  src/sensor/NvidiaSensor.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
@@ -29,8 +30,10 @@ add_executable(${PROJECT_NAME}
 
 set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 20)
 
-target_include_directories(${PROJECT_NAME} PUBLIC include /opt/cuda)
+# 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_include_directories(${PROJECT_NAME} PUBLIC include)
+# 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})
 
 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,6 +7,7 @@
 #include <nlohmann/json.hpp>
 
 #include <Settings.h>
+#include <fan/Aggregators.h>
 #include <fan/Fan.h>
 #include <fan/FanCurve.h>
 #include <sensor/Sensor.h>
@@ -16,20 +17,22 @@
 
 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>>
+  std::vector<std::shared_ptr<Fan>> DeserializeFans(
-  DeserializeFans(std::vector<std::shared_ptr<Sensor>> availableSensors);
+    std::vector<std::shared_ptr<Sensor>> availableSensors);
-  std::vector<std::shared_ptr<FanCurve>>
+  std::vector<std::shared_ptr<FanCurve>> DeserializeFanCurves(
-  DeserializeFanCurves(std::vector<std::shared_ptr<Sensor>> availableSensors,
+    std::vector<std::shared_ptr<Sensor>> availableSensors,
-                       std::vector<std::shared_ptr<Fan>> availableFans);
+    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

@@ -0,0 +1,27 @@
+#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,19 +4,23 @@
 #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();
 
@@ -27,6 +31,7 @@ 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/src/Serializer.cxx

@@ -1,4 +1,3 @@
-#include "Settings.h"
 #include <filesystem>
 #include <fstream>
 #include <iostream>
@@ -9,17 +8,21 @@
 #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 Serializer::SerializeFans(vector<shared_ptr<Fan>> fans) {
+void
+Serializer::SerializeFans(vector<shared_ptr<Fan>> fans)
+{
   json obj;
 
   for (auto f : fans) {
@@ -30,7 +33,8 @@ void 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
@@ -41,7 +45,7 @@ Serializer::DeserializeFans(vector<shared_ptr<Sensor>> availableSensors) {
 
   auto data = ReadJson();
   try {
-    for (auto &el : data["fans"].items()) {
+    for (auto& el : data["fans"].items()) {
       auto pwmControl = make_shared<PWMControl>(el.value()["PWMControl"]);
       auto rpmSensor = sensorMap[el.value()["LMSensor"]];
 
@@ -56,20 +60,22 @@ Serializer::DeserializeFans(vector<shared_ptr<Sensor>> availableSensors) {
 
       fans.push_back(fan);
     }
-  } catch (const std::exception &e) {
+  } catch (const std::exception& e) {
     std::cout << "Deserialization error! Message: " << e.what() << std::endl;
   }
   return fans;
 }
 
-void Serializer::WriteJson(json o) {
+void
+Serializer::WriteJson(json o)
+{
   json obj;
 
   if (fs::exists(fs::path(SERIALIZATION_DIR) / FANS_JSON_FILENAME)) {
     obj = ReadJson();
   }
 
-  for (auto &[key, value] : o.items()) {
+  for (auto& [key, value] : o.items()) {
     obj[key] = value;
   }
 
@@ -77,14 +83,18 @@ void Serializer::WriteJson(json o) {
   ostrm << obj.dump(2) << "\n";
 }
 
-json Serializer::ReadJson() {
+json
+Serializer::ReadJson()
+{
   ifstream istrm(fs::path(SERIALIZATION_DIR) / FANS_JSON_FILENAME);
   return json::parse(istrm);
 }
 
-vector<shared_ptr<FanCurve>> Serializer::DeserializeFanCurves(
+vector<shared_ptr<FanCurve>>
-    std::vector<std::shared_ptr<Sensor>> availableSensors,
+Serializer::DeserializeFanCurves(
-    std::vector<std::shared_ptr<Fan>> availableFans) {
+  std::vector<std::shared_ptr<Sensor>> availableSensors,
+  std::vector<std::shared_ptr<Fan>> availableFans)
+{
   auto data = ReadJson();
 
   map<string, shared_ptr<Sensor>> sensorMap;
@@ -99,32 +109,47 @@ vector<shared_ptr<FanCurve>> Serializer::DeserializeFanCurves(
 
   vector<shared_ptr<FanCurve>> curves;
 
-  for (auto &el : data["fancurves"].items()) {
+  for (auto& el : data["fancurves"].items()) {
     vector<FanStep> steps;
     vector<shared_ptr<Sensor>> sensors;
     vector<shared_ptr<Fan>> fans;
 
-    for (auto &step : el.value()["FanSteps"].items()) {
+    for (auto& step : el.value()["FanSteps"].items()) {
-      steps.push_back(FanStep{step.value()[0], step.value()[1]});
+      steps.push_back(FanStep{ step.value()[0], step.value()[1] });
     }
 
-    for (auto &sensor : el.value()["Sensors"].items()) {
+    for (auto& sensor : el.value()["Sensors"].items()) {
       if (sensorMap.contains(sensor.value()))
         sensors.push_back(sensorMap[sensor.value()]);
     }
 
-    for (auto &fan : el.value()["Fans"].items()) {
+    for (auto& fan : el.value()["Fans"].items()) {
       if (fanMap.contains(fan.value()))
         fans.push_back(fanMap[fan.value()]);
     }
 
-    curves.push_back(make_shared<FanCurve>(steps, sensors, fans));
+    std::unique_ptr<Aggregator> aggregator =
+      aggregatorFromString(el.value()["AggregateFunction"]);
+
+    curves.push_back(
+      make_shared<FanCurve>(steps, sensors, fans, std::move(aggregator)));
   }
 
   return curves;
 }
 
-shared_ptr<Settings> Serializer::DeserializeSettings() {
+std::unique_ptr<Aggregator>
+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

@@ -0,0 +1,39 @@
+#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

@@ -4,17 +4,25 @@
 #include <boost/log/trivial.hpp>
 
 #include <fan/FanCurve.h>
+#include <memory>
 
 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,
-    : mSteps(steps), mTempSensors(sensors), mFans(fans) {
+                   std::unique_ptr<Aggregator> aggregator)
+  : mSteps(steps)
+  , mTempSensors(sensors)
+  , mFans(fans)
+  , mAggregator(std::move(aggregator))
+{
   PrintInfo();
 }
 
-void FanCurve::DoFanControl() {
+void
+FanCurve::DoFanControl()
+{
   BOOST_LOG_FUNCTION();
 
   int temp = AggregateTemperature();
@@ -51,17 +59,15 @@ void FanCurve::DoFanControl() {
   }
 }
 
-// Dummy Implementation using AVG
+int
-int FanCurve::AggregateTemperature() {
+FanCurve::AggregateTemperature()
-  int sum = 0;
+{
-  for (auto s : mTempSensors) {
+  return mAggregator->aggregate(mTempSensors);
-    sum += s->value();
-  }
-
-  return sum / mTempSensors.size();
 }
 
-void FanCurve::PrintInfo() {
+void
+FanCurve::PrintInfo()
+{
   BOOST_LOG_FUNCTION()
 
   BOOST_LOG_TRIVIAL(info) << "### Fan curve:";
@@ -90,4 +96,10 @@ void 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.8"
+#define PROJECT_VERSION "v0.2.0"
 
 namespace po = boost::program_options;
 namespace logging = boost::log;

app/src/pwm/PWMControl.cxx

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

app/src/sensor/SensorManager.cxx

@@ -11,8 +11,9 @@ vector<shared_ptr<Sensor>> SensorManager::TemperatureSensors() {
 
   tempSensors = mLMSensorsFacade->TemperatureSensors();
 
-  auto gpuSensors = mGPUSensorsFacade->TemperatureSensors();
+  //   auto gpuSensors = mGPUSensorsFacade->TemperatureSensors();
-  tempSensors.insert(tempSensors.end(), gpuSensors.begin(), gpuSensors.end());
+  //  tempSensors.insert(tempSensors.end(), gpuSensors.begin(),
+  //  gpuSensors.end());
 
   return tempSensors;
 }