Made comments doxygen compatible

Author: sfkhalid

vpr/src/base/partition.cpp

@@ -10,10 +10,10 @@ void Partition::set_name(std::string _part_name) {
     name = _part_name;
 }
 
-const PartitionRegion Partition::get_part_regions() {
-    return part_regions;
+const PartitionRegion Partition::get_part_region() {
+    return part_region;
 }
 
-void Partition::set_part_regions(PartitionRegion pr) {
-    part_regions = pr;
+void Partition::set_part_region(PartitionRegion pr) {
+    part_region = pr;
 }

vpr/src/base/partition.h

@@ -7,32 +7,41 @@
 #include "partition_region.h"
 /**
  * @file
- * @brief This file defines the data for a partition: a grouping of atoms that are constrained to a portion of an FPGA. A partition defines
- * the atoms that are assigned to it, and the locations in which they can be placed. The locations are a union of rectangles in x, y,
- * sub_tile space. Common cases include a single rectangle or a single x, y, sub_tile (specific location). More complex partitions
+ * @brief This file defines the data for a partition: a grouping of atoms that are constrained to a portion of an FPGA.
+ *
+ * A partition defines the atoms that are assigned to it, and the locations in which they can be placed.
+ * The locations are a union of rectangles in x, y, sub_tile space.
+ * Common cases include a single rectangle or a single x, y, sub_tile (specific location). More complex partitions
  * with L, T or other shapes can be created with a union of multiple rectangles.
  */
 
-//Type tag for PartitionId
+/// @brief Type tag for PartitionId
 struct partition_id_tag;
 
-//A unique identifier for a partition
+/// @brief A unique identifier for a partition
 typedef vtr::StrongId<partition_id_tag> PartitionId;
 
 class Partition {
   public:
     const std::string get_name();
+
     void set_name(std::string _part_name);
 
-    //set the union of regions for this partition;
-    void set_part_regions(PartitionRegion pr);
+    /**
+     * @brief Set the PartitionRegion (union of rectangular regions) for this partition
+     *
+     *   @param pr     The PartitionRegion belonging to the partition
+     */
+    void set_part_region(PartitionRegion pr);
 
-    //get the union of regions of this partition
-    const PartitionRegion get_part_regions();
+    /**
+     * @brief Get the PartitionRegion (union of rectangular regions) for this partition
+     */
+    const PartitionRegion get_part_region();
 
   private:
-    std::string name;             //name of the partition, name will be unique across partitions
-    PartitionRegion part_regions; //the union of regions that the partition can be placed in
+    std::string name;            ///< name of the partition, name will be unique across partitions
+    PartitionRegion part_region; ///< the union of regions that the partition can be placed in
 };
 
 #endif /* PARTITION_H */

vpr/src/base/partition_region.cpp

@@ -9,23 +9,23 @@ PartitionRegion PartitionRegion::get_intersection(PartitionRegion part_region) {
     PartitionRegion pr;
     Region intersect_region;
     bool regions_intersect;
-    for (unsigned int i = 0; i < partition_regions.size(); i++) {
-        for (unsigned int j = 0; j < part_region.partition_regions.size(); j++) {
-            regions_intersect = partition_regions[i].do_regions_intersect(part_region.partition_regions[j]);
+    for (unsigned int i = 0; i < partition_region.size(); i++) {
+        for (unsigned int j = 0; j < part_region.partition_region.size(); j++) {
+            regions_intersect = partition_region[i].do_regions_intersect(part_region.partition_region[j]);
             if (regions_intersect) {
-                intersect_region = partition_regions[i].regions_intersection(part_region.partition_regions[j]);
-                pr.partition_regions.push_back(intersect_region);
+                intersect_region = partition_region[i].regions_intersection(part_region.partition_region[j]);
+                pr.partition_region.push_back(intersect_region);
             }
         }
     }
 
     return pr;
 }
 
-void PartitionRegion::add_to_part_regions(Region region) {
-    partition_regions.push_back(region);
+void PartitionRegion::add_to_part_region(Region region) {
+    partition_region.push_back(region);
 }
 
-std::vector<Region> PartitionRegion::get_partition_regions() {
-    return partition_regions;
+std::vector<Region> PartitionRegion::get_partition_region() {
+    return partition_region;
 }

vpr/src/base/partition_region.h

@@ -12,17 +12,27 @@
 
 class PartitionRegion {
   public:
-    //Returns the intersection of two PartitionRegions vectors that are passed to it.
+    /**
+     * @brief Return the intersection of two PartitionRegions
+     *
+     *   @param part_region     The PartitionRegion that the calling object will be intersected with
+     */
     PartitionRegion get_intersection(PartitionRegion part_region);
 
-    //function to add to the partition_regions vector
-    void add_to_part_regions(Region region);
+    /**
+     * @brief Add a region to the union of regions belonging to the partition
+     *
+     *   @param region     The region to be added to the calling object
+     */
+    void add_to_part_region(Region region);
 
-    //function to get the partition_regions vector
-    std::vector<Region> get_partition_regions();
+    /**
+     * @brief Return the union of regions
+     */
+    std::vector<Region> get_partition_region();
 
   private:
-    std::vector<Region> partition_regions; //vector of regions that a partition can be placed in
+    std::vector<Region> partition_region; ///< union of rectangular regions that a partition can be placed in
 };
 
 #endif /* PARTITION_REGIONS_H */

vpr/src/base/region.cpp

@@ -1,6 +1,6 @@
 #include "region.h"
 
-//sentinel value for indicating that a subtile has not been specified
+/// @brief sentinel value for indicating that a subtile has not been specified
 constexpr int NO_SUBTILE = -1;
 
 Region::Region() {
@@ -40,7 +40,8 @@ bool Region::do_regions_intersect(Region region) {
 
     intersect_rect = intersection(region_bounds, region_rect);
 
-    /**if the intersection rectangle is empty or the subtile of the two regions does not match,
+    /**
+     * if the intersection rectangle is empty or the subtile of the two regions does not match,
      * the regions do not intersect
      */
     if (intersect_rect.empty() || sub_tile != region.get_sub_tile()) {

vpr/src/base/region.h

@@ -6,8 +6,9 @@
 /**
  * @file
  * @brief This file defines the Region class. The Region class stores the data for each constraint region.
- *        This includes the x and y bounds of the region rectangle and its sub_tile. To lock a block down to a specific location,
- *        when defining the region specify xmin = xmax, ymin = ymax, and specify a subtile value.
+ *
+ * This includes the x and y bounds of the region rectangle and its sub_tile. To lock a block down to a specific location,
+ * when defining the region specify xmin = xmax, ymin = ymax, and specify a subtile value.
  *
  */
 
@@ -23,27 +24,38 @@ class Region {
 
     void set_sub_tile(int _sub_tile);
 
-    //function to see if region is empty (checks if region rectangle is empty)
+    /**
+     * @brief Return whether the region is empty, based on whether the region rectangle is empty
+     */
     bool empty();
 
-    /**function to see if two regions intersect anywhere
+    /**
+     * @brief Returns whether two regions intersect
+     *
      * Intersection is the area of overlap between the rectangles of two regions,
      * given that both regions have matching subtile values, or no subtiles assigned to them
      * The overlap is inclusive of the x and y boundaries of the rectangles
+     *
+     *   @param region  The region to intersect with the calling object
      */
     bool do_regions_intersect(Region region);
 
-    //returns the coordinates of the rectangular intersection of two regions
+    /**
+     * @brief Returns the coordinates of intersection of two regions
+     *
+     *   @param region  The region to intersect with the calling object
+     */
     Region regions_intersection(Region region);
 
-    //function to check whether a block is locked down to a specific x, y, subtile location
-    //can be called by the placer to see if the block is locked down
+    /**
+     * @brief Checks whether a block is locked down to a specific x, y, subtile location
+     */
     bool locked();
 
   private:
     //may need to include zmin, zmax for future use in 3D FPGA designs
-    vtr::Rect<int> region_bounds; //xmin, ymin, xmax, ymax inclusive
-    int sub_tile;                 //users will optionally select a subtile
+    vtr::Rect<int> region_bounds; ///< xmin, ymin, xmax, ymax inclusive
+    int sub_tile;                 ///< users will optionally select a subtile
 };
 
 #endif /* REGION_H */

vpr/src/base/vpr_constraints.cpp

@@ -3,7 +3,6 @@
 void VprConstraints::add_constrained_atom(const AtomBlockId blk_id, const PartitionId part_id) {
     constrained_atoms.insert({blk_id, part_id});
 
-    //std::unordered_map<AtomBlockId, PartitionId>::const_iterator got = constrained_atoms.find(blk_id);
     auto got = constrained_atoms.find(blk_id);
 
     if (got == constrained_atoms.end()) {
@@ -16,7 +15,6 @@ void VprConstraints::add_constrained_atom(const AtomBlockId blk_id, const Partit
 PartitionId VprConstraints::get_atom_partition(AtomBlockId blk_id) {
     PartitionId part_id;
 
-    //std::unordered_map<AtomBlockId, PartitionId>::const_iterator got = constrained_atoms.find(blk_id);
     auto got = constrained_atoms.find(blk_id);
 
     if (got == constrained_atoms.end()) {

vpr/src/base/vpr_constraints.h

@@ -14,37 +14,58 @@
  * Overview
  * ========
  * This class contains functions that read in and store information from a constraints XML file.
- * The XML file provides a partition list, with the names/ids of the partitions, and each atom in the partition.
- * It also specifies which regions the partitions should be placed in.
+ * The XML file provides a partition list, with the names of the partitions, and each atom in the partition.
+ * It also specifies which regions the partitions should be placed in. Atoms cannot be placed in more than one partition.
+ * If an atom is assigned to more than one partition, the last partition is was assigned to will be the partition it is placed in.
  *
  */
 
 class VprConstraints {
   public:
-    //function to add an atom to constrained_atoms
+    /**
+     * @brief Store the id of a constrained atom with the id of the partition it belongs to
+     *
+     *   @param blk_id      The atom being stored
+     *   @param part_id     The partition the atom is being constrained to
+     */
     void add_constrained_atom(const AtomBlockId blk_id, const PartitionId part_id);
 
-    //function to find which partition an atom belongs to
+    /**
+     * @brief Return id of the partition the atom belongs to
+     *
+     *   @param blk_id      The atom for which the partition id is needed
+     */
     PartitionId get_atom_partition(AtomBlockId blk_id);
 
-    //function to add a partition to partitions
+    /**
+     * @brief Store a partition
+     *
+     *   @param part     The partition being stored
+     */
     void add_partition(Partition part);
 
-    //function to return a partition given a PartitionId
+    /**
+     * @brief Return a partition
+     *
+     *   @param part_id    The id of the partition that is wanted
+     */
     Partition get_partition(PartitionId part_id);
 
-    //function to return the atoms belonging to a partition
+    /**
+     * @brief Return all the atoms that belong to a partition
+     *
+     *   @param part_id   The id of the partition whose atoms are needed
+     */
     std::vector<AtomBlockId> get_part_atoms(PartitionId part_id);
 
   private:
     /**
-     * Store constraints information of each  constrained atom.
-     * Store ID of the partition the atom belongs to.
+     * Store all constrained atoms
      */
     std::unordered_map<AtomBlockId, PartitionId> constrained_atoms;
 
     /**
-     * Store partitions in a vector
+     * Store all partitions
      */
     vtr::vector<PartitionId, Partition> partitions;
 };