Add getting CPU usage information on Linux. (#1)

* Add getting CPU usage information on Linux.

* Add getting CPU usage information on Linux.

Author: AnatolyKalin

CMakeLists.txt

@@ -1,17 +1,43 @@
 # Copyright (c) 2023 ttldtor.
 # SPDX-License-Identifier: BSL-1.0
 
-cmake_minimum_required(VERSION 3.26)
+cmake_minimum_required(VERSION 3.22)
+
 project(process)
+include(GNUInstallDirs)
+
+set(TTLDTOR_PROCESS "1.0.0" CACHE STRING "The Process package version")
 
 set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CXX_EXTENSIONS OFF)
+set(C_EXTENSIONS OFF)
+
+# Determine if process is built as a subproject (using add_subdirectory)
+# or if it is the master project.
+if (NOT DEFINED TTLDTOR_PROCESS_ROOT_PROJECT)
+    set(TTLDTOR_PROCESS_ROOT_PROJECT OFF)
+    if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+        set(TTLDTOR_PROCESS_ROOT_PROJECT ON)
+        message(STATUS "CMake version: ${CMAKE_VERSION}")
+    endif ()
+endif ()
+
+option(TTLDTOR_PROCESS_SAMPLES "Enable building samples for Process" ${TTLDTOR_PROCESS_ROOT_PROJECT})
 
 add_library(process src/process.cpp)
 target_include_directories(process PUBLIC include)
 
+add_library(process::process ALIAS process)
+
 if (WIN32)
     target_link_libraries(process PRIVATE psapi)
 endif ()
 
-add_executable(process_test test/main.cpp)
-target_link_libraries(process_test process)
+if (TTLDTOR_PROCESS_SAMPLES)
+    add_executable(process_test test/main.cpp)
+    target_link_libraries(process_test process)
+endif ()

README.md

@@ -1,2 +1,56 @@
 # Process
 Cross-platform library for obtaining metrics of the current process
+
+Status:
+* [x] Windows
+* [x] Linux
+* [ ] MacOS
+* [ ] FreeBSD
+* [ ] AIX
+* [ ] ...
+
+Example:
+
+```cpp
+#include <process/process.hpp>
+
+#include <chrono>
+#include <iostream>
+#include <thread>
+#include <vector>
+
+using namespace std::literals;
+using namespace ttldtor::process;
+
+int main() {
+    auto now = [] {
+        return duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
+    };
+    std::cout << "Physical memory usage: " << Process::getPhysicalMemorySize() / 1024 << "KB" << std::endl;
+    std::cout << "Total CPU time: " << Process::getTotalProcessorTime().count() << "ms" << std::endl;
+
+    auto t1 = now();
+
+    while (now() - t1 <= 5) {
+        static std::size_t i = 0;
+        (void)(i++);
+    }
+
+    std::cout << "Total CPU time: " << Process::getTotalProcessorTime().count() << "ms" << std::endl;
+    std::cout << "Physical memory usage: " << Process::getPhysicalMemorySize() / 1024 << "KB" << std::endl;
+    std::vector<std::byte> vb(10 * 1024 * 1024);
+    std::cout << "Physical memory usage: " << Process::getPhysicalMemorySize() / 1024 << "KB" << std::endl;
+    vb.resize(1);
+    vb.shrink_to_fit();
+    std::cout << "Physical memory usage: " << Process::getPhysicalMemorySize() / 1024 << "KB" << std::endl;
+}
+```
+
+```text
+Physical memory usage: 3676KB
+Total CPU time: 15ms
+Total CPU time: 5687ms
+Physical memory usage: 3720KB
+Physical memory usage: 13964KB
+Physical memory usage: 3720KB
+```

include/process/process.hpp

