Feature/gridedit 589 query sys mem bench

cmake/options.cmake

@@ -1,3 +1,5 @@
+include(CMakeDependentOption)
+
 # unit testing option
 option(
   ENABLE_UNIT_TESTING
@@ -13,7 +15,6 @@ option(
 )
 
 # memory usgae reporting option
-include(CMakeDependentOption)
 cmake_dependent_option(
   ENABLE_BENCHMARKING_MEM_REPORT
   "When benchmarking is enabled, enables reporting memory usage statistics."
@@ -22,6 +23,18 @@ cmake_dependent_option(
   OFF
 )
 
+if(ENABLE_BENCHMARKING_MEM_REPORT)
+  set(
+    MEM_COLLECTION_METHOD "" 
+    CACHE STRING 
+    "When memory reporting is enabled, specifies how memory metrics are collected."
+  )
+  if( NOT (MEM_COLLECTION_METHOD STREQUAL "QUERY_SYSTEM" OR MEM_COLLECTION_METHOD STREQUAL "COUNT_BYTES"))
+    message(WARNING "Option MEM_COLLECTION_METHOD not set. QUERY_SYSTEM will be used.")
+    set(MEM_COLLECTION_METHOD "QUERY_SYSTEM")
+  endif()
+endif()
+
 # code coverage option
 if(LINUX AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
   option(

libs/MeshKernel/benchmark/CMakeLists.txt

@@ -30,18 +30,38 @@ target_link_libraries(
 )
 
 if(ENABLE_BENCHMARKING_MEM_REPORT)
-  # link memory manager
-  target_link_libraries(
-    ${TARGET_NAME}
-    PRIVATE
-    MeshKernelBenchmarkMemoryManager
-  )
   # add compiler definition for reporting the memory statistics in src
   target_compile_definitions(
     ${TARGET_NAME}
     PRIVATE
     ENABLE_BENCHMARKING_MEM_REPORT
   )
+
+  if(MEM_COLLECTION_METHOD STREQUAL "QUERY_SYSTEM")
+    # link memory manager
+    target_link_libraries(
+      ${TARGET_NAME}
+      PRIVATE
+      MeshKernelBenchmarkMemorySystemQuery
+    )
+    target_compile_definitions(
+      ${TARGET_NAME}
+      PRIVATE
+      MEM_COLLECTION_METHOD_QUERY_SYSTEM
+    )
+  elseif(MEM_COLLECTION_METHOD STREQUAL "COUNT_BYTES")
+    # link memory manager
+    target_link_libraries(
+      ${TARGET_NAME}
+      PRIVATE
+      MeshKernelBenchmarkMemoryManager
+    )
+    target_compile_definitions(
+        ${TARGET_NAME}
+        PRIVATE
+        MEM_COLLECTION_METHOD_COUNT_BYTES
+    )
+  endif()
 endif()
 
 # group the sources

libs/MeshKernel/benchmark/src/main.cpp

@@ -1,7 +1,11 @@
 #include <benchmark/benchmark.h>
 
 #ifdef ENABLE_BENCHMARKING_MEM_REPORT
+#if defined(MEM_COLLECTION_METHOD_COUNT_BYTES)
 #include "custom_memory_manager.hpp"
+#elif defined(MEM_COLLECTION_METHOD_QUERY_SYSTEM)
+#include "memory_system_query.hpp"
+#endif
 #endif
 
 int main(int argc, char** argv)
@@ -16,7 +20,11 @@ int main(int argc, char** argv)
     ::benchmark::Initialize(&argc, argv);
     ::benchmark::SetDefaultTimeUnit(::benchmark::kMillisecond);
 #ifdef ENABLE_BENCHMARKING_MEM_REPORT
+#if defined(MEM_COLLECTION_METHOD_COUNT_BYTES)
     ::benchmark::RegisterMemoryManager(&CUSTOM_MEMORY_MANAGER);
+#elif defined(MEM_COLLECTION_METHOD_QUERY_SYSTEM)
+    ::benchmark::RegisterMemoryManager(&MEMORY_SYSTEM_QUERY);
+#endif
 #endif
     if (::benchmark::ReportUnrecognizedArguments(argc, argv))
     {

tools/CMakeLists.txt

@@ -4,7 +4,11 @@ add_subdirectory(Version)
 # Add custom_memory_manager
 # This target is built only if benchmarking with memory reporting is enabled
 if(ENABLE_BENCHMARKING AND ENABLE_BENCHMARKING_MEM_REPORT)
-  add_subdirectory(custom_memory_manager)
+  if(MEM_COLLECTION_METHOD STREQUAL "COUNT_BYTES")
+    add_subdirectory(custom_memory_manager)
+  elseif(MEM_COLLECTION_METHOD STREQUAL "QUERY_SYSTEM")
+  add_subdirectory(memory_system_query)
+  endif()
 endif()
 
 # Add test utilities

tools/memory_system_query/CMakeLists.txt

@@ -0,0 +1,62 @@
+# project name
+project(
+  MeshKernelBenchmarkMemorySystemQuery
+  VERSION ${CMAKE_PROJECT_VERSION}
+  DESCRIPTION "MeshKernel benchmark memory system query"
+  LANGUAGES CXX
+)
+
+# target name
+set(TARGET_NAME ${PROJECT_NAME})
+
+# executable
+add_library(${TARGET_NAME} STATIC)
+
+# source directories
+set(SRC_DIR ${PROJECT_SOURCE_DIR}/src)
+
+# include directories
+set(INC_DIR ${PROJECT_SOURCE_DIR}/include)
+
+# list of target sources
+set(
+  SRC_LIST
+  ${SRC_DIR}/memory_system_query.cpp
+)
+
+# list of tagret headers
+set(
+  INC_LIST
+  ${INC_DIR}/memory_system_query.hpp
+  ${INC_DIR}/memory_monitor.hpp
+  ${INC_DIR}/memory_monitor_linux.hpp
+  ${INC_DIR}/memory_monitor_windows.hpp
+  ${INC_DIR}/memory_monitor_factory.hpp
+)
+
+# add sources to target
+target_sources(
+  ${TARGET_NAME}
+  PRIVATE
+    ${SRC_LIST}
+  PUBLIC
+    FILE_SET HEADERS
+      BASE_DIRS ${INC_DIR}
+      FILES ${INC_LIST}
+)
+
+# specify libraries to be linked to the executable
+target_link_libraries(
+  ${TARGET_NAME}
+  PRIVATE
+    benchmark::benchmark
+)
+
+# group the sources and headers
+source_group("Source Files" FILES ${SRC_LIST})
+source_group("Header Files" FILES ${INC_LIST})
+
+# add unit tests subdirectory
+if(ENABLE_UNIT_TESTING)
+  add_subdirectory(tests)
+endif()

tools/memory_system_query/include/memory_monitor.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <cstdint>
+
+enum class MemoryType
+{
+    Physical = 0,
+    PhysicalPeak = 1,
+    Virtual = 2,
+    VirtualPeak = 3
+};
+
+class MemoryMonitor
+{
+public:
+    MemoryMonitor() = default;
+    virtual ~MemoryMonitor() = default;
+    // non-copyable
+    MemoryMonitor(const MemoryMonitor& other) = delete;
+    MemoryMonitor& operator=(const MemoryMonitor& other) = delete;
+    MemoryMonitor(MemoryMonitor&& other) = delete;
+    MemoryMonitor& operator=(MemoryMonitor&& other) = delete;
+
+    /// @brief Gets the memory usage my type
+    /// @param memory_type The type of requested memory usage
+    /// @return            The memory usage
+    virtual uint64_t Usage(MemoryType memory_type) const = 0;
+
+    /// @brief Convenience method that returns the total current physical and virtual usage
+    /// @return The total current physical and virtual usage
+    uint64_t CurrentUsage() const
+    {
+        return Usage(MemoryType::Physical) + Usage(MemoryType::Virtual);
+    }
+
+    /// @brief Convenience method that returns the total peak physical and virtual usage
+    /// @return The total peak physical and virtual usage
+    uint64_t PeakUsage() const
+    {
+        return Usage(MemoryType::PhysicalPeak) + Usage(MemoryType::VirtualPeak);
+    }
+
+private:
+    inline static uint64_t constexpr kilobyte = 1024;
+};

tools/memory_system_query/include/memory_monitor_factory.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <iostream>
+#include <memory>
+
+#if defined(_WIN32)
+#include "memory_monitor_windows.hpp"
+#elif defined(__linux__)
+#include "memory_monitor_linux.hpp"
+#else
+#error "Unsupported platform"
+#endif
+
+inline static std::unique_ptr<MemoryMonitor> CreateMemoryMonitor()
+{
+#if defined(_WIN32)
+    return std::make_unique<WindowsMemoryMonitor>();
+#elif defined(__linux__)
+    return std::make_unique<LinuxMemoryMonitor>();
+#else
+#error "Unsupported platform"
+#endif
+}

tools/memory_system_query/include/memory_monitor_linux.hpp

@@ -0,0 +1,123 @@
+#ifdef __linux__
+
+#pragma once
+
+#include <filesystem>
+#include <fstream>
+#include <map>
+#include <stdexcept>
+#include <string>
+
+#include <cmath>
+#include <cstdint>
+
+#include <unistd.h>
+
+#include "memory_monitor.hpp"
+
+class LinuxMemoryMonitor final : public MemoryMonitor
+{
+public:
+    LinuxMemoryMonitor()
+    {
+        std::filesystem::path path("/proc");
+        path /= std::to_string(getpid());
+        path /= "status";
+        m_path_str = path.string();
+        std::cout << m_path_str << std::endl;
+    }
+
+    ~LinuxMemoryMonitor() = default;
+
+    // non-copyable
+    LinuxMemoryMonitor(const LinuxMemoryMonitor&) = delete;
+    LinuxMemoryMonitor& operator=(const LinuxMemoryMonitor&) = delete;
+    LinuxMemoryMonitor(LinuxMemoryMonitor&&) = delete;
+    LinuxMemoryMonitor& operator=(LinuxMemoryMonitor&&) = delete;
+
+    uint64_t Usage(MemoryType memory_type) const override
+    {
+        uint64_t usage = 0;
+        std::ifstream file(m_path_str);
+        std::string line;
+
+        std::string const memory_type_str = memory_type_map.at(memory_type);
+        while (std::getline(file, line))
+        {
+            if (line.find(memory_type_str) != std::string::npos)
+            {
+                usage = Bytes(line);
+                /*if (memory_type == MemoryType::Physical)
+                {
+                    usage *= page_size;
+                }*/
+                break;
+            }
+        }
+        return usage;
+    }
+
+private:
+    std::string m_path_str;
+
+    inline static std::map<MemoryType, std::string> const memory_type_map = {
+        {MemoryType::Physical, "VmRSS"},
+        {MemoryType::PhysicalPeak, "VmHWM"},
+        {MemoryType::Virtual, "VmSize"},
+        {MemoryType::VirtualPeak, "VmPeak"} //
+    };
+
+    inline static std::map<char, uint64_t> unit_prefix_map = {
+        {'k', 1}, // kilo
+        {'K', 1}, // Kilo
+        {'m', 2}, // mega
+        {'M', 2}, // Mega
+        {'g', 3}, // giga
+        {'G', 3}  // Giga
+    };
+
+    inline static uint64_t constexpr kilobyte = 1024;
+
+    inline static uint64_t const page_size = sysconf(_SC_PAGE_SIZE); // in bytes
+
+    static uint64_t ConversionFactor(std::string const& unit)
+    {
+        uint64_t conversion_factor = 1;
+        char const byte = unit[1];
+        if (byte == 'b' || byte == 'B')
+        {
+            char const unit_prefix = unit[0];
+            conversion_factor = std::pow(kilobyte, unit_prefix_map.at(unit_prefix));
+        }
+        else
+        {
+            throw std::runtime_error("Memory is not measured bytes");
+        }
+        return conversion_factor;
+    }
+
+    // ex: VmPeak:     4296 kB
+    //  KEY:            VALUE UNIT
+    // >   < key
+    //    > < colon
+    //     >    < tab
+    //         >        < spaces
+    //                 >     < value
+    //                      > < space
+    //                        >  < unit (2 chars)
+    // position of colon separating the key from the value
+
+    static uint64_t Bytes(std::string& line)
+    {
+        size_t const key_end_pos = line.find(':');
+        size_t const value_start_pos = line.find_first_not_of('\t', key_end_pos + 1);
+        size_t const value_end_pos = line.size() - 2;
+        std::string const value(line.begin() + value_start_pos, line.begin() + value_end_pos);
+        uint64_t const usage = std::stoull(value.c_str());
+        std::string const unit(line.begin() + value_end_pos, line.end());
+        uint64_t const conversion_factor = ConversionFactor(unit);
+        return usage * conversion_factor;
+    }
+};
+
+#endif