Add "Load model ram used (KB)" metric for BAPP

Author: nikita-kud

samples/cpp/benchmark_app/main.cpp

@@ -35,9 +35,71 @@
 #include "remote_tensors_filling.hpp"
 #include "statistics_report.hpp"
 #include "utils.hpp"
+
+#if defined _WIN32
+#include <windows.h>
+#include <psapi.h>
+#else
+#include <fstream>
+#include <regex>
+#include <sstream>
+#endif
+
 // clang-format on
 
 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
+
 bool parse_and_check_command_line(int argc, char* argv[]) {
     // ---------------------------Parsing and validating input
     // arguments--------------------------------------
@@ -563,10 +625,18 @@ int main(int argc, char* argv[]) {
             slog::info << "Skipping the step for loading model from file" << slog::endl;
             next_step();
             slog::info << "Skipping the step for loading model from file" << slog::endl;
+            auto compile_model_mem_start = get_peak_memory_usage();
             auto startTime = Time::now();
             compiledModel = core.compile_model(FLAGS_m, device_name, device_config);
             auto duration_ms = get_duration_ms_till_now(startTime);
+            auto compile_model_mem_end = get_peak_memory_usage();
             slog::info << "Compile model took " << double_to_string(duration_ms) << " ms" << slog::endl;
+
+            slog::info << "Start of compilation memory usage: Peak " << compile_model_mem_start << " KB" << slog::endl;
+            slog::info << "End of compilation memory usage: Peak " << compile_model_mem_end << " KB" << slog::endl;
+            slog::info << "Load model ram used " << compile_model_mem_end - compile_model_mem_start << " KB"
+                       << slog::endl;
+
             slog::info << "Original model I/O parameters:" << slog::endl;
             printInputAndOutputsInfoShort(compiledModel);
 
@@ -737,10 +807,18 @@ int main(int argc, char* argv[]) {
             // ----------------- 7. Loading the model to the device
             // --------------------------------------------------------
             next_step();
+            auto compile_model_mem_start = get_peak_memory_usage();
             startTime = Time::now();
             compiledModel = core.compile_model(model, device_name, device_config);
             duration_ms = get_duration_ms_till_now(startTime);
+            auto compile_model_mem_end = get_peak_memory_usage();
             slog::info << "Compile model took " << double_to_string(duration_ms) << " ms" << slog::endl;
+
+            slog::info << "Start of compilation memory usage: Peak " << compile_model_mem_start << " KB" << slog::endl;
+            slog::info << "End of compilation memory usage: Peak " << compile_model_mem_end << " KB" << slog::endl;
+            slog::info << "Load model ram used " << compile_model_mem_end - compile_model_mem_start << " KB"
+                       << slog::endl;
+
             if (statistics)
                 statistics->add_parameters(
                     StatisticsReport::Category::EXECUTION_RESULTS,
@@ -759,17 +837,26 @@ int main(int argc, char* argv[]) {
             // ----------------- 7. Loading the model to the device
             // --------------------------------------------------------
             next_step();
+            auto import_model_mem_start = get_peak_memory_usage();
             auto startTime = Time::now();
 
             std::ifstream modelStream(FLAGS_m, std::ios_base::binary | std::ios_base::in);
             if (!modelStream.is_open()) {
                 throw std::runtime_error("Cannot open model file " + FLAGS_m);
             }
+
             compiledModel = core.import_model(modelStream, device_name, device_config);
             modelStream.close();
 
             auto duration_ms = get_duration_ms_till_now(startTime);
+            auto import_model_mem_end = get_peak_memory_usage();
             slog::info << "Import model took " << double_to_string(duration_ms) << " ms" << slog::endl;
+
+            slog::info << "Start of import memory usage: Peak " << import_model_mem_start << " KB" << slog::endl;
+            slog::info << "End of import memory usage: Peak " << import_model_mem_end << " KB" << slog::endl;
+            slog::info << "Load model ram used " << import_model_mem_end - import_model_mem_start << " KB"
+                       << slog::endl;
+
             slog::info << "Original model I/O paramteters:" << slog::endl;
             printInputAndOutputsInfoShort(compiledModel);