Merge pull request verilog-to-routing#2010 from verilog-to-routing/noc_description_support

Noc description support and modelling in VPR

Author: vaughnbetz

libs/libarchfpga/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.9)
 
 project("libarchfpga")
 
-file(GLOB_RECURSE EXEC_SOURCES main.cpp)
+file(GLOB_RECURSE EXEC_SOURCES src/main.cpp)
 file(GLOB_RECURSE LIB_SOURCES src/*.cpp)
 file(GLOB_RECURSE LIB_HEADERS src/*.h)
 files_to_dirs(LIB_HEADERS LIB_INCLUDE_DIRS)
@@ -41,3 +41,10 @@ if (READ_ARCH_USES_IPO)
 endif()
 
 install(TARGETS libarchfpga read_arch DESTINATION bin)
+
+# 
+# Unit Tests
+#
+file(GLOB_RECURSE TEST_SOURCES test/*.cpp)
+add_executable(test_archfpga ${TEST_SOURCES})
+target_link_libraries(test_archfpga Catch2::Catch2WithMain libarchfpga)

libs/libarchfpga/src/arch_util.cpp

@@ -204,6 +204,8 @@ void free_arch(t_arch* arch) {
     if (arch->clocks) {
         vtr::free(arch->clocks->clock_inf);
     }
+
+    delete (arch->noc);
 }
 
 //Frees all models in the linked list

libs/libarchfpga/src/physical_types.h

@@ -1791,6 +1791,43 @@ struct t_lut_element {
     }
 };
 
+/**
+ * Represents a Network-on-chip(NoC) Router data type. It is used
+ * to store individual router information when parsing the arch file.
+ * */
+struct t_router {
+    /** A unique id provided by the user to identify a router. Must be a positive value*/
+    int id = -1;
+
+    /** A value representing the approximate horizontal position on the FPGA device where the router
+     * tile is located*/
+    double device_x_position = -1;
+    /** A value representing the approximate vertical position on the FPGA device where the router
+     * tile is located*/
+    double device_y_position = -1;
+
+    /** A list of router ids that are connected to the current router*/
+    std::vector<int> connection_list;
+};
+
+/**
+ * Network-on-chip(NoC) data type used to store the network properties
+ * when parsing the arh file. This is used when building the dedicated on-chip
+ * network during the device creation.
+ * */
+struct t_noc_inf {
+    double link_bandwidth; /*!< The maximum bandwidth supported in the NoC. This value is the same for all links. units in bps*/
+    double link_latency;   /*!< The worst case latency seen when traversing a link. This value is the same for all links. units in seconds*/
+    double router_latency; /*!< The worst case latency seen when traversing a router. This value is the same for all routers, units in seconds*/
+
+    /** A list of all routers in the NoC*/
+    std::vector<t_router> router_list;
+
+    /** Represents the name of a router tile on the FPGA device. This should match the name used in the arch file when
+     * describing a NoC router tile within the FPGA device*/
+    std::string noc_router_tile_name;
+};
+
 /*   Detailed routing architecture */
 struct t_arch {
     mutable vtr::string_internment strings;
@@ -1851,6 +1888,9 @@ struct t_arch {
     std::vector<t_grid_def> grid_layouts; //Set of potential device layouts
 
     t_clock_arch_spec clock_arch; // Clock related data types
+
+    // if we have an embedded NoC in the architecture, then we store it here
+    t_noc_inf* noc = nullptr;
 };
 
 #endif

libs/libarchfpga/src/read_xml_arch_file.cpp

@@ -0,0 +1,2 @@
+#define CATCH_CONFIG_MAIN
+#include "catch2/catch_test_macros.hpp"

libs/libarchfpga/test/main.cpp

@@ -0,0 +1,269 @@
+// test framework
+#include "catch2/catch_test_macros.hpp"
+#include "catch2/matchers/catch_matchers_all.hpp"
+
+// testting statuc functions so include whole source file it is in
+#include "read_xml_arch_file.cpp"
+
+// for comparing floats
+#include "vtr_math.h"
+
+TEST_CASE("Updating router info in arch", "[NoC Arch Tests]") {
+    std::map<int, std::pair<int, int>> test_router_list;
+
+    std::map<int, std::pair<int, int>>::iterator it;
+
+    // initial conditions
+    int router_id = 1;
+    bool router_is_from_connection_list = false;
+
+    // we initially need the map to be empty
+    REQUIRE(test_router_list.size() == 0);
+
+    SECTION("Update the number of declarations for a router for the first time ") {
+        update_router_info_in_arch(router_id, router_is_from_connection_list, test_router_list);
+
+        it = test_router_list.find(router_id);
+
+        // check first that the router was newly added to the router databse
+        REQUIRE(it != test_router_list.end());
+
+        // no verify the components of the router parameter
+        REQUIRE(it->second.first == 1);
+        REQUIRE(it->second.second == 0);
+    }
+    SECTION("Update the number of connections for a router for the first time") {
+        router_is_from_connection_list = true;
+
+        update_router_info_in_arch(router_id, router_is_from_connection_list, test_router_list);
+
+        it = test_router_list.find(router_id);
+
+        // check first that the router was newly added to the router databse
+        REQUIRE(it != test_router_list.end());
+
+        // no verify the components of the router parameter
+        REQUIRE(it->second.first == 0);
+        REQUIRE(it->second.second == 1);
+    }
+    SECTION("Update the number of declarations for a router when it already exists") {
+        update_router_info_in_arch(router_id, router_is_from_connection_list, test_router_list);
+
+        // verify that a router was added
+        REQUIRE(test_router_list.size() != 0);
+
+        update_router_info_in_arch(router_id, router_is_from_connection_list, test_router_list);
+
+        it = test_router_list.find(router_id);
+
+        // check first that the router was newly added to the router databse
+        REQUIRE(it != test_router_list.end());
+
+        // no verify the components of the router parameter
+        REQUIRE(it->second.first == 2);
+        REQUIRE(it->second.second == 0);
+    }
+    SECTION("Update the number of connections for a router when it already exists") {
+        router_is_from_connection_list = true;
+
+        update_router_info_in_arch(router_id, router_is_from_connection_list, test_router_list);
+
+        // verify that a router was added
+        REQUIRE(test_router_list.size() != 0);
+
+        update_router_info_in_arch(router_id, router_is_from_connection_list, test_router_list);
+
+        it = test_router_list.find(router_id);
+
+        // check first that the router was newly added to the router databse
+        REQUIRE(it != test_router_list.end());
+
+        // no verify the components of the router parameter
+        REQUIRE(it->second.first == 0);
+        REQUIRE(it->second.second == 2);
+    }
+}
+
+TEST_CASE("Verifying a parsed NoC topology", "[NoC Arch Tests]") {
+    std::map<int, std::pair<int, int>> test_router_list;
+
+    REQUIRE(test_router_list.size() == 0);
+
+    SECTION("Check the error where a router in the NoC is not connected to other routers.") {
+        // error router
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(1, std::pair<int, int>(1, 0)));
+
+        // sonme normal routers
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(2, std::pair<int, int>(1, 5)));
+
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(3, std::pair<int, int>(1, 6)));
+
+        REQUIRE(test_router_list.size() == 3);
+
+        REQUIRE_THROWS_WITH(verify_noc_topology(test_router_list), "The router with id:'1' is not connected to any other router in the NoC.");
+    }
+    SECTION("Check the error where a router in the NoC is connected to other routers but missing a declaration in the arch file.") {
+        // normal routers
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(1, std::pair<int, int>(1, 5)));
+
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(2, std::pair<int, int>(1, 3)));
+
+        // error router
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(3, std::pair<int, int>(0, 5)));
+
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(4, std::pair<int, int>(1, 10)));
+
+        REQUIRE(test_router_list.size() == 4);
+
+        REQUIRE_THROWS_WITH(verify_noc_topology(test_router_list), "The router with id:'3' was found to be connected to another router but missing in the architecture file. Add the router using the <router> tag.");
+    }
+    SECTION("Check the error where the router is included more than once in the architecture file.") {
+        // normal routers
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(1, std::pair<int, int>(1, 5)));
+
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(2, std::pair<int, int>(1, 3)));
+
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(3, std::pair<int, int>(1, 10)));
+
+        // error routers
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(4, std::pair<int, int>(2, 10)));
+
+        // normal routers
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(5, std::pair<int, int>(1, 3)));
+
+        test_router_list.insert(std::pair<int, std::pair<int, int>>(6, std::pair<int, int>(1, 10)));
+
+        REQUIRE(test_router_list.size() == 6);
+
+        REQUIRE_THROWS_WITH(verify_noc_topology(test_router_list), "The router with id:'4' was included more than once in the architecture file. Routers should only be declared once.");
+    }
+}
+
+TEST_CASE("Verifying mesh topology creation", "[NoC Arch Tests]") {
+    // data for the xml parsing
+    pugi::xml_node test;
+    pugiutil::loc_data test_location;
+
+    // the noc storage
+    t_noc_inf test_noc;
+
+    // mesh parameters
+    double mesh_start_x = 10;
+    double mesh_start_y = 10;
+    double mesh_end_x = 5;
+    double mesh_end_y = 56;
+    double mesh_size = 0;
+
+    SECTION("Check the error where a mesh size was illegal.") {
+        REQUIRE_THROWS_WITH(generate_noc_mesh(test, test_location, &test_noc, mesh_start_x, mesh_end_x, mesh_start_y, mesh_end_y, mesh_size), "The NoC mesh size cannot be 0.");
+    }
+    SECTION("Check the error where a mesh region size was invalid.") {
+        mesh_size = 3;
+
+        REQUIRE_THROWS_WITH(generate_noc_mesh(test, test_location, &test_noc, mesh_start_x, mesh_end_x, mesh_start_y, mesh_end_y, mesh_size), "The NoC region is invalid.");
+    }
+    SECTION("Check the mesh creation for integer precision coordinates.") {
+        // define test parameters
+        mesh_size = 3;
+
+        mesh_start_x = 0;
+        mesh_start_y = 0;
+
+        mesh_end_x = 4;
+        mesh_end_y = 4;
+
+        // create the golden golden results
+        double golden_results_x[9];
+        double golden_results_y[9];
+
+        // first row of the mesh
+        golden_results_x[0] = 0;
+        golden_results_y[0] = 0;
+        golden_results_x[1] = 2;
+        golden_results_y[1] = 0;
+        golden_results_x[2] = 4;
+        golden_results_y[2] = 0;
+
+        // second row of the mesh
+        golden_results_x[3] = 0;
+        golden_results_y[3] = 2;
+        golden_results_x[4] = 2;
+        golden_results_y[4] = 2;
+        golden_results_x[5] = 4;
+        golden_results_y[5] = 2;
+
+        // third row of the mesh
+        golden_results_x[6] = 0;
+        golden_results_y[6] = 4;
+        golden_results_x[7] = 2;
+        golden_results_y[7] = 4;
+        golden_results_x[8] = 4;
+        golden_results_y[8] = 4;
+
+        generate_noc_mesh(test, test_location, &test_noc, mesh_start_x, mesh_end_x, mesh_start_y, mesh_end_y, mesh_size);
+
+        // go through all the expected routers
+        for (int expected_router_id = 0; expected_router_id < (mesh_size * mesh_size); expected_router_id++) {
+            // make sure the router ids match
+            REQUIRE(test_noc.router_list[expected_router_id].id == expected_router_id);
+
+            // make sure the position of the routers are correct
+            // x position
+            REQUIRE(golden_results_x[expected_router_id] == test_noc.router_list[expected_router_id].device_x_position);
+            // y position
+            REQUIRE(golden_results_y[expected_router_id] == test_noc.router_list[expected_router_id].device_y_position);
+        }
+    }
+    SECTION("Check the mesh creation for double precision coordinates.") {
+        // define test parameters
+        mesh_size = 3;
+
+        mesh_start_x = 3.5;
+        mesh_start_y = 5.7;
+
+        mesh_end_x = 10.8;
+        mesh_end_y = 6.4;
+
+        // create the golden golden results
+        double golden_results_x[9];
+        double golden_results_y[9];
+
+        // first row of the mesh
+        golden_results_x[0] = 3.5;
+        golden_results_y[0] = 5.7;
+        golden_results_x[1] = 7.15;
+        golden_results_y[1] = 5.7;
+        golden_results_x[2] = 10.8;
+        golden_results_y[2] = 5.7;
+
+        // second row of the mesh
+        golden_results_x[3] = 3.5;
+        golden_results_y[3] = 6.05;
+        golden_results_x[4] = 7.15;
+        golden_results_y[4] = 6.05;
+        golden_results_x[5] = 10.8;
+        golden_results_y[5] = 6.05;
+
+        // third row of the mesh
+        golden_results_x[6] = 3.5;
+        golden_results_y[6] = 6.4;
+        golden_results_x[7] = 7.15;
+        golden_results_y[7] = 6.4;
+        golden_results_x[8] = 10.8;
+        golden_results_y[8] = 6.4;
+
+        generate_noc_mesh(test, test_location, &test_noc, mesh_start_x, mesh_end_x, mesh_start_y, mesh_end_y, mesh_size);
+
+        // go through all the expected routers
+        for (int expected_router_id = 0; expected_router_id < (mesh_size * mesh_size); expected_router_id++) {
+            // make sure the router ids match
+            REQUIRE(test_noc.router_list[expected_router_id].id == expected_router_id);
+
+            // make sure the position of the routers are correct
+            // x position
+            REQUIRE(vtr::isclose(golden_results_x[expected_router_id], test_noc.router_list[expected_router_id].device_x_position));
+            // y position
+            REQUIRE(vtr::isclose(golden_results_y[expected_router_id], test_noc.router_list[expected_router_id].device_y_position));
+        }
+    }
+}

