Method Sample

src/daemon/resource_monitor.cpp:100–129

}

ProcessResources ProcessSampler::Sample(int pid) {
    ProcessResources out;
    if (pid <= 0) return out;
    out.rss_bytes = ReadRssBytes(pid);

    const uint64_t ticks_now = ReadCpuTicks(pid);
    const int64_t wall_now = WallClockMs();
    const long clk_tck = ::sysconf(_SC_CLK_TCK);
    if (ticks_now == 0 || clk_tck <= 0) return out;

    std::lock_guard<std::mutex> lock(mutex_);
    auto it = last_.find(pid);
    if (it != last_.end() && it->second.cpu_ticks > 0 && wall_now > it->second.wall_ms) {
        const uint64_t d_ticks = (ticks_now > it->second.cpu_ticks)
            ? (ticks_now - it->second.cpu_ticks)
            : 0;
        const int64_t d_wall_ms = wall_now - it->second.wall_ms;
        if (d_wall_ms > 0) {
            // d_ticks/clk_tck = CPU seconds consumed; divide by wall seconds
            // (d_wall_ms/1000) and multiply by 100 to express as "% of one
            // logical core".
            const double cpu_seconds = static_cast<double>(d_ticks) / static_cast<double>(clk_tck);
            const double wall_seconds = static_cast<double>(d_wall_ms) / 1000.0;
            out.cpu_percent = (cpu_seconds / wall_seconds) * 100.0;
            if (out.cpu_percent < 0.0) out.cpu_percent = 0.0;
        }
    }
    last_[pid] = PidSample{.cpu_ticks = ticks_now, .wall_ms = wall_now};
    return out;
}

void ProcessSampler::Forget(int pid) {
    std::lock_guard<std::mutex> lock(mutex_);