Merge pull request #775 from os-fpga/checker_developing_clock_data

checker: developing clock-data

Author: serge-dsa

planning/src/RS/rsCheck.cpp

@@ -87,7 +87,7 @@ static bool do_check_blif(CStr cfn) {
   ls << "[Error] !!! " << bfile.err_msg_ << endl;
 
   flush_out(true);
-  lprintf2("ERROR: BLIF verification failed at %s:%zu\n",
+  lprintf2("ERROR: BLIF verification failed at %s:%u\n",
             bfile.fnm_.c_str(), bfile.err_lnum_);
 
   return false;

planning/src/file_readers/pln_blif_file.cpp

@@ -378,7 +378,7 @@ bool BLIF_file::checkBlif() noexcept {
   }
 
   bool link_ok = linkNodes();
-  if (!link_ok) {
+  if (not link_ok) {
     string tmp = err_msg_;
     err_msg_ = "link failed at line ";
     err_msg_ += std::to_string(err_lnum_);
@@ -420,17 +420,28 @@ bool BLIF_file::checkBlif() noexcept {
 
   // 6. clock-data separation
   if (!topInputs_.empty() and !topOutputs_.empty()) {
-    NW pinG;
-    pinG.trace_ = trace_;
-    for (const Node* port : topOutputs_) {
-      assert(port->isRoot());
-      assert(port->inDeg() == 0);
-      pinG.insK(port->hashCode());
+    vector<const Node*> clocked;
+    collectClockedNodes(clocked);
+    uint clocked_sz = clocked.size();
+    if (trace_ >= 3) {
+      lprintf("(clock-data separation)  num_nodes= %u  num_clocked= %u\n",
+              numNodes(), clocked_sz);
     }
-    if (trace_ >= 14) {
-      flush_out(true);
-      pinG.printSum(ls, 0);
+    if (clocked_sz) {
+      bool separ_ok = checkClockSepar(clocked);
+      if (not separ_ok) {
+        string tmp = err_msg_;
+        err_msg_ = "clock-data separation issue at line ";
+        err_msg_ += std::to_string(err_lnum_);
+        err_msg_ += "  ";
+        err_msg_ += tmp;
+        flush_out(true);
+        return false;
+      }
+      if (trace_ >= 4)
+        lputs("(clock-data separation)  checked OK.");
     }
+    flush_out(true);
   }
 
   chk_ok_ = true;
@@ -531,7 +542,7 @@ uint BLIF_file::printPrimitives(std::ostream& os, bool instCounts) const noexcep
       }
       if (n_clocks and IC[t]) {
         ::sprintf(ncs_buf, "   #clock_pins= %u", n_clocks);
-        n_clock_inst++;
+        n_clock_inst += IC[t];
       }
       os_printf(os, "    [%u]  %s   %s%s\n",
                 t, pn, ic_buf, ncs_buf);
@@ -560,6 +571,24 @@ uint BLIF_file::printPrimitives(std::ostream& os, bool instCounts) const noexcep
   return Prim_MAX_ID;
 }
 
+void BLIF_file::collectClockedNodes(vector<const Node*>& V) noexcept {
+  V.clear();
+  uint nn = numNodes();
+  if (nn == 0)
+    return;
+
+  V.reserve(20);
+  for (uint i = 1; i <= nn; i++) {
+    const Node& nd = nodePool_[i];
+    uint t = nd.ptype_;
+    if (!t or t >= Prim_MAX_ID)
+      continue;
+    uint n_clocks = pr_num_clocks(nd.ptype_);
+    if (n_clocks)
+      V.push_back(&nd);
+  }
+}
+
 std::array<uint, Prim_MAX_ID> BLIF_file::countTypes() const noexcept {
   std::array<uint, Prim_MAX_ID> A;
   for (uint t = 0; t < Prim_MAX_ID; t++)
@@ -1258,7 +1287,6 @@ bool BLIF_file::linkNodes() noexcept {
       continue;
     Node* drv_cell = findFabricDriver(nd.id_, inp1);
     if (!drv_cell) {
-      // lputs9();
       err_msg_ = "undriven cell input: ";
       err_msg_ += inp1;
       if (trace_ >= 2) {
@@ -1273,4 +1301,63 @@ bool BLIF_file::linkNodes() noexcept {
   return true;
 }
 
+bool BLIF_file::checkClockSepar(vector<const Node*>& clocked) const noexcept {
+  if (1|| clocked.empty())
+    return true;
+
+  NW g;
+  auto& ls = lout();
+  char nm_buf[512] = {};
+
+  for (const Node* np : clocked) {
+    const Node& nd = *np;
+    if (not pr_num_clocks(nd.ptype_))
+      continue;
+    if (nd.ptype_ == CLK_BUF)
+      continue;
+    if (nd.parent_ == 0)
+      continue;
+    lprintf("...... checking clock-separ for node #%u of type %s\n",
+             nd.id_, nd.cPrimType());
+    lprintf("\t\t  parent= %u\n", nd.parent_);
+
+    g.clear();
+
+    uint64_t rhash = nd.hashCode();
+    uint g_rid = g.addNode(rhash);
+    g.addRoot(g_rid);
+
+    const Node& par = nodeRef(nd.parent_);
+
+    uint g_pid = g.insK(par.hashCode());
+    g.markSink(g_pid, true);
+
+    g.linkNodes(g_rid, g_pid, false);
+
+    ::snprintf(nm_buf, 510, "%s_%uL", nd.cPrimType(), nd.lnum_);
+    g.setNodeName(g_rid, nm_buf);
+
+    ::snprintf(nm_buf, 510, "%s_%uL", par.cPrimType(), par.lnum_);
+    g.setNodeName(g_pid, nm_buf);
+
+    uint bh_id = g.insK(111);
+    g.markSink(bh_id, true);
+    g.setNodeName(bh_id, "BH1");
+
+    g.linkNodes(g_pid, bh_id, false);
+
+    g.labelDepth();
+
+    g.dump("\t *** g separ ***");
+    lprintf("\t  g. numN()= %u   numE()= %u\n", g.numN(), g.numE());
+    g.printSum(ls, 0);
+
+    lputs("\n\t***** break; // TMP");
+    break; // TMP
+  }
+
+  return true;
 }
+
+}
+

planning/src/file_readers/pln_blif_file.h

@@ -148,12 +148,22 @@ struct BLIF_file : public fio::MMapReader
 
   }; // Node
 
+  Node& nodeRef(uint id) noexcept {
+    assert(id > 0 and id < nodePool_.size());
+    return nodePool_[id];
+  }
+  const Node& nodeRef(uint id) const noexcept {
+    assert(id > 0 and id < nodePool_.size());
+    return nodePool_[id];
+  }
+
   string topModel_;
 
   vector<string> inputs_;
   vector<string> outputs_;
 
-  size_t inputs_lnum_ = 0, outputs_lnum_ = 0, err_lnum_ = 0;
+  size_t inputs_lnum_ = 0, outputs_lnum_ = 0;
+  mutable uint err_lnum_ = 0;
 
   string err_msg_;
   uint16_t trace_ = 0;
@@ -178,6 +188,7 @@ struct BLIF_file : public fio::MMapReader
   uint numOutputs() const noexcept { return outputs_.size(); }
   uint numNodes() const noexcept { return nodePool_.empty() ? 0 : nodePool_.size() - 1; }
 
+  void collectClockedNodes(vector<const Node*>& V) noexcept;
   std::array<uint, prim::Prim_MAX_ID> countTypes() const noexcept;
 
   uint printInputs(std::ostream& os, CStr spacer = nullptr) const noexcept;
@@ -193,6 +204,8 @@ struct BLIF_file : public fio::MMapReader
   bool linkNodes() noexcept;
   void link(Node& from, Node& to) noexcept;
 
+  bool checkClockSepar(vector<const Node*>& clocked) const noexcept;
+
   Node* findOutputPort(const string& contact) noexcept;
   Node* findInputPort(const string& contact) noexcept;
 

planning/src/main.cpp

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

planning/src/util/nw/Nw.cpp

@@ -158,8 +158,98 @@ uint NW::getRadius() noexcept {
   return ml >= 0 ? ml : 0;
 }
 
+using Nd = NW::Node;
+
+static void dfs_setD(NW& g, const Nd& fr, Nd& to) noexcept {
+  assert(to.lbl_ == UINT_MAX);
+  assert(fr.lbl_ != UINT_MAX);
+  assert(to.par_ > 0 and to.par_ == fr.id_);
+
+  to.lbl_ = fr.lbl_ + 1;
+
+  for (int i = to.degree() - 1; i >= 0; i--) {
+    uint ei = to.edges_[i];
+    NW::Edge& e = g.edgeRef(ei);
+    Nd& other = g.nodeRef(to.otherSide(e));
+    if (other.id_ == fr.id_) continue;
+    dfs_setD(g, to, other);
+  }
+}
+
+void NW::labelDepth() noexcept {
+  assert(not empty());
+  uint rootId = first_rid();
+  assert(rootId);
+  assert(verifyOneRoot());
+
+  Node& root = nodeRefCk(rootId);
+
+  for (NI I(*this); I.valid(); ++I) I->lbl_ = UINT_MAX;
+  root.lbl_ = 0;
+  if (size() == 1) {
+    return;
+  }
+  if (size() == 2) {
+    for (NI I(*this); I.valid(); ++I) {
+      Node& nd = *I;
+      if (nd.id_ != rootId)
+        nd.lbl_ = 1;
+    }
+    return;
+  }
+
+  for (int i = root.degree() - 1; i >= 0; i--) {
+    Edge& e = edStor_[root.edges_[i]];
+    Node& to = ndStor_[root.otherSide(e)];
+    dfs_setD(*this, root, to);
+  }
+}
+
+upair NW::getMinMaxDeg() const noexcept {
+  upair dg{0, 0};
+  if (empty()) return dg;
+
+  const Node& n0 = nodeRefCk(nids_[0]);
+  dg.first = n0.degree();
+  dg.second = dg.first;
+  for (cNI I(*this); I.valid(); ++I) {
+    const Node& nd = *I;
+    uint d = nd.degree();
+    if (d < dg.first) dg.first = d;
+    if (d > dg.second) dg.second = d;
+  }
+  return dg;
+}
+
+upair NW::getMinMaxLbl() const noexcept {
+  upair L{0, 0};
+  if (empty()) return L;
+
+  const Node& n0 = nodeRefCk(nids_[0]);
+  L.first = n0.lbl_;
+  L.second = n0.lbl_;
+  for (cNI I(*this); I.valid(); ++I) {
+    const Node& nd = *I;
+    uint x = nd.lbl_;
+    if (x < L.first) L.first = x;
+    if (x > L.second) L.second = x;
+  }
+  return L;
+}
+
 // ==== DEBUG
 
+void NW::dot_comment(ostream& os, uint16_t dotMode, CStr msg) noexcept {
+  if (!dotMode) return;
+  if (dotMode == 1) {
+    os << s_dotComment;
+  } else {
+    assert(dotMode == 2);
+    os << s_metisComment;
+  }
+  if (msg) os << msg;
+}
+
 bool NW::verifyOneRoot() const noexcept {
   if (empty()) return true;
   assert(!rids_.empty());
@@ -194,21 +284,15 @@ void NW::Node::print(ostream& os) const noexcept {
     os << " r-";
   }
   if (sink_flag_) os << " S";
-  os << " par=" << par_;
-  os << " lbl=" << lbl_;
+  os_printf(os, " par=%u lbl=%u", par_, lbl_);
+  if (not name_.empty())
+    os << " nm= " << name_;
   os << endl;
 }
 
 void NW::Node::nprint_dot(ostream& os) const noexcept {
   os << "  " << getName();
-  if (isCell()) {
-    if (0) {
-    } else {
-      os << " [ shape=box";
-    }
-    os << " ] ";
-  } else if (0) {
-  }
+
   os_printf(os, "  // deg= %u;\n", degree());
 }
 
@@ -276,19 +360,21 @@ uint NW::printNodes(ostream& os, CStr msg, uint16_t forDot) const noexcept {
 uint NW::dumpNodes(CStr msg) const noexcept { return printNodes(lout(), msg, 0); }
 
 uint NW::printSum(ostream& os, uint16_t forDot) const noexcept {
-  using std::endl;
   dot_comment(os, forDot);
   if (empty()) {
-    os << "(empty NW)" << endl;
+    os_printf(os, "(empty NW)\n)");
     return 0;
   }
 
-  ipair mmD = getMinMaxDeg();
-  ipair mmL = getMinMaxLbl();
+  upair mmD = getMinMaxDeg();
+  upair mmL = getMinMaxLbl();
   upair rcnt = countRoots();
 
-  os_printf(os, "nn= %u  ne= %u  nr= %zu  r0= %u", numN(), numE(), rids_.size(), first_rid());
-  os << "  mm-deg: " << mmD << "  mm-lbl: " << mmL << endl;
+  os_printf(os, "nn= %u  ne= %u  nr= %zu  r0= %u",
+            numN(), numE(), rids_.size(), first_rid());
+
+  os_printf(os, "  mm-deg: (%u,%u)", mmD.first, mmD.second);
+  os_printf(os, "  mm-lbl: (%u,%u)\n", mmL.first, mmL.second);
 
   dot_comment(os, forDot);
   os_printf(os, "nr=(%u,%u)\n", rcnt.first, rcnt.second);