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   else {
  28     topGroup = true;
  29     name = QString("top_group");
  30     // creating external clk/rst interfaces
  31     clk = new GroupInterface(this,"ext_clk", AbstractInterface::Input, AbstractInterface::Clock);
  32     rst = new GroupInterface(this,"ext_reset", AbstractInterface::Input, AbstractInterface::Reset);
  33     addInterface(clk);
  34     addInterface(rst);
  35     // creating clkrstgen block and connecting it to this: done in Dispatcher since this has no access to library
  36   }
  37   parent = _parent;
  38
  39   if (_parent != NULL) {
  40     try {
  41       connectClkReset();
  42     }
  43     catch(Exception e) {
  44       AbstractBlock* source = (AbstractBlock *)(e.getSource());
  45       cerr << qPrintable(source->getName()) << ":" << qPrintable(e.getMessage()) << endl;
  46       throw(e);
  47     }
  48   }
  49
  50 }
  51
  52 GroupBlock::~GroupBlock() {
  53   foreach(AbstractBlock* block, blocks) {
  54     delete block;
  55   }
  56 }
  57
  58 bool GroupBlock::isGroupBlock() {
  59   return true;
  60 }
  61
  62 bool GroupBlock::isTopGroupBlock() {
  63   return topGroup;
  64 }
  65
  66 void GroupBlock::setParent(AbstractBlock *_parent) {
  67   parent = _parent;
  68   if (parent != NULL) {
  69     topGroup = false;
  70   }
  71 }
  72
  73 void GroupBlock::removeAllBlocks() {
  74   foreach(AbstractBlock* block, blocks) {
  75     if (block->isGroupBlock()) {
  76       GroupBlock* group = AB_TO_GRP(block);
  77       group->removeAllBlocks();
  78     }
  79     removeBlock(block);
  80   }
  81 }
  82
  83 void GroupBlock::removeBlock(AbstractBlock* block) {
  84   /* CAUTION: no check is done if the block has connected interface
  85      or not. Thus, they must be deleted elsewhere.
  86   */
  87   blocks.removeAll(block);
  88   delete block;
  89 }
  90
  91 AbstractBlock *GroupBlock::getFunctionalBlockByName(QString name) {
  92   foreach(AbstractBlock* block, blocks) {
  93     if (block->isFunctionalBlock()) {
  94       if (block->getName() == name) return block;
  95     }
  96   }
  97   return NULL;
  98 }
  99
 100 void GroupBlock::parametersValidation(QList<AbstractBlock *> *checkedBlocks, QList<AbstractBlock *> *blocksToConfigure) {
 101
 102   /*
 103   checkedBlocks->append(this);
 104
 105   foreach(BlockParameter* param, params){
 106     if(param->isUserParameter() && !param->isValueSet()){
 107       if(!blocksToConfigure->contains(param->getOwner())){
 108         blocksToConfigure->append(param->getOwner());
 109       }
 110     }
 111   }
 112   foreach(AbstractInterface *inter, outputs){
 113     foreach(AbstractInterface *connectedInter, inter->getConnectedTo()){
 114       if(!checkedBlocks->contains(connectedInter->getOwner())){
 115         connectedInter->getOwner()->parametersValidation(checkedBlocks, blocksToConfigure);
 116       }
 117     }
 118   }
 119   */
 120 }
 121
 122 void GroupBlock::addGenericParameter(QString name, QString type, QString value) {
 123   BlockParameter* param = new BlockParameterGeneric(this, name, type, value);
 124   params.append(param);
 125 }
 126
 127 void GroupBlock::removeGenericParameter(QString name) {
 128   BlockParameter* p = getParameterFromName(name);
 129   if (p != NULL) params.removeAll(p);
 130 }
 131
 132 void GroupBlock::createInputPattern() {
 133   foreach(AbstractInterface* iface, getControlInputs()) {
 134     ConnectedInterface* connIface = AI_TO_CON(iface);
 135     QList<char>* pattern = new QList<char>(*(connIface->getConnectedFrom()->getOutputPattern()));
 136     connIface->setOutputPattern(pattern);
 137   }
 138 }
 139
 140 void GroupBlock::computeAdmittanceDelays() throw(Exception) {
 141   throw(Exception(INVALID_GROUPBLOCK_USE));
 142 }
 143
 144 void GroupBlock::checkInputPatternCompatibility()  throw(Exception){
 145   throw(Exception(INVALID_GROUPBLOCK_USE));
 146 }
 147
 148
 149 void GroupBlock::computeOutputPattern(int nbExec) throw(Exception) {
 150
 151   static QString fctName = "GroupBlock::computeOutputPattern()";
 152 #ifdef DEBUG_FCTNAME
 153   cout << "call to " << qPrintable(fctName) << endl;
 154 #endif
 155
 156   cout << "computing output pattern of group " << qPrintable(name) << endl;
 157
 158   bool canCompute = false;
 159   // get the input pattern on each inputs
 160   createInputPattern();
 161
 162   cout << "Input pattern OK" << endl;
 163   // find blocks that are connected to that inputs and generators
 164   QList<AbstractBlock*> fifo;
 165   foreach(AbstractBlock* block, blocks) {
 166
 167     bool addIt = false;
 168     // if a block is a generator and has control outputs, add it
 169     if (block->isGeneratorBlock()) {
 170       if (block->getControlOutputs().size() > 0) addIt = true;
 171     }
 172     else {
 173       // if the block has all its connected control inputs that are connected to an intput of the group, add it too
 174       if (block->getControlInputs().size() > 0) {
 175         addIt = true;
 176         foreach(AbstractInterface* iface, block->getControlInputs()) {
 177           //cout << qPrintable(iface->getName()) << " of " << qPrintable(iface->getOwner()->getName()) << " connected to " << endl;
 178           ConnectedInterface* connFrom = ((ConnectedInterface*)iface)->getConnectedFrom();
 179           //cout << qPrintable(connFrom->getName()) << " of " << qPrintable(connFrom->getOwner()->getName()) << endl;
 180
 181           if (connFrom == NULL) {
 182             addIt = false;
 183             break;
 184           }
 185           else if (connFrom->getOwner() != this) {
 186             addIt = false;
 187             break;
 188           }
 189         }
 190       }
 191     }
 192     if (addIt) {
 193       cout << "adding " << qPrintable(block->getName()) << " to initialize the FIFO" << endl;
 194       block->setTraversalLevel(0); // level 0 = first blocks to be evaluated
 195       fifo.append(block);
 196     }
 197   }
 198
 199   while (!fifo.isEmpty()) {
 200     AbstractBlock* block = fifo.takeFirst();
 201
 202     if (block->getPatternComputed()) continue; // block has already been processed
 203
 204     cout << "computing compat and output for " << qPrintable(block->getName()) << endl;
 205
 206
 207     try {
 208       block->checkInputPatternCompatibility();
 209     }
 210     catch(Exception e) {
 211       cout << qPrintable(block->getName()) << " is not compatible with its input pattern" << endl;
 212       throw(e);
 213     }
 214
 215     try {
 216       block->computeOutputPattern();
 217     }
 218     catch(Exception e) {
 219       cout << "cannot finalize output pattern computation of " << qPrintable(block->getName()) << endl;
 220       throw(e);
 221     }
 222     canCompute = true;
 223     block->setPatternComputed(true);
 224     /* add other blocks connected from block to the fifo but only if
 225        all their connected inputs are connected to blocks that have
 226        a traversalLevel >=0
 227      */
 228     foreach(AbstractInterface* iface, block->getControlOutputs()) {
 229       ConnectedInterface* conn = (ConnectedInterface*)iface;
 230       foreach(ConnectedInterface* connTo, conn->getConnectedTo()) {
 231
 232         AbstractBlock* block1 = connTo->getOwner();
 233         cout << "testing if " << qPrintable(block1->getName()) << " has all connected inputs connected to already processed blocks" << endl;
 234         bool addIt = true;
 235         int maxLevel = 0;
 236
 237         foreach(AbstractInterface* iface, block1->getControlInputs()) {
 238           //cout << qPrintable(iface->getName()) << " of " << qPrintable(iface->getOwner()->getName()) << " connected to " << endl;
 239           ConnectedInterface* connFrom = ((ConnectedInterface*)iface)->getConnectedFrom();
 240           //cout << qPrintable(connFrom->getName()) << " of " << qPrintable(connFrom->getOwner()->getName()) << endl;
 241
 242           if ((connFrom != NULL) && (connFrom->getOwner()->getPatternComputed() == false)) {
 243             addIt = false;
 244             break;
 245           }
 246           else {
 247             if (connFrom->getOwner()->getTraversalLevel() > maxLevel) maxLevel = connFrom->getOwner()->getTraversalLevel();
 248           }
 249         }
 250
 251         if (addIt) {
 252           cout << "adding " << qPrintable(block1->getName()) << " to the FIFO" << endl;
 253           block1->setTraversalLevel(maxLevel+1); // level 0 = first blocks to be evaluated
 254           fifo.append(block1);
 255         }
 256       }
 257     }
 258   }
 259
 260   if (canCompute) {
 261     foreach(AbstractInterface* iface, getControlOutputs()) {
 262       ConnectedInterface* connIface = AI_TO_CON(iface);
 263       QList<char>* pattern = new QList<char>(*(connIface->getConnectedFrom()->getOutputPattern()));
 264       connIface->setOutputPattern(pattern);
 265     }
 266     setPatternComputed(true);
 267   }
 268 }
 269
 270 void GroupBlock::generateVHDL(const QString& path) throw(Exception) {
 271
 272   QString coreFile = "";
 273
 274   coreFile = path;
 275   coreFile.append(Parameters::normalizeName(name));
 276   coreFile.append(".vhd");
 277
 278   QFile vhdlCore(coreFile);
 279
 280   if (!vhdlCore.open(QIODevice::WriteOnly)) {
 281     throw(Exception(VHDLFILE_NOACCESS));
 282   }
 283
 284   cout << "generate VHDL of block " << qPrintable(name) << " in " << qPrintable(coreFile) << endl;
 285   QTextStream outCore(&vhdlCore);
 286
 287   QDomElement dummyElt;
 288   try {
 289     generateComments(outCore,dummyElt,"");
 290     generateLibraries(outCore,dummyElt);
 291     generateEntity(outCore);
 292     generateArchitecture(outCore,dummyElt);
 293   }
 294   catch(Exception err) {
 295     throw(err);
 296   }
 297
 298   vhdlCore.close();
 299 }
 300
 301
 302 void GroupBlock::generateComments(QTextStream& out, QDomElement &elt, QString coreFile) throw(Exception) {
 303   out << " -- VHDL generated automatically for " << name << " --" << endl << endl;
 304 }
 305
 306 void GroupBlock::generateLibraries(QTextStream& out, QDomElement &elt) throw(Exception) {
 307
 308   out << "library IEEE;" << endl;
 309   out << "use IEEE.STD_LOGIC_1164.all;" << endl;
 310   out << "use IEEE.numeric_std.all;" << endl;
 311
 312 }
 313
 314 void GroupBlock::generateEntityOrComponentBody(QTextStream& out, int indentLevel, bool hasController) throw(Exception) {
 315
 316   int i;
 317   QString indent = "";
 318   for(i=0;i<indentLevel;i++) {
 319     indent += " ";
 320   }
 321
 322   QList<BlockParameter*> listGenerics = getGenericParameters();
 323   QList<AbstractInterface*> listInputs = getInputs();
 324   QList<AbstractInterface*> listOutputs = getOutputs();
 325   QList<AbstractInterface*> listBidirs = getBidirs();
 326
 327   if (!listGenerics.isEmpty()) {
 328     out << indent << "  generic (" << endl;
 329     for(i=0;i<listGenerics.size()-1;i++) {
 330       out << indent << "    " << listGenerics.at(i)->toVHDL(BlockParameter::Entity, 0) << endl;
 331     }
 332     out << indent << "    " << listGenerics.at(i)->toVHDL(BlockParameter::Entity,BlockParameter::NoComma) << endl;
 333     out << indent << "    );" << endl;
 334   }
 335
 336   out << indent << "  port (" << endl;
 337
 338   // Generation of the clk & rst signals
 339   out << indent << "    -- clk/rst" << endl;
 340   foreach(AbstractInterface* iface, listInputs) {
 341     if(iface->getPurpose() == AbstractInterface::Clock || iface->getPurpose() == AbstractInterface::Reset) {
 342       out << indent << "    " << iface->getName() << " : in std_logic;" << endl;
 343     }
 344   }
 345
 346   int count = 0;
 347   foreach(AbstractInterface* iface, getInterfaces()) {
 348     if((iface->getPurpose() == AbstractInterface::Data)||(iface->getPurpose() == AbstractInterface::Control)) count++;
 349   }
 350   // Generation of the data/control signals
 351
 352   int flag = 0;
 353   bool first = true;
 354
 355   foreach(AbstractInterface* iface, listInputs) {
 356     if(iface->getPurpose() == AbstractInterface::Data) {
 357       if (first) {
 358         out << indent << "    -- input data ports" << endl;
 359         first = false;
 360       }
 361       count--;
 362       if (count == 0) flag = AbstractInterface::NoComma;
 363       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 364     }
 365   }
 366   first = true;
 367   foreach(AbstractInterface* iface, listInputs) {
 368     if(iface->getPurpose() == AbstractInterface::Control) {
 369       if (first) {
 370         out << indent << "    -- input control ports" << endl;
 371         first = false;
 372       }
 373       count--;
 374       if (count == 0) flag = AbstractInterface::NoComma;
 375       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 376     }
 377   }
 378   first = true;
 379   foreach(AbstractInterface* iface, listOutputs) {
 380     if(iface->getPurpose() == AbstractInterface::Data) {
 381       if (first) {
 382         out << indent << "    -- output data ports" << endl;
 383         first = false;
 384       }
 385       count--;
 386       if (count == 0) flag = AbstractInterface::NoComma;
 387       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 388     }
 389   }
 390   first = true;
 391   foreach(AbstractInterface* iface, listOutputs) {
 392     if(iface->getPurpose() == AbstractInterface::Control) {
 393       if (first) {
 394         out << indent << "    -- output control ports" << endl;
 395         first = false;
 396       }
 397       count--;
 398       if (count == 0) flag = AbstractInterface::NoComma;
 399       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 400     }
 401   }
 402   first = true;
 403   foreach(AbstractInterface* iface, listBidirs) {
 404     if(iface->getPurpose() == AbstractInterface::Data) {
 405       if (first) {
 406         out << indent << "    -- bidirs data ports" << endl;
 407         first = false;
 408       }
 409       count--;
 410       if (count == 0) flag = AbstractInterface::NoComma;
 411       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 412     }
 413   }
 414   out << indent << "    );" << endl << endl;
 415 }
 416
 417 void GroupBlock::generateArchitecture(QTextStream& out, QDomElement &elt) throw(Exception) {
 418
 419   int i;
 420
 421   out << "architecture rtl of " << name << " is " << endl << endl;
 422
 423   // generate the components
 424   foreach(AbstractBlock* block, blocks) {
 425     try {
 426       block->generateComponent(out,false);
 427     }
 428     catch(Exception e) {
 429       throw(e);
 430     }
 431   }
 432
 433   out << endl;
 434   // generate signals
 435   out << "  ----------------------------" << endl;
 436   out << "    SIGNALS" << endl;
 437   out << "  ----------------------------" << endl << endl;
 438
 439   out << "  -- signals from input ports of " << name << endl;
 440   QList<AbstractInterface*> listInputs = getInputs();
 441   foreach(AbstractInterface* iface, listInputs) {
 442     if ((iface->getPurpose() == AbstractInterface::Data)||(iface->getPurpose() == AbstractInterface::Control)) {
 443       ConnectedInterface* connIface = AI_TO_CON(iface);
 444       QString prefixName = name+"_"+iface->getName()+"_TO_";
 445       foreach(ConnectedInterface* toIface, connIface->getConnectedTo()) {
 446         QString sigName = prefixName+toIface->getOwner()->getName()+"_"+toIface->getName();
 447         out << "  signal " << sigName << " : " << iface->toVHDL(AbstractInterface::Signal,0) << endl;
 448       }
 449     }
 450   }
 451   out << endl;
 452   foreach(AbstractBlock* block, blocks) {
 453     try {
 454       out << "  -- signals from output ports of " << block->getName() << endl;
 455       QList<AbstractInterface*> listOutputs = block->getOutputs();
 456       foreach(AbstractInterface* iface, listOutputs) {
 457         if ((iface->getPurpose() == AbstractInterface::Data)||(iface->getPurpose() == AbstractInterface::Control)) {
 458           ConnectedInterface* connIface = AI_TO_CON(iface);
 459           QString prefixName = block->getName()+"_"+iface->getName()+"_TO_";
 460           foreach(ConnectedInterface* toIface, connIface->getConnectedTo()) {
 461             QString sigName = prefixName+toIface->getOwner()->getName()+"_"+toIface->getName();
 462             out << "  signal " << sigName << " : " << iface->toVHDL(AbstractInterface::Signal,0) << endl;
 463           }
 464         }
 465       }
 466     }
 467     catch(Exception e) {
 468       throw(e);
 469     }
 470     out << endl;
 471   }
 472
 473
 474   out << "end architecture rtl;" << endl;
 475 }
 476
 477 void GroupBlock::generateController(QTextStream &out) throw(Exception) {
 478
 479 }
 480