#include <iostream>
#include <cmath>
#include "EstimatorCmdLineOptions.hh"
#include "Machine.hh"
#include "ADFSerializer.hh"
#include "MachineImplementation.hh"
#include "IDFSerializer.hh"
#include "Program.hh"
#include "NullProgram.hh"
#include "Binary.hh"
#include "FileSystem.hh"
#include "BinaryStream.hh"
#include "BinaryReader.hh"
#include "TPEFProgramFactory.hh"
#include "ExecutionTrace.hh"
#include "Estimator.hh"

Include dependency graph for EstimatorCmdLineUI.cc:

Functions
bool	loadInputs (EstimatorCmdLineOptions &options)

void	cleanup ()

int	main (int argc, char *argv[])

Variables
bool	energyEstimation = false
	this is set to true in case energy estimation can be performed with the given input files

TTAMachine::Machine *	machine = NULL
	the architecture definition of the estimated processor

IDF::MachineImplementation *	implementation = NULL
	the implementation definition of the estimated processor

TTAProgram::Program *	program = NULL
	the estimated program is stored in this variable (in case energy estimation is wanted

ExecutionTrace *	trace = NULL
	the execution trace database

Detailed Description

Implementation of estimate.

The command line user interface of cost estimator.

Author: Pekka Jääskeläinen 2005 (pjaaskel-no.spam-cs.tut.fi)

Note: rating: red

Definition in file EstimatorCmdLineUI.cc.

Function Documentation

◆ cleanup()

void cleanup ( )

Frees all allocated input resources.

Definition at line 179 of file EstimatorCmdLineUI.cc.

               {
 
    delete machine;
    machine = NULL;
    delete implementation;
    implementation = NULL;
 
    if (energyEstimation) {
        delete program;
        program = NULL;
        delete trace;
        trace = NULL;
    }
}

References energyEstimation, implementation, machine, program, and trace.

Referenced by main().

◆ loadInputs()

bool loadInputs ( EstimatorCmdLineOptions & options )

Loads the input files using the command line arguments.

Parameters

options The command line arguments.

Returns: True in case there was no errors in the arguments.

Definition at line 75 of file EstimatorCmdLineUI.cc.

                                             {
    
    if (options.numberOfArguments() < 2) {
        std::cerr << "ADF and IDF are required." << std::endl;
        return false;
    }
    else if (options.numberOfArguments() > 2) {
        std::cerr << "Illegal command line arguments." << std::endl;
        return false;
    }
    
    std::string adfFile = options.argument(1);
    std::string idfFile = options.argument(2);    
    
    try {
        ADFSerializer serializer;
        serializer.setSourceFile(adfFile);
        machine = serializer.readMachine(); 
    } catch (const Exception& e) {
        std::cerr << "Error while loading ADF. " << e.errorMessage() 
                  << std::endl;
        return false;
    }
 
    try {
        IDF::IDFSerializer serializer;
        serializer.setSourceFile(idfFile);
        implementation = serializer.readMachineImplementation();    
    } catch (const Exception& e) {
        std::cerr << "Error while loading IDF. " << e.errorMessage() 
                  << std::endl;
        return false;
    }
 
    if (options.TPEF() != "") {
        
        if (options.traceDB() == "") {
            std::cerr << "Also TraceDB is required for energy estimation."
                      << std::endl;
            return false;
        }
 
        TPEF::Binary* tpef = NULL;
        try {
            const std::string tpefFileName = options.TPEF();
            if (!FileSystem::fileExists(tpefFileName)) {
                std::cerr << "Error while loading TPEF. " 
                          << "Cannot open file '" << tpefFileName << "'."
                          << std::endl;
                delete machine;
                machine = NULL;
                delete implementation;
                implementation = NULL;
                return EXIT_FAILURE;
            }
            TPEF::BinaryStream binaryStream(tpefFileName);
 
            // read first to a TPEF Handler Module
            tpef = TPEF::BinaryReader::readBinary(binaryStream);
 
            assert(tpef != NULL);
            assert(machine != NULL);
 
            // convert the loaded TPEF to POM
            TTAProgram::TPEFProgramFactory factory(*tpef, *machine);
            program = factory.build();
            delete tpef;
            tpef = NULL;      
        } catch (const Exception& e) {
            std::cerr << "Error while loading TPEF. " << e.errorMessage()
                      << std::endl;
            delete tpef;
            tpef = NULL;
            return false;
        }
    }
 
    if (options.traceDB() != "") {
        
        const std::string traceDBFileName = options.traceDB();
        if (!FileSystem::fileExists(traceDBFileName)) {
            std::cerr << "Error while loading TraceDB. " 
                      << "Cannot open file '" << traceDBFileName << "'."
                      << std::endl;
            return false;
        }
 
        try {
            trace = ExecutionTrace::open(traceDBFileName);
        } catch (const Exception& e) {
            std::cerr << "Error while loading TraceDB. " << e.errorMessage() 
                      << std::endl;
            return false;
        }
        if (program == NULL)
            program = &TTAProgram::NullProgram::instance();
        energyEstimation = true;
    }
    return true;
}

References CmdLineParser::argument(), assert, TTAProgram::TPEFProgramFactory::build(), energyEstimation, Exception::errorMessage(), FileSystem::fileExists(), implementation, TTAProgram::NullProgram::instance(), machine, CmdLineParser::numberOfArguments(), ExecutionTrace::open(), options, program, TPEF::BinaryReader::readBinary(), ADFSerializer::readMachine(), IDF::IDFSerializer::readMachineImplementation(), XMLSerializer::setSourceFile(), and trace.

Referenced by main().

Here is the call graph for this function:

◆ main()

int main	(	int	argc,
		char *	argv[]
	)

Main function.

Parses the command line and executes cost estimation functionality.

Parameters

argc	The command line argument count.
argv	The command line arguments (passed to the interpreter).

Returns: The return status.

Definition at line 204 of file EstimatorCmdLineUI.cc.

                             {
 
    Application::initialize();    
 
    EstimatorCmdLineOptions *options = new EstimatorCmdLineOptions();
    try {
        options->parse(argv, argc);
        Application::setCmdLineOptions(options);
    } catch (ParserStopRequest const&) {
        return EXIT_SUCCESS;
    } catch (const IllegalCommandLine& i) {
        std::cerr << i.errorMessage() << std::endl;
        return EXIT_FAILURE;
    }
 
    if (!loadInputs(*options)) {
        cleanup();
        return EXIT_FAILURE;
    }
 
    Estimator estimator;
    if (options->totalArea() || !options->runOnlyEstimations()) {
        CostEstimator::AreaInGates totalArea = -1;
        try {
            totalArea = round(estimator.totalArea(*machine, *implementation));
        } catch (const Exception& e) {
            std::cerr << "estimation failed: " + e.errorMessage() 
                      << std::endl;
        }
 
        if (totalArea >= 0) {
            std::cout << "total area: " << totalArea << " gates"
                      << std::endl;
        }
    }
 
    if (options->longestPath() || !options->runOnlyEstimations()) {
        std::cout << "delay of the longest path: ";
        try {
            std::cout 
                << round(estimator.longestPath(*machine, *implementation))
                << " ns" << std::endl;
        } catch (const Exception& e) {
            std::cerr << "estimation failed: " + e.errorMessage() 
                      << std::endl;
        }
    }
 
    if (energyEstimation && 
            (options->totalEnergy() || !options->runOnlyEstimations())) {
        std::cout << "total consumed energy: ";
        try {
            std::cout 
                << estimator.totalEnergy(
                        *machine, *implementation, *program, *trace)
                << " mJ" << std::endl;
        } catch (const Exception& e) {
            std::cerr << "estimation failed: " + e.errorMessage() 
                      << std::endl;
        }
    }
 
    cleanup();
    return EXIT_SUCCESS;
}