vpr: Use Logic Elements instead of ALMs to be more general

Author: MohamedEldafrawy

vpr/src/pack/cluster.cpp

@@ -347,17 +347,17 @@ static t_pb_graph_pin* get_driver_pb_graph_pin(const t_pb* driver_pb, const Atom
 
 static void update_pb_type_count(const t_pb* pb, std::unordered_map<std::string, int>& pb_type_count);
 
-static void update_alm_count(const t_pb* pb, const t_type_ptr logic_block_type, const t_pb_type* alm_pb_type, std::vector<int>& alm_count);
+static void update_le_count(const t_pb* pb, const t_type_ptr logic_block_type, const t_pb_type* le_pb_type, std::vector<int>& le_count);
 
 static void print_pb_type_count(std::unordered_map<std::string, int>& pb_type_count);
 
 static t_type_ptr identify_logic_block_type(std::map<const t_model*, std::vector<t_type_ptr>>& primitive_candidate_block_types);
 
-static t_pb_type* identify_alm_block_type(t_type_ptr logic_block_type);
+static t_pb_type* identify_le_block_type(t_type_ptr logic_block_type);
 
 static bool pb_used_for_blif_model(const t_pb* pb, std::string blif_model_name);
 
-static void print_alm_count(std::vector<int>& alm_count);
+static void print_le_count(std::vector<int>& le_count, const t_pb_type* le_pb_type);
 
 /*****************************************/
 /*globally accessible function*/
@@ -420,16 +420,15 @@ std::map<t_type_ptr, size_t> do_clustering(const t_packer_opts& packer_opts,
     // used for each physical block type defined in the architecture file.
     std::unordered_map<std::string, int> pb_type_count;
 
-    // this data structure tracks the number of ALMs used. It is populated only
-    // for architectures which has an ALM-like logic blocks. The architecture is
-    // assumed to have an ALM-like logic block only if it has a logic block that
-    // contains LUT primitives and is the first pb_block to have more than one
-    // instance from the top of the hierarchy (All parent pb_block have one
-    // instance only and one mode only). Index 0 holds the number of ALMs that are
-    // used for both logic (LUTs/adders) and registers. Index 1 holds the number
-    // of ALMs that are used for logic (LUTs/adders) only. Index 2 holds the
-    // number of ALMs that are used for registers only.
-    std::vector<int> alm_count(3, 0);
+    // this data structure tracks the number of Logic Elements (LEs) used. It is
+    // populated only for architectures which has LEs. The architecture is assumed
+    // to have LEs only iff it has a logic block that contains LUT primitives and is
+    // the first pb_block to have more than one instance from the top of the hierarchy
+    // (All parent pb_block have one instance only and one mode only). Index 0 holds
+    // the number of LEs that are used for both logic (LUTs/adders) and registers.
+    // Index 1 holds the number of LEs that are used for logic (LUTs/adders) only.
+    // Index 2 holds the number of LEs that are used for registers only.
+    std::vector<int> le_count(3, 0);
 
     num_clb = 0;
 
@@ -482,8 +481,8 @@ std::map<t_type_ptr, size_t> do_clustering(const t_packer_opts& packer_opts,
     auto primitive_candidate_block_types = identify_primitive_candidate_block_types();
     // find the cluster type that has lut primitives
     auto logic_block_type = identify_logic_block_type(primitive_candidate_block_types);
-    // find an ALM-like pb_type within the found logic_block_type
-    auto alm_pb_type = identify_alm_block_type(logic_block_type);
+    // find a LE pb_type within the found logic_block_type
+    auto le_pb_type = identify_le_block_type(logic_block_type);
 
     blocks_since_last_analysis = 0;
     num_blocks_hill_added = 0;
@@ -737,8 +736,8 @@ std::map<t_type_ptr, size_t> do_clustering(const t_packer_opts& packer_opts,
                 auto cur_pb = cluster_ctx.clb_nlist.block_pb(clb_index);
                 // update the pb type count by counting the used pb types in this packed cluster
                 update_pb_type_count(cur_pb, pb_type_count);
-                // update the data structure holding the alm counts
-                update_alm_count(cur_pb, logic_block_type, alm_pb_type, alm_count);
+                // update the data structure holding the LE counts
+                update_le_count(cur_pb, logic_block_type, le_pb_type, le_count);
                 free_pb_stats_recursive(cur_pb);
             } else {
                 /* Free up data structures and requeue used molecules */
@@ -758,9 +757,9 @@ std::map<t_type_ptr, size_t> do_clustering(const t_packer_opts& packer_opts,
     // physical block type after finishing the packing stage
     print_pb_type_count(pb_type_count);
 
-    // if this architecture has an ALM-like physical block, report its usage
-    if (alm_pb_type) {
-        print_alm_count(alm_count);
+    // if this architecture has LE physical block, report its usage
+    if (le_pb_type) {
+        print_le_count(le_count, le_pb_type);
     }
 
     /****************************************************************
@@ -3402,13 +3401,13 @@ static t_type_ptr identify_logic_block_type(std::map<const t_model*, std::vector
 }
 
 /**
- * This function returns the pb_type that is similar to an ALM in an Intel
- * FPGA. The ALM is defined as a physical block that contains a LUT primitive and
+ * This function returns the pb_type that is similar to Logic Element (LE) in an FPGA
+ * The LE is defined as a physical block that contains a LUT primitive and
  * is found by searching a cluster type to find the first pb_type (from the top
- * of the hierarchy clb->alm) that has more than one instance within the cluster.
+ * of the hierarchy clb->LE) that has more than one instance within the cluster.
  */
-static t_pb_type* identify_alm_block_type(t_type_ptr logic_block_type) {
-    // if there is no CLB-like cluster, then there is no ALM-like pb_block
+static t_pb_type* identify_le_block_type(t_type_ptr logic_block_type) {
+    // if there is no CLB-like cluster, then there is no LE pb_block
     if (!logic_block_type)
         return nullptr;
 
@@ -3423,7 +3422,7 @@ static t_pb_type* identify_alm_block_type(t_type_ptr logic_block_type) {
         // explore the only child of this pb_graph_node
         pb_graph_node = &pb_graph_node->child_pb_graph_nodes[0][0][0];
         // if the child node has more than one instance in the
-        // cluster then this is the pb_type similar to an ALM
+        // cluster then this is the pb_type similar to a LE
         if (pb_graph_node->pb_type->num_pb > 1)
             return pb_graph_node->pb_type;
     }
@@ -3432,12 +3431,12 @@ static t_pb_type* identify_alm_block_type(t_type_ptr logic_block_type) {
 }
 
 /**
- * This function updates the alm_count data structure from the given packed cluster
+ * This function updates the le_count data structure from the given packed cluster
  */
-static void update_alm_count(const t_pb* pb, const t_type_ptr logic_block_type, const t_pb_type* alm_pb_type, std::vector<int>& alm_count) {
-    // if this cluster doesn't contain ALMs or there
-    // are no alms in this architecture, ignore it
-    if (!logic_block_type || pb->pb_graph_node != logic_block_type->pb_graph_head || !alm_pb_type)
+static void update_le_count(const t_pb* pb, const t_type_ptr logic_block_type, const t_pb_type* le_pb_type, std::vector<int>& le_count) {
+    // if this cluster doesn't contain LEs or there
+    // are no les in this architecture, ignore it
+    if (!logic_block_type || pb->pb_graph_node != logic_block_type->pb_graph_head || !le_pb_type)
         return;
 
     const std::string lut(".names");
@@ -3446,29 +3445,29 @@ static void update_alm_count(const t_pb* pb, const t_type_ptr logic_block_type,
 
     auto parent_pb = pb;
 
-    // go down the hierarchy till the parent physical block of the ALM is found
-    while (parent_pb->child_pbs[0][0].pb_graph_node->pb_type != alm_pb_type) {
+    // go down the hierarchy till the parent physical block of the LE is found
+    while (parent_pb->child_pbs[0][0].pb_graph_node->pb_type != le_pb_type) {
         parent_pb = &parent_pb->child_pbs[0][0];
     }
 
-    // iterate over all the ALMs and update the ALM count accordingly
-    for (int ialm = 0; ialm < parent_pb->get_num_children_of_type(0); ialm++) {
-        if (!parent_pb->child_pbs[0][ialm].name)
+    // iterate over all the LEs and update the LE count accordingly
+    for (int ile = 0; ile < parent_pb->get_num_children_of_type(0); ile++) {
+        if (!parent_pb->child_pbs[0][ile].name)
             continue;
 
-        auto has_used_lut = pb_used_for_blif_model(&parent_pb->child_pbs[0][ialm], lut);
-        auto has_used_adder = pb_used_for_blif_model(&parent_pb->child_pbs[0][ialm], adder);
-        auto has_used_ff = pb_used_for_blif_model(&parent_pb->child_pbs[0][ialm], ff);
+        auto has_used_lut = pb_used_for_blif_model(&parent_pb->child_pbs[0][ile], lut);
+        auto has_used_adder = pb_used_for_blif_model(&parent_pb->child_pbs[0][ile], adder);
+        auto has_used_ff = pb_used_for_blif_model(&parent_pb->child_pbs[0][ile], ff);
 
-        // First type of ALMs: used for logic and registers
+        // First type of LEs: used for logic and registers
         if ((has_used_lut || has_used_adder) && has_used_ff) {
-            alm_count[0]++;
-            // Second type of ALMs: used for logic only
+            le_count[0]++;
+            // Second type of LEs: used for logic only
         } else if (has_used_lut || has_used_adder) {
-            alm_count[1]++;
-            // Third type of ALMs: used for registers only
+            le_count[1]++;
+            // Third type of LEs: used for registers only
         } else if (has_used_ff) {
-            alm_count[2]++;
+            le_count[2]++;
         }
     }
 }
@@ -3505,12 +3504,12 @@ static bool pb_used_for_blif_model(const t_pb* pb, std::string blif_model_name)
 }
 
 /**
- * Print the alm count data strurture
+ * Print the LE count data strurture
  */
-static void print_alm_count(std::vector<int>& alm_count) {
-    VTR_LOG("\nALM count...\n");
-    VTR_LOG("  Total number of ALMs used         : %d\n", alm_count[0] + alm_count[1] + alm_count[2]);
-    VTR_LOG("  ALMs used for logic and registers : %d\n", alm_count[0]);
-    VTR_LOG("  ALMs used for logic only          : %d\n", alm_count[1]);
-    VTR_LOG("  ALMs used for registers only      : %d\n\n", alm_count[2]);
+static void print_le_count(std::vector<int>& le_count, const t_pb_type* le_pb_type) {
+    VTR_LOG("\nLogic Element (%s) detailed count:\n", le_pb_type->name);
+    VTR_LOG("  Total number of Logic Elements used : %d\n", le_count[0] + le_count[1] + le_count[2]);
+    VTR_LOG("  LEs used for logic and registers    : %d\n", le_count[0]);
+    VTR_LOG("  LEs used for logic only             : %d\n", le_count[1]);
+    VTR_LOG("  LEs used for registers only         : %d\n\n", le_count[2]);
 }