Noc traffic flows parser final

libs/libarchfpga/src/read_xml_arch_file.cpp

@@ -4672,7 +4672,7 @@ static void processTopology(pugi::xml_node topology_tag, const pugiutil::loc_dat
     /**
      * Stores router information that includes the number of connections a router has within a given topology and also the number of times a router was declared in the arch file using the <router> tag.
      * In the datastructure below, the router id is the key and the stored data is a pair, where the first element describes the number of router declarations and the second element describes the number of router connections.
-     * This is used only for erro checking.
+     * This is used only for error checking.
      */
     std::map<int, std::pair<int, int>> routers_in_arch_info;
 

vpr/src/base/SetupVPR.cpp

@@ -665,6 +665,7 @@ static void SetupPowerOpts(const t_options& Options, t_power_opts* power_opts, t
 static void SetupNocOpts(const t_options& Options, t_noc_opts* NocOpts) {
     // assign the noc specific options from the command line
     NocOpts->noc = Options.noc;
+    NocOpts->noc_flows_file = Options.noc_flows_file;
 
     return;
 }

vpr/src/base/ShowSetup.cpp

@@ -20,6 +20,7 @@ static void ShowPlacerOpts(const t_placer_opts& PlacerOpts,
                            const t_annealing_sched& AnnealSched);
 static void ShowRouterOpts(const t_router_opts& RouterOpts);
 static void ShowAnalysisOpts(const t_analysis_opts& AnalysisOpts);
+static void ShowNocOpts(const t_noc_opts& NocOpts);
 
 static void ShowAnnealSched(const t_annealing_sched& AnnealSched);
 
@@ -61,6 +62,9 @@ void ShowSetup(const t_vpr_setup& vpr_setup) {
     if (vpr_setup.AnalysisOpts.doAnalysis) {
         ShowAnalysisOpts(vpr_setup.AnalysisOpts);
     }
+    if (vpr_setup.NocOpts.noc) {
+        ShowNocOpts(vpr_setup.NocOpts);
+    }
 }
 
 void ClusteredNetlistStats::writeHuman(std::ostream& output) const {
@@ -764,3 +768,10 @@ static void ShowPackerOpts(const t_packer_opts& PackerOpts) {
     VTR_LOG("\n");
     VTR_LOG("\n");
 }
+
+static void ShowNocOpts(const t_noc_opts& NocOpts) {
+    VTR_LOG("NocOpts.noc_flows_file: %s\n", NocOpts.noc_flows_file.c_str());
+    VTR_LOG("\n");
+
+    // add future options here (routing algorithm etc...)
+}

vpr/src/base/clustered_netlist.cpp

@@ -121,6 +121,8 @@ ClusterBlockId ClusteredNetlist::create_block(const char* name, t_pb* pb, t_logi
 
         //Allocate and initialize every potential pin of the block
         block_logical_pins_.insert(blk_id, std::vector<ClusterPinId>(get_max_num_pins(type), ClusterPinId::INVALID()));
+
+        add_block_to_logical_type(blk_id, type);
     }
 
     //Check post-conditions: size
@@ -274,6 +276,28 @@ void ClusteredNetlist::shrink_to_fit_impl() {
     net_is_global_.shrink_to_fit();
 }
 
+/**
+ * @brief Given a newly created block, find its logical type and store the 
+ *        block in a list where all the other blocks in the list are of the
+ *        blocks logical type.
+ */
+void ClusteredNetlist::add_block_to_logical_type(ClusterBlockId blk_id, t_logical_block_type_ptr type) {
+    std::string logical_block_type_name = type->name;
+
+    // check if a group of blocks exist for the current logical block type
+    // basically checking if this is the first time we are seeing this logical block type
+    auto logical_type_blocks = block_type_to_id.find(logical_block_type_name);
+
+    if (logical_type_blocks == block_type_to_id.end()) {
+        // if the current logical block doesnt exist then create a new group of blocks for it and add it
+        block_type_to_id.emplace(logical_block_type_name, std::vector<ClusterBlockId>({blk_id}));
+    } else {
+        // current logical block exists, so add the current block to the group other blocks of this type
+        logical_type_blocks->second.push_back(blk_id);
+    }
+    return;
+}
+
 /*
  *
  * Sanity Checks
@@ -306,3 +330,52 @@ bool ClusteredNetlist::validate_net_sizes_impl(size_t num_nets) const {
     }
     return true;
 }
+
+/**
+ * @brief Finds a block where the blocks name contains within it the
+ *        provided input name. The intented use is to find the block id of a 
+ *        hard block when provided with the its module name in the HDL design.
+ *        
+ *        For example, suppose a RAM block was instantiated in the design and it
+ *        was named "test_ram". The generated netlist would not have the block
+ *        named as "test_ram", instead it would be something different but the
+ *        name should contain "test_ram" inside it since it represents that  
+ *        block. If "test_ram" is provided to find_block() above, then an 
+ *        invalid block ID would be returned. The find_block_with_matching_name
+ *        () can instead be used and it should find the ram block that has 
+ *        "test_ram" within its name.
+ * 
+ *        There is a similiar function in the Netlist Class. This function 
+ *        additionally requires the logical type of the block as well. Since
+ *        the inteded use is to find hard blocks, it is quite inefficient to 
+ *        to go through all the blocks to find a matching one. Instead, an
+ *        additional datastructure is created that groups clusters by their
+ *        logical type. This function filters the clusters and only searches
+ *        for the matching block within a list of blocks that are the same 
+ *        logical type. The idea here is that the filtered list should be
+ *        considereably smaller that a list of every block in the netlist
+ *        and this should help improve run time.
+ * 
+ */
+ClusterBlockId ClusteredNetlist::find_block_with_matching_name(const std::string& name, t_logical_block_type_ptr blk_type) const {
+    ClusterBlockId blk_id = ClusterBlockId::INVALID();
+    auto blks_of_logical_type = block_type_to_id.find(blk_type->name);
+    std::regex name_to_match(name);
+
+    if (blks_of_logical_type != block_type_to_id.end()) {
+        // get the list of blocks that are of the specified logical type
+        const std::vector<ClusterBlockId>* blk_list = &blks_of_logical_type->second;
+
+        // go through the list of blocks to find if any block name matches the provided name (contains the input string in its name)
+        for (auto blk = blk_list->begin(); blk != blk_list->end(); blk++) {
+            // another thing you can do is go through blocks and instead string.find(), you can use a regular expression version (so match a regular expression)
+
+            // check for the string match
+            if (std::regex_match(Netlist::block_name(*blk), name_to_match)) {
+                blk_id = *blk;
+                break;
+            }
+        }
+    }
+    return blk_id;
+}

vpr/src/base/clustered_netlist.h

@@ -228,6 +228,14 @@ class ClusteredNetlist : public Netlist<ClusterBlockId, ClusterPortId, ClusterPi
     ///@brief Sets the flag in net_is_global_ = state
     void set_net_is_global(ClusterNetId net_id, bool state);
 
+    /**
+     * @brief Given a name of a block and logical type, go through all the
+     *        cluster blocks of that type and return the id of a block where 
+     *        the block name matches to provided name.
+     * 
+     */
+    ClusterBlockId find_block_with_matching_name(const std::string& name, t_logical_block_type_ptr blk_type) const;
+
   private: //Private Members
     /*
      * Netlist compression/optimization
@@ -242,6 +250,9 @@ class ClusteredNetlist : public Netlist<ClusterBlockId, ClusterPortId, ClusterPi
     ///@brief Shrinks internal data structures to required size to reduce memory consumption
     void shrink_to_fit_impl() override;
 
+    ///@brief Group the block to its corresponding logical type
+    void add_block_to_logical_type(ClusterBlockId blk_id, t_logical_block_type_ptr type);
+
     /*
      * Component removal
      */
@@ -277,8 +288,10 @@ class ClusteredNetlist : public Netlist<ClusterBlockId, ClusterPortId, ClusterPi
     vtr::vector_map<ClusterBlockId, t_pb*> block_pbs_;                              ///<Physical block representing the clustering & internal hierarchy of each CLB
     vtr::vector_map<ClusterBlockId, t_logical_block_type_ptr> block_types_;         ///<The type of logical block this user circuit block is mapped to
     vtr::vector_map<ClusterBlockId, std::vector<ClusterPinId>> block_logical_pins_; ///<The logical pin associated with each physical tile pin
-
-    //Pins
+    std::unordered_map<std::string, std::vector<ClusterBlockId>> block_type_to_id;  ///<Group the physical blocks by their logical types
+                                                                                    /// each logical type contains a list of blocks that are
+                                                                                    /// its type
+                                                                                    /// the key here is the logical type name
     /**
      * @brief The logical pin index of this block (i.e. pin index in t_logical_block_type)
      *        corresponding to the clustered pin

vpr/src/base/echo_files.cpp

@@ -132,6 +132,7 @@ void alloc_and_load_echo_file_info() {
 
     //NoC
     setEchoFileName(E_ECHO_NOC_MODEL, "noc_model.echo");
+    setEchoFileName(E_ECHO_NOC_TRAFFIC_FLOWS, "noc_traffic_flows.echo");
 }
 
 void free_echo_file_info() {

vpr/src/base/echo_files.h

@@ -65,6 +65,7 @@ enum e_echo_files {
 
     //NoC
     E_ECHO_NOC_MODEL,
+    E_ECHO_NOC_TRAFFIC_FLOWS,
 
     E_ECHO_END_TOKEN
 };

vpr/src/base/netlist.h

@@ -727,6 +727,13 @@ class Netlist {
      */
     BlockId find_block(const std::string& name) const;
 
+    /**
+     * @brief Returns the BlockId of the specified block or BlockId::INVALID() if not found. The name of the block returned contains the provided input name in it.
+     *
+     *   @param name   The name of the block
+     */
+    BlockId find_block_with_matching_name(const std::string& name) const;
+
     /**
      * @brief Returns the PortId of the specifed port if it exists or PortId::INVALID() if not
      *

vpr/src/base/netlist.tpp

@@ -458,6 +458,39 @@ BlockId Netlist<BlockId, PortId, PinId, NetId>::find_block(const std::string& na
     }
 }
 
+/**
+ * @brief Finds a block where the blocks name contains within it the
+ *        provided input name. The intented use is to find the block id of a 
+ *        hard block when provided with the its module name in the HDL design.
+ *        
+ *        For example, suppose a RAM block was instantiated in the design and it
+ *        was named "test_ram". The generated netlist would not have the block
+ *        named as "test_ram", instead it would be something different but the
+ *        name should contain "test_ram" inside it since it represents that  
+ *        block. If "test_ram" is provided to find_block() above, then an 
+ *        invalid block ID would be returned. The find_block_with_matching_name
+ *        () can instead be used and it should find the ram block that has 
+ *        "test_ram" within its name.
+ * 
+ */
+template<typename BlockId, typename PortId, typename PinId, typename NetId>
+BlockId Netlist<BlockId, PortId, PinId, NetId>::find_block_with_matching_name(const std::string& name) const {
+    BlockId matching_blk_id = BlockId::INVALID();
+    const std::string blk_name;
+
+    // go through all the blocks in the netlist
+    for (auto blk_id = block_ids_.begin(); blk_id != block_ids_.end(); blk_id++) {
+        // get the corresponding block name
+        blk_name = &strings_[block_names_[*blk_id]];
+        // check whether the current block name contains the input string within it
+        if (blk_name.find(name) != std::string::npos) {
+            matching_blk_id = blk_id;
+            break;
+        }
+    }
+    return matching_blk_id;
+}
+
 template<typename BlockId, typename PortId, typename PinId, typename NetId>
 PortId Netlist<BlockId, PortId, PinId, NetId>::find_port(const BlockId blk_id, const std::string& name) const {
     VTR_ASSERT_SAFE(valid_block_id(blk_id));

vpr/src/base/read_options.cpp

@@ -2622,6 +2622,13 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .default_value("off")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    noc_grp.add_argument<std::string>(args.noc_flows_file, "--noc_flows_file")
+        .help(
+            "XML file containing the list of traffic flows within the NoC (communication between routers)."
+            "This is required if the --noc option is turned on.")
+        .default_value("")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     return parser;
 }
 
@@ -2803,7 +2810,7 @@ void set_conditional_defaults(t_options& args) {
 
 bool verify_args(const t_options& args) {
     /*
-     * Check for conflicting paramaters
+     * Check for conflicting paramaters or dependencies where one parameter set requires another parameter to be included
      */
     if (args.read_rr_graph_file.provenance() == Provenance::SPECIFIED
         && args.RouteChanWidth.provenance() != Provenance::SPECIFIED) {
@@ -2826,5 +2833,19 @@ bool verify_args(const t_options& args) {
                         args.router_lookahead_type.argument_name().c_str());
     }
 
+    /**
+     * @brief If the user provided the "--noc" command line option, then there
+     * must be a NoC in the FPGA and the netlist must include NoC routers.
+     * Therefore, the user must also provide a noc traffic flows file to
+     * describe the communication within the NoC. We ensure that a noc traffic
+     * flows file is provided when the "--noc" option is used. If it is not
+     * provided, we throw an error.
+     * 
+     */
+    if (args.noc.provenance() == Provenance::SPECIFIED && args.noc_flows_file.provenance() != Provenance::SPECIFIED) {
+        VPR_FATAL_ERROR(VPR_ERROR_OTHER,
+                        "--noc_flows_file option must be specified if --noc is turned on.\n");
+    }
+
     return true;
 }

vpr/src/base/read_options.h

@@ -140,6 +140,7 @@ struct t_options {
 
     /*NoC Options*/
     argparse::ArgValue<bool> noc;
+    argparse::ArgValue<std::string> noc_flows_file;
 
     /* Timing-driven placement options only */
     argparse::ArgValue<float> PlaceTimingTradeoff;

vpr/src/base/setup_noc.cpp

@@ -1,4 +1,3 @@
-
 #include <climits>
 #include <cmath>
 

vpr/src/base/setup_noc.h

@@ -1,13 +1,6 @@
 #ifndef SETUP_NOC
 #define SETUP_NOC
 
-/*
- * THis file contains functions and datatypes that help setup the NoC model datastructure from the user NoC description in the arch file. 
- *
- * During VPR setup, the functions here should be used to setup the NoC. 
- *
- */
-
 /**
  * @file 
  * @brief This is the setup_noc header file. The main purpose of 

vpr/src/base/vpr_api.cpp

@@ -39,6 +39,7 @@
 #include "SetupGrid.h"
 #include "setup_clocks.h"
 #include "setup_noc.h"
+#include "read_xml_noc_traffic_flows_file.h"
 #include "stats.h"
 #include "read_options.h"
 #include "echo_files.h"
@@ -518,6 +519,8 @@ void vpr_setup_noc(const t_vpr_setup& vpr_setup, const t_arch& arch) {
     if (vpr_setup.NocOpts.noc == true) {
         // create the NoC model based on the user description from the arch file
         setup_noc(arch);
+        // read and store the noc traffic flow information
+        read_xml_noc_traffic_flows_file(vpr_setup.NocOpts.noc_flows_file.c_str());
 
 #ifndef NO_GRAPHICS
         // setup the graphics

vpr/src/base/vpr_context.h

@@ -28,6 +28,7 @@
 #include "metadata_storage.h"
 #include "vpr_constraints.h"
 #include "noc_storage.h"
+#include "noc_traffic_flows.h"
 
 /**
  * @brief A Context is collection of state relating to a particular part of VPR
@@ -427,6 +428,16 @@ struct NocContext : public Context {
      * The NoC model is created once from the architecture file description. 
      */
     NocStorage noc_model;
+
+    /**
+     * @brief Stores all the communication happening betwee routers in the NoC 
+     *
+     * Contains all of the traffic flows that describe which two routers are communication with each other and also some metrics and constraints on the data transfer between the two routers. 
+     * 
+     *
+     * This is created from a user supplied .flows file.
+     */
+    NocTrafficFlows noc_traffic_flows_storage;
 };
 
 /**

vpr/src/base/vpr_types.h

@@ -1271,7 +1271,8 @@ struct t_analysis_opts {
 
 // used to store NoC specific options, when supplied as an input by the user
 struct t_noc_opts {
-    bool noc; ///<options to model the noc within the FPGA device
+    bool noc;                   ///<options to model the noc within the FPGA device
+    std::string noc_flows_file; ///<name of the file that contains all the traffic flow information in the NoC
 };
 
 /**

vpr/src/base/noc_data_types.h → vpr/src/noc/noc_data_types.h

@@ -4,11 +4,15 @@
 #include "vtr_strong_id.h"
 
 // data types used to index the routers and links within the noc
-
 struct noc_router_id_tag;
 struct noc_link_id_tag;
 
 typedef vtr::StrongId<noc_router_id_tag, int> NocRouterId;
 typedef vtr::StrongId<noc_link_id_tag, int> NocLinkId;
 
+// data type to index traffic flows within the noc
+struct noc_traffic_flow_id_tag;
+
+typedef vtr::StrongId<noc_traffic_flow_id_tag, int> NocTrafficFlowId;
+
 #endif