cpu: port parseCpuinfo to BSDs

src/modules/cpu/bsd.cpp

@@ -0,0 +1,97 @@
+#include "modules/cpu.hpp"
+
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <cstdlib>            // malloc
+#include <unistd.h>           // sysconf
+
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+#  include <sys/sched.h>
+#else
+#  include <sys/resource.h>
+#endif
+
+#if defined(__NetBSD__)
+typedef uint64_t cp_time_t;
+#else
+typedef long cp_time_t;
+#endif
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+typedef uint64_t pcp_time_t;
+#else
+typedef long pcp_time_t;
+#endif
+
+std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
+  cp_time_t sum_cp_time[CPUSTATES];
+  size_t sum_sz = sizeof(sum_cp_time);
+  int ncpu = sysconf(_SC_NPROCESSORS_CONF);
+  size_t sz = CPUSTATES * (ncpu + 1) * sizeof(pcp_time_t);
+  pcp_time_t *cp_time = static_cast<pcp_time_t *>(malloc(sz)), *pcp_time = cp_time;
+#if defined(__NetBSD__)
+  int mib[] = {
+    CTL_KERN,
+    KERN_CP_TIME,
+  };
+  if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), sum_cp_time, &sum_sz, NULL, 0)) {
+    throw std::runtime_error("sysctl kern.cp_time failed");
+  }
+  for (int state = 0; state < CPUSTATES; state++) {
+    cp_time[state] = sum_cp_time[state];
+  }
+  pcp_time += CPUSTATES;
+  if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), pcp_time, &sz, NULL, 0)) {
+    throw std::runtime_error("sysctl kern.cp_time failed");
+  }
+#elif defined(__OpenBSD__)
+  {
+    int mib[] = {
+      CTL_KERN,
+      KERN_CPTIME,
+    };
+    if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), sum_cp_time, &sum_sz, NULL, 0)) {
+      throw std::runtime_error("sysctl kern.cp_time failed");
+    }
+  }
+  for (int state = 0; state < CPUSTATES; state++) {
+    cp_time[state] = sum_cp_time[state];
+  }
+  pcp_time = cp_time;
+  sz /= ncpu + 1;
+  {
+    int mib[] = {
+      CTL_KERN,
+      KERN_CPTIME2,
+      0,
+    };
+    for (int cpu = 0; cpu < ncpu; cpu++) {
+      mib[2] = cpu;
+      pcp_time += CPUSTATES;
+      if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), pcp_time, &sz, NULL, 0)) {
+        throw std::runtime_error("sysctl kern.cp_time2 failed");
+      }
+    }
+  }
+#else
+  if (sysctlbyname("kern.cp_time", sum_cp_time, &sum_sz, NULL, 0)) {
+    throw std::runtime_error("sysctl kern.cp_time failed");
+  }
+  for (int state = 0; state < CPUSTATES; state++) {
+    cp_time[state] = sum_cp_time[state];
+  }
+  pcp_time += CPUSTATES;
+  if (sysctlbyname("kern.cp_times", pcp_time, &sz, NULL, 0)) {
+    throw std::runtime_error("sysctl kern.cp_times failed");
+  }
+#endif
+  std::vector<std::tuple<size_t, size_t>> cpuinfo;
+  for (int cpu = 0; cpu < ncpu + 1; cpu++) {
+    pcp_time_t total = 0, *single_cp_time = &cp_time[cpu * CPUSTATES];
+    for (int state = 0; state < CPUSTATES; state++) {
+      total += single_cp_time[state];
+    }
+    cpuinfo.emplace_back(single_cp_time[CP_IDLE], total);
+  }
+  free(cp_time);
+  return cpuinfo;
+}

src/modules/cpu/common.cpp

@@ -0,0 +1,55 @@
+#include "modules/cpu.hpp"
+
+waybar::modules::Cpu::Cpu(const std::string& id, const Json::Value& config)
+    : ALabel(config, "cpu", id, "{usage}%", 10) {
+  thread_ = [this] {
+    dp.emit();
+    thread_.sleep_for(interval_);
+  };
+}
+
+auto waybar::modules::Cpu::update() -> void {
+  // TODO: as creating dynamic fmt::arg arrays is buggy we have to calc both
+  auto cpu_load = getCpuLoad();
+  auto [cpu_usage, tooltip] = getCpuUsage();
+  if (tooltipEnabled()) {
+    label_.set_tooltip_text(tooltip);
+  }
+  label_.set_markup(fmt::format(format_, fmt::arg("load", cpu_load), fmt::arg("usage", cpu_usage)));
+  getState(cpu_usage);
+  // Call parent update
+  ALabel::update();
+}
+
+uint16_t waybar::modules::Cpu::getCpuLoad() {
+  double load[1];
+  if (getloadavg(load, 1) != -1) {
+    return load[0] * 100 / sysconf(_SC_NPROCESSORS_ONLN);
+  }
+  throw std::runtime_error("Can't get Cpu load");
+}
+
+std::tuple<uint16_t, std::string> waybar::modules::Cpu::getCpuUsage() {
+  if (prev_times_.empty()) {
+    prev_times_ = parseCpuinfo();
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+  std::vector<std::tuple<size_t, size_t>> curr_times = parseCpuinfo();
+  std::string                             tooltip;
+  uint16_t                                usage = 0;
+  for (size_t i = 0; i < curr_times.size(); ++i) {
+    auto [curr_idle, curr_total] = curr_times[i];
+    auto [prev_idle, prev_total] = prev_times_[i];
+    const float delta_idle = curr_idle - prev_idle;
+    const float delta_total = curr_total - prev_total;
+    uint16_t    tmp = 100 * (1 - delta_idle / delta_total);
+    if (i == 0) {
+      usage = tmp;
+      tooltip = fmt::format("Total: {}%", tmp);
+    } else {
+      tooltip = tooltip + fmt::format("\nCore{}: {}%", i - 1, tmp);
+    }
+  }
+  prev_times_ = curr_times;
+  return {usage, tooltip};
+}

src/modules/cpu/linux.cpp

@@ -0,0 +1,29 @@
+#include "modules/cpu.hpp"
+
+std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
+  const std::string data_dir_ = "/proc/stat";
+  std::ifstream info(data_dir_);
+  if (!info.is_open()) {
+    throw std::runtime_error("Can't open " + data_dir_);
+  }
+  std::vector<std::tuple<size_t, size_t>> cpuinfo;
+  std::string                             line;
+  while (getline(info, line)) {
+    if (line.substr(0, 3).compare("cpu") != 0) {
+      break;
+    }
+    std::stringstream   sline(line.substr(5));
+    std::vector<size_t> times;
+    for (size_t time = 0; sline >> time; times.push_back(time))
+      ;
+
+    size_t idle_time = 0;
+    size_t total_time = 0;
+    if (times.size() >= 4) {
+      idle_time = times[3];
+      total_time = std::accumulate(times.begin(), times.end(), 0);
+    }
+    cpuinfo.emplace_back(idle_time, total_time);
+  }
+  return cpuinfo;
+}