changed VHDL converter

[blast.git] / Graph.cpp

diff --git a/Graph.cpp b/Graph.cpp
index 1c8712337d1c771545e8be61a6397ac75e32dfa7..4b24181bbf023f8a0a318eaaf36b3ac824bab28f 100644 (file)
--- a/Graph.cpp
+++ b/Graph.cpp
@@ -6,9 +6,11 @@
 Graph::Graph() {
   topGroup = new GroupBlock(NULL);
   topGroup->setName("top group");
+  groups.append(topGroup);
 }
 
 Graph::~Graph() {
+  
   delete topGroup;
 }
 
@@ -16,12 +18,27 @@ QList<AbstractInterface *> Graph::getOutsideInterfaces() {
   return topGroup->getInterfaces();
 }
 
-GroupBlock* Graph::createChildBlock(GroupBlock* parent) {
+GroupBlock* Graph::createChildGroupBlock(GroupBlock* parent) {
   GroupBlock* b = new GroupBlock(parent);
+  groups.append(b);
   return b;
 }
 
-FunctionalBlock* Graph::addFunctionalBlock(GroupBlock* group, ReferenceBlock* ref) {
+void Graph::removeGroupBlock(GroupBlock *group) {
+  group->removeAllBlocks();
+  GroupBlock* parent = AB_TO_GRP(group->getParent());
+  parent->removeBlock(group);
+  groups.removeAll(group);
+}
+
+GroupBlock* Graph::getGroupBlockByName(QString name) {
+  foreach(GroupBlock* group, groups) {
+    if (group->getName() == name) return group;
+  }
+  return NULL;
+}
+
+FunctionalBlock* Graph::createFunctionalBlock(GroupBlock* group, ReferenceBlock* ref) {
 
   FunctionalBlock* newBlock = new FunctionalBlock(group,ref);
   newBlock->populate();
@@ -29,3 +46,146 @@ FunctionalBlock* Graph::addFunctionalBlock(GroupBlock* group, ReferenceBlock* re
 
   return newBlock;
 }
+
+FunctionalBlock* Graph::duplicateFunctionalBlock(FunctionalBlock *block) {
+
+  ReferenceBlock* ref = block->getReference();
+  GroupBlock* group = AB_TO_GRP(block->getParent());
+
+  // adding to the graph
+  FunctionalBlock* newBlock = createFunctionalBlock(group,ref);
+  return newBlock;
+}
+
+
+bool Graph::removeFunctionalBlock(FunctionalBlock* block) {
+  GroupBlock* group = AB_TO_GRP(block->getParent());
+  group->removeBlock(block);
+  return true;
+}
+
+FunctionalBlock* Graph::getFunctionalBlockByName(QString name, GroupBlock* parent) {
+  FunctionalBlock* block = NULL;
+  if (parent != NULL) {
+    block = AB_TO_FUN(parent->getFunctionalBlockByName(name));
+  }
+  else {
+    foreach(GroupBlock* group, groups) {
+      block = AB_TO_FUN(group->getFunctionalBlockByName(name));
+      if (block != NULL) return block;
+    }
+  }
+  return block;
+}
+
+FunctionalBlock* Graph::createSourceBlock(ReferenceBlock* ref) {
+
+  FunctionalBlock* newBlock = new FunctionalBlock(NULL,ref);
+  newBlock->populate();
+  sources.append(newBlock);
+  return newBlock;
+}
+
+FunctionalBlock* Graph::duplicateSourceBlock(FunctionalBlock *block) {
+
+  ReferenceBlock* ref = block->getReference();  
+
+  // adding to the graph
+  FunctionalBlock* newBlock = createSourceBlock(ref);
+  return newBlock;
+}
+
+FunctionalBlock* Graph::getSourceBlockByName(QString name) {
+  foreach(FunctionalBlock* block, sources) {
+    if (block->getName() == name) return block;
+  }
+  return NULL;
+}
+
+bool Graph::removeSourceBlock(FunctionalBlock *block) {
+  sources.removeAll(block);
+  return true;
+}
+
+void Graph::createPatterns() throw(Exception) {
+  
+  foreach(AbstractBlock* block, sources) {
+    FunctionalBlock* funBlock = AB_TO_FUN(block);
+    try {
+      funBlock->createPatterns();
+    }
+    catch(Exception e) {
+      throw(e);      
+    }
+  }
+  
+  foreach(AbstractBlock* block, groups) {
+    GroupBlock* group = AB_TO_GRP(block);    
+    foreach(AbstractBlock* inBlock, group->getBlocks()) {
+      if (inBlock->isFunctionalBlock()) {
+        FunctionalBlock* funBlock = AB_TO_FUN(inBlock);
+        try {
+          funBlock->createPatterns();
+        }
+        catch(Exception e) {
+          throw(e);
+        }
+      }
+    }
+  }  
+}
+
+void Graph::resetPatternComputed() {
+  foreach(AbstractBlock* block, sources) {
+    block->setPatternComputed(false);
+  }
+  foreach(AbstractBlock* block, groups) {
+    GroupBlock* group = AB_TO_GRP(block);
+    group->setPatternComputed(false);
+    foreach(AbstractBlock* inBlock, group->getBlocks()) {
+      inBlock->setPatternComputed(false);
+    }
+  }
+}
+
+void Graph::computeOutputPatterns(int nbExec) throw(Exception) {
+  
+  try {
+    createPatterns();
+  }
+  catch(Exception e) {
+    throw(e);    
+  }
+
+  resetPatternComputed();  
+  // search for all block that are generators.
+  QList<FunctionalBlock*> generators;
+  generators.append(sources);
+  foreach(AbstractBlock* block, groups) {    
+    GroupBlock* group = AB_TO_GRP(block);    
+    foreach(AbstractBlock* inBlock, group->getBlocks()) {
+      FunctionalBlock* funBlock = AB_TO_FUN(inBlock);
+      if ((inBlock->isFunctionalBlock()) && (inBlock->isGeneratorBlock())) {
+        generators.append(funBlock);
+      }
+    }    
+  }
+  // search for maximum PP length
+  int maxPP = 0;
+  foreach(FunctionalBlock* block, generators) {    
+    if (block->getProductionPatternLength() > maxPP) maxPP = block->getProductionPatternLength();
+  }
+  // compute output for generators
+  int maxExecLen = maxPP*nbExec;
+  foreach(FunctionalBlock* block, generators) {    
+    int d = block->getProductionPatternLength();
+    block->computeOutputPattern((maxExecLen+d-1)/d);
+  }
+  // compute output for top group
+  try {
+    topGroup->computeOutputPattern();
+  }
+  catch(Exception e) {
+    throw(e);
+  }
+}