checker: identify clock pins in graph

Author: serge-rs

planning/src/file_readers/pln_blif_file.cpp

@@ -1429,11 +1429,48 @@ bool BLIF_file::checkClockSepar(vector<const Node*>& clocked) noexcept {
     flush_out(true); err_puts();
     lprintf2("[Error] NOT createPinGraph()\n");
     err_puts(); flush_out(true);
+    return true;
+  }
+  if (pg_.size() < 3)
+    return true;
+
+  if (not pg_.hasClockNodes())
+    return true;
+
+  // -- paint clock nodes and their incoming edges Red
+  for (NW::NI I(pg_); I.valid(); ++I) {
+    NW::Node& nd = *I;
+    if (nd.isClk()) {
+      nd.paintRed();
+      for (NW::IncoEI J(pg_, nd); J.valid(); ++J) {
+        uint eid = J->id_;
+        pg_.edgeRef(eid).paintRed();
+      }
+    }
   }
 
   return true;
 }
 
+struct qTup {
+  uint inpNid_ = 0;
+  uint cellId_ = 0;
+  uint inputPin_ = 0;
+  CStr outNet_ = nullptr;
+
+  qTup() noexcept = default;
+
+  qTup(uint inid, uint cid, uint ip, CStr z) noexcept
+    : inpNid_(inid),
+      cellId_(cid),
+      inputPin_(ip),
+      outNet_(z) {
+    assert(inid);
+    assert(cid);
+    assert(z and z[0]);
+  }
+};
+
 bool BLIF_file::createPinGraph() noexcept {
   auto& ls = lout();
   pg_.clear();
@@ -1468,8 +1505,10 @@ bool BLIF_file::createPinGraph() noexcept {
     pg_.nodeRef(nid).markOut(true);
   }
 
+  vector<qTup> Q;
+  Q.reserve(topInputs_.size());
+
   // -- link from input ports to fabric
-  // lputs9();
   for (Node* p : topInputs_) {
     INP.clear();
     Node& port = *p;
@@ -1493,11 +1532,17 @@ bool BLIF_file::createPinGraph() noexcept {
       INP.clear();
       pr_get_inputs(par.ptype_, INP);
 
+      const string& pinName = par.getInPin(pinIndex);
+      bool is_clock = pr_pin_is_clock(par.ptype_, pinName);
+
       if (trace_ >= 5) {
-        lprintf("        FabricParent par:  lnum_= %u  kw_= %s  ptype_= %s  #inputs= %u\n",
+        lprintf("      FabricParent par:  lnum_= %u  kw_= %s  ptype_= %s  pin[%u nm= %s%s]\n",
                 par.lnum_, par.kw_.c_str(), par.cPrimType(),
-                pr_num_inputs(par.ptype_));
-        logVec(INP, "        [par_inputs] ");
+                pinIndex, pinName.c_str(), is_clock ? " <C>" : "");
+        logVec(INP, "      [par_inputs] ");
+        logVec(par.inPins_, "         [inPins_] ");
+        if (trace_ >= 7)
+          logVec(par.inSigs_, "        [inSigs_] ");
         lputs();
       }
 
@@ -1511,19 +1556,47 @@ bool BLIF_file::createPinGraph() noexcept {
       assert(pg_.hasKey(port.id_)); //
 
       pg_.nodeRef(kid).setCid(par.id_);
-      ::snprintf(nm_buf, 510, "%s_%uL",
-                 par.hasPrimType() ? par.cPrimType() : "NP", par.lnum_);
+      ::snprintf(nm_buf, 510, "%s_%uL_%up%u",
+                 par.hasPrimType() ? par.cPrimType() : "NP",
+                 par.lnum_, par.id_, pinIndex);
       pg_.setNodeName(kid, nm_buf);
+      pg_.nodeRef(kid).markClk(is_clock);
 
       eid = pg_.linK(port.id_, key);
       assert(eid);
+
+      Q.emplace_back(kid, par.id_, pinIndex, par.out_.c_str());
+    }
+  }
+
+  // -- link cell-edges and next level
+  if (trace_ >= 5) {
+    lprintf("|Q| .sz= %zu\n", Q.size());
+    for (uint i = 0; i < Q.size(); i++) {
+      const qTup& q = Q[i];
+      lprintf("   |%u|  ( nid:%u  %u.%u  %s )\n",
+              i, q.inpNid_, q.cellId_, q.inputPin_, q.outNet_);
+    }
+  }
+  if (not Q.empty()) {
+    for (uint i = 0; i < Q.size(); i++) {
+      const qTup& q = Q[i];
+      uint64_t qk = hashComb(q.cellId_, q.outNet_);
+      assert(qk);
+      kid = pg_.insK(qk);
+      eid = pg_.linkNodes(q.inpNid_, kid, true);
+
+      ::snprintf(nm_buf, 510, "nd%u_L%u_Q%u",
+                kid, nodeRef(q.cellId_).lnum_, q.cellId_);
+      pg_.setNodeName(kid, nm_buf);
     }
   }
 
   if (1) {
 
+    flush_out(true);
     pg_.setNwName("pin_graph");
-    pg_.dump("\t *** pg_ separ ***");
+    pg_.dump("\t *** pin_graph for clock-data separation ***");
     lprintf("\t  pg_. numN()= %u   numE()= %u\n", pg_.numN(), pg_.numE());
     lputs();
     pg_.printSum(ls, 0);
@@ -1536,7 +1609,7 @@ bool BLIF_file::createPinGraph() noexcept {
 
   }
 
-  return false;
+  return true;
 }
 
 }

planning/src/file_readers/pln_blif_file.h

@@ -47,6 +47,17 @@ struct BLIF_file : public fio::MMapReader
       if (keyword) kw_ = keyword;
     }
 
