[ClusterLegalizer] Cleaned Up Cluster Placement Stats

Removed external access to the cluster placement stats.

Made the cluster palcement info private for each cluster. The cluster
placement info of each cluster was being shared per cluster
type. This caused issues when two clusters were being created at the
same time.

Author: AlexandreSinger

libs/libarchfpga/src/physical_types.h

@@ -1292,7 +1292,6 @@ class t_pb_graph_node {
     int total_pb_pins; /* only valid for top-level */
 
     void* temp_scratch_pad;                                     /* temporary data, useful for keeping track of things when traversing data structure */
-    t_cluster_placement_primitive* cluster_placement_primitive; /* pointer to indexing structure useful during packing stage */
 
     int* input_pin_class_size;  /* Stores the number of pins that belong to a particular input pin class */
     int num_input_pin_class;    /* number of input pin classes that this pb_graph_node has */

vpr/src/base/vpr_types.cpp

@@ -452,100 +452,3 @@ void t_pb::set_atom_pin_bit_index(const t_pb_graph_pin* gpin, BitIndex atom_pin_
     pin_rotations_[gpin] = atom_pin_bit_idx;
 }
 
-/**
- * Free linked lists found in cluster_placement_stats_list
- */
-void free_cluster_placement_stats(t_cluster_placement_stats* cluster_placement_stats_list) {
-    auto& device_ctx = g_vpr_ctx.device();
-
-    for (const auto& type : device_ctx.logical_block_types) {
-        int index = type.index;
-        cluster_placement_stats_list[index].free_primitives();
-    }
-    delete[] cluster_placement_stats_list;
-}
-
-void t_cluster_placement_stats::move_inflight_to_tried() {
-    tried.insert(*in_flight.begin());
-    in_flight.clear();
-}
-
-void t_cluster_placement_stats::invalidate_primitive_and_increment_iterator(int pb_type_index, std::unordered_multimap<int, t_cluster_placement_primitive*>::iterator& it) {
-    invalid.insert(*it);
-    valid_primitives[pb_type_index].erase(it++);
-}
-
-void t_cluster_placement_stats::move_primitive_to_inflight(int pb_type_index, std::unordered_multimap<int, t_cluster_placement_primitive*>::iterator& it) {
-    in_flight.insert(*it);
-    valid_primitives[pb_type_index].erase(it);
-}
-
-/**
- * @brief Put primitive back on the correct location of valid primitives vector based on the primitive pb type
- *
- * @note that valid status is not changed because if the primitive is not valid, it will get properly collected later
- */
-void t_cluster_placement_stats::insert_primitive_in_valid_primitives(std::pair<int, t_cluster_placement_primitive*> cluster_placement_primitive) {
-    int i;
-    bool success = false;
-    int null_index = OPEN;
-    t_cluster_placement_primitive* input_cluster_placement_primitive = cluster_placement_primitive.second;
-
-    for (i = 0; i < num_pb_types && !success; i++) {
-        if (valid_primitives[i].empty()) {
-            null_index = i;
-            continue;
-        }
-        t_cluster_placement_primitive* cur_cluster_placement_primitive = valid_primitives[i].begin()->second;
-        if (input_cluster_placement_primitive->pb_graph_node->pb_type
-            == cur_cluster_placement_primitive->pb_graph_node->pb_type) {
-            success = true;
-            valid_primitives[i].insert(cluster_placement_primitive);
-        }
-    }
-    if (!success) {
-        VTR_ASSERT(null_index != OPEN);
-        valid_primitives[null_index].insert(cluster_placement_primitive);
-    }
-}
-
-void t_cluster_placement_stats::flush_queue(std::unordered_multimap<int, t_cluster_placement_primitive*>& queue) {
-    for (auto& it : queue) {
-        insert_primitive_in_valid_primitives(it);
-    }
-    queue.clear();
-}
-
-void t_cluster_placement_stats::flush_intermediate_queues() {
-    flush_queue(in_flight);
-    flush_queue(tried);
-}
-
-void t_cluster_placement_stats::flush_invalid_queue() {
-    flush_queue(invalid);
-}
-
-bool t_cluster_placement_stats::in_flight_empty() {
-    return in_flight.empty();
-}
-
-t_pb_type* t_cluster_placement_stats::in_flight_type() {
-    return in_flight.begin()->second->pb_graph_node->pb_type;
-}
-
-void t_cluster_placement_stats::free_primitives() {
-    for (auto& primitive : tried)
-        delete primitive.second;
-
-    for (auto& primitive : in_flight)
-        delete primitive.second;
-
-    for (auto& primitive : invalid)
-        delete primitive.second;
-
-    for (int j = 0; j < num_pb_types; j++) {
-        for (auto& primitive : valid_primitives[j]) {
-            delete primitive.second;
-        }
-    }
-}

vpr/src/base/vpr_types.h

@@ -430,90 +430,6 @@ struct t_chain_info {
     t_pack_molecule* first_packed_molecule = nullptr;
 };
 
-/**
- * @brief Stats keeper for placement information during packing
- *
- * Contains data structure of placement locations based on status of primitive
- */
-class t_cluster_placement_stats {
-  public:
-    int num_pb_types;                     ///<num primitive pb_types inside complex block
-    bool has_long_chain;                  ///<specifies if this cluster has a molecule placed in it that belongs to a long chain (a chain that spans more than one cluster)
-    const t_pack_molecule* curr_molecule; ///<current molecule being considered for packing
-
-    // Vector of size num_pb_types [0.. num_pb_types-1]. Each element is an unordered_map of the cluster_placement_primitives that are of this pb_type
-    // Each cluster_placement_primitive is associated with and index (key of the map) for easier lookup, insertion and deletion.
-    std::vector<std::unordered_map<int, t_cluster_placement_primitive*>> valid_primitives;
-
-  public:
-    // Moves primitives that are inflight to the tried map
-    void move_inflight_to_tried();
-
-    /**
-     * @brief Move the primitive at (it) to inflight and increment the current iterator.
-     *
-     * Because the element at (it) is deleted from valid_primitives, (it) is incremented to keep it valid and pointing at the next element.
-     *
-     * @param pb_type_index: is the index of this pb_type in valid_primitives vector
-     * @param it: is the iterator pointing at the element that needs to be moved to inflight
-     */
-    void move_primitive_to_inflight(int pb_type_index, std::unordered_multimap<int, t_cluster_placement_primitive*>::iterator& it);
-
-    /**
-     * @brief Move the primitive at (it) to invalid and increment the current iterator
-     *
-     * Because the element at (it) is deleted from valid_primitives, (it) is incremented to keep it valid and pointing at the next element.
-     *
-     * @param  pb_type_index: is the index of this pb_type in valid_primitives vector
-     * @param it: is the iterator pointing at the element that needs to be moved to invalid
-     */
-    void invalidate_primitive_and_increment_iterator(int pb_type_index, std::unordered_multimap<int, t_cluster_placement_primitive*>::iterator& it);
-
-    /**
-     * @brief Add a primitive in its correct location in valid_primitives vector based on its pb_type
-     *
-     * @param cluster_placement_primitive: a pair of the cluster_placement_primtive and its corresponding index(for reference in pb_graph_node)
-     */
-    void insert_primitive_in_valid_primitives(std::pair<int, t_cluster_placement_primitive*> cluster_placement_primitive);
-
-    /**
-     * @brief Move all the primitives from (in_flight and tried) maps to valid primitives and clear (in_flight and tried)
-     */
-    void flush_intermediate_queues();
-
-    /**
-     * @brief Move all the primitives from invalid to valid_primitives and clear the invalid map
-     */
-    void flush_invalid_queue();
-
-    /**
-     * @brief Return true if the in_flight map is empty (no primitive is in_flight currently)
-     */
-    bool in_flight_empty();
-
-    /**
-     * @brief Return the type of the first element of the primitives currently being considered
-     */
-    t_pb_type* in_flight_type();
-
-    /**
-     * @brief free the dynamically allocated memory for primitives
-     */
-    void free_primitives();
-
-  private:
-    std::unordered_multimap<int, t_cluster_placement_primitive*> in_flight; ///<ptrs to primitives currently being considered to pack into
-    std::unordered_multimap<int, t_cluster_placement_primitive*> tried;     ///<ptrs to primitives that are already tried but current logic block unable to pack to
-    std::unordered_multimap<int, t_cluster_placement_primitive*> invalid;   ///<ptrs to primitives that are invalid (already occupied by another primitive in this cluster)
-
-    /**
-     * @brief iterate over elements of a queue and move its elements to valid_primitives
-     *
-     * @param queue the unordered_multimap to work on (e.g. in_flight, tried, or invalid)
-     */
-    void flush_queue(std::unordered_multimap<int, t_cluster_placement_primitive*>& queue);
-};
-
 /******************************************************************
  * Timing data types
  *******************************************************************/
@@ -1840,11 +1756,6 @@ typedef vtr::vector<ClusterBlockId, std::vector<std::vector<RRNodeId>>> t_clb_op
 
 typedef std::vector<std::map<int, int>> t_arch_switch_fanin;
 
-/**
- * @brief Free the linked lists to placement locations based on status of primitive inside placement stats data structure.
- */
-void free_cluster_placement_stats(t_cluster_placement_stats* cluster_placement_stats);
-
 struct pair_hash {
     std::size_t operator()(const std::pair<ClusterBlockId, ClusterBlockId>& p) const noexcept {
         return std::hash<ClusterBlockId>()(p.first) ^ (std::hash<ClusterBlockId>()(p.second) << 1);

vpr/src/pack/cluster.cpp

@@ -116,7 +116,6 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
 
     enum e_block_pack_status block_pack_status;
 
-    t_cluster_placement_stats* cur_cluster_placement_stats_ptr = nullptr;
     t_pack_molecule *istart, *next_molecule, *prev_molecule;
 
     auto& atom_ctx = g_vpr_ctx.atom();
@@ -275,7 +274,6 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                 /*it doesn't make sense to do a timing analysis here since there*
                  *is only one atom block clustered it would not change anything      */
             }
-            cur_cluster_placement_stats_ptr = cluster_legalizer.get_cluster_placement_stats(legalization_cluster_id);
             cluster_stats.num_unrelated_clustering_attempts = 0;
             next_molecule = get_molecule_for_cluster(cluster_legalizer.get_cluster_pb(legalization_cluster_id),
                                                      attraction_groups,
@@ -284,7 +282,6 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                                      packer_opts.transitive_fanout_threshold,
                                                      packer_opts.feasible_block_array_size,
                                                      &cluster_stats.num_unrelated_clustering_attempts,
-                                                     cur_cluster_placement_stats_ptr,
                                                      prepacker,
                                                      cluster_legalizer,
                                                      clb_inter_blk_nets,
@@ -317,7 +314,6 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                 try_fill_cluster(cluster_legalizer,
                                  prepacker,
                                  packer_opts,
-                                 cur_cluster_placement_stats_ptr,
                                  prev_molecule,
                                  next_molecule,
                                  num_repeated_molecules,