| /* |
| |
| Permission is hereby granted, free of charge, to any person |
| obtaining a copy of this software and associated documentation |
| files (the "Software"), to deal in the Software without |
| restriction, including without limitation the rights to use, |
| copy, modify, merge, publish, distribute, sublicense, and/or sell |
| copies of the Software, and to permit persons to whom the |
| Software is furnished to do so, subject to the following |
| conditions: |
| |
| The above copyright notice and this permission notice shall be |
| included in all copies or substantial portions of the Software. |
| |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES |
| OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
| HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| #include "container.h" |
| #include <time.h> |
| |
| Container::Container(ExplorerScene* scene) |
| { |
| myScene = scene; |
| maxlayer = 0; |
| maxcountPerLayer = 0; |
| myOdin = new OdinInterface(); |
| odinStarted = false; |
| simOffset = 0; |
| maxSimStep = 0; |
| actSimStep = 0; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: setFilename) |
| *-------------------------------------------------------------------------------------------*/ |
| void Container::setFilename(QString filename) |
| { |
| myFilename = filename; |
| myOdin->setFilename(filename); |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: addUnit) |
| *-------------------------------------------------------------------------------------------*/ |
| LogicUnit * Container::addUnit(QString name,LogicUnit::UnitType type, QPointF position, |
| nnode_t* odinRef) |
| { |
| LogicUnit* newUnit; |
| //create in scene |
| newUnit = myScene->addLogicUnit(name,type,position); |
| newUnit->setPos(position); |
| newUnit->setOdinRef(odinRef); |
| unithashtable[name] = newUnit; |
| unitcontainer.append(newUnit); |
| return newUnit; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: addModule) |
| *-------------------------------------------------------------------------------------------*/ |
| LogicUnit * Container::addModule(QString name) |
| { |
| LogicUnit* newUnit; |
| //create in scene |
| newUnit = myScene->addLogicUnit(name,LogicUnit::Module,QPointF(100,100)); |
| newUnit->setPos(QPointF(100,100)); |
| unithashtable[name] = newUnit; |
| unitcontainer.append(newUnit); |
| return newUnit; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: addConnectionHash) |
| *-------------------------------------------------------------------------------------------*/ |
| bool Container::addConnectionHash(QString start, QString end) |
| { |
| //do not connect modules with themself |
| if(start.compare(end) == 0) |
| return false; |
| |
| bool startFound = false; |
| bool endFound = false; |
| bool success = false; |
| LogicUnit *startUnit, *endUnit; |
| if(unithashtable.contains(start)){ |
| startUnit = unithashtable.value(start); |
| startFound = true; |
| } |
| if(unithashtable.contains(end)){ |
| endUnit = unithashtable.value(end); |
| endFound = true; |
| } |
| if(startFound && endFound){ |
| myScene->addConnection(startUnit, endUnit); |
| success = true; |
| } |
| return success; |
| |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: arrangeContainer) |
| *-------------------------------------------------------------------------------------------*/ |
| //arrange the modules according to their layer. |
| //at the moment wire crossing is not considered |
| void Container::arrangeContainer() |
| { |
| computeLayers(); |
| spreadLayers(); |
| myScene->setSceneRect(0,0,1000.0+400*maxlayer+maxcountPerLayer*50,1000.0+400*maxcountPerLayer); |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: deleteModule) |
| *-------------------------------------------------------------------------------------------*/ |
| void Container::deleteModule(QString name) |
| { |
| for(int i = 0;i<unitcontainer.count();i++){ |
| LogicUnit *temp = unitcontainer.at(i); |
| if(temp->getName().compare(name)==0){ |
| unitcontainer.removeAt(i); |
| } |
| } |
| if(unithashtable.contains(name)) |
| unithashtable.remove(name); |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: clearContainer) |
| *-------------------------------------------------------------------------------------------*/ |
| //delete everything in the container |
| void Container::clearContainer() |
| { |
| while(!unitcontainer.empty()){ |
| unitcontainer.removeFirst(); |
| } |
| unithashtable.clear(); |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: setLayer) |
| *-------------------------------------------------------------------------------------------*/ |
| void Container::setLayer(QString unitName, int layercount){ |
| QString actName; |
| |
| foreach (LogicUnit *actUnit, unitcontainer) { |
| actName = actUnit->getName(); |
| if(actName.compare(unitName)==0){ |
| if(layercount > actUnit->getLayer()){ |
| actUnit->setLayer(layercount); |
| } |
| } |
| } |
| |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: computeLayersHash) |
| *-------------------------------------------------------------------------------------------*/ |
| //A smarter function to compute the layers. |
| void Container::computeLayersHash() |
| { |
| QHash<QString, LogicUnit *> currentStep = arrHashtable; |
| QHash<QString, LogicUnit *> nextStep; |
| QHash<QString, LogicUnit *>::const_iterator blockIterator = currentStep.constBegin(); |
| LogicUnit *actUnit; |
| |
| for(int i = unitcontainer.count(); i>=0;i--){ |
| while(blockIterator != currentStep.constEnd()){ |
| actUnit = blockIterator.value(); |
| //adjust the layers of all "children" |
| QList<Wire *> cons = actUnit->getOutCons(); |
| foreach(Wire *wire, cons){ |
| //go through all of the ends and set the layer to layer+1 |
| int newLayer = actUnit->getLayer()+1; |
| wire->endUnit()->setLayer(newLayer); |
| nextStep.insert(wire->endUnit()->getName(),wire->endUnit()); |
| if(newLayer > maxlayer){ |
| maxlayer = newLayer; |
| } |
| } |
| //get next Item |
| ++blockIterator; |
| } |
| currentStep.clear(); |
| currentStep = nextStep; |
| nextStep.clear(); |
| blockIterator = currentStep.constBegin(); |
| } |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getMaxParentLayer) |
| *-------------------------------------------------------------------------------------------*/ |
| int Container::getMaxParentLayer(LogicUnit* node){ |
| QList<LogicUnit*> parents = node->getParents(); |
| int result = -1; |
| foreach(LogicUnit* parent, parents){ |
| if(parent->getLayer() > result){ |
| result = parent->getLayer(); |
| } |
| } |
| return result; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: copySimCyclesintoNodes) |
| *-------------------------------------------------------------------------------------------*/ |
| void Container::copySimCyclesIntoNodes() |
| { //for each cycle which was simulated //int value; |
| //int i;, copy the values into the nodes |
| int cycle; |
| for(cycle=0+simOffset;cycle<maxSimStep;cycle++){ |
| QHash<QString, nnode_t *>::const_iterator blockIterator = odinTable.constBegin(); |
| |
| while(blockIterator != odinTable.constEnd()){ |
| int value; |
| int i; |
| QString name = blockIterator.key(); |
| LogicUnit* visNode = unithashtable[name]; |
| nnode_t* node = blockIterator.value(); |
| //for each output pin of the node update the current value |
| for(i=0;i<node->num_output_pins;i++){ |
| value = myOdin->getOutputValue(node, i, cycle); |
| visNode->setOutValue(i, value, cycle); |
| visNode->updateWires(); |
| } |
| ++blockIterator; |
| } |
| } |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: computeLayers) |
| *-------------------------------------------------------------------------------------------*/ |
| //compute the layers of all modules inside the container |
| void Container::computeLayers() |
| { |
| QQueue<LogicUnit*> nodequeue; |
| QHash<QString, LogicUnit*> donehashtable; |
| for (int i = 0; i < myOdin->blifexplorer_netlist->num_top_input_nodes; i++){ |
| QString name = myOdin->blifexplorer_netlist->top_input_nodes[i]->name; |
| nodequeue.enqueue(getReferenceToUnit(name)); |
| } |
| |
| // Enqueue constant nodes. |
| nnode_t* constant_nodes[] = {myOdin->blifexplorer_netlist->gnd_node, |
| myOdin->blifexplorer_netlist->vcc_node, |
| myOdin->blifexplorer_netlist->pad_node}; |
| int num_constant_nodes = 3; |
| for (int i = 0; i < num_constant_nodes; i++){ |
| QString name = constant_nodes[i]->name; |
| nodequeue.enqueue(getReferenceToUnit(name)); |
| } |
| |
| // go through the netlist. While doing so |
| // remove nodes from the queue and add followup nodes |
| LogicUnit* node; |
| int maxparent; |
| while(!nodequeue.isEmpty()){ |
| node = nodequeue.dequeue(); |
| //remember name of the node so it is not processed again |
| QString nodeName(node->getName()); |
| //assign layer |
| maxparent = getMaxParentLayer(node); |
| |
| //only if the node is visible it is considered for a layer |
| if(node->isVisible()){ |
| node->setLayer(maxparent+1); |
| } |
| if(node->getLayer()>maxlayer){ |
| maxlayer = node->getLayer(); |
| } |
| //save node in hash, so it will be processed only once |
| donehashtable[nodeName] = node; |
| //Enqueue child nodes which are ready |
| int num_children = 0; |
| nnode_t** children = get_children_of(node->getOdinRef(), &num_children); |
| |
| // connect node to all children |
| //enqueue children if not already done or in queue |
| for(int i=0; i< num_children; i++){ |
| nnode_t* nodeKid = children[i]; |
| QString kidName(nodeKid->name); |
| LogicUnit* kidUnit = getReferenceToUnit(kidName); |
| |
| bool inQueue = nodequeue.contains(kidUnit); |
| bool done = donehashtable.contains(kidName); |
| |
| if(!inQueue && !done && parentsDone(kidUnit,donehashtable)){ |
| nodequeue.enqueue(kidUnit); |
| } |
| } |
| } |
| maxlayer++; |
| /*Locate all outputs at the very end of the graph*/ |
| QHash<QString, LogicUnit*>::const_iterator blockIterator = unithashtable.constBegin(); |
| for(int i = 0; i<=maxlayer;i++){ |
| blockIterator = unithashtable.constBegin(); |
| while(blockIterator != unithashtable.constEnd()){ |
| LogicUnit* actUnit = blockIterator.value(); |
| if(actUnit->getName().contains("top^out")){ |
| actUnit->setLayer(maxlayer); |
| } |
| |
| ++blockIterator; |
| } |
| } |
| |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: spreadLayers) |
| *-------------------------------------------------------------------------------------------*/ |
| void Container::spreadLayers() |
| { |
| QHash<QString, LogicUnit*>::const_iterator blockIterator = unithashtable.constBegin(); |
| LogicUnit* lastUnit = NULL; |
| int counter = 0; |
| int offset = 200; |
| |
| for(int i = 0; i<=maxlayer;i++){ |
| blockIterator = unithashtable.constBegin(); |
| |
| while(blockIterator != unithashtable.constEnd()){ |
| LogicUnit* actUnit = blockIterator.value(); |
| if(actUnit->isVisible()){ |
| if(actUnit->getLayer()== i){ |
| actUnit->setPos(offset+15*counter,100.0+200*counter); |
| actUnit->updateWires(); |
| lastUnit = actUnit; |
| counter++; |
| } |
| if(maxcountPerLayer < counter){ |
| maxcountPerLayer = counter; |
| } |
| } |
| ++blockIterator; |
| } |
| if(lastUnit!=NULL){ |
| offset = lastUnit->x()+200; |
| }else{ |
| offset = 200; |
| } |
| |
| counter = 0; |
| |
| } |
| |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: startOdin) |
| *-------------------------------------------------------------------------------------------*/ |
| void Container::startOdin(){ |
| int error_code = 0; |
| if(!odinStarted){ |
| myOdin->setFilename(myFilename); |
| error_code = myOdin->startOdin(); |
| } |
| else |
| { |
| std::cout << "odin is already started"; |
| } |
| |
| odinStarted = (error_code == 0)? true: false; |
| |
| if(odinStarted){ |
| odinTable = myOdin->getNodeTable(); |
| } |
| else |
| { |
| std::cout << "odin failed to start with error:" << std::to_string(error_code); |
| exit(1); |
| } |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: createNodesFromOdin) |
| *-------------------------------------------------------------------------------------------*/ |
| int Container::createNodesFromOdin(){ |
| QHash<QString, nnode_t *>::const_iterator blockIterator = odinTable.constBegin(); |
| int items = 0; |
| int odinNodeCount = odinTable.count(); |
| while(blockIterator != odinTable.constEnd()){ |
| QString actName = blockIterator.key(); |
| nnode_t* actOdinNode = blockIterator.value(); |
| operation_list odinType = actOdinNode->type; |
| LogicUnit::UnitType type; |
| |
| switch(odinType){ |
| case CLOCK_NODE: |
| type = LogicUnit::Clock; |
| break; |
| case INPUT_NODE: |
| type = LogicUnit::Input; |
| break; |
| case FF_NODE: |
| type = LogicUnit::Latch; |
| break; |
| case OUTPUT_NODE: |
| type = LogicUnit::Output; |
| break; |
| case LOGICAL_AND: |
| type = LogicUnit::And; |
| break; |
| case LOGICAL_OR: |
| type = LogicUnit::Or; |
| break; |
| case LOGICAL_NOT: |
| type = LogicUnit::Not; |
| break; |
| case LOGICAL_NAND: |
| type = LogicUnit::Nand; |
| break; |
| case LOGICAL_XOR: |
| type = LogicUnit::Xor; |
| break; |
| case LOGICAL_XNOR: |
| type = LogicUnit::Xnor; |
| break; |
| case LOGICAL_NOR: |
| type = LogicUnit::Nor; |
| break; |
| case MUX_2: |
| type = LogicUnit::MUX; |
| break; |
| case ADDER_FUNC: |
| type = LogicUnit::ADDER_FUNC; |
| break; |
| case CARRY_FUNC: |
| type = LogicUnit::CARRY_FUNC; |
| break; |
| case MULTIPLY: |
| type = LogicUnit::MULTIPLY; |
| break; |
| case ADD: |
| type = LogicUnit::ADD; |
| break; |
| case MINUS: |
| type = LogicUnit::MINUS; |
| break; |
| case MEMORY: |
| type = LogicUnit::MEMORY; |
| break; |
| default: |
| type = LogicUnit::LogicGate; |
| break; |
| } |
| //add Unit with name and type |
| addUnit(actName, type,QPointF(100,100),actOdinNode); |
| if(actName.contains("+")){ |
| assignToModule(actName); |
| unithashtable[actName]->setVisible(false); |
| } |
| items++; |
| if((100*items/odinNodeCount)%5==0) |
| { |
| fprintf(stdout, "VISUALIZATION: Node progress: %d\n", 100*items/odinNodeCount); |
| } |
| ++blockIterator; |
| } |
| fprintf(stderr, "Created Nodes from Netlist: %d\n", items); |
| return items; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: parentsDone) |
| *-------------------------------------------------------------------------------------------*/ |
| bool Container::parentsDone(LogicUnit *unit, QHash<QString, LogicUnit *> donehashlist) |
| { |
| //in case it is a flipFlop the parents don't have to be done |
| //FlipFlops can be parts of cycles. |
| if(unit->unitType() == LogicUnit::Latch || |
| unit->unitType() == LogicUnit::MEMORY){ |
| return true; |
| } |
| |
| bool result = true; |
| QList<LogicUnit*> parents = unit->getParents(); |
| foreach(LogicUnit* parent,parents){ |
| if(!donehashlist.contains(parent->getName())){ |
| result = false; |
| } |
| } |
| return result; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: parentsDone) |
| *-------------------------------------------------------------------------------------------*/ |
| bool Container::parentsDone(LogicUnit *unit) |
| { |
| bool result = true; |
| QList<LogicUnit*> parents = unit->getParents(); |
| foreach(LogicUnit* parent,parents){ |
| if(!completeNodes.contains(parent->getName())){ |
| result = false; |
| } |
| } |
| return result; |
| } |
| |
| |
| int Container::createConnectionsFromOdinIterate() |
| { |
| //only create connections if nodes are created |
| if(myItemcount <= 0) |
| return -1; |
| //create all connections while iterating through all nodes |
| //leave out the clocks |
| //(visual reasons. The clock should be added last to be at the right port) |
| int conCount = 0; |
| int itemNr = 0; |
| int j,i, itemTotal; |
| bool clocksFound = false; |
| |
| QHash<QString, LogicUnit *> hash =unithashtable; |
| QHash<QString, LogicUnit *>::const_iterator blockIterator = hash.constBegin(); |
| itemTotal = hash.count(); |
| while(blockIterator != hash.constEnd()){ |
| QString actName = blockIterator.key(); |
| LogicUnit* actNode = blockIterator.value(); |
| |
| if(actNode->unitType() == LogicUnit::Module){ |
| ++blockIterator; |
| continue; |
| } |
| |
| if(actNode->getOdinRef()->type == CLOCK_NODE){ |
| if(!clocks.contains(actNode)){ |
| clocks.append(actNode); |
| clocksFound = true; |
| } |
| }else{//if the node is not a clock node, create all output connections |
| int output_number = actNode->getOdinRef()->num_output_pins; |
| for(j=0; j<output_number;j++) |
| { |
| int num_children = 0; |
| nnode_t** children = get_children_of_nodepin(actNode->getOdinRef(), &num_children,j); |
| QHash<QString, nnode_t*> childrenDone; |
| for(i=0; i< num_children; i++){ |
| nnode_t* nodeKid = children[i]; |
| QString kidName(nodeKid->name); |
| //LogicUnit* kidUnit = getReferenceToUnit(kidName); |
| |
| if(!childrenDone.contains(kidName)){ |
| //bool success = addConnectionHashByRef(actNode,kidUnit); |
| bool success = addConnectionHash(actName,kidName); |
| if(!success){ |
| /*FIXME: This error is sometimes created by Odin as |
| the method get_children_of(node->getOdinRef(), &num_children) |
| sometimes returns a node itself as its child.*/ |
| fprintf(stderr, "CONTAINER: Warning: Node has itself in childlist in Odin II:"); |
| fprintf(stderr,"%s", ((char*)actName.toLocal8Bit().data())); |
| fprintf(stderr,"\n"); |
| }else{ |
| //for hard blocks add the output pin of the created connection |
| Wire* newWire = getConnectionBetween(actName, kidName); |
| newWire->setMaxOutputPinNumber( |
| actNode->getOdinRef()->num_output_pins); |
| newWire->setMyOutputPinNumber(j+1); |
| //add modules to connection if needed |
| LogicUnit* startNode = unithashtable[actName]; |
| LogicUnit* startModule; |
| LogicUnit* endNode = unithashtable[kidName]; |
| LogicUnit* endModule; |
| if(startNode->hasModule && endNode->hasModule){ |
| startModule = startNode->getModule(); |
| endModule = endNode->getModule(); |
| if(startModule->getName().compare(endModule->getName())!=0){ |
| //both connections are in modules |
| startModule->addConnection(newWire); |
| endModule->addConnection(newWire); |
| newWire->setEndModule(endModule); |
| newWire->setStartModule(startModule); |
| } |
| }else if(startNode->hasModule){ |
| startModule = startNode->getModule(); |
| startModule->addConnection(newWire); |
| newWire->setStartModule(startModule); |
| }else if(endNode->hasModule){ |
| endModule = endNode->getModule(); |
| endModule->addConnection(newWire); |
| newWire->setEndModule(endModule); |
| } |
| |
| childrenDone[kidName] = nodeKid; |
| conCount++; |
| if(conCount%500 == 0){ |
| fprintf(stdout, "CONTAINER: Connection progress: %d Cons, %d.%d Percent.\n", conCount, 100*itemNr/itemTotal, |
| (10000*itemNr/itemTotal)%100); |
| fflush(stdout); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| //go through each output pin of the node and create all connections |
| itemNr++; |
| ++blockIterator; |
| } |
| |
| //create all clock connections if clocks exist |
| if(clocksFound){ |
| //for all clocks create the connections |
| foreach(LogicUnit* clock, clocks){ |
| int num_children = 0; |
| nnode_t** children = get_children_of(clock->getOdinRef(), &num_children); |
| QString clockName = clock->getName(); |
| |
| // connect clock to all children |
| for(i=0; i< num_children; i++){ |
| nnode_t* nodeKid = children[i]; |
| QString kidName(nodeKid->name); |
| addConnectionHash(clockName,kidName); |
| |
| Wire* newWire = getConnectionBetween(clockName, kidName); |
| LogicUnit* startNode = unithashtable[clockName]; |
| LogicUnit* startModule; |
| LogicUnit* endNode = unithashtable[kidName]; |
| LogicUnit* endModule; |
| |
| if(startNode->hasModule && endNode->hasModule){ |
| startModule = startNode->getModule(); |
| endModule = endNode->getModule(); |
| if(startModule->getName().compare(endModule->getName())!=0){ |
| //both connections are in modules |
| startModule->addConnection(newWire); |
| endModule->addConnection(newWire); |
| newWire->setEndModule(endModule); |
| newWire->setStartModule(startModule); |
| } |
| }else if(startNode->hasModule){ |
| startModule = startNode->getModule(); |
| startModule->addConnection(newWire); |
| newWire->setStartModule(startModule); |
| }else if(endNode->hasModule){ |
| endModule = endNode->getModule(); |
| endModule->addConnection(newWire); |
| newWire->setEndModule(endModule); |
| } |
| |
| conCount++; |
| } |
| } |
| } |
| return conCount; |
| |
| |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: createConnectionsFromOdin) |
| *-------------------------------------------------------------------------------------------*/ |
| int Container::createConnectionsFromOdin() |
| { |
| //only create connections if nodes are created |
| if(myItemcount <= 0) |
| return -1; |
| //create all connections while traversing through the netlist |
| //leave out the clocks |
| //(visual reasons. The clock should be added last to be at the right port) |
| int i, j, conCount; |
| conCount = 0; |
| QQueue<LogicUnit*> nodequeue; |
| QHash<QString, LogicUnit*> donehashtable; |
| |
| for (i = 0; i < myOdin->blifexplorer_netlist->num_top_input_nodes; i++){ |
| QString name = myOdin->blifexplorer_netlist->top_input_nodes[i]->name; |
| nodequeue.enqueue(getReferenceToUnit(name)); |
| } |
| |
| // Enqueue constant nodes. |
| nnode_t* constant_nodes[] = {myOdin->blifexplorer_netlist->gnd_node, |
| myOdin->blifexplorer_netlist->vcc_node, |
| myOdin->blifexplorer_netlist->pad_node}; |
| int num_constant_nodes = 3; |
| for (i = 0; i < num_constant_nodes; i++){ |
| QString name = constant_nodes[i]->name; |
| nodequeue.enqueue(getReferenceToUnit(name)); |
| } |
| |
| // go through the netlist. While doing so |
| // remove nodes from the queue and add followup nodes |
| LogicUnit* node; |
| bool clockFound = false; |
| while(!nodequeue.isEmpty()){ |
| node = nodequeue.dequeue(); |
| //remember name of the node so it is not processed again |
| QString nodeName(node->getName()); |
| //save node in hash, so it will be processed only once |
| donehashtable[nodeName] = node; |
| //check each output pin for children. |
| int output_number = node->getOdinRef()->num_output_pins; |
| for(j=0; j<output_number;j++) |
| { |
| //Enqueue child nodes which are ready |
| int num_children = 0; |
| nnode_t** children = get_children_of_nodepin(node->getOdinRef(), &num_children,j); |
| QHash<QString, nnode_t*> childrenDone;//used to not create a connection multiple times |
| // connect node to all children |
| //enqueue children if not already done or in queue |
| for(i=0; i< num_children; i++){ |
| nnode_t* nodeKid = children[i]; |
| QString kidName(nodeKid->name); |
| LogicUnit* kidUnit = getReferenceToUnit(kidName); |
| |
| bool inQueue = nodequeue.contains(getReferenceToUnit(kidName)); |
| bool done = donehashtable.contains(kidName); |
| |
| if(node->getOdinRef()->type != CLOCK_NODE) |
| { |
| if(!childrenDone.contains(kidName)){ |
| bool success = addConnectionHash(nodeName,kidName); |
| if(!success){ |
| /*FIXME: This error is sometimes created by Odin as |
| the method get_children_of(node->getOdinRef(), &num_children) |
| sometimes returns a node itself as its child.*/ |
| fprintf(stderr, "CONTAINER: Warning: Node has itself in childlist in Odin II.\n"); |
| }else{ |
| //for hard blocks add the output pin of the created connection |
| Wire* newWire = getConnectionBetween(nodeName, kidName); |
| newWire->setMaxOutputPinNumber( |
| getReferenceToUnit(nodeName)->getOdinRef()->num_output_pins); |
| newWire->setMyOutputPinNumber(j+1); |
| childrenDone[kidName] = nodeKid; |
| conCount++; |
| } |
| } |
| }else if(!clocks.contains(node)){ |
| clocks.append(node); |
| clockFound = true; |
| } |
| |
| if(!inQueue && !done && parentsDone(kidUnit,donehashtable)){ |
| nodequeue.enqueue(kidUnit); |
| }else if(!inQueue && !done && kidUnit->getOdinRef()->type == FF_NODE){ |
| nodequeue.enqueue(kidUnit); |
| } |
| } |
| } |
| } |
| |
| //create clock connections |
| int num_children = 0; |
| if(clockFound){ |
| //for all clocks create the connections |
| foreach(LogicUnit* clock, clocks){ |
| nnode_t** children = get_children_of(clock->getOdinRef(), &num_children); |
| QString clockName = clock->getName(); |
| |
| // connect clock to all children |
| for(i=0; i< num_children; i++){ |
| nnode_t* nodeKid = children[i]; |
| QString kidName(nodeKid->name); |
| addConnectionHash(clockName,kidName); |
| conCount++; |
| } |
| } |
| } |
| //return connection count |
| return conCount; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: readInFileOdinOnly) |
| *-------------------------------------------------------------------------------------------*/ |
| /** |
| * Reads in the file in Odin and creates the nodes based on the netlist provided by odin. |
| */ |
| int Container::readInFileOdinOnly(){ |
| //used to measure the time, which is needed to create a graph |
| clock_t start, finish; |
| int cons; |
| start = clock(); |
| //let odin ii parse in the file and return a hashtable of all nodes in the netlist |
| startOdin(); |
| fprintf(stdout, "VISUALIZATION: Creating nodes...\n"); |
| //iterate through the hashtable and create all nodes based on the type |
| myItemcount = createNodesFromOdin(); |
| fprintf(stdout, "VISUALIZATION: Creating Node connections...\n"); |
| //create connections |
| cons = createConnectionsFromOdinIterate(); |
| if(myItemcount <= 0) |
| return -1; |
| |
| finish = clock(); |
| fprintf(stderr, "Nodes: %d, Cons: %d, Time: %f\n", myItemcount, cons, (double)(finish - start)/CLOCKS_PER_SEC); |
| return 0; |
| |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: findByName) |
| *-------------------------------------------------------------------------------------------*/ |
| QHash<QString, LogicUnit *> Container::findByName(QString name) |
| { |
| QHash<QString, LogicUnit *> result; |
| QHash<QString, LogicUnit *> hash =unithashtable; |
| QHash<QString, LogicUnit *>::const_iterator blockIterator = hash.constBegin(); |
| |
| while(blockIterator != unithashtable.constEnd()){ |
| QString actName = blockIterator.key(); |
| if(actName.contains(name, Qt::CaseInsensitive)){ |
| result.insert(actName, blockIterator.value()); |
| blockIterator.value()->setBrush(QColor(23,255,255,255)); |
| } |
| ++blockIterator; |
| } |
| return result; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getReferenceToUnit) |
| *-------------------------------------------------------------------------------------------*/ |
| LogicUnit * Container::getReferenceToUnit(QString name) |
| { |
| if(!unithashtable.contains(name)){ |
| fprintf(stderr, "Container: Not all nodes could be connected!\n"); |
| } |
| return unithashtable[name]; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getMaxSimStep) |
| *-------------------------------------------------------------------------------------------*/ |
| int Container::getMaxSimStep() |
| { |
| return maxSimStep; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getActSimiStep) |
| *-------------------------------------------------------------------------------------------*/ |
| int Container::getActSimStep() |
| { |
| return actSimStep; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: startSimulator) |
| *-------------------------------------------------------------------------------------------*/ |
| int Container::startSimulator() |
| { |
| myOdin->setUpSimulation(); |
| maxSimStep = myOdin->simulateNextWave(); |
| copySimCyclesIntoNodes(); |
| /* |
| myOdin->simulateNextWave(); |
| myOdin->endSimulation(); |
| copySimCyclesIntoNodes();*/ |
| return 0; |
| } |
| |
| int Container::simulateNextWave() |
| { |
| int success = -1; |
| simOffset = maxSimStep; |
| maxSimStep = myOdin->simulateNextWave(); |
| copySimCyclesIntoNodes(); |
| |
| return success; |
| } |
| |
| void Container::resetAllHighlights() |
| { |
| QHash<QString, LogicUnit *> hash =unithashtable; |
| QHash<QString, LogicUnit *>::const_iterator blockIterator = hash.constBegin(); |
| |
| while(blockIterator != unithashtable.constEnd()){ |
| LogicUnit *unit = blockIterator.value(); |
| unit->setBrush(QColor(255,255,255,255)); |
| QList<Wire *> list = unit->getAllCons(); |
| foreach (Wire *wire, list) { |
| wire->setColor(QColor(0,0,0,255)); |
| wire->setZValue(-1000); |
| wire->update(); |
| } |
| ++blockIterator; |
| } |
| } |
| |
| void Container::setVisibilityForAll(bool value) |
| { |
| QHash<QString, LogicUnit *> hash =unithashtable; |
| QHash<QString, LogicUnit *>::const_iterator blockIterator = hash.constBegin(); |
| |
| while(blockIterator != unithashtable.constEnd()){ |
| LogicUnit *unit = blockIterator.value(); |
| unit->setShown(value); |
| QList<Wire *> list = unit->getAllCons(); |
| foreach (Wire *wire, list) { |
| wire->updatePosition(); |
| } |
| ++blockIterator; |
| } |
| } |
| |
| void Container::showActivity() |
| { |
| QHash<QString, nnode_t *>::const_iterator blockIterator = odinTable.constBegin(); |
| |
| while(blockIterator != odinTable.constEnd()){ |
| QString name = blockIterator.key(); |
| LogicUnit* visNode = unithashtable[name]; |
| //get all connections outgoing and advise them to |
| //represent the activity by color |
| QList<Wire*> outgoingWires = visNode->getOutCons(); |
| foreach(Wire* wire, outgoingWires){ |
| wire->showActivity(); |
| wire->update(); |
| } |
| visNode->showActivity(); |
| |
| ++blockIterator; |
| } |
| |
| } |
| |
| void Container::getActivityInformation() |
| { |
| //right now it is a dummy function. the activity values are |
| //generated randomly |
| QHash<QString, nnode_t *>::const_iterator blockIterator = odinTable.constBegin(); |
| |
| while(blockIterator != odinTable.constEnd()){ |
| QString name = blockIterator.key(); |
| LogicUnit* visNode = unithashtable[name]; |
| //get all connections outgoing and advise them to |
| //represent the activity by color |
| QList<Wire*> outgoingWires = visNode->getOutCons(); |
| foreach(Wire* wire, outgoingWires){ |
| int act = qrand() % 255; |
| wire->setActivity(act); |
| |
| } |
| ++blockIterator; |
| } |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: showSimulationStep) |
| *-------------------------------------------------------------------------------------------*/ |
| void Container::showSimulationStep(int cycle) |
| { |
| actSimStep = cycle; |
| |
| //if current step is bigger than the last cycle, create new values |
| if(actSimStep>maxSimStep){ |
| maxSimStep = myOdin->simulateNextWave(); |
| copySimCyclesIntoNodes(); |
| } |
| |
| //visit each node and update the output status of each one of them |
| QHash<QString, nnode_t *>::const_iterator blockIterator = odinTable.constBegin(); |
| |
| while(blockIterator != odinTable.constEnd()){ |
| QString name = blockIterator.key(); |
| LogicUnit* visNode = unithashtable[name]; |
| visNode->setCurrentCycle(cycle); |
| ++blockIterator; |
| } |
| //actSimStep = (simOffset+1)%64; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getConnectionBetween) |
| *-------------------------------------------------------------------------------------------*/ |
| Wire *Container::getConnectionBetween(QString nodeName, QString kidName) |
| { |
| Wire* result = NULL; |
| QHash<QString, Wire *> wires; |
| QHash<QString, LogicUnit *> hash =unithashtable; |
| QHash<QString, LogicUnit *>::const_iterator blockIterator = hash.constBegin(); |
| |
| while(blockIterator != unithashtable.constEnd()){ |
| QString actName = blockIterator.key(); |
| if(actName.compare(nodeName)==0){ |
| LogicUnit* actUnit = blockIterator.value(); |
| wires = actUnit->getOutConsHash(); |
| } |
| ++blockIterator; |
| } |
| |
| if(wires.contains(kidName)){ |
| result = wires.value(kidName); |
| } |
| return result; |
| } |
| |
| QList<LogicUnit *> Container::getClocks() |
| { |
| return clocks; |
| } |
| |
| QString Container::extractModuleFromName(QString name){ |
| if(!name.contains("+")) |
| return QString(""); |
| |
| QString result = name.left(name.lastIndexOf("+")); |
| result = result.right(result.length()-name.lastIndexOf(".")-1); |
| return result; |
| } |
| |
| void Container::assignNodeToModule(QString nodeName, |
| QString moduleName){ |
| LogicUnit* node = unithashtable[nodeName]; |
| LogicUnit* module = unithashtable[moduleName]; |
| |
| node->addPartner(module); |
| module->addPartner(node); |
| } |
| |
| void Container::assignToModule(QString actName) |
| { |
| //extract module |
| QString moduleName = extractModuleFromName(actName); |
| //check if module exist |
| if(!unithashtable.contains(moduleName)){ |
| //create module |
| addModule(moduleName); |
| } |
| //assign node to module |
| assignNodeToModule(actName, moduleName); |
| } |
| |
| void Container::expandCollapse(QString modulename) |
| { |
| bool makeAllVisible; |
| LogicUnit* module = unithashtable[modulename]; |
| |
| makeAllVisible = module->isVisible(); |
| |
| //toggle module visibility |
| module->setVisible(!module->isVisible()); |
| |
| QHash<QString, LogicUnit *> hash =unithashtable; |
| QHash<QString, LogicUnit *>::const_iterator blockIterator = hash.constBegin(); |
| |
| while(blockIterator != unithashtable.constEnd()){ |
| LogicUnit* actNode = blockIterator.value(); |
| if(actNode->hasModule && |
| actNode->getModule()->getName().compare(modulename)==0){ |
| actNode->setVisible(makeAllVisible); |
| } |
| ++blockIterator; |
| } |
| arrangeContainer(); |
| |
| |
| } |
| |
| |
| |