@@ -38,18 +38,27 @@ namespace ttldtor::process {
 struct TTLDTOR_PROCESS_EXPORT Process {
 
     /**
-     * Returns the kernel (privileged) CPU time for the current process in ms.
+     * Returns the kernel (privileged, system) CPU time for the current process in ms.
      *
-     * @return The kernel (privileged) CPU time for the current process in ms.
+     * @return The kernel (privileged, system) CPU time for the current process in ms.
      */
     static std::chrono::milliseconds getKernelProcessorTime() noexcept;
 
     /**
-     * Returns the kernel (privileged) CPU time for the current process in ms.
+     * Returns the kernel (privileged, system) CPU time for the current process in ms.
      *
-     * @return The kernel (privileged) CPU time for the current process in ms.
+     * @return The kernel (privileged, system) CPU time for the current process in ms.
      */
-    static std::chrono::milliseconds PrivilegedProcessorTime() noexcept {
+    static std::chrono::milliseconds getPrivilegedProcessorTime() noexcept {
+        return getKernelProcessorTime();
+    }
+
+    /**
+     * Returns the kernel (privileged, system) CPU time for the current process in ms.
+     *
+     * @return The kernel (privileged, system) CPU time for the current process in ms.
+     */
+    static std::chrono::milliseconds getSystemProcessorTime() noexcept {
         return getKernelProcessorTime();
     }
 

src/process.cpp

@@ -3,13 +3,13 @@
 
 #include <process/process.hpp>
 
+#include <atomic>
 #include <chrono>
 #include <cstring>
 #include <fstream>
 #include <iostream>
 #include <string>
 #include <type_traits>
-#include <atomic>
 
 namespace ttldtor::process {
 
@@ -121,26 +121,18 @@ std::uint64_t Process::getPrivateMemorySize() noexcept {
 }
 } // namespace ttldtor::process
 #elif defined(__linux__)
-int parseLine(char *line) {
-    // This assumes that a digit will be found and the line ends in " Kb".
-    int i = strlen(line);
-    const char *p = line;
-    while (*p < '0' || *p > '9')
-        p++;
-    line[i - 3] = '\0';
-    i = atoi(p);
-    return i;
-}
+
+#    include <sys/resource.h>
 
 struct Parser {
     enum ParseResultType { KEY_NOT_FOUND, VALUE_NOT_FOUND, OK };
 
-    struct ParseResult {
+    struct ParseStatusResult {
         ParseResultType resultType;
         std::uint64_t value;
     };
 
-    static ParseResult parse(const std::string &s, const std::string &key) noexcept {
+    static ParseStatusResult parseStatus(const std::string &s, const std::string &key) noexcept {
         if (auto foundKeyPos = s.find(key); foundKeyPos != std::string::npos) {
             if (auto foundValuePos = s.find_first_of("0123456789", foundKeyPos + 6);
                 foundValuePos != std::string::npos) {
@@ -158,36 +150,43 @@ struct Parser {
     }
 };
 
+namespace ttldtor::process {
+struct RUsageResult {
+    std::chrono::milliseconds sysTime{};
+    std::chrono::milliseconds userTime{};
+    std::chrono::milliseconds totalTime{};
+
+    explicit RUsageResult(const rusage &ru)
+        : sysTime{static_cast<std::uint64_t>(ru.ru_stime.tv_sec) * 1000000ULL +
+                  static_cast<std::uint64_t>(ru.ru_stime.tv_usec)},
+          userTime{static_cast<std::uint64_t>(ru.ru_utime.tv_sec) * 1000000ULL +
+                   static_cast<std::uint64_t>(ru.ru_utime.tv_usec)},
+          totalTime{sysTime + userTime} {
+    }
+};
 
+std::chrono::milliseconds Process::getKernelProcessorTime() noexcept {
+    rusage ru{};
 
-static unsigned long long lastTotalUser, lastTotalUserLow, lastTotalSys, lastTotalIdle;
+    getrusage(RUSAGE_SELF, &ru);
 
-void init() {
-    FILE *file = fopen("/proc/stat", "r");
-    fscanf(file, "cpu %llu %llu %llu %llu", &lastTotalUser, &lastTotalUserLow, &lastTotalSys, &lastTotalIdle);
-    fclose(file);
+    return RUsageResult{ru}.sysTime;
 }
 
-namespace ttldtor::process {
-/*TODO: implement
- * https://github.com/dotnet/runtime/blob/de0ab156194eb64deae0e1018db9a58f7b02f4a3/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs#L817
- * https://github.com/dotnet/runtime/blob/de0ab156194eb64deae0e1018db9a58f7b02f4a3/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Linux.cs#L130
- */
+std::chrono::milliseconds Process::getUserProcessorTime() noexcept {
+    rusage ru{};
 
-std::chrono::milliseconds Process::getKernelProcessorTime() noexcept {
-    return std::chrono::milliseconds(0);
-}
+    getrusage(RUSAGE_SELF, &ru);
 
-std::chrono::milliseconds Process::getUserProcessorTime() noexcept {
-    return std::chrono::milliseconds(0);
+    return RUsageResult{ru}.userTime;
 }
 
 std::chrono::milliseconds Process::getTotalProcessorTime() noexcept {
-    init();
+    rusage ru{};
 
-    // std::cout << (lastTotalUser + lastTotalSys) << std::endl;
+    getrusage(RUSAGE_SELF, &ru);
 
-    return std::chrono::milliseconds((lastTotalUser + lastTotalSys) * 10);
+    return RUsageResult{ru}.totalTime;
 }
 
 std::uint64_t Process::getWorkingSetSize() noexcept {
@@ -200,7 +199,7 @@ std::uint64_t Process::getWorkingSetSize() noexcept {
     std::string s{};
 
     while (!std::getline(is, s).fail()) {
-        auto result = Parser::parse(s, "VmRSS:");
+        auto result = Parser::parseStatus(s, "VmRSS:");
 
         if (result.resultType == Parser::KEY_NOT_FOUND) {
             continue;
@@ -222,7 +221,7 @@ std::uint64_t Process::getPrivateMemorySize() noexcept {
     std::string s{};
 
     while (!std::getline(is, s).fail()) {
-        auto result = Parser::parse(s, "VmSize:");
+        auto result = Parser::parseStatus(s, "VmSize:");
 
         if (result.resultType == Parser::KEY_NOT_FOUND) {
             continue;

test/main.cpp

@@ -1,17 +1,19 @@
 #include <process/process.hpp>
 
+#include <chrono>
 #include <iostream>
 #include <thread>
-#include <chrono>
 #include <vector>
 
 using namespace std::literals;
 using namespace ttldtor::process;
 
 int main() {
-    auto now = [] { return duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now().time_since_epoch()).count(); };
+    auto now = [] {
+        return duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
+    };
     std::cout << "Physical memory usage: " << Process::getPhysicalMemorySize() / 1024 << "KB" << std::endl;
-    std::cout << "Total CPU time: " << Process::getTotalProcessorTime() << std::endl;
+    std::cout << "Total CPU time: " << Process::getTotalProcessorTime().count() << "ms" << std::endl;
 
     auto t1 = now();
 
@@ -20,9 +22,9 @@ int main() {
         (void)(i++);
     }
 
-    std::cout << "Total CPU time: " <<  Process::getTotalProcessorTime() << std::endl;
+    std::cout << "Total CPU time: " << Process::getTotalProcessorTime().count() << "ms" << std::endl;
     std::cout << "Physical memory usage: " << Process::getPhysicalMemorySize() / 1024 << "KB" << std::endl;
-    std::vector<std::byte> vb(10000000);
+    std::vector<std::byte> vb(10 * 1024 * 1024);
     std::cout << "Physical memory usage: " << Process::getPhysicalMemorySize() / 1024 << "KB" << std::endl;
     vb.resize(1);
     vb.shrink_to_fit();