riscv
/
coriolis
mirror of https://gitlab.lip6.fr/vlsi-eda/coriolis.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'devel' of ssh://bop-t/users/largo2/git/coriolis into devel 

This is the same branch, but on the remote repository.
This commit is contained in:
Jean-Paul Chaput 2016-02-20 18:44:15 +01:00
parent 1b7bd9de36 5809fc7aa0
commit f508bb0d20
7 changed files with 2046 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
bootstrap/build.conf
View File

@ -43,6 +43,7 @@ projects = [
, "graph"
, "pharos"
, "isis"
, "horus"
#, "schematic"
, "solver"
, "autoDTR"

1
vlsisapd/CMakeLists.txt
View File

@ -20,6 +20,7 @@
find_package(BISON REQUIRED)
find_package(FLEX REQUIRED)
find_package(Doxygen)
find_package(HURRICANE REQUIRED)
add_subdirectory(src)
add_subdirectory(cmake_modules)

43
vlsisapd/src/openChams/src/CMakeLists.txt
View File

@ -1,4 +1,9 @@
INCLUDE_DIRECTORIES(${VLSISAPD_SOURCE_DIR}/src/openChams/src ${LIBXML2_INCLUDE_DIR} ${Boost_INCLUDE_DIRS} ${PYTHON_INCLUDE_PATH})
INCLUDE_DIRECTORIES( ${VLSISAPD_SOURCE_DIR}/src/openChams/src
${LIBXML2_INCLUDE_DIR}
${Boost_INCLUDE_DIRS}
${PYTHON_INCLUDE_PATH}
${HURRICANE_INCLUDE_DIR}
)
SET ( hpps vlsisapd/openChams/Circuit.h
vlsisapd/openChams/Netlist.h
@ -21,6 +26,7 @@ SET ( hpps vlsisapd/openChams/Circuit.h
vlsisapd/openChams/NRCCstr.h
vlsisapd/openChams/DDP.h
vlsisapd/openChams/DesignerCstrOC.h
vlsisapd/openChams/SlicingTree.h
)
SET ( cpps Circuit.cpp
Netlist.cpp
@ -41,23 +47,24 @@ SET ( cpps Circuit.cpp
NRCCstr.cpp
DDP.cpp
DesignerCstrOC.cpp
)
SET ( pycpps PyOpenChams.cpp
)
SlicingTree.cpp
)
SET ( pycpps PyOpenChams.cpp
)
ADD_LIBRARY(openChams ${cpps})
TARGET_LINK_LIBRARIES(openChams ${LIBXML2_LIBRARIES})
SET_TARGET_PROPERTIES(openChams PROPERTIES VERSION 1.0 SOVERSION 1)
INSTALL(TARGETS openChams DESTINATION lib${LIB_SUFFIX} )
ADD_LIBRARY(openChams ${cpps})
TARGET_LINK_LIBRARIES(openChams ${LIBXML2_LIBRARIES})
SET_TARGET_PROPERTIES(openChams PROPERTIES VERSION 1.0 SOVERSION 1)
INSTALL(TARGETS openChams DESTINATION lib${LIB_SUFFIX} )
IF(Boost_FOUND)
ADD_LIBRARY(pyOPENCHAMS MODULE ${pycpps})
SET_TARGET_PROPERTIES(pyOPENCHAMS PROPERTIES
OUTPUT_NAME "OPENCHAMS"
PREFIX ""
)
TARGET_LINK_LIBRARIES(pyOPENCHAMS openChams ${LIBXML2_LIBRARIES} ${Boost_LIBRARIES} ${PYTHON_LIBRARIES})
INSTALL(TARGETS pyOPENCHAMS DESTINATION ${PYTHON_SITE_PACKAGES})
ENDIF(Boost_FOUND)
IF(Boost_FOUND)
ADD_LIBRARY(pyOPENCHAMS MODULE ${pycpps})
SET_TARGET_PROPERTIES(pyOPENCHAMS PROPERTIES
OUTPUT_NAME "OPENCHAMS"
PREFIX ""
)
TARGET_LINK_LIBRARIES(pyOPENCHAMS openChams ${LIBXML2_LIBRARIES} ${Boost_LIBRARIES} ${PYTHON_LIBRARIES})
INSTALL(TARGETS pyOPENCHAMS DESTINATION ${PYTHON_SITE_PACKAGES})
ENDIF(Boost_FOUND)
INSTALL(FILES ${hpps} DESTINATION include/vlsisapd/openChams)
INSTALL(FILES ${hpps} DESTINATION include/vlsisapd/openChams)

758
vlsisapd/src/openChams/src/Circuit.cpp
View File

@ -2,13 +2,14 @@
// -*- C++ -*-
//
// This file is part of the VLSI SAPD Software.
// Copyright (c) UPMC/LIP6 2009-2012, All Rights Reserved
// Copyright (c) UPMC/LIP6 2009-2016, All Rights Reserved
//
// +-----------------------------------------------------------------+
// | V L S I S A P D |
// | OpenChams Circuit Data Base |
// | |
// | Author : Damien Dupuis |
// | Eric Lao |
// | E-mail : Jean-Paul.Chaput@lip6.fr |
// | =============================================================== |
// | C++ Module : "./Circuit.cpp" |
@ -152,6 +153,7 @@ namespace OpenChams {
static bool readSchematicDone = false;
static bool readSizingDone = false;
static bool readLayoutDone = false;
static bool readSlicingTreeDone = false;
Circuit::Circuit(const std::string& name, const std::string& techno)
: _name (name)
@ -161,6 +163,7 @@ namespace OpenChams {
, _schematic (NULL)
, _sizing (NULL)
, _layout (NULL)
, _slicingtree (NULL)
{
readSubCircuitsPathsDone = false;
readCircuitParametersDone = false;
@ -981,16 +984,16 @@ namespace OpenChams {
Layout* layout = new Layout(this);
xmlNode* child = node->children;
//cerr << "** L ** " << node->name << ": " << node->type << endl;
//cerr << "** L ** " << node->name << ": " << node->type << endl;
for (xmlNode* node = child; node; node = node->next) {
if (node->type == XML_ELEMENT_NODE) {
if (xmlStrEqual(node->name, (xmlChar*)"instance")) {
readInstanceLayout(node, layout);
} else if (xmlStrEqual(node->name, (xmlChar*)"hbtree")) {
readHBTree(node, layout);
} else {
cerr << "[WARNING] Only 'instance' and 'hbtree' nodes are allowed in 'layout' section, others will be ignored." << endl;
}
if (xmlStrEqual(node->name, (xmlChar*)"instance")) {
readInstanceLayout(node, layout);
} else if (xmlStrEqual(node->name, (xmlChar*)"hbtree")) {
readHBTree(node, layout);
} else {
cerr << "[WARNING] Only 'instance' and 'hbtree' nodes are allowed in 'layout' section, others will be ignored." << endl;
}
}
}
readLayoutDone = true;
@ -1010,10 +1013,10 @@ namespace OpenChams {
}
void Circuit::readHBTree(xmlNode* node, Layout* layout) {
// HBTree node can have only one child (group or bloc)
// HBTree node can have only one child (group or bloc)
xmlNode* child = node->children;
if (child->type == XML_ELEMENT_NODE) {
// create root node
// create root node
// thanks to readNodeOrBloc
Node* root = readNodeOrBloc(child);
// save root node in layout
@ -1022,70 +1025,70 @@ namespace OpenChams {
}
Node* Circuit::readNodeOrBloc(xmlNode* node, Node* parent) {
// 1 - create Node based on xmlNode* passed as argument
// 1 - create Node based on xmlNode* passed as argument
if (node->type == XML_ELEMENT_NODE) {
bool isAGroup = xmlStrEqual(node->name, (xmlChar*)"group");
xmlChar* nameC = xmlGetProp(node, (xmlChar*)"name");
xmlChar* posiC = xmlGetProp(node, (xmlChar*)"position");
if (!nameC)
throw OpenChamsException("[ERROR] 'bloc' and 'group' nodes in 'hbtree' must have at least a 'name' property.");
throw OpenChamsException("[ERROR] 'bloc' and 'group' nodes in 'hbtree' must have at least a 'name' property.");
Node* nodeOC = NULL;
const std::string& name ((const char*)nameC);
Node::Position pos = Node::NONE;
if (posiC) {
string posStr ((const char*)posiC);
if (posStr == "right") pos = Node::RIGHT;
else if (posStr == "top") pos = Node::TOP;
else throw OpenChamsException("[ERROR] 'position' property of 'bloc' and 'group' nodes must be 'right' or 'top'.");
string posStr ((const char*)posiC);
if (posStr == "right") pos = Node::RIGHT;
else if (posStr == "top") pos = Node::TOP;
else throw OpenChamsException("[ERROR] 'position' property of 'bloc' and 'group' nodes must be 'right' or 'top'.");
}
if (isAGroup) {
Group* groupOC = new Group(name, pos, parent);
xmlChar* isolatC = xmlGetProp(node, (xmlChar*)"isolation");
xmlChar* alignC = xmlGetProp(node, (xmlChar*)"align");
xmlChar* pairedC = xmlGetProp(node, (xmlChar*)"paired");
if (isolatC) {
string isolation ((const char*)isolatC);
if (isolation == "true") groupOC->setIsolated(true);
else if (isolation == "false") groupOC->setIsolated(false);
else throw OpenChamsException("[ERROR] 'isolation' property of 'group' node must be 'true' or 'false'.");
}
if (alignC) {
string align ((const char*)alignC);
Group::Align galign = Group::NONE;
if (align == "vertical") galign = Group::VERTICAL;
else if (align == "horizontal") galign = Group::HORIZONTAL;
else throw OpenChamsException("[ERROR] 'align' property of 'group' node must be 'vertical' or 'horizontal'.");
groupOC->setAlign(galign);
}
if (pairedC) {
string paired ((const char*)pairedC);
if (paired == "true") groupOC->setPaired(true);
else if (paired == "false") groupOC->setPaired(false);
else throw OpenChamsException("[ERROR] 'paired' property of 'group' node must be 'true' or 'false'.");
}
nodeOC = groupOC;
Group* groupOC = new Group(name, pos, parent);
xmlChar* isolatC = xmlGetProp(node, (xmlChar*)"isolation");
xmlChar* alignC = xmlGetProp(node, (xmlChar*)"align");
xmlChar* pairedC = xmlGetProp(node, (xmlChar*)"paired");
if (isolatC) {
string isolation ((const char*)isolatC);
if (isolation == "true") groupOC->setIsolated(true);
else if (isolation == "false") groupOC->setIsolated(false);
else throw OpenChamsException("[ERROR] 'isolation' property of 'group' node must be 'true' or 'false'.");
}
if (alignC) {
string align ((const char*)alignC);
Group::Align galign = Group::NONE;
if (align == "vertical") galign = Group::VERTICAL;
else if (align == "horizontal") galign = Group::HORIZONTAL;
else throw OpenChamsException("[ERROR] 'align' property of 'group' node must be 'vertical' or 'horizontal'.");
groupOC->setAlign(galign);
}
if (pairedC) {
string paired ((const char*)pairedC);
if (paired == "true") groupOC->setPaired(true);
else if (paired == "false") groupOC->setPaired(false);
else throw OpenChamsException("[ERROR] 'paired' property of 'group' node must be 'true' or 'false'.");
}
nodeOC = groupOC;
} else {
nodeOC = new Bloc(name, pos, parent);
nodeOC = new Bloc(name, pos, parent);
}
// 2 - for each children (up to 2) readNodeOrBloc
// 2 - for each children (up to 2) readNodeOrBloc
for (xmlNode* child = node->children; child; child = child->next) {
if (child->type == XML_ELEMENT_NODE) {
Node* childOC = readNodeOrBloc(child, nodeOC);
// 3 - add to returned Node* to current Node* as right or top children (based on its position)
switch(childOC->getPosition()) {
case Node::RIGHT:
nodeOC->setRight(childOC);
break;
case Node::TOP:
nodeOC->setTop(childOC);
break;
case Node::NONE:
if (!isAGroup)
throw OpenChamsException("[ERROR] a 'bloc' or 'group' without position is only allowed directly under a 'group'.");
Group* groupOC = dynamic_cast<Group*>(nodeOC);
groupOC->setRootNode(childOC);
}
}
if (child->type == XML_ELEMENT_NODE) {
Node* childOC = readNodeOrBloc(child, nodeOC);
// 3 - add to returned Node* to current Node* as right or top children (based on its position)
switch(childOC->getPosition()) {
case Node::RIGHT:
nodeOC->setRight(childOC);
break;
case Node::TOP:
nodeOC->setTop(childOC);
break;
case Node::NONE:
if (!isAGroup)
throw OpenChamsException("[ERROR] a 'bloc' or 'group' without position is only allowed directly under a 'group'.");
Group* groupOC = dynamic_cast<Group*>(nodeOC);
groupOC->setRootNode(childOC);
}
}
}
// 4 - return current Node
return nodeOC;
@ -1103,6 +1106,254 @@ namespace OpenChams {
_absolutePath = _absolutePath.substr(0, found);
}
// SLICINGTREE //
void Circuit::readSlicingTree(xmlNode* node) {
if (readSlicingTreeDone) {
cerr << "[WARNING] Only one 'slicingtree' is allowed in circuit, others will be ignored." << endl;
return;
}
_slicingtree = readSlicingNode(node);
readSlicingTreeDone = true;
}
SlicingNode* Circuit::readSlicingNode(xmlNode* xnode, SlicingNode* slicingNode) {
SlicingNode* snode = NULL;
xmlNode* child = xnode->children;
for (xmlNode* node = child; node; node = node->next) {
if (node->type == XML_ELEMENT_NODE) {
if (xmlStrEqual(node->name , (xmlChar*)"vertical" )) {
snode = createVerticalSlicingNode (node, slicingNode);
} else if (xmlStrEqual(node->name , (xmlChar*)"horizontal")) {
snode = createHorizontalSlicingNode(node, slicingNode);
} else if (xmlStrEqual(node->name , (xmlChar*)"device" )) {
snode = createDeviceSlicingNode (node, slicingNode);
} else if (xmlStrEqual(node->name , (xmlChar*)"routing" )) {
snode = createRoutingSlicingNode (node, slicingNode);
} else if (!xmlStrEqual(node->name, (xmlChar*)"comment" )) {
cerr << "[WARNING] Unknown " << node->name << " node in 'slicingtree' section, it will be ignored." << endl;
}
}
}
return snode;
}
VSlicingNode* Circuit::createVerticalSlicingNode (xmlNode* xnode, SlicingNode* slicingNode) {
VSlicingNode* vnode = VSlicingNode::create(slicingNode);
xmlNode* child = xnode->children;
for (xmlNode* node = child; node; node = node->next) {
if (xmlStrEqual(node->name , (xmlChar*)"parameters")) {
setHVParameters(node, vnode);
} else if (xmlStrEqual(node->name, (xmlChar*)"symmetries")) {
setHVSymmetries(node, vnode);
} else if (xmlStrEqual(node->name, (xmlChar*)"children" )) {
addChildren(node, vnode);
} else if (!xmlStrEqual(node->name,(xmlChar*)"comment" )) {
cerr << "[WARNING] Unknown " << node->name << " node in 'vertical' section, it will be ignored." << endl;
}
}
return vnode;
}
HSlicingNode* Circuit::createHorizontalSlicingNode (xmlNode* xnode, SlicingNode* slicingNode) {
HSlicingNode* hnode = HSlicingNode::create(slicingNode);
xmlNode* child = xnode->children;
for (xmlNode* node = child; node; node = node->next) {
if (xmlStrEqual(node->name, (xmlChar*)"children")) {
addChildren(node, hnode);
} else if (xmlStrEqual(node->name , (xmlChar*)"parameters")) {
setHVParameters(node, hnode);
} else if (xmlStrEqual(node->name , (xmlChar*)"symmetries")) {
setHVSymmetries(node, hnode);
} else if (!xmlStrEqual(node->name, (xmlChar*)"comment" )){
cerr << "[WARNING] Unknown " << node->name << " node in 'horizontal' section, it will be ignored." << endl;
}
}
return hnode;
}
void Circuit::addChildren (xmlNode* xnode, HVSlicingNode* hvnode) {
xmlNode* child = xnode->children;
for (xmlNode* node = child; node; node = node->next) {
if (node->type == XML_ELEMENT_NODE) {
if (xmlStrEqual(node->name , (xmlChar*)"vertical" )) {
hvnode->push_back(createVerticalSlicingNode (node, hvnode));
} else if (xmlStrEqual(node->name , (xmlChar*)"horizontal")) {
hvnode->push_back(createHorizontalSlicingNode(node, hvnode));
} else if (xmlStrEqual(node->name , (xmlChar*)"device" )) {
hvnode->push_back(createDeviceSlicingNode (node, hvnode));
} else if (xmlStrEqual(node->name , (xmlChar*)"routing" )) {
hvnode->push_back(createRoutingSlicingNode (node, hvnode));
} else if (!xmlStrEqual(node->name, (xmlChar*)"comment" )){
cerr << "[WARNING] Unknown " << node->name << " node in 'slicingtree' section, it will be ignored." << endl;
}
}
}
}
void Circuit::setHVParameters (xmlNode* xnode, HVSlicingNode* hvnode) {
bool toleranceRatioHSet = false;
bool toleranceRatioWSet = false;
bool toleranceBandHSet = false;
bool toleranceBandWSet = false;
xmlNode* child = xnode->children;
for (xmlNode* node = child; node; node = node->next) {
xmlChar* typeC = xmlGetProp(node, (xmlChar*)"type");
if (typeC) {
string type ((const char*)typeC);
if (type == "alignment") {
xmlChar* alignmentC = xmlGetProp(node, (xmlChar*)"alignment");
if (alignmentC){
string alignment ((const char*)alignmentC);
hvnode->setAlignment(alignment);
}
} else if (type == "toleranceBandH") {
xmlChar* toleranceBandHC = xmlGetProp(node, (xmlChar*)"toleranceBandH");
if (toleranceBandHC){
string toleranceBandH ((const char*)toleranceBandHC);
hvnode->setToleranceBandH(toleranceBandH);
toleranceBandHSet = true;
}
} else if (type == "toleranceBandW") {
xmlChar* toleranceBandWC = xmlGetProp(node, (xmlChar*)"toleranceBandW");
if (toleranceBandWC){
string toleranceBandW ((const char*)toleranceBandWC);
hvnode->setToleranceBandW(toleranceBandW);
toleranceBandWSet = true;
}
} else if (type == "toleranceRatioH") {
xmlChar* toleranceRatioHC = xmlGetProp(node, (xmlChar*)"toleranceRatioH");
if (toleranceRatioHC){
string toleranceRatioH ((const char*)toleranceRatioHC);
hvnode->setToleranceRatioH(toleranceRatioH);
toleranceRatioHSet = true;
}
} else if (type == "toleranceRatioW") {
xmlChar* toleranceRatioWC = xmlGetProp(node, (xmlChar*)"toleranceRatioW");
if (toleranceRatioWC){
string toleranceRatioW ((const char*)toleranceRatioWC);
hvnode->setToleranceRatioW(toleranceRatioW);
toleranceRatioWSet = true;
}
} else if (!xmlStrEqual(node->name, (xmlChar*)"comment" )){
cerr << "[WARNING] Unknown " << node->name << " node in 'HVparameters' section, it will be ignored." << endl;
}
}
}
if (!hvnode->isRoot()){
if (!toleranceRatioHSet){
hvnode->setToleranceRatioH(hvnode->getParent()->getToleranceRatioH());
}
if (!toleranceRatioWSet){
hvnode->setToleranceRatioW(hvnode->getParent()->getToleranceRatioW());
}
if (!toleranceBandHSet){
hvnode->setToleranceBandH(hvnode->getParent()->getToleranceBandH());
}
if (!toleranceBandWSet){
hvnode->setToleranceBandW(hvnode->getParent()->getToleranceBandW());
}
}
}
void Circuit::setHVSymmetries (xmlNode* xnode, HVSlicingNode* hvnode) {
xmlNode* child = xnode->children;
for (xmlNode* node = child; node; node = node->next) {
xmlChar* sourceC = xmlGetProp(node, (xmlChar*)"source");
xmlChar* targetC = xmlGetProp(node, (xmlChar*)"target");
if ((sourceC)&&(targetC)) {
string source ((const char*)sourceC);
string target ((const char*)targetC);
hvnode->addSymmetry(source, target);
} else if (!xmlStrEqual(node->name, (xmlChar*)"comment" )){
cerr << "[WARNING] Unknown " << node->name << " node in 'HVsymmetries' section, it will be ignored." << endl;
}
}
}
DSlicingNode* Circuit::createDeviceSlicingNode (xmlNode* xnode, SlicingNode* slicingNode) {
DSlicingNode* dnode = NULL;
xmlChar* instanceNameC = xmlGetProp(xnode, (xmlChar*)"instance");
if (instanceNameC){
string instanceName ((const char*)instanceNameC);
dnode = DSlicingNode::create( instanceName, slicingNode );
xmlNode* child = xnode->children;
for (xmlNode* node = child; node; node = node->next) {
xmlChar* typeC = xmlGetProp(node, (xmlChar*)"type");
if (typeC) {
string type ((const char*)typeC);
if (type == "alignment") {
xmlChar* alignmentC = xmlGetProp(node, (xmlChar*)"alignment");
if (alignmentC){
string alignment ((const char*)alignmentC);
dnode->setAlignment(alignment);
}
} else if (type == "preset") {
xmlChar* presetC = xmlGetProp(node, (xmlChar*)"preset");
if (presetC){
string preset ((const char*)presetC);
dnode->setPreset(preset);
}
} else if (type == "nfing") {
xmlChar* nfingC = xmlGetProp(node, (xmlChar*)"nfing");
if (nfingC){
string nfing ((const char*)nfingC);
dnode->setNFing(nfing);
}
} else if (type == "x") {
xmlChar* xC = xmlGetProp(node, (xmlChar*)"x");
if (xC){
string x ((const char*)xC);
dnode->setX(x);
}
} else if (type == "y") {
xmlChar* yC = xmlGetProp(node, (xmlChar*)"y");
if (yC){
string y ((const char*)yC);
dnode->setY(y);
}
} else if (type == "nodeSets") {
xmlChar* startC = xmlGetProp(node, (xmlChar*)"start");
xmlChar* stepC = xmlGetProp(node, (xmlChar*)"step");
xmlChar* countC = xmlGetProp(node, (xmlChar*)"count");
if ( (startC) && (stepC) && (countC) ){
string start ((const char*)startC);
string step ((const char*)stepC);
string count ((const char*)countC);
dnode->setStart(start);
dnode->setStep (step);
dnode->setCount(count);
}
} else
cerr << "[WARNING] Unknown " << type << " type in 'device/parameter' section, it will be ignored." << endl;
} else if (!xmlStrEqual(node->name, (xmlChar*)"comment" )){
cerr << "[WARNING] Unknown " << node->name << " node in 'device' section, it will be ignored." << endl;
}
}
}
return dnode;
}
RSlicingNode* Circuit::createRoutingSlicingNode (xmlNode* xnode, SlicingNode* slicingNode) {
RSlicingNode* rnode = NULL;
xmlChar* valueC = xmlGetProp(xnode, (xmlChar*)"value");
if (valueC){
string value ((const char*)valueC);
rnode = RSlicingNode::create(value, slicingNode);
}
return rnode;
}
Circuit* Circuit::readFromFile(const string filePath) {
LIBXML_TEST_VERSION;
Circuit* cir = NULL;
@ -1112,7 +1363,7 @@ namespace OpenChams {
string error ("[ERROR] Failed to parse: ");
error += filePath;
throw OpenChamsException(error);
//return NULL;
//return NULL;
}
xmlNode* rootElement = xmlDocGetRootElement(doc);
if (rootElement->type == XML_ELEMENT_NODE && xmlStrEqual(rootElement->name, (xmlChar*)"circuit")) {
@ -1120,47 +1371,50 @@ namespace OpenChams {
xmlChar* technoNameC = xmlGetProp(rootElement, (xmlChar*)"techno");
if (circuitNameC && technoNameC) {
const std::string& circuitName ((const char*)circuitNameC);
const std::string& technoName ((const char*)technoNameC);
cir = new Circuit(circuitName, technoName);
const std::string& circuitName ((const char*)circuitNameC);
const std::string& technoName ((const char*)technoNameC);
cir = new Circuit(circuitName, technoName);
} else {
throw OpenChamsException("[ERROR] 'circuit' node must have 'name' and 'techno' properties.");
return NULL;
throw OpenChamsException("[ERROR] 'circuit' node must have 'name' and 'techno' properties.");
return NULL;
}
cir->setAbsolutePath(filePath);
xmlNode* child = rootElement->children;
for (xmlNode* node = child; node; node = node->next) {
if (node->type == XML_ELEMENT_NODE) {
if (xmlStrEqual(node->name, (xmlChar*)"subCircuitsPaths")) {
cir->readSubCircuitsPaths(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"parameters")) {
cir->readCircuitParameters(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"simulModels")) {
cir->readSimulModels(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"netlist")) {
cir->readNetList(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"schematic")) {
cir->readSchematic(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"sizing")) {
cir->readSizing(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"layout")) {
cir->readLayout(node);
}
else {
string error("[ERROR] Unknown section ");
error += string((const char*)node->name);
error += " in circuit description.";
throw OpenChamsException(error);
return NULL;
}
}
if (node->type == XML_ELEMENT_NODE) {
if (xmlStrEqual(node->name, (xmlChar*)"subCircuitsPaths")) {
cir->readSubCircuitsPaths(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"parameters")) {
cir->readCircuitParameters(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"simulModels")) {
cir->readSimulModels(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"netlist")) {
cir->readNetList(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"schematic")) {
cir->readSchematic(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"sizing")) {
cir->readSizing(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"layout")) {
cir->readLayout(node);
}
else if (xmlStrEqual(node->name, (xmlChar*)"slicingtree")) {
cir->readSlicingTree(node);
}
else {
string error("[ERROR] Unknown section ");
error += string((const char*)node->name);
error += " in circuit description.";
throw OpenChamsException(error);
return NULL;
}
}
}
}
if (!readNetListDone) {
@ -1213,6 +1467,16 @@ namespace OpenChams {
return _layout;
}
void Circuit::setSlicingTree( SlicingNode* slicingtree ) {
if (_slicingtree)
throw OpenChamsException("[ERROR] Cannot create two slicing trees in one circuit.");
_slicingtree = slicingtree;
if (!_slicingtree)
throw OpenChamsException("[ERROR] Cannot create slicingtree.");
}
void Circuit::driveHBTree(ofstream& file, Node* node, unsigned indent) {
if (!node) return;
for (unsigned i = 0 ; i < indent ; i++)
@ -1233,16 +1497,16 @@ namespace OpenChams {
if (bloc) {
file << "<bloc name=\"" << bloc->getName() << "\"";
if (pos != "")
file << " position=\"" << pos << "\"";
file << " position=\"" << pos << "\"";
if (bloc->getTop() == NULL && bloc->getRight() == NULL)
file << "/>" << endl;
file << "/>" << endl;
else {
file << ">" << endl;
driveHBTree(file, bloc->getTop() , indent+1);
driveHBTree(file, bloc->getRight(), indent+1);
for (unsigned i = 0 ; i < indent ; i++)
file << " ";
file << "</bloc>" << endl;
file << ">" << endl;
driveHBTree(file, bloc->getTop() , indent+1);
driveHBTree(file, bloc->getRight(), indent+1);
for (unsigned i = 0 ; i < indent ; i++)
file << " ";
file << "</bloc>" << endl;
}
return;
}
@ -1275,6 +1539,17 @@ namespace OpenChams {
}
}
void Circuit::driveSlicingTree(ofstream& file, SlicingNode* snode, unsigned indent) {
if (!snode) return;
for (unsigned i = 0 ; i < indent ; i++){ file << " "; }
file << "<slicingtree>" << endl;
snode->toXML(file, indent+1);
for (unsigned i = 0 ; i < indent ; i++){ file << " "; }
file << "</slicingtree>" << endl;
}
bool Circuit::writeToFile(string filePath) {
ofstream file;
file.open(filePath.c_str());
@ -1284,21 +1559,21 @@ namespace OpenChams {
error += " for writing.";
throw OpenChamsException(error);
}
// checks before do anything
// checks before do anything
if (!_netlist) {
//cerr << "no netlist" << endl; cerr.flush();
//cerr << "no netlist" << endl; cerr.flush();
throw OpenChamsException("[ERROR] Cannot writeToFile since no netlist is defined !");
//return false;
//return false;
}
if (_netlist->hasNoInstances()) {
//cerr << "no instances" << endl; cerr.flush();
//cerr << "no instances" << endl; cerr.flush();
throw OpenChamsException("[ERROR] Cannot writeToFile since no instance is defined in netlist !");
//return false;
//return false;
}
if (_netlist->hasNoNets()) {
//cerr << "no nets" << endl; cerr.flush();
//cerr << "no nets" << endl; cerr.flush();
throw OpenChamsException("[ERROR] Cannot writeToFile since no net is defined in netlist !");
//return false;
//return false;
}
file << "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>" << endl
@ -1306,7 +1581,7 @@ namespace OpenChams {
if (_subCircuitsPaths.size() != 0) {
file << " <subCircuitsPaths>" << endl;
for (size_t i = 0 ; i < _subCircuitsPaths.size() ; i++ ) {
file << " <path path=\"" << _subCircuitsPaths[i] << "\"/>" << endl;
file << " <path path=\"" << _subCircuitsPaths[i] << "\"/>" << endl;
}
file << " </subCircuitsPaths>" << endl;
}
@ -1315,7 +1590,7 @@ namespace OpenChams {
for (map<string,string>::const_iterator it = _params.getValues().begin() ; it != _params.getValues().end() ; ++it) {
file << " <parameter name=\"" << (*it).first << "\" value=\"" << (*it).second << "\"/>" << endl;
}
//cerr << "_params.getValues().size() = " << _params.getValues().size() << endl;
//cerr << "_params.getValues().size() = " << _params.getValues().size() << endl;
file << " </parameters>" << endl;
}
file << " <netlist>" << endl
@ -1326,46 +1601,46 @@ namespace OpenChams {
Instance* inst = (*it);
Device* dev = dynamic_cast<Device*>(inst);
if (inst->hasNoConnectors()) {
string error("[ERROR] Cannot writeToFile since instance (");
error += inst->getName();
error += ") has no connectors !";
throw OpenChamsException(error);
//return false;
string error("[ERROR] Cannot writeToFile since instance (");
error += inst->getName();
error += ") has no connectors !";
throw OpenChamsException(error);
//return false;
}
if (dev && dev->hasNoTransistors()) {
string error("[ERROR] Cannot writeToFile since device instance (");
error += dev->getName();
error += ") has no transistors !";
throw OpenChamsException(error);
string error("[ERROR] Cannot writeToFile since device instance (");
error += dev->getName();
error += ") has no transistors !";
throw OpenChamsException(error);
}
if (dev) {
string sourceBulkStr = (dev->isSourceBulkConnected()) ? "True" : "False";
file << " <instance name=\"" << dev->getName() << "\" model=\"" << dev->getModel() << "\" mostype=\"" << dev->getMosType() << "\" sourceBulkConnected=\"" << sourceBulkStr << "\" order=\"" << dev->getOrder() << "\">" << endl;
string sourceBulkStr = (dev->isSourceBulkConnected()) ? "True" : "False";
file << " <instance name=\"" << dev->getName() << "\" model=\"" << dev->getModel() << "\" mostype=\"" << dev->getMosType() << "\" sourceBulkConnected=\"" << sourceBulkStr << "\" order=\"" << dev->getOrder() << "\">" << endl;
} else {
file << " <instance name=\"" << inst->getName() << "\" model=\"" << inst->getModel() << "\" order=\"" << inst->getOrder() << "\">" << endl;
file << " <instance name=\"" << inst->getName() << "\" model=\"" << inst->getModel() << "\" order=\"" << inst->getOrder() << "\">" << endl;
}
file << " <connectors>" << endl;
for (map<string, Net*>::const_iterator it = inst->getConnectors().begin() ; it != inst->getConnectors().end() ; ++it) {
file << " <connector name=\"" << (*it).first << "\"/>" << endl;
file << " <connector name=\"" << (*it).first << "\"/>" << endl;
}
file << " </connectors>" << endl;
if (dev) {
file << " <transistors>" << endl;
for (vector<Transistor*>::const_iterator it = dev->getTransistors().begin() ; it != dev->getTransistors().end() ; ++it ) {
Transistor* tr = (*it);
file << " <transistor name=\"" << tr->getName() << "\">" << endl
<< " <connection gate=\"" << tr->getGate() << "\" source=\"" << tr->getSource() << "\" drain=\"" << tr->getDrain() << "\" bulk=\"" << tr->getBulk() << "\"/>" << endl
<< " </transistor>" << endl;
}
file << " </transistors>" << endl;
file << " <transistors>" << endl;
for (vector<Transistor*>::const_iterator it = dev->getTransistors().begin() ; it != dev->getTransistors().end() ; ++it ) {
Transistor* tr = (*it);
file << " <transistor name=\"" << tr->getName() << "\">" << endl
<< " <connection gate=\"" << tr->getGate() << "\" source=\"" << tr->getSource() << "\" drain=\"" << tr->getDrain() << "\" bulk=\"" << tr->getBulk() << "\"/>" << endl
<< " </transistor>" << endl;
}
file << " </transistors>" << endl;
}
if (!inst->getParameters().isEmpty()) {
Parameters params = inst->getParameters();
file << " <parameters>" << endl;
for (map<string,string>::const_iterator it = params.getValues().begin() ; it != params.getValues().end() ; ++it) {
file << " <parameter name=\"" << (*it).first << "\" value=\"" << (*it).second << "\"/>" << endl;
}
file << " </parameters>" << endl;
Parameters params = inst->getParameters();
file << " <parameters>" << endl;
for (map<string,string>::const_iterator it = params.getValues().begin() ; it != params.getValues().end() ; ++it) {
file << " <parameter name=\"" << (*it).first << "\" value=\"" << (*it).second << "\"/>" << endl;
}
file << " </parameters>" << endl;
}
file << " </instance>" << endl;
}
@ -1377,20 +1652,20 @@ namespace OpenChams {
for (vector<Net*>::iterator it = nets.begin() ; it != nets.end() ; ++it) {
Net* net = (*it);
if (net->hasNoConnections()) {
string error("[ERROR] Cannot writeToFile since net (");
error += net->getName();
error += ") has no connectors !";
throw OpenChamsException(error);
//return false;
string error("[ERROR] Cannot writeToFile since net (");
error += net->getName();
error += ") has no connectors !";
throw OpenChamsException(error);
//return false;
}
if (!net->hasNoPorts() || !net->hasNoWires())
schematicNets = true;
schematicNets = true;
string externStr = (net->isExternal()) ? "True" : "False";
file << " <net name=\"" << net->getName() << "\" type=\"" << net->getType() << "\" isExternal=\"" << externStr << "\">" << endl;
vector<Net::Connection*> connections = net->getConnections();
sort(connections.begin(), connections.end(), ConnectionsSort);
for (vector<Net::Connection*>::iterator it = connections.begin() ; it != connections.end() ; ++it) {
file << " <connector instance=\"" << (*it)->getInstanceName() << "\" name=\"" << (*it)->getConnectorName() << "\"/>" << endl;
file << " <connector instance=\"" << (*it)->getInstanceName() << "\" name=\"" << (*it)->getConnectorName() << "\"/>" << endl;
}
file << " </net>" << endl;
}
@ -1399,119 +1674,119 @@ namespace OpenChams {
if (_schematic && !_schematic->hasNoInstances()) {
file << " <schematic>" << endl;
for (map<string, Schematic::Infos*>::const_iterator it = _schematic->getInstances().begin() ; it != _schematic->getInstances().end(); ++it ) {
Schematic::Infos* infos = (*it).second;
file << " <instance name=\"" << ((*it).first) << "\" x=\"" << infos->getX() << "\" y=\"" << infos->getY() << "\" orient=\"" << infos->getOrientation() << "\"/>" << endl;
Schematic::Infos* infos = (*it).second;
file << " <instance name=\"" << ((*it).first) << "\" x=\"" << infos->getX() << "\" y=\"" << infos->getY() << "\" orient=\"" << infos->getOrientation() << "\"/>" << endl;
}
if (schematicNets) {
for (size_t i = 0 ; i < nets.size() ; i++) {
Net* net = nets[i];
if (net->hasNoPorts() && net->hasNoWires())
continue;
file << " <net name=\"" << net->getName() << "\">" << endl;
for (size_t j = 0 ; j < net->getPorts().size() ; j++) {
Port* port = net->getPorts()[j];
if (!port)
continue;
file << " <port type=\"" << port->getType() << "\" idx=\"" << port->getIndex() << "\" x=\"" << port->getX() << "\" y=\"" << port->getY() << "\" orient=\"" << port->getOrientation() << "\"/>" << endl;
}
for (size_t j = 0 ; j < net->getWires().size() ; j++) {
Wire* wire = net->getWires()[j];
file << " <wire>" << endl;
WirePoint* start = wire->getStartPoint();
WirePoint* end = wire->getEndPoint();
// start point
if (dynamic_cast<InstancePoint*>(start)) {
InstancePoint* iP = static_cast<InstancePoint*>(start);
file << " <connector name=\"" << iP->getName() << "\" plug=\"" << iP->getPlug() << "\"/>" << endl;
} else if (dynamic_cast<PortPoint*>(start)) {
PortPoint* pP = static_cast<PortPoint*>(start);
file << " <connector idx=\"" << pP->getIndex() << "\"/>" << endl;
} else {
throw OpenChamsException("[ERROR] Wire start point is nor an InstancePoint nor a PortPoint.");
}
// intermediate points
for (size_t k = 0 ; k < wire->getIntermediatePoints().size() ; k++) {
IntermediatePoint* iP = wire->getIntermediatePoints()[k];
file << " <point x=\"" << iP->getX() << "\" y=\"" << iP->getY() << "\"/>" << endl;
}
// end point
if (dynamic_cast<InstancePoint*>(end)) {
InstancePoint* iP = static_cast<InstancePoint*>(end);
file << " <connector name=\"" << iP->getName() << "\" plug=\"" << iP->getPlug() << "\"/>" << endl;
} else if (dynamic_cast<PortPoint*>(end)) {
PortPoint* pP = static_cast<PortPoint*>(end);
file << " <connector idx=\"" << pP->getIndex() << "\"/>" << endl;
} else {
throw OpenChamsException("[ERROR] Wire end point is nor an InstancePoint nor a PortPoint.");
}
file << " </wire>" << endl;
}
file << " </net>" << endl;
}
for (size_t i = 0 ; i < nets.size() ; i++) {
Net* net = nets[i];
if (net->hasNoPorts() && net->hasNoWires())
continue;
file << " <net name=\"" << net->getName() << "\">" << endl;
for (size_t j = 0 ; j < net->getPorts().size() ; j++) {
Port* port = net->getPorts()[j];
if (!port)
continue;
file << " <port type=\"" << port->getType() << "\" idx=\"" << port->getIndex() << "\" x=\"" << port->getX() << "\" y=\"" << port->getY() << "\" orient=\"" << port->getOrientation() << "\"/>" << endl;
}
for (size_t j = 0 ; j < net->getWires().size() ; j++) {
Wire* wire = net->getWires()[j];
file << " <wire>" << endl;
WirePoint* start = wire->getStartPoint();
WirePoint* end = wire->getEndPoint();
// start point
if (dynamic_cast<InstancePoint*>(start)) {
InstancePoint* iP = static_cast<InstancePoint*>(start);
file << " <connector name=\"" << iP->getName() << "\" plug=\"" << iP->getPlug() << "\"/>" << endl;
} else if (dynamic_cast<PortPoint*>(start)) {
PortPoint* pP = static_cast<PortPoint*>(start);
file << " <connector idx=\"" << pP->getIndex() << "\"/>" << endl;
} else {
throw OpenChamsException("[ERROR] Wire start point is nor an InstancePoint nor a PortPoint.");
}
// intermediate points
for (size_t k = 0 ; k < wire->getIntermediatePoints().size() ; k++) {
IntermediatePoint* iP = wire->getIntermediatePoints()[k];
file << " <point x=\"" << iP->getX() << "\" y=\"" << iP->getY() << "\"/>" << endl;
}
// end point
if (dynamic_cast<InstancePoint*>(end)) {
InstancePoint* iP = static_cast<InstancePoint*>(end);
file << " <connector name=\"" << iP->getName() << "\" plug=\"" << iP->getPlug() << "\"/>" << endl;
} else if (dynamic_cast<PortPoint*>(end)) {
PortPoint* pP = static_cast<PortPoint*>(end);
file << " <connector idx=\"" << pP->getIndex() << "\"/>" << endl;
} else {
throw OpenChamsException("[ERROR] Wire end point is nor an InstancePoint nor a PortPoint.");
}
file << " </wire>" << endl;
}
file << " </net>" << endl;
}
}
file << " </schematic>" << endl;
}
// SIZING (modified by Farakh) ***************************************************************
// SIZING (modified by Farakh) ***************************************************************
if(_sizing && (!_sizing->hasNoOperators() || !_sizing->hasNoEquations()) )
file << " <sizing>" << endl;
if (_sizing && !_sizing->hasNoOperators()) {
// file << " <sizing>" << endl;
// file << " <sizing>" << endl;
for (map<string, Operator*>::const_iterator it = _sizing->getOperators().begin() ; it != _sizing->getOperators().end() ; ++it) {
Operator* op = (*it).second;
string opName = op->getName();
transform(opName.begin(), opName.end(), opName.begin(), ::toupper);
file << " <instance name=\"" << ((*it).first) << "\" operator=\"" << opName << "\" simulModel=\"" << op->getSimulModel() << "\">" << endl;
if (!op->hasNoConstraints()) {
for (map<string, Operator::Constraint*>::const_iterator cit = op->getConstraints().begin() ; cit != op->getConstraints().end() ; ++cit) {
Operator::Constraint* cn = (*cit).second;
const std::string& ref = cn->getRef();
if (ref.empty()) {
file << " <constraint param=\"" << ((*cit).first) << "\" refEquation=\"" << cn->getRefParam() << "\" factor=\"" << cn->getFactor() << "\"/>" << endl;
} else {
file << " <constraint param=\"" << ((*cit).first) << "\" ref=\"" << cn->getRef() << "\" refParam=\"" << cn->getRefParam() << "\" factor=\"" << cn->getFactor() << "\"/>" << endl;
}
}
}
file << " </instance>" << endl;
Operator* op = (*it).second;
string opName = op->getName();
transform(opName.begin(), opName.end(), opName.begin(), ::toupper);
file << " <instance name=\"" << ((*it).first) << "\" operator=\"" << opName << "\" simulModel=\"" << op->getSimulModel() << "\">" << endl;
if (!op->hasNoConstraints()) {
for (map<string, Operator::Constraint*>::const_iterator cit = op->getConstraints().begin() ; cit != op->getConstraints().end() ; ++cit) {
Operator::Constraint* cn = (*cit).second;
const std::string& ref = cn->getRef();
if (ref.empty()) {
file << " <constraint param=\"" << ((*cit).first) << "\" refEquation=\"" << cn->getRefParam() << "\" factor=\"" << cn->getFactor() << "\"/>" << endl;
} else {
file << " <constraint param=\"" << ((*cit).first) << "\" ref=\"" << cn->getRef() << "\" refParam=\"" << cn->getRefParam() << "\" factor=\"" << cn->getFactor() << "\"/>" << endl;
}
}
}
file << " </instance>" << endl;
}
}
// EQUATIONS
// EQUATIONS
if (_sizing && !_sizing->hasNoEquations()) {
file << " <equations>" << endl;
// for (map<string, string>::const_iterator it = _sizing->getEquations().begin() ; it != _sizing->getEquations().end() ; ++it)
// file << " <eq name=\"" << ((*it).first) << "\" equation=\"" << (*it).second << "\"/>" << endl;
// for (map<string, string>::const_iterator it = _sizing->getEquations().begin() ; it != _sizing->getEquations().end() ; ++it)
// file << " <eq name=\"" << ((*it).first) << "\" equation=\"" << (*it).second << "\"/>" << endl;
file << " <cstr_designer>" << endl;
for(map<string, Equation*>::const_iterator it = _sizing->getEquations().begin() ; it != _sizing->getEquations().end() ; ++it) {
if(dynamic_cast<DesignerCstrOC*>((*it).second))
file << " <cstr_dsg name=\"" << ((*it).first) << "\" equation=\"" << (*it).second->getEquationStr()[0] << "\"/>" << endl;
if(dynamic_cast<DesignerCstrOC*>((*it).second))
file << " <cstr_dsg name=\"" << ((*it).first) << "\" equation=\"" << (*it).second->getEquationStr()[0] << "\"/>" << endl;
}
file << " </cstr_designer>" << endl;
file << " <cstr_circuit_level>" << endl;
for(map<string, Equation*>::const_iterator it = _sizing->getEquations().begin() ; it != _sizing->getEquations().end() ; ++it) {
if(dynamic_cast<HighLevelCstr*>((*it).second))
file << " <cstr_cl name=\"" << ((*it).first) << "\" equation=\"" << (*it).second->getEquationStr()[0] << "\"/>" << endl;
if(dynamic_cast<HighLevelCstr*>((*it).second))
file << " <cstr_cl name=\"" << ((*it).first) << "\" equation=\"" << (*it).second->getEquationStr()[0] << "\"/>" << endl;
}
file << " </cstr_circuit_level>" << endl;
file << " <nrc_cstr>" << endl;
for(map<string, Equation*>::const_iterator it = _sizing->getEquations().begin() ; it != _sizing->getEquations().end() ; ++it) {
if(dynamic_cast<NRCCstr*>((*it).second)) {
NRCCstr* nrcCstr = (NRCCstr*)((*it).second);
file << " <nrc name=\"" << ((*it).first) << "\" param=\"" << nrcCstr->getVoltage() << "\" equation=\"" << (*it).second->getEquationStr()[0] << "\"/>" << endl;
}
if(dynamic_cast<NRCCstr*>((*it).second)) {
NRCCstr* nrcCstr = (NRCCstr*)((*it).second);
file << " <nrc name=\"" << ((*it).first) << "\" param=\"" << nrcCstr->getVoltage() << "\" equation=\"" << (*it).second->getEquationStr()[0] << "\"/>" << endl;
}
}
file << " </nrc_cstr>" << endl;
file << " <ddps>" << endl;
for(map<string, Equation*>::const_iterator it = _sizing->getEquations().begin() ; it != _sizing->getEquations().end() ; ++it) {
if(dynamic_cast<DDP*>((*it).second)) {
file << " <ddp_i name=\"" << ((*it).first) << "\">" << endl;
for(map<int, string>::const_iterator it2 = (*it).second->getEquationStr().begin(); it2!=(*it).second->getEquationStr().end(); ++it2)
file << " <ddp_eq equation=\"" << (*it2).second << "\"/>" << endl;
file << " </ddp_i>" << endl;
}
if(dynamic_cast<DDP*>((*it).second)) {
file << " <ddp_i name=\"" << ((*it).first) << "\">" << endl;
for(map<int, string>::const_iterator it2 = (*it).second->getEquationStr().begin(); it2!=(*it).second->getEquationStr().end(); ++it2)
file << " <ddp_eq equation=\"" << (*it2).second << "\"/>" << endl;
file << " </ddp_i>" << endl;
}
}
file << " </ddps>" << endl;
@ -1520,22 +1795,29 @@ namespace OpenChams {
}
if(_sizing && (!_sizing->hasNoOperators() || !_sizing->hasNoEquations()) )
file << " </sizing>" << endl;
// *******************************************************************************************
// *******************************************************************************************
if (_layout) {
file << " <layout>" << endl;
if (!_layout->hasNoInstance()) {
for (map<string, string>::const_iterator it = _layout->getInstances().begin() ; it != _layout->getInstances().end() ; ++it) {
file << " <instance name=\"" << ((*it).first) << "\" style=\"" << ((*it).second) << "\"/>" << endl;
}
for (map<string, string>::const_iterator it = _layout->getInstances().begin() ; it != _layout->getInstances().end() ; ++it) {
file << " <instance name=\"" << ((*it).first) << "\" style=\"" << ((*it).second) << "\"/>" << endl;
}
}
if (Node* root = _layout->getHBTreeRoot()) {
file << " <hbtree>" << endl;
driveHBTree(file, root, 3);
file << " </hbtree>" << endl;
file << " <hbtree>" << endl;
driveHBTree(file, root, 3);
file << " </hbtree>" << endl;
}
file << " </layout>" << endl;
}
// *******************************************************************************************
if (_slicingtree) {
driveSlicingTree(file, _slicingtree, 1);
}
file << "</circuit>" << endl;
file.close();
return true;

1088
vlsisapd/src/openChams/src/SlicingTree.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

21
vlsisapd/src/openChams/src/vlsisapd/openChams/Circuit.h
View File

@ -2,13 +2,14 @@
// -*- C++ -*-
//
// This file is part of the VLSI SAPD Software.
// Copyright (c) UPMC/LIP6 2009-2012, All Rights Reserved
// Copyright (c) UPMC/LIP6 2009-2016, All Rights Reserved
//
// +-----------------------------------------------------------------+
// | V L S I S A P D |
// | OpenChams Circuit Data Base |
// | |
// | Author : Damien Dupuis |
// | Eric Lao |
// | E-mail : Jean-Paul.Chaput@lip6.fr |
// | =============================================================== |
// | C++ Header : "./vlsisapd/openChams/Circuit.h" |
@ -27,6 +28,7 @@
#include "vlsisapd/openChams/Parameters.h"
#include "vlsisapd/openChams/SimulModel.h"
#include "vlsisapd/openChams/SlicingTree.h"
namespace OpenChams {
@ -58,6 +60,7 @@ namespace OpenChams {
inline Parameters getParameters ();
inline void addSubCircuitPath ( std::string );
inline std::vector<std::string>& getSubCircuitPaths ();
inline SlicingNode* getSlicingTree ();
// Mutators.
void addSimulModel ( unsigned
, SimulModel::Base
@ -69,7 +72,9 @@ namespace OpenChams {
Schematic* createSchematic ();
Sizing* createSizing ();
Layout* createLayout ();
void setSlicingTree ( SlicingNode* slicingtree );
void driveHBTree ( std::ofstream&, Node*, unsigned );
void driveSlicingTree ( std::ofstream&, SlicingNode*, unsigned );
bool writeToFile ( std::string filePath );
static Circuit* readFromFile ( const std::string filePath );
@ -112,6 +117,17 @@ namespace OpenChams {
void readHBTree ( xmlNode*, Layout* );
Node* readNodeOrBloc ( xmlNode*, Node* parent = NULL );
void setAbsolutePath ( const std::string filePath );
// Slicingtree related XML methods.
void readSlicingTree ( xmlNode* );
SlicingNode* readSlicingNode ( xmlNode* xnode, SlicingNode* slicingNode = NULL );
VSlicingNode* createVerticalSlicingNode ( xmlNode* xnode, SlicingNode* slicingNode = NULL );
HSlicingNode* createHorizontalSlicingNode ( xmlNode* xnode, SlicingNode* slicingNode = NULL );
DSlicingNode* createDeviceSlicingNode ( xmlNode* xnode, SlicingNode* slicingNode = NULL );
RSlicingNode* createRoutingSlicingNode ( xmlNode* xnode, SlicingNode* slicingNode = NULL );
void addChildren ( xmlNode*, HVSlicingNode* );
void setHVParameters ( xmlNode*, HVSlicingNode* );
void setHVSymmetries ( xmlNode*, HVSlicingNode* );
// Utilities methods.
void check_uppercase ( std::string& str, std::vector<std::string>& compares, std::string message );
void check_lowercase ( std::string& str, std::vector<std::string>& compares, std::string message );
@ -127,6 +143,7 @@ namespace OpenChams {
Layout* _layout;
std::vector<std::string> _subCircuitsPaths;
std::map<unsigned, SimulModel*> _simulModels;
SlicingNode* _slicingtree;
};
@ -142,7 +159,7 @@ namespace OpenChams {
inline Parameters Circuit::getParameters () { return _params; }
inline void Circuit::addSubCircuitPath (std::string path) { _subCircuitsPaths.push_back(path); }
inline std::vector<std::string>& Circuit::getSubCircuitPaths () { return _subCircuitsPaths; }
inline SlicingNode* Circuit::getSlicingTree () { return _slicingtree; }
template<typename T>
inline std::string asString ( T value )

392
vlsisapd/src/openChams/src/vlsisapd/openChams/SlicingTree.h Normal file
View File

@ -0,0 +1,392 @@
// -*- C++ -*-
//
// This file is part of the VLSI SAPD Software.
// Copyright (c) UPMC/LIP6 2008-2016, All Rights Reserved
//
// +-----------------------------------------------------------------+
// | V L S I S A P D |
// | OpenChams Circuit Data Base |
// | |
// | Author : Eric Lao |
// | E-mail : Jean-Paul.Chaput@lip6.fr |
// | =============================================================== |
// | C++ Header : "./vlsisapd/openChams/SlicingTree.h" |
// +-----------------------------------------------------------------+
#ifndef __OPENCHAMS_SLICINGTREE_H__
#define __OPENCHAMS_SLICINGTREE_H__
#include <vector>
#include <list>
#include <string>
#include <iostream>
#include <sstream>
#include <fstream>
namespace OpenChams {
enum Flags { UnknownType = 1 << 0
, HorizontalSNode = 1 << 1
, VerticalSNode = 1 << 2
, DeviceSNode = 1 << 3
, RoutingSNode = 1 << 4
, UnknownAlignment = 1 << 5
, AlignLeft = 1 << 6
, AlignRight = 1 << 7
, AlignCenter = 1 << 8
, AlignTop = 1 << 9
, AlignBottom = 1 << 10
};
// -----------------------------------------------------------------------------------------------//
// Class : SlicingNode
// -----------------------------------------------------------------------------------------------//
class SlicingNode
{
public:
SlicingNode( SlicingNode* parent = NULL );
virtual ~SlicingNode(){};
public:
virtual unsigned int getType () const { return UnknownType; }
virtual void print () const {};
inline void recursiveDestroy ();
void setParent ( SlicingNode* parent );
SlicingNode* getParent () const;
inline bool isRoot () const;
virtual void setAlignment ( std::string alignment );
std::string alignmentToString() const;
//Error Methods
virtual std::string getInstanceName () const;
virtual unsigned int getAlignment () const;
virtual bool getPreset () const;
virtual double getX () const;
virtual double getY () const;
virtual int getNFing () const;
virtual double getStart () const;
virtual double getStep () const;
virtual double getCount () const;
virtual void setInstanceName ( std::string instanceName );
virtual void setPreset ( std::string preset );
virtual void setX ( std::string x );
virtual void setY ( std::string y );
virtual void setNFing ( std::string nfing );
virtual void setStart ( std::string start );
virtual void setStep ( std::string step );
virtual void setCount ( std::string count );
virtual void setPreset ( bool preset );
virtual void setX ( double x );
virtual void setY ( double y );
virtual void setNFing ( int nfing );
virtual void setStart ( double start );
virtual void setStep ( double step );
virtual void setCount ( double count );
virtual const std::vector<SlicingNode*> getChildren () const;
virtual std::list<std::pair <int,int> > getSymmetries () const;
virtual double getToleranceRatioH() const;
virtual double getToleranceRatioW() const;
virtual double getToleranceBandH () const;
virtual double getToleranceBandW () const;
virtual void setToleranceRatioH( std::string value );
virtual void setToleranceRatioW( std::string value );
virtual void setToleranceBandH ( std::string value );
virtual void setToleranceBandW ( std::string value );
virtual void setToleranceRatioH( double value );
virtual void setToleranceRatioW( double value );
virtual void setToleranceBandH ( double value );
virtual void setToleranceBandW ( double value );
virtual void push_back ( SlicingNode* node );
virtual void addSymmetry ( std::string source, std::string target );
virtual void addSymmetry ( int source, int target );
virtual double getValue () const;
virtual void setValue ( std::string value );
virtual void toXML ( std::ofstream& file, unsigned indent ){};
virtual std::string presetToString () const;
virtual std::string xToString () const;
virtual std::string yToString () const;
virtual std::string nfingToString () const;
virtual std::string startToString () const;
virtual std::string stepToString () const;
virtual std::string countToString () const;
virtual std::string valueToString () const;
virtual std::string toleranceRatioHToString() const;
virtual std::string toleranceRatioWToString() const;
virtual std::string toleranceBandHToString () const;
virtual std::string toleranceBandWToString () const;
virtual bool hasSameParentToleranceRatioH () const;
virtual bool hasSameParentToleranceRatioW () const;
virtual bool hasSameParentToleranceBandH () const;
virtual bool hasSameParentToleranceBandW () const;
virtual bool checkInitialPlacement( int& cpt ) const;
virtual std::list<SlicingNode*> getLeaves () const;
protected:
SlicingNode* _parent;
unsigned int _alignment;
};
inline void SlicingNode::recursiveDestroy(){ delete(this); }
inline bool SlicingNode::isRoot () const { return (_parent == NULL); }
// -----------------------------------------------------------------------------------------------//
// Class : DeviceSNode
// -----------------------------------------------------------------------------------------------//
class DSlicingNode : public SlicingNode
{
private:
DSlicingNode( std::string instanceName, SlicingNode* parent = NULL );
~DSlicingNode(){};
public:
inline static DSlicingNode* create ( std::string instanceName, SlicingNode* parent = NULL );
inline std::string getInstanceName () const;
inline unsigned int getAlignment () const;
inline bool getPreset () const;
inline double getX () const;
inline double getY () const;
inline int getNFing () const;
inline double getStart () const;
inline double getStep () const;
inline double getCount () const;
inline unsigned int getType () const;
void setInstanceName ( std::string instanceName );
void setPreset ( std::string preset );
void setX ( std::string x );
void setY ( std::string y );
void setNFing ( std::string nfing );
void setStart ( std::string start );
void setStep ( std::string step );
void setCount ( std::string count );
inline void setPreset ( bool preset );
inline void setX ( double x );
inline void setY ( double y );
inline void setNFing ( int nfing );
inline void setStart ( double start );
inline void setStep ( double step );
inline void setCount ( double count );
void print () const;
void toXML ( std::ofstream& file, unsigned indent );
inline std::string presetToString () const;
inline std::string xToString () const;
inline std::string yToString () const;
inline std::string nfingToString () const;
inline std::string startToString () const;
inline std::string stepToString () const;
inline std::string countToString () const;
bool checkInitialPlacement ( int& cpt ) const;
private:
std::string _instanceName;
bool _preset;
double _x;
double _y;
int _nfing;
double _start;
double _step;
double _count;
};
inline DSlicingNode* DSlicingNode::create ( std::string instanceName, SlicingNode* parent ){ return new DSlicingNode( instanceName ); }
inline std::string DSlicingNode::getInstanceName () const { return _instanceName ; }
inline unsigned int DSlicingNode::getAlignment () const { return _alignment ; }
inline bool DSlicingNode::getPreset () const { return _preset ; }
inline double DSlicingNode::getX () const { return _x ; }
inline double DSlicingNode::getY () const { return _y ; }
inline int DSlicingNode::getNFing () const { return _nfing ; }
inline double DSlicingNode::getStart () const { return _start ; }
inline double DSlicingNode::getStep () const { return _step ; }
inline double DSlicingNode::getCount () const { return _count ; }
inline unsigned int DSlicingNode::getType () const { return DeviceSNode ; }
inline void DSlicingNode::setPreset ( bool preset ) { _preset = preset; }
inline void DSlicingNode::setX ( double x ) { _x = x ; }
inline void DSlicingNode::setY ( double y ) { _y = y ; }
inline void DSlicingNode::setNFing ( int nfing ) { _nfing = nfing ; }
inline void DSlicingNode::setStart ( double start ) { _start = start ; }
inline void DSlicingNode::setStep ( double step ) { _step = step ; }
inline void DSlicingNode::setCount ( double count ) { _count = count ; }
inline std::string DSlicingNode::presetToString () const { return _preset ? "true" : "false"; }
inline std::string DSlicingNode::xToString () const { return std::to_string(_x ); }
inline std::string DSlicingNode::yToString () const { return std::to_string(_y ); }
inline std::string DSlicingNode::nfingToString () const { return std::to_string(_nfing); }
inline std::string DSlicingNode::startToString () const { return std::to_string(_start); }
inline std::string DSlicingNode::stepToString () const { return std::to_string(_step ); }
inline std::string DSlicingNode::countToString () const { return std::to_string(_count); }
// -----------------------------------------------------------------------------------------------//
// Class : HVSlicingNode
// -----------------------------------------------------------------------------------------------//
class HVSlicingNode : public SlicingNode
{
protected:
HVSlicingNode( SlicingNode* parent = NULL );
virtual ~HVSlicingNode(){};
public:
inline unsigned int getAlignment () const;
inline double getToleranceRatioH() const;
inline double getToleranceRatioW() const;
inline double getToleranceBandH () const;
inline double getToleranceBandW () const;
inline const std::vector<SlicingNode*> getChildren () const;
inline std::list<std::pair <int,int> > getSymmetries () const;
void setToleranceRatioH( std::string value );
void setToleranceRatioW( std::string value );
void setToleranceBandH ( std::string value );
void setToleranceBandW ( std::string value );
void setToleranceRatioH( double value );
void setToleranceRatioW( double value );
void setToleranceBandH ( double value );
void setToleranceBandW ( double value );
void push_back ( SlicingNode* node );
void addSymmetry ( std::string source, std::string target );
void addSymmetry ( int source, int target );
void recursiveDestroy ();
void print () const;
inline std::string toleranceRatioHToString () const;
inline std::string toleranceRatioWToString () const;
inline std::string toleranceBandHToString () const;
inline std::string toleranceBandWToString () const;
bool hasSameParentToleranceRatioH () const;
bool hasSameParentToleranceRatioW () const;
bool hasSameParentToleranceBandH () const;
bool hasSameParentToleranceBandW () const;
bool checkInitialPlacement ( int& cpt ) const;
std::list<SlicingNode*> getLeaves () const;
protected:
double _toleranceRatioH;
double _toleranceRatioW;
double _toleranceBandH;
double _toleranceBandW;
std::list<std::pair <int,int> > _symmetries;
std::vector<SlicingNode*> _children;
};
inline unsigned int HVSlicingNode::getAlignment () const { return _alignment ; }
inline double HVSlicingNode::getToleranceRatioH() const { return _toleranceRatioH; }
inline double HVSlicingNode::getToleranceRatioW() const { return _toleranceRatioW; }
inline double HVSlicingNode::getToleranceBandH () const { return _toleranceBandH ; }
inline double HVSlicingNode::getToleranceBandW () const { return _toleranceBandW ; }
inline const std::vector<SlicingNode*> HVSlicingNode::getChildren () const { return _children ; }
inline std::list<std::pair<int,int> > HVSlicingNode::getSymmetries () const { return _symmetries ; }
inline std::string HVSlicingNode::toleranceRatioHToString() const { return std::to_string(_toleranceRatioH); }
inline std::string HVSlicingNode::toleranceRatioWToString() const { return std::to_string(_toleranceRatioW); }
inline std::string HVSlicingNode::toleranceBandHToString () const { return std::to_string(_toleranceBandH); }
inline std::string HVSlicingNode::toleranceBandWToString () const { return std::to_string(_toleranceBandW); }
// -----------------------------------------------------------------------------------------------//
// Class : HSlicingNode
// -----------------------------------------------------------------------------------------------//
class HSlicingNode: public HVSlicingNode
{
private:
HSlicingNode( SlicingNode* parent = NULL );
~HSlicingNode(){};
public:
inline static HSlicingNode* create ( SlicingNode* parent = NULL );
inline unsigned int getType () const;
void print () const;
void toXML ( std::ofstream& file, unsigned indent );
};
inline HSlicingNode* HSlicingNode::create ( SlicingNode* parent ){ return new HSlicingNode(parent); }
inline unsigned int HSlicingNode::getType() const { return HorizontalSNode ; }
// -----------------------------------------------------------------------------------------------//
// Class : VSlicingNode
// -----------------------------------------------------------------------------------------------//
class VSlicingNode: public HVSlicingNode
{
private:
VSlicingNode( SlicingNode* parent = NULL );
~VSlicingNode(){};
public:
inline static VSlicingNode* create ( SlicingNode* parent = NULL );
inline unsigned int getType () const;
void print () const;
void toXML ( std::ofstream& file, unsigned indent );
};
inline VSlicingNode* VSlicingNode::create ( SlicingNode* parent ){ return new VSlicingNode(parent); }
inline unsigned int VSlicingNode::getType() const { return VerticalSNode ; }
// -----------------------------------------------------------------------------------------------//
// Class : RoutingSNode
// -----------------------------------------------------------------------------------------------//
class RSlicingNode: public SlicingNode
{
private:
RSlicingNode( std::string value, SlicingNode* parent = NULL );
RSlicingNode( double value, SlicingNode* parent = NULL );
~RSlicingNode(){};
public:
inline static RSlicingNode* create ( std::string value, SlicingNode* parent = NULL );
inline static RSlicingNode* create ( double value, SlicingNode* parent = NULL );
inline void recursiveDestroy ();
inline double getValue () const;
void setValue ( std::string value );
inline unsigned int getType () const;
void print () const;
void setAlignment ( std::string alignment) {};
void toXML ( std::ofstream& file, unsigned indent );
inline std::string valueToString () const;
private:
double _value;
};
inline RSlicingNode* RSlicingNode::create ( std::string value, SlicingNode* parent ){ return new RSlicingNode( value, parent ); }
inline RSlicingNode* RSlicingNode::create ( double value, SlicingNode* parent ){ return new RSlicingNode( value, parent ); }
inline double RSlicingNode::getValue () const{ return _value ; }
inline unsigned int RSlicingNode::getType () const{ return RoutingSNode; }
inline std::string RSlicingNode::valueToString () const { return std::to_string(_value); }
} // OpenChams namespace
#endif