1 ///////////////////////////////////////////////////////////////////////////////
2 // BSD 3-Clause License
3 //
4 // Copyright (c) 2020, The Regents of the University of California
5 // All rights reserved.
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions are met:
9 //
10 // * Redistributions of source code must retain the above copyright notice, this
11 // list of conditions and the following disclaimer.
12 //
13 // * Redistributions in binary form must reproduce the above copyright notice,
14 // this list of conditions and the following disclaimer in the documentation
15 // and/or other materials provided with the distribution.
16 //
17 // * Neither the name of the copyright holder nor the names of its
18 // contributors may be used to endorse or promote products derived from
19 // this software without specific prior written permission.
20 //
21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
25 // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 // POSSIBILITY OF SUCH DAMAGE.
32
33 // Generator Code Begin Cpp
34 #include "dbGroup.h"
35
36 #include "db.h"
37 #include "dbBlock.h"
38 #include "dbBox.h"
39 #include "dbDatabase.h"
40 #include "dbDiff.hpp"
41 #include "dbGroupInstItr.h"
42 #include "dbGroupItr.h"
43 #include "dbGroupModInstItr.h"
44 #include "dbHashTable.hpp"
45 #include "dbInst.h"
46 #include "dbModInst.h"
47 #include "dbNet.h"
48 #include "dbTable.h"
49 #include "dbTable.hpp"
50 // User Code Begin Includes
51 #include "dbGroupGroundNetItr.h"
52 #include "dbGroupPowerNetItr.h"
53 // User Code End Includes
54 namespace odb {
55
56 template class dbTable<_dbGroup>;
57
operator ==(const _dbGroup & rhs) const58 bool _dbGroup::operator==(const _dbGroup& rhs) const
59 {
60 if (flags_._type != rhs.flags_._type)
61 return false;
62
63 if (flags_._box != rhs.flags_._box)
64 return false;
65
66 if (_name != rhs._name)
67 return false;
68
69 if (_box != rhs._box)
70 return false;
71
72 if (_next_entry != rhs._next_entry)
73 return false;
74
75 if (_group_next != rhs._group_next)
76 return false;
77
78 if (_parent_group != rhs._parent_group)
79 return false;
80
81 if (_insts != rhs._insts)
82 return false;
83
84 if (_modinsts != rhs._modinsts)
85 return false;
86
87 if (_groups != rhs._groups)
88 return false;
89
90 // User Code Begin ==
91 if (_power_nets != rhs._power_nets)
92 return false;
93
94 if (_ground_nets != rhs._ground_nets)
95 return false;
96 // User Code End ==
97 return true;
98 }
operator <(const _dbGroup & rhs) const99 bool _dbGroup::operator<(const _dbGroup& rhs) const
100 {
101 // User Code Begin <
102 if (strcmp(_name, rhs._name) >= 0)
103 return false;
104 if (flags_._type >= rhs.flags_._type)
105 return false;
106 if (_box >= rhs._box)
107 return false;
108 // User Code End <
109 return true;
110 }
differences(dbDiff & diff,const char * field,const _dbGroup & rhs) const111 void _dbGroup::differences(dbDiff& diff,
112 const char* field,
113 const _dbGroup& rhs) const
114 {
115 DIFF_BEGIN
116
117 DIFF_FIELD(flags_._type);
118 DIFF_FIELD(flags_._box);
119 DIFF_FIELD(_name);
120 DIFF_FIELD(_box);
121 DIFF_FIELD(_next_entry);
122 DIFF_FIELD(_group_next);
123 DIFF_FIELD(_parent_group);
124 DIFF_FIELD(_insts);
125 DIFF_FIELD(_modinsts);
126 DIFF_FIELD(_groups);
127 // User Code Begin Differences
128
129 DIFF_VECTOR(_power_nets);
130
131 DIFF_VECTOR(_ground_nets);
132
133 // User Code End Differences
134 DIFF_END
135 }
out(dbDiff & diff,char side,const char * field) const136 void _dbGroup::out(dbDiff& diff, char side, const char* field) const
137 {
138 DIFF_OUT_BEGIN
139 DIFF_OUT_FIELD(flags_._type);
140 DIFF_OUT_FIELD(flags_._box);
141 DIFF_OUT_FIELD(_name);
142 DIFF_OUT_FIELD(_box);
143 DIFF_OUT_FIELD(_next_entry);
144 DIFF_OUT_FIELD(_group_next);
145 DIFF_OUT_FIELD(_parent_group);
146 DIFF_OUT_FIELD(_insts);
147 DIFF_OUT_FIELD(_modinsts);
148 DIFF_OUT_FIELD(_groups);
149
150 // User Code Begin Out
151
152 DIFF_OUT_VECTOR(_power_nets);
153
154 DIFF_OUT_VECTOR(_ground_nets);
155
156 // User Code End Out
157 DIFF_END
158 }
_dbGroup(_dbDatabase * db)159 _dbGroup::_dbGroup(_dbDatabase* db)
160 {
161 uint32_t* flags__bit_field = (uint32_t*) &flags_;
162 *flags__bit_field = 0;
163 // User Code Begin Constructor
164 // User Code End Constructor
165 }
_dbGroup(_dbDatabase * db,const _dbGroup & r)166 _dbGroup::_dbGroup(_dbDatabase* db, const _dbGroup& r)
167 {
168 flags_._type = r.flags_._type;
169 flags_._box = r.flags_._box;
170 flags_.spare_bits_ = r.flags_.spare_bits_;
171 _name = r._name;
172 _box = r._box;
173 _next_entry = r._next_entry;
174 _group_next = r._group_next;
175 _parent_group = r._parent_group;
176 _insts = r._insts;
177 _modinsts = r._modinsts;
178 _groups = r._groups;
179 // User Code Begin CopyConstructor
180 _power_nets = r._power_nets;
181 _ground_nets = r._ground_nets;
182 // User Code End CopyConstructor
183 }
184
operator >>(dbIStream & stream,_dbGroup & obj)185 dbIStream& operator>>(dbIStream& stream, _dbGroup& obj)
186 {
187 uint32_t* flags__bit_field = (uint32_t*) &obj.flags_;
188 stream >> *flags__bit_field;
189 stream >> obj._name;
190 stream >> obj._box;
191 stream >> obj._next_entry;
192 stream >> obj._group_next;
193 stream >> obj._parent_group;
194 stream >> obj._insts;
195 stream >> obj._modinsts;
196 stream >> obj._groups;
197 stream >> obj._power_nets;
198 stream >> obj._ground_nets;
199 // User Code Begin >>
200 // User Code End >>
201 return stream;
202 }
operator <<(dbOStream & stream,const _dbGroup & obj)203 dbOStream& operator<<(dbOStream& stream, const _dbGroup& obj)
204 {
205 uint32_t* flags__bit_field = (uint32_t*) &obj.flags_;
206 stream << *flags__bit_field;
207 stream << obj._name;
208 stream << obj._box;
209 stream << obj._next_entry;
210 stream << obj._group_next;
211 stream << obj._parent_group;
212 stream << obj._insts;
213 stream << obj._modinsts;
214 stream << obj._groups;
215 stream << obj._power_nets;
216 stream << obj._ground_nets;
217 // User Code Begin <<
218 // User Code End <<
219 return stream;
220 }
221
~_dbGroup()222 _dbGroup::~_dbGroup()
223 {
224 if (_name)
225 free((void*) _name);
226 // User Code Begin Destructor
227 // User Code End Destructor
228 }
229
230 // User Code Begin PrivateMethods
231 // User Code End PrivateMethods
232
233 ////////////////////////////////////////////////////////////////////
234 //
235 // dbGroup - Methods
236 //
237 ////////////////////////////////////////////////////////////////////
238
getName() const239 const char* dbGroup::getName() const
240 {
241 _dbGroup* obj = (_dbGroup*) this;
242 return obj->_name;
243 }
244
getBox() const245 Rect dbGroup::getBox() const
246 {
247 _dbGroup* obj = (_dbGroup*) this;
248 return obj->_box;
249 }
250
setParentGroup(dbGroup * parent_group)251 void dbGroup::setParentGroup(dbGroup* parent_group)
252 {
253 _dbGroup* obj = (_dbGroup*) this;
254
255 obj->_parent_group = parent_group->getImpl()->getOID();
256 }
257
getParentGroup() const258 dbGroup* dbGroup::getParentGroup() const
259 {
260 _dbGroup* obj = (_dbGroup*) this;
261 if (obj->_parent_group == 0)
262 return NULL;
263 _dbBlock* par = (_dbBlock*) obj->getOwner();
264 return (dbGroup*) par->_group_tbl->getPtr(obj->_parent_group);
265 }
266
267 // User Code Begin dbGroupPublicMethods
setType(dbGroupType _type)268 void dbGroup::setType(dbGroupType _type)
269 {
270 _dbGroup* obj = (_dbGroup*) this;
271
272 obj->flags_._type = (uint) _type;
273 }
274
getType() const275 dbGroup::dbGroupType dbGroup::getType() const
276 {
277 _dbGroup* obj = (_dbGroup*) this;
278
279 return (dbGroup::dbGroupType) obj->flags_._type;
280 }
281
setBox(Rect _box)282 void dbGroup::setBox(Rect _box)
283 {
284 _dbGroup* obj = (_dbGroup*) this;
285 obj->flags_._box = 1;
286 obj->_box = _box;
287 }
288
hasBox()289 bool dbGroup::hasBox()
290 {
291 _dbGroup* obj = (_dbGroup*) this;
292 return obj->flags_._box;
293 }
294
addModInst(dbModInst * modinst)295 void dbGroup::addModInst(dbModInst* modinst)
296 {
297 _dbGroup* _group = (_dbGroup*) this;
298 _dbModInst* _modinst = (_dbModInst*) modinst;
299 if (_modinst->_group != 0)
300 modinst->getGroup()->removeModInst(modinst);
301 _modinst->_group = _group->getOID();
302 _modinst->_group_next = _group->_modinsts;
303 _group->_modinsts = _modinst->getOID();
304 }
305
removeModInst(dbModInst * modinst)306 void dbGroup::removeModInst(dbModInst* modinst)
307 {
308 _dbGroup* _group = (_dbGroup*) this;
309 _dbModInst* _modinst = (_dbModInst*) modinst;
310 if (_modinst->_group != _group->getOID())
311 return;
312 _dbBlock* _block = (_dbBlock*) _group->getOwner();
313 uint id = _modinst->getOID();
314 _dbModInst* prev = NULL;
315 uint cur = _group->_modinsts;
316 while (cur) {
317 _dbModInst* c = _block->_modinst_tbl->getPtr(cur);
318 if (cur == id) {
319 if (prev == NULL)
320 _group->_modinsts = _modinst->_group_next;
321 else
322 prev->_group_next = _modinst->_group_next;
323 break;
324 }
325 prev = c;
326 cur = c->_group_next;
327 }
328 _modinst->_group = 0;
329 _modinst->_group_next = 0;
330 }
331
getModInsts()332 dbSet<dbModInst> dbGroup::getModInsts()
333 {
334 _dbGroup* _group = (_dbGroup*) this;
335 _dbBlock* block = (_dbBlock*) _group->getOwner();
336 return dbSet<dbModInst>(_group, block->_group_modinst_itr);
337 }
338
addInst(dbInst * inst)339 void dbGroup::addInst(dbInst* inst)
340 {
341 _dbGroup* _group = (_dbGroup*) this;
342 _dbInst* _inst = (_dbInst*) inst;
343 if (_inst->_group != 0)
344 inst->getGroup()->removeInst(inst);
345 _inst->_group = _group->getOID();
346 _inst->_group_next = _group->_insts;
347 _group->_insts = _inst->getOID();
348 }
349
removeInst(dbInst * inst)350 void dbGroup::removeInst(dbInst* inst)
351 {
352 _dbGroup* _group = (_dbGroup*) this;
353 _dbInst* _inst = (_dbInst*) inst;
354 if (_inst->_group != _group->getOID())
355 return;
356 _dbBlock* _block = (_dbBlock*) _group->getOwner();
357 uint id = _inst->getOID();
358 _dbInst* prev = NULL;
359 uint cur = _group->_insts;
360 while (cur) {
361 _dbInst* c = _block->_inst_tbl->getPtr(cur);
362 if (cur == id) {
363 if (prev == NULL)
364 _group->_insts = _inst->_group_next;
365 else
366 prev->_group_next = _inst->_group_next;
367 break;
368 }
369 prev = c;
370 cur = c->_group_next;
371 }
372 _inst->_group = 0;
373 _inst->_group_next = 0;
374 }
375
getInsts()376 dbSet<dbInst> dbGroup::getInsts()
377 {
378 _dbGroup* _group = (_dbGroup*) this;
379 _dbBlock* block = (_dbBlock*) _group->getOwner();
380 return dbSet<dbInst>(_group, block->_group_inst_itr);
381 }
382
addGroup(dbGroup * child)383 void dbGroup::addGroup(dbGroup* child)
384 {
385 _dbGroup* _group = (_dbGroup*) this;
386 _dbGroup* _child = (_dbGroup*) child;
387 if (_child->_parent_group != 0)
388 child->getParentGroup()->removeGroup(child);
389 _child->_parent_group = _group->getOID();
390 _child->_group_next = _group->_groups;
391 _group->_groups = _child->getOID();
392 }
393
removeGroup(dbGroup * child)394 void dbGroup::removeGroup(dbGroup* child)
395 {
396 _dbGroup* _group = (_dbGroup*) this;
397 _dbGroup* _child = (_dbGroup*) child;
398 if (_child->_parent_group != _group->getOID())
399 return;
400 _dbBlock* _block = (_dbBlock*) _group->getOwner();
401 uint id = _child->getOID();
402 _dbGroup* prev = NULL;
403 uint cur = _group->_groups;
404 while (cur) {
405 _dbGroup* c = _block->_group_tbl->getPtr(cur);
406 if (cur == id) {
407 if (prev == NULL)
408 _group->_groups = _child->_group_next;
409 else
410 prev->_group_next = _child->_group_next;
411 break;
412 }
413 prev = c;
414 cur = c->_group_next;
415 }
416 _child->_parent_group = 0;
417 _child->_group_next = 0;
418 }
419
getGroups()420 dbSet<dbGroup> dbGroup::getGroups()
421 {
422 _dbGroup* _group = (_dbGroup*) this;
423 _dbBlock* block = (_dbBlock*) _group->getOwner();
424 return dbSet<dbGroup>(_group, block->_group_itr);
425 }
426
addPowerNet(dbNet * net)427 void dbGroup::addPowerNet(dbNet* net)
428 {
429 _dbGroup* _group = (_dbGroup*) this;
430 _dbNet* _net = (_dbNet*) net;
431 for (dbId<_dbNet> _child : _group->_power_nets)
432 if (_child == _net->getOID())
433 return;
434 bool found = false;
435 dbVector<dbId<_dbNet>>::iterator it;
436 for (it = _group->_ground_nets.begin();
437 it != _group->_ground_nets.end() && !found;
438 it++)
439 if (*it == _net->getOID()) {
440 _group->_ground_nets.erase(it--);
441 found = true;
442 }
443 _group->_power_nets.push_back(_net->getOID());
444 if (!found)
445 _net->_groups.push_back(_group->getOID());
446 }
447
addGroundNet(dbNet * net)448 void dbGroup::addGroundNet(dbNet* net)
449 {
450 _dbGroup* _group = (_dbGroup*) this;
451 _dbNet* _net = (_dbNet*) net;
452 for (dbId<_dbNet> _child : _group->_ground_nets)
453 if (_child == _net->getOID())
454 return;
455 bool found = false;
456 dbVector<dbId<_dbNet>>::iterator it;
457 for (it = _group->_power_nets.begin();
458 it != _group->_power_nets.end() && !found;
459 it++)
460 if (*it == _net->getOID()) {
461 _group->_power_nets.erase(it--);
462 found = true;
463 }
464 _group->_ground_nets.push_back(_net->getOID());
465 if (!found)
466 _net->_groups.push_back(_group->getOID());
467 }
468
removeNet(dbNet * net)469 void dbGroup::removeNet(dbNet* net)
470 {
471 _dbGroup* _group = (_dbGroup*) this;
472 _dbNet* _net = (_dbNet*) net;
473 bool found = false;
474 dbVector<dbId<_dbNet>>::iterator net_itr;
475 for (net_itr = _group->_power_nets.begin();
476 net_itr != _group->_power_nets.end() && !found;
477 net_itr++)
478 if (*net_itr == _net->getOID()) {
479 _group->_power_nets.erase(net_itr--);
480 found = true;
481 }
482 for (net_itr = _group->_ground_nets.begin();
483 net_itr != _group->_ground_nets.end() && !found;
484 net_itr++)
485 if (*net_itr == _net->getOID()) {
486 _group->_ground_nets.erase(net_itr--);
487 found = true;
488 }
489 if (found) {
490 dbVector<dbId<_dbGroup>>::iterator group_itr;
491 for (group_itr = _net->_groups.begin(); group_itr != _net->_groups.end();
492 group_itr++)
493 if (*group_itr == _group->getOID()) {
494 _net->_groups.erase(group_itr--);
495 return;
496 }
497 }
498 }
499
getPowerNets()500 dbSet<dbNet> dbGroup::getPowerNets()
501 {
502 _dbGroup* _group = (_dbGroup*) this;
503 _dbBlock* _block = (_dbBlock*) _group->getOwner();
504 return dbSet<dbNet>(_group, _block->_group_power_net_itr);
505 }
506
getGroundNets()507 dbSet<dbNet> dbGroup::getGroundNets()
508 {
509 _dbGroup* _group = (_dbGroup*) this;
510 _dbBlock* _block = (_dbBlock*) _group->getOwner();
511 return dbSet<dbNet>(_group, _block->_group_ground_net_itr);
512 }
513
create(dbBlock * block,const char * name)514 dbGroup* dbGroup::create(dbBlock* block, const char* name)
515 {
516 _dbBlock* _block = (_dbBlock*) block;
517 if (_block->_group_hash.hasMember(name))
518 return nullptr;
519 _dbGroup* _group = _block->_group_tbl->create();
520 _group->_name = strdup(name);
521 ZALLOCATED(_group->_name);
522 _group->flags_._type = PHYSICAL_CLUSTER;
523 _block->_group_hash.insert(_group);
524 return (dbGroup*) _group;
525 }
526
create(dbBlock * block,const char * name,int x1,int y1,int x2,int y2)527 dbGroup* dbGroup::create(dbBlock* block,
528 const char* name,
529 int x1,
530 int y1,
531 int x2,
532 int y2)
533 {
534 _dbBlock* _block = (_dbBlock*) block;
535 if (_block->_group_hash.hasMember(name))
536 return nullptr;
537 _dbGroup* _group = _block->_group_tbl->create();
538 _group->_name = strdup(name);
539 ZALLOCATED(_group->_name);
540 _group->flags_._type = VOLTAGE_DOMAIN;
541 _group->flags_._box = 1;
542 _block->_group_hash.insert(_group);
543 _group->_box.init(x1, y1, x2, y2);
544 return (dbGroup*) _group;
545 }
546
create(dbGroup * parent,const char * name)547 dbGroup* dbGroup::create(dbGroup* parent, const char* name)
548 {
549 _dbGroup* _parent = (_dbGroup*) parent;
550 _dbBlock* _block = (_dbBlock*) _parent->getOwner();
551 if (_block->_group_hash.hasMember(name))
552 return nullptr;
553 _dbGroup* _group = _block->_group_tbl->create();
554 _group->_name = strdup(name);
555 ZALLOCATED(_group->_name);
556 _group->flags_._type = PHYSICAL_CLUSTER;
557 _block->_group_hash.insert(_group);
558 parent->addGroup((dbGroup*) _group);
559 return (dbGroup*) _group;
560 }
561
destroy(dbGroup * group)562 void dbGroup::destroy(dbGroup* group)
563 {
564 _dbGroup* _group = (_dbGroup*) group;
565 _dbBlock* block = (_dbBlock*) _group->getOwner();
566 for (auto inst : group->getInsts()) {
567 group->removeInst(inst);
568 }
569 for (auto modinst : group->getModInsts()) {
570 group->removeModInst(modinst);
571 }
572 for (auto child : group->getGroups()) {
573 group->removeGroup(child);
574 }
575 if (_group->_parent_group != 0)
576 group->getParentGroup()->removeGroup(group);
577 dbProperty::destroyProperties(_group);
578 block->_group_hash.remove(_group);
579 block->_group_tbl->destroy(_group);
580 }
581
getGroup(dbBlock * block_,uint dbid_)582 dbGroup* dbGroup::getGroup(dbBlock* block_, uint dbid_)
583 {
584 _dbBlock* block = (_dbBlock*) block_;
585 return (dbGroup*) block->_group_tbl->getPtr(dbid_);
586 }
587
588 // User Code End dbGroupPublicMethods
589 } // namespace odb
590 // Generator Code End Cpp
591