ProGeScriptGenerator Class Reference

#include <ProGeScriptGenerator.hh>

Collaboration diagram for ProGeScriptGenerator:

Public Member Functions
	ProGeScriptGenerator (const ProGe::HDL language, const IDF::MachineImplementation &idf, const std::string &dstDir, const std::string &progeOutDir, const std::string &sharedOutDir, const std::string &testBenchDir, const std::string &toplevelEntity, const std::string &simulationRuntime="52390")
virtual	~ProGeScriptGenerator ()
void	generateAll ()
void	generateModsimCompile ()
void	generateGhdlCompile (std::string scriptName, std::string tbName, std::vector< std::list< std::string > > filesToCompile, bool clearWorkingDir)
void	generatePlatformGhdlCompile ()
void	generateIverilogCompile ()
void	generateModsimSimulate ()
void	generateGhdlSimulate ()
void	generatePlatformGhdlSimulate ()
void	generateIverilogSimulate ()

Private Member Functions
void	generateCompileStart (std::ostream &stream)
void	generateSimulationStart (std::ostream &stream)
void	createExecutableFile (const std::string &fileName)
void	outputScriptCommands (std::ostream &stream, const std::list< std::string > &files, const std::string &cmdPrefix, const std::string &cmdPostfix)
void	outputScriptCommand (std::ostream &stream, const std::string &file, const std::string &cmdPrefix, const std::string &cmdPostfix)
template<typename T >
void	findFiles (const std::string &perlre, T files, std::list< std::string > &found)
template<typename T >
void	findFiles (const std::string &perlre, T &files)
void	findText (const std::string &perlre, const unsigned int &matchRegion, const std::string &fileName, std::list< std::string > &found)
void	getBlockOrder (std::list< std::string > &order)
void	sortFilesFirst (std::list< std::string > &toSort, std::list< std::string > &acSort)
void	sortFilesLast (std::list< std::string > &toSort, std::list< std::string > &acSort)
template<typename CONT >
void	uniqueFileNames (CONT &files, const std::string &rootDirectory)
void	prefixStrings (std::list< std::string > &tlist, const std::string &prefix, int start=0, int end=-1)
void	fetchFiles ()
void	packageFilesFirst ()
void	prepareFiles ()

Private Attributes
std::string	dstDir_
std::string	progeOutDir_
std::string	sharedOutDir_
std::string	testBenchDir_
std::list< std::string >	vhdlFiles_
std::list< std::string >	gcuicFiles_
std::list< std::string >	testBenchFiles_
std::list< std::string >	platformFiles_
const std::string	workDir_
const std::string	vhdlDir_
const std::string	verDir_
const std::string	gcuicDir_
const std::string	tbDir_
const std::string	platformDir_
const std::string	modsimCompileScriptName_
const std::string	ghdlCompileScriptName_
const std::string	iverilogCompileScriptName_
const std::string	modsimSimulateScriptName_
const std::string	ghdlSimulateScriptName_
const std::string	iverilogSimulateScriptName_
const std::string	ghdlPlatformCompileScriptName_
const std::string	testbenchName_
const std::string	platformTestbenchName_
const std::string	toplevelEntity_
const IDF::MachineImplementation &	idf_
const ProGe::HDL	language_
const std::string	simulationRuntime_

Detailed Description

Class for script generating objects.

Base class for script generating. simulationRuntime defaults to 52390ns, can be changed in generateprocessor with a command line parameter, but not in ProDe yet. TODO.

Definition at line 52 of file ProGeScriptGenerator.hh.

Constructor & Destructor Documentation

ProGeScriptGenerator()

ProGeScriptGenerator::ProGeScriptGenerator	(	const ProGe::HDL	language,
		const IDF::MachineImplementation &	idf,
		const std::string &	dstDir,
		const std::string &	progeOutDir,
		const std::string &	sharedOutDir,
		const std::string &	testBenchDir,
		const std::string &	toplevelEntity = "tta0",
		const std::string &	simulationRuntime = "52390"
	)

The constructor.

Script generating needs a IDF file and hdb files mentioned there. Working directory is assumed to be the destination directory for script files.

Parameters

dstDir	Directory where to generate scripts.
progeOutDir	Directory where ProGes output vhdl files lie.
testBenchDir	Directory where a test bench files are located.
projectRoot	Directory that is project root, needed if relative dirs wanted to generated scripts. Useful if other dirs given are under this directory.

Definition at line 86 of file ProGeScriptGenerator.cc.

    : dstDir_(dstDir),
      progeOutDir_(progeOutDir),
      sharedOutDir_(sharedOutDir),
      testBenchDir_(testBenchDir),
      workDir_("work"),
      vhdlDir_("vhdl"),
      verDir_("verilog"),
      gcuicDir_("gcu_ic"),
      tbDir_("tb"),
      platformDir_("platform"),
      modsimCompileScriptName_("modsim_compile.sh"),
      ghdlCompileScriptName_("ghdl_compile.sh"),
      iverilogCompileScriptName_("iverilog_compile.sh"),
      modsimSimulateScriptName_("modsim_simulate.sh"),
      ghdlSimulateScriptName_("ghdl_simulate.sh"),
      iverilogSimulateScriptName_("iverilog_simulate.sh"),
      ghdlPlatformCompileScriptName_("ghdl_platform_compile.sh"),
      testbenchName_("testbench"),
      platformTestbenchName_("tta_almaif_tb"),
      toplevelEntity_(toplevelEntity),
      idf_(idf),
      language_(language),
      simulationRuntime_(simulationRuntime) {
    fetchFiles();
    packageFilesFirst();
    prepareFiles();
}