+    const string& getInPin(uint pinIndex) const noexcept {
+      assert(inPins_.size() == inSigs_.size());
+      assert(pinIndex < inPins_.size());
+      return inPins_[pinIndex];
+    }
+    const string& getInSig(uint pinIndex) const noexcept {
+      assert(inPins_.size() == inSigs_.size());
+      assert(pinIndex < inSigs_.size());
+      return inSigs_[pinIndex];
+    }
+
     void setOutHash() noexcept {
       out_hc_ = str::hashf(out_.c_str());
     }

planning/src/main.cpp

@@ -1,4 +1,4 @@
-static const char* _pln_VERSION_STR = "pln0299";
+static const char* _pln_VERSION_STR = "pln0304";
 
 #include "RS/rsEnv.h"
 #include "util/pln_log.h"

planning/src/util/geo/iv.h

@@ -24,6 +24,8 @@
 #include <utility>
 #include <vector>
 
+#include "util/pln_log.h"
+
 namespace pln {
 
 inline constexpr uint64_t hashComb(uint64_t a, uint64_t b) noexcept {
@@ -35,6 +37,13 @@ inline constexpr uint64_t hashComb(uint64_t a, uint64_t b, uint64_t c) noexcept
   return hashComb(a, hashComb(b, c));
 }
 
+inline uint64_t hashComb(uint64_t a, CStr s) noexcept {
+  return hashComb(a, str::hashf(s));
+}
+inline uint64_t hashComb(uint64_t a, const std::string& s) noexcept {
+  return hashComb(a, str::hashf(s));
+}
+
 inline constexpr int protectedAdd(int a, int b) noexcept {
   int64_t c = int64_t(a) + int64_t(b);
   if (c > INT_MAX) return INT_MAX;

planning/src/util/nw/Nw.cpp

@@ -251,6 +251,25 @@ uint NW::findNode(uint64_t k) const noexcept {
   return 0;
 }
 
+uint NW::countClockNodes() const noexcept {
+  uint cnt = 0;
+  if (empty()) return 0;
+  for (cNI I(*this); I.valid(); ++I) {
+    if (I->isClk())
+      cnt++;
+  }
+  return cnt;
+}
+
+bool NW::hasClockNodes() const noexcept {
+  if (empty()) return false;
+  for (cNI I(*this); I.valid(); ++I) {
+    if (I->isClk())
+      return true;
+  }
+  return false;
+}
+
 // ==== DEBUG
 
 void NW::dot_comment(ostream& os, uint16_t dotMode, CStr msg) noexcept {
@@ -314,16 +333,31 @@ static void replace_bus_for_dot(char* buf) noexcept {
 }
 
 void NW::Node::nprint_dot(ostream& os) const noexcept {
-  char buf[2048] = {};
-  getName(buf);
-  replace_bus_for_dot(buf);
+  char name_buf[2048] = {};
+  getName(name_buf);
+  replace_bus_for_dot(name_buf);
 
-  CStr attrib = "[ shape=record, style=rounded ];";
-  if (inp_flag_)
-    attrib = "[ shape=box, color=gray, style=filled ];";
+  char attrib[512] = {};
+
+  if (!inp_flag_ and !clk_flag_) {
+    if (isRed())
+      ::strcpy(attrib, "[ shape=record, color=red, style=rounded ];");
+    else
+      ::strcpy(attrib, "[ shape=record, style=rounded ];");
+  }
+  else {
+    if (inp_flag_) {
+      CStr cs = isRed() ? "red" : "gray";
+      ::sprintf(attrib, "[ shape=box, color=%s, style=filled ];", cs);
+    }
+    else if (clk_flag_) {
+      CStr cs = isRed() ? "red" : "orange";
+      ::sprintf(attrib, "[ shape=record, color=%s, style=filled ];", cs);
+    }
+  }
 
   os_printf(os, "%s  %s  // deg= %u;\n",
-            buf, attrib, degree());
+            name_buf, attrib, degree());
 }
 
 void NW::Edge::eprint_dot(ostream& os, char arrow, const NW& g) const noexcept {
@@ -417,10 +451,11 @@ uint NW::printSum(ostream& os, uint16_t forDot) const noexcept {
   upair mmD = getMinMaxDeg();
   upair mmL = getMinMaxLbl();
   upair rcnt = countRoots();
+  uint numClkNodes = countClockNodes();
 
   dot_comment(os, forDot);
-  os_printf(os, "nn= %u  ne= %u  nr= %zu  r0= %u",
-            numN(), numE(), rids_.size(), first_rid());
+  os_printf(os, "nn= %u  ne= %u  nr= %zu  r0= %u  #clkn= %u",
+            numN(), numE(), rids_.size(), first_rid(), numClkNodes);
 
   os_printf(os, "  mm-deg: (%u,%u)", mmD.first, mmD.second);
   os_printf(os, "  mm-lbl: (%u,%u)\n", mmL.first, mmL.second);

planning/src/util/nw/Nw.h

@@ -20,17 +20,24 @@
 
 namespace pln {
 
+using std::string;
+using std::ostream;
 using veci = std::vector<int>;
 using vecu = std::vector<uint>;
 using ipair = std::pair<int, int>;
 using upair = std::pair<uint, uint>;
-using std::ostream;
-using std::string;
+using uspair = std::pair<uint, string>;
 
 struct NW {
   struct Node;
   using NodeStor = std::deque<Node>;
 
+  static constexpr uint c_Red = 1;
+  static constexpr uint c_Orange = 2;
+  static constexpr uint c_Yellow = 3;
+  static constexpr uint c_Green = 4;
+  static constexpr uint c_Blue = 5;
+
   struct Edge {
     uint id_ = 0;
     uint n1_ = 0, n2_ = 0;
@@ -46,6 +53,10 @@ struct NW {
       assert(n1 != n2);
     }
 
+    void paint(uint col) noexcept { color_ = col; }
+    void paintRed() noexcept { color_ = c_Red; }
+    bool isRed() const noexcept { return color_ == c_Red; }
+
     bool valid() const noexcept { return n1_; }
     void inval() noexcept { ::memset(this, 0, sizeof(*this)); }
 
@@ -131,6 +142,8 @@ struct NW {
     void markSink(bool val) noexcept { sink_flag_ = val; }
     void markInp(bool val) noexcept { inp_flag_ = val; }
     void markOut(bool val) noexcept { out_flag_ = val; }
+    void markClk(bool val) noexcept { clk_flag_ = val; }
+    bool isClk() const noexcept { return clk_flag_; }
     bool terminal() const noexcept { return sink_flag_ or root_flag_; }
 
     void print(ostream& os) const noexcept;
@@ -139,6 +152,10 @@ struct NW {
     bool isCell() const noexcept { return cid_; }
     void setCid(uint ci) noexcept { cid_ = ci; }
 
+    void paint(uint col) noexcept { color_ = col; }
+    void paintRed() noexcept { color_ = c_Red; }
+    bool isRed() const noexcept { return color_ == c_Red; }
+
     // DATA:
     vecu edges_;
 
@@ -147,6 +164,7 @@ struct NW {
     uint id_ = 0;
     uint par_ = 0;
     uint cid_ = 0;
+    uint color_ = 0;
 
     uint lbl_ = 0;
     int rad_ = 0;
@@ -156,6 +174,7 @@ struct NW {
     bool sink_flag_ = false;
     bool inp_flag_ = false;
     bool out_flag_ = false;
+    bool clk_flag_ = false;
     string name_;
   };
 
@@ -236,6 +255,8 @@ struct NW {
   inline uint numE() const noexcept;
 
   inline upair countRoots() const noexcept;
+  bool hasClockNodes() const noexcept;
+  uint countClockNodes() const noexcept;
 
   void getNodes(vecu& V) const noexcept { V = nids_; }
 

planning/src/util/pln_log.h

@@ -255,6 +255,11 @@ inline size_t hashf(CStr z) noexcept {
   std::hash<std::string_view> h;
   return h(std::string_view{z});
 }
+inline size_t hashf(const std::string& s) noexcept {
+  if (s.empty()) return 1;
+  std::hash<std::string> h;
+  return h(s);
+}
 
 }  // NS str