[packer] Changing the vector of candidate molecules into LazyPopUniquePriorityQueue.

    The class LazyPopUniquePriorityQueue is a priority queue that allows for lazy deletion of elements.
    It is implemented using a vector and 2 sets, one set keeps track of the elements in the queue, and the other set keeps track of the elements that are pending deletion.
    The queue is sorted by the sort-value(SV) of the elements, and the elements are stored in a vector.
    The set is used to keep track of the elements that are pending deletion, so that they can be removed from the queue when they are popped.
    The class definiation can be found in vpr/src/util/lazy_pop_unique_priority_queue.h

    Currently, the class supports the following functions:
        LazyPopUniquePriorityQueue::push(): Pushes a key-sort-value (K-SV) pair into the priority queue and adds the key to the tracking set.
        LazyPopUniquePriorityQueue::pop(): Returns the K-SV pair with the highest SV whose key is not pending deletion.
        LazyPopUniquePriorityQueue::remove(): Removes an element from the priority queue immediately.
        LazyPopUniquePriorityQueue::remove_at_pop_time(): Removes an element from the priority queue when it is popped.
        LazyPopUniquePriorityQueue::empty(): Returns whether the queue is empty.
        LazyPopUniquePriorityQueue::clear(): Clears the priority queue vector and the tracking sets.
        LazyPopUniquePriorityQueue::size(): Returns the number of elements in the queue.
        LazyPopUniquePriorityQueue::contains(): Returns true if the key is in the queue, false otherwise.

Author: Rongbo Zhang

vpr/src/pack/greedy_candidate_selector.cpp

