[WIP] VIB Upgrades for Tileable Routing Resource Graph on OpenFPGA

libs/libarchfpga/src/physical_types.h

@@ -47,6 +47,8 @@
 #include "logic_types.h"
 #include "clock_types.h"
 
+#include "vib_inf.h"
+
 //Forward declarations
 struct t_clock_arch;
 struct t_clock_network;
@@ -1629,7 +1631,16 @@ enum e_Fc_type {
  *           For backward compatibility, this attribute is optional. If not  *
  *           specified, the resource type for the segment is considered to   *
  *           be GENERAL.                                                     *
- * meta: Table storing extra arbitrary metadata attributes.                  */
+ * meta: Table storing extra arbitrary metadata attributes.                  *
+ * 
+ * 
+ * New added parameters for bend wires:                                      *
+ * isbend: This segment is bend or not                                       *
+ * bend: The bend type of the segment, "-"-0, "U"-1, "D"-2                   *
+ *       For example: bend pattern <- - U ->; corresponding bend: [0,0,1,0]  *
+ * part_len: Divide the segment into several parts based on bend position.   *
+ *           For example: length-5 bend segment: <- - U ->;                  *
+ *           Corresponding part_len: [3,2]                                   */
 struct t_segment_inf {
     std::string name;
     int frequency;
@@ -1648,6 +1659,9 @@ struct t_segment_inf {
     enum e_parallel_axis parallel_axis;
     std::vector<bool> cb;
     std::vector<bool> sb;
+    bool isbend;                                 
+    std::vector<int> bend;
+    std::vector<int> part_len;
     int seg_index;
     enum SegResType res_type = SegResType::GENERAL;
     //float Cmetal_per_m; /* Wire capacitance (per meter) */
@@ -2045,7 +2059,9 @@ struct t_noc_inf {
     std::string noc_router_tile_name;
 };
 
-/*   Detailed routing architecture */
+
+
+/* Detailed routing architecture */
 struct t_arch {
     /** Stores unique strings used as key and values in <metadata> tags,
      * i.e. implements a flyweight pattern to save memory.*/
@@ -2127,10 +2143,16 @@ struct t_arch {
     //If the layout is not specified in the command line options, this variable will be set to "auto"
     std::string device_layout; 
 
+    std::vector<t_vib_grid_def> vib_grid_layouts;
+
     t_clock_arch_spec clock_arch; // Clock related data types
 
     // if we have an embedded NoC in the architecture, then we store it here
     t_noc_inf* noc = nullptr;
+
+    // added for vib
+    //bool is_vib_arch = false;
+    std::vector<VibInf> vib_infs;
 };
 
 #endif

libs/libarchfpga/src/vib_inf.cpp

@@ -0,0 +1,127 @@
+#include "vib_inf.h"
+// #include "vtr_math.h"
+// #include "vtr_util.h"
+// #include "vtr_log.h"
+
+// #include "arch_util.h"
+
+VibInf::VibInf() {
+    name_.clear();
+    pbtype_name_.clear();
+    seg_group_num_ = 0;
+    switch_idx_ = -1;
+    seg_groups_.clear();
+    first_stages_.clear();
+    second_stages_.clear();
+}
+
+void VibInf::set_name(const std::string name) {
+    VTR_ASSERT(!name.empty());
+    name_ = name;
+}
+
+void VibInf::set_pbtype_name(const std::string pbtype_name) {
+    VTR_ASSERT(!pbtype_name.empty());
+    pbtype_name_ = pbtype_name;
+}
+
+void VibInf::set_seg_group_num(const int seg_group_num) {
+    VTR_ASSERT(seg_group_num >= 0);
+    seg_group_num_ = seg_group_num;
+}
+
+void VibInf::set_switch_idx(const int switch_idx) {
+    VTR_ASSERT(switch_idx != -1);
+    switch_idx_ = switch_idx;
+}
+
+void VibInf::set_switch_name(const std::string switch_name) {
+    VTR_ASSERT(!switch_name.empty());
+    switch_name_ = switch_name;
+}
+
+void VibInf::set_seg_groups(const std::vector<t_seg_group> seg_groups) {
+    VTR_ASSERT(!seg_groups.empty());
+    seg_groups_.clear();
+    for(auto seg_group : seg_groups) {
+        seg_groups_.push_back(seg_group);
+    }
+}
+
+void VibInf::push_seg_group(const t_seg_group seg_group) {
+    VTR_ASSERT(!seg_group.name.empty());
+    seg_groups_.push_back(seg_group);
+}
+
+void VibInf::set_first_stages(const std::vector<t_first_stage_mux_inf> first_stages) {
+    VTR_ASSERT(!first_stages.empty());
+    first_stages_.clear();
+    for(auto first_stage : first_stages) {
+        first_stages_.push_back(first_stage);
+    }
+}
+
+void VibInf::push_first_stage(const t_first_stage_mux_inf first_stage) {
+    VTR_ASSERT(!first_stage.mux_name.empty());
+    first_stages_.push_back(first_stage);
+}
+
+void VibInf::set_second_stages(const std::vector<t_second_stage_mux_inf> second_stages) {
+    VTR_ASSERT(!second_stages.empty());
+    second_stages_.clear();
+    for(auto second_stage : second_stages) {
+        second_stages_.push_back(second_stage);
+    }
+}
+
+void VibInf::push_second_stage(const t_second_stage_mux_inf second_stage) {
+    VTR_ASSERT(!second_stage.mux_name.empty());
+    second_stages_.push_back(second_stage);
+}
+
+std::string VibInf::get_name() const{
+    VTR_ASSERT(!name_.empty());
+    return name_;
+}
+
+std::string VibInf::get_pbtype_name() const{
+    VTR_ASSERT(!pbtype_name_.empty());
+    return pbtype_name_;
+}
+
+int VibInf::get_seg_group_num() const{
+    VTR_ASSERT(seg_group_num_ >= 0);
+    return seg_group_num_;
+}
+
+int VibInf::get_switch_idx() const{
+    VTR_ASSERT(switch_idx_ != -1);
+    return switch_idx_;
+}
+
+std::string VibInf::get_switch_name() const{
+    VTR_ASSERT(!switch_name_.empty());
+    return switch_name_;
+}
+
+std::vector<t_seg_group> VibInf::get_seg_groups() const{
+    VTR_ASSERT(!seg_groups_.empty());
+    return seg_groups_;
+}
+
+std::vector<t_first_stage_mux_inf> VibInf::get_first_stages() const{
+    VTR_ASSERT(!first_stages_.empty());
+    return first_stages_;
+}
+
+std::vector<t_second_stage_mux_inf> VibInf::get_second_stages() const{
+    VTR_ASSERT(!second_stages_.empty());
+    return second_stages_;
+}
+
+
+VibDeviceGrid::VibDeviceGrid(std::string grid_name, vtr::NdMatrix<const VibInf*, 3> vib_grid)
+    : name_(std::move(grid_name))
+    , vib_grid_(std::move(vib_grid)) {
+
+}