References fetchFiles(), packageFilesFirst(), and prepareFiles().

Here is the call graph for this function:

~ProGeScriptGenerator()

ProGeScriptGenerator::~ProGeScriptGenerator ( )

virtual

The destructor.

Definition at line 123 of file ProGeScriptGenerator.cc.

                                            {
 
}

Member Function Documentation

createExecutableFile()

void ProGeScriptGenerator::createExecutableFile ( const std::string &  fileName )

private

Creates a script file given as parameter and sets permissions.

Parameters

Name	of the script file to be created

Exceptions

IOException

Definition at line 416 of file ProGeScriptGenerator.cc.

                                                                    {
    FileSystem::removeFileOrDirectory(fileName);
    bool isCreated = FileSystem::createFile(fileName);
    if (!isCreated) {
        string errorMsg = "Unable to create file " + fileName;
        throw IOException(__FILE__, __LINE__, __func__, errorMsg);
    }
    FileSystem::setFileExecutable(fileName);
}

References __func__, FileSystem::createFile(), FileSystem::removeFileOrDirectory(), and FileSystem::setFileExecutable().

Referenced by generateGhdlCompile(), generateGhdlSimulate(), generateIverilogCompile(), generateIverilogSimulate(), generateModsimCompile(), and generateModsimSimulate().

Here is the call graph for this function:

fetchFiles()

void ProGeScriptGenerator::fetchFiles ( )

private

Gets file names from project directory.

Definition at line 729 of file ProGeScriptGenerator.cc.

                                 {
    
    // files that match are accepted
    string vhdlRegex =
    ((language_==VHDL)?".*\\.(vhd|vhdl|pkg)$":".*\\.(v)$");
 
    // generate relative paths
    bool absolutePaths = false;
    
    // getting files from project dir
    string dirName = progeOutDir_ + FileSystem::DIRECTORY_SEPARATOR 
        + ((language_==VHDL)?vhdlDir_:verDir_);
    if (FileSystem::fileIsDirectory(dirName)) {
        findFiles(vhdlRegex, 
            FileSystem::directoryContents(dirName, absolutePaths),
            vhdlFiles_);
        // add the toplevelEntity + _imem_mau_pkg.vhdl to vhdlFiles_.
        // It is generated by PIG so it is not yet present.
        if(language_==VHDL){
            string imemMauPkg = dirName + FileSystem::DIRECTORY_SEPARATOR
                + toplevelEntity_ + "_imem_mau_pkg.vhdl";
            vhdlFiles_.push_back(imemMauPkg);
        }
    }
    std::string DS = FileSystem::DIRECTORY_SEPARATOR;
 
    std::string sharedDir = 
        sharedOutDir_ + FileSystem::DIRECTORY_SEPARATOR +
        ((language_==VHDL)?vhdlDir_:verDir_);
        
    if (sharedDir != FileSystem::absolutePathOf(dirName)
        && FileSystem::fileIsDirectory(sharedDir)) {
        findFiles(
            vhdlRegex, 
            FileSystem::directoryContents(sharedDir, absolutePaths),
            vhdlFiles_);
    }    
 
    dirName = progeOutDir_ + FileSystem::DIRECTORY_SEPARATOR + gcuicDir_;
    if (FileSystem::fileIsDirectory(dirName)) {
        findFiles(vhdlRegex, 
            FileSystem::directoryContents(dirName, absolutePaths),
            gcuicFiles_);
    }
 
    if (FileSystem::fileIsDirectory(testBenchDir_)) {
        FileSystem::findFromDirectoryRecursive(vhdlRegex, testBenchDir_,
            testBenchFiles_);
    } else {
        findFiles(vhdlRegex, 
            FileSystem::directoryContents(dstDir_, absolutePaths),
            testBenchFiles_);
    }
 
    dirName = progeOutDir_ + DS + platformDir_;
    if (FileSystem::fileIsDirectory(dirName)) {
        findFiles(
            vhdlRegex, FileSystem::directoryContents(dirName, absolutePaths),
            platformFiles_);
    }
}

References FileSystem::absolutePathOf(), FileSystem::DIRECTORY_SEPARATOR, FileSystem::directoryContents(), DS, dstDir_, FileSystem::fileIsDirectory(), findFiles(), FileSystem::findFromDirectoryRecursive(), gcuicDir_, gcuicFiles_, language_, platformDir_, platformFiles_, progeOutDir_, sharedOutDir_, testBenchDir_, testBenchFiles_, toplevelEntity_, verDir_, ProGe::VHDL, vhdlDir_, and vhdlFiles_.

Referenced by ProGeScriptGenerator().

Here is the call graph for this function:

findFiles() [1/2]

template<typename T >

void ProGeScriptGenerator::findFiles ( const std::string &  perlre, T &  files  )

private

findFiles() [2/2]

template<typename T >

void ProGeScriptGenerator::findFiles ( const std::string &  perlre, T  files, std::list< std::string > &  found  )

private

Referenced by fetchFiles().

findText()

void ProGeScriptGenerator::findText ( const std::string &  perlre, const unsigned int &  matchRegion, const std::string &  fileName, std::list< std::string > &  found  )

private

Regex find from a file.

Finds text matching the given regex from file by line at a time. Case is ignored when interpreting the regex.

Parameters

perlre	Perl syntax regular expression.
matchRegion	Region from the match appended to output list.
fileName	Name and path of file name to be opened and read.
found	List where matches are appended.