libs/libarchfpga/test/test_read_xml_arch_file.cpp

@@ -35,6 +35,8 @@ static void SetupPlacerOpts(const t_options& Options,
 static void SetupAnnealSched(const t_options& Options,
                              t_annealing_sched* AnnealSched);
 static void SetupRouterOpts(const t_options& Options, t_router_opts* RouterOpts);
+static void SetupNocOpts(const t_options& Options,
+                         t_noc_opts* NocOpts);
 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,
@@ -64,6 +66,7 @@ void SetupVPR(const t_options* Options,
               t_annealing_sched* AnnealSched,
               t_router_opts* RouterOpts,
               t_analysis_opts* AnalysisOpts,
+              t_noc_opts* NocOpts,
               t_det_routing_arch* RoutingArch,
               std::vector<t_lb_type_rr_node>** PackerRRGraphs,
               std::vector<t_segment_inf>& Segments,
@@ -108,6 +111,7 @@ void SetupVPR(const t_options* Options,
     SetupRouterOpts(*Options, RouterOpts);
     SetupAnalysisOpts(*Options, *AnalysisOpts);
     SetupPowerOpts(*Options, PowerOpts, Arch);
+    SetupNocOpts(*Options, NocOpts);
 
     if (readArchFile == true) {
         vtr::ScopedStartFinishTimer t("Loading Architecture Description");
@@ -655,6 +659,16 @@ static void SetupPowerOpts(const t_options& Options, t_power_opts* power_opts, t
     }
 }
 
+/*
+ * Go through all the NoC options supplied by the user and store them internally.
+ */
+static void SetupNocOpts(const t_options& Options, t_noc_opts* NocOpts) {
+    // assign the noc specific options from the command line
+    NocOpts->noc = Options.noc;
+
+    return;
+}
+
 static int find_ipin_cblock_switch_index(const t_arch& Arch) {
     int ipin_cblock_switch_index = UNDEFINED;
     for (int i = 0; i < Arch.num_switches; ++i) {