RPJosh
/
Waybar
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cpu module: Reuse getCpuUsage of cpu_usage module

pull/2114/head
Mann mit Hut 2023-07-29 15:56:51 +02:00
parent c45f6681b3
commit d1602e383c
No known key found for this signature in database
GPG Key ID: 02D4D60B8250CB8C
7 changed files with 13 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/modules/cpu.hpp
View File

@ -22,8 +22,6 @@ class Cpu : public ALabel {
private:
double getCpuLoad();
std::tuple<std::vector<uint16_t>, std::string> getCpuUsage();
std::vector<std::tuple<size_t, size_t>> parseCpuinfo();
std::vector<std::tuple<size_t, size_t>> prev_times_;

6
include/modules/cpu_usage.hpp
View File

@ -20,9 +20,11 @@ class CpuUsage : public ALabel {
virtual ~CpuUsage() = default;
auto update() -> void override;
// This is a static member because it is also used by the cpu module.
static std::tuple<std::vector<uint16_t>, std::string> getCpuUsage(std::vector<std::tuple<size_t, size_t>>&);
private:
std::tuple<std::vector<uint16_t>, std::string> getCpuUsage();
std::vector<std::tuple<size_t, size_t>> parseCpuinfo();
static std::vector<std::tuple<size_t, size_t>> parseCpuinfo();
std::vector<std::tuple<size_t, size_t>> prev_times_;

2
meson.build
View File

@ -189,7 +189,6 @@ if is_linux
src_files += files(
'src/modules/battery.cpp',
'src/modules/cpu/common.cpp',
'src/modules/cpu/linux.cpp',
'src/modules/cpu_frequency/common.cpp',
'src/modules/cpu_frequency/linux.cpp',
'src/modules/cpu_usage/common.cpp',
@ -201,7 +200,6 @@ elif is_dragonfly or is_freebsd or is_netbsd or is_openbsd
add_project_arguments('-DHAVE_CPU_BSD', language: 'cpp')
add_project_arguments('-DHAVE_MEMORY_BSD', language: 'cpp')
src_files += files(
'src/modules/cpu/bsd.cpp',
'src/modules/cpu/common.cpp',
'src/modules/cpu_usage/bsd.cpp',
'src/modules/cpu_usage/common.cpp',

102
src/modules/cpu/bsd.cpp
View File

@ -1,102 +0,0 @@
#include <spdlog/spdlog.h>
// clang-format off
#include <sys/types.h>
#include <sys/sysctl.h>
// clang-format on
#include <unistd.h> // sysconf
#include <cmath> // NAN
#include <cstdlib> // malloc
#include "modules/cpu.hpp"
#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;
}

28
src/modules/cpu/common.cpp
View File

@ -1,5 +1,6 @@
#include "modules/cpu.hpp"
#include "modules/cpu_frequency.hpp"
#include "modules/cpu_usage.hpp"
// In the 80000 version of fmt library authors decided to optimize imports
// and moved declarations required for fmt::dynamic_format_arg_store in new
@ -21,7 +22,7 @@ waybar::modules::Cpu::Cpu(const std::string& id, const Json::Value& config)
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();
auto [cpu_usage, tooltip] = CpuUsage::getCpuUsage(prev_times_);
auto [max_frequency, min_frequency, avg_frequency] = CpuFrequency::getCpuFrequency();
if (tooltipEnabled()) {
label_.set_tooltip_text(tooltip);
@ -66,28 +67,3 @@ double waybar::modules::Cpu::getCpuLoad() {
}
throw std::runtime_error("Can't get Cpu load");
}
std::tuple<std::vector<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;
std::vector<uint16_t> usage;
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) {
tooltip = fmt::format("Total: {}%", tmp);
} else {
tooltip = tooltip + fmt::format("\nCore{}: {}%", i - 1, tmp);
}
usage.push_back(tmp);
}
prev_times_ = curr_times;
return {usage, tooltip};
}

31
src/modules/cpu/linux.cpp
View File

@ -1,31 +0,0 @@
#include <filesystem>
#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;
}

14
src/modules/cpu_usage/common.cpp
View File

@ -19,7 +19,7 @@ waybar::modules::CpuUsage::CpuUsage(const std::string& id, const Json::Value& co
auto waybar::modules::CpuUsage::update() -> void {
// TODO: as creating dynamic fmt::arg arrays is buggy we have to calc both
auto [cpu_usage, tooltip] = getCpuUsage();
auto [cpu_usage, tooltip] = CpuUsage::getCpuUsage(prev_times_);
if (tooltipEnabled()) {
label_.set_tooltip_text(tooltip);
}
@ -52,17 +52,17 @@ auto waybar::modules::CpuUsage::update() -> void {
ALabel::update();
}
std::tuple<std::vector<uint16_t>, std::string> waybar::modules::CpuUsage::getCpuUsage() {
if (prev_times_.empty()) {
prev_times_ = parseCpuinfo();
std::tuple<std::vector<uint16_t>, std::string> waybar::modules::CpuUsage::getCpuUsage(std::vector<std::tuple<size_t, size_t>>& prev_times) {
if (prev_times.empty()) {
prev_times = CpuUsage::parseCpuinfo();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
std::vector<std::tuple<size_t, size_t>> curr_times = parseCpuinfo();
std::vector<std::tuple<size_t, size_t>> curr_times = CpuUsage::parseCpuinfo();
std::string tooltip;
std::vector<uint16_t> usage;
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];
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);
@ -73,6 +73,6 @@ std::tuple<std::vector<uint16_t>, std::string> waybar::modules::CpuUsage::getCpu
}
usage.push_back(tmp);
}
prev_times_ = curr_times;
prev_times = curr_times;
return {usage, tooltip};
}