[vpr][place] remove the parts for reclustering

Author: amin1377

libs/libarchfpga/src/physical_types_util.cpp

@@ -524,39 +524,6 @@ bool is_sub_tile_compatible(t_physical_tile_type_ptr physical_tile, t_logical_bl
     return capacity_compatible && is_tile_compatible(physical_tile, logical_block);
 }
 
-bool is_atom_compatible(t_logical_block_type_ptr logical_block, const t_pb_graph_node* atom_pb_graph_node, int loc_primitive_num) {
-    VTR_ASSERT(loc_primitive_num != OPEN);
-    const t_pb_graph_node* loc_pb_graph_node = nullptr;
-
-    // Check whether the atom
-    const t_pb_graph_node* parent_pb_graph_node = atom_pb_graph_node->parent_pb_graph_node;
-    while (parent_pb_graph_node->parent_pb_graph_node != nullptr) {
-        parent_pb_graph_node = parent_pb_graph_node->parent_pb_graph_node;
-    }
-
-    if (logical_block->pb_graph_head != parent_pb_graph_node) {
-        return false;
-    }
-    /**
-     * Iterate over the data structure that maps primitive_pb_graph_node to their respective class range,
-     * and retrieve the primitive_pb_graph_node from that map. If the primitive number assigned to that
-     * primitive_pb_graph_node is equal to loc_primitive_num, then we have found the desired primitive_pb_graph_node.
-     */
-    for (const auto& primitive_node_class_pair : logical_block->primitive_pb_graph_node_class_range) {
-        const auto& primitive_node = primitive_node_class_pair.first;
-        VTR_ASSERT_SAFE(primitive_node->primitive_num != OPEN);
-        if (primitive_node->primitive_num == loc_primitive_num) {
-            loc_pb_graph_node = primitive_node;
-            break;
-        }
-    }
-    VTR_ASSERT_SAFE(loc_pb_graph_node != nullptr);
-    if (loc_pb_graph_node->pb_type == atom_pb_graph_node->pb_type)
-        return true;
-    else
-        return false;
-}
-
 int get_physical_pin_at_sub_tile_location(t_physical_tile_type_ptr physical_tile,
                                           t_logical_block_type_ptr logical_block,
                                           int sub_tile_capacity,

libs/libarchfpga/src/physical_types_util.h

@@ -187,9 +187,6 @@ bool is_tile_compatible(t_physical_tile_type_ptr physical_tile, t_logical_block_
 ///@brief Verifies whether a logical block and a relative placement location is compatible with a given physical tile
 bool is_sub_tile_compatible(t_physical_tile_type_ptr physical_tile, t_logical_block_type_ptr logical_block, int sub_tile_loc);
 
-///@brief Verifies whether the given atom_pb_graph_node can be mapped to the primitive that loc_primitive_num is pointing to.
-bool is_atom_compatible(t_logical_block_type_ptr logical_block, const t_pb_graph_node* atom_pb_graph_node, int loc_primitive_num);
-
 /**
  * @brief Returns the first physical tile type that matches the logical block
  *

vpr/src/base/SetupVPR.cpp

@@ -693,7 +693,6 @@ static void SetupPlacerOpts(const t_options& Options, t_placer_opts* PlacerOpts)
     PlacerOpts->place_constraint_subtile = Options.place_constraint_subtile;
     PlacerOpts->floorplan_num_horizontal_partitions = Options.floorplan_num_horizontal_partitions;
     PlacerOpts->floorplan_num_vertical_partitions = Options.floorplan_num_vertical_partitions;
-    PlacerOpts->place_re_cluster = Options.place_re_cluster;
 
     PlacerOpts->seed = Options.Seed;
 

vpr/src/base/read_options.cpp

@@ -2200,15 +2200,6 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .choices({"move_type", "move_block_type"})
         .show_in(argparse::ShowIn::HELP_ONLY);
 
-    place_grp.add_argument<bool, ParseOnOff>(args.place_re_cluster, "--place_re_cluster")
-        .help(
-            "Use this option to determine whether reclustering occurs during placement. "
-            ""
-            "When this option is set to 'on,' the placement stage may change some clusters. "
-            "Conversely, if the option is set to 'off,' the clustering determined by the packer will remain unchanged")
-        .default_value("off")
-        .show_in(argparse::ShowIn::HELP_ONLY);
-
     place_grp.add_argument(args.placer_debug_block, "--placer_debug_block")
         .help(
             " Controls when placer debugging is enabled for blocks.\n"

vpr/src/base/read_options.h

@@ -151,7 +151,6 @@ struct t_options {
     argparse::ArgValue<bool> place_constraint_subtile;
     argparse::ArgValue<int> floorplan_num_horizontal_partitions;
     argparse::ArgValue<int> floorplan_num_vertical_partitions;
-    argparse::ArgValue<bool> place_re_cluster;
 
     argparse::ArgValue<int> placer_debug_block;
     argparse::ArgValue<int> placer_debug_net;

vpr/src/base/vpr_types.cpp

@@ -557,31 +557,4 @@ void t_cluster_placement_stats::free_primitives() {
             delete primitive.second;
         }
     }
-}
-
-/**
- * @brief Get the atom block id at the given location. Since we currently don't have any array to retrieve this information directly,
- * we first find the cluster mapped to that location, and then find the atom inside that cluster that is mapped to the given location.
- */
-AtomBlockId GridBlock::block_at_location(const t_pl_atom_loc& loc) const {
-    const auto& atom_lookup = g_vpr_ctx.atom().lookup;
-    t_pl_loc cluster_loc(loc.x, loc.y, loc.sub_tile, loc.layer);
-    ClusterBlockId cluster_at_loc = block_at_location(cluster_loc);
-    if (cluster_at_loc == EMPTY_BLOCK_ID) {
-        return EMPTY_PRIMITIVE_BLOCK_ID;
-    } else if (cluster_at_loc == INVALID_BLOCK_ID) {
-        return INVALID_PRIMITIVE_BLOCK_ID;
-    } else {
-        VTR_ASSERT(cluster_at_loc.is_valid());
-        const auto& cluster_atoms = g_vpr_ctx.cl_helper().atoms_lookup;
-        const auto& atom_list = cluster_atoms.at(cluster_at_loc);
-        for (const auto& atom : atom_list) {
-            int primitive_pin = atom_lookup.atom_pb_graph_node(atom)->primitive_num;
-            t_pl_atom_loc atom_loc(primitive_pin, cluster_loc.x, cluster_loc.y, cluster_loc.sub_tile, cluster_loc.layer);
-            if (atom_loc == loc) {
-                return atom;
-            }
-        }
-        return EMPTY_PRIMITIVE_BLOCK_ID;
-    }
 }

vpr/src/base/vpr_types.h

@@ -98,9 +98,7 @@ enum class ScreenUpdatePriority {
 
 /* Defining macros for the placement_ctx t_grid_blocks. Assumes that ClusterBlockId's won't exceed positive 32-bit integers */
 constexpr auto EMPTY_BLOCK_ID = ClusterBlockId(-1);
-constexpr auto EMPTY_PRIMITIVE_BLOCK_ID = AtomBlockId(-1);
 constexpr auto INVALID_BLOCK_ID = ClusterBlockId(-2);
-constexpr auto INVALID_PRIMITIVE_BLOCK_ID = AtomBlockId(-2);
 
 /*
  * Files
@@ -814,40 +812,6 @@ struct hash<t_pl_loc> {
 };
 } // namespace std
 
-struct t_pl_atom_loc {
-    t_pl_atom_loc() = default;
-    t_pl_atom_loc(int primitive_id_, int x_, int y_, int sub_tile_, int layer_)
-        : primitive_id(primitive_id_)
-        , x(x_)
-        , y(y_)
-        , sub_tile(sub_tile_)
-        , layer(layer_) {}
-
-    int primitive_id = OPEN;
-    int x = OPEN;
-    int y = OPEN;
-    int sub_tile = OPEN;
-    int layer = OPEN;
-};
-
-inline bool operator==(const t_pl_atom_loc& lhs, const t_pl_atom_loc& rhs) {
-    return std::tie(lhs.primitive_id, lhs.x, lhs.y, lhs.sub_tile, lhs.layer) == std::tie(rhs.primitive_id, rhs.x, rhs.y, rhs.sub_tile, rhs.layer);
-}
-
-namespace std {
-template<>
-struct hash<t_pl_atom_loc> {
-    std::size_t operator()(const t_pl_atom_loc& v) const noexcept {
-        std::size_t seed = std::hash<int>{}(v.x);
-        vtr::hash_combine(seed, v.y);
-        vtr::hash_combine(seed, v.sub_tile);
-        vtr::hash_combine(seed, v.layer);
-        vtr::hash_combine(seed, v.primitive_id);
-        return seed;
-    }
-};
-} // namespace std
-
 struct t_place_region {
     float capacity; ///<Capacity of this region, in tracks.
     float inv_capacity;
@@ -912,8 +876,6 @@ class GridBlock {
         return grid_blocks_[loc.layer][loc.x][loc.y].blocks[loc.sub_tile];
     }
 
-    AtomBlockId block_at_location(const t_pl_atom_loc& loc) const;
-
     inline size_t num_blocks_at_location(const t_physical_tile_loc& loc) const {
         return grid_blocks_[loc.layer_num][loc.x][loc.y].blocks.size();
     }
@@ -1316,7 +1278,6 @@ struct t_placer_opts {
     int floorplan_num_horizontal_partitions;
     int floorplan_num_vertical_partitions;
 
-    bool place_re_cluster;
     int placer_debug_block;
     int placer_debug_net;
 

vpr/src/place/atom_critical_uniform_move_generator.cpp

@@ -3,35 +3,6 @@
 #include "globals.h"
 #include "place_util.h"
 
-e_block_move_result record_block_move(t_pl_atom_blocks_to_be_moved& blocks_affected, AtomBlockId blk, t_pl_atom_loc to) {
-    auto res = blocks_affected.moved_to.emplace(to);
-    if (!res.second) {
-        log_move_abort("duplicate block move to location");
-        return e_block_move_result::ABORT;
-    }
-
-    const auto& place_ctx = g_vpr_ctx.placement();
-
-    t_pl_atom_loc from = get_atom_loc(blk);
-
-    auto res2 = blocks_affected.moved_from.emplace(from);
-    if (!res2.second) {
-        log_move_abort("duplicate block move from location");
-        return e_block_move_result::ABORT;
-    }
-
-    VTR_ASSERT_SAFE(to.sub_tile < int(place_ctx.grid_blocks.num_blocks_at_location({to.x, to.y, to.layer})));
-
-    // Sets up the blocks moved
-    int imoved_blk = blocks_affected.num_moved_blocks;
-    blocks_affected.moved_blocks[imoved_blk].block_num = blk;
-    blocks_affected.moved_blocks[imoved_blk].old_loc = from;
-    blocks_affected.moved_blocks[imoved_blk].new_loc = to;
-    blocks_affected.num_moved_blocks++;
-
-    return e_block_move_result::VALID;
-}
-
 //Records that block 'blk' should be moved to the specified 'to' location
 e_block_move_result record_block_move(t_pl_blocks_to_be_moved& blocks_affected, ClusterBlockId blk, t_pl_loc to) {
     auto res = blocks_affected.moved_to.emplace(to);
@@ -62,21 +33,6 @@ e_block_move_result record_block_move(t_pl_blocks_to_be_moved& blocks_affected,
     return e_block_move_result::VALID;
 }
 
-//Moves the blocks in blocks_affected to their new locations
-void apply_move_blocks(const t_pl_atom_blocks_to_be_moved& blocks_affected) {
-    const auto& atom_lookup = g_vpr_ctx.atom().lookup;
-    std::set<ClusterBlockId> seen_clusters;
-    const int num_moved_blocks = blocks_affected.num_moved_blocks;
-    for (int blk_idx = 0; blk_idx < num_moved_blocks; blk_idx++) {
-        AtomBlockId atom_blk = blocks_affected.moved_blocks[blk_idx].block_num;
-        ClusterBlockId cluster_blk = atom_lookup.atom_clb(atom_blk);
-        if (seen_clusters.find(cluster_blk) == seen_clusters.end()) {
-            seen_clusters.insert(cluster_blk);
-            place_sync_external_block_connections(cluster_blk);
-        }
-    }
-}
-
 //Moves the blocks in blocks_affected to their new locations
 void apply_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected) {
     auto& place_ctx = g_vpr_ctx.mutable_placement();
@@ -135,10 +91,6 @@ void commit_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected) {
     } // Finish updating clb for all blocks
 }
 
-void revert_move_blocks(t_pl_atom_blocks_to_be_moved& blocks_affected) {
-    //TODO: this function needs to be implemented
-}
-
 //Moves the blocks in blocks_affected to their old locations
 void revert_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected) {
     auto& place_ctx = g_vpr_ctx.mutable_placement();