odb: test 3dblox checker

osamahammad21 · osamahammad21 · commit 03ce502ff32b · 2025-11-12T18:35:26.000+02:00
Signed-off-by: osamahammad21 &lt;osama21@aucegypt.edu&gt;
diff --git a/src/odb/src/db/dbMarker.cpp b/src/odb/src/db/dbMarker.cpp
@@ -23,6 +23,7 @@
 #include "dbVector.h"
 #include "odb/db.h"
 // User Code Begin Includes
+#include "dbChip.h"
 #include "dbCore.h"
 #include "odb/dbBlockCallBackObj.h"
 // User Code End Includes
@@ -203,6 +204,13 @@ _dbBlock* _dbMarker::getBlock() const
   return category->getBlock();
 }
 
+_dbChip* _dbMarker::getChip() const
+{
+  dbMarker* marker = (dbMarker*) this;
+  _dbMarkerCategory* category = (_dbMarkerCategory*) marker->getCategory();
+  return category->getChip();
+}
+
 void _dbMarker::writeTR(std::ofstream& report) const
 {
   dbBlock* block = (dbBlock*) getBlock();
@@ -622,6 +630,9 @@ std::string dbMarker::getName() const
       case dbObstructionObj:
         sources += "obstruction";
         break;
+      case dbChipInstObj:
+        sources += static_cast<dbChipInst*>(src)->getName();
+        break;
       default:
         obj->getLogger()->error(
             utl::ODB, 290, "Unsupported object type: {}", src->getTypeName());
@@ -762,6 +773,7 @@ std::set<dbObject*> dbMarker::getSources() const
 {
   _dbMarker* marker = (_dbMarker*) this;
   _dbBlock* block = marker->getBlock();
+  _dbChip* chip = marker->getChip();
 
   std::set<dbObject*> objs;
   if (block) {
@@ -771,6 +783,13 @@ std::set<dbObject*> dbMarker::getSources() const
         objs.insert(table->getObject(id));
       }
     }
+  } else {
+    for (const auto& [db_type, id] : marker->sources_) {
+      dbObjectTable* table = chip->getObjectTable(db_type);
+      if (table != nullptr && table->validObject(id)) {
+        objs.insert(table->getObject(id));
+      }
+    }
   }
   return objs;
 }
diff --git a/src/odb/src/db/dbMarker.h b/src/odb/src/db/dbMarker.h
@@ -31,6 +31,7 @@ class _dbTechLayer;
 class Line;
 class Rect;
 class Polygon;
+class _dbChip;
 // User Code End Classes
 
 struct dbMarkerFlags
@@ -63,6 +64,7 @@ class _dbMarker : public _dbObject
   void collectMemInfo(MemInfo& info);
   // User Code Begin Methods
   _dbBlock* getBlock() const;
+  _dbChip* getChip() const;
 
   void populatePTree(_dbMarkerCategory::PropertyTree& tree) const;
   void fromPTree(const _dbMarkerCategory::PropertyTree& tree);
diff --git a/src/odb/src/db/dbMarkerCategory.cpp b/src/odb/src/db/dbMarkerCategory.cpp
@@ -153,6 +153,14 @@ _dbBlock* _dbMarkerCategory::getBlock() const
   return (_dbBlock*) chip->getBlock();
 }
 
