GroupBlock.cpp

   1 #include "GroupBlock.h"
   2 #include "BlockParameterGeneric.h"
   3 #include "AbstractInterface.h"
   4 #include "ConnectedInterface.h"
   5 #include "GroupInterface.h"
   6 #include "string.h"
   7 #include <sstream>
   8 #include "Parameters.h"
   9
  10 int GroupBlock::counter = 1;
  11
  12 GroupBlock::GroupBlock(GroupBlock *_parent) throw(Exception) :  AbstractBlock() {
  13
  14   GroupInterface* clk = NULL;
  15   GroupInterface* rst = NULL;
  16
  17   // force topGroup to false if this group has a parent
  18   if (_parent != NULL) {
  19     topGroup = false;
  20     name = QString("sub_group")+"_"+QString::number(counter++);
  21     // creating clk/rst interfaces
  22     clk = new GroupInterface(this,"clk", AbstractInterface::Input, AbstractInterface::Clock);
  23     rst = new GroupInterface(this,"reset", AbstractInterface::Input, AbstractInterface::Reset);
  24     addInterface(clk);
  25     addInterface(rst);
  26
  27     try {
  28       connectClkReset();
  29     }
  30     catch(Exception e) {
  31       AbstractBlock* source = (AbstractBlock *)(e.getSource());
  32       cerr << qPrintable(source->getName()) << ":" << qPrintable(e.getMessage()) << endl;
  33       throw(e);
  34     }
  35   }
  36   else {
  37     topGroup = true;
  38     name = QString("top_group");
  39     // creating external clk/rst interfaces
  40     clk = new GroupInterface(this,"ext_clk", AbstractInterface::Input, AbstractInterface::Clock);
  41     rst = new GroupInterface(this,"ext_reset", AbstractInterface::Input, AbstractInterface::Reset);
  42     addInterface(clk);
  43     addInterface(rst);
  44     // creating clkrstgen block and connecting it to this: done in Dispatcher since this has no access to library
  45   }
  46   parent = _parent;
  47
  48   if (_parent != NULL) {
  49     try {
  50       connectClkReset();
  51     }
  52     catch(Exception e) {
  53       AbstractBlock* source = (AbstractBlock *)(e.getSource());
  54       cerr << qPrintable(source->getName()) << ":" << qPrintable(e.getMessage()) << endl;
  55       throw(e);
  56     }
  57   }
  58
  59 }
  60
  61 GroupBlock::~GroupBlock() {
  62   foreach(AbstractBlock* block, blocks) {
  63     delete block;
  64   }
  65 }
  66
  67 bool GroupBlock::isGroupBlock() {
  68   return true;
  69 }
  70
  71 bool GroupBlock::isTopGroupBlock() {
  72   return topGroup;
  73 }
  74
  75 void GroupBlock::setParent(AbstractBlock *_parent) {
  76   parent = _parent;
  77   if (parent != NULL) {
  78     topGroup = false;
  79   }
  80 }
  81
  82 void GroupBlock::removeAllBlocks() {
  83   foreach(AbstractBlock* block, blocks) {
  84     if (block->isGroupBlock()) {
  85       GroupBlock* group = AB_TO_GRP(block);
  86       group->removeAllBlocks();
  87     }
  88     removeBlock(block);
  89   }
  90 }
  91
  92 void GroupBlock::removeBlock(AbstractBlock* block) {
  93   /* CAUTION: no check is done if the block has connected interface
  94      or not. Thus, they must be deleted elsewhere.
  95   */
  96   blocks.removeAll(block);
  97   delete block;
  98 }
  99
 100 AbstractBlock *GroupBlock::getFunctionalBlockByName(QString name) {
 101   foreach(AbstractBlock* block, blocks) {
 102     if (block->isFunctionalBlock()) {
 103       if (block->getName() == name) return block;
 104     }
 105   }
 106   return NULL;
 107 }
 108
 109 void GroupBlock::parametersValidation(QList<AbstractBlock *> *checkedBlocks, QList<AbstractBlock *> *blocksToConfigure) {
 110
 111   /*
 112   checkedBlocks->append(this);
 113
 114   foreach(BlockParameter* param, params){
 115     if(param->isUserParameter() && !param->isValueSet()){
 116       if(!blocksToConfigure->contains(param->getOwner())){
 117         blocksToConfigure->append(param->getOwner());
 118       }
 119     }
 120   }
 121   foreach(AbstractInterface *inter, outputs){
 122     foreach(AbstractInterface *connectedInter, inter->getConnectedTo()){
 123       if(!checkedBlocks->contains(connectedInter->getOwner())){
 124         connectedInter->getOwner()->parametersValidation(checkedBlocks, blocksToConfigure);
 125       }
 126     }
 127   }
 128   */
 129 }
 130
 131 void GroupBlock::addGenericParameter(QString name, QString type, QString value) {
 132   BlockParameter* param = new BlockParameterGeneric(this, name, type, value);
 133   params.append(param);
 134 }
 135
 136 void GroupBlock::removeGenericParameter(QString name) {
 137   BlockParameter* p = getParameterFromName(name);
 138   if (p != NULL) params.removeAll(p);
 139 }
 140
 141 void GroupBlock::createInputPattern() {
 142   foreach(AbstractInterface* iface, getControlInputs()) {
 143     ConnectedInterface* connIface = AI_TO_CON(iface);
 144     QList<char>* pattern = new QList<char>(*(connIface->getConnectedFrom()->getOutputPattern()));
 145     connIface->setOutputPattern(pattern);
 146   }
 147 }
 148
 149 void GroupBlock::computeAdmittanceDelays() throw(Exception) {
 150   throw(Exception(INVALID_GROUPBLOCK_USE));
 151 }
 152
 153 void GroupBlock::checkInputPatternCompatibility()  throw(Exception){
 154   throw(Exception(INVALID_GROUPBLOCK_USE));
 155 }
 156
 157
 158 void GroupBlock::computeOutputPattern(int nbExec) throw(Exception) {
 159
 160   static QString fctName = "GroupBlock::computeOutputPattern()";
 161 #ifdef DEBUG_FCTNAME
 162   cout << "call to " << qPrintable(fctName) << endl;
 163 #endif
 164
 165   cout << "computing output pattern of group " << qPrintable(name) << endl;
 166
 167   bool canCompute = false;
 168   // get the input pattern on each inputs
 169   createInputPattern();
 170
 171   cout << "Input pattern OK" << endl;
 172   // find blocks that are connected to that inputs and generators
 173   QList<AbstractBlock*> fifo;
 174   foreach(AbstractBlock* block, blocks) {
 175
 176     bool addIt = false;
 177     // if a block is a generator and has control outputs, add it
 178     if (block->isGeneratorBlock()) {
 179       if (block->getControlOutputs().size() > 0) addIt = true;
 180     }
 181     else {
 182       // if the block has all its connected control inputs that are connected to an intput of the group, add it too
 183       if (block->getControlInputs().size() > 0) {
 184         addIt = true;
 185         foreach(AbstractInterface* iface, block->getControlInputs()) {
 186           //cout << qPrintable(iface->getName()) << " of " << qPrintable(iface->getOwner()->getName()) << " connected to " << endl;
 187           ConnectedInterface* connFrom = ((ConnectedInterface*)iface)->getConnectedFrom();
 188           //cout << qPrintable(connFrom->getName()) << " of " << qPrintable(connFrom->getOwner()->getName()) << endl;
 189
 190           if (connFrom == NULL) {
 191             addIt = false;
 192             break;
 193           }
 194           else if (connFrom->getOwner() != this) {
 195             addIt = false;
 196             break;
 197           }
 198         }
 199       }
 200     }
 201     if (addIt) {
 202       cout << "adding " << qPrintable(block->getName()) << " to initialize the FIFO" << endl;
 203       block->setTraversalLevel(0); // level 0 = first blocks to be evaluated
 204       fifo.append(block);
 205     }
 206   }
 207
 208   while (!fifo.isEmpty()) {
 209     AbstractBlock* block = fifo.takeFirst();
 210
 211     if (block->getPatternComputed()) continue; // block has already been processed
 212
 213     cout << "computing compat and output for " << qPrintable(block->getName()) << endl;
 214
 215
 216     try {
 217       block->checkInputPatternCompatibility();
 218     }
 219     catch(Exception e) {
 220       cout << qPrintable(block->getName()) << " is not compatible with its input pattern" << endl;
 221       throw(e);
 222     }
 223
 224     try {
 225       block->computeOutputPattern();
 226     }
 227     catch(Exception e) {
 228       cout << "cannot finalize output pattern computation of " << qPrintable(block->getName()) << endl;
 229       throw(e);
 230     }
 231     canCompute = true;
 232     block->setPatternComputed(true);
 233     /* add other blocks connected from block to the fifo but only if
 234        all their connected inputs are connected to blocks that have
 235        a traversalLevel >=0
 236      */
 237     foreach(AbstractInterface* iface, block->getControlOutputs()) {
 238       ConnectedInterface* conn = (ConnectedInterface*)iface;
 239       foreach(ConnectedInterface* connTo, conn->getConnectedTo()) {
 240
 241         AbstractBlock* block1 = connTo->getOwner();
 242         cout << "testing if " << qPrintable(block1->getName()) << " has all connected inputs connected to already processed blocks" << endl;
 243         bool addIt = true;
 244         int maxLevel = 0;
 245
 246         foreach(AbstractInterface* iface, block1->getControlInputs()) {
 247           //cout << qPrintable(iface->getName()) << " of " << qPrintable(iface->getOwner()->getName()) << " connected to " << endl;
 248           ConnectedInterface* connFrom = ((ConnectedInterface*)iface)->getConnectedFrom();
 249           //cout << qPrintable(connFrom->getName()) << " of " << qPrintable(connFrom->getOwner()->getName()) << endl;
 250
 251           if ((connFrom != NULL) && (connFrom->getOwner()->getPatternComputed() == false)) {
 252             addIt = false;
 253             break;
 254           }
 255           else {
 256             if (connFrom->getOwner()->getTraversalLevel() > maxLevel) maxLevel = connFrom->getOwner()->getTraversalLevel();
 257           }
 258         }
 259
 260         if (addIt) {
 261           cout << "adding " << qPrintable(block1->getName()) << " to the FIFO" << endl;
 262           block1->setTraversalLevel(maxLevel+1); // level 0 = first blocks to be evaluated
 263           fifo.append(block1);
 264         }
 265       }
 266     }
 267   }
 268
 269   if (canCompute) {
 270     foreach(AbstractInterface* iface, getControlOutputs()) {
 271       ConnectedInterface* connIface = AI_TO_CON(iface);
 272       QList<char>* pattern = new QList<char>(*(connIface->getConnectedFrom()->getOutputPattern()));
 273       connIface->setOutputPattern(pattern);
 274     }
 275     setPatternComputed(true);
 276   }
 277 }
 278
 279 void GroupBlock::generateVHDL(const QString& path) throw(Exception) {
 280
 281   QString coreFile = "";
 282
 283   coreFile = path;
 284   coreFile.append(Parameters::normalizeName(name));
 285   coreFile.append(".vhd");
 286
 287   QFile vhdlCore(coreFile);
 288
 289   if (!vhdlCore.open(QIODevice::WriteOnly)) {
 290     throw(Exception(VHDLFILE_NOACCESS));
 291   }
 292
 293   cout << "generate VHDL of block " << qPrintable(name) << " in " << qPrintable(coreFile) << endl;
 294   QTextStream outCore(&vhdlCore);
 295
 296   QDomElement dummyElt;
 297   try {
 298     generateComments(outCore,dummyElt,"");
 299     generateLibraries(outCore,dummyElt);
 300     generateEntity(outCore);
 301     generateArchitecture(outCore,dummyElt);
 302   }
 303   catch(Exception err) {
 304     throw(err);
 305   }
 306
 307   vhdlCore.close();
 308 }
 309
 310
 311 void GroupBlock::generateComments(QTextStream& out, QDomElement &elt, QString coreFile) throw(Exception) {
 312   out << " -- VHDL generated automatically for " << name << " --" << endl << endl;
 313 }
 314
 315 void GroupBlock::generateLibraries(QTextStream& out, QDomElement &elt) throw(Exception) {
 316
 317   out << "library IEEE;" << endl;
 318   out << "use IEEE.STD_LOGIC_1164.all;" << endl;
 319   out << "use IEEE.numeric_std.all;" << endl;
 320
 321 }
 322
 323 void GroupBlock::generateEntityOrComponentBody(QTextStream& out, int indentLevel, bool hasController) throw(Exception) {
 324
 325   int i;
 326   QString indent = "";
 327   for(i=0;i<indentLevel;i++) {
 328     indent += " ";
 329   }
 330
 331   QList<BlockParameter*> listGenerics = getGenericParameters();
 332   QList<AbstractInterface*> listInputs = getInputs();
 333   QList<AbstractInterface*> listOutputs = getOutputs();
 334   QList<AbstractInterface*> listBidirs = getBidirs();
 335
 336   if (!listGenerics.isEmpty()) {
 337     out << indent << "  generic (" << endl;
 338     for(i=0;i<listGenerics.size()-1;i++) {
 339       out << indent << "    " << listGenerics.at(i)->toVHDL(BlockParameter::Entity, 0) << endl;
 340     }
 341     out << indent << "    " << listGenerics.at(i)->toVHDL(BlockParameter::Entity,BlockParameter::NoComma) << endl;
 342     out << indent << "    );" << endl;
 343   }
 344
 345   out << indent << "  port (" << endl;
 346
 347   // Generation of the clk & rst signals
 348   out << indent << "    -- clk/rst" << endl;
 349   foreach(AbstractInterface* iface, listInputs) {
 350     if(iface->getPurpose() == AbstractInterface::Clock || iface->getPurpose() == AbstractInterface::Reset) {
 351       out << indent << "    " << iface->getName() << " : in std_logic;" << endl;
 352     }
 353   }
 354
 355   int count = 0;
 356   foreach(AbstractInterface* iface, getInterfaces()) {
 357     if((iface->getPurpose() == AbstractInterface::Data)||(iface->getPurpose() == AbstractInterface::Control)) count++;
 358   }
 359   // Generation of the data/control signals
 360
 361   int flag = 0;
 362   bool first = true;
 363
 364   foreach(AbstractInterface* iface, listInputs) {
 365     if(iface->getPurpose() == AbstractInterface::Data) {
 366       if (first) {
 367         out << indent << "    -- input data ports" << endl;
 368         first = false;
 369       }
 370       count--;
 371       if (count == 0) flag = AbstractInterface::NoComma;
 372       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 373     }
 374   }
 375   first = true;
 376   foreach(AbstractInterface* iface, listInputs) {
 377     if(iface->getPurpose() == AbstractInterface::Control) {
 378       if (first) {
 379         out << indent << "    -- input control ports" << endl;
 380         first = false;
 381       }
 382       count--;
 383       if (count == 0) flag = AbstractInterface::NoComma;
 384       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 385     }
 386   }
 387   first = true;
 388   foreach(AbstractInterface* iface, listOutputs) {
 389     if(iface->getPurpose() == AbstractInterface::Data) {
 390       if (first) {
 391         out << indent << "    -- output data ports" << endl;
 392         first = false;
 393       }
 394       count--;
 395       if (count == 0) flag = AbstractInterface::NoComma;
 396       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 397     }
 398   }
 399   first = true;
 400   foreach(AbstractInterface* iface, listOutputs) {
 401     if(iface->getPurpose() == AbstractInterface::Control) {
 402       if (first) {
 403         out << indent << "    -- output control ports" << endl;
 404         first = false;
 405       }
 406       count--;
 407       if (count == 0) flag = AbstractInterface::NoComma;
 408       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 409     }
 410   }
 411   first = true;
 412   foreach(AbstractInterface* iface, listBidirs) {
 413     if(iface->getPurpose() == AbstractInterface::Data) {
 414       if (first) {
 415         out << indent << "    -- bidirs data ports" << endl;
 416         first = false;
 417       }
 418       count--;
 419       if (count == 0) flag = AbstractInterface::NoComma;
 420       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 421     }
 422   }
 423   out << indent << "    );" << endl << endl;
 424 }
 425
 426 void GroupBlock::generateArchitecture(QTextStream& out, QDomElement &elt) throw(Exception) {
 427
 428   int i;
 429
 430   out << "architecture rtl of " << name << " is " << endl << endl;
 431
 432   // generate the components
 433   foreach(AbstractBlock* block, blocks) {
 434     try {
 435       block->generateComponent(out,false);
 436     }
 437     catch(Exception e) {
 438       throw(e);
 439     }
 440   }
 441
 442   out << endl;
 443   // generate signals
 444   out << "  ----------------------------" << endl;
 445   out << "    SIGNALS" << endl;
 446   out << "  ----------------------------" << endl << endl;
 447
 448
 449   foreach(AbstractBlock* block, blocks) {
 450     try {
 451       out << "  -- signals from output ports of " << block->getName() << endl;
 452       QList<AbstractInterface*> listOutputs = block->getOutputs();
 453       foreach(AbstractInterface* iface, listOutputs) {
 454         if ((iface->getPurpose() == AbstractInterface::Data)||(iface->getPurpose() == AbstractInterface::Control)) {
 455           out << "  signal " << iface->toVHDL(AbstractInterface::Signal,0) << endl;
 456         }
 457         else if (block->getName() == "clkrstgen") {
 458           if ((iface->getPurpose() == AbstractInterface::Clock)||(iface->getPurpose() == AbstractInterface::Reset)) {
 459             out << "  signal " << iface->toVHDL(AbstractInterface::Signal,0) << endl;
 460           }
 461         }
 462       }
 463     }
 464     catch(Exception e) {
 465       throw(e);
 466     }
 467     out << endl;
 468   }
 469   foreach(AbstractBlock* block, blocks) {
 470     try {
 471       out << "  -- signals for modified input ports of " << block->getName() << endl;
 472       QList<AbstractInterface*> listInputs = block->getInputs();
 473       foreach(AbstractInterface* iface, listInputs) {
 474         if (iface->getPurpose() == AbstractInterface::Control) {
 475           ConnectedInterface* connCtlIface = AI_TO_CON(iface);
 476           AbstractInputModifier* modifier = connCtlIface->getInputModifier();
 477           if (modifier != NULL) {
 478             out << modifier->toVHDL(AbstractInputModifier::Signal,0) << endl;
 479           }
 480         }
 481       }
 482     }
 483     catch(Exception e) {
 484       throw(e);
 485     }
 486     out << endl;
 487   }
 488
 489   out << "begin" << endl;
 490
 491   // generate signals that goes to the output ports
 492
 493   out << "  -- connections to output ports of " << name << endl;
 494   QList<AbstractInterface*> listOutputs = getOutputs();
 495   foreach(AbstractInterface* iface, listOutputs) {
 496     if ((iface->getPurpose() == AbstractInterface::Data)||(iface->getPurpose() == AbstractInterface::Control)) {
 497       ConnectedInterface* connIface = AI_TO_CON(iface);
 498       ConnectedInterface* fromIface = connIface->getConnectedFrom();
 499       out << "  " << connIface->getName() << " <= " << fromIface->toVHDL(AbstractInterface::Instance,0) << ";" << endl;
 500     }
 501   }
 502
 503   out << endl;
 504
 505
 506
 507   // generate instances
 508   foreach(AbstractBlock* block, blocks) {
 509     try {
 510       out << "  " << block->getName() << "_1 : " << block->getName() << endl;
 511
 512       QList<BlockParameter*> listGenerics = block->getGenericParameters();
 513       QList<AbstractInterface*> listInputs = block->getInputs();
 514       QList<AbstractInterface*> listOutputs = block->getOutputs();
 515       QList<AbstractInterface*> listBidirs = block->getBidirs();
 516
 517       if (!listGenerics.isEmpty()) {
 518         out << "    generic map (" << endl;
 519         for(i=0;i<listGenerics.size()-1;i++) {
 520           out << "      " << listGenerics.at(i)->toVHDL(BlockParameter::Instance, BlockParameter::NoComma) << "," << endl;
 521         }
 522         out << "      " << listGenerics.at(i)->toVHDL(BlockParameter::Instance,BlockParameter::NoComma) << endl;
 523         out << "    )" << endl;
 524       }
 525
 526       out << "    port map (" << endl;
 527       QString portMap = "";
 528
 529       for(i=0;i<listInputs.size();i++) {
 530         ConnectedInterface* connIface = AI_TO_CON(listInputs.at(i));
 531         ConnectedInterface* fromIface = connIface->getConnectedFrom();
 532
 533         if (fromIface->isFunctionalInterface()) {
 534           portMap += "      " + connIface->getName() + " => ";
 535           bool hasMod = false;
 536           if (connIface->getPurpose() == AbstractInterface::Data) {
 537             ConnectedInterface* connCtlIface = AI_TO_CON(connIface->getAssociatedIface());
 538             if ((connCtlIface != NULL) && (connCtlIface->getInputModifier() != NULL)) {
 539               hasMod = true;
 540             }
 541           }
 542           else if (connIface->getPurpose() == AbstractInterface::Control) {
 543             if (connIface->getInputModifier() != NULL) {
 544               hasMod = true;
 545             }
 546           }
 547           if (hasMod) {
 548             portMap += connIface->getOwner()->getName()+"_"+connIface->getName()+"_mod,\n";
 549           }
 550           else {
 551             portMap += fromIface->toVHDL(AbstractInterface::Instance, AbstractInterface::NoComma) + ",\n";
 552           }
 553         }
 554         else if (fromIface->isGroupInterface()) {
 555           portMap += "      " + connIface->getName() + " => " + fromIface->getName() + ",\n";
 556         }
 557       }
 558       if (listOutputs.size()>0) {
 559         for(i=0;i<listOutputs.size();i++) {
 560           ConnectedInterface* connIface = AI_TO_CON(listOutputs.at(i));
 561           portMap += "      " + connIface->getName() + " => " + connIface->toVHDL(AbstractInterface::Instance, AbstractInterface::NoComma) + ",\n";
 562         }
 563       }
 564       if (listBidirs.size()>0) {
 565         for(i=0;i<listBidirs.size();i++) {
 566           ConnectedInterface* connIface = AI_TO_CON(listBidirs.at(i));
 567           portMap += "      " + connIface->getName() + " => " + connIface->toVHDL(AbstractInterface::Instance, AbstractInterface::NoComma) + ",\n";
 568         }
 569       }
 570       portMap.chop(2);
 571       out << portMap << endl;
 572
 573
 574       out << "    );" << endl;
 575     }
 576     catch(Exception e) {
 577       throw(e);
 578     }
 579     out << endl;
 580   }
 581
 582   // generate input modifiers
 583   foreach(AbstractBlock* block, blocks) {
 584
 585     foreach(AbstractInterface* iface, block->getControlInputs()) {
 586       ConnectedInterface* connIface = AI_TO_CON(iface);
 587       // check if it is connected
 588       if (connIface->getConnectedFrom() == NULL) {
 589         throw(Exception(IFACE_NOT_CONNECTED,this));
 590       }
 591       AbstractInputModifier* modifier = connIface->getInputModifier();
 592       if (modifier != NULL) {
 593         try {
 594           out << modifier->toVHDL(AbstractInputModifier::Architecture,0) << endl;
 595         }
 596         catch(Exception e) {
 597           throw(e);
 598         }
 599       }
 600     }
 601   }
 602
 603   out << "end architecture rtl;" << endl;
 604 }
 605
 606 void GroupBlock::generateController(QTextStream &out) throw(Exception) {
 607
 608 }
 609