std::move optimizations for crit paths result and report string

Author: w0lek

vpr/src/base/vpr_context.h

@@ -575,7 +575,7 @@ class ServerContext : public Context {
     const server::TaskResolver& task_resolver() const { return task_resolver_; }
     server::TaskResolver& mutable_task_resolver() { return task_resolver_; }
 
-    void set_crit_paths(const std::vector<tatum::TimingPath>& crit_paths) { crit_paths_ = crit_paths; }
+    void set_crit_paths(std::vector<tatum::TimingPath>&& crit_paths) { crit_paths_ = std::move(crit_paths); }
     const std::vector<tatum::TimingPath>& crit_paths() const { return crit_paths_; }
 
     void clear_crit_path_elements() { crit_path_element_indexes_.clear(); }

vpr/src/server/pathhelper.cpp

@@ -32,7 +32,7 @@ static void collect_crit_path_metadata(std::stringstream& ss, const std::vector<
 /** 
  * @brief Helper function to calculate critical path timing report with specified parameters.
  */
-CritPathsResult calc_critical_path(const std::string& report_type, int crit_path_num, e_timing_report_detail details_level, bool is_flat_routing) {
+CritPathsResultPtr calc_critical_path(const std::string& report_type, int crit_path_num, e_timing_report_detail details_level, bool is_flat_routing) {
     // shortcuts
     const std::shared_ptr<SetupHoldTimingInfo>& timing_info = g_vpr_ctx.server().timing_info();
     const std::shared_ptr<RoutingDelayCalculator>& routing_delay_calc = g_vpr_ctx.server().routing_delay_calc();
@@ -50,20 +50,21 @@ CritPathsResult calc_critical_path(const std::string& report_type, int crit_path
 
     tatum::TimingReporter timing_reporter(resolver, *timing_ctx.graph, *timing_ctx.constraints);
 
-    std::vector<tatum::TimingPath> paths;
+    CritPathsResultPtr result = std::make_shared<CritPathsResult>();
+
     std::stringstream ss;
     if (report_type == comm::KEY_SETUP_PATH_LIST) {
-        timing_reporter.report_timing_setup(paths, ss, *timing_info->setup_analyzer(), analysis_opts.timing_report_npaths);
+        timing_reporter.report_timing_setup(result->paths, ss, *timing_info->setup_analyzer(), analysis_opts.timing_report_npaths);
     } else if (report_type == comm::KEY_HOLD_PATH_LIST) {
-        timing_reporter.report_timing_hold(paths, ss, *timing_info->hold_analyzer(), analysis_opts.timing_report_npaths);
+        timing_reporter.report_timing_hold(result->paths, ss, *timing_info->hold_analyzer(), analysis_opts.timing_report_npaths);
     }
 
-    if (!paths.empty()) {
-        collect_crit_path_metadata(ss, paths);
-        return CritPathsResult{paths, ss.str()};
-    } else {
-        return CritPathsResult{std::vector<tatum::TimingPath>(), ""};
+    if (!result->paths.empty()) {
+        collect_crit_path_metadata(ss, result->paths);
+        result->report = ss.str();
     }
+
+    return result;
 }
 
 } // namespace server

vpr/src/server/pathhelper.h

@@ -5,6 +5,7 @@
 
 #include <vector>
 #include <string>
+#include <memory>
 
 #include "tatum/report/TimingPath.hpp"
 #include "vpr_types.h"
@@ -21,11 +22,12 @@ struct CritPathsResult {
     std::vector<tatum::TimingPath> paths;
     std::string report;
 };
+using CritPathsResultPtr = std::shared_ptr<CritPathsResult>;
 
 /** 
  * @brief Helper function to calculate critical path timing report with specified parameters.
  */
-CritPathsResult calc_critical_path(const std::string& type, int crit_path_num, e_timing_report_detail details_level, bool is_flat_routing);
+CritPathsResultPtr calc_critical_path(const std::string& type, int crit_path_num, e_timing_report_detail details_level, bool is_flat_routing);
 
 } // namespace server
 

vpr/src/server/task.cpp

@@ -40,8 +40,13 @@ void Task::fail(const std::string& error) {
     bake_response();
 }
 
-void Task::success(const std::string& result) {
-    m_result = result;
+void Task::success() {
+    m_is_finished = true;
+    bake_response();
+}
+
+void Task::success(std::string&& result) {
+    m_result = std::move(result);
     m_is_finished = true;
     bake_response();
 }

vpr/src/server/task.h

@@ -42,7 +42,8 @@ class Task {
     bool is_response_fully_sent() const { return m_is_response_fully_sent; }
 
     void fail(const std::string& error);
-    void success(const std::string& result = "");
+    void success();
+    void success(std::string&& result);
 
     std::string info(bool skip_duration = false) const;
 

vpr/src/server/taskresolver.cpp

@@ -99,14 +99,10 @@ void TaskResolver::process_get_path_list_task(ezgl::application*, const TaskPtr&
         // calculate critical path depending on options and store result in server context
         std::optional<e_timing_report_detail> details_level_opt = try_get_details_level_enum(details_level_str);
         if (details_level_opt) {
-            CritPathsResult crit_paths_result = calc_critical_path(path_type, n_critical_path_num, details_level_opt.value(), is_flat);
-
-            // setup context
-            server_ctx.set_crit_paths(crit_paths_result.paths);
-
-            if (crit_paths_result.is_valid()) {
-                std::string msg{crit_paths_result.report};
-                task->success(msg);
+            CritPathsResultPtr crit_paths_result = calc_critical_path(path_type, n_critical_path_num, details_level_opt.value(), is_flat);
+            if (crit_paths_result->is_valid()) {
+                server_ctx.set_crit_paths(std::move(crit_paths_result->paths));
+                task->success(std::move(crit_paths_result->report));
             } else {
                 std::string msg{"Critical paths report is empty"};
                 VTR_LOG_ERROR(msg.c_str());