+_dbChip* _dbMarkerCategory::getChip() const
+{
+  dbMarkerCategory* category = (dbMarkerCategory*) this;
+  _dbMarkerCategory* top_category
+      = (_dbMarkerCategory*) category->getTopCategory();
+  return (_dbChip*) top_category->getOwner();
+}
+
 bool _dbMarkerCategory::hasMaxMarkerLimit() const
 {
   return max_markers_ > 0;
diff --git a/src/odb/src/db/dbMarkerCategory.h b/src/odb/src/db/dbMarkerCategory.h
@@ -25,6 +25,7 @@ class _dbMarker;
 class _dbMarkerCategory;
 // User Code Begin Classes
 class _dbBlock;
+class _dbChip;
 // User Code End Classes
 
 class _dbMarkerCategory : public _dbObject
@@ -48,6 +49,7 @@ class _dbMarkerCategory : public _dbObject
   bool hasMaxMarkerLimit() const;
 
   _dbBlock* getBlock() const;
+  _dbChip* getChip() const;
   void populatePTree(PropertyTree& tree) const;
   void fromPTree(const PropertyTree& tree);
   static void writeJSON(std::ofstream& report,
diff --git a/src/odb/test/cpp/BUILD b/src/odb/test/cpp/BUILD
@@ -231,5 +231,22 @@ cc_test(
         "@googletest//:gtest_main",
     ],
 )
+cc_test(
+    name = "Test3DBloxChecker",
+    srcs = [
+        "Test3DBloxChecker.cpp",
+    ],
+    data = [
+        "//src/odb/test:regression_resources",
+    ],
+    deps = [
+        "//src/odb",
+        "//src/tst",
+        "//src/tst:nangate45_fixture",
+        "//src/utl",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)
 
 # TODO: more to come.
diff --git a/src/odb/test/cpp/CMakeLists.txt b/src/odb/test/cpp/CMakeLists.txt
@@ -36,6 +36,7 @@ add_executable(TestMaster TestMaster.cpp)
 add_executable(TestGDSIn TestGDSIn.cpp)
 add_executable(TestChips TestChips.cpp)
 add_executable(Test3DBloxParser Test3DBloxParser.cpp)
+add_executable(Test3DBloxChecker Test3DBloxChecker.cpp)
 add_executable(TestSwapMaster TestSwapMaster.cpp)
 
 target_link_libraries(OdbGTests ${TEST_LIBS})
@@ -53,6 +54,7 @@ target_link_libraries(TestMaster ${TEST_LIBS})
 target_link_libraries(TestGDSIn ${TEST_LIBS})
 target_link_libraries(TestChips ${TEST_LIBS})
 target_link_libraries(Test3DBloxParser ${TEST_LIBS})
+target_link_libraries(Test3DBloxChecker ${TEST_LIBS})
 target_link_libraries(TestSwapMaster ${TEST_LIBS})
 
 # Skip the tests from being registered here, since they are called via
@@ -64,7 +66,7 @@ target_link_libraries(TestSwapMaster ${TEST_LIBS})
 # directory.
 gtest_discover_tests(OdbGTests
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/..
-    TEST_FILTER "-TestAccessPoint.*,-TestCallBacks.*,-TestGCellGrid.*,-TestGeom.*,-TestGroup.*,-TestGuide.*,-TestJournal.*-TestLef58Properties.*,-TestMaster.*,-TestModule.*,-TestNetTrack.*,-TestChips.*,-Test3DBloxParser.*"
+    TEST_FILTER "-TestAccessPoint.*,-TestCallBacks.*,-TestGCellGrid.*,-TestGeom.*,-TestGroup.*,-TestGuide.*,-TestJournal.*-TestLef58Properties.*,-TestMaster.*,-TestModule.*,-TestNetTrack.*,-TestChips.*,-Test3DBloxParser.*,-Test3DBloxChecker.*"
 )
 
 add_dependencies(build_and_test 
@@ -78,6 +80,7 @@ add_dependencies(build_and_test
         TestMaster
         TestChips
         Test3DBloxParser
+        Test3DBloxChecker
         TestSwapMaster
         OdbGTests
 )
diff --git a/src/odb/test/cpp/Test3DBloxChecker.cpp b/src/odb/test/cpp/Test3DBloxChecker.cpp
@@ -0,0 +1,221 @@
+#include <iostream>
+#include <string>
+
+#include "gtest/gtest.h"
+#include "odb/3dblox.h"
+#include "odb/db.h"
+#include "odb/geom.h"
+#include "tst/fixture.h"
+
+namespace odb {
+namespace {
+
+class CheckerFixture : public tst::Fixture
+{
+ protected:
+  CheckerFixture()
+  {
+    tech_ = dbTech::create(db_.get(), "tech");
+    // Create a top chip
+    top_chip_
+        = dbChip::create(db_.get(), nullptr, "TopChip", dbChip::ChipType::HIER);
+    top_chip_->setWidth(10000);
+    top_chip_->setHeight(10000);
+    top_chip_->setThickness(1000);
+    // Create master chips
+    chip1_ = dbChip::create(db_.get(), tech_, "Chip1", dbChip::ChipType::DIE);
+    chip1_->setWidth(2000);
+    chip1_->setHeight(2000);
+    chip1_->setThickness(500);
+
+    chip2_ = dbChip::create(db_.get(), tech_, "Chip2", dbChip::ChipType::DIE);
+    chip2_->setWidth(1500);
+    chip2_->setHeight(1500);
+    chip2_->setThickness(500);
+
+    chip3_ = dbChip::create(db_.get(), tech_, "Chip3", dbChip::ChipType::DIE);
+    chip3_->setWidth(1000);
+    chip3_->setHeight(1000);
+    chip3_->setThickness(500);
+  }
+
+  dbTech* tech_;
+  dbChip* top_chip_;
+  dbChip* chip1_;
+  dbChip* chip2_;
+  dbChip* chip3_;
+};
+
+TEST_F(CheckerFixture, test_overlapping_chips)
+{
+  // Create two overlapping chip instances
+  auto inst1 = dbChipInst::create(top_chip_, chip1_, "inst1");
+  inst1->setLoc(Point3D(0, 0, 0));
+  inst1->setOrient(dbOrientType3D(dbOrientType::R0, false));
+
+  auto inst2 = dbChipInst::create(top_chip_, chip2_, "inst2");
+  // Place inst2 overlapping with inst1
+  inst2->setLoc(Point3D(1000, 1000, 0));  // Overlaps with inst1
+  inst2->setOrient(dbOrientType3D(dbOrientType::R0, false));
+
+  // Run checker
+  ThreeDBlox three_dblox(&logger_, db_.get());
+  three_dblox.check();
+
+  // Verify markers were created
+  auto category = top_chip_->findMarkerCategory("3DBlox");
+  ASSERT_NE(category, nullptr);
+
+  auto overlapping_category = category->findMarkerCategory("Overlapping chips");
+  ASSERT_NE(overlapping_category, nullptr);
+
+  auto markers = overlapping_category->getMarkers();
+  EXPECT_EQ(markers.size(), 1);
+
+  if (markers.size() > 0) {
+    auto marker = *markers.begin();
+    auto sources = marker->getSources();
+    EXPECT_EQ(sources.size(), 2);
+    EXPECT_EQ(marker->getBBox(), odb::Rect(1000, 1000, 2000, 2000));
+    // Verify both chip instances are in the sources
+    bool found_inst1 = false;
+    bool found_inst2 = false;
+    for (auto src : sources) {
+      if (src->getObjectType() == dbObjectType::dbChipInstObj) {
+        auto chip_inst = static_cast<dbChipInst*>(src);
+        if (chip_inst->getName() == "inst1") {
+          found_inst1 = true;
+        }
+        if (chip_inst->getName() == "inst2") {
+          found_inst2 = true;
+        }
+      }
+    }
+    EXPECT_TRUE(found_inst1);
+    EXPECT_TRUE(found_inst2);
+  }
+}
+
+TEST_F(CheckerFixture, test_floating_chips)
+{
+  // Create three chip instances: two connected, one floating
+  auto inst1 = dbChipInst::create(top_chip_, chip1_, "inst1");
+  inst1->setLoc(Point3D(0, 0, 0));
+  inst1->setOrient(dbOrientType3D(dbOrientType::R0, false));
+
+  auto inst2 = dbChipInst::create(top_chip_, chip2_, "inst2");
+  // Place inst2 touching inst1 (connected)
+  inst2->setLoc(Point3D(0, 0, 500));  // Stacked on top of inst1
+  inst2->setOrient(dbOrientType3D(dbOrientType::R0, false));
+
+  auto inst3 = dbChipInst::create(top_chip_, chip3_, "inst3");
+  // Place inst3 far away (floating)
+  inst3->setLoc(Point3D(5000, 5000, 0));
+  inst3->setOrient(dbOrientType3D(dbOrientType::R0, false));
+
+  // Run checker
+  ThreeDBlox three_dblox(&logger_, db_.get());
+  three_dblox.check();
+
+  // Verify markers were created
+  auto category = top_chip_->findMarkerCategory("3DBlox");
+  ASSERT_NE(category, nullptr);
+
+  auto floating_category = category->findMarkerCategory("Floating chips");
+  ASSERT_NE(floating_category, nullptr);
+
+  auto markers = floating_category->getMarkers();
+  EXPECT_EQ(markers.size(), 1);
+
+  if (markers.size() > 0) {
+    auto marker = *markers.begin();
+    auto sources = marker->getSources();
+    EXPECT_EQ(sources.size(), 1);
+    // Verify the floating chip is inst3
+    if (sources.size() > 0) {
+      auto src = *sources.begin();
+      EXPECT_EQ(src->getObjectType(), dbObjectType::dbChipInstObj);
+      auto chip_inst = static_cast<dbChipInst*>(src);
+      EXPECT_EQ(chip_inst->getName(), "inst3");
+    }
+  }
+}
+
+TEST_F(CheckerFixture, test_no_violations)
+{
+  // Create two non-overlapping, connected chip instances
+  auto inst1 = dbChipInst::create(top_chip_, chip1_, "inst1");
+  inst1->setLoc(Point3D(0, 0, 0));
+  inst1->setOrient(dbOrientType3D(dbOrientType::R0, false));
+
+  auto inst2 = dbChipInst::create(top_chip_, chip2_, "inst2");
+  // Place inst2 touching but not overlapping inst1
+  inst2->setLoc(Point3D(0, 0, 500));  // Stacked on top
+  inst2->setOrient(dbOrientType3D(dbOrientType::R0, false));
+
+  // Run checker
+  ThreeDBlox three_dblox(&logger_, db_.get());
+  three_dblox.check();
+
+  // Verify no violation markers were created
+  auto category = top_chip_->findMarkerCategory("3DBlox");
+  ASSERT_NE(category, nullptr);
+
+  auto overlapping_category = category->findMarkerCategory("Overlapping chips");
+  if (overlapping_category != nullptr) {
+    auto markers = overlapping_category->getMarkers();
+    EXPECT_EQ(markers.size(), 0);
+  }
+
+  auto floating_category = category->findMarkerCategory("Floating chips");
+  if (floating_category != nullptr) {
+    auto markers = floating_category->getMarkers();
+    EXPECT_EQ(markers.size(), 0);
+  }
+}
+
+TEST_F(CheckerFixture, test_multiple_violations)
+{
+  // Create a complex scenario with both overlapping and floating chips
+  auto inst1 = dbChipInst::create(top_chip_, chip1_, "inst1");
+  inst1->setLoc(Point3D(0, 0, 0));
+  inst1->setOrient(dbOrientType3D(dbOrientType::R0, false));
+
+  auto inst2 = dbChipInst::create(top_chip_, chip2_, "inst2");
+  // Overlapping with inst1
+  inst2->setLoc(Point3D(500, 500, 0));
+  inst2->setOrient(dbOrientType3D(dbOrientType::R0, false));
+
+  auto inst3 = dbChipInst::create(top_chip_, chip3_, "inst3");
+  // Also overlapping with inst1
+  inst3->setLoc(Point3D(1000, 1000, 0));
+  inst3->setOrient(dbOrientType3D(dbOrientType::R0, false));
+
+  auto inst4 = dbChipInst::create(top_chip_, chip3_, "inst4");
+  // Floating chip
+  inst4->setLoc(Point3D(7000, 7000, 0));
+  inst4->setOrient(dbOrientType3D(dbOrientType::R0, false));
+
+  // Run checker
+  ThreeDBlox three_dblox(&logger_, db_.get());
+  three_dblox.check();
+
+  // Verify markers were created
+  auto category = top_chip_->findMarkerCategory("3DBlox");
+  ASSERT_NE(category, nullptr);
+
+  // Check overlapping chips
+  auto overlapping_category = category->findMarkerCategory("Overlapping chips");
+  ASSERT_NE(overlapping_category, nullptr);
+  auto overlapping_markers = overlapping_category->getMarkers();
+  EXPECT_GT(overlapping_markers.size(), 0);
+
+  // Check floating chips
+  auto floating_category = category->findMarkerCategory("Floating chips");
+  ASSERT_NE(floating_category, nullptr);
+  auto floating_markers = floating_category->getMarkers();
+  EXPECT_EQ(floating_markers.size(), 1);
+}
+
+}  // namespace
+}  // namespace odb

Original file line number	Diff line number	Diff line change
`@@ -153,6 +153,14 @@ _dbBlock* _dbMarkerCategory::getBlock() const`
`153`	`153`	`return (_dbBlock*) chip->getBlock();`
`154`	`154`	`}`
`155`	`155`
	`156`	`+_dbChip* _dbMarkerCategory::getChip() const`
	`157`	`+{`
	`158`	`+ dbMarkerCategory* category = (dbMarkerCategory*) this;`
	`159`	`+ _dbMarkerCategory* top_category`
	`160`	`+ = (_dbMarkerCategory*) category->getTopCategory();`
	`161`	`+ return (_dbChip*) top_category->getOwner();`
	`162`	`+}`
	`163`	`+`
`156`	`164`	`bool _dbMarkerCategory::hasMaxMarkerLimit() const`
`157`	`165`	`{`
`158`	`166`	`return max_markers_ > 0;`