Add tileable rr graph support.

Author: Yitian4Debug

libs/libarchfpga/src/physical_types.h

@@ -613,6 +613,8 @@ struct t_physical_tile_type {
 
     std::vector<t_class> class_inf; /* [0..num_class-1] */
 
+    int num_class = 0;
+
     std::vector<int> pin_width_offset;  // [0..num_pins-1]
     std::vector<int> pin_height_offset; // [0..num_pins-1]
     std::vector<int> pin_class;         // [0..num_pins-1]
@@ -1397,7 +1399,7 @@ enum e_directionality {
     BI_DIRECTIONAL
 };
 /* X_AXIS: Data that describes an x-directed wire segment (CHANX)                     *
- * Y_AXIS: Data that describes an y-directed wire segment (CHANY)                     *     
+ * Y_AXIS: Data that describes an y-directed wire segment (CHANY)                     *
  * BOTH_AXIS: Data that can be applied to both x-directed and y-directed wire segment */
 enum e_parallel_axis {
     X_AXIS,
@@ -1442,7 +1444,7 @@ enum e_Fc_type {
  * Cmetal: Capacitance of a routing track, per unit logic block length.      *
  * Rmetal: Resistance of a routing track, per unit logic block length.       *
  * (UDSD by AY) drivers: How do signals driving a routing track connect to   *
- *                       the track?  
+ *                       the track?
  * seg_index: The index of the segment as stored in the appropriate Segs list*
  *            Upon loading the architecture, we use this field to keep track *
  *            the segment's index in the unified segment_inf vector. This is *
@@ -1498,12 +1500,12 @@ constexpr std::array<const char*, size_t(SwitchType::NUM_SWITCH_TYPES)> SWITCH_T
 
 /* Constant/Reserved names for switches in architecture XML
  * Delayless switch:
- *   The zero-delay switch created by VPR internally 
+ *   The zero-delay switch created by VPR internally
  *   This is a special switch just to ease CAD algorithms
  *   It is mainly used in
- *     - the edges between SOURCE and SINK nodes in routing resource graphs  
+ *     - the edges between SOURCE and SINK nodes in routing resource graphs
  *     - the edges in CLB-to-CLB connections (defined by <directlist> in arch XML)
- *   
+ *
  */
 constexpr const char* VPR_DELAYLESS_SWITCH_NAME = "__vpr_delayless_switch__";
 
@@ -1798,12 +1800,18 @@ struct t_arch {
 
     char* architecture_id; //Secure hash digest of the architecture file to uniquely identify this architecture
 
+    /* Xifan Tang: options for tileable routing architectures */
+    bool tileable;
+    bool through_channel;
+
     t_chan_width_dist Chans;
     enum e_switch_block_type SBType;
+    enum e_switch_block_type SBSubType;
     std::vector<t_switchblock_inf> switchblocks;
     float R_minW_nmos;
     float R_minW_pmos;
     int Fs;
+    int subFs;
     float grid_logic_tile_area;
     std::vector<t_segment_inf> Segments;
     t_arch_switch_inf* Switches = nullptr;

libs/libvtrutil/src/vtr_geometry.h

@@ -61,6 +61,9 @@ bool operator!=(const RectUnion<T>& lhs, const RectUnion<T>& rhs);
 template<class T>
 class Point {
   public: //Constructors
+    // below is to create a no argument constructor for libopenfpga/libopenfpgautil/src/openfpga_pb_parser.cpp
+    // need to figure out a better solution to avoid change this in libs from vtr
+    Point();
     Point(T x_val, T y_val) noexcept;
 
   public: //Accessors

vpr/src/tileable_rr_graph/chan_node_details.cpp

@@ -0,0 +1,299 @@
+/************************************************************************
+ *  This file contains member functions for class ChanNodeDetails
+ ***********************************************************************/
+#include <algorithm>
+
+/* Headers from vtrutil library */
+#include "vtr_assert.h"
+
+#include "chan_node_details.h"
+
+/* begin namespace openfpga */
+namespace openfpga {
+
+/************************************************************************
+ *  Constructors 
+ ***********************************************************************/
+ChanNodeDetails::ChanNodeDetails(const ChanNodeDetails& src) {
+  /* duplicate */
+  size_t chan_width = src.get_chan_width();
+  this->reserve(chan_width); 
+  for (size_t itrack = 0; itrack < chan_width; ++itrack) {
+    track_node_ids_.push_back(src.get_track_node_id(itrack));
+    track_direction_.push_back(src.get_track_direction(itrack));
+    seg_ids_.push_back(src.get_track_segment_id(itrack));
+    seg_length_.push_back(src.get_track_segment_length(itrack));
+    track_start_.push_back(src.is_track_start(itrack));
+    track_end_.push_back(src.is_track_end(itrack));
+  }
+}
+
+ChanNodeDetails::ChanNodeDetails() {
+  this->clear();
+}
+
+/************************************************************************
+ *  Accessors
+ ***********************************************************************/
+size_t ChanNodeDetails::get_chan_width() const {
+  VTR_ASSERT(validate_chan_width());
+  return track_node_ids_.size();
+}
+
+size_t ChanNodeDetails::get_track_node_id(const size_t& track_id) const {
+  VTR_ASSERT(validate_track_id(track_id));
+  return track_node_ids_[track_id];
+}
+
+/* Return a copy of vector */
+std::vector<size_t> ChanNodeDetails::get_track_node_ids() const {
+  std::vector<size_t> copy;
+  for (size_t inode = 0; inode < get_chan_width(); ++inode) {
+    copy.push_back(track_node_ids_[inode]);
+  } 
+  return copy;
+}
+
+Direction ChanNodeDetails::get_track_direction(const size_t& track_id) const {
+  VTR_ASSERT(validate_track_id(track_id));
+  return track_direction_[track_id];
+}
+
+size_t ChanNodeDetails::get_track_segment_length(const size_t& track_id) const {
+  VTR_ASSERT(validate_track_id(track_id));
+  return seg_length_[track_id];
+}
+
+size_t ChanNodeDetails::get_track_segment_id(const size_t& track_id) const {
+  VTR_ASSERT(validate_track_id(track_id));
+  return seg_ids_[track_id];
+}
+
+bool   ChanNodeDetails::is_track_start(const size_t& track_id) const {
+  VTR_ASSERT(validate_track_id(track_id));
+  return track_start_[track_id];
+}
+
+bool   ChanNodeDetails::is_track_end(const size_t& track_id) const {
+  VTR_ASSERT(validate_track_id(track_id));
+  return track_end_[track_id];
+}
+
+/* Track_id is the starting point of group (whose is_start should be true) 
+ * This function will try to find the track_ids with the same directionality as track_id and seg_length
+ * A group size is the number of such nodes between the starting points (include the 1st starting point) 
+ */
+std::vector<size_t> ChanNodeDetails::get_seg_group(const size_t& track_id) const {
+  VTR_ASSERT(validate_chan_width());
+  VTR_ASSERT(validate_track_id(track_id));
+  VTR_ASSERT(is_track_start(track_id));
+  
+  std::vector<size_t> group;
+  /* Make sure a clean start */
+  group.clear();
+
+  for (size_t itrack = track_id; itrack < get_chan_width(); ++itrack) {
+    if ( (get_track_direction(itrack) != get_track_direction(track_id) )
+      || (get_track_segment_id(itrack) != get_track_segment_id(track_id)) ) {
+      /* Bypass any nodes in different direction and segment information*/
+      continue;
+    }
+    if ( (false == is_track_start(itrack)) 
+      || ( (true == is_track_start(itrack)) && (itrack == track_id)) ) {
+      group.push_back(itrack);
+      continue;
+    }
+    /* Stop if this another starting point */
+    if (true == is_track_start(itrack)) {
+      break;
+    }
+  }  
+  return group;
+}
+
+/* Get a list of track_ids with the given list of track indices */
+std::vector<size_t> ChanNodeDetails::get_seg_group_node_id(const std::vector<size_t>& seg_group) const {
+  std::vector<size_t> group;
+  /* Make sure a clean start */
+  group.clear();
+
+  for (size_t id = 0; id < seg_group.size(); ++id) {
+    VTR_ASSERT(validate_track_id(seg_group[id]));
+    group.push_back(get_track_node_id(seg_group[id]));
+  }
+
+  return group;
+}
+
+/* Get the number of tracks that starts in this routing channel */
+size_t ChanNodeDetails::get_num_starting_tracks(const Direction& track_direction) const {
+  size_t counter = 0;
+  for (size_t itrack = 0; itrack < get_chan_width(); ++itrack) {
+    /* Bypass unmatched track_direction */
+    if (track_direction != get_track_direction(itrack)) {
+      continue;
+    }
+    if (false == is_track_start(itrack)) {
+      continue;
+    } 
+    counter++;
+  }  
+  return counter;
+}
+
+/* Get the number of tracks that ends in this routing channel */
+size_t ChanNodeDetails::get_num_ending_tracks(const Direction& track_direction) const {
+  size_t counter = 0;
+  for (size_t itrack = 0; itrack < get_chan_width(); ++itrack) {
+    /* Bypass unmatched track_direction */
+    if (track_direction != get_track_direction(itrack)) {
+      continue;
+    }
+    if (false == is_track_end(itrack)) {
+      continue;
+    } 
+    counter++;
+  }  
+  return counter;
+}
+
+
+/************************************************************************
+ *  Mutators
+ ***********************************************************************/
+/* Reserve the capacitcy of vectors */
+void ChanNodeDetails::reserve(const size_t& chan_width) {
+  track_node_ids_.reserve(chan_width);
+  track_direction_.reserve(chan_width);
+  seg_length_.reserve(chan_width);
+  seg_ids_.reserve(chan_width);
+  track_start_.reserve(chan_width);
+  track_end_.reserve(chan_width);
+}
+
+/* Add a track to the channel */
+void ChanNodeDetails::add_track(const size_t& track_node_id, const Direction& track_direction,
+                                const size_t& seg_id, const size_t& seg_length,
+                                const size_t& is_start, const size_t& is_end) {
+  track_node_ids_.push_back(track_node_id);
+  track_direction_.push_back(track_direction);
+  seg_ids_.push_back(seg_id);
+  seg_length_.push_back(seg_length);
+  track_start_.push_back(is_start);
+  track_end_.push_back(is_end);
+}
+
+/* Update the node_id of a given track */
+void ChanNodeDetails::set_track_node_id(const size_t& track_index, const size_t& track_node_id) {
+  VTR_ASSERT(validate_track_id(track_index));
+  track_node_ids_[track_index] = track_node_id; 
+}
+
+/* Update the node_ids from a vector */
+void ChanNodeDetails::set_track_node_ids(const std::vector<size_t>& track_node_ids) {
+  /* the size of vector should match chan_width */
+  VTR_ASSERT ( get_chan_width() == track_node_ids.size() );
+  for (size_t inode = 0; inode < track_node_ids.size(); ++inode) {
+    track_node_ids_[inode] = track_node_ids[inode]; 
+  }
+}
+
+/* Set tracks with a given direction to start */
+void ChanNodeDetails::set_tracks_start(const Direction& track_direction) {
+  for (size_t inode = 0; inode < get_chan_width(); ++inode) {
+    /* Bypass non-match tracks */
+    if (track_direction != get_track_direction(inode)) {
+      continue; /* Pass condition*/
+    }
+    track_start_[inode] = true;
+  }
+}
+
+/* Set tracks with a given direction to end */
+void ChanNodeDetails::set_tracks_end(const Direction& track_direction) {
+  for (size_t inode = 0; inode < get_chan_width(); ++inode) {
+    /* Bypass non-match tracks */
+    if (track_direction != get_track_direction(inode)) {
+      continue; /* Pass condition*/
+    }
+    track_end_[inode] = true;
+  }
+}
+
+/* rotate the track_node_id by an offset */
+void ChanNodeDetails::rotate_track_node_id(const size_t& offset, const Direction& track_direction, const bool& counter_rotate) {
+  /* Direct return if offset = 0*/
+  if (0 == offset) {
+    return;
+  }
+ 
+  /* Rotate the node_ids by groups
+   * A group begins from a track_start and ends before another track_start  
+   */
+  VTR_ASSERT(validate_chan_width());
+  for (size_t itrack = 0; itrack < get_chan_width(); ++itrack) { 
+    /* Bypass non-start segment */
+    if (false == is_track_start(itrack) ) {
+      continue;
+    }
+    /* Bypass segments do not match track_direction */
+    if (track_direction != get_track_direction(itrack) ) {
+      continue;
+    }
+    /* Find the group nodes */
+    std::vector<size_t> track_group = get_seg_group(itrack);
+    /* Build a vector of the node ids of the tracks */
+    std::vector<size_t> track_group_node_id = get_seg_group_node_id(track_group);
+    /* adapt offset to the range of track_group_node_id */
+    size_t actual_offset = offset % track_group_node_id.size();
+    /* Rotate or Counter rotate */
+    if (true == counter_rotate) {
+      std::rotate(track_group_node_id.rbegin(), track_group_node_id.rbegin() + actual_offset, track_group_node_id.rend());
+    } else {
+      std::rotate(track_group_node_id.begin(), track_group_node_id.begin() + actual_offset, track_group_node_id.end());
+    }
+    /* Update the node_ids */
+    for (size_t inode = 0; inode < track_group.size(); ++inode) {
+      track_node_ids_[track_group[inode]] = track_group_node_id[inode];
+    }
+  }
+  return;
+}
+
+void ChanNodeDetails::clear() {
+  track_node_ids_.clear();
+  track_direction_.clear();
+  seg_ids_.clear();
+  seg_length_.clear();
+  track_start_.clear();
+  track_end_.clear();
+}
+
+/************************************************************************
+ *  Validators 
+ ***********************************************************************/
+bool ChanNodeDetails::validate_chan_width() const {
+  size_t chan_width = track_node_ids_.size();
+  if ( (chan_width == track_direction_.size())
+     &&(chan_width == seg_ids_.size())
+     &&(chan_width == seg_length_.size())
+     &&(chan_width == track_start_.size())
+     &&(chan_width == track_end_.size()) ) {
+    return true;
+  }
+  return false;
+}
+
+bool ChanNodeDetails::validate_track_id(const size_t& track_id) const {
+  if ( (track_id < track_node_ids_.size()) 
+    && (track_id < track_direction_.size()) 
+    && (track_id < seg_ids_.size()) 
+    && (track_id < seg_length_.size()) 
+    && (track_id < track_start_.size()) 
+    && (track_id < track_end_.size()) ) {
+    return true;
+  } 
+  return false;
+}
+
+} /* end namespace openfpga */