Merge pull request #2272 from verilog-to-routing/block_type_based_RLplace_agent

RLPlace 2.0: Proposing block and move types

Author: vaughnbetz

comparison_output.xlsx

@@ -658,6 +658,7 @@ static void SetupPlacerOpts(const t_options& Options, t_placer_opts* PlacerOpts)
     PlacerOpts->place_agent_epsilon = Options.place_agent_epsilon;
     PlacerOpts->place_agent_gamma = Options.place_agent_gamma;
     PlacerOpts->place_dm_rlim = Options.place_dm_rlim;
+    PlacerOpts->place_agent_space = Options.place_agent_space;
     PlacerOpts->place_reward_fun = Options.place_reward_fun;
     PlacerOpts->place_crit_limit = Options.place_crit_limit;
     PlacerOpts->place_agent_algorithm = Options.place_agent_algorithm;

vpr/src/base/SetupVPR.cpp

@@ -28,6 +28,14 @@ t_logical_block_type_ptr ClusteredNetlist::block_type(const ClusterBlockId id) c
     return block_types_[id];
 }
 
+std::vector<ClusterBlockId> ClusteredNetlist::blocks_per_type(const t_logical_block_type blk_type) const {
+    if (blocks_per_type_.count(blk_type.index) == 0) {
+        std::vector<ClusterBlockId> empty_vector;
+        return empty_vector;
+    }
+    return blocks_per_type_.at(blk_type.index);
+}
+
 ClusterNetId ClusteredNetlist::block_net(const ClusterBlockId blk_id, const int logical_pin_index) const {
     auto pin_id = block_pin(blk_id, logical_pin_index);
 
@@ -108,6 +116,8 @@ ClusterBlockId ClusteredNetlist::create_block(const char* name, t_pb* pb, t_logi
         block_pbs_.insert(blk_id, pb);
         block_types_.insert(blk_id, type);
 
+        blocks_per_type_[type->index].push_back(blk_id);
+
         //Allocate and initialize every potential pin of the block
         block_logical_pins_.insert(blk_id, std::vector<ClusterPinId>(get_max_num_pins(type), ClusterPinId::INVALID()));
     }
@@ -168,11 +178,14 @@ ClusterNetId ClusteredNetlist::create_net(const std::string name) {
 }
 
 void ClusteredNetlist::remove_block_impl(const ClusterBlockId blk_id) {
+    //find the block type, so we can remove it from blocks_per_type_ data structure
+    auto blk_type = block_type(blk_id);
     //Remove & invalidate pointers
     free_pb(block_pbs_[blk_id]);
     delete block_pbs_[blk_id];
     block_pbs_.insert(blk_id, NULL);
     block_types_.insert(blk_id, NULL);
+    std::remove(blocks_per_type_[blk_type->index].begin(), blocks_per_type_[blk_type->index].end(), blk_id);
     block_logical_pins_.insert(blk_id, std::vector<ClusterPinId>());
 }
 

vpr/src/base/clustered_netlist.cpp

@@ -134,6 +134,9 @@ class ClusteredNetlist : public Netlist<ClusterBlockId, ClusterPortId, ClusterPi
     ///@brief Returns the type of CLB (Logic block, RAM, DSP, etc.)
     t_logical_block_type_ptr block_type(const ClusterBlockId id) const;
 
+    ///@brief Returns the blocks with the specific block types in the netlist
+    std::vector<ClusterBlockId> blocks_per_type(const t_logical_block_type blk_type) const;
+
     ///@brief Returns the net of the block attached to the specific pin index
     ClusterNetId block_net(const ClusterBlockId blk_id, const int pin_index) const;
 
@@ -331,6 +334,7 @@ class ClusteredNetlist : public Netlist<ClusterBlockId, ClusterPortId, ClusterPi
     vtr::vector_map<ClusterBlockId, t_pb*> block_pbs_;                              ///<Physical block representing the clustering & internal hierarchy of each CLB
     vtr::vector_map<ClusterBlockId, t_logical_block_type_ptr> block_types_;         ///<The type of logical block this user circuit block is mapped to
     vtr::vector_map<ClusterBlockId, std::vector<ClusterPinId>> block_logical_pins_; ///<The logical pin associated with each physical tile pin
+    std::unordered_map<int, std::vector<ClusterBlockId>> blocks_per_type_;          ///<Block IDs associated with each physical block type, Used in placement to move specific block type
 
     //Pins
     /**

vpr/src/base/clustered_netlist.h

@@ -977,12 +977,12 @@ void Netlist<BlockId, PortId, PinId, NetId>::remove_block(const BlockId blk_id)
     StringId name_id = block_names_[blk_id];
     block_name_to_block_id_.insert(name_id, BlockId::INVALID());
 
-    //Mark as invalid
-    block_ids_[blk_id] = BlockId::INVALID();
-
     //Call derived class' remove()
     remove_block_impl(blk_id);
 
+    //Mark as invalid
+    block_ids_[blk_id] = BlockId::INVALID();
+
     //Mark netlist dirty
     dirty_ = true;
 }

vpr/src/base/netlist.tpp

@@ -461,6 +461,37 @@ struct ParsePlaceAgentAlgorithm {
     }
 };
 
+struct ParsePlaceAgentSpace {
+    ConvertedValue<e_agent_space> from_str(std::string str) {
+        ConvertedValue<e_agent_space> conv_value;
+        if (str == "move_type")
+            conv_value.set_value(MOVE_TYPE);
+        else if (str == "move_block_type")
+            conv_value.set_value(MOVE_BLOCK_TYPE);
+        else {
+            std::stringstream msg;
+            msg << "Invalid conversion from '" << str << "' to e_agent_space (expected one of: " << argparse::join(default_choices(), ", ") << ")";
+            conv_value.set_error(msg.str());
+        }
+        return conv_value;
+    }
+
+    ConvertedValue<std::string> to_str(e_agent_space val) {
+        ConvertedValue<std::string> conv_value;
+        if (val == MOVE_TYPE)
+            conv_value.set_value("move_type");
+        else {
+            VTR_ASSERT(val == MOVE_BLOCK_TYPE);
+            conv_value.set_value("move_block_type");
+        }
+        return conv_value;
+    }
+
+    std::vector<std::string> default_choices() {
+        return {"move_type", "move_block_type"};
+    }
+};
+
 struct ParseFixPins {
     ConvertedValue<e_pad_loc_type> from_str(std::string str) {
         ConvertedValue<e_pad_loc_type> conv_value;
@@ -2083,6 +2114,14 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .choices({"e_greedy", "softmax"})
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    place_grp.add_argument<e_agent_space, ParsePlaceAgentSpace>(args.place_agent_space, "--place_agent_space")
+        .help(
+            "Agent exploration space can be either based on only move types or also consider different block types\n"
+            "The available values are: move_type, move_block_type")
+        .default_value("move_block_type")
+        .choices({"move_type", "move_block_type"})
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     auto& place_timing_grp = parser.add_argument_group("timing-driven placement options");
 
     place_timing_grp.add_argument(args.PlaceTimingTradeoff, "--timing_tradeoff")

vpr/src/base/read_options.cpp

@@ -134,6 +134,7 @@ struct t_options {
     argparse::ArgValue<float> place_agent_epsilon;
     argparse::ArgValue<float> place_agent_gamma;
     argparse::ArgValue<float> place_dm_rlim;
+    argparse::ArgValue<e_agent_space> place_agent_space;
     argparse::ArgValue<e_agent_algorithm> place_agent_algorithm;
     argparse::ArgValue<std::string> place_reward_fun;
     argparse::ArgValue<float> place_crit_limit;

vpr/src/base/read_options.h

@@ -387,6 +387,19 @@ struct PlacementContext : public Context {
      * Used for unique identification and consistency checking
      */
     std::string placement_id;
+
+    /**
+     * @brief Map physical block type to RL-agent block type
+     *
+     * RL-agent block types are the physical block types that are used in the netlist (at least one logical block in the netlist maps to).
+     * As an example:
+     *      Having physical block types (EMPTY, LAB, DSP, IO),
+     *      agent block types would be (LAB,IO) if netlist doesn't contain DSP blocks.
+     * Key   : physical (agent) block type index
+     * Value : agent (physical) block type index
+     */
+    std::unordered_map<int, int> phys_blk_type_to_agent_blk_type_map;
+    std::unordered_map<int, int> agent_blk_type_to_phys_blk_type_map;
 };
 
 /**

vpr/src/base/vpr_context.h

@@ -983,6 +983,18 @@ enum e_agent_algorithm {
     SOFTMAX
 };
 
+/**
+ * @brief Used to determines the dimensionality of the RL agent exploration space
+ *
+ * Agent exploration space can be either based on only move types or
+ * can be based on (block_type, move_type) pair.
+ *
+ */
+enum e_agent_space {
+    MOVE_TYPE,
+    MOVE_BLOCK_TYPE
+};
+
 ///@brief Used to calculate the inner placer loop's block swapping limit move_lim.
 enum e_place_effort_scaling {
     CIRCUIT,       ///<Effort scales based on circuit size only
@@ -1065,6 +1077,8 @@ enum class e_place_delta_delay_algorithm {
  *   @param place_constraint_subtile
  *              True if subtiles should be specified when printing floorplan
  *              constraints. False if not.
+ *
+ *
  */
 struct t_placer_opts {
     t_place_algorithm place_algorithm;
@@ -1113,6 +1127,7 @@ struct t_placer_opts {
     float place_agent_epsilon;
     float place_agent_gamma;
     float place_dm_rlim;
+    e_agent_space place_agent_space;
     //int place_timing_cost_func;
     std::string place_reward_fun;
     float place_crit_limit;

vpr/src/base/vpr_types.h

@@ -310,7 +310,8 @@ e_create_move manual_move_display_and_propose(ManualMoveGenerator& manual_move_g
     draw_manual_moves_window("");
     update_screen(ScreenUpdatePriority::MAJOR, " ", PLACEMENT, nullptr);
     move_type = e_move_type::MANUAL_MOVE;
-    return manual_move_generator.propose_move(blocks_affected, move_type, rlim, placer_opts, criticalities);
+    t_logical_block_type blk_type; //no need to specify block type in manual move "propose_move" function
+    return manual_move_generator.propose_move(blocks_affected, move_type, blk_type, rlim, placer_opts, criticalities);
 }
 
 #endif /*NO_GRAPHICS*/