FunctionalBlock.h

   1 #ifndef __FUNCTIONALBLOCK_H__\r
   2 #define __FUNCTIONALBLOCK_H__\r
   3 \r
   4 #include <iostream>\r
   5 \r
   6 #include <QtCore>\r
   7 \r
   8 #include "AbstractBlock.h"\r
   9 class AbstractBlock;\r
  10 class ReferenceBlock;\r
  11 class GroupBlock;\r
  12 #include "Exception.h"\r
  13 class Exception;\r
  14 class BlockImplementation;\r
  15 class ArithmeticEvaluator;\r
  16     \r
  17 \r
  18 \r
  19 using namespace std;\r
  20 using namespace Qt;\r
  21 \r
  22 /* NOTES :\r
  23    - NEVER forget to call populate() after creating an instance of GraphBlock.\r
  24  */\r
  25 \r
  26 class FunctionalBlock : public AbstractBlock {\r
  27 public:\r
  28 \r
  29   FunctionalBlock(Graph* _graph, GroupBlock* _parent, ReferenceBlock* _reference, bool createIfaces = true) throw(Exception);\r
  30   ~FunctionalBlock();\r
  31   // getters\r
  32   inline ReferenceBlock* getReference() { return reference; }\r
  33   inline QList<int> getProductionCounter() { return productionCounter; }\r
  34   inline QMap<AbstractInterface*, QList<char>* > getConsumptionPattern() { return consumptionPattern; }\r
  35   inline QMap<AbstractInterface*, QList<char>* > getProductionPattern() { return productionPattern; }\r
  36   inline QMap<AbstractInterface*, QList<int>* > getAdmittanceDelays() { return admittanceDelays; }\r
  37   inline int getConsumptionPatternLength() { return lengthCP; }\r
  38   inline int getProductionPatternLength() { return lengthPP; }\r
  39   inline int getDelta() { return delta; }\r
  40   \r
  41   // setters\r
  42   inline void setImplementation(BlockImplementation* impl) { implementation = impl; }\r
  43   inline void setProductionCounter(QList<int> pattern) { productionCounter = pattern; }\r
  44   inline void setDelta(int _delta) { delta = _delta; }\r
  45   \r
  46 \r
  47   // testers\r
  48   bool isFunctionalBlock();\r
  49   bool isStimuliBlock(); //! a stimuli block has no parent and has no data inputs\r
  50 \r
  51   // others\r
  52 \r
  53   void populate(); // create parameters and interface from reference block\r
  54 \r
  55   QList<QString> getExternalResources();\r
  56   void generateVHDL(const QString& path) throw(Exception); // main entry to generate the VHDL code  \r
  57   QString getIfaceUserName(AbstractInterface* refIface); // get iface name from reference interface\r
  58 \r
  59   void parametersValidation(QList<AbstractBlock *> *checkedBlocks, QList<AbstractBlock*>* blocksToConfigure);\r
  60 \r
  61   QString getReferenceXmlFile();\r
  62   QString getReferenceHashMd5();\r
  63   \r
  64   // patterns\r
  65   void createPatterns() throw(Exception); // called in Graph, before checking compatibility and computing output pattern\r
  66   virtual void checkInputPatternCompatibility() throw(Exception);\r
  67   virtual void computeOutputPattern(int nbExec = -1) throw(Exception);\r
  68   void computeAdmittanceDelays() throw(Exception); // compute differences between IP and admittance\r
  69 \r
  70 protected:\r
  71   // patterns\r
  72   void createDelta() throw(Exception);\r
  73   void createConsumptionPattern() throw(Exception); // initialize a QList<char> for each interface from patterns defined in implementation\r
  74   void createProductionPattern() throw(Exception); // initialize a QList<char> for each interface from patterns defined in implementation\r
  75   void createProductionCounter() throw(Exception); // initialize a QList<int> from counter defined in implementation\r
  76   void createAdmittance(int nbExec) throw(Exception); // initialize a QList<char> from consumption pattern and delta\r
  77   void createInputPattern() throw(Exception);\r
  78 \r
  79   void clearConsumptionPattern();\r
  80   void clearProductionPattern(); \r
  81   void clearInputPattern();\r
  82   void clearOutputPattern();\r
  83   void clearAdmittanceDelays();\r
  84   int createTriggers(); // compute the clock cycle at which the block is triggered\r
  85   \r
  86   double evaluateExpression(const QString& expression) throw(Exception);\r
  87   QList<char>* expandPattern(const QString& patternIn) throw(Exception);\r
  88   QList<char> expandPatternRecur(const QString& patternIn, int* offset)  throw(Exception);\r
  89   QString replaceExpressions(const QString& patternIn) throw(Exception);\r
  90   /*!\r
  91    * \brief samePatterns\r
  92    * \param patternSrc the pattern that must be tested with patternDest (is patternDest == patternDest)  \r
  93    * \param srcCol the column index within patternSrc\r
  94    * \param patternDest the pattern that must be tested with patternSrc\r
  95    * \param destCol the column index within patternDest      \r
  96    * BEWARE: this method returns as soons as there is an acces problem (i.e. out of list range, impossible combine, ...)\r
  97    leaving the dest pattern in an inconsistent state. Thus, it is a good idea to call canCombine before.\r
  98    */\r
  99   bool samePatterns(const QMap<AbstractInterface*, QList<char>* >& patternSrc, int srcCol, const QMap<AbstractInterface*, QList<char>* >& patternDest, int destCol);\r
 100   bool samePatterns(const QMap<AbstractInterface*, QList<char>* >& patternSrc, const QList<int>& srcCols, const QMap<AbstractInterface*, QList<char>* >& patternDest, int destCol);\r
 101   /*!\r
 102    * \brief canCombinePatterns\r
 103    * \param patternSrc the pattern that must be combined with patternDest (patternDest = patternDest OR patternSrc)  \r
 104    * \param srcCol the column index within patternSrc\r
 105    * \param patternDest the pattern that is modified by the combination (patternDest = patternDest OR patternSrc)\r
 106    * \param destCol the column index within patternDest  \r
 107    * \return true if the combination is possible, and false else (e.g. when X1 must be combined with 11)\r
 108    * NB: if src/destCol are outside the range of the list, false is returned.   \r
 109    */\r
 110   bool canCombinePatterns(const QMap<AbstractInterface*, QList<char>* >& patternSrc, int srcCol, QMap<AbstractInterface*, QList<char>* > patternDest, int destCol);\r
 111   /*!\r
 112    * \brief combinePatterns\r
 113    * \param patternSrc the pattern that must be combined with patternDest (patternDest = patternDest OR patternSrc)  \r
 114    * \param srcCol the column index within patternSrc\r
 115    * \param patternDest the pattern that is modified by the combination (patternDest = patternDest OR patternSrc)\r
 116    * \param destCol the column index within patternDest      \r
 117    * BEWARE: this method returns as soons as there is an acces problem (i.e. out of list range, impossible combine, ...)\r
 118    leaving the dest pattern in an inconsistent state. Thus, it is a good idea to call canCombine before.\r
 119    */\r
 120   void combinePatterns(const QMap<AbstractInterface*, QList<char>* >& patternSrc, int srcCol, QMap<AbstractInterface*, QList<char>* > patternDest, int destCol);\r
 121   /*!\r
 122    * \brief appendToPattern\r
 123    * \param patternSrc the pattern that must be appended to patternDest\r
 124    * \param srcCol the column index within patternSrc\r
 125    * \param patternDest the pattern that is modified by the append   \r
 126    * \param nbCols the numer of columns to append   \r
 127    * BEWARE: if nbCols is not consistent with the real length of src pattern, there may be less that nbCols\r
 128    * that will be appended\r
 129    */\r
 130   void appendToPattern(const QMap<AbstractInterface*, QList<char>* >& patternSrc, int srcCol, QMap<AbstractInterface*, QList<char>* > patternDest, int nbCols);\r
 131   /*!\r
 132   * \brief removeDataGroup\r
 133   * \param pattern the pattern for which a column is removed\r
 134   * \param offset the index of the column to remove \r
 135   */\r
 136   void removeDataGroup(QMap<AbstractInterface*, QList<char>* >& pattern, int offset);\r
 137   /*!\r
 138   * \brief isValidGroup\r
 139   * \param pattern the pattern to test\r
 140   * \param offset the column to test\r
 141   * isValidGroup checks if there is at least one 1 in the column offset of pattern.\r
 142   */\r
 143   bool isValidDataGroup(const QMap<AbstractInterface*, QList<char>* >& pattern, int offset);\r
 144   bool isValidDataGroup(const QMap<AbstractInterface*, QList<char>* >& pattern, const QList<int> offsets);\r
 145   /*!\r
 146   * \brief isOnlyXGroup\r
 147   * \param pattern the pattern to test\r
 148   * \param offset the column to test\r
 149   * isOnlyXGroup checks if there is only X in the column offset of pattern.\r
 150   */\r
 151   bool isOnlyXDataGroup(const QMap<AbstractInterface*, QList<char>* >& pattern, int offset);\r
 152   /*!\r
 153   * \brief shifRightPattern\r
 154   * \param pattern the pattern to shift\r
 155   * \param offset the column where to shift\r
 156   * shiftRightPattern insert a null colmun in pattern, which leads to shift right the pattern at offset.\r
 157   * this method is used during admittance generation\r
 158   */\r
 159   void shiftRightPattern(const QMap<AbstractInterface*, QList<char>* >& pattern, int offset);\r
 160 \r
 161   void generateComments(QTextStream& out, QDomElement &elt, QString coreFile) throw(Exception); // generates comments from <comments> element\r
 162   void generateLibraries(QTextStream& out, QDomElement &elt) throw(Exception); // generates libraries from <libraries> element\r
 163   void generateArchitecture(QTextStream& out, QDomElement &elt ) throw(Exception); // generate the architecture using <architecture> element\r
 164   void generateController(QTextStream& out) throw(Exception); // generate the wishbone controller of the block\r
 165   void generateEntityOrComponentBody(QTextStream& out, int indentLevel, bool hasController=false) throw(Exception); // generate the entity/compo body using reference\r
 166 \r
 167   QMap<AbstractInterface*, QList<char>* > consumptionPattern;\r
 168   QMap<AbstractInterface*, QString > admittanceCyclic; // the admittance expressed as prologue-cyclic part-epilogue, deduced from admittance\r
 169   QMap<AbstractInterface*, QList<char>* > admittance; // the admittance taking into account nb exec.\r
 170   QMap<AbstractInterface*, QList<int>* > admittanceDelays; // the delay between what should be consumed and IP\r
 171   QMap<AbstractInterface*, QList<char>* > productionPattern;\r
 172   QMap<AbstractInterface*,QList<char>* > inputPattern;\r
 173   QMap<AbstractInterface*, QList<char>* > outputPattern; // CAUTION: the QList<char>* must also be stored in the outputPattern attributes of AbstractInterface\r
 174   QList<int> productionCounter; // only usefull for control output interfaces\r
 175   QList<int> triggers; // the clock cycles at which the block is triggered, taking into account IP\r
 176   int lengthIP; // for convenience, set in createInputPattern()\r
 177   int lengthCP; // for convenience, set in createConsumptionPattern()\r
 178   int lengthAP; // for convenience, set in createAdmittance()\r
 179   int lengthPP;  // for convenience, set in createProductionPattern()\r
 180   int lengthOP;  // for convenience, set in computeOutputPattern()\r
 181   int delta;\r
 182     \r
 183   ArithmeticEvaluator* evaluator;\r
 184   \r
 185   ReferenceBlock* reference;\r
 186   BlockImplementation* implementation;\r
 187 \r
 188 };\r
 189 \r
 190 #endif // __FUNCTIONALBLOCK_H__\r