Added more unit test cases for the partition regions intersection function

Author: sfkhalid

vpr/src/base/partition_regions.cpp

@@ -1,16 +1,19 @@
 #include "partition_regions.h"
 
-PartitionRegions PartitionRegions::get_intersection(PartitionRegions region) {
-    //region is a vector of regions, part_regions is another vector of regions
-    //have to intersect the regions and return their intersection
+PartitionRegions PartitionRegions::get_intersection(PartitionRegions part_region) {
+    /**for N regions in part_region and M in the calling object you can get anywhere from
+     * 0 to M*N regions in the resulting vector. Only regions with non-zero area rectangles and
+     * equivalent subtiles are put in the resulting vector
+     * Rectangles are not merged even if it would be possible
+     */
     PartitionRegions pr;
     Region intersect_region;
     bool regions_intersect;
     for (unsigned int i = 0; i < partition_regions.size(); i++) {
-        for (unsigned int j = 0; j < region.partition_regions.size(); j++) {
-            regions_intersect = partition_regions[i].do_regions_intersect(region.partition_regions[j]);
+        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]);
             if (regions_intersect) {
-                intersect_region = partition_regions[i].regions_intersection(region.partition_regions[j]);
+                intersect_region = partition_regions[i].regions_intersection(part_region.partition_regions[j]);
                 pr.partition_regions.push_back(intersect_region);
             }
         }

vpr/src/base/partition_regions.h

@@ -15,7 +15,7 @@ class PartitionRegions {
     /**
      * Returns the intersection of two PartitionRegions vectors that are passed to it.
      */
-    PartitionRegions get_intersection(PartitionRegions region);
+    PartitionRegions get_intersection(PartitionRegions part_region);
 
     //method to add to the partition_regions vector
     void add_to_part_regions(Region region);

vpr/src/base/region.cpp

@@ -69,14 +69,19 @@ bool Region::do_regions_intersect(Region region) {
 Region Region::regions_intersection(Region region) {
     Region intersect;
 
-    vtr::Rect<int> region_rect = region.get_region_rect();
-    vtr::Rect<int> intersect_rect;
-
-    intersect_rect = intersection(region_bounds, region_rect);
-
-    intersect.set_region_rect(intersect_rect.xmin(), intersect_rect.ymin(), intersect_rect.xmax(), intersect_rect.ymax());
+    //if the subtiles do not match, there is no intersection
+    //so, the control will go straight to returning intersect, which will just be a region with an empty rectangle
+    //if the subtiles do match, then there will be an intersection as long as the rectangles overlap
+    //and the intersection will be found by the code in the if statement
+    //if they do not overlap, the intersection rectangle will still return an empty rectangle
     if (sub_tile == region.get_sub_tile()) {
         intersect.set_sub_tile(sub_tile);
+        vtr::Rect<int> region_rect = region.get_region_rect();
+        vtr::Rect<int> intersect_rect;
+
+        intersect_rect = intersection(region_bounds, region_rect);
+
+        intersect.set_region_rect(intersect_rect.xmin(), intersect_rect.ymin(), intersect_rect.xmax(), intersect_rect.ymax());
     }
 
     return intersect;
@@ -99,3 +104,7 @@ bool Region::locked() {
 
     return locked = true;
 }
+
+bool Region::empty() {
+    return region_bounds.empty();
+}

vpr/src/base/region.h

@@ -26,6 +26,10 @@ class Region {
 
     void set_sub_tile(int _sub_tile);
 
+    //function to see if region is empty
+    //checks if the Rect of the region is empty
+    bool empty();
+
     //function to see if two regions intersect anywhere
     bool do_regions_intersect(Region region);
 
@@ -39,7 +43,7 @@ class Region {
   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, will select if they want to lock down block to specific location
+    int sub_tile;                 //users will optionally select a subtile
 };
 
 #endif /* REGION_H */

vpr/test/test_vpr_constraints.cpp

@@ -159,14 +159,34 @@ TEST_CASE("RegionIntersect", "[vpr]") {
     REQUIRE(rect_2.xmax() == 8);
     REQUIRE(rect_2.ymax() == 6);
 
-    //Test no intersection (rect is empty)
+    //Test no intersection (rectangles don't overlap, intersect region will be returned empty)
 
     Region int_reg_3;
 
     int_reg_3 = region1.regions_intersection(region3);
-    vtr::Rect<int> rect_3 = int_reg_3.get_region_rect();
 
-    REQUIRE(rect_3.empty() == TRUE);
+    REQUIRE(int_reg_3.empty() == TRUE);
+
+    //Test no intersection (rectangles overlap but different subtiles are specified, intersect region will be returned empty)
+    region1.set_sub_tile(5);
+    region2.set_sub_tile(3);
+
+    Region int_reg_4;
+    int_reg_4 = region1.regions_intersection(region2);
+
+    REQUIRE(int_reg_4.empty() == TRUE);
+
+    //Test intersection where subtiles are the same and equal to something other than the INVALID value
+    region1.set_sub_tile(6);
+    region2.set_sub_tile(6);
+
+    Region int_reg_5;
+    int_reg_5 = region1.regions_intersection(region2);
+    vtr::Rect<int> rect_5 = int_reg_5.get_region_rect();
+    REQUIRE(rect_5.xmin() == 2);
+    REQUIRE(rect_5.ymin() == 3);
+    REQUIRE(rect_5.xmax() == 3);
+    REQUIRE(rect_5.ymax() == 5);
 }
 
 TEST_CASE("PartRegionIntersect", "[vpr]") {
@@ -201,61 +221,207 @@ TEST_CASE("PartRegionIntersect", "[vpr]") {
     REQUIRE(regions[1].get_ymax() == 2);
 }
 
-TEST_CASE("RegionLocked", "[vpr]") {
+TEST_CASE("PartRegionIntersect2", "[vpr]") {
+    PartitionRegions pr1;
+    PartitionRegions pr2;
+
     Region r1;
-    bool is_r1_locked = false;
+    Region r2;
+    Region r3;
 
-    //set the region to a specific x, y, subtile location - region is locked
-    r1.set_region_rect(2, 3, 2, 3); //point (2,3) to point (2,3) - locking to specific x, y location
-    r1.set_sub_tile(3);             //locking down to subtile 3
+    r1.set_region_rect(0, 0, 2, 2);
+    r2.set_region_rect(4, 4, 6, 6);
+    r3.set_region_rect(0, 0, 2, 2);
 
-    is_r1_locked = r1.locked();
+    pr1.add_to_part_regions(r1);
+    pr1.add_to_part_regions(r2);
+    pr2.add_to_part_regions(r3);
 
-    REQUIRE(is_r1_locked == true);
+    PartitionRegions int_pr;
 
-    //do not set region to specific x, y location - region is not locked even if a subtile is specified
-    r1.set_region_rect(2, 3, 5, 6); //point (2,3) to point (5,6) - not locking to specific x, y location
-    r1.set_sub_tile(3);             //locking down to subtile 3
+    int_pr = pr1.get_intersection(pr2);
+    std::vector<Region> regions = int_pr.get_partition_regions();
 
-    is_r1_locked = r1.locked();
+    REQUIRE(regions.size() == 1);
+    REQUIRE(regions[0].get_xmin() == 0);
+    REQUIRE(regions[0].get_ymin() == 0);
+    REQUIRE(regions[0].get_xmax() == 2);
+    REQUIRE(regions[0].get_ymax() == 2);
+}
 
-    REQUIRE(is_r1_locked == false);
+//2x2 regions, no overlaps
+TEST_CASE("PartRegionIntersect3", "[vpr]") {
+    PartitionRegions pr1;
+    PartitionRegions pr2;
 
-    //do not specify a subtile for the region - region is not locked even if it is set at specific x, y location
+    Region r1;
     Region r2;
-    bool is_r2_locked = true;
+    Region r3;
+    Region r4;
 
-    r2.set_region_rect(2, 3, 2, 3);
+    r1.set_region_rect(1, 2, 3, 5);
+    r1.set_sub_tile(2);
 
-    is_r2_locked = r2.locked();
+    r2.set_region_rect(4, 2, 6, 4);
 
-    REQUIRE(is_r2_locked == false);
+    r3.set_region_rect(4, 5, 5, 7);
+
+    r4.set_region_rect(1, 2, 3, 5);
+    r4.set_sub_tile(4);
+
+    pr1.add_to_part_regions(r1);
+    pr1.add_to_part_regions(r2);
+    pr2.add_to_part_regions(r3);
+    pr2.add_to_part_regions(r4);
+
+    PartitionRegions int_pr;
+
+    int_pr = pr1.get_intersection(pr2);
+    std::vector<Region> regions = int_pr.get_partition_regions();
+
+    REQUIRE(regions.size() == 0);
 }
 
-TEST_CASE("PartRegionIntersect2", "[vpr]") {
+//2x2 regions, 1 overlap
+TEST_CASE("PartRegionIntersect4", "[vpr]") {
     PartitionRegions pr1;
     PartitionRegions pr2;
 
     Region r1;
     Region r2;
     Region r3;
+    Region r4;
 
-    r1.set_region_rect(0, 0, 2, 2);
-    r2.set_region_rect(4, 4, 6, 6);
-    r3.set_region_rect(0, 0, 2, 2);
+    r1.set_region_rect(1, 2, 3, 5);
+    r1.set_sub_tile(2);
+
+    r2.set_region_rect(4, 2, 6, 4);
+
+    r3.set_region_rect(4, 5, 5, 7);
+
+    r4.set_region_rect(1, 2, 3, 4);
+    r4.set_sub_tile(2);
 
     pr1.add_to_part_regions(r1);
     pr1.add_to_part_regions(r2);
     pr2.add_to_part_regions(r3);
+    pr2.add_to_part_regions(r4);
 
     PartitionRegions int_pr;
 
     int_pr = pr1.get_intersection(pr2);
     std::vector<Region> regions = int_pr.get_partition_regions();
 
+    vtr::Rect<int> intersect(1, 2, 3, 4);
+
     REQUIRE(regions.size() == 1);
-    REQUIRE(regions[0].get_xmin() == 0);
-    REQUIRE(regions[0].get_ymin() == 0);
-    REQUIRE(regions[0].get_xmax() == 2);
-    REQUIRE(regions[0].get_ymax() == 2);
+    REQUIRE(regions[0].get_region_rect() == intersect);
+    REQUIRE(regions[0].get_sub_tile() == 2);
+}
+
+//2x2 regions, 2 overlap
+TEST_CASE("PartRegionIntersect5", "[vpr]") {
+    PartitionRegions pr1;
+    PartitionRegions pr2;
+
+    Region r1;
+    Region r2;
+    Region r3;
+    Region r4;
+
+    r1.set_region_rect(1, 5, 5, 7);
+
+    r2.set_region_rect(6, 3, 8, 5);
+
+    r3.set_region_rect(2, 6, 4, 9);
+
+    r4.set_region_rect(6, 4, 8, 7);
+
+    pr1.add_to_part_regions(r1);
+    pr1.add_to_part_regions(r2);
+    pr2.add_to_part_regions(r3);
+    pr2.add_to_part_regions(r4);
+
+    PartitionRegions int_pr;
+
+    int_pr = pr1.get_intersection(pr2);
+    std::vector<Region> regions = int_pr.get_partition_regions();
+
+    vtr::Rect<int> int_r1r3(2, 6, 4, 7);
+    vtr::Rect<int> int_r2r4(6, 4, 8, 5);
+
+    REQUIRE(regions.size() == 2);
+    REQUIRE(regions[0].get_region_rect() == int_r1r3);
+    REQUIRE(regions[1].get_region_rect() == int_r2r4);
+}
+
+//2x2 regions, 4 overlap
+TEST_CASE("PartRegionIntersect6", "[vpr]") {
+    PartitionRegions pr1;
+    PartitionRegions pr2;
+
+    Region r1;
+    Region r2;
+    Region r3;
+    Region r4;
+
+    r1.set_region_rect(2, 3, 4, 7);
+
+    r2.set_region_rect(5, 3, 7, 8);
+
+    r3.set_region_rect(2, 2, 7, 4);
+
+    r4.set_region_rect(2, 6, 7, 8);
+
+    pr1.add_to_part_regions(r1);
+    pr1.add_to_part_regions(r2);
+    pr2.add_to_part_regions(r3);
+    pr2.add_to_part_regions(r4);
+
+    PartitionRegions int_pr;
+
+    int_pr = pr1.get_intersection(pr2);
+    std::vector<Region> regions = int_pr.get_partition_regions();
+
+    vtr::Rect<int> int_r1r3(2, 3, 4, 4);
+    vtr::Rect<int> int_r1r4(2, 6, 4, 7);
+    vtr::Rect<int> int_r2r3(5, 3, 7, 4);
+    vtr::Rect<int> int_r2r4(5, 6, 7, 8);
+
+    REQUIRE(regions.size() == 4);
+    REQUIRE(regions[0].get_region_rect() == int_r1r3);
+    REQUIRE(regions[1].get_region_rect() == int_r1r4);
+    REQUIRE(regions[2].get_region_rect() == int_r2r3);
+    REQUIRE(regions[3].get_region_rect() == int_r2r4);
+}
+
+TEST_CASE("RegionLocked", "[vpr]") {
+    Region r1;
+    bool is_r1_locked = false;
+
+    //set the region to a specific x, y, subtile location - region is locked
+    r1.set_region_rect(2, 3, 2, 3); //point (2,3) to point (2,3) - locking to specific x, y location
+    r1.set_sub_tile(3);             //locking down to subtile 3
+
+    is_r1_locked = r1.locked();
+
+    REQUIRE(is_r1_locked == true);
+
+    //do not set region to specific x, y location - region is not locked even if a subtile is specified
+    r1.set_region_rect(2, 3, 5, 6); //point (2,3) to point (5,6) - not locking to specific x, y location
+    r1.set_sub_tile(3);             //locking down to subtile 3
+
+    is_r1_locked = r1.locked();
+
+    REQUIRE(is_r1_locked == false);
+
+    //do not specify a subtile for the region - region is not locked even if it is set at specific x, y location
+    Region r2;
+    bool is_r2_locked = true;
+
+    r2.set_region_rect(2, 3, 2, 3);
+
+    is_r2_locked = r2.locked();
+
+    REQUIRE(is_r2_locked == false);
 }