GenerateProcessor Class Reference

#include <GenerateProcessor.hh>

Inheritance diagram for GenerateProcessor:

Collaboration diagram for GenerateProcessor:

Public Member Functions
	GenerateProcessor ()
virtual	~GenerateProcessor ()
bool	generateProcessor (int argc, char *argv[])
Public Member Functions inherited from ProGe::ProGeUI
virtual	~ProGeUI ()
	ProGeUI ()
void	generateProcessor (const ProGeOptions &options, int imemWidthInMAUs, std::ostream &errorStream, std::ostream &warningStream, std::ostream &verboseStream)
void	generateTestBench (const ProGe::HDL language, const std::string &dstDir, const std::string &progeOutDir)
void	generateScripts (const ProGe::HDL language, const std::string &dstDir, const std::string &progeOutDir, const std::string &sharedOutDir, const std::string &testBenchDir, const std::string &simulationRuntime)
void	loadMachine (const TTAMachine::Machine &adf)
void	loadBinaryEncoding (const BinaryEncoding &bem)
void	loadMachineImplementation (const IDF::MachineImplementation &idf)

Private Member Functions
void	getOutputDir (const ProGeCmdLineOptions &options, std::string &outputDir)
bool	listICDecPluginParameters (const std::string &pluginFile) const
void	listIntegrators () const
bool	validIntegratorParameters (const ProGeCmdLineOptions &options) const
MemType	string2MemType (const std::string &memoryString) const

Additional Inherited Members
Protected Member Functions inherited from ProGe::ProGeUI
void	loadMachine (const std::string &adfFile)
void	loadBinaryEncoding (const std::string &bemFile)
void	loadMachineImplementation (const std::string &idfFile)
void	loadProcessorConfiguration (const std::string &configurationFile)
void	loadICDecoderGeneratorPlugin (const std::string &pluginFile, const std::string &pluginName)
void	integrateProcessor (std::ostream &warningStream, std::ostream &errorStream, std::string progeOutDir, std::string sharedOutputDir, const std::string &platformIntegrator, const std::string &coreEntityName, const std::string &programName, const std::string &deviceFamily, const std::string &deviceName, MemType imem, MemType dmem, HDL language, int fmax, bool syncReset)
Protected Attributes inherited from ProGe::ProGeUI
TTAMachine::Machine *	machine_
	The loaded machine. More...

Detailed Description

Implements the command line user interface 'generateprocessor'.

Definition at line 46 of file GenerateProcessor.hh.

Constructor & Destructor Documentation

GenerateProcessor()

GenerateProcessor::GenerateProcessor

(

)

The constructor.

Definition at line 82 of file GenerateProcessor.cc.

                                     {
}

~GenerateProcessor()

GenerateProcessor::~GenerateProcessor ( )

virtual

The destructor.

Definition at line 89 of file GenerateProcessor.cc.

                                      {
}

Member Function Documentation

generateProcessor()

bool GenerateProcessor::generateProcessor	(	int	argc,
		char *	argv[]
	)

Parses the command line arguments and generates the processor.

Returns

True if the generation of the processor was succesful, otherwise false.