Definition at line 528 of file ProGeScriptGenerator.cc.

                               {
 
    const int LINESIZE = 1000;
    
    const boost::regex re(perlre, 
            boost::regex::perl|boost::regex::icase);
    
    char line[LINESIZE];
    string::const_iterator begin;
    string::const_iterator end;
    string stemp;
    std::ifstream ifs( fileName.c_str() , std::ifstream::in );
    boost::match_results<string::const_iterator> matches;
    while (ifs.good()) {
 
        ifs.getline(line, LINESIZE-1);
        stemp = string(line);
 
        begin = stemp.begin();
        end = stemp.end();
 
        if (boost::regex_search(begin, end, matches, re)) {
            found.push_back(string(matches[matchRegion].first, 
                matches[matchRegion].second));
        }
    }
    ifs.close();
}

generateAll()

void ProGeScriptGenerator::generateAll

(

)

Generates all scripts to destination dir (dstDir_).

Exceptions

IOException

Definition at line 134 of file ProGeScriptGenerator.cc.

                                  {
    generateModsimCompile();
 
    if (language_ == VHDL) {
        generateGhdlCompile(
            ghdlCompileScriptName_, testbenchName_,
            {vhdlFiles_, gcuicFiles_, testBenchFiles_}, true);
        if (!platformFiles_.empty()) {
            generateGhdlCompile(
                ghdlPlatformCompileScriptName_, platformTestbenchName_,
                {platformFiles_}, false);
        }
    } else
        generateIverilogCompile();
 
    generateModsimSimulate();
    
    if(language_==VHDL)
        generateGhdlSimulate();
    else
        generateIverilogSimulate();
}

References gcuicFiles_, generateGhdlCompile(), generateGhdlSimulate(), generateIverilogCompile(), generateIverilogSimulate(), generateModsimCompile(), generateModsimSimulate(), ghdlCompileScriptName_, ghdlPlatformCompileScriptName_, language_, platformFiles_, platformTestbenchName_, testBenchFiles_, testbenchName_, ProGe::VHDL, and vhdlFiles_.

Referenced by ProGe::ProGeUI::generateScripts().

Here is the call graph for this function:

generateCompileStart()

void ProGeScriptGenerator::generateCompileStart ( std::ostream &  stream )

private

Generates the start of the shell script for compilation script.

Parameters

stream

Stream where output is put.

Definition at line 432 of file ProGeScriptGenerator.cc.

                                                             {
    stream << "#!/bin/bash" << endl;
    stream << "# This script was automatically generated." << endl << endl;
 
    // Copy common compile start from template
    static const string separator(FileSystem::DIRECTORY_SEPARATOR);
    const string scriptTmpl = Environment::dataDirPath("ProGe") +
        separator + "tb" + separator + "compile.sh.tmpl";
 
    std::ifstream scriptTmplIn(scriptTmpl.c_str());
    stream << scriptTmplIn.rdbuf();
}

References Environment::dataDirPath(), and FileSystem::DIRECTORY_SEPARATOR.

Referenced by generateGhdlCompile(), generateIverilogCompile(), and generateModsimCompile().

Here is the call graph for this function:

generateGhdlCompile()

void ProGeScriptGenerator::generateGhdlCompile	(	std::string	scriptName,
		std::string	tbName,
		std::vector< std::list< std::string > >	filesToCompile,
		bool	clearWorkingDir
	)

Generates a script for compilation using ghdl.

Exceptions

IOException

Definition at line 236 of file ProGeScriptGenerator.cc.

                          {
    string dstFile = dstDir_ + FileSystem::DIRECTORY_SEPARATOR + scriptName;
 
    createExecutableFile(dstFile);
 
    std::ofstream stream(dstFile.c_str(), std::ofstream::out);
    generateCompileStart(stream);
 
    if (clearWorkingDir) {
        stream << "rm -rf " << workDir_ << endl;
        stream << "mkdir -p work" << endl;
        stream << "rm -rf bus.dump" << endl;
        stream << "rm -rf " << tbName << endl;
    }
 
    stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
    stream << "    echo \"-c option is not available for ghdl.\"; exit 2;"
           << endl;
    stream << "fi" << endl;
 
    stream << endl;
    string program = "ghdl -i ${std_version} --workdir=" + workDir_;
    string exitOnFailure = " || exit 1";
 
    for (auto& files : filesToCompile) {
        outputScriptCommands(stream, files, program, exitOnFailure);
        stream << endl;
    }
    // compile command for ghdl
    stream << "if [ \"$only_add_files\" = \"no\" ]; then" << endl;
    stream << "    ghdl -m ${std_version} -Wno-hide --workdir=" << workDir_
           << " --ieee=synopsys -fexplicit " << tbName << endl;
    stream << "fi" << endl;
 
    stream << "exit 0" << endl;
    stream.close();
}

References createExecutableFile(), FileSystem::DIRECTORY_SEPARATOR, dstDir_, generateCompileStart(), outputScriptCommands(), program, and workDir_.

Referenced by generateAll().

Here is the call graph for this function:

generateGhdlSimulate()

void ProGeScriptGenerator::generateGhdlSimulate

(

)

Generates a script for simulating using ghdl.

Exceptions

IOException

