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 50 of file ProgramPass.cc.

                                            :
    SchedulerPass(data)  {
}

~ProgramPass()

ProgramPass::~ProgramPass ( )

virtual

Destructor.

Definition at line 57 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 74 of file ProgramPass.cc.

                                  {
    auto totalTimeStart = std::chrono::steady_clock::now();
 
    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;
 
        auto currentTimeStart = std::chrono::steady_clock::now();
        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) {
            long currentElapsed =
                std::chrono::duration_cast<std::chrono::seconds>(
                    std::chrono::steady_clock::now() - currentTimeStart)
                    .count();
            long totalElapsed =
                std::chrono::duration_cast<std::chrono::seconds>(
                    std::chrono::steady_clock::now() - totalTimeStart)
                    .count();
            long eta = static_cast<long>(
                (totalElapsed / 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 PreOptimizer::handleProgram(), handleProgram(), SimpleIfConverter::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 PreOptimizer, SimpleIfConverter, and BBSchedulerController.

Definition at line 151 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