FEAT: run flags (#334)

closes #321

Author: PaulRalnikov

README.md

@@ -15,26 +15,34 @@ cmake --build build
 
 ```
 ./build/nons
-    --config path 
-    [--output-dir output-dir-name] 
+    --config path
+    [--output-dir output-dir-name]
     [--no-logs]
-    [--no-plots] 
-    [--export-metrics] 
+    [--no-plots]
+    [--export-metrics]
 ```
 
 Options:
 
 ```
--c, --config arg      Path to the simulation configuration file
-    --output-dir arg  Output directory for metrics and plots (default: metrics)
-    --no-logs         Disables logging
-    --no-plots        Disables plots generation
-    --export-metrics  Export metric values into output-dir
--h, --help            Print usage
+-c, --config arg          Path to the simulation configuration file
+    --output-dir arg      Output directory for metrics and plots
+                        (default: metrics)
+    --no-logs             Output without logs
+    --no-plots            Disables plots generation
+    --metrics-filter arg  Fiter for collecting metrics pathes
+                        (default: .*)
+-h, --help                Print usage
 ```
 
 Examples of simulation configs placed in `configuration_examples/simulation_examples`
 
+### `export-metrics` flag format
+
+This flags represents regular expression that match generated **data file names** under metrics output directory. Plots generates accordingly to collected data.
+
+E.g. if `--metrics-filter = "cwnd/.*"`, NoNS measures only CWND values, if `--metrics-filter = ".*_link1.*"`, only metircs about link1.
+
 ## Resuls of simulations
 
 Metrics of all simulation runs deploys to [gihub pages](https://cloud-storage-team.github.io/algnet/main). If you want to see results on all branches, visit [root site](https://cloud-storage-team.github.io/algnet).

source/main.cpp

@@ -15,38 +15,34 @@ int main(const int argc, char **argv) {
         cxxopts::value<bool>()->default_value("false"))(
         "no-plots", "Disables plots generation",
         cxxopts::value<bool>()->default_value("false"))(
-        "export-metrics", "Export metric values into output-dir",
-        cxxopts::value<bool>()->default_value("false"))("h,help",
-                                                        "Print usage");
-
-    try {
-        auto flags = options.parse(argc, argv);
-        auto output_dir = flags["output-dir"].as<std::string>();
-
-        if (flags.contains("help")) {
-            std::cout << options.help() << std::endl;
-            return 0;
-        }
-
-        if (flags["no-logs"].as<bool>()) {
-            Logger::get_instance().disable_logs();
-        }
-
-        sim::YamlParser parser;
-        auto [simulator, simulation_time] = parser.build_simulator_from_config(
-            flags["config"].as<std::string>());
-        std::visit([&](auto &sim) { sim.start(simulation_time); }, simulator);
-
-        if (!flags["no-plots"].as<bool>()) {
-            sim::MetricsCollector::get_instance().draw_metric_plots(output_dir);
-        }
-        if (flags["export-metrics"].as<bool>()) {
-            sim::MetricsCollector::get_instance().export_metrics_to_files(
-                output_dir);
-        }
-    } catch (const std::exception &e) {
-        std::cerr << fmt::format("Error: {}", e.what()) << std::endl;
-        return 1;
+        "metrics-filter", "Fiter for collecting metrics pathes",
+        cxxopts::value<std::string>()->default_value(".*"))("h,help",
+                                                            "Print usage");
+
+    auto flags = options.parse(argc, argv);
+    auto output_dir = flags["output-dir"].as<std::string>();
+
+    if (flags.contains("help")) {
+        std::cout << options.help() << std::endl;
+        return 0;
     }
+
+    if (flags["no-logs"].as<bool>()) {
+        Logger::get_instance().disable_logs();
+    }
+
+    sim::MetricsCollector::get_instance().set_metrics_filter(
+        flags["metrics-filter"].as<std::string>());
+
+    sim::YamlParser parser;
+    auto [simulator, simulation_time] =
+        parser.build_simulator_from_config(flags["config"].as<std::string>());
+    std::visit([&](auto &sim) { sim.start(simulation_time); }, simulator);
+
+    if (!flags["no-plots"].as<bool>()) {
+        sim::MetricsCollector::get_instance().draw_metric_plots(output_dir);
+    }
+    sim::MetricsCollector::get_instance().export_metrics_to_files(output_dir);
+
     return 0;
 }

source/metrics/metrics_collector.cpp

@@ -1,13 +1,11 @@
-#include "metrics/metrics_collector.hpp"
+#include "metrics_collector.hpp"
 
-#include <matplot/matplot.h>
 #include <spdlog/fmt/fmt.h>
 
-#include <filesystem>
-
 #include "flow/i_flow.hpp"
 #include "link/i_link.hpp"
 #include "utils/identifier_factory.hpp"
+#include "utils/safe_matplot.hpp"
 
 namespace sim {
 
@@ -17,42 +15,28 @@ MetricsCollector& MetricsCollector::get_instance() {
 }
 
 void MetricsCollector::add_cwnd(Id flow_id, Time time, double cwnd) {
-    m_cwnd_storage[flow_id].add_record(time, cwnd);
+    m_cwnd_storage.add_record(std::move(flow_id), time, cwnd);
 }
 
 void MetricsCollector::add_delivery_rate(Id flow_id, Time time, double value) {
-    m_rate_storage[flow_id].add_record(time, value);
+    m_rate_storage.add_record(std::move(flow_id), time, value);
 }
 
 void MetricsCollector::add_RTT(Id flow_id, Time time, Time value) {
-    m_RTT_storage[flow_id].add_record(time, value);
-}
-
-void MetricsCollector::export_metrics_to_files(
-    std::filesystem::path metrics_dir) const {
-    for (auto& [flow_id, values] : m_RTT_storage) {
-        values.export_to_file(metrics_dir / fmt::format("rtt_{}.txt", flow_id));
-    }
-
-    for (auto& [link_id, values] : m_queue_size_storage) {
-        values.export_to_file(metrics_dir /
-                              fmt::format("queue_size_{}.txt", link_id));
-    }
-
-    for (auto& [flow_id, values] : m_cwnd_storage) {
-        values.export_to_file(metrics_dir /
-                              fmt::format("cwnd_{}.txt", flow_id));
-    }
-
-    for (auto& [flow_id, values] : m_rate_storage) {
-        values.export_to_file(metrics_dir /
-                              fmt::format("rate_{}.txt", flow_id));
-    }
+    m_RTT_storage.add_record(std::move(flow_id), time, value);
 }
 
 void MetricsCollector::add_queue_size(Id link_id, Time time,
                                       std::uint32_t value) {
-    m_queue_size_storage[link_id].add_record(time, value);
+    m_queue_size_storage.add_record(std::move(link_id), time, value);
+}
+
+void MetricsCollector::export_metrics_to_files(
+    std::filesystem::path metrics_dir) const {
+    m_RTT_storage.export_to_files(metrics_dir);
+    m_queue_size_storage.export_to_files(metrics_dir);
+    m_cwnd_storage.export_to_files(metrics_dir);
+    m_rate_storage.export_to_files(metrics_dir);
 }
 
 // verctor of pairs<Storage, curve name>
@@ -76,14 +60,14 @@ static void draw_on_same_plot(std::filesystem::path path, PlotMetricsData data,
     ax->title(metadata.title);
     ax->legend(std::vector<std::string>());
 
-    matplot::save(fig, path.string());
+    matplot::safe_save(fig, path.string());
 }
 
 void MetricsCollector::draw_cwnd_plot(std::filesystem::path path) const {
     PlotMetricsData data;
     std::transform(
-        begin(m_cwnd_storage), end(m_cwnd_storage), std::back_inserter(data),
-        [](auto const& pair) {
+        begin(m_cwnd_storage.data()), end(m_cwnd_storage.data()),
+        std::back_inserter(data), [](auto const& pair) {
             auto flow =
                 IdentifierFactory::get_instance().get_object<IFlow>(pair.first);
             std::string name =
@@ -98,8 +82,8 @@ void MetricsCollector::draw_cwnd_plot(std::filesystem::path path) const {
 void MetricsCollector::draw_RTT_plot(std::filesystem::path path) const {
     PlotMetricsData data;
     std::transform(
-        begin(m_RTT_storage), end(m_RTT_storage), std::back_inserter(data),
-        [](auto const& pair) {
+        begin(m_RTT_storage.data()), end(m_RTT_storage.data()),
+        std::back_inserter(data), [](auto const& pair) {
             auto flow =
                 IdentifierFactory::get_instance().get_object<IFlow>(pair.first);
             std::string name =
@@ -115,8 +99,8 @@ void MetricsCollector::draw_delivery_rate_plot(
     std::filesystem::path path) const {
     PlotMetricsData data;
     std::transform(
-        begin(m_rate_storage), end(m_rate_storage), std::back_inserter(data),
-        [](auto const& pair) {
+        begin(m_rate_storage.data()), end(m_rate_storage.data()),
+        std::back_inserter(data), [](auto const& pair) {
             auto flow =
                 IdentifierFactory::get_instance().get_object<IFlow>(pair.first);
             std::string name =
@@ -130,7 +114,7 @@ void MetricsCollector::draw_delivery_rate_plot(
 
 void MetricsCollector::draw_queue_size_plots(
     std::filesystem::path dir_path) const {
-    for (auto& [link_id, values] : m_queue_size_storage) {
+    for (auto& [link_id, values] : m_queue_size_storage.data()) {
         auto link =
             IdentifierFactory::get_instance().get_object<ILink>(link_id);
         auto fig = values.get_picture(
@@ -149,7 +133,10 @@ void MetricsCollector::draw_queue_size_plots(
 
         ax->color("white");
 
-        matplot::save(fig, dir_path / fmt::format("{}.svg", link_id));
+        std::filesystem::path plot_path =
+            dir_path / fmt::format("{}.svg", link_id);
+
+        matplot::safe_save(fig, plot_path.string());
     }
 }
 
@@ -161,4 +148,11 @@ void MetricsCollector::draw_metric_plots(
     draw_queue_size_plots(metrics_dir / "queue_size");
 }
 
+void MetricsCollector::set_metrics_filter(const std::string& filter) {
+    m_RTT_storage.set_filter(filter);
+    m_cwnd_storage.set_filter(filter);
+    m_rate_storage.set_filter(filter);
+    m_queue_size_storage.set_filter(filter);
+}
+
 }  // namespace sim

source/metrics/metrics_collector.hpp

@@ -1,8 +1,9 @@
 #pragma once
 
+#include <regex>
 #include <unordered_map>
 
-#include "metrics/metrics_storage.hpp"
+#include "multi_id_metrics_storage.hpp"
 
 namespace sim {
 
@@ -18,6 +19,8 @@ class MetricsCollector {
     void export_metrics_to_files(std::filesystem::path metrics_dir) const;
     void draw_metric_plots(std::filesystem::path metrics_dir) const;
 
+    void set_metrics_filter(const std::string& filter);
+
 private:
     MetricsCollector() {}
     MetricsCollector(const MetricsCollector&) = delete;
@@ -29,12 +32,13 @@ class MetricsCollector {
     void draw_queue_size_plots(std::filesystem::path dir_path) const;
 
     // flow_ID --> vector of <time, ...> values
-    std::unordered_map<Id, MetricsStorage> m_RTT_storage;
-    std::unordered_map<Id, MetricsStorage> m_cwnd_storage;
-    std::unordered_map<Id, MetricsStorage> m_rate_storage;
+    MultiIdMetricsStorage m_RTT_storage = MultiIdMetricsStorage("rtt");
+    MultiIdMetricsStorage m_cwnd_storage = MultiIdMetricsStorage("cwnd");
+    MultiIdMetricsStorage m_rate_storage = MultiIdMetricsStorage("rate");
 
     // link_ID --> vector of <time, queue size> values
-    std::unordered_map<Id, MetricsStorage> m_queue_size_storage;
+    MultiIdMetricsStorage m_queue_size_storage =
+        MultiIdMetricsStorage("queue_size");
 };
 
 }  // namespace sim

source/metrics/metrics_storage.cpp

@@ -2,26 +2,15 @@
 
 #include <spdlog/fmt/fmt.h>
 
+#include "utils/safe_matplot.hpp"
+
 namespace sim {
 
 void MetricsStorage::add_record(Time time, double value) {
     m_records.emplace_back(time, value);
 }
-
-void static create_all_directories(std::filesystem::path path) {
-    std::filesystem::path dir_path = path.parent_path();
-    if (std::filesystem::exists(dir_path)) {
-        return;
-    }
-    if (!std::filesystem::create_directories(dir_path) ||
-        !std::filesystem::exists(dir_path)) {
-        throw std::runtime_error(
-            fmt::format("Can not create {} directory", dir_path.string()));
-    }
-}
-
 void MetricsStorage::export_to_file(std::filesystem::path path) const {
-    create_all_directories(path);
+    utils::create_all_directories(path);
     std::ofstream output_file(path);
     if (!output_file) {
         throw std::runtime_error("Failed to create file for metric values");
@@ -48,8 +37,7 @@ matplot::figure_handle MetricsStorage::get_picture(
 void MetricsStorage::draw_plot(std::filesystem::path path,
                                PlotMetadata metadata) const {
     auto fig = get_picture(metadata);
-    create_all_directories(path);
-    matplot::save(fig, path.string());
+    matplot::safe_save(fig, path.string());
 }
 
 void MetricsStorage::draw_on_plot(matplot::figure_handle& fig,

source/metrics/multi_id_metrics_collector.cpp

@@ -0,0 +1,51 @@
+#include <ranges>
+
+#include "multi_id_metrics_storage.hpp"
+
+namespace sim {
+MultiIdMetricsStorage::MultiIdMetricsStorage(std::string a_metric_name)
+    : metric_name(std::move(a_metric_name)) {}
+
+void MultiIdMetricsStorage::add_record(Id id, Time time, double value) {
+    auto it = m_storage.find(id);
+    if (it == m_storage.end()) {
+        if (!std::regex_match(get_metrics_filename(id), m_filter)) {
+            m_storage[id] = std::nullopt;
+        } else {
+            MetricsStorage new_storage;
+            new_storage.add_record(time, value);
+            m_storage.emplace(std::move(id), std::move(new_storage));
+        }
+    } else if (it->second.has_value()) {
+        it->second->add_record(time, value);
+    }
+}
+
+void MultiIdMetricsStorage::export_to_files(
+    std::filesystem::path output_dir_path) const {
+    for (auto& [id, values] : m_storage) {
+        if (values) {
+            values->export_to_file(output_dir_path / get_metrics_filename(id));
+        }
+    }
+}
+
+std::unordered_map<Id, MetricsStorage> MultiIdMetricsStorage::data() const {
+    std::unordered_map<Id, MetricsStorage> result;
+    for (auto [id, maybe_storage] : m_storage) {
+        if (maybe_storage) {
+            result[id] = maybe_storage.value();
+        }
+    }
+    return result;
+}
+
+void MultiIdMetricsStorage::set_filter(std::string filter) {
+    m_filter = std::regex(filter);
+}
+
+std::string MultiIdMetricsStorage::get_metrics_filename(Id id) const {
+    return fmt::format("{}/{}.txt", metric_name, id);
+}
+
+}  // namespace sim