Definition at line 356 of file ProGeScriptGenerator.cc.

                                           {
    string dstFile = dstDir_ + FileSystem::DIRECTORY_SEPARATOR +
        ghdlSimulateScriptName_;
    createExecutableFile(dstFile);
 
    std::ofstream stream(dstFile.c_str(), std::ofstream::out);
    generateSimulationStart(stream);
 
    stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
    stream << "    echo \"-c option is not available for ghdl.\"; exit 2;"
           << endl;
    stream << "fi" << endl;
    stream << "if [ -e ${tb_entity} ]; then" << endl
           << "    ./${tb_entity}"
           << " --stop-time=${runtime}ns" << endl
           << "else" << endl
           << "    # Newer GHDL versions does not produce binary." << endl
           << "    ghdl -r ${std_version} --workdir=work --ieee=synopsys "
           << "${tb_entity} --stop-time=${runtime}ns "
           << "--ieee-asserts=disable-at-0 ${generic_list}" << endl
           << "fi" << endl;
 
    stream.close();
}

References createExecutableFile(), FileSystem::DIRECTORY_SEPARATOR, dstDir_, generateSimulationStart(), and ghdlSimulateScriptName_.

Referenced by generateAll().

Here is the call graph for this function:

generateIverilogCompile()

void ProGeScriptGenerator::generateIverilogCompile

(

)

Generates a script for compilation using iVerilog.

Exceptions

IOException

Definition at line 283 of file ProGeScriptGenerator.cc.

                                              {
    string dstFile = dstDir_ + FileSystem::DIRECTORY_SEPARATOR +
        iverilogCompileScriptName_;
 
    createExecutableFile(dstFile);
 
    std::ofstream stream(dstFile.c_str(), std::ofstream::out);
    generateCompileStart(stream);
 
    stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
    stream << "    echo \"-c option is not available for iverilog.\"; exit 2;"
           << endl;
    stream << "fi" << endl;
 
    stream << "rm -rf " << testbenchName_ << endl
           << endl
           << "iverilog -g2001 -D _IVERILOG_ "
           << "-D SIMTIME=" << simulationRuntime_ << " "
           << "-Itb -Iverilog -Igcu_ic ";
    outputScriptCommands(stream, vhdlFiles_, ""," \\");
    outputScriptCommands(stream, gcuicFiles_, ""," \\");
    outputScriptCommands(stream, testBenchFiles_, ""," \\");
 
    stream << "-s " << testbenchName_ << " \\" << endl;
    stream << "-o " << testbenchName_ << endl;
    stream.close();
}

References createExecutableFile(), FileSystem::DIRECTORY_SEPARATOR, dstDir_, gcuicFiles_, generateCompileStart(), iverilogCompileScriptName_, outputScriptCommands(), simulationRuntime_, testBenchFiles_, testbenchName_, and vhdlFiles_.

Referenced by generateAll().

Here is the call graph for this function:

generateIverilogSimulate()

void ProGeScriptGenerator::generateIverilogSimulate

(

)

Generates a script for simulating using iVerilog.

Exceptions

IOException

Definition at line 387 of file ProGeScriptGenerator.cc.

                                               {
    string dstFile = dstDir_ + FileSystem::DIRECTORY_SEPARATOR +
        iverilogSimulateScriptName_;
 
    createExecutableFile(dstFile);
 
    std::ofstream stream(dstFile.c_str(), std::ofstream::out);
    generateSimulationStart(stream);
 
    stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
    stream << "    echo \"-c option is not available for iverilog.\"; exit 2;"
           << endl;
    stream << "fi" << endl;
 
    stream << "./" << testbenchName_ 
           << " --assert-level=none --stop-time="
           << "${runtime}" << "ns"
           << endl;
 
    stream.close();
}

References createExecutableFile(), FileSystem::DIRECTORY_SEPARATOR, dstDir_, generateSimulationStart(), iverilogSimulateScriptName_, and testbenchName_.

Referenced by generateAll().

Here is the call graph for this function:

generateModsimCompile()

void ProGeScriptGenerator::generateModsimCompile

(

)

Generates a script for compilation using modelsim.

Exceptions

IOException

Definition at line 163 of file ProGeScriptGenerator.cc.

                                            {
    string dstFile = dstDir_ + FileSystem::DIRECTORY_SEPARATOR +
        modsimCompileScriptName_;
    const string coverageOpt = "+cover=sbcet";
 
    createExecutableFile(dstFile);
 
    std::ofstream stream(dstFile.c_str(), std::ofstream::out);
    generateCompileStart(stream);
 
    stream << "rm -rf " << workDir_ << endl;
    stream << "vlib " << workDir_ << endl;
    stream << "vmap"  << endl;
 
    stream << "if [ \"$only_add_files\" = \"yes\" ]; then" << endl;
    stream << "    echo \"-a option is not available for modelsim.\"; exit 2;"
           << endl;
    stream << "fi" << endl;
 
    stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
    stream << "    coverage_opt=\"" << coverageOpt << "\"" << endl;
    stream << "fi" << endl;
 
    stream << endl;
    string coverageOptAssign = " $coverage_opt";
    string program =
    ((language_==VHDL)?
        "vcom": "vlog +define+SIMTIME=" + simulationRuntime_ +
        " +incdir+verilog +incdir+gcu_ic +incdir+tb");
    string exitOnFailure = "|| exit 1";
    string checkSynthesisFLag = (language_==VHDL)?" -check_synthesis":"";
 
    for (const std::string& file : vhdlFiles_) {
        if (file.find("_pkg.") != std::string::npos) {
            // Do not add coverage option for package files since unused
            // functions in the packages are not excluded and thus spoils
            // code coverage.
            outputScriptCommand(stream, file, program, exitOnFailure);
        } else {
            outputScriptCommand(
                stream, file, program + coverageOptAssign + checkSynthesisFLag,
                exitOnFailure);
        }
    }
 
    stream << endl;
    for (const std::string& file : gcuicFiles_) {
        if (file.find("_pkg.") != std::string::npos) {
            // Do not add coverage option for package files since unused
            // functions in the packages are not excluded and thus spoils
            // code coverage.
            outputScriptCommand(stream, file,
                program + checkSynthesisFLag, exitOnFailure);
        } else {
            outputScriptCommand(
                stream, file, program + coverageOptAssign + checkSynthesisFLag,
                exitOnFailure);
        }
    }
 
    stream << endl;
    outputScriptCommands(stream, testBenchFiles_, program, exitOnFailure);
 
    stream << "exit 0" << endl;
    stream.close();
}

