Merge pull request #14 from tier4/validation_hardware

feat: validation of hardware information

Author: atsushi421

cie_thread_configurator/CMakeLists.txt

@@ -22,17 +22,17 @@ if(BUILD_TESTING)
   ament_lint_auto_find_test_dependencies()
 endif()
 
+add_library(thread_configurator SHARED src/util.cpp)
+ament_target_dependencies(thread_configurator rclcpp cie_config_msgs)
+
 add_executable(thread_configurator_node src/main.cpp src/thread_configurator_node.cpp src/prerun_node.cpp)
 ament_target_dependencies(thread_configurator_node rclcpp cie_config_msgs)
-target_link_libraries(thread_configurator_node yaml-cpp)
+target_link_libraries(thread_configurator_node yaml-cpp thread_configurator)
 
 target_include_directories(thread_configurator_node PRIVATE
   ${CMAKE_CURRENT_SOURCE_DIR}/include
 )
 
-add_library(thread_configurator SHARED src/util.cpp)
-ament_target_dependencies(thread_configurator rclcpp cie_config_msgs)
-
 target_include_directories(thread_configurator PUBLIC
   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   $<INSTALL_INTERFACE:include>

cie_thread_configurator/include/cie_thread_configurator/cie_thread_configurator.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "rclcpp/rclcpp.hpp"
+#include <map>
 #include <memory>
 #include <string>
 
@@ -26,4 +27,7 @@ void publish_callback_group_info(
         &publisher,
     int64_t tid, const std::string &callback_group_id);
 
+// Get hardware information from lscpu command
+std::map<std::string, std::string> get_hardware_info();
+
 } // namespace cie_thread_configurator

cie_thread_configurator/src/main.cpp

@@ -5,20 +5,73 @@
 #include "rclcpp/rclcpp.hpp"
 #include "yaml-cpp/yaml.h"
 
+#include "cie_thread_configurator/cie_thread_configurator.hpp"
 #include "cie_thread_configurator/prerun_node.hpp"
 #include "cie_thread_configurator/thread_configurator_node.hpp"
 
+static bool validate_hardware_info(const YAML::Node &yaml) {
+  YAML::Node yaml_hw_info = yaml["hardware_info"];
+  auto current_hw_info = cie_thread_configurator::get_hardware_info();
+
+  bool all_match = true;
+  std::vector<std::string> mismatches;
+
+  for (const auto &[key, current_value] : current_hw_info) {
+    if (!yaml_hw_info[key]) {
+      continue;
+    }
+
+    std::string yaml_value = yaml_hw_info[key].as<std::string>();
+    if (yaml_value != current_value) {
+      all_match = false;
+      mismatches.push_back(key + ": expected '" + yaml_value + "', got '" +
+                           current_value + "'");
+    }
+  }
+
+  // Report results
+  if (!all_match) {
+    std::cerr << "[ERROR] Hardware validation failed with the following "
+                 "mismatches:"
+              << std::endl;
+    for (const auto &mismatch : mismatches) {
+      std::cerr << "  - " << mismatch << std::endl;
+    }
+  } else {
+    std::cout << "[INFO] Hardware validation successful. Configuration matches "
+                 "this system."
+              << std::endl;
+  }
+
+  return all_match;
+}
+
 static void spin_thread_configurator_node(const std::string &config_filename) {
   YAML::Node config;
 
   try {
     config = YAML::LoadFile(config_filename);
-    std::cout << config << std::endl;
   } catch (const std::exception &e) {
     std::cerr << "Error reading the YAML file: " << e.what() << std::endl;
     return;
   }
 
+  // Validate hardware information if present in YAML
+  if (config["hardware_info"]) {
+    if (!validate_hardware_info(config)) {
+      std::cerr << "[ERROR] Hardware information validation failed. The "
+                   "configuration may not match this system."
+                << std::endl;
+      return;
+    }
+  } else {
+    std::cout << "[WARN] No hardware_info section found in configuration file. "
+                 "Skipping hardware validation."
+              << std::endl;
+  }
+
+  std::cout << config["callback_groups"] << std::endl;
+
   auto node = std::make_shared<ThreadConfiguratorNode>(config);
   auto executor = std::make_shared<rclcpp::executors::SingleThreadedExecutor>();
 

cie_thread_configurator/src/prerun_node.cpp

@@ -7,6 +7,7 @@
 #include "rclcpp/rclcpp.hpp"
 #include "yaml-cpp/yaml.h"
 
+#include "cie_thread_configurator/cie_thread_configurator.hpp"
 #include "cie_thread_configurator/prerun_node.hpp"
 
 PrerunNode::PrerunNode() : Node("prerun_node") {
@@ -32,6 +33,20 @@ void PrerunNode::dump_yaml_config(std::filesystem::path path) {
   YAML::Emitter out;
 
   out << YAML::BeginMap;
+
+  // Add hardware information section
+  out << YAML::Key << "hardware_info";
+  out << YAML::Value << YAML::BeginMap;
+
+  auto hw_info = cie_thread_configurator::get_hardware_info();
+
+  for (const auto &[key, value] : hw_info) {
+    out << YAML::Key << key << YAML::Value << value;
+  }
+
+  out << YAML::EndMap;
+
+  // Add callback_groups section
   out << YAML::Key << "callback_groups";
   out << YAML::Value << YAML::BeginSeq;
 

cie_thread_configurator/src/util.cpp

@@ -1,3 +1,4 @@
+#include <array>
 #include <chrono>
 #include <functional>
 #include <memory>
@@ -85,4 +86,61 @@ void publish_callback_group_info(
   rclcpp::sleep_for(std::chrono::milliseconds(500));
 }
 
+std::map<std::string, std::string> get_hardware_info() {
+  std::map<std::string, std::string> hw_info;
+
+  // Execute lscpu command and capture output
+  std::array<char, 128> buffer;
+  std::string result;
+  std::unique_ptr<FILE, decltype(&pclose)> pipe(popen("/usr/bin/lscpu", "r"),
+                                                pclose);
+
+  if (!pipe) {
+    return hw_info;
+  }
+
+  while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
+    result += buffer.data();
+  }
+
+  // Parse lscpu output
+  std::istringstream iss(result);
+  std::string line;
+
+  while (std::getline(iss, line)) {
+    size_t colon_pos = line.find(':');
+    if (colon_pos == std::string::npos)
+      continue;
+
+    std::string key = line.substr(0, colon_pos);
+    std::string value = line.substr(colon_pos + 1);
+
+    // Trim leading/trailing whitespace from value
+    size_t start = value.find_first_not_of(" \t");
+    size_t end = value.find_last_not_of(" \t\r\n");
+    if (start != std::string::npos && end != std::string::npos) {
+      value = value.substr(start, end - start + 1);
+    }
+
+    // Store relevant hardware information
+    if (key == "Model name") {
+      hw_info["model_name"] = value;
+    } else if (key == "CPU family") {
+      hw_info["cpu_family"] = value;
+    } else if (key == "Model") {
+      hw_info["model"] = value;
+    } else if (key == "Thread(s) per core") {
+      hw_info["threads_per_core"] = value;
+    } else if (key == "Frequency boost") {
+      hw_info["frequency_boost"] = value;
+    } else if (key == "CPU max MHz") {
+      hw_info["cpu_max_mhz"] = value;
+    } else if (key == "CPU min MHz") {
+      hw_info["cpu_min_mhz"] = value;
+    }
+  }
+
+  return hw_info;
+}
+
 } // namespace cie_thread_configurator