Skip to content

Commit c1e4420

Browse files
serge-rsserge-rs
committed
checker: fixes for SERDES
1 parent 4139a36 commit c1e4420

File tree

6 files changed

+115
-57
lines changed

6 files changed

+115
-57
lines changed

‎planning/src/file_io/pln_blif_file.cpp

Lines changed: 61 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -435,7 +435,7 @@ bool BLIF_file::checkBlif() noexcept {
435435
if (!topInputs_.empty() and !topOutputs_.empty()) {
436436
if (trace_ >= 5)
437437
pg_.setTrace(trace_);
438-
vector<const BNode*> clocked;
438+
vector<BNode*> clocked;
439439
collectClockedNodes(clocked);
440440
uint clocked_sz = clocked.size();
441441
if (trace_ >= 3) {
@@ -636,15 +636,15 @@ uint BLIF_file::printPrimitives(std::ostream& os, bool instCounts) const noexcep
636636
return Prim_MAX_ID;
637637
}
638638

639-
void BLIF_file::collectClockedNodes(vector<const BNode*>& V) noexcept {
639+
void BLIF_file::collectClockedNodes(vector<BNode*>& V) noexcept {
640640
V.clear();
641641
uint nn = numNodes();
642642
if (nn == 0)
643643
return;
644644

645645
V.reserve(20);
646646
for (uint i = 1; i <= nn; i++) {
647-
const BNode& nd = nodePool_[i];
647+
BNode& nd = nodePool_[i];
648648
uint t = nd.ptype_;
649649
if (!t or t >= Prim_MAX_ID)
650650
continue;
@@ -1555,7 +1555,7 @@ bool BLIF_file::linkNodes() noexcept {
15551555
return true;
15561556
}
15571557

1558-
bool BLIF_file::checkClockSepar(vector<const BNode*>& clocked) noexcept {
1558+
bool BLIF_file::checkClockSepar(vector<BNode*>& clocked) noexcept {
15591559
auto& ls = lout();
15601560
if (::getenv("pln_dont_check_clock_separation"))
15611561
return true;
@@ -1727,6 +1727,8 @@ struct qTup {
17271727
}
17281728
};
17291729

1730+
static CStr s_possible_cdrivers = "{iport, CLK_BUF, I_SERDES}";
1731+
17301732
bool BLIF_file::createPinGraph() noexcept {
17311733
pg_.clear();
17321734
pg2blif_.clear();
@@ -1822,32 +1824,40 @@ bool BLIF_file::createPinGraph() noexcept {
18221824
lputs();
18231825
}
18241826

1825-
assert(par.cell_hc_);
1826-
key = hashCantor(par.id_, pinIndex+1) + max_key1;
1827+
uint par_realId = par.realId(*this);
1828+
key = hashCantor(par_realId, pinIndex+1) + max_key1;
18271829
assert(key);
1828-
assert(not pg_.hasKey(key));
1830+
kid = pg_.findNode(key);
1831+
if (kid) {
1832+
// virtual MOG effect
1833+
if (trace_ >= 7) {
1834+
lprintf(" (virtual MOG effect) node exists: key=%zu nid=%u\n",
1835+
key, kid);
1836+
}
1837+
continue;
1838+
}
18291839
kid = pg_.insK(key);
18301840
assert(kid);
18311841
assert(key != port.id_); // bc port.id_ is a key for port
18321842
assert(pg_.hasKey(port.id_)); //
1833-
pg2blif_.emplace(kid, par.id_);
1843+
pg2blif_.emplace(kid, par_realId);
18341844

1835-
pg_.nodeRef(kid).setCid(par.id_);
1845+
pg_.nodeRef(kid).setCid(par_realId);
18361846
::snprintf(nm_buf, 510, "%s_%uL_%up%u",
18371847
par.hasPrimType() ? par.cPrimType() : "NP",
1838-
par.lnum_, par.id_, pinIndex);
1848+
par.lnum_, par_realId, pinIndex);
18391849

18401850
assert(not pg_.nodeRef(kid).inp_flag_);
1841-
pg_.setNodeName4(kid, par.id_, par.lnum_, pinIndex+1, par.cPrimType());
1851+
pg_.setNodeName4(kid, par_realId, par.lnum_, pinIndex+1, par.cPrimType());
18421852
pg_.nodeRef(kid).markClk(is_clock);
18431853

1844-
if (trace_ >= 6)
1854+
if (trace_ >= 7)
18451855
lprintf(" ALT nodeName %s --> %s\n", pg_.cnodeName(kid), nm_buf);
18461856

18471857
eid = pg_.linK(port.id_, key);
18481858
assert(eid);
18491859

1850-
Q.emplace_back(kid, par.id_, pinIndex, par.out_.c_str());
1860+
Q.emplace_back(kid, par_realId, pinIndex, par.out_.c_str());
18511861
}
18521862
}
18531863

@@ -1885,27 +1895,27 @@ bool BLIF_file::createPinGraph() noexcept {
18851895
}
18861896

18871897
// -- create pg-nodes for sequential input pins
1888-
vector<const BNode*> clocked;
1898+
vector<BNode*> clocked;
18891899
collectClockedNodes(clocked);
18901900
if (trace_ >= 4)
18911901
lprintf(" createPinGraph: clocked.size()= %zu\n", clocked.size());
18921902
if (not clocked.empty()) {
18931903
string inp1;
1894-
for (const BNode* cnp : clocked) {
1895-
const BNode& cn = *cnp;
1904+
for (BNode* cnp : clocked) {
1905+
BNode& cn = *cnp;
18961906
assert(cn.hasPrimType());
18971907
if (cn.ptype_ == prim::CLK_BUF or cn.ptype_ == prim::FCLK_BUF)
18981908
continue;
1899-
// lputs9();
1909+
19001910
for (uint i = 0; i < cn.inPins_.size(); i++) {
19011911
const string& inp = cn.inPins_[i];
19021912
assert(not inp.empty());
19031913
if (not pr_pin_is_clock(cn.ptype_, inp))
19041914
continue;
1905-
assert(cn.cell_hc_);
1906-
key = hashCantor(cn.id_, i + 1) + max_key1;
1915+
1916+
uint cn_realId = cn.realId(*this);
1917+
key = hashCantor(cn_realId, i + 1) + max_key1;
19071918
assert(key);
1908-
// assert(not pg_.hasKey(key));
19091919
kid = pg_.insK(key);
19101920
assert(kid);
19111921
pg_.nodeRef(kid).markClk(true);
@@ -1914,32 +1924,33 @@ bool BLIF_file::createPinGraph() noexcept {
19141924
kid, cn.lnum_);
19151925

19161926
assert(not pg_.nodeRef(kid).inp_flag_);
1917-
pg_.setNodeName4(kid, cn.id_, cn.lnum_, i+1, cn.cPrimType());
1918-
pg2blif_.emplace(kid, cn.id_);
1927+
pg_.setNodeName4(kid, cn_realId, cn.lnum_, i+1, cn.cPrimType());
1928+
pg2blif_.emplace(kid, cn_realId);
19191929

19201930
const string& inet = cn.inSigs_[i];
19211931
assert(not inet.empty());
1922-
const BNode* driver = findDriverNode(cn.id_, inet);
1932+
const BNode* driver = findDriverNode(cn_realId, inet);
19231933
if (!driver) {
19241934
flush_out(true); err_puts();
19251935
lprintf2("[Error] no driver for clock node #%u %s line:%u\n",
1926-
cn.id_, cn.cPrimType(), cn.lnum_);
1936+
cn_realId, cn.cPrimType(), cn.lnum_);
19271937
err_puts(); flush_out(true);
19281938
return false;
19291939
}
1940+
uint driver_realId = driver->realId(*this);
19301941

19311942
if (trace_ >= 5) {
19321943
lputs9();
19331944
lprintf(" from cn#%u %s ",
1934-
cn.id_, cn.cPrimType() );
1945+
cn_realId, cn.cPrimType() );
19351946
lprintf( " CLOCK_TRACE driver-> id_%u %s out_net %s\n",
1936-
driver->id_, driver->cPrimType(), driver->out_.c_str() );
1947+
driver_realId, driver->cPrimType(), driver->out_.c_str() );
19371948
}
19381949

1939-
if (not driver->is_CLK_BUF() and not driver->isTopInput()) {
1950+
if (not driver->canDriveClockNode()) {
19401951
flush_out(true); err_puts();
1941-
lprintf2("[Error] bad driver for clock node #%u must be CLK_BUF or iport\n",
1942-
cn.id_);
1952+
lprintf2("[Error] bad driver (%s) for clock node #%u must be %s\n",
1953+
driver->cPrimType(), cn_realId, s_possible_cdrivers);
19431954
err_puts(); flush_out(true);
19441955
return false;
19451956
}
@@ -1949,7 +1960,7 @@ bool BLIF_file::createPinGraph() noexcept {
19491960
uint opin_nid = pg_.findNode(opin_key);
19501961
if (opin_nid) {
19511962
assert(pg_.nodeRef(opin_nid).isNamed());
1952-
assert(map_pg2blif(opin_nid) == driver->id_);
1963+
assert(map_pg2blif(opin_nid) == driver_realId);
19531964
}
19541965
else {
19551966
opin_nid = pg_.insK(opin_key);
@@ -1964,9 +1975,9 @@ bool BLIF_file::createPinGraph() noexcept {
19641975
}
19651976

19661977
assert(not pg_.nodeRef(opin_nid).inp_flag_);
1967-
pg_.setNodeName3(opin_nid, driver->id_,
1978+
pg_.setNodeName3(opin_nid, driver_realId,
19681979
driver->lnum_, driver->out_.c_str());
1969-
pg2blif_.emplace(opin_nid, driver->id_);
1980+
pg2blif_.emplace(opin_nid, driver_realId);
19701981
}
19711982

19721983
assert(opin_nid and kid);
@@ -1991,7 +2002,7 @@ bool BLIF_file::createPinGraph() noexcept {
19912002
return false;
19922003
}
19932004

1994-
uint64_t ipin_key = hashCantor(dn.id_, 1) + max_key1;
2005+
uint64_t ipin_key = hashCantor(dn.realId(*this), 1) + max_key1;
19952006
assert(ipin_key);
19962007
uint ipin_nid = pg_.findNode(ipin_key);
19972008
if (ipin_nid) {
@@ -2041,10 +2052,10 @@ bool BLIF_file::createPinGraph() noexcept {
20412052
drv_drv->out_.c_str(), drv_drv->lnum_);
20422053
}
20432054

2044-
if (not drv_drv->is_CLK_BUF() and not drv_drv->isTopInput()) {
2055+
if (not drv_drv->canDriveClockNode()) {
20452056
flush_out(true); err_puts();
2046-
lprintf2("[Error] bad driver (%s) for clock-buf node #%u line:%u must be CLK_BUF or iport\n",
2047-
drv_drv->cPrimType(), dn.id_, dn.lnum_);
2057+
lprintf2("[Error] bad driver (%s) for clock-buf node #%u line:%u must be %s\n",
2058+
drv_drv->cPrimType(), dn.id_, dn.lnum_, s_possible_cdrivers);
20482059
err_puts(); flush_out(true);
20492060
err_lnum_ = dn.lnum_;
20502061
err_lnum2_ = drv_drv->lnum_;
@@ -2055,17 +2066,17 @@ bool BLIF_file::createPinGraph() noexcept {
20552066
// and connect it to the iput of CLK_BUF 'dn'
20562067

20572068
assert(drv_drv->out_ == inp1);
2058-
assert(drv_drv->cell_hc_);
20592069
uint64_t drv_drv_outKey = 0;
20602070
uint drv_drv_outNid = 0;
20612071
nid = kid = 0;
2072+
uint drv_drv_realId = drv_drv->realId(*this);
20622073

20632074
if (drv_drv->isTopInput()) {
20642075
assert(drv_drv->nw_id_);
20652076
drv_drv_outNid = drv_drv->nw_id_;
20662077
assert(pg_.hasNode(drv_drv_outNid));
20672078
assert(pg2blif_.count(drv_drv_outNid));
2068-
assert(map_pg2blif(drv_drv_outNid) == drv_drv->id_);
2079+
assert(map_pg2blif(drv_drv_outNid) == drv_drv_realId);
20692080
drv_drv_outKey = pg_.nodeRefCk(drv_drv_outNid).key_;
20702081
assert(drv_drv_outKey);
20712082
}
@@ -2076,7 +2087,7 @@ bool BLIF_file::createPinGraph() noexcept {
20762087
drv_drv_outNid = pg_.insK(drv_drv_outKey);
20772088
assert(drv_drv_outNid);
20782089
pg_.nodeRef(drv_drv_outNid).markClk(true);
2079-
pg2blif_.emplace(drv_drv_outNid, drv_drv->id_);
2090+
pg2blif_.emplace(drv_drv_outNid, drv_drv_realId);
20802091

20812092
if (not pg_.nodeRefCk(drv_drv_outNid).isNamed()) {
20822093
::snprintf(nm_buf, 510, "nd%u_L%u_",
@@ -2089,7 +2100,7 @@ bool BLIF_file::createPinGraph() noexcept {
20892100
}
20902101

20912102
assert(not pg_.nodeRef(drv_drv_outNid).inp_flag_);
2092-
pg_.setNodeName3(drv_drv_outNid, drv_drv->id_,
2103+
pg_.setNodeName3(drv_drv_outNid, drv_drv_realId,
20932104
drv_drv->lnum_, drv_drv->out_.c_str());
20942105
}
20952106

@@ -2114,6 +2125,16 @@ bool BLIF_file::createPinGraph() noexcept {
21142125
}
21152126
}
21162127

2128+
// mark prim-types in NW:
2129+
for (const auto I : pg2blif_) {
2130+
uint nw_id = I.first;
2131+
uint bl_id = I.second;
2132+
const BNode& bnode = bnodeRef(bl_id);
2133+
assert(not bnode.isVirtualMog());
2134+
if (bnode.hasPrimType())
2135+
pg_.nodeRefCk(nw_id).markPrim(bnode.ptype_);
2136+
}
2137+
21172138
pg_.setNwName("pin_graph");
21182139

21192140
// writePinGraph("pin_graph_1.dot");

‎planning/src/file_io/pln_blif_file.h

Lines changed: 12 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -115,6 +115,12 @@ struct BLIF_file : public fio::MMapReader
115115
return pt > 0 and pt < prim::Prim_MAX_ID;
116116
}
117117

118+
uint realId(const BLIF_file& bf) const noexcept {
119+
if (isVirtualMog())
120+
return bf.bnodeRef(virtualOrigin_).id_;
121+
return id_;
122+
}
123+
118124
uint deg() const noexcept { return uint(!isRoot()) + chld_.size(); }
119125
uint inDeg() const noexcept { return uint(!isRoot()); }
120126
uint outDeg() const noexcept { return chld_.size(); }
@@ -160,6 +166,10 @@ struct BLIF_file : public fio::MMapReader
160166
return prim::pr_is_DFF(ptype_);
161167
}
162168

169+
bool canDriveClockNode() const noexcept {
170+
return isTopInput() or is_CLK_BUF() or ptype_ == prim::I_SERDES;
171+
}
172+
163173
string firstInputNet() const noexcept;
164174

165175
void allInputPins(vector<string>& V) const noexcept;
@@ -258,7 +268,7 @@ struct BLIF_file : public fio::MMapReader
258268

259269
uint typeHist(prim::Prim_t t) const noexcept { return typeHistogram_[t]; }
260270

261-
void collectClockedNodes(vector<const BNode*>& V) noexcept;
271+
void collectClockedNodes(vector<BNode*>& V) noexcept;
262272
std::array<uint, prim::Prim_MAX_ID> countTypes() const noexcept;
263273

264274
uint printInputs(std::ostream& os, CStr spacer = nullptr) const noexcept;
@@ -279,7 +289,7 @@ struct BLIF_file : public fio::MMapReader
279289

280290
string writePinGraph(CStr fn0) const noexcept;
281291

282-
bool checkClockSepar(vector<const BNode*>& clocked) noexcept;
292+
bool checkClockSepar(vector<BNode*>& clocked) noexcept;
283293

284294
BNode* findOutputPort(const string& contact) noexcept;
285295
BNode* findInputPort(const string& contact) noexcept;

‎planning/src/main.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
static const char* _pln_VERSION_STR = "pln0333";
1+
static const char* _pln_VERSION_STR = "pln0334";
22

33
#include "RS/rsEnv.h"
44
#include "util/pln_log.h"

‎planning/src/util/nw/Nw.h

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -152,12 +152,15 @@ struct NW {
152152
uint parent() const noexcept { return par_; }
153153
bool isTreeRoot() const noexcept { return !par_; }
154154
bool isFlagRoot() const noexcept { return root_flag_; }
155+
155156
void markRoot(bool val) noexcept { root_flag_ = val; }
156157
void markSink(bool val) noexcept { sink_flag_ = val; }
157158
void markInp(bool val) noexcept { inp_flag_ = val; }
158159
void markOut(bool val) noexcept { out_flag_ = val; }
159160
void markClk(bool val) noexcept { clk_flag_ = val; }
160161
void markViol(bool val) noexcept { viol_flag_ = val; }
162+
void markPrim(uint16_t pt) noexcept { prim_ = pt; }
163+
161164
bool isClk() const noexcept { return clk_flag_; }
162165
bool terminal() const noexcept { return sink_flag_ or root_flag_; }
163166

@@ -184,7 +187,8 @@ struct NW {
184187
uint lbl_ = 0;
185188
int rad_ = 0;
186189

187-
// DATA:
190+
uint16_t prim_ = 0; // primitive code from pln_primitives.h
191+
188192
bool root_flag_ = false;
189193
bool sink_flag_ = false;
190194
bool inp_flag_ = false;

0 commit comments

Comments
 (0)