References createExecutableFile(), FileSystem::DIRECTORY_SEPARATOR, dstDir_, gcuicFiles_, generateCompileStart(), language_, modsimCompileScriptName_, outputScriptCommand(), outputScriptCommands(), program, simulationRuntime_, testBenchFiles_, ProGe::VHDL, vhdlFiles_, and workDir_.

Referenced by generateAll().

Here is the call graph for this function:

generateModsimSimulate()

void ProGeScriptGenerator::generateModsimSimulate

(

)

Generates a script for simulating using modelsims vsim.

Definition at line 315 of file ProGeScriptGenerator.cc.

                                             {
    string dstFile = dstDir_ + FileSystem::DIRECTORY_SEPARATOR +
        modsimSimulateScriptName_;
 
    createExecutableFile(dstFile);
 
    std::ofstream stream(dstFile.c_str(), std::ofstream::out);
    generateSimulationStart(stream);
 
    stream << "master_coverage_db=accumulated_coverage.ucdb" << endl;
    stream << "coverage_db=cov000.ucdb" << endl;
    stream << "res_opt=\"-t $sim_res\"";
    stream << endl;
    stream << "coverage_opt=\"\"" << endl;
    stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
    stream << "    coverage_opt=\"-coverage\"" << endl;
    stream << "    do_script=\"" << "coverage save -onexit ${coverage_db}; "
           << "run ${runtime} ns; exit" << "\"" << endl;
    stream << "else" << endl;
    stream << "    do_script=\"" << "run ${runtime} ns; exit" << "\"" << endl;
    stream << "fi" << endl;
    stream << endl;
    stream << "vsim " << testbenchName_ << " $res_opt -c $coverage_opt"
           << " -do \"$do_script\"" << endl;
    stream << endl;
    stream << "# merge produced code coverage data into master database."
           << endl;
    stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
    stream << "    vcover merge $master_coverage_db "
           << "$master_coverage_db $coverage_db > /dev/null 2>&1" << endl;
    stream << "fi" << endl;
 
    stream.close();
}

References createExecutableFile(), FileSystem::DIRECTORY_SEPARATOR, dstDir_, generateSimulationStart(), modsimSimulateScriptName_, and testbenchName_.

Referenced by generateAll().

Here is the call graph for this function:

generatePlatformGhdlCompile()

void ProGeScriptGenerator::generatePlatformGhdlCompile

(

)

generatePlatformGhdlSimulate()

void ProGeScriptGenerator::generatePlatformGhdlSimulate

(

)

generateSimulationStart()

void ProGeScriptGenerator::generateSimulationStart ( std::ostream &  stream )

private

Generates the start of the shell script for simulation script.

The script includes option parsing for simulation controls. Shell variable "runtime" holds default simulation time set by this class or user defined time by option.

Parameters

stream

Stream where output is put.

Definition at line 455 of file ProGeScriptGenerator.cc.

                                                                {
    stream << "#!/bin/bash" << endl;
    stream << "# This script was automatically generated." << endl << endl;
    stream << "DEFAULT_RUN_TIME=" << simulationRuntime_ << endl << endl;
 
    // Copy rest of the shell script start from template
    static const string separator(FileSystem::DIRECTORY_SEPARATOR);
    const string scriptTmpl = Environment::dataDirPath("ProGe") +
        separator + "tb" + separator + "simulate.sh.tmpl";
 
    std::ifstream scriptTmplIn(scriptTmpl.c_str());
    stream << scriptTmplIn.rdbuf();
}

References Environment::dataDirPath(), FileSystem::DIRECTORY_SEPARATOR, and simulationRuntime_.

Referenced by generateGhdlSimulate(), generateIverilogSimulate(), and generateModsimSimulate().

Here is the call graph for this function:

getBlockOrder()

void ProGeScriptGenerator::getBlockOrder ( std::list< std::string > &  order )

private

Gets compilation order for vhdl files from IDF/HDB files.

Parameters

order

List of file names is relative compilation order.

Definition at line 657 of file ProGeScriptGenerator.cc.

                                                             {
 
    std::set<string> uniqueFiles;    
 
    // FU implementation HDL files
    for (int i = 0; i < idf_.fuImplementationCount(); i++) {
        const FUImplementationLocation& fuLoc = idf_.fuImplementation(i);
        string hdbFile = fuLoc.hdbFile();
        HDB::CachedHDBManager& hdb =
            HDB::HDBRegistry::instance().hdb(hdbFile);
        HDB::FUEntry* fu = hdb.fuByEntryID(fuLoc.id());
        const HDB::FUImplementation& fuImpl = fu->implementation();
        for (int j = 0; j < fuImpl.implementationFileCount(); j++) {
            string file = FileSystem::fileOfPath(fuImpl.file(j).pathToFile());
            if (uniqueFiles.find(file) == uniqueFiles.end()) {
                order.push_back(file);
                uniqueFiles.insert(file);
            }
        }
    }
 
    // RF implementation HDL files
    for (int i = 0; i < idf_.rfImplementationCount(); i++) {
        const RFImplementationLocation& rfLoc = idf_.rfImplementation(i);
        string hdbFile = rfLoc.hdbFile();
        HDB::CachedHDBManager& hdb =
            HDB::HDBRegistry::instance().hdb(hdbFile);
        HDB::RFEntry* rf = hdb.rfByEntryID(rfLoc.id());
        const HDB::RFImplementation& rfImpl = rf->implementation();
        for (int j = 0; j < rfImpl.implementationFileCount(); j++) {
            string file = FileSystem::fileOfPath(rfImpl.file(j).pathToFile());
            if (uniqueFiles.find(file) == uniqueFiles.end()) {
                order.push_back(file);
                uniqueFiles.insert(file);
            }
        }
    }
}

