Merge pull request #2526 from w0lek/ipa_it2_clean

Interactive Path Analysis Feature Integration

Author: vaughnbetz

.github/workflows/test.yml

@@ -197,6 +197,11 @@ jobs:
             params: '-DVTR_ASSERT_LEVEL=3 -DWITH_BLIFEXPLORER=on -DVPR_USE_EZGL=off',
             suite: 'vtr_reg_basic'
           },
+          {
+            name: 'Basic with NO_SERVER',
+            params: '-DVTR_ASSERT_LEVEL=3 -DWITH_BLIFEXPLORER=on -DVPR_USE_EZGL=on -DVPR_USE_SERVER=off',
+            suite: 'vtr_reg_basic'
+          },
           {
             name: 'Basic with CAPNPROTO disabled',
             params: '-DVTR_ASSERT_LEVEL=3 -DWITH_BLIFEXPLORER=on -DVTR_ENABLE_CAPNPROTO=off',

.gitmodules

@@ -1,3 +1,7 @@
 [submodule "libs/EXTERNAL/libcatch2"]
 	path = libs/EXTERNAL/libcatch2
 	url = https://github.com/catchorg/Catch2.git
+[submodule "libs/EXTERNAL/sockpp"]
+	path = libs/EXTERNAL/sockpp
+	#url = git@github.com:fpagliughi/sockpp.git
+	url = git@github.com:w0lek/sockpp.git # fork where in branch v1.0.0_no_complication_warnings there are compilation warnings fixes for upstream tag v1.0.0 of sockpp

CMakeLists.txt

@@ -39,6 +39,9 @@ set(VPR_USE_EZGL "auto" CACHE STRING "Specify whether vpr uses the graphics libr
 set_property(CACHE VPR_USE_EZGL PROPERTY STRINGS auto off on)
 option(VTR_ENABLE_CAPNPROTO "Enable capnproto binary serialization support in VPR." ON)
 
+#Allow the user to decide whether to compile the server module
+option(VPR_USE_SERVER "Specify whether vpr enables the server mode" ON)
+
 #Allow the user to enable/disable VPR analytic placement
 #VPR option --enable_analytic_placer is also required for Analytic Placement
 option(VPR_ANALYTIC_PLACE "Enable analytic placement in VPR." ON)

libs/EXTERNAL/CMakeLists.txt

@@ -11,6 +11,14 @@ add_subdirectory(libtatum)
 add_subdirectory(libcatch2)
 #add_subdirectory(parmys)
 
+#VPR_USE_SERVER is initialized in the root CMakeLists
+#compile sockpp only if server mode is enabled
+if (VPR_USE_SERVER)
+    set(SOCKPP_BUILD_SHARED OFF CACHE BOOL "Override default value" FORCE)
+    set(SOCKPP_BUILD_STATIC ON CACHE BOOL "Override default value" FORCE)
+    add_subdirectory(sockpp)
+endif()
+
 #VPR_USE_EZGL is initialized in the root CMakeLists.
 #compile libezgl only if the user asks for or has its dependencies installed.
 if (VPR_USE_EZGL STREQUAL "on")
@@ -132,3 +140,12 @@ target_include_directories(Catch2
         $<INSTALL_INTERFACE:include>
         )
 
+# Some sockpp headers generate warnings, so treat them as system headers to suppress warnings
+if (VPR_USE_SERVER)
+    target_include_directories(sockpp-static
+            SYSTEM
+            PUBLIC
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/sockpp/include>
+            $<INSTALL_INTERFACE:include>
+            )
+endif()

libs/EXTERNAL/libtatum/libtatum/tatum/TimingReporter.cpp

@@ -99,6 +99,15 @@ void TimingReporter::report_timing_setup(std::ostream& os,
     report_timing(os, paths);
 }
 
+void TimingReporter::report_timing_setup(std::vector<tatum::TimingPath>& paths,
+                                         std::ostream& os,
+                                         const SetupTimingAnalyzer& setup_analyzer,
+                                         size_t npaths) const {
+    paths = path_collector_.collect_worst_setup_timing_paths(timing_graph_, setup_analyzer, npaths);
+
+    report_timing(os, paths);
+}
+
 void TimingReporter::report_timing_hold(std::string filename, 
                                          const HoldTimingAnalyzer& hold_analyzer,
                                          size_t npaths) const {
@@ -114,6 +123,15 @@ void TimingReporter::report_timing_hold(std::ostream& os,
     report_timing(os, paths);
 }
 
+void TimingReporter::report_timing_hold(std::vector<tatum::TimingPath>& paths,
+                                         std::ostream& os,
+                                         const HoldTimingAnalyzer& hold_analyzer,
+                                         size_t npaths) const {
+    paths = path_collector_.collect_worst_hold_timing_paths(timing_graph_, hold_analyzer, npaths);
+
+    report_timing(os, paths);
+}
+
 void TimingReporter::report_skew_setup(std::string filename, 
                                          const SetupTimingAnalyzer& setup_analyzer,
                                          size_t nworst) const {

libs/EXTERNAL/libtatum/libtatum/tatum/TimingReporter.hpp

@@ -64,9 +64,11 @@ class TimingReporter {
     public:
         void report_timing_setup(std::string filename, const tatum::SetupTimingAnalyzer& setup_analyzer, size_t npaths=REPORT_TIMING_DEFAULT_NPATHS) const;
         void report_timing_setup(std::ostream& os, const tatum::SetupTimingAnalyzer& setup_analyzer, size_t npaths=REPORT_TIMING_DEFAULT_NPATHS) const;
+        void report_timing_setup(std::vector<tatum::TimingPath>& paths, std::ostream& os, const tatum::SetupTimingAnalyzer& setup_analyzer, size_t npaths=REPORT_TIMING_DEFAULT_NPATHS) const;
 
         void report_timing_hold(std::string filename, const tatum::HoldTimingAnalyzer& hold_analyzer, size_t npaths=REPORT_TIMING_DEFAULT_NPATHS) const;
         void report_timing_hold(std::ostream& os, const tatum::HoldTimingAnalyzer& hold_analyzer, size_t npaths=REPORT_TIMING_DEFAULT_NPATHS) const;
+        void report_timing_hold(std::vector<tatum::TimingPath>& paths, std::ostream& os, const tatum::HoldTimingAnalyzer& hold_analyzer, size_t npaths=REPORT_TIMING_DEFAULT_NPATHS) const;
 
         void report_skew_setup(std::string filename, const tatum::SetupTimingAnalyzer& setup_analyzer, size_t nworst=REPORT_TIMING_DEFAULT_NPATHS) const;
         void report_skew_setup(std::ostream& os, const tatum::SetupTimingAnalyzer& setup_analyzer, size_t nworst=REPORT_TIMING_DEFAULT_NPATHS) const;

libs/EXTERNAL/sockpp

@@ -32,6 +32,25 @@ else()
     message(STATUS "EZGL: graphics disabled")
 endif()
 
+
+#Handle server setup
+set(SERVER_DEFINES "")
+
+set(SERVER_DISABILED_REASON "")
+if (VPR_USE_SERVER)
+    if (VPR_USE_EZGL STREQUAL "off")
+        set(SERVER_DISABILED_REASON ", due to EZGL being disabled")
+        set(VPR_USE_SERVER OFF)
+    endif()
+endif()
+
+if (VPR_USE_SERVER)
+    message(STATUS "Server mode is enabled")
+else()
+    list(APPEND SERVER_DEFINES "-DNO_SERVER")
+    message(STATUS "Server mode is disabled${SERVER_DISABILED_REASON}")
+endif()
+
 #
 # Build Configuration
 #
@@ -87,6 +106,13 @@ target_link_libraries(libvpr
                         librrgraph
 )
 
+if(VPR_USE_SERVER)
+    target_link_libraries(libvpr
+                          sockpp-static
+                          -lz
+    )
+endif()
+
 #link graphics library only when graphics set to on
 if (VPR_USE_EZGL STREQUAL "on")
     target_link_libraries(libvpr
@@ -123,7 +149,7 @@ if (VPR_USE_EZGL STREQUAL "on")
 
 endif()
 
-target_compile_definitions(libvpr PUBLIC ${GRAPHICS_DEFINES})
+target_compile_definitions(libvpr PUBLIC ${GRAPHICS_DEFINES} ${SERVER_DEFINES})
 
 if(${VTR_ENABLE_CAPNPROTO})
     target_link_libraries(libvpr libvtrcapnproto)

vpr/CMakeLists.txt

@@ -10,6 +10,7 @@
 void CheckSetup(const t_packer_opts& PackerOpts,
                 const t_placer_opts& PlacerOpts,
                 const t_router_opts& RouterOpts,
+                const t_server_opts& ServerOpts,
                 const t_det_routing_arch& RoutingArch,
                 const std::vector<t_segment_inf>& Segments,
                 const t_timing_inf Timing,
@@ -105,4 +106,12 @@ void CheckSetup(const t_packer_opts& PackerOpts,
                             "Place channel width must be even for unidirectional.\n");
         }
     }
+
+    if (ServerOpts.is_server_mode_enabled) {
+        if (ServerOpts.port_num < DYMANIC_PORT_RANGE_MIN || ServerOpts.port_num > DYNAMIC_PORT_RANGE_MAX) {
+                VPR_FATAL_ERROR(VPR_ERROR_OTHER,
+                                "Specified server port number `--port %d` is out of range [%d-%d]. Please specify a port number within that range.\n",
+                                ServerOpts.port_num, DYMANIC_PORT_RANGE_MIN, DYNAMIC_PORT_RANGE_MAX);
+        }
+    }
 }

vpr/src/base/CheckSetup.cpp

@@ -2,9 +2,13 @@
 #define CHECKSETUP_H
 #include "vpr_types.h"
 
+const int DYMANIC_PORT_RANGE_MIN = 49152;
+const int DYNAMIC_PORT_RANGE_MAX = 65535;
+
 void CheckSetup(const t_packer_opts& PackerOpts,
                 const t_placer_opts& PlacerOpts,
                 const t_router_opts& RouterOpts,
+                const t_server_opts& ServerOpts,
                 const t_det_routing_arch& RoutingArch,
                 const std::vector<t_segment_inf>& Segments,
                 const t_timing_inf Timing,

vpr/src/base/CheckSetup.h

@@ -38,6 +38,8 @@ static void SetupAnnealSched(const t_options& Options,
 static void SetupRouterOpts(const t_options& Options, t_router_opts* RouterOpts);
 static void SetupNocOpts(const t_options& Options,
                          t_noc_opts* NocOpts);
+static void SetupServerOpts(const t_options& Options,
+                            t_server_opts* ServerOpts);
 static void SetupRoutingArch(const t_arch& Arch, t_det_routing_arch* RoutingArch);
 static void SetupTiming(const t_options& Options, const bool TimingEnabled, t_timing_inf* Timing);
 static void SetupSwitches(const t_arch& Arch,
@@ -99,6 +101,7 @@ void SetupVPR(const t_options* Options,
               t_router_opts* RouterOpts,
               t_analysis_opts* AnalysisOpts,
               t_noc_opts* NocOpts,
+              t_server_opts* ServerOpts,
               t_det_routing_arch* RoutingArch,
               std::vector<t_lb_type_rr_node>** PackerRRGraphs,
               std::vector<t_segment_inf>& Segments,
@@ -144,6 +147,7 @@ void SetupVPR(const t_options* Options,
     SetupAnalysisOpts(*Options, *AnalysisOpts);
     SetupPowerOpts(*Options, PowerOpts, Arch);
     SetupNocOpts(*Options, NocOpts);
+    SetupServerOpts(*Options, ServerOpts);
 
     if (readArchFile == true) {
         vtr::ScopedStartFinishTimer t("Loading Architecture Description");
@@ -743,6 +747,11 @@ static void SetupNocOpts(const t_options& Options, t_noc_opts* NocOpts) {
     NocOpts->noc_placement_file_name = Options.noc_placement_file_name;
 }
 
+static void SetupServerOpts(const t_options& Options, t_server_opts* ServerOpts) {
+    ServerOpts->is_server_mode_enabled = Options.is_server_mode_enabled;
+    ServerOpts->port_num = Options.server_port_num;
+}
+
 static void find_ipin_cblock_switch_index(const t_arch& Arch, int& wire_to_arch_ipin_switch, int& wire_to_arch_ipin_switch_between_dice) {
     for (auto cb_switch_name_index = 0; cb_switch_name_index < (int)Arch.ipin_cblock_switch_name.size(); cb_switch_name_index++) {
         int ipin_cblock_switch_index = UNDEFINED;

vpr/src/base/SetupVPR.cpp

@@ -20,6 +20,7 @@ void SetupVPR(const t_options* Options,
               t_router_opts* RouterOpts,
               t_analysis_opts* AnalysisOpts,
               t_noc_opts* NocOpts,
+              t_server_opts* ServerOpts,
               t_det_routing_arch* RoutingArch,
               std::vector<t_lb_type_rr_node>** PackerRRGraphs,
               std::vector<t_segment_inf>& Segments,

vpr/src/base/SetupVPR.h

@@ -2874,6 +2874,21 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .default_value("vpr_noc_placement_output.txt")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+#ifndef NO_SERVER
+    auto& server_grp = parser.add_argument_group("server options");
+
+    server_grp.add_argument<bool, ParseOnOff>(args.is_server_mode_enabled, "--server")
+        .help("Run in server mode."
+              "Accept client application connection and respond to requests." )
+        .action(argparse::Action::STORE_TRUE)
+        .default_value("off");
+
+    server_grp.add_argument<int>(args.server_port_num, "--port")
+        .help("Server port number.")
+        .default_value("60555")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+#endif /* NO_SERVER */
+
     return parser;
 }
 

vpr/src/base/read_options.cpp

@@ -75,6 +75,10 @@ struct t_options {
     argparse::ArgValue<bool> allow_dangling_combinational_nodes;
     argparse::ArgValue<bool> terminate_if_timing_fails;
 
+    /* Server options */
+    argparse::ArgValue<bool> is_server_mode_enabled;
+    argparse::ArgValue<int> server_port_num;
+
     /* Atom netlist options */
     argparse::ArgValue<bool> absorb_buffer_luts;
     argparse::ArgValue<e_const_gen_inference> const_gen_inference;

vpr/src/base/read_options.h

@@ -102,6 +102,11 @@
 #    include <tbb/global_control.h>
 #endif
 
+#ifndef NO_SERVER
+#include "gateio.h"
+#include "serverupdate.h"
+#endif /* NO_SERVER */
+
 /* Local subroutines */
 static void free_complex_block_types();
 
@@ -291,6 +296,7 @@ void vpr_init_with_options(const t_options* options, t_vpr_setup* vpr_setup, t_a
              &vpr_setup->RouterOpts,
              &vpr_setup->AnalysisOpts,
              &vpr_setup->NocOpts,
+             &vpr_setup->ServerOpts,
              &vpr_setup->RoutingArch,
              &vpr_setup->PackerRRGraph,
              vpr_setup->Segments,
@@ -309,6 +315,7 @@ void vpr_init_with_options(const t_options* options, t_vpr_setup* vpr_setup, t_a
     CheckSetup(vpr_setup->PackerOpts,
                vpr_setup->PlacerOpts,
                vpr_setup->RouterOpts,
+               vpr_setup->ServerOpts,
                vpr_setup->RoutingArch, vpr_setup->Segments, vpr_setup->Timing, arch->Chans);
 
     /* flush any messages to user still in stdout that hasn't gotten displayed */
@@ -387,6 +394,9 @@ bool vpr_flow(t_vpr_setup& vpr_setup, t_arch& arch) {
 
     // TODO: Placer still assumes that cluster net list is used - graphics can not work with flat routing yet
     vpr_init_graphics(vpr_setup, arch, false);
+
+    vpr_init_server(vpr_setup);
+
     { //Place
         const auto& placement_net_list = (const Netlist<>&)g_vpr_ctx.clustering().clb_nlist;
         bool place_success = vpr_place_flow(placement_net_list, vpr_setup, arch);
@@ -806,6 +816,12 @@ RouteStatus vpr_route_flow(const Netlist<>& net_list,
             auto& atom_ctx = g_vpr_ctx.atom();
             routing_delay_calc = std::make_shared<RoutingDelayCalculator>(atom_ctx.nlist, atom_ctx.lookup, net_delay, is_flat);
             timing_info = make_setup_hold_timing_info(routing_delay_calc, router_opts.timing_update_type);
+#ifndef NO_SERVER
+            if (g_vpr_ctx.server().gateIO().is_running()) {
+                g_vpr_ctx.mutable_server().set_timing_info(timing_info);
+                g_vpr_ctx.mutable_server().set_routing_delay_calc(routing_delay_calc);
+            }
+#endif /* NO_SERVER */
         } else {
             /* No delay calculator (segfault if the code calls into it) and wirelength driven routing */
             timing_info = make_constant_timing_info(0);
@@ -1049,6 +1065,21 @@ void vpr_init_graphics(const t_vpr_setup& vpr_setup, const t_arch& arch, bool is
         alloc_draw_structs(&arch);
 }
 
+void vpr_init_server(const t_vpr_setup& vpr_setup) {
+#ifndef NO_SERVER
+    if (vpr_setup.ServerOpts.is_server_mode_enabled) {
+        /* Set up a server and its callback to be triggered at 100ms intervals by the timer's timeout event. */
+        server::GateIO& gate_io = g_vpr_ctx.mutable_server().mutable_gateIO();
+        if (!gate_io.is_running()) {
+            gate_io.start(vpr_setup.ServerOpts.port_num);
+            g_timeout_add(/*interval_ms*/ 100, server::update, &application);
+        }
+    }
+#else
+    (void)(vpr_setup);
+#endif /* NO_SERVER */
+}
+
 void vpr_close_graphics(const t_vpr_setup& /*vpr_setup*/) {
     /* Close down X Display */
     free_draw_structs();
@@ -1256,6 +1287,7 @@ void vpr_setup_vpr(t_options* Options,
                    t_router_opts* RouterOpts,
                    t_analysis_opts* AnalysisOpts,
                    t_noc_opts* NocOpts,
+                   t_server_opts* ServerOpts,
                    t_det_routing_arch* RoutingArch,
                    std::vector<t_lb_type_rr_node>** PackerRRGraph,
                    std::vector<t_segment_inf>& Segments,
@@ -1280,6 +1312,7 @@ void vpr_setup_vpr(t_options* Options,
              RouterOpts,
              AnalysisOpts,
              NocOpts,
+             ServerOpts,
              RoutingArch,
              PackerRRGraph,
              Segments,
@@ -1300,11 +1333,12 @@ void vpr_check_arch(const t_arch& Arch) {
 void vpr_check_setup(const t_packer_opts& PackerOpts,
                      const t_placer_opts& PlacerOpts,
                      const t_router_opts& RouterOpts,
+                     const t_server_opts& ServerOpts,
                      const t_det_routing_arch& RoutingArch,
                      const std::vector<t_segment_inf>& Segments,
                      const t_timing_inf& Timing,
                      const t_chan_width_dist& Chans) {
-    CheckSetup(PackerOpts, PlacerOpts, RouterOpts, RoutingArch,
+    CheckSetup(PackerOpts, PlacerOpts, RouterOpts, ServerOpts, RoutingArch,
                Segments, Timing, Chans);
 }
 

vpr/src/base/vpr_api.cpp

@@ -139,6 +139,8 @@ void vpr_create_device_grid(const t_vpr_setup& vpr_setup, const t_arch& Arch);
 void vpr_create_rr_graph(t_vpr_setup& vpr_setup, const t_arch& arch, int chan_width, bool is_flat);
 
 void vpr_init_graphics(const t_vpr_setup& vpr_setup, const t_arch& arch, bool is_flat);
+void vpr_init_server(const t_vpr_setup& vpr_setup);
+
 void vpr_close_graphics(const t_vpr_setup& vpr_setup);
 
 void vpr_setup_clock_networks(t_vpr_setup& vpr_setup, const t_arch& Arch);
@@ -177,6 +179,7 @@ void vpr_setup_vpr(t_options* Options,
                    t_router_opts* RouterOpts,
                    t_analysis_opts* AnalysisOpts,
                    t_noc_opts* NocOpts,
+                   t_server_opts* ServerOpts,
                    t_det_routing_arch* RoutingArch,
                    std::vector<t_lb_type_rr_node>** PackerRRGraph,
                    std::vector<t_segment_inf>& Segments,
@@ -195,6 +198,7 @@ void vpr_check_arch(const t_arch& Arch);
 void vpr_check_setup(const t_packer_opts& PackerOpts,
                      const t_placer_opts& PlacerOpts,
                      const t_router_opts& RouterOpts,
+                     const t_server_opts& ServerOpts,
                      const t_det_routing_arch& RoutingArch,
                      const std::vector<t_segment_inf>& Segments,
                      const t_timing_inf& Timing,