tlbmc/thermal/controller_info/controller_info.cc

#include "tlbmc/thermal/controller_info/controller_info.h"

#include <string>
#include <vector>

#include "absl/base/nullability.h"
#include "absl/strings/string_view.h"
#include "absl/synchronization/mutex.h"
#include "tlbmc/thermal/controller/controller.h"
#include "tlbmc/thermal/thermal_control_utils.h"

namespace milotic_tlbmc {
namespace thermal {

void ControllerInfo::AddThermalController(
    absl::string_view controller_name,
    ThermalController* absl_nonnull controller, bool is_enabled) {
  {
    absl::MutexLock lock(name_to_info_mutex_);
    auto& thermal_controller_info = name_to_info_[controller_name];
    thermal_controller_info.thermal_controller = controller;
    thermal_controller_info.is_enabled = is_enabled;
  }
  {
    absl::MutexLock lock(controllers_mutex_);
    controller_names_.push_back(std::string(controller_name));
    controllers_.push_back(controller);
  }
}

void ControllerInfo::SetThermalControllerEnabled(
    absl::string_view controller_name, bool is_enabled) {
  absl::MutexLock lock(name_to_info_mutex_);
  if (!name_to_info_.contains(controller_name)) {
    return;
  }
  name_to_info_[controller_name].is_enabled = is_enabled;
}

void ControllerInfo::SetThermalControllerSetpoint(
    absl::string_view controller_name, double setpoint) {
  absl::MutexLock lock(name_to_info_mutex_);
  if (!name_to_info_.contains(controller_name)) {
    return;
  }
  name_to_info_[controller_name].setpoint = setpoint;
}

double ControllerInfo::GetThermalControllerSetpoint(
    absl::string_view controller_name) {
  absl::MutexLock lock(name_to_info_mutex_);
  if (!name_to_info_.contains(controller_name)) {
    return kDefaultSetpointValue;
  }
  return name_to_info_[controller_name].setpoint;
}

std::vector<std::string> ControllerInfo::GetControllerNames(
    ThreadSafetyMode thread_safety_mode) {
  if (thread_safety_mode == ThreadSafetyMode::EnforceThreadSafety) {
    absl::MutexLock lock(controllers_mutex_);
    return controller_names_;
  }
  return controller_names_;
}

bool ControllerInfo::IsControllerEnabled(absl::string_view controller_name,
                                         ThreadSafetyMode thread_safety_mode) {
  if (thread_safety_mode == ThreadSafetyMode::EnforceThreadSafety) {
    absl::MutexLock lock(name_to_info_mutex_);
    auto it = name_to_info_.find(controller_name);
    return it != name_to_info_.end() ? it->second.is_enabled : false;
  }
  auto it = name_to_info_.find(controller_name);
  return it != name_to_info_.end() ? it->second.is_enabled : false;
}

std::vector<ThermalController*> ControllerInfo::GetAllThermalControllers(
    ThreadSafetyMode thread_safety_mode) {
  if (thread_safety_mode == ThreadSafetyMode::EnforceThreadSafety) {
    absl::MutexLock lock(controllers_mutex_);
    std::vector<ThermalController*> thermal_controllers;
    for (ThermalController* controller : controllers_) {
      if (controller != nullptr && !controller->IsFanController()) {
        thermal_controllers.push_back(controller);
      }
    }
    return thermal_controllers;
  }
  std::vector<ThermalController*> thermal_controllers;
  for (ThermalController* controller : controllers_) {
    if (controller != nullptr && !controller->IsFanController()) {
      thermal_controllers.push_back(controller);
    }
  }
  return thermal_controllers;
}

std::vector<ThermalController*> ControllerInfo::GetAllFanControllers(
    ThreadSafetyMode thread_safety_mode) {
  if (thread_safety_mode == ThreadSafetyMode::EnforceThreadSafety) {
    absl::MutexLock lock(controllers_mutex_);
    std::vector<ThermalController*> fan_controllers;
    for (ThermalController* controller : controllers_) {
      if (controller != nullptr && controller->IsFanController()) {
        fan_controllers.push_back(controller);
      }
    }
    return fan_controllers;
  }
  std::vector<ThermalController*> fan_controllers;
  for (ThermalController* controller : controllers_) {
    if (controller != nullptr && controller->IsFanController()) {
      fan_controllers.push_back(controller);
    }
  }
  return fan_controllers;
}

ThermalController* ControllerInfo::GetThermalController(
    absl::string_view controller_name, ThreadSafetyMode thread_safety_mode) {
  if (thread_safety_mode == ThreadSafetyMode::EnforceThreadSafety) {
    absl::MutexLock lock(name_to_info_mutex_);
    auto it = name_to_info_.find(controller_name);
    return it != name_to_info_.end() ? it->second.thermal_controller : nullptr;
  }
  auto it = name_to_info_.find(controller_name);
  return it != name_to_info_.end() ? it->second.thermal_controller : nullptr;
}

void ControllerInfo::Clear() {
  absl::MutexLock lock(name_to_info_mutex_);
  for (auto& [name, controller_info] : name_to_info_) {
    controller_info.setpoint = kDefaultSetpointValue;
  }
}

}  // namespace thermal
}  // namespace milotic_tlbmc