References HDB::HWBlockImplementation::file(), FileSystem::fileOfPath(), HDB::HDBManager::fuByEntryID(), IDF::MachineImplementation::fuImplementation(), IDF::MachineImplementation::fuImplementationCount(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), idf_, HDB::FUEntry::implementation(), HDB::RFEntry::implementation(), HDB::HWBlockImplementation::implementationFileCount(), HDB::HDBRegistry::instance(), HDB::BlockImplementationFile::pathToFile(), HDB::HDBManager::rfByEntryID(), IDF::MachineImplementation::rfImplementation(), and IDF::MachineImplementation::rfImplementationCount().

Referenced by prepareFiles().

Here is the call graph for this function:

outputScriptCommand()

void ProGeScriptGenerator::outputScriptCommand ( std::ostream &  stream, const std::string &  file, const std::string &  cmdPrefix, const std::string &  cmdPostfix  )

private

Outputs shell command to stream.

Creates script commands using a file and command prefix and outputs them to the given stream.

Parameters

stream	Output stream.
files	List of filenames to use.
cmdPrefix	Prefix command.
cmdPostfix	Postfix command.

Definition at line 506 of file ProGeScriptGenerator.cc.

                                 {
 
    stream << cmdPrefix << " " << file << " " << cmdPostfix << endl;
}

Referenced by generateModsimCompile(), and outputScriptCommands().

outputScriptCommands()

void ProGeScriptGenerator::outputScriptCommands ( std::ostream &  stream, const std::list< std::string > &  files, const std::string &  cmdPrefix, const std::string &  cmdPostfix  )

private

Outputs shell commands to stream.

Creates script commands using list of files and command prefix and outputs them to the given stream.

Parameters

stream	Output stream.
files	List of filenames to use.
cmdPrefix	Prefix command.
cmdPostfix	Prefix command.

Definition at line 482 of file ProGeScriptGenerator.cc.

                                 {
 
    list<string>::const_iterator iter = files.begin();
    while (iter != files.end()) {
        outputScriptCommand(stream, *iter++, cmdPrefix, cmdPostfix);
    }
}

References outputScriptCommand().

Referenced by generateGhdlCompile(), generateIverilogCompile(), and generateModsimCompile().

Here is the call graph for this function:

packageFilesFirst()

void ProGeScriptGenerator::packageFilesFirst ( )

private

Reorders filename lists by arranging packages (*_pkg*) to the beginning of the lists.

Definition at line 796 of file ProGeScriptGenerator.cc.

                                        {
    auto packageComp = [](const string& str1, const string& str2) -> bool {
        bool str1IsPkg = (str1.find("_pkg") != string::npos);
        bool str2IsPkg = (str2.find("_pkg") != string::npos);
        if (str1IsPkg && !str2IsPkg) {
            return true;
        } else if (!str1IsPkg && str2IsPkg) {
            return false;
        } else {
            return str1 < str2;
        }
    };
 
    vhdlFiles_.sort(packageComp);
    gcuicFiles_.sort(packageComp);
    testBenchFiles_.sort(packageComp);
}

References gcuicFiles_, testBenchFiles_, and vhdlFiles_.

Referenced by ProGeScriptGenerator().

prefixStrings()

void ProGeScriptGenerator::prefixStrings ( std::list< std::string > &  tlist, const std::string &  prefix, int  start = 0, int  end = -1  )

private

Prefixes strings in a container with a string within a range.

Parameters

tlist	Container of strings.
prefix	Prefix to be added to strings in container.
start	Starting location in a container, 0 is the first.
end	Ending location in a container, size-1 is the last.

Definition at line 706 of file ProGeScriptGenerator.cc.

             {
    
    if (end == -1 || end >= static_cast<int>(tlist.size())) {
        end = tlist.size() - 1;
    }
 
    list<string>::iterator itl = tlist.begin();
    for (int c = 0; c <= end; ++c, ++itl) {
        if (c >= start) {
            *itl = prefix + *itl; 
        }
    }
}

Referenced by prepareFiles().

prepareFiles()

void ProGeScriptGenerator::prepareFiles ( )

private

Prepares filename lists, generally sorts them.

