--- /dev/null
+/************************************************************************
+ ************************************************************************
+ FAUST compiler
+ Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ ************************************************************************
+ ************************************************************************/
+
+
+
+ /**********************************************************************
+ - klass.cpp : class C++ a remplir (projet FAUST) -
+
+
+ Historique :
+ -----------
+ 17-10-2001 : implementation initiale (yo)
+ 18-10-2001 : Ajout de getFreshID (yo)
+ 02-11-2001 : Ajout de sous classes (yo)
+ 06-11-2001 : modif impression des classes (yo)
+
+***********************************************************************/
+
+#include <stdio.h>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <list>
+#include <map>
+
+#include "floats.hh"
+#include "smartpointer.hh"
+#include "klass.hh"
+#include "uitree.hh"
+#include "Text.hh"
+#include "signals.hh"
+#include "ppsig.hh"
+#include "recursivness.hh"
+
+
+extern bool gVectorSwitch;
+extern bool gDeepFirstSwitch;
+extern bool gOpenMPSwitch;
+extern bool gOpenMPLoop;
+extern bool gSchedulerSwitch;
+extern int gVecSize;
+extern bool gUIMacroSwitch;
+extern int gVectorLoopVariant;
+extern bool gGroupTaskSwitch;
+
+extern map<Tree, set<Tree> > gMetaDataSet;
+static int gTaskCount = 0;
+
+void tab (int n, ostream& fout)
+{
+ fout << '\n';
+ while (n--) fout << '\t';
+}
+
+bool Klass::fNeedPowerDef = false;
+
+/**
+ * Store the loop used to compute a signal
+ */
+void Klass::setLoopProperty(Tree sig, Loop* l)
+{
+ fLoopProperty.set(sig,l);
+}
+
+/**
+ * Returns the loop used to compute a signal
+ */
+bool Klass::getLoopProperty(Tree sig, Loop*& l)
+{
+ return fLoopProperty.get(sig, l);
+}
+
+/**
+ * Open a non-recursive loop on top of the stack of open loops.
+ * @param size the number of iterations of the loop
+ */
+void Klass::openLoop(const string& size)
+{
+ fTopLoop = new Loop(fTopLoop, size);
+ //cerr << "\nOPEN SHARED LOOP(" << size << ") ----> " << fTopLoop << endl;
+}
+
+/**
+ * Open a recursive loop on top of the stack of open loops.
+ * @param recsymbol the recursive symbol defined in this loop
+ * @param size the number of iterations of the loop
+ */
+void Klass::openLoop(Tree recsymbol, const string& size)
+{
+ fTopLoop = new Loop(recsymbol, fTopLoop, size);
+ //cerr << "\nOPEN REC LOOP(" << *recsymbol << ", " << size << ") ----> " << fTopLoop << endl;
+}
+
+/**
+ * Close the top loop and either keep it
+ * or absorb it within its enclosing loop.
+ */
+void Klass::closeLoop(Tree sig)
+{
+ assert(fTopLoop);
+ Loop* l = fTopLoop;
+ fTopLoop = l->fEnclosingLoop;
+ assert(fTopLoop);
+
+ //l->println(4, cerr);
+ //cerr << endl;
+
+ Tree S = symlist(sig);
+ //cerr << "CLOSE LOOP :" << l << " with symbols " << *S << endl;
+ if (l->isEmpty() || fTopLoop->hasRecDependencyIn(S)) {
+ //cout << " will absorb" << endl;
+ // empty or dependent loop -> absorbed by enclosing one
+ //cerr << "absorbed by : " << fTopLoop << endl;
+ fTopLoop->absorb(l);
+ //delete l; HACK !!!
+ } else {
+ // cout << " will NOT absorb" << endl;
+ // we have an independent loop
+ setLoopProperty(sig,l); // associate the signal
+ fTopLoop->fBackwardLoopDependencies.insert(l);
+ // we need to indicate that all recursive symbols defined
+ // in this loop are defined in this loop
+ for (Tree lsym=l->fRecSymbolSet; !isNil(lsym); lsym=tl(lsym)) {
+ this->setLoopProperty(hd(lsym), l);
+ //cerr << "loop " << l << " defines " << *hd(lsym) << endl;
+ }
+ }
+ //cerr << "\n" << endl;
+}
+
+/**
+ * Print a list of lines.
+ */
+void printlines(int n, list<string>& lines, ostream& fout)
+{
+ list<string>::iterator s;
+ for (s = lines.begin(); s != lines.end(); s++) {
+ tab(n, fout); fout << *s;
+ }
+}
+
+/**
+ * Print a list of elements (e1, e2,...)
+ */
+void printdecllist(int n, const string& decl, list<string>& content, ostream& fout)
+{
+ if (!content.empty()) {
+ list<string>::iterator s;
+ fout << "\\";
+ tab(n, fout); fout << decl;
+ string sep = "(";
+ for (s = content.begin(); s != content.end(); s++) {
+ fout << sep << *s;
+ sep = ", ";
+ }
+ fout << ')';
+ }
+}
+
+/**
+ * Print the required C++ libraries as comments in source code
+ */
+void Klass::printLibrary(ostream& fout)
+{
+ set<string> S;
+ set<string>::iterator f;
+
+ string sep;
+ collectLibrary(S);
+ fout << "/* link with ";
+ for (f = S.begin(), sep =": "; f != S.end(); f++, sep = ", ") {
+ fout << sep << *f;
+ }
+ fout << " */\n";
+}
+
+/**
+ * Print the required include files
+ */
+void Klass::printIncludeFile(ostream& fout)
+{
+ set<string> S;
+ set<string>::iterator f;
+
+ if (gOpenMPSwitch) {
+ fout << "#include <omp.h>" << "\n";
+ }
+
+ collectIncludeFile(S);
+ for (f = S.begin(); f != S.end(); f++) {
+ fout << "#include " << *f << "\n";
+ }
+}
+
+/**
+ * Print additional functions required by the generated code
+ */
+void Klass::printAdditionalCode(ostream& fout)
+{
+ if (fNeedPowerDef) {
+ // Add faustpower definition to C++ code
+ fout << "#include <cmath>" << endl;
+ fout << "template <int N> inline float faustpower(float x) { return powf(x,N); } " << endl;
+ fout << "template <int N> inline double faustpower(double x) { return pow(x,N); }" << endl;
+ fout << "template <int N> inline int faustpower(int x) { return faustpower<N/2>(x) * faustpower<N-N/2>(x); } " << endl;
+ fout << "template <> inline int faustpower<0>(int x) { return 1; }" << endl;
+ fout << "template <> inline int faustpower<1>(int x) { return x; }" << endl;
+ }
+
+}
+
+/**
+ * Print metadata declaration
+ */
+void Klass::printMetadata(int n, const map<Tree, set<Tree> >& S, ostream& fout)
+{
+ tab(n,fout); fout << "static void metadata(Meta* m) \t{ ";
+
+ for (map<Tree, set<Tree> >::iterator i = gMetaDataSet.begin(); i != gMetaDataSet.end(); i++) {
+ if (i->first != tree("author")) {
+ tab(n+1,fout); fout << "m->declare(\"" << *(i->first) << "\", " << **(i->second.begin()) << ");";
+ } else {
+ for (set<Tree>::iterator j = i->second.begin(); j != i->second.end(); j++) {
+ if (j == i->second.begin()) {
+ tab(n+1,fout); fout << "m->declare(\"" << *(i->first) << "\", " << **j << ");" ;
+ } else {
+ tab(n+1,fout); fout << "m->declare(\"" << "contributor" << "\", " << **j << ");";
+ }
+ }
+ }
+ }
+
+ tab(n,fout); fout << "}" << endl;
+}
+
+inline bool isElement(const set<Loop*>& S, Loop* l)
+{
+ return S.find(l)!= S.end();
+}
+
+/**
+ * Print a loop graph deep first
+ */
+void Klass::printLoopDeepFirst(int n, ostream& fout, Loop* l, set<Loop*>& visited)
+{
+ // avoid printing already printed loops
+ if (isElement(visited, l)) return;
+
+ // remember we have printed this loop
+ visited.insert(l);
+
+ // print the dependencies loops (that need to be computed before this one)
+ for (lset::const_iterator p =l->fBackwardLoopDependencies.begin(); p!=l->fBackwardLoopDependencies.end(); p++) {
+ printLoopDeepFirst(n, fout, *p, visited);
+ }
+ // the print the loop itself
+ tab(n, fout);
+ tab(n, fout); fout << "// LOOP " << l << ", ORDER " << l->fOrder << endl;
+ l->println(n+1, fout);
+}
+
+/**
+ * Compute how many time each loop is used in a DAG
+ */
+static void computeUseCount(Loop* l)
+{
+ l->fUseCount++;
+ if (l->fUseCount == 1) {
+ for (lset::iterator p =l->fBackwardLoopDependencies.begin(); p!=l->fBackwardLoopDependencies.end(); p++) {
+ computeUseCount(*p);
+ }
+ }
+}
+
+/**
+ * Group together sequences of loops
+ */
+static void groupSeqLoops(Loop* l)
+{
+ int n = l->fBackwardLoopDependencies.size();
+ if (n==0) {
+ return;
+ } else if (n==1) {
+ Loop* f = *(l->fBackwardLoopDependencies.begin());
+ if (f->fUseCount == 1) {
+ l->concat(f);
+ groupSeqLoops(l);
+ } else {
+ groupSeqLoops(f);
+ }
+ return;
+ } else if (n > 1) {
+ for (lset::iterator p =l->fBackwardLoopDependencies.begin(); p!=l->fBackwardLoopDependencies.end(); p++) {
+ groupSeqLoops(*p);
+ }
+ }
+}
+
+#define WORK_STEALING_INDEX 0
+#define LAST_TASK_INDEX 1
+#define START_TASK_INDEX LAST_TASK_INDEX + 1
+
+#define START_TASK_MAX 2
+
+void Klass::buildTasksList()
+{
+ lgraph G;
+
+ if (gGroupTaskSwitch) {
+ computeUseCount(fTopLoop);
+ groupSeqLoops(fTopLoop);
+ }
+
+ sortGraph(fTopLoop, G);
+ int index_task = START_TASK_INDEX;
+
+ addDeclCode("TaskGraph fGraph;");
+ addDeclCode("FAUSTFLOAT** input;");
+ addDeclCode("FAUSTFLOAT** output;");
+ addDeclCode("volatile bool fIsFinished;");
+ addDeclCode("int fFullCount;");
+ addDeclCode("int fIndex;");
+ addDeclCode("DSPThreadPool* fThreadPool;");
+ addDeclCode("int fStaticNumThreads;");
+ addDeclCode("int fDynamicNumThreads;");
+
+ // Compute forward dependencies
+ for (int l=G.size()-1; l>=0; l--) {
+ for (lset::const_iterator p =G[l].begin(); p!=G[l].end(); p++) {
+ for (lset::const_iterator p1 = (*p)->fBackwardLoopDependencies.begin(); p1!=(*p)->fBackwardLoopDependencies.end(); p1++) {
+ (*p1)->fForwardLoopDependencies.insert((*p));
+ }
+ (*p)->fIndex = index_task;
+ index_task++;
+ }
+ }
+
+ // Compute ready tasks list
+ vector<int> task_num;
+ for (int l=G.size()-1; l>=0; l--) {
+ lset::const_iterator next;
+ for (lset::const_iterator p =G[l].begin(); p!=G[l].end(); p++) {
+ if ((*p)->fBackwardLoopDependencies.size() == 0) {
+ task_num.push_back((*p)->fIndex);
+ }
+ }
+ }
+
+ if (task_num.size() < START_TASK_MAX) {
+
+ // Push ready tasks thread 0, execute one task directly
+
+ addZone3("if (cur_thread == 0) {");
+
+ Loop* keep = NULL;
+ for (int l=G.size()-1; l>=0; l--) {
+ lset::const_iterator next;
+ for (lset::const_iterator p =G[l].begin(); p!=G[l].end(); p++) {
+ if ((*p)->fBackwardLoopDependencies.size() == 0) {
+ if (keep == NULL) {
+ keep = *p;
+ } else {
+ addZone3(subst(" taskqueue.PushHead($0);", T((*p)->fIndex)));
+ }
+ }
+ }
+ }
+
+ if (keep != NULL) {
+ addZone3(subst(" tasknum = $0;", T(keep->fIndex)));
+ }
+
+ addZone3("} else {");
+ addZone3(" tasknum = TaskQueue::GetNextTask(cur_thread, fDynamicNumThreads);");
+ addZone3("}");
+
+ } else {
+
+ // Cut ready tasks list and have each thread (dynamically) use a subpart
+ addZone3(subst("int task_list_size = $0;", T((int)task_num.size())));
+ stringstream buf;
+ buf << "int task_list[" << task_num.size() << "] = {";
+ for(size_t i = 0; i < task_num.size(); i++) {
+ buf << task_num[i];
+ if (i != (task_num.size() - 1))
+ buf << ",";
+ }
+ buf << "};";
+
+ addZone3(buf.str());
+ addZone3("taskqueue.InitTaskList(task_list_size, task_list, fDynamicNumThreads, cur_thread, tasknum);");
+ }
+
+ // Last stage connected to end task
+ if (G[0].size() > 1) {
+ addZone2c("// Initialize end task, if more than one input");
+ addZone2c(subst("fGraph.InitTask($0,$1);", T(LAST_TASK_INDEX), T((int)G[0].size())));
+ } else {
+ addZone2c("// End task has only one input, so will be directly activated");
+ }
+
+ // Compute init section
+ addZone2c("// Only initialize taks with more than one input");
+ for (int l=G.size()-1; l>=0; l--) {
+ for (lset::const_iterator p =G[l].begin(); p!=G[l].end(); p++) {
+ if ((*p)->fBackwardLoopDependencies.size() > 1) { // Only initialize taks with more than 1 input, since taks with one input are "directly" activated.
+ addZone2c(subst("fGraph.InitTask($0,$1);", T(START_TASK_INDEX + gTaskCount++), T((int)(*p)->fBackwardLoopDependencies.size())));
+ } else {
+ gTaskCount++;
+ }
+ }
+ }
+
+ addInitCode("fStaticNumThreads = get_max_cpu();");
+ addInitCode("fDynamicNumThreads = getenv(\"OMP_NUM_THREADS\") ? atoi(getenv(\"OMP_NUM_THREADS\")) : fStaticNumThreads;");
+ addInitCode("fThreadPool = DSPThreadPool::Init();");
+ addInitCode("fThreadPool->StartAll(fStaticNumThreads - 1, false);");
+
+ gTaskCount = 0;
+}
+
+/**
+ * Print the loop graph (used for vector code)
+ */
+void Klass::printLoopGraphVector(int n, ostream& fout)
+{
+ if (gGroupTaskSwitch) {
+ computeUseCount(fTopLoop);
+ groupSeqLoops(fTopLoop);
+ }
+
+ lgraph G;
+ sortGraph(fTopLoop, G);
+
+#if 1
+ // EXPERIMENTAL
+ if (gVectorSwitch && gDeepFirstSwitch) {
+ set<Loop*> visited;
+ printLoopDeepFirst(n, fout, fTopLoop, visited);
+ return;
+ }
+#endif
+
+ // normal mode
+ for (int l=G.size()-1; l>=0; l--) {
+ if (gVectorSwitch) { tab(n, fout); fout << "// SECTION : " << G.size() - l; }
+ for (lset::const_iterator p =G[l].begin(); p!=G[l].end(); p++) {
+ (*p)->println(n, fout);
+ }
+ }
+}
+
+/**
+ * Print the loop graph as a serie of parallel loops
+ */
+void Klass::printLoopGraphOpenMP(int n, ostream& fout)
+{
+ if (gGroupTaskSwitch) {
+ computeUseCount(fTopLoop);
+ groupSeqLoops(fTopLoop);
+ }
+
+ lgraph G;
+ sortGraph(fTopLoop, G);
+
+ // OpenMP mode : add OpenMP directives
+ for (int l=G.size()-1; l>=0; l--) {
+ tab(n, fout); fout << "// SECTION : " << G.size() - l;
+ printLoopLevelOpenMP(n, G.size() - l, G[l], fout);
+ }
+}
+
+/**
+ * Print the loop graph as a serie of parallel loops
+ */
+void Klass::printLoopGraphScheduler(int n, ostream& fout)
+{
+ if (gGroupTaskSwitch) {
+ computeUseCount(fTopLoop);
+ groupSeqLoops(fTopLoop);
+ }
+
+ lgraph G;
+ sortGraph(fTopLoop, G);
+
+ // OpenMP mode : add OpenMP directives
+ for (int l=G.size()-1; l>0; l--) {
+ tab(n, fout); fout << "// SECTION : " << G.size() - l;
+ printLoopLevelScheduler(n, G.size() - l, G[l], fout);
+ }
+
+ printLastLoopLevelScheduler(n, G.size(), G[0], fout);
+}
+
+
+/**
+ * Print the loop graph in dot format
+ */
+void Klass::printGraphDotFormat(ostream& fout)
+{
+ lgraph G;
+ sortGraph(fTopLoop, G);
+
+ fout << "strict digraph loopgraph {" << endl;
+ fout << '\t' << "rankdir=LR;" << endl;
+ fout << '\t' << "node[color=blue, fillcolor=lightblue, style=filled, fontsize=9];" << endl;
+
+ int lnum = 0; // used for loop numbers
+ // for each level of the graph
+ for (int l=G.size()-1; l>=0; l--) {
+ // for each task in the level
+ for (lset::const_iterator t =G[l].begin(); t!=G[l].end(); t++) {
+ // print task label "Lxxx : 0xffffff"
+ fout << '\t' << 'L'<<(*t)<<"[label=<<font face=\"verdana,bold\">L"<<lnum++<<"</font> : "<<(*t)<<">];"<<endl;
+ // for each source of the task
+ for (lset::const_iterator src = (*t)->fBackwardLoopDependencies.begin(); src!=(*t)->fBackwardLoopDependencies.end(); src++) {
+ // print the connection Lxxx -> Lyyy;
+ fout << '\t' << 'L'<<(*src)<<"->"<<'L'<<(*t)<<';'<<endl;
+ }
+ }
+ }
+ fout << "}" << endl;
+}
+
+/**
+ * Print the loop graph (used for internals classes)
+ */
+void Klass::printLoopGraphInternal(int n, ostream& fout)
+{
+ lgraph G;
+ sortGraph(fTopLoop, G);
+
+ // normal mode
+ for (int l=G.size()-1; l>=0; l--) {
+ if (gVectorSwitch) { tab(n, fout); fout << "// SECTION : " << G.size() - l; }
+ for (lset::const_iterator p =G[l].begin(); p!=G[l].end(); p++) {
+ (*p)->printoneln(n, fout);
+ }
+ }
+}
+
+/**
+ * Print the loop graph (scalar mode)
+ */
+void Klass::printLoopGraphScalar(int n, ostream& fout)
+{
+ fTopLoop->printoneln(n, fout);
+}
+
+/**
+ * returns true if all the loops are non recursive
+ */
+static bool nonRecursiveLevel(const lset& L)
+{
+ for (lset::const_iterator p =L.begin(); p!=L.end(); p++) {
+ if ((*p)->fIsRecursive) return false;
+ }
+ return true;
+}
+
+/**
+ * Print the 'level' of the loop graph as a set of
+ * parallel loops
+ */
+void Klass::printLoopLevelOpenMP(int n, int lnum, const lset& L, ostream& fout)
+{
+ if (nonRecursiveLevel(L) && L.size()==1) {
+ for (lset::const_iterator p =L.begin(); p!=L.end(); p++) {
+ if ((*p)->isEmpty() == false) {
+ if (gOpenMPLoop) {
+ (*p)->printParLoopln(n, fout);
+ } else {
+ tab(n, fout); fout << "#pragma omp single ";
+ tab(n, fout); fout << "{ ";
+ (*p)->println(n+1, fout);
+ tab(n, fout); fout << "} ";
+ }
+ }
+ }
+
+ } else if (L.size() > 1) {
+ tab(n, fout); fout << "#pragma omp sections ";
+ tab(n, fout); fout << "{ ";
+ for (lset::const_iterator p =L.begin(); p!=L.end(); p++) {
+ tab(n+1, fout); fout << "#pragma omp section ";
+ tab(n+1, fout); fout << "{";
+ (*p)->println(n+2, fout);
+ tab(n+1, fout); fout << "} ";
+ }
+ tab(n, fout); fout << "} ";
+ } else if (L.size() == 1 && !(*L.begin())->isEmpty()) {
+ tab(n, fout); fout << "#pragma omp single ";
+ tab(n, fout); fout << "{ ";
+ for (lset::const_iterator p =L.begin(); p!=L.end(); p++) {
+ (*p)->println(n+1, fout);
+ }
+ tab(n, fout); fout << "} ";
+ }
+}
+
+/**
+ * Print the 'level' of the loop graph as a set of
+ * parallel loops
+ */
+void Klass::printLastLoopLevelScheduler(int n, int lnum, const lset& L, ostream& fout)
+{
+ if (nonRecursiveLevel(L) && L.size() == 1 && !(*L.begin())->isEmpty()) {
+
+ lset::const_iterator p =L.begin();
+ tab(n, fout); fout << "case " << gTaskCount++ << ": { ";
+ (*p)->println(n+1, fout);
+ tab(n+1, fout); fout << "tasknum = LAST_TASK_INDEX;";
+ tab(n+1, fout); fout << "break;";
+ tab(n, fout); fout << "} ";
+
+ } else if (L.size() > 1) {
+
+ for (lset::const_iterator p =L.begin(); p!=L.end(); p++) {
+ tab(n, fout); fout << "case " << gTaskCount++ << ": { ";
+ (*p)->println(n+1, fout);
+ tab(n+1, fout); fout << "fGraph.ActivateOneOutputTask(taskqueue, LAST_TASK_INDEX, tasknum);";
+ tab(n+1, fout); fout << "break;";
+ tab(n, fout); fout << "} ";
+ }
+
+ } else if (L.size() == 1 && !(*L.begin())->isEmpty()) {
+
+ lset::const_iterator p =L.begin();
+ tab(n, fout); fout << "case " << gTaskCount++ << ": { ";
+ (*p)->println(n+1, fout);
+ tab(n+1, fout); fout << "tasknum = LAST_TASK_INDEX;";
+ tab(n+1, fout); fout << "break;";
+ tab(n, fout); fout << "} ";
+
+ }
+}
+
+void Klass::printOneLoopScheduler(lset::const_iterator p, int n, ostream& fout)
+{
+ tab(n, fout); fout << "case " << gTaskCount++ << ": { ";
+ (*p)->println(n+1, fout);
+
+ // One output only
+ if ((*p)->fForwardLoopDependencies.size() == 1) {
+
+ lset::const_iterator p1 = (*p)->fForwardLoopDependencies.begin();
+ if ((*p1)->fBackwardLoopDependencies.size () == 1) {
+ tab(n+1, fout); fout << subst("tasknum = $0;", T((*p1)->fIndex));
+ } else {
+ tab(n+1, fout); fout << subst("fGraph.ActivateOneOutputTask(taskqueue, $0, tasknum);", T((*p1)->fIndex));
+ }
+
+ } else {
+
+ Loop* keep = NULL;
+ // Find one output with only one backward dependencies
+ for (lset::const_iterator p1 = (*p)->fForwardLoopDependencies.begin(); p1!=(*p)->fForwardLoopDependencies.end(); p1++) {
+ if ((*p1)->fBackwardLoopDependencies.size () == 1) {
+ keep = *p1;
+ break;
+ }
+ }
+
+ if (keep == NULL) {
+ tab(n+1, fout); fout << "tasknum = WORK_STEALING_INDEX;";
+ }
+
+ for (lset::const_iterator p1 = (*p)->fForwardLoopDependencies.begin(); p1!=(*p)->fForwardLoopDependencies.end(); p1++) {
+ if ((*p1)->fBackwardLoopDependencies.size () == 1) { // Task is the only input
+ if (*p1 != keep) {
+ tab(n+1, fout); fout << subst("taskqueue.PushHead($0);", T((*p1)->fIndex));
+ }
+ } else {
+ if (keep == NULL) {
+ tab(n+1, fout); fout << subst("fGraph.ActivateOutputTask(taskqueue, $0, tasknum);", T((*p1)->fIndex));
+ } else {
+ tab(n+1, fout); fout << subst("fGraph.ActivateOutputTask(taskqueue, $0);", T((*p1)->fIndex));
+ }
+ }
+ }
+
+ if (keep != NULL) {
+ tab(n+1, fout); fout << subst("tasknum = $0;", T(keep->fIndex)); // Last one
+ } else {
+ tab(n+1, fout); fout << "fGraph.GetReadyTask(taskqueue, tasknum);"; // Last one
+ }
+ }
+
+ tab(n+1, fout); fout << "break;";
+ tab(n, fout); fout << "} ";
+}
+
+/**
+ * Print the 'level' of the loop graph as a set of
+ * parallel loops
+ */
+
+void Klass::printLoopLevelScheduler(int n, int lnum, const lset& L, ostream& fout)
+{
+ if (nonRecursiveLevel(L) && L.size() == 1 && !(*L.begin())->isEmpty()) {
+ printOneLoopScheduler(L.begin(), n, fout);
+ } else if (L.size() > 1) {
+ for (lset::const_iterator p = L.begin(); p != L.end(); p++) {
+ printOneLoopScheduler(p, n, fout);
+ }
+ } else if (L.size() == 1 && !(*L.begin())->isEmpty()) {
+ printOneLoopScheduler(L.begin(), n, fout);
+ }
+}
+
+/**
+ * Print a full C++ class corresponding to a Faust dsp
+ */
+void Klass::println(int n, ostream& fout)
+{
+ list<Klass* >::iterator k;
+
+ tab(n,fout); fout << "#define FAUSTCLASS "<< fKlassName << endl;
+
+ if (gSchedulerSwitch) {
+ tab(n,fout); fout << "class " << fKlassName << " : public " << fSuperKlassName << ", public Runnable {";
+ } else {
+ tab(n,fout); fout << "class " << fKlassName << " : public " << fSuperKlassName << " {";
+ }
+
+ if (gUIMacroSwitch) {
+ tab(n,fout); fout << " public:";
+ } else {
+ tab(n,fout); fout << " private:";
+ }
+
+ for (k = fSubClassList.begin(); k != fSubClassList.end(); k++) (*k)->println(n+1, fout);
+
+ printlines(n+1, fDeclCode, fout);
+
+ tab(n,fout); fout << " public:";
+
+ printMetadata(n+1, gMetaDataSet, fout);
+
+ if (gSchedulerSwitch) {
+ tab(n+1,fout); fout << "virtual ~" << fKlassName << "() \t{ "
+ << "DSPThreadPool::Destroy()"
+ << "; }";
+ }
+
+ tab(n+1,fout); fout << "virtual int getNumInputs() \t{ "
+ << "return " << fNumInputs
+ << "; }";
+ tab(n+1,fout); fout << "virtual int getNumOutputs() \t{ "
+ << "return " << fNumOutputs
+ << "; }";
+
+ tab(n+1,fout); fout << "static void classInit(int samplingFreq) {";
+ printlines (n+2, fStaticInitCode, fout);
+ tab(n+1,fout); fout << "}";
+
+ tab(n+1,fout); fout << "virtual void instanceInit(int samplingFreq) {";
+ tab(n+2,fout); fout << "fSamplingFreq = samplingFreq;";
+ printlines (n+2, fInitCode, fout);
+ tab(n+1,fout); fout << "}";
+
+ tab(n+1,fout); fout << "virtual void init(int samplingFreq) {";
+ tab(n+2,fout); fout << "classInit(samplingFreq);";
+ tab(n+2,fout); fout << "instanceInit(samplingFreq);";
+ tab(n+1,fout); fout << "}";
+
+
+ tab(n+1,fout); fout << "virtual void buildUserInterface(UI* interface) {";
+ printlines (n+2, fUICode, fout);
+ tab(n+1,fout); fout << "}";
+
+ printComputeMethod(n, fout);
+
+ tab(n,fout); fout << "};\n" << endl;
+
+ printlines(n, fStaticFields, fout);
+
+ // generate user interface macros if needed
+ if (gUIMacroSwitch) {
+ tab(n, fout); fout << "#ifdef FAUST_UIMACROS";
+ tab(n+1,fout); fout << "#define FAUST_INPUTS " << fNumInputs;
+ tab(n+1,fout); fout << "#define FAUST_OUTPUTS " << fNumOutputs;
+ tab(n+1,fout); fout << "#define FAUST_ACTIVES " << fNumActives;
+ tab(n+1,fout); fout << "#define FAUST_PASSIVES " << fNumPassives;
+ printlines(n+1, fUIMacro, fout);
+ tab(n, fout); fout << "#endif";
+ }
+
+ fout << endl;
+}
+
+/**
+ * Print Compute() method according to the various switch
+ */
+void Klass::printComputeMethod(int n, ostream& fout)
+{
+ if (gSchedulerSwitch) {
+ printComputeMethodScheduler (n, fout);
+ } else if (gOpenMPSwitch) {
+ printComputeMethodOpenMP (n, fout);
+ } else if (gVectorSwitch) {
+ switch (gVectorLoopVariant) {
+ case 0 : printComputeMethodVectorFaster(n, fout); break;
+ case 1 : printComputeMethodVectorSimple(n, fout); break;
+ default : cerr << "unknown loop variant " << gVectorLoopVariant << endl; exit(1);
+ }
+ } else {
+ printComputeMethodScalar(n, fout);
+ }
+}
+
+void Klass::printComputeMethodScalar(int n, ostream& fout)
+{
+ tab(n+1,fout); fout << subst("virtual void compute (int count, $0** input, $0** output) {", xfloat());
+ printlines (n+2, fZone1Code, fout);
+ printlines (n+2, fZone2Code, fout);
+ printlines (n+2, fZone2bCode, fout);
+ printlines (n+2, fZone3Code, fout);
+ printLoopGraphScalar (n+2,fout);
+ tab(n+1,fout); fout << "}";
+}
+
+/**
+ * Uses loops of constant gVecSize boundary in order to provide the
+ * C compiler with more optimisation opportunities. Improves performances
+ * in general, but not always
+ */
+void Klass::printComputeMethodVectorFaster(int n, ostream& fout)
+{
+ // in vector mode we need to split loops in smaller pieces not larger
+ // than gVecSize
+ tab(n+1,fout); fout << subst("virtual void compute (int fullcount, $0** input, $0** output) {", xfloat());
+ printlines(n+2, fZone1Code, fout);
+ printlines(n+2, fZone2Code, fout);
+ printlines(n+2, fZone2bCode, fout);
+
+ tab(n+2,fout); fout << "int index;";
+ tab(n+2,fout); fout << "for (index = 0; index <= fullcount - " << gVecSize << "; index += " << gVecSize << ") {";
+ tab(n+3,fout); fout << "// compute by blocks of " << gVecSize << " samples";
+ tab(n+3,fout); fout << "const int count = " << gVecSize << ";";
+ printlines (n+3, fZone3Code, fout);
+ printLoopGraphVector(n+3,fout);
+ tab(n+2,fout); fout << "}";
+
+ tab(n+2,fout); fout << "if (index < fullcount) {";
+ tab(n+3,fout); fout << "// compute the remaining samples if any";
+ tab(n+3,fout); fout << "int count = fullcount-index;";
+ printlines (n+3, fZone3Code, fout);
+ printLoopGraphVector(n+3,fout);
+ tab(n+2,fout); fout << "}";
+ tab(n+1,fout); fout << "}";
+}
+
+/**
+ * Simple loop layout, generally less efficient than printComputeMethodVectorFaster
+ */
+void Klass::printComputeMethodVectorSimple(int n, ostream& fout)
+{
+ // in vector mode we need to split loops in smaller pieces not larger
+ // than gVecSize
+ tab(n+1,fout); fout << subst("virtual void compute (int fullcount, $0** input, $0** output) {", xfloat());
+ printlines(n+2, fZone1Code, fout);
+ printlines(n+2, fZone2Code, fout);
+ printlines(n+2, fZone2bCode, fout);
+ tab(n+2,fout); fout << "for (int index = 0; index < fullcount; index += " << gVecSize << ") {";
+ tab(n+3,fout); fout << "int count = min("<< gVecSize << ", fullcount-index);";
+ printlines (n+3, fZone3Code, fout);
+ printLoopGraphVector(n+3,fout);
+ tab(n+2,fout); fout << "}";
+ tab(n+1,fout); fout << "}";
+}
+
+/*
+void Klass::printComputeMethodVectorFix0 (int n, ostream& fout)
+{
+ // in vector mode we need to split loops in smaller pieces not larger
+ // than gVecSize
+ tab(n+1,fout); fout << "virtual void compute (int fullcount, float** input, float** output) {";
+ printlines(n+2, fZone1Code, fout);
+ printlines(n+2, fZone2Code, fout);
+ printlines(n+2, fZone2bCode, fout);
+ tab(n+2,fout); fout << "for (int index = 0; index < fullcount; index += " << gVecSize << ") {";
+ tab(n+3,fout); fout << "if (fullcount >= index + " << gVecSize << ") {";
+ tab(n+4,fout); fout << "// compute by blocks of " << gVecSize << " samples";
+ tab(n+4,fout); fout << "const int count = " << gVecSize << ";"; // temporaire
+ printlines(n+4, fZone3Code, fout);
+ printLoopGraph (n+4,fout);
+ tab(n+3,fout); fout << "} else if (fullcount > index) {";
+ //tab(n+3,fout); fout << "int count = min ("<< gVecSize << ", fullcount-index);";
+ tab(n+4,fout); fout << "// compute the remaining samples";
+ tab(n+4,fout); fout << "int count = fullcount-index;" ;
+ printlines(n+4, fZone3Code, fout);
+ printLoopGraph (n+4,fout);
+ tab(n+3,fout); fout << "}";
+ tab(n+2,fout); fout << "}";
+ tab(n+1,fout); fout << "}";
+}
+
+void Klass::printComputeMethodVectorFix1 (int n, ostream& fout)
+{
+ // in vector mode we need to split loops in smaller pieces not larger
+ // than gVecSize
+ tab(n+1,fout); fout << "virtual void compute (int fullcount, float** input, float** output) {";
+ printlines(n+2, fZone1Code, fout);
+ printlines(n+2, fZone2Code, fout);
+ printlines(n+2, fZone2bCode, fout);
+
+ tab(n+2,fout); fout << "int \tblock;";
+ tab(n+2,fout); fout << "for (block = 0; block < fullcount/" << gVecSize << "; block++) {";
+ tab(n+3,fout); fout << "// compute by blocks of " << gVecSize << " samples";
+ tab(n+3,fout); fout << "const int index = block*" << gVecSize << ";";
+ tab(n+3,fout); fout << "const int count = " << gVecSize << ";"; // temporaire
+ printlines(n+3, fZone3Code, fout);
+ printLoopGraph (n+3,fout);
+ tab(n+2,fout); fout << "}";
+
+ tab(n+2,fout); fout << "if (fullcount%" << gVecSize << " != 0) {";
+ //tab(n+3,fout); fout << "int count = min ("<< gVecSize << ", fullcount-index);";
+ tab(n+3,fout); fout << "// compute the remaining samples";
+ tab(n+3,fout); fout << "const int index = block*" << gVecSize << ";";
+ tab(n+3,fout); fout << "int count = fullcount%" << gVecSize << ";" ;
+ printlines(n+3, fZone3Code, fout);
+ printLoopGraph (n+3,fout);
+ tab(n+2,fout); fout << "}";
+ tab(n+1,fout); fout << "}";
+}*/
+
+void Klass::printComputeMethodOpenMP(int n, ostream& fout)
+{
+ // in openMP mode we need to split loops in smaller pieces not larger
+ // than gVecSize and add OpenMP pragmas
+ tab(n+1,fout); fout << subst("virtual void compute (int fullcount, $0** input, $0** output) {", xfloat());
+ printlines(n+2, fZone1Code, fout);
+ printlines(n+2, fZone2Code, fout);
+ tab(n+2,fout); fout << "#pragma omp parallel";
+ printdecllist(n+3, "firstprivate", fFirstPrivateDecl, fout);
+
+ tab(n+2,fout); fout << "{";
+ if (!fZone2bCode.empty()) {
+ tab(n+3,fout); fout << "#pragma omp single";
+ tab(n+3,fout); fout << "{";
+ printlines(n+4, fZone2bCode, fout);
+ tab(n+3,fout); fout << "}";
+ }
+
+ tab(n+3,fout); fout << "for (int index = 0; index < fullcount; index += " << gVecSize << ") {";
+ tab(n+4,fout); fout << "int count = min ("<< gVecSize << ", fullcount-index);";
+
+ printlines (n+4, fZone3Code, fout);
+ printLoopGraphOpenMP (n+4,fout);
+
+ tab(n+3,fout); fout << "}";
+
+ tab(n+2,fout); fout << "}";
+ tab(n+1,fout); fout << "}";
+}
+
+/*
+void Klass::printComputeMethodScheduler (int n, ostream& fout)
+{
+ tab(n+1,fout); fout << subst("virtual void compute (int fullcount, $0** input, $0** output) {", xfloat());
+ printlines (n+2, fZone1Code, fout);
+ printlines (n+2, fZone2Code, fout);
+
+ // Init input and output
+ tab(n+2,fout); fout << "// Init input and output";
+ printlines (n+2, fZone3aCode, fout);
+ printlines (n+2, fZone3bCode, fout);
+
+ tab(n+2,fout); fout << "// Init graph state";
+ tab(n+2,fout); fout << "initState(fTasksList);";
+ tab(n+2,fout); fout << "bool is_finished = false;";
+ tab(n+2,fout); fout << "unsigned int index_in = 0;";
+ tab(n+2,fout); fout << "unsigned int index_out = 0;";
+ tab(n+2,fout); fout << "int count = min ("<< gVecSize << ", fullcount);";
+
+ tab(n+2,fout); fout << "InitSchedulingMap();";
+ tab(n+2,fout); fout << "#pragma omp parallel";
+ printdecllist(n+3, "firstprivate", fFirstPrivateDecl, fout);
+
+ tab(n+2,fout); fout << "{";
+ tab(n+3,fout); fout << "while (!is_finished) {";
+ tab(n+4,fout); fout << "Task* task = searchTaskToAcquire(fTasksList);";
+ tab(n+4,fout); fout << "if (task != NULL) {";
+ tab(n+5,fout); fout << "bool last_cycle_for_thread = false;";
+ tab(n+5,fout); fout << "do {";
+ tab(n+6,fout); fout << "AddTaskToScheduling(task);";
+ tab(n+6,fout); fout << "switch (task->fNum) {";
+
+ // DSP tasks
+ printLoopGraph (n+7,fout);
+
+ // Input task
+ tab(n+7, fout); fout << "case " << gTaskCount++ << ": { ";
+ printlines (n+8, fZone6Code, fout);
+ tab(n+8, fout); fout << "index_in += count;";
+ tab(n+8, fout); fout << "last_cycle_for_thread = (index_in > fullcount);";
+ tab(n+8, fout); fout << "break;";
+ tab(n+7, fout); fout << "} ";
+
+ // Output task
+ tab(n+7, fout); fout << "case " << gTaskCount++ << ": { ";
+ printlines (n+8, fZone7Code, fout);
+ tab(n+8, fout); fout << "index_out += count;";
+ tab(n+8, fout); fout << "last_cycle_for_thread = (index_out > fullcount);";
+ tab(n+8, fout); fout << "break;";
+ tab(n+7, fout); fout << "} ";
+
+ // End task
+ tab(n+7, fout); fout << "case " << gTaskCount++ << ": { ";
+ tab(n+8, fout); fout << "is_finished = ((index_in >= fullcount) && (index_out >= fullcount));";
+ tab(n+8, fout); fout << "break;";
+ tab(n+7, fout); fout << "} ";
+
+ tab(n+6,fout); fout << "}";
+ tab(n+6,fout); fout << "if (last_cycle_for_thread) break;";
+
+ tab(n+5,fout); fout << "} while ((task = task->concludeAndTryToAcquireNext()) != NULL);";
+ tab(n+4,fout); fout << "}";
+ tab(n+3,fout); fout << "}";
+ tab(n+2,fout); fout << "}";
+ tab(n+2,fout); fout << "PrintSchedulingMap();";
+ tab(n+1,fout); fout << "}";
+}
+*/
+
+void Klass::printComputeMethodScheduler (int n, ostream& fout)
+{
+ tab(n+1,fout); fout << "void display() {";
+ tab(n+2,fout); fout << "fGraph.Display();";
+ tab(n+1,fout); fout << "}";
+
+ tab(n+1,fout); fout << subst("virtual void compute (int fullcount, $0** input, $0** output) {", xfloat());
+
+ tab(n+2,fout); fout << "GetRealTime();";
+
+ tab(n+2,fout); fout << "this->input = input;";
+ tab(n+2,fout); fout << "this->output = output;";
+
+ tab(n+2,fout); fout << "StartMeasure();";
+
+ tab(n+2,fout); fout << "for (fIndex = 0; fIndex < fullcount; fIndex += " << gVecSize << ") {";
+
+ tab(n+3,fout); fout << "fFullCount = min ("<< gVecSize << ", fullcount-fIndex);";
+ tab(n+3,fout); fout << "TaskQueue::Init();";
+ printlines (n+3, fZone2cCode, fout);
+
+ tab(n+3,fout); fout << "fIsFinished = false;";
+ tab(n+3,fout); fout << "fThreadPool->SignalAll(fDynamicNumThreads - 1, this);";
+ tab(n+3,fout); fout << "computeThread(0);";
+ tab(n+3,fout); fout << "while (!fThreadPool->IsFinished()) {}";
+
+ tab(n+2,fout); fout << "}";
+
+ tab(n+2,fout); fout << "StopMeasure(fStaticNumThreads, fDynamicNumThreads);";
+
+ tab(n+1,fout); fout << "}";
+
+ tab(n+1,fout); fout << "void computeThread(int cur_thread) {";
+ printlines (n+2, fZone1Code, fout);
+ printlines (n+2, fZone2Code, fout);
+
+ tab(n+2,fout); fout << "// Init graph state";
+
+ tab(n+2,fout); fout << "{";
+ tab(n+3,fout); fout << "TaskQueue taskqueue(cur_thread);";
+ tab(n+3,fout); fout << "int tasknum = -1;";
+ tab(n+3,fout); fout << "int count = fFullCount;";
+
+ // Init input and output
+ tab(n+3,fout); fout << "// Init input and output";
+ printlines (n+3, fZone3Code, fout);
+
+ tab(n+3,fout); fout << "while (!fIsFinished) {";
+ tab(n+4,fout); fout << "switch (tasknum) {";
+
+ // Work stealing task
+ tab(n+5, fout); fout << "case WORK_STEALING_INDEX: { ";
+ tab(n+6, fout); fout << "tasknum = TaskQueue::GetNextTask(cur_thread, fDynamicNumThreads);";
+ tab(n+6, fout); fout << "break;";
+ tab(n+5, fout); fout << "} ";
+
+ // End task
+ tab(n+5, fout); fout << "case LAST_TASK_INDEX: { ";
+ tab(n+6, fout); fout << "fIsFinished = true;";
+ tab(n+6, fout); fout << "break;";
+ tab(n+5, fout); fout << "} ";
+
+ gTaskCount = START_TASK_INDEX;
+
+ // DSP tasks
+ printLoopGraphScheduler (n+5,fout);
+
+ tab(n+4,fout); fout << "}";
+ tab(n+3,fout); fout << "}";
+ tab(n+2,fout); fout << "}";
+ tab(n+1,fout); fout << "}";
+}
+
+/**
+ * Print an auxillary C++ class corresponding to an integer init signal
+ */
+void SigIntGenKlass::println(int n, ostream& fout)
+{
+ list<Klass* >::iterator k;
+
+ tab(n,fout); fout << "class " << fKlassName << " {";
+
+ tab(n,fout); fout << " private:";
+ tab(n+1,fout); fout << "int \tfSamplingFreq;";
+
+ for (k = fSubClassList.begin(); k != fSubClassList.end(); k++) (*k)->println(n+1, fout);
+
+ printlines(n+1, fDeclCode, fout);
+
+ tab(n,fout); fout << " public:";
+
+ tab(n+1,fout); fout << "int getNumInputs() \t{ "
+ << "return " << fNumInputs << "; }";
+ tab(n+1,fout); fout << "int getNumOutputs() \t{ "
+ << "return " << fNumOutputs << "; }";
+
+ tab(n+1,fout); fout << "void init(int samplingFreq) {";
+ tab(n+2,fout); fout << "fSamplingFreq = samplingFreq;";
+ printlines(n+2, fInitCode, fout);
+ tab(n+1,fout); fout << "}";
+
+ tab(n+1,fout); fout << "void fill (int count, int output[]) {";
+ printlines (n+2, fZone1Code, fout);
+ printlines (n+2, fZone2Code, fout);
+ printlines (n+2, fZone2bCode, fout);
+ printlines (n+2, fZone3Code, fout);
+ printLoopGraphInternal (n+2,fout);
+ tab(n+1,fout); fout << "}";
+
+ tab(n,fout); fout << "};\n" << endl;
+}
+
+/**
+ * Print an auxillary C++ class corresponding to an float init signal
+ */
+void SigFloatGenKlass::println(int n, ostream& fout)
+{
+ list<Klass* >::iterator k;
+
+ tab(n,fout); fout << "class " << fKlassName << " {";
+
+ tab(n,fout); fout << " private:";
+ tab(n+1,fout); fout << "int \tfSamplingFreq;";
+
+ for (k = fSubClassList.begin(); k != fSubClassList.end(); k++) (*k)->println(n+1, fout);
+
+ printlines(n+1, fDeclCode, fout);
+
+ tab(n,fout); fout << " public:";
+
+ tab(n+1,fout); fout << "int getNumInputs() \t{ "
+ << "return " << fNumInputs << "; }";
+ tab(n+1,fout); fout << "int getNumOutputs() \t{ "
+ << "return " << fNumOutputs << "; }";
+
+ tab(n+1,fout); fout << "void init(int samplingFreq) {";
+ tab(n+2,fout); fout << "fSamplingFreq = samplingFreq;";
+ printlines(n+2, fInitCode, fout);
+ tab(n+1,fout); fout << "}";
+
+ tab(n+1,fout); fout << subst("void fill (int count, $0 output[]) {", ifloat());
+ printlines (n+2, fZone1Code, fout);
+ printlines (n+2, fZone2Code, fout);
+ printlines (n+2, fZone2bCode, fout);
+ printlines (n+2, fZone3Code, fout);
+ printLoopGraphInternal(n+2,fout);
+ tab(n+1,fout); fout << "}";
+
+ tab(n,fout); fout << "};\n" << endl;
+}
+
+static void merge (set<string>& dst, set<string>& src)
+{
+ set<string>::iterator i;
+ for (i = src.begin(); i != src.end(); i++) dst.insert(*i);
+}
+
+void Klass::collectIncludeFile(set<string>& S)
+{
+ list<Klass* >::iterator k;
+
+ for (k = fSubClassList.begin(); k != fSubClassList.end(); k++) (*k)->collectIncludeFile(S);
+ merge(S, fIncludeFileSet);
+}
+
+void Klass::collectLibrary(set<string>& S)
+{
+ list<Klass* >::iterator k;
+
+ for (k = fSubClassList.begin(); k != fSubClassList.end(); k++) (*k)->collectLibrary(S);
+ merge(S, fLibrarySet);
+}
projects / Faustine.git / blobdiff