ProgramPass Class Reference

#include <ProgramPass.hh>

Inheritance diagram for ProgramPass:

Collaboration diagram for ProgramPass:

Public Member Functions
	ProgramPass (InterPassData &data)
virtual	~ProgramPass ()
virtual void	handleProgram (TTAProgram::Program &program, const TTAMachine::Machine &targetMachine)
Public Member Functions inherited from SchedulerPass
	SchedulerPass (InterPassData &data)
virtual	~SchedulerPass ()
InterPassData &	interPassData ()
virtual std::string	shortDescription () const =0
virtual std::string	longDescription () const

Static Public Member Functions
static void	executeProcedurePass (TTAProgram::Program &program, const TTAMachine::Machine &targetMachine, ProcedurePass &procedurePass)

Detailed Description

Interface for scheduler passes that handle fully-linked programs.

Definition at line 52 of file ProgramPass.hh.

Constructor & Destructor Documentation

ProgramPass()

ProgramPass::ProgramPass

(

InterPassData &

data

)

Constructor.

Definition at line 48 of file ProgramPass.cc.

                                            :
    SchedulerPass(data)  {
}

~ProgramPass()

ProgramPass::~ProgramPass ( )

virtual

Destructor.

Definition at line 55 of file ProgramPass.cc.

                          {
}

Member Function Documentation

executeProcedurePass()

void ProgramPass::executeProcedurePass ( TTAProgram::Program &  program, const TTAMachine::Machine &  targetMachine, ProcedurePass &  procedurePass  )

static

Executes the given procedure pass on each procedure of the given program in the original program order.

A helper function for implementing most simplest types of program passes.

Parameters

program	The program to handle.
machine	The target machine if any. (NullMachine::instance() if target machine is irrelevant).
procedurePass	The procedure pass to execute.

Exceptions

In	case handling is unsuccesful for any reason (cfg might still get modified).

Definition at line 72 of file ProgramPass.cc.

                                  {
    boost::timer totalTime;
 
    FunctionNameList proceduresToProcess, proceduresToIgnore;
    if (procedurePass.interPassData().hasDatum("FUNCTIONS_TO_PROCESS")) {
        proceduresToProcess = 
            dynamic_cast<FunctionNameList&>(
                procedurePass.interPassData().datum("FUNCTIONS_TO_PROCESS"));
    } else if (procedurePass.interPassData().hasDatum("FUNCTIONS_TO_IGNORE")) {
        proceduresToIgnore = 
            dynamic_cast<FunctionNameList&>(
                procedurePass.interPassData().datum("FUNCTIONS_TO_IGNORE"));
    }
    
    std::size_t proceduresDone = 0;
    // always call procedureCount() again because a pass might have
    // added a new procedure to the program that needs to be handled
    for (int procIndex = 0; procIndex < program.procedureCount(); 
         ++procIndex) {
        TTAProgram::Procedure& proc = program.procedure(procIndex);
               
        if (proceduresToProcess.size() > 0 && 
            proceduresToProcess.find(proc.name()) == 
            proceduresToProcess.end())
            continue;
 
        if (proceduresToIgnore.size() > 0 &&
            proceduresToIgnore.find(proc.name()) !=
            proceduresToIgnore.end())
            continue;
            
 
        boost::timer currentTime;
        std::size_t totalProcedures = 0;
        if (Application::verboseLevel() > 0) {
 
            if (proceduresToProcess.size() > 0) {
                totalProcedures = proceduresToProcess.size();
            } else {
                totalProcedures = program.procedureCount();
            }
 
            totalProcedures -= proceduresToIgnore.size();
            Application::logStream() 
                << std::endl
                << "procedure: " << proc.name() 
                << (boost::format(" (%d/%d)") 
                    % (proceduresDone + 1) % totalProcedures).str();
        }
        procedurePass.handleProcedure(proc, targetMachine);
        ++proceduresDone;
 
        if (Application::verboseLevel() > 0) {
            double cur = currentTime.elapsed();
            double tot = totalTime.elapsed();
            long currentElapsed = static_cast<long>(cur);
            long totalElapsed = static_cast<long>(tot);
            long eta = 
                static_cast<long>(
                    (tot / proceduresDone) * 
                    (totalProcedures - proceduresDone));
            Application::logStream()
                << (boost::format(
                        " %d min %d s. Total %d min %d s. ETA in %d min %d s")
                    % (currentElapsed / 60) % (currentElapsed % 60)
                    % (totalElapsed / 60) % (totalElapsed % 60)
                    % (eta / 60) % (eta % 60)).str()
                << std::endl;
        }
    }
}

References InterPassData::datum(), ProcedurePass::handleProcedure(), InterPassData::hasDatum(), SchedulerPass::interPassData(), Application::logStream(), TTAProgram::Procedure::name(), program, and Application::verboseLevel().

Referenced by SimpleIfConverter::handleProgram(), handleProgram(), PreOptimizer::handleProgram(), and BBSchedulerController::handleProgram().

Here is the call graph for this function:

handleProgram()

void ProgramPass::handleProgram ( TTAProgram::Program &  program, const TTAMachine::Machine &  targetMachine  )

virtual

Reimplemented in BBSchedulerController, PreOptimizer, and SimpleIfConverter.

Definition at line 147 of file ProgramPass.cc.

                                                                        {
    ProcedurePass* procPass = dynamic_cast<ProcedurePass*>(this);
    if (procPass != NULL) {
        executeProcedurePass(program, targetMachine, *procPass);
    } else {
        abortWithError("Program pass is not also a procedure pass so you "
                       "must overload handleProgram method!");
    }
}

References abortWithError, executeProcedurePass(), and program.

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• ProgramPass.hh
• ProgramPass.cc