Merge pull request #2083 from verilog-to-routing/noc_traffic_flows_parser_final

Noc traffic flows parser final

Author: Srivat97

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

@@ -306,3 +306,17 @@ bool ClusteredNetlist::validate_net_sizes_impl(size_t num_nets) const {
     }
     return true;
 }
+
+ClusterBlockId ClusteredNetlist::find_block_by_name_fragment(const std::string& name_pattern, const std::vector<ClusterBlockId>& cluster_block_candidates) const {
+    ClusterBlockId blk_id = ClusterBlockId::INVALID();
+    std::regex name_to_match(name_pattern);
+
+    for (auto compatible_block_id = cluster_block_candidates.begin(); compatible_block_id != cluster_block_candidates.end(); compatible_block_id++) {
+        if (std::regex_match(Netlist::block_name(*compatible_block_id), name_to_match)) {
+            blk_id = *compatible_block_id;
+            break;
+        }
+    }
+
+    return blk_id;
+}

vpr/src/base/clustered_netlist.h

@@ -228,6 +228,77 @@ 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 vector of possible cluster blocks
+     *        that are candidates to match the block name, go through 
+     *        the vector of cluster blocks and return the id of the block
+     *        where the block name matches the provided name.
+     * 
+     *        Given a string pattern representing a block name and a vector of
+     *        poissble cluster blocks that are candidates to match to the block
+     *        name pattern, go through the vector of cluster blocks and return 
+     *        the id of the block where the block name matches to the provided
+     *        input pattern.
+     * 
+     */
+
+    /**
+     * @brief The intented use is to find the block id of a 
+     *        hard block without knowing its name in the netlist. Instead
+     *        a pattern can be created that we know the block's name will
+     *        match to. Generally, we expect the pattern to be constructed
+     *        using the block's module name in the HDL design, since we can
+     *        expect the netlist name of the block to include the module
+     *        name within it.
+     * 
+     *        For example, suppose a RAM block was named in the netlist as
+     *        "top|alu|test_ram|out". The user instantiated the ram module
+     *        in the HDL design as "test_ram". So instead of going through 
+     *        the netlist and finding the ram block's full name, this
+     *        function can be used by just providing the string pattern as
+     *        ".*test_ram.*". We know that the module name should be somewhere
+     *        within the string, so the pattern we provide says that the netlist
+     *        name of the block contains arbritary characters then the module
+     *        name and then some other arbritary characters after.
+     *        This pattern will then be used to match to the block in the
+     *        netlist. The matched cluster block id is returned, and if no
+     *        block matched to the input string then an invalid block id
+     *        is returned.
+     * 
+     *        The function 
+     *        here additionally requires a vector of possible cluster blocks
+     *        that can match to the input pattern. This vector can be the
+     *        entire netlist or a subset. For example, if the intended use 
+     *        is to find hard blocks, it is quite inefficient
+     *        to go through all the blocks to find a matching one. Instead, a
+     *        a filtered vector can be passed that is a subset of the entire 
+     *        netlist and can only contain blocks of a certain logical block 
+     *        type (blocks that can be placed on a specific hard block).
+     *        The idea here is that the filtered vector should be
+     *        considereably smaller that a vector of every block in the netlist
+     *        and this should help improve run time.
+     * 
+     *        This function runs in linear time (O(N)) as it goes over the
+     *        vector of 'cluster_block_candidates'. 'cluster_block_candidates'
+     *        could be the whole netlist or a subset as explained above.
+     *        Additionally, if there are multiple
+     *        blocks that match to the provided input pattern, then the
+     *        first block found is returned.
+     * 
+     * 
+     * @param name_pattern A regex string pattern that can be used to match to  
+     *             a clustered block name within the netlist.
+     * @param cluster_block_candidates A vector of clustered block ids that
+     *                                 represent a subset of the clustered
+     *                                 netlist. The blocks in this vector
+     *                                 will be used to compare and match
+     *                                 to the input string pattern. 
+     * @return A cluster block id representing a unique cluster block that 
+     *         matched to the input string pattern.
+     *         
+     */
+    ClusterBlockId find_block_by_name_fragment(const std::string& name_pattern, const std::vector<ClusterBlockId>& cluster_block_candidates) const;
+
   private: //Private Members
     /*
      * Netlist compression/optimization

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,43 @@ class Netlist {
      */
     BlockId find_block(const std::string& name) const;
 
+    /**
+     * @brief Finds a block where the block's name contains the
+     *        provided input name as a substring. 
+     *        The intented use is to find the block id of a 
+     *        hard block without knowing its name in the netlist. Instead
+     *        the block's module name in the HDL design can be used as it will
+     *        be a substring within its full name in the netlist.
+     * 
+     *        For example, suppose a RAM block was named in the netlist as
+     *        "top|alu|test_ram|out". The user instantiated the ram module
+     *        in the HDL design as "test_ram". So instead of going through 
+     *        the netlist and finding the ram block's full name, this
+     *        function can be used by just providing the module name "test_ram"
+     *        and using this substring to match the blocks name in the netlist
+     *        and retrieving its block id. If no blocks matched to input pattern
+     *        then an invalid block id is returned.
+     * 
+     *        This function runs in linear time (O(N)) as it goes over all the 
+     *        cluster blocks in the netlist. Additionally, if there are multiple
+     *        blocks that contain the provided input as a substring, then the
+     *        first block found is returned.
+     * 
+     *        NOTE: This function tries to find blocks by checking for 
+     *              substrings.
+     *              The clustered netlist class defines another version of this
+     *              function that find blocks by checking for a pattern match,
+     *              meaning that the input is a pattern string and the pattern
+     *              is looked for ine each block name.
+     * 
+     * @param name_substring A substring of a block name for which an ID needs  
+     *             to be found.
+     * @return A cluster block id representing a unique cluster block that 
+     *         matched to the input string pattern.
+     *        
+     */
+    BlockId find_block_by_name_fragment(const std::string& name_substring) 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,24 @@ BlockId Netlist<BlockId, PortId, PinId, NetId>::find_block(const std::string& na
     }
 }
 
+template<typename BlockId, typename PortId, typename PinId, typename NetId>
+BlockId Netlist<BlockId, PortId, PinId, NetId>::find_block_by_name_fragment(const std::string& name_substring) 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_substring) != 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;
 }