Definition at line 818 of file ProGeScriptGenerator.cc.

                                   {
 
    const string DS = FileSystem::DIRECTORY_SEPARATOR;
    if(language_==VHDL){
        string gcuIcDirName = progeOutDir_ + DS + gcuicDir_ + DS;
        list<string> gcuicFirstOrder;
        gcuicFirstOrder.push_back("gcu_opcodes_pkg.vhdl");
        prefixStrings(gcuicFirstOrder, gcuIcDirName);
        sortFilesFirst(gcuicFiles_, gcuicFirstOrder); 
 
        list<string> gcuicLastOrder;
        gcuicLastOrder.push_back("ic.vhdl");
        prefixStrings(gcuicLastOrder, gcuIcDirName);
        sortFilesLast(gcuicFiles_, gcuicLastOrder);
 
        string vhdlDirName = progeOutDir_ + DS + vhdlDir_ + DS;
        list<string> vhdlFirstOrder;
        vhdlFirstOrder.push_back("tce_util_pkg.vhdl");
        vhdlFirstOrder.push_back(toplevelEntity_ + "_imem_mau_pkg.vhdl");
        vhdlFirstOrder.push_back(toplevelEntity_ + "_globals_pkg.vhdl");
        vhdlFirstOrder.push_back(toplevelEntity_ + "_params_pkg.vhdl");
        // add FU and RF files in correct order
        getBlockOrder(vhdlFirstOrder);
        prefixStrings(vhdlFirstOrder, vhdlDirName);
        sortFilesFirst(vhdlFiles_, vhdlFirstOrder);
        
        list<string> vhdlLastOrder;
        string toplevelFile = toplevelEntity_ + ".vhdl";
        vhdlLastOrder.push_back(toplevelFile);
        prefixStrings(vhdlLastOrder, vhdlDirName);
        sortFilesLast(vhdlFiles_, vhdlLastOrder);
        
        string tbDirName = progeOutDir_ + DS + tbDir_ + DS;
        list<string> testBenchLastOrder;
        testBenchLastOrder.push_back("testbench_cfg.vhdl");
        testBenchLastOrder.push_back("testbench.vhdl");
        testBenchLastOrder.push_back("proc_arch.vhdl");
        testBenchLastOrder.push_back("proc_ent.vhdl");
        prefixStrings(testBenchLastOrder, tbDirName);
        sortFilesLast(testBenchFiles_, testBenchLastOrder);
    } else {
    //nothing to do here
    }
    // make dirs relative to dstDir_
    list<string>::iterator itl;
    itl = vhdlFiles_.begin();
    while (itl != vhdlFiles_.end()) {
        FileSystem::relativeDir(dstDir_, *itl++);
    }
    itl = gcuicFiles_.begin();
    while (itl != gcuicFiles_.end()) {
        FileSystem::relativeDir(dstDir_, *itl++);
    }
    itl = testBenchFiles_.begin();
    while (itl != testBenchFiles_.end()) {
        FileSystem::relativeDir(dstDir_, *itl++);
    }
    itl = platformFiles_.begin();
    while (itl != platformFiles_.end()) {
        FileSystem::relativeDir(dstDir_, *itl++);
    }
}

References FileSystem::DIRECTORY_SEPARATOR, DS, dstDir_, gcuicDir_, gcuicFiles_, getBlockOrder(), language_, platformFiles_, prefixStrings(), progeOutDir_, FileSystem::relativeDir(), sortFilesFirst(), sortFilesLast(), tbDir_, testBenchFiles_, toplevelEntity_, ProGe::VHDL, vhdlDir_, and vhdlFiles_.

Referenced by ProGeScriptGenerator().

Here is the call graph for this function:

sortFilesFirst()

void ProGeScriptGenerator::sortFilesFirst ( std::list< std::string > &  toSort, std::list< std::string > &  acSort  )

private

Relative file name/path sort using a reference.

Sorts file in one list according to other list,placing in beginning of list, only relative order matters (which entry comes first). Algorithm used does relative sort between two lists, the other is sorted according to the other.

Parameters

toSort	List to be sorted.
acSort	List where reference order is taken from.

Definition at line 574 of file ProGeScriptGenerator.cc.

                                {
 
    typedef std::list<std::string>::iterator listStrIt;
 
    listStrIt itAc1 = acSort.begin();
    listStrIt itTo  = toSort.begin();
    listStrIt itTo2;
 
    while (itAc1 != acSort.end()) {
        // now check list to be sorted
        bool swapped = false;
        itTo2 = itTo;
        while (itTo2 != toSort.end()) {
            if (FileSystem::compareFileNames(*itTo2, *itAc1, dstDir_)) {
                // now change itTo2 and itTo places                            
                string temp = *itTo;
                *itTo = *itTo2;
                *itTo2 = temp;
                swapped = true;
                break;
                }
            ++itTo2;
        }
        if (swapped) {
            ++itTo;
        }
        ++itAc1;
    }
}

References FileSystem::compareFileNames(), and dstDir_.

Referenced by prepareFiles().

Here is the call graph for this function:

sortFilesLast()

void ProGeScriptGenerator::sortFilesLast ( std::list< std::string > &  toSort, std::list< std::string > &  acSort  )

private

Relative file name/path sort using a reference.

Sorts file in one list according to other list, placing in end of list, only relative order matters (which entry comes first). Algorithm used does relative sort between two lists, the other is sorted according to the other.

Parameters

toSort	List to be sorted.
acSort	List where reference order is taken from.

Definition at line 619 of file ProGeScriptGenerator.cc.

                                {
    typedef std::list<std::string>::iterator listStrIt;
    typedef std::list<std::string>::reverse_iterator  rlistStrIt;
 
    listStrIt itAc1 = acSort.begin();
    rlistStrIt itTo    = toSort.rbegin();
    rlistStrIt itTo2;
 
    while (itAc1 != acSort.end()) {
        // now check list to be sorted
        bool swapped = false;
        itTo2 = itTo;
        while (itTo2 != toSort.rend()) {
            if (FileSystem::compareFileNames(*itTo2, *itAc1,dstDir_)) {
                // now change itTo2 and itTo places                            
                string temp  = *itTo;
                *itTo = *itTo2;
                *itTo2 = temp;
                swapped = true;
                break;
                }
            ++itTo2;
        }
        if (swapped) {
            ++itTo;
        }
        ++itAc1;
    }
}

References FileSystem::compareFileNames(), and dstDir_.

Referenced by prepareFiles().

Here is the call graph for this function:

uniqueFileNames()

template<typename CONT >

void ProGeScriptGenerator::uniqueFileNames ( CONT &  files, const std::string &  rootDirectory  )

private

Member Data Documentation

dstDir_

std::string ProGeScriptGenerator::dstDir_

private

Definition at line 134 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), generateGhdlCompile(), generateGhdlSimulate(), generateIverilogCompile(), generateIverilogSimulate(), generateModsimCompile(), generateModsimSimulate(), prepareFiles(), sortFilesFirst(), and sortFilesLast().

gcuicDir_

const std::string ProGeScriptGenerator::gcuicDir_

private

Definition at line 152 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), and prepareFiles().

gcuicFiles_

std::list<std::string> ProGeScriptGenerator::gcuicFiles_

private

Definition at line 144 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), generateAll(), generateIverilogCompile(), generateModsimCompile(), packageFilesFirst(), and prepareFiles().

ghdlCompileScriptName_

const std::string ProGeScriptGenerator::ghdlCompileScriptName_

private

Definition at line 158 of file ProGeScriptGenerator.hh.

Referenced by generateAll().

ghdlPlatformCompileScriptName_

const std::string ProGeScriptGenerator::ghdlPlatformCompileScriptName_

private

Definition at line 163 of file ProGeScriptGenerator.hh.

Referenced by generateAll().

ghdlSimulateScriptName_

const std::string ProGeScriptGenerator::ghdlSimulateScriptName_

private

Definition at line 161 of file ProGeScriptGenerator.hh.

Referenced by generateGhdlSimulate().

idf_

const IDF::MachineImplementation& ProGeScriptGenerator::idf_

private

Definition at line 169 of file ProGeScriptGenerator.hh.

Referenced by getBlockOrder().

iverilogCompileScriptName_

const std::string ProGeScriptGenerator::iverilogCompileScriptName_

private

Definition at line 159 of file ProGeScriptGenerator.hh.

Referenced by generateIverilogCompile().

iverilogSimulateScriptName_

const std::string ProGeScriptGenerator::iverilogSimulateScriptName_

private

Definition at line 162 of file ProGeScriptGenerator.hh.

Referenced by generateIverilogSimulate().

language_

const ProGe::HDL ProGeScriptGenerator::language_

private

Definition at line 170 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), generateAll(), generateModsimCompile(), and prepareFiles().

modsimCompileScriptName_

const std::string ProGeScriptGenerator::modsimCompileScriptName_

private

Definition at line 157 of file ProGeScriptGenerator.hh.

Referenced by generateModsimCompile().

modsimSimulateScriptName_

const std::string ProGeScriptGenerator::modsimSimulateScriptName_

private

Definition at line 160 of file ProGeScriptGenerator.hh.

Referenced by generateModsimSimulate().

platformDir_

const std::string ProGeScriptGenerator::platformDir_

private

Definition at line 154 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles().

platformFiles_

std::list<std::string> ProGeScriptGenerator::platformFiles_

private

Definition at line 146 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), generateAll(), and prepareFiles().

platformTestbenchName_

const std::string ProGeScriptGenerator::platformTestbenchName_

private

Definition at line 167 of file ProGeScriptGenerator.hh.

Referenced by generateAll().

progeOutDir_

std::string ProGeScriptGenerator::progeOutDir_

private

Definition at line 136 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), and prepareFiles().

sharedOutDir_

std::string ProGeScriptGenerator::sharedOutDir_

private

Definition at line 138 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles().

simulationRuntime_

const std::string ProGeScriptGenerator::simulationRuntime_

private

Definition at line 173 of file ProGeScriptGenerator.hh.

Referenced by generateIverilogCompile(), generateModsimCompile(), and generateSimulationStart().

tbDir_

const std::string ProGeScriptGenerator::tbDir_

private

Definition at line 153 of file ProGeScriptGenerator.hh.

Referenced by prepareFiles().

testBenchDir_

std::string ProGeScriptGenerator::testBenchDir_

private

Definition at line 140 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles().

testBenchFiles_

std::list<std::string> ProGeScriptGenerator::testBenchFiles_

private

Definition at line 145 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), generateAll(), generateIverilogCompile(), generateModsimCompile(), packageFilesFirst(), and prepareFiles().

testbenchName_

const std::string ProGeScriptGenerator::testbenchName_

private

Definition at line 166 of file ProGeScriptGenerator.hh.

Referenced by generateAll(), generateIverilogCompile(), generateIverilogSimulate(), and generateModsimSimulate().

toplevelEntity_

const std::string ProGeScriptGenerator::toplevelEntity_

private

Definition at line 168 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), and prepareFiles().

verDir_

const std::string ProGeScriptGenerator::verDir_

private

Definition at line 151 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles().

vhdlDir_

const std::string ProGeScriptGenerator::vhdlDir_

private

Definition at line 150 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), and prepareFiles().

vhdlFiles_

std::list<std::string> ProGeScriptGenerator::vhdlFiles_

private

Definition at line 143 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), generateAll(), generateIverilogCompile(), generateModsimCompile(), packageFilesFirst(), and prepareFiles().

workDir_

const std::string ProGeScriptGenerator::workDir_

private

Definition at line 149 of file ProGeScriptGenerator.hh.

Referenced by generateGhdlCompile(), and generateModsimCompile().

---

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

• ProGeScriptGenerator.hh
• ProGeScriptGenerator.cc