@@ -64,7 +64,6 @@ static void add_molecule_to_pb_stats_candidates(
     PackMoleculeId molecule_id,
     ClusterGainStats& cluster_gain_stats,
     t_logical_block_type_ptr cluster_type,
-    int max_queue_size,
     AttractionInfo& attraction_groups,
     const Prepacker& prepacker,
     const AtomNetlist& atom_netlist,
@@ -219,13 +218,11 @@ ClusterGainStats GreedyCandidateSelector::create_cluster_gain_stats(
     // Initialize the cluster gain stats.
     ClusterGainStats cluster_gain_stats;
     cluster_gain_stats.seed_molecule_id = cluster_seed_mol_id;
-    cluster_gain_stats.num_feasible_blocks = NOT_VALID;
     cluster_gain_stats.has_done_connectivity_and_timing = false;
-    // TODO: The reason this is being resized and not reserved is due to legacy
-    //       code which should be updated.
-    cluster_gain_stats.feasible_blocks.resize(packer_opts_.feasible_block_array_size);
-    for (int i = 0; i < packer_opts_.feasible_block_array_size; i++)
-        cluster_gain_stats.feasible_blocks[i] = PackMoleculeId::INVALID();
+    cluster_gain_stats.initial_search_for_feasible_blocks = true;
+    cluster_gain_stats.num_candidates_proposed = 0;
+    cluster_gain_stats.candidates_propose_limit = packer_opts_.feasible_block_array_size;
+    cluster_gain_stats.feasible_blocks.clear();
     cluster_gain_stats.tie_break_high_fanout_net = AtomNetId::INVALID();
     cluster_gain_stats.explore_transitive_fanout = true;
 
@@ -288,8 +285,10 @@ void GreedyCandidateSelector::update_cluster_gain_stats_candidate_success(
         AttractGroupId atom_grp_id = attraction_groups.get_atom_attraction_group(blk_id);
 
         /* reset list of feasible blocks */
-        cluster_gain_stats.num_feasible_blocks = NOT_VALID;
         cluster_gain_stats.has_done_connectivity_and_timing = false;
+        cluster_gain_stats.initial_search_for_feasible_blocks = true;
+        cluster_gain_stats.num_candidates_proposed = 0;
+        cluster_gain_stats.feasible_blocks.clear();
         /* TODO: Allow clusters to have more than one attraction group. */
         if (atom_grp_id.is_valid())
             cluster_gain_stats.attraction_grp_id = atom_grp_id;
@@ -684,8 +683,8 @@ PackMoleculeId GreedyCandidateSelector::get_next_candidate_for_cluster(
      */
 
     // 1. Find unpacked molecules based on criticality and strong connectedness (connected by low fanout nets) with current cluster
-    if (cluster_gain_stats.num_feasible_blocks == NOT_VALID) {
-        cluster_gain_stats.num_feasible_blocks = 0;
+    if (cluster_gain_stats.initial_search_for_feasible_blocks) {
+        cluster_gain_stats.initial_search_for_feasible_blocks = false;
         add_cluster_molecule_candidates_by_connectivity_and_timing(cluster_gain_stats,
                                                                    cluster_id,
                                                                    cluster_legalizer,
@@ -695,31 +694,31 @@ PackMoleculeId GreedyCandidateSelector::get_next_candidate_for_cluster(
 
     if (packer_opts_.prioritize_transitive_connectivity) {
         // 2. Find unpacked molecules based on transitive connections (eg. 2 hops away) with current cluster
-        if (cluster_gain_stats.num_feasible_blocks == 0 && cluster_gain_stats.explore_transitive_fanout) {
+        if (cluster_gain_stats.feasible_blocks.empty() && cluster_gain_stats.explore_transitive_fanout) {
             add_cluster_molecule_candidates_by_transitive_connectivity(cluster_gain_stats,
                                                                        cluster_id,
                                                                        cluster_legalizer,
                                                                        attraction_groups);
         }
 
         // 3. Find unpacked molecules based on weak connectedness (connected by high fanout nets) with current cluster
-        if (cluster_gain_stats.num_feasible_blocks == 0 && cluster_gain_stats.tie_break_high_fanout_net) {
+        if (cluster_gain_stats.feasible_blocks.empty() && cluster_gain_stats.tie_break_high_fanout_net) {
             add_cluster_molecule_candidates_by_highfanout_connectivity(cluster_gain_stats,
                                                                        cluster_id,
                                                                        cluster_legalizer,
                                                                        attraction_groups);
         }
     } else { //Reverse order
         // 3. Find unpacked molecules based on weak connectedness (connected by high fanout nets) with current cluster
-        if (cluster_gain_stats.num_feasible_blocks == 0 && cluster_gain_stats.tie_break_high_fanout_net) {
+        if (cluster_gain_stats.feasible_blocks.empty() && cluster_gain_stats.tie_break_high_fanout_net) {
             add_cluster_molecule_candidates_by_highfanout_connectivity(cluster_gain_stats,
                                                                        cluster_id,
                                                                        cluster_legalizer,
                                                                        attraction_groups);
         }
 
         // 2. Find unpacked molecules based on transitive connections (eg. 2 hops away) with current cluster
-        if (cluster_gain_stats.num_feasible_blocks == 0 && cluster_gain_stats.explore_transitive_fanout) {
+        if (cluster_gain_stats.feasible_blocks.empty() && cluster_gain_stats.explore_transitive_fanout) {
             add_cluster_molecule_candidates_by_transitive_connectivity(cluster_gain_stats,
                                                                        cluster_id,
                                                                        cluster_legalizer,
@@ -728,23 +727,33 @@ PackMoleculeId GreedyCandidateSelector::get_next_candidate_for_cluster(
     }
 
     // 4. Find unpacked molecules based on attraction group of the current cluster (if the cluster has an attraction group)
-    if (cluster_gain_stats.num_feasible_blocks == 0) {
+    if (cluster_gain_stats.feasible_blocks.empty()) {
         add_cluster_molecule_candidates_by_attraction_group(cluster_gain_stats,
                                                             cluster_id,
                                                             cluster_legalizer,
                                                             attraction_groups);
     }
 
     /* Grab highest gain molecule */
-    // If this was a vector, this would just be a pop_back.
     PackMoleculeId best_molecule = PackMoleculeId::INVALID();
-    if (cluster_gain_stats.num_feasible_blocks > 0) {
-        cluster_gain_stats.num_feasible_blocks--;
-        int index = cluster_gain_stats.num_feasible_blocks;
-        best_molecule = cluster_gain_stats.feasible_blocks[index];
+    // If there are feasible blocks being proposed and the number of suggestions did not reach the limit.
+    // Get the block with highest gain from the top of the priority queue.
+    if (!cluster_gain_stats.feasible_blocks.empty() && !cluster_gain_stats.current_stage_candidates_proposed_limit_reached()) {
+        best_molecule = cluster_gain_stats.feasible_blocks.pop().first;
+        VTR_ASSERT(best_molecule != PackMoleculeId::INVALID());
+        cluster_gain_stats.num_candidates_proposed++;
         VTR_ASSERT(!cluster_legalizer.is_mol_clustered(best_molecule));
     }
 
+    // If we have no feasible blocks, or we have reached the limit of number of pops,
+    // then we need to clear the feasible blocks list and reset the number of pops.
+    // This ensures that we can continue searching for feasible blocks for the remaining
+    // steps (2.transitive, 3.high fanout, 4.attraction group).
+    if (cluster_gain_stats.feasible_blocks.empty() || cluster_gain_stats.current_stage_candidates_proposed_limit_reached()) {
+        cluster_gain_stats.feasible_blocks.clear();
+        cluster_gain_stats.num_candidates_proposed = 0;
+    }
+
     // If we are allowing unrelated clustering and no molecule has been found,
     // get unrelated candidate for cluster.
     if (allow_unrelated_clustering_ && best_molecule == PackMoleculeId::INVALID()) {
@@ -778,7 +787,9 @@ void GreedyCandidateSelector::add_cluster_molecule_candidates_by_connectivity_an
     LegalizationClusterId legalization_cluster_id,
     const ClusterLegalizer& cluster_legalizer,
     AttractionInfo& attraction_groups) {
-    cluster_gain_stats.explore_transitive_fanout = true; /* If no legal molecules found, enable exploration of molecules two hops away */
+
+    cluster_gain_stats.explore_transitive_fanout = true;                                  /* If no legal molecules found, enable exploration of molecules two hops away */
+    cluster_gain_stats.candidates_propose_limit = packer_opts_.feasible_block_array_size; // set the limit of candidates to propose
 
     for (AtomBlockId blk_id : cluster_gain_stats.marked_blocks) {
         // Get the molecule that contains this block.
@@ -789,7 +800,6 @@ void GreedyCandidateSelector::add_cluster_molecule_candidates_by_connectivity_an
             add_molecule_to_pb_stats_candidates(molecule_id,
                                                 cluster_gain_stats,
                                                 cluster_legalizer.get_cluster_type(legalization_cluster_id),
-                                                packer_opts_.feasible_block_array_size,
                                                 attraction_groups,
                                                 prepacker_,
                                                 atom_netlist_,
@@ -805,6 +815,7 @@ void GreedyCandidateSelector::add_cluster_molecule_candidates_by_transitive_conn
     AttractionInfo& attraction_groups) {
     //TODO: For now, only done by fan-out; should also consider fan-in
     cluster_gain_stats.explore_transitive_fanout = false;
+    cluster_gain_stats.candidates_propose_limit = std::min(packer_opts_.feasible_block_array_size, AAPACK_MAX_TRANSITIVE_EXPLORE); // set the limit of candidates to propose
 
     /* First time finding transitive fanout candidates therefore alloc and load them */
     load_transitive_fanout_candidates(cluster_gain_stats,
@@ -818,8 +829,6 @@ void GreedyCandidateSelector::add_cluster_molecule_candidates_by_transitive_conn
             add_molecule_to_pb_stats_candidates(molecule_id,
                                                 cluster_gain_stats,
                                                 cluster_legalizer.get_cluster_type(legalization_cluster_id),
-                                                std::min(packer_opts_.feasible_block_array_size,
-                                                         AAPACK_MAX_TRANSITIVE_EXPLORE),
                                                 attraction_groups,
                                                 prepacker_,
                                                 atom_netlist_,
@@ -838,6 +847,7 @@ void GreedyCandidateSelector::add_cluster_molecule_candidates_by_highfanout_conn
      * related blocks */
 
     AtomNetId net_id = cluster_gain_stats.tie_break_high_fanout_net;
+    cluster_gain_stats.candidates_propose_limit = std::min(packer_opts_.feasible_block_array_size, AAPACK_MAX_TRANSITIVE_EXPLORE); // set the limit of candidates to propose
 
     int count = 0;
     for (AtomPinId pin_id : atom_netlist_.net_pins(net_id)) {
@@ -852,8 +862,6 @@ void GreedyCandidateSelector::add_cluster_molecule_candidates_by_highfanout_conn
             add_molecule_to_pb_stats_candidates(molecule_id,
                                                 cluster_gain_stats,
                                                 cluster_legalizer.get_cluster_type(legalization_cluster_id),
-                                                std::min(packer_opts_.feasible_block_array_size,
-                                                         AAPACK_MAX_HIGH_FANOUT_EXPLORE),
                                                 attraction_groups,
                                                 prepacker_,
                                                 atom_netlist_,
@@ -881,6 +889,7 @@ void GreedyCandidateSelector::add_cluster_molecule_candidates_by_attraction_grou
      * group molecules for candidate molecules.
      */
     AttractGroupId grp_id = cluster_gain_stats.attraction_grp_id;
+    cluster_gain_stats.candidates_propose_limit = packer_opts_.feasible_block_array_size; // set the limit of candidates to propose
     if (grp_id == AttractGroupId::INVALID()) {
         return;
     }
@@ -913,7 +922,6 @@ void GreedyCandidateSelector::add_cluster_molecule_candidates_by_attraction_grou
                 add_molecule_to_pb_stats_candidates(molecule_id,
                                                     cluster_gain_stats,
                                                     cluster_legalizer.get_cluster_type(legalization_cluster_id),
-                                                    packer_opts_.feasible_block_array_size,
                                                     attraction_groups,
                                                     prepacker_,
                                                     atom_netlist_,
@@ -935,7 +943,6 @@ void GreedyCandidateSelector::add_cluster_molecule_candidates_by_attraction_grou
             add_molecule_to_pb_stats_candidates(molecule_id,
                                                 cluster_gain_stats,
                                                 cluster_legalizer.get_cluster_type(legalization_cluster_id),
-                                                packer_opts_.feasible_block_array_size,
                                                 attraction_groups,
                                                 prepacker_,
                                                 atom_netlist_,
@@ -950,7 +957,6 @@ void GreedyCandidateSelector::add_cluster_molecule_candidates_by_attraction_grou
 static void add_molecule_to_pb_stats_candidates(PackMoleculeId molecule_id,
                                                 ClusterGainStats& cluster_gain_stats,
                                                 t_logical_block_type_ptr cluster_type,
-                                                int max_queue_size,
                                                 AttractionInfo& attraction_groups,
                                                 const Prepacker& prepacker,
                                                 const AtomNetlist& atom_netlist,
@@ -1004,45 +1010,18 @@ static void add_molecule_to_pb_stats_candidates(PackMoleculeId molecule_id,
         }
     }
 
-    for (int i = 0; i < cluster_gain_stats.num_feasible_blocks; i++) {
-        if (cluster_gain_stats.feasible_blocks[i] == molecule_id) {
-            return; // already in queue, do nothing
-        }
+    // if already in queue, do nothing
+    if (cluster_gain_stats.feasible_blocks.contains(molecule_id)) {
+        return;
     }
 
-    if (cluster_gain_stats.num_feasible_blocks >= max_queue_size - 1) {
-        /* maximum size for array, remove smallest gain element and sort */
-        if (get_molecule_gain(molecule_id, cluster_gain_stats, cluster_att_grp, attraction_groups, num_molecule_failures, prepacker, atom_netlist, appack_ctx) > get_molecule_gain(cluster_gain_stats.feasible_blocks[0], cluster_gain_stats, cluster_att_grp, attraction_groups, num_molecule_failures, prepacker, atom_netlist, appack_ctx)) {
-            /* single loop insertion sort */
-            int j;
-            for (j = 0; j < cluster_gain_stats.num_feasible_blocks - 1; j++) {
-                if (get_molecule_gain(molecule_id, cluster_gain_stats, cluster_att_grp, attraction_groups, num_molecule_failures, prepacker, atom_netlist, appack_ctx) <= get_molecule_gain(cluster_gain_stats.feasible_blocks[j + 1], cluster_gain_stats, cluster_att_grp, attraction_groups, num_molecule_failures, prepacker, atom_netlist, appack_ctx)) {
-                    cluster_gain_stats.feasible_blocks[j] = molecule_id;
-                    break;
-                } else {
-                    cluster_gain_stats.feasible_blocks[j] = cluster_gain_stats.feasible_blocks[j + 1];
-                }
-            }
-            if (j == cluster_gain_stats.num_feasible_blocks - 1) {
-                cluster_gain_stats.feasible_blocks[j] = molecule_id;
-            }
-        }
-    } else {
-        /* Expand array and single loop insertion sort */
-        int j;
-        for (j = cluster_gain_stats.num_feasible_blocks - 1; j >= 0; j--) {
-            if (get_molecule_gain(cluster_gain_stats.feasible_blocks[j], cluster_gain_stats, cluster_att_grp, attraction_groups, num_molecule_failures, prepacker, atom_netlist, appack_ctx) > get_molecule_gain(molecule_id, cluster_gain_stats, cluster_att_grp, attraction_groups, num_molecule_failures, prepacker, atom_netlist, appack_ctx)) {
-                cluster_gain_stats.feasible_blocks[j + 1] = cluster_gain_stats.feasible_blocks[j];
-            } else {
-                cluster_gain_stats.feasible_blocks[j + 1] = molecule_id;
-                break;
-            }
-        }
-        if (j < 0) {
-            cluster_gain_stats.feasible_blocks[0] = molecule_id;
-        }
-        cluster_gain_stats.num_feasible_blocks++;
+    for (std::pair<PackMoleculeId, float>& feasible_block : cluster_gain_stats.feasible_blocks.heap) {
+        VTR_ASSERT_DEBUG(get_molecule_gain(feasible_block.first, cluster_gain_stats, cluster_att_grp, attraction_groups, num_molecule_failures, prepacker, atom_netlist, appack_ctx) == feasible_block.second);
     }
+
+    // Insert the molecule into the queue sorted by gain, and maintain the heap property
+    float molecule_gain = get_molecule_gain(molecule_id, cluster_gain_stats, cluster_att_grp, attraction_groups, num_molecule_failures, prepacker, atom_netlist, appack_ctx);
+    cluster_gain_stats.feasible_blocks.push(molecule_id, molecule_gain);
 }
 
 /*
@@ -1053,27 +1032,7 @@ static void add_molecule_to_pb_stats_candidates(PackMoleculeId molecule_id,
  */
 static void remove_molecule_from_pb_stats_candidates(PackMoleculeId molecule_id,
                                                      ClusterGainStats& cluster_gain_stats) {
-    int molecule_index;
-    bool found_molecule = false;
-
-    //find the molecule index
-    for (int i = 0; i < cluster_gain_stats.num_feasible_blocks; i++) {
-        if (cluster_gain_stats.feasible_blocks[i] == molecule_id) {
-            found_molecule = true;
-            molecule_index = i;
-        }
-    }
-
-    //if it is not in the array, return
-    if (found_molecule == false) {
-        return;
-    }
-
-    //Otherwise, shift the molecules while removing the specified molecule
-    for (int j = molecule_index; j < cluster_gain_stats.num_feasible_blocks - 1; j++) {
-        cluster_gain_stats.feasible_blocks[j] = cluster_gain_stats.feasible_blocks[j + 1];
-    }
-    cluster_gain_stats.num_feasible_blocks--;
+    cluster_gain_stats.feasible_blocks.remove_at_pop_time(molecule_id);
 }
 
 /*