loop.cpp

Go to the documentation of this file.

#include "loop.hh"
extern bool gVectorSwitch;
extern bool gOpenMPSwitch;
extern bool gOpenMPLoop;

using namespace std;

static void tab (int n, ostream& fout)
{
    fout << '\n';
    while (n--) fout << '\t';
}


static 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;
    }
}


Loop::Loop(Tree recsymbol, Loop* encl, const string& size)
        : fIsRecursive(true), fRecSymbolSet(singleton(recsymbol)), fEnclosingLoop(encl), fSize(size), fOrder(-1), fIndex(-1), fUseCount(0), fPrinted(0)
{}


Loop::Loop(Loop* encl, const string& size) 
        : fIsRecursive(false), fRecSymbolSet(nil), fEnclosingLoop(encl), fSize(size), fOrder(-1), fIndex(-1), fUseCount(0), fPrinted(0)
{}


bool Loop::hasRecDependencyIn(Tree S)
{
    Loop* l = this;
    while ( l && isNil(setIntersection(l->fRecSymbolSet,S)) ) l=l->fEnclosingLoop;
    return l != 0;
}

bool Loop::isEmpty()                  
{ 
    return fPreCode.empty() && fExecCode.empty() && fPostCode.empty() && (fExtraLoops.begin()==fExtraLoops.end()); 
}

void Loop::addPreCode (const string& str)    
{ 
   // cerr << this << "->addExecCode " << str << endl;
    fPreCode.push_back(str); 
}

void Loop::addExecCode (const string& str)    
{ 
   // cerr << this << "->addExecCode " << str << endl;
    fExecCode.push_back(str); 
}


void Loop::addPostCode (const string& str)    
{ 
   // cerr << this << "->addPostCode " << str << endl;
    fPostCode.push_front(str); 
}


void Loop::absorb (Loop* l)    
{ 
    // the loops must have the same number of iterations
    assert(fSize == l->fSize); 
    fRecSymbolSet = setUnion(fRecSymbolSet, l->fRecSymbolSet);

    // update loop dependencies by adding those from the absorbed loop
    fBackwardLoopDependencies.insert(l->fBackwardLoopDependencies.begin(), l->fBackwardLoopDependencies.end());  

    // add the line of code of the absorbed loop
    fPreCode.insert(fPreCode.end(), l->fPreCode.begin(), l->fPreCode.end());
    fExecCode.insert(fExecCode.end(), l->fExecCode.begin(), l->fExecCode.end());
    fPostCode.insert(fPostCode.begin(), l->fPostCode.begin(), l->fPostCode.end());
}


void Loop::println(int n, ostream& fout)
{
    for (list<Loop*>::const_iterator s = fExtraLoops.begin(); s != fExtraLoops.end(); s++) {
        (*s)->println(n, fout);
    }

    if (fPreCode.size()+fExecCode.size()+fPostCode.size() > 0) {
/*        if (gVectorSwitch) {
            tab(n,fout);
            fout << ((fIsRecursive) ? "// recursive loop" : "// vectorizable loop");
        }*/

        tab(n,fout); fout << "// LOOP " << this ;
        if (fPreCode.size()>0) {
            tab(n,fout); fout << "// pre processing";
            printlines(n, fPreCode, fout);
        }

        tab(n,fout); fout << "// exec code";
        tab(n,fout); fout << "for (int i=0; i<" << fSize << "; i++) {";
        printlines(n+1, fExecCode, fout);
        tab(n,fout); fout << "}";

        if (fPostCode.size()>0) {
            tab(n,fout); fout << "// post processing";
            printlines(n, fPostCode, fout);
        }
        tab(n,fout);
    }
}


void Loop::printParLoopln(int n, ostream& fout)
{
    for (list<Loop*>::const_iterator s = fExtraLoops.begin(); s != fExtraLoops.end(); s++) {
        tab(n,fout); fout << "#pragma omp single";
        tab(n,fout); fout << "{";
        (*s)->println(n+1, fout);
        tab(n,fout); fout << "}";
    }

    if (fPreCode.size()+fExecCode.size()+fPostCode.size() > 0) {

        tab(n,fout); fout << "// LOOP " << this ;
        if (fPreCode.size()>0) {
            tab(n,fout); fout << "#pragma omp single";
            tab(n,fout); fout << "{";
            tab(n+1,fout); fout << "// pre processing";
            printlines(n+1, fPreCode, fout);
            tab(n,fout); fout << "}";
        }

        tab(n,fout); fout << "// exec code";
        tab(n,fout); fout << "#pragma omp for";
        tab(n,fout); fout << "for (int i=0; i<" << fSize << "; i++) {";
        printlines(n+1, fExecCode, fout);
        tab(n,fout); fout << "}";

        if (fPostCode.size()>0) {
            tab(n,fout); fout << "#pragma omp single";
            tab(n,fout); fout << "{";
            tab(n+1,fout); fout << "// post processing";
            printlines(n+1, fPostCode, fout);
            tab(n,fout); fout << "}";
        }
        tab(n,fout);
    }
}

void Loop::printoneln(int n, ostream& fout)
{
    if (fPreCode.size()+fExecCode.size()+fPostCode.size() > 0) {
/*        if (gVectorSwitch) {
            tab(n,fout); 
            fout << ((fIsRecursive) ? "// recursive loop" : "// vectorizable loop");
        }*/
            
        tab(n,fout); fout << "for (int i=0; i<" << fSize << "; i++) {";
        if (fPreCode.size()>0) {
            tab(n+1,fout); fout << "// pre processing";
            printlines(n+1, fPreCode, fout);
        }
        printlines(n+1, fExecCode, fout);
        if (fPostCode.size()>0) {
            tab(n+1,fout); fout << "// post processing";
            printlines(n+1, fPostCode, fout);
        }
        tab(n,fout); fout << "}";
    }
}

//-------------------------------------------------------
void Loop::concat(Loop* l)
{
    assert(l->fUseCount == 1);
    assert(fBackwardLoopDependencies.size() == 1);
    assert((*fBackwardLoopDependencies.begin()) == l);
    
    fExtraLoops.push_front(l);
    fBackwardLoopDependencies = l->fBackwardLoopDependencies;   
}