Log compilation memory usage for CID

Author: nikita-kud

src/plugins/intel_npu/src/compiler_adapter/src/driver_compiler_adapter.cpp

@@ -79,8 +79,68 @@
 #include "ir_serializer.hpp"
 #include "openvino/core/model.hpp"
 
+#if defined _WIN32
+#include <windows.h>
+#include <psapi.h>
+#else
+#include <fstream>
+#include <regex>
+#include <sstream>
+#endif
+
 namespace {
 
+#if defined _WIN32
+
+int64_t get_peak_memory_usage() {
+    PROCESS_MEMORY_COUNTERS mem_counters;
+    if (!GetProcessMemoryInfo(GetCurrentProcess(), &mem_counters, sizeof(mem_counters))) {
+        throw std::runtime_error("Can't get system memory values");
+    }
+
+    // Linux tracks memory usage in pages and then converts them to kB.
+    // Thus, there is always some room for inaccuracy as pages are not guaranteed to be fully used.
+    // In Windows, the situation is different: the system returns the memory usage in bytes, not in pages.
+    // To align the output between the two operating systems as closely as possible, we have two options:
+    //     1. Use rounding to the nearest integer.
+    //     2. Try to estimate the number of pages used in Windows. However,
+    //         this approach is likely to be inaccurate as well, so option 1 was chosen.
+    static constexpr double bytes_in_kilobyte = 1024.0;
+
+    // please note then we calculate difference
+    // to get peak memory increment value, so we return int64, not size_t
+    return static_cast<int64_t>(std::round(mem_counters.PeakWorkingSetSize / bytes_in_kilobyte));
+}
+
+#else
+
+int64_t get_peak_memory_usage() {
+    size_t peak_mem_usage_kB = 0;
+
+    std::ifstream status_file("/proc/self/status");
+    std::string line;
+    std::regex vm_peak_regex("VmPeak:");
+    std::smatch vm_match;
+    bool mem_values_found = false;
+    while (std::getline(status_file, line)) {
+        if (std::regex_search(line, vm_match, vm_peak_regex)) {
+            std::istringstream iss(vm_match.suffix());
+            iss >> peak_mem_usage_kB;
+            mem_values_found = true;
+        }
+    }
+
+    if (!mem_values_found) {
+        throw std::runtime_error("Can't get system memory values");
+    }
+
+    // please note then we calculate difference
+    // to get peak memory increment value, so we return int64, not size_t
+    return static_cast<int64_t>(peak_mem_usage_kB);
+}
+
+#endif
+
 constexpr std::string_view INPUTS_PRECISIONS_KEY = "--inputs_precisions";
 constexpr std::string_view INPUTS_LAYOUTS_KEY = "--inputs_layouts";
 constexpr std::string_view OUTPUTS_PRECISIONS_KEY = "--outputs_precisions";
@@ -444,6 +504,7 @@ std::vector<std::shared_ptr<IGraph>> DriverCompilerAdapter::compileWS(const std:
     size_t callNumber = 0;
     bool compilationDone = false;
 
+    auto compile_model_mem_start = get_peak_memory_usage();
     while (!compilationDone) {
         _logger.debug("compileWS iteration %d", callNumber);
 
@@ -482,6 +543,12 @@ std::vector<std::shared_ptr<IGraph>> DriverCompilerAdapter::compileWS(const std:
             mainGraphHandle = graphHandle;
         }
     }
+    auto compile_model_mem_end = get_peak_memory_usage();
+
+    std::cout << "Start of compilation memory usage: Peak " << compile_model_mem_start << " KB" << std::endl;
+    std::cout << "End of compilation memory usage: Peak " << compile_model_mem_end << " KB" << std::endl;
+    std::cout << "Compilation memory usage: Peak " << compile_model_mem_end - compile_model_mem_start << " KB"
+               << std::endl;
 
     std::vector<std::shared_ptr<IGraph>> driverGraphs;
     for (size_t handleIndex = 0; handleIndex < initGraphHandles.size(); ++handleIndex) {