Definition at line 100 of file GenerateProcessor.cc.

                                                           {
 
    ProGeCmdLineOptions options;
    string entity = "";
 
    try {
 
        options.parse(argv, argc);
        ProGeOptions progeOptions(options);
 
        std::string pluginParamQuery = options.pluginParametersQuery();
        if (pluginParamQuery != "") {
            return listICDecPluginParameters(pluginParamQuery);
        }
 
        if (options.isVerboseSwitchDefined()) {
            Application::setVerboseLevel(
                Application::VERBOSE_LEVEL_INCREASED);
        }
 
        if (options.isVerboseSpamSwitchDefined()) {
            Application::setVerboseLevel(Application::VERBOSE_LEVEL_SPAM);
        }
 
        if (options.listAvailableIntegrators()) {
            listIntegrators();
            return true;
        }
        
        if (options.numberOfArguments() == 0) {
            options.printHelp();
            return false;
        }
 
        if (!validIntegratorParameters(options)) {
            options.printHelp();
            return false;
        }
 
        if (!options.forceOutputDirectory() &&
            FileSystem::fileExists(progeOptions.outputDirectory)) {
            cerr << "Error: Output directory " << progeOptions.outputDirectory
                 << " already exists." << endl;
            return false;
        }
 
        string processorDefinition = options.processorToGenerate();
        if (FileSystem::fileExtension(processorDefinition) == ".adf") {
            loadMachine(processorDefinition);
        } else if (FileSystem::fileExtension(processorDefinition) == 
                   ".pcf") {
            loadProcessorConfiguration(processorDefinition);
        } else {
            cerr << "Unknown file: " << processorDefinition 
                 << ". The given file must be either an ADF or PCF file." 
                 << endl;
            throw IllegalCommandLine(__FILE__, __LINE__, __func__);
        }
        
        string bem = options.bemFile();
        string idf = options.idfFile();
        string hdl = options.hdl();
 
        int imemWidthInMAUs = DEFAULT_IMEMWIDTH_IN_MAUS;
        if (machine_->isRISCVMachine()) {
            imemWidthInMAUs = 4;
        }
 
        if (bem != "") {
            loadBinaryEncoding(bem);
        }
        if (idf != "") {
            loadMachineImplementation(idf);
        }
 
        ProGeUI::generateProcessor(
            progeOptions, imemWidthInMAUs, std::cerr, std::cerr, std::cerr);
    } catch (ParserStopRequest) {
        return false;
    } catch (const IllegalCommandLine& exception) {
        cerr << exception.errorMessage() << endl;
        return false;
    } catch (const Exception& e) {
        cerr << e.errorMessage() << endl;
        cerr << "Exception thrown at: " << e.fileName() << ":" 
             << e.lineNum() << endl;
        cerr << "  message: " << e.errorMessage() << endl;
        return false;
    }
 
    ProGeOptions progeOptions(options);
 
    if (options.generateTestbench()) {
        string testBenchDir = progeOptions.outputDirectory +
                              FileSystem::DIRECTORY_SEPARATOR + "tb";
        try {
            ProGeUI::generateTestBench(
                progeOptions.language, testBenchDir,
                progeOptions.outputDirectory);
        } catch (const Exception& e) {
            std::cerr << "Warning: Processor Generator failed to "
                    << "generate testbench." << std::endl;
            std::cerr << e.errorMessage() << std::endl;
        }
 
        try {
            ProGeUI::generateScripts(
                progeOptions.language, progeOptions.outputDirectory,
                progeOptions.outputDirectory,
                progeOptions.sharedOutputDirectory, testBenchDir,
                progeOptions.simulationRuntime);
        } catch (const Exception& e) {
            std::cerr << "Warning: Processor Generator failed to "
                    << "generate simulation/compilation scripts."
                    << std::endl;
            std::cerr << e.errorMessage() << std::endl;
        }
    }
    
    string integrator = options.integratorName();
    if (!integrator.empty()) {
        if (progeOptions.language == Verilog) {
            std::cerr << "Verilog is not yet supported by Platform Integrator"
                      << std::endl;
            return false;
        }
 
        string progeOutDir = progeOptions.outputDirectory;
        string sharedOutDir = progeOptions.sharedOutputDirectory;
        if (!options.useAbsolutePaths()) {
            string cwd = FileSystem::currentWorkingDir();
            FileSystem::relativeDir(cwd, progeOutDir);
            FileSystem::relativeDir(cwd, sharedOutDir);
        }
 
        string platformDir = progeOutDir + FileSystem::DIRECTORY_SEPARATOR +
        "platform";
        string program = 
            StringTools::chopString(options.tpefName(), ".tpef").at(0);
        MemType imem = string2MemType(options.imemType());
        MemType dmem = string2MemType(options.dmemType());
        int fmax = options.clockFrequency();
        string devFamily = options.deviceFamilyName();
        string devName = options.deviceName();
        bool syncReset = options.syncReset();
 
        try {
            ProGeUI::integrateProcessor(
                std::cout, std::cerr, progeOutDir, sharedOutDir, integrator,
                progeOptions.entityName, program, devFamily, devName, imem,
                dmem, progeOptions.language, fmax, syncReset);
        } catch (const Exception& e) {
            std::cerr << "Processor integration failed: "
                      << e.procedureName() << ": "
                      << e.errorMessage() << endl;
            return false;
        }
    }
    
    return true;
}

References __func__, StringTools::chopString(), FileSystem::currentWorkingDir(), DEFAULT_IMEMWIDTH_IN_MAUS, FileSystem::DIRECTORY_SEPARATOR, ProGeOptions::entityName, Exception::errorMessage(), FileSystem::fileExists(), FileSystem::fileExtension(), Exception::fileName(), ProGe::ProGeUI::generateProcessor(), ProGe::ProGeUI::generateScripts(), ProGe::ProGeUI::generateTestBench(), ProGe::ProGeUI::integrateProcessor(), CmdLineOptions::isVerboseSpamSwitchDefined(), CmdLineOptions::isVerboseSwitchDefined(), ProGeOptions::language, Exception::lineNum(), loadMachine(), CmdLineParser::numberOfArguments(), options, ProGeOptions::outputDirectory, CmdLineOptions::parse(), MachInfoCmdLineOptions::printHelp(), Exception::procedureName(), program, FileSystem::relativeDir(), Application::setVerboseLevel(), ProGeOptions::sharedOutputDirectory, ProGeOptions::simulationRuntime, Application::VERBOSE_LEVEL_INCREASED, Application::VERBOSE_LEVEL_SPAM, and ProGe::Verilog.

Referenced by main().

Here is the call graph for this function:

getOutputDir()

void GenerateProcessor::getOutputDir ( const ProGeCmdLineOptions &  options, std::string &  outputDir  )

private

Generates the output directory name.

Parameters

options	Proge command line options.
outputDir	String where output directory name is to be stored.

Definition at line 269 of file GenerateProcessor.cc.

                          {
 
    outputDir = options.outputDirectory();
 
    if (outputDir == "") {
        outputDir = FileSystem::currentWorkingDir() + 
            FileSystem::DIRECTORY_SEPARATOR + "proge-output";
    } else {
        outputDir = FileSystem::expandTilde(outputDir);
        outputDir = FileSystem::absolutePathOf(outputDir);
    }
}

References FileSystem::absolutePathOf(), FileSystem::currentWorkingDir(), FileSystem::DIRECTORY_SEPARATOR, FileSystem::expandTilde(), and options.

Here is the call graph for this function:

listICDecPluginParameters()

bool GenerateProcessor::listICDecPluginParameters ( const std::string &  pluginFile ) const

private

Prints listing of IC/Decoder generator plugin parameters to stdout.

Parameters

pluginFile

Full path to the plugin file.

Definition at line 290 of file GenerateProcessor.cc.

                                       {
 
    // An ugly way to determine the plugin name which should be the
    // file name minus the "Plugin.so" ending.
    string pluginName = FileSystem::fileOfPath(pluginFile);
    pluginName = FileSystem::fileNameBody(pluginFile);
    if (pluginName.length() < 6 ||
        pluginName.substr(pluginName.length() - 6) != "Plugin") {
        
        cerr << "Unable to determine plugin name. Plugin file must be named "
             << "'<plugin name>Plugin.so'." << endl;;
        return false;
    }
 
    pluginName = pluginName.substr(0, pluginName.length() - 6);
 
    // initialize plugin tool
    PluginTools pluginTool;
    std::vector<string> pluginPaths = Environment::icDecoderPluginPaths();
    for (std::vector<string>::const_iterator iter = pluginPaths.begin();
         iter != pluginPaths.end(); iter++) {
        try {
            pluginTool.addSearchPath(*iter);
        } catch (const FileNotFound&) {
        }
    }
 
    try {
        pluginTool.registerModule(pluginFile);
    } catch (const FileNotFound&) {
        cerr << "Plugin file '" << pluginFile << "' not found." << endl;
        return false;
    } catch (Exception& e) {
        cerr << "Error loading plugin file '" << pluginFile << "': "
             << e.errorMessage() << endl;
 
        return false;
    }
 
    
    ICDecoderGeneratorPlugin* (*creator)(
        TTAMachine::Machine&, BinaryEncoding&);
 
    ICDecoderGeneratorPlugin* plugin;
 
    TTAMachine::Machine machine;
    BinaryEncoding bem;
 
    try {
        pluginTool.importSymbol(
            "create_generator_plugin_" + pluginName, creator, pluginFile);
 
        plugin = creator(machine, bem);
    } catch (Exception& e) {
        cerr << "Error loading plugin '" << pluginName << "' from '"
             << pluginFile << "':" << endl;
        cerr << e.errorMessage() << endl;
        return false;
    }
 
    assert(plugin != NULL);
 
    cout << pluginName << ":" << endl;
    cout << plugin->pluginDescription() << endl << endl;
    cout << "Recognized parameters:" << endl
         << "----------------------" << endl;
 
    for (int i = 0; i < plugin->recognizedParameterCount(); i++) {
        std::string paramName = plugin->recognizedParameter(i);
        cout << paramName << endl;
        cout << "   " << plugin->parameterDescription(paramName) << endl;
        cout << endl;
    }
    cout << "----------------------" << endl;
 
    delete plugin;
    return true;
}

References PluginTools::addSearchPath(), assert, Exception::errorMessage(), FileSystem::fileNameBody(), FileSystem::fileOfPath(), Environment::icDecoderPluginPaths(), PluginTools::importSymbol(), machine, and PluginTools::registerModule().

Here is the call graph for this function:

listIntegrators()

void GenerateProcessor::listIntegrators ( ) const

private

Definition at line 372 of file GenerateProcessor.cc.

                                         {
    
    std::vector<PlatformIntegrator*> integrators;
    // append new integrators here
    integrators.push_back(new Stratix2DSPBoardIntegrator());
    integrators.push_back(new Stratix3DevKitIntegrator());
    integrators.push_back(new KoskiIntegrator());
    integrators.push_back(new AvalonIntegrator());
    integrators.push_back(new AlmaIFIntegrator());
 
    for (unsigned int i = 0; i < integrators.size(); i++) {
        integrators.at(i)->printInfo(std::cout);
        delete integrators.at(i);
    }
    std::cout << "Please refer to the user manual for more information on "
              << "Platform Integrators." << std::endl;
}

string2MemType()

MemType GenerateProcessor::string2MemType ( const std::string &  memoryString ) const

private

Definition at line 440 of file GenerateProcessor.cc.

                                                                     {
 
    MemType memory = UNKNOWN;
    if (memoryString == "none") {
        memory = NONE;
    } else if (memoryString == "vhdl_array") {
        memory = VHDL_ARRAY;
    } else if (memoryString == "onchip") {
        memory = ONCHIP;
    } else if (memoryString == "sram") {
        memory = SRAM;
    } else if (memoryString == "dram") {
        memory = DRAM;
    }
    return memory;
}

References DRAM, NONE, ONCHIP, SRAM, UNKNOWN, and VHDL_ARRAY.

validIntegratorParameters()

bool GenerateProcessor::validIntegratorParameters ( const ProGeCmdLineOptions &  options ) const

private

Definition at line 392 of file GenerateProcessor.cc.

                                              {
 
    if (options.integratorName().empty()) {
        return true;
    }
    string entity = options.entityName();
    if (entity.empty()) {
        std::cerr << "Entity name must be given" << endl;
        return false;
    }
    string program = options.tpefName();
    if (program.empty()) {
        std::cerr
            << "Tpef is required for platform integration" << endl;
        return false;
    }
    if (!StringTools::endsWith(program, ".tpef")) {
        std::cerr << "Program does not have '.tpef' ending" << endl;
        return false;
    }
 
    string imem = options.imemType();
    if (imem.empty()) {
        std::cerr << "Instruction memory type is required for platform "
                  << "integration" << endl;
        return false;
    }
    string dmem = options.dmemType();
    if (dmem.empty()) {
        std::cerr << "Data memory type is required for platform integration"
                  << endl;
        return false;
    }
    if (string2MemType(imem) == UNKNOWN) {
        std::cerr
            << "Invalid instruction memory type " << imem << endl;
        return false;
    }
    if (string2MemType(dmem) == UNKNOWN) {
        std::cerr << "Invalid data memory type " << dmem << endl;
        return false;
    }
    return true;
}

References StringTools::endsWith(), options, program, and UNKNOWN.

Here is the call graph for this function:

---

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

• GenerateProcessor.hh
• GenerateProcessor.cc