#include <BlockSourceCopier.hh>

Collaboration diagram for ProGe::BlockSourceCopier:

Public Member Functions
	BlockSourceCopier (const IDF::MachineImplementation &implementation, TCEString entityStr, const ProGe::HDL language)

virtual	~BlockSourceCopier ()

void	copyShared (const std::string &dstDirectory)

void	copyProcessorSpecific (const std::string &dstDirectory)

void	instantiateHDLTemplate (const std::string &srcFile, const std::string &dstDirectory, std::string newName="0")

HDLTemplateInstantiator &	getTemplateInstatiator ()

Private Member Functions
void	copyBaseRFFiles (const IDF::RFImplementationLocation &implementation, const std::string &dstDirectory)

void	copyFiles (const HDB::HWBlockImplementation &implementation, const std::string &hdbFile, const std::string &dstDirectory)

void	copyFromTemplate (const std::string &templateFile, const std::string &dstDirectory)

void	setCopied (const std::string &file)

bool	isCopied (const std::string &file) const

Private Attributes
const IDF::MachineImplementation &	implementation_
	The IDF object model.

TCEString	entityStr_

const HDL	language_

std::set< std::string >	copiedFiles_
	Copied files.

HDLTemplateInstantiator	instantiator_
	Object that instantiates templates.

Detailed Description

Copies the block definition files used in the processor implementation to the output directory of ProGe.

Definition at line 63 of file BlockSourceCopier.hh.

Constructor & Destructor Documentation

◆ BlockSourceCopier()

ProGe::BlockSourceCopier::BlockSourceCopier	(	const IDF::MachineImplementation &	implementation,
		TCEString	entityStr,
		const ProGe::HDL	language
	)

The constructor.

Definition at line 67 of file BlockSourceCopier.cc.

                       :
    implementation_(implementation), entityStr_(entityStr), language_(language){
    instantiator_.setEntityString(entityStr_);
}

References entityStr_, instantiator_, and HDLTemplateInstantiator::setEntityString().

Here is the call graph for this function:

◆ ~BlockSourceCopier()

ProGe::BlockSourceCopier::~BlockSourceCopier ( )

virtual

The destructor.

Definition at line 79 of file BlockSourceCopier.cc.

79 {

80}

Member Function Documentation

◆ copyBaseRFFiles()

void ProGe::BlockSourceCopier::copyBaseRFFiles	(	const IDF::RFImplementationLocation &	implementation,
		const std::string &	dstDirectory
	)

private

Copies the block definition files of the given RF implementation to the proper subdirectories of the given directory.

Parameters

implementation	The location of the RF implementation.
dstDirectory	The destination "root" directory.

Exceptions

IOException If some file cannot be copied or HDB cannot be opened.

Definition at line 251 of file BlockSourceCopier.cc.

                                   {
    string hdbFile = implementation.hdbFile();
    int id = implementation.id();
    HDBManager& manager = HDBRegistry::instance().hdb(hdbFile);
    RFEntry* entry = manager.rfByEntryID(id);
    assert(entry->hasImplementation());
    RFImplementation& impl = entry->implementation();
    copyFiles(impl, hdbFile, dstDirectory);
    delete entry;
}

References assert, copyFiles(), HDB::RFEntry::hasImplementation(), HDB::HDBRegistry::hdb(), HDB::RFEntry::implementation(), implementation, HDB::HDBRegistry::instance(), and HDB::HDBManager::rfByEntryID().

Referenced by copyShared().

Here is the call graph for this function:

◆ copyFiles()

void ProGe::BlockSourceCopier::copyFiles	(	const HDB::HWBlockImplementation &	implementation,
		const std::string &	hdbFile,
		const std::string &	dstDirectory
	)

private

Copies the block definition files of the given HW block implementation to the proper subdirectories of the given directory.

Parameters

implementation	The block implementation.
hdbFile	The HDB file that contains the block.
dstDirectory	The destination "root" directory.

Exceptions

UnreachableStream	If some file cannot be copied to the destination directory.
FileNotFound	If the file referred to in HDB is not found.

Definition at line 276 of file BlockSourceCopier.cc.

                                                             {
    for (int i = 0; i < implementation.implementationFileCount(); i++) {
        BlockImplementationFile& file = implementation.file(i);
        vector<string> modulePaths = Environment::vhdlPaths(hdbFile);
 
        string absoluteFile;
        try {
                    absoluteFile = FileSystem::findFileInSearchPaths(
                        modulePaths, file.pathToFile());
        } catch (const Exception& e) {
            string errorMsg =
                "Problem with " + implementation.moduleName() + " in HDB " +
                hdbFile + ".\n" +
                "Unable to find file mentioned in HDB: " + file.pathToFile() +
                ":\n";
            errorMsg += e.errorMessage();
            throw FileNotFound(__FILE__, __LINE__, __func__, errorMsg);
        }
 
        if (!isCopied(absoluteFile)) {
            string fileName = FileSystem::fileOfPath(absoluteFile);
            string targetDir, targetFile;
            string DS = FileSystem::DIRECTORY_SEPARATOR;
 
            if(language_== VHDL && (ProGe::HDL)file.format()==VHDL) {
                targetDir = dstDirectory + DS + "vhdl";
            } else
            if(language_== Verilog && (ProGe::HDL) file.format()==Verilog) {
                targetDir = dstDirectory + DS + "verilog";
            } else {
                setCopied(absoluteFile);
                continue;//next file for check
            }
            
            targetFile = targetDir + DS + fileName;
            
            if (!FileSystem::fileExists(targetDir)) {
                bool directoryCreated = 
                    FileSystem::createDirectory(targetDir);
                if (!directoryCreated) {
                    string errorMsg = "Unable to create directory " +
                        targetDir  + ".";
                    throw IOException(__FILE__, __LINE__, __func__, errorMsg);
                }
            }
 
            try {
                FileSystem::copy(absoluteFile, targetFile);
            } catch (const Exception& e) {
                string errorMsg = "Unable to copy file " + targetFile + ":";
                errorMsg += e.errorMessage();
 
                throw UnreachableStream(
                    __FILE__, __LINE__, __func__, errorMsg);
            }
            setCopied(absoluteFile);
        }
    }
}

References __func__, FileSystem::copy(), FileSystem::createDirectory(), FileSystem::DIRECTORY_SEPARATOR, DS, Exception::errorMessage(), FileSystem::fileExists(), FileSystem::fileOfPath(), FileSystem::findFileInSearchPaths(), HDB::BlockImplementationFile::format(), implementation, isCopied(), language_, HDB::BlockImplementationFile::pathToFile(), setCopied(), ProGe::Verilog, ProGe::VHDL, and Environment::vhdlPaths().

Referenced by copyBaseRFFiles(), and copyShared().

Here is the call graph for this function:

◆ copyFromTemplate()

void ProGe::BlockSourceCopier::copyFromTemplate	(	const std::string &	templateFile,
		const std::string &	dstDirectory
	)

private

◆ copyProcessorSpecific()

void ProGe::BlockSourceCopier::copyProcessorSpecific ( const std::string & dstDirectory )

Copies the block definition files of the blocks given in IDF to proper subdirectories of the given directory.

This method copies the processor-specific files that are not reused between multiple TTAs.

Parameters

dstDirectory The destination "root" directory.

Exceptions

IOException If some file cannot be copied or HDB cannot be opened.

Definition at line 145 of file BlockSourceCopier.cc.

                                                                      {
    // copy decompressor file
    const string DS = FileSystem::DIRECTORY_SEPARATOR;
    string decompressorTargetDir = dstDirectory + DS + "gcu_ic";
    if (!FileSystem::fileExists(decompressorTargetDir)) {
        if (!FileSystem::createDirectory(decompressorTargetDir)) {
            string errorMsg = "Unable to create directory " +
                decompressorTargetDir;
            throw IOException(__FILE__, __LINE__, __func__, errorMsg);
        }
    }
 
    string sourceFile;
    string dstFile;
    if (implementation_.hasDecompressorFile()) {
        sourceFile = implementation_.decompressorFile();
        string file = FileSystem::fileOfPath(sourceFile);
        dstFile = decompressorTargetDir + DS + file;
        FileSystem::copy(sourceFile, dstFile);
    } else {
        sourceFile = Environment::dataDirPath("ProGe") + DS +
                     ((language_ == Verilog) ? "idecompressor.v.tmpl"
                                             : "idecompressor.vhdl.tmpl");
        string file =
            ((language_ == Verilog) ? "idecompressor.v"
                                    : "idecompressor.vhdl");
        dstFile = decompressorTargetDir + DS + file;
 
        if (!FileSystem::fileExists(dstFile)) {
            instantiator_.instantiateTemplateFile(sourceFile, dstFile);
        }
    }
 
    string ifetchSrcFile;
    ifetchSrcFile =
        Environment::dataDirPath("ProGe") + DS +
        ((language_ == Verilog) ? "ifetch.v.tmpl" : "ifetch.vhdl.tmpl");
    string ifetchTargetDir = decompressorTargetDir;
    assert(FileSystem::fileExists(ifetchTargetDir));
    string ifetchDstFile = 
        ifetchTargetDir + DS + ((language_==Verilog)?"ifetch.v":"ifetch.vhdl");
 
    if (!FileSystem::fileExists(ifetchDstFile)) {
        instantiator_.instantiateTemplateFile(ifetchSrcFile, ifetchDstFile);
    }
}

References __func__, assert, FileSystem::copy(), FileSystem::createDirectory(), Environment::dataDirPath(), IDF::MachineImplementation::decompressorFile(), FileSystem::DIRECTORY_SEPARATOR, DS, FileSystem::fileExists(), FileSystem::fileOfPath(), IDF::MachineImplementation::hasDecompressorFile(), implementation_, HDLTemplateInstantiator::instantiateTemplateFile(), instantiator_, language_, and ProGe::Verilog.

Referenced by ProGe::ProcessorGenerator::generateProcessor().

Here is the call graph for this function:

◆ copyShared()

void ProGe::BlockSourceCopier::copyShared ( const std::string & dstDirectory )

Copies the block definition files of the blocks given in IDF to proper subdirectories of the given directory.

This method copies the files that can and are potentially shared by multiple TTAs in the same system design. That is, the FU, RF and IU implementations.

Parameters

dstDirectory The destination "root" directory.

Exceptions

IOException If some file cannot be copied or HDB cannot be opened.

Definition at line 96 of file BlockSourceCopier.cc.

                                                           {
    // copy FU files
    for (int i = 0; i < implementation_.fuImplementationCount(); i++) {
        FUImplementationLocation& fuImpl =
            implementation_.fuImplementation(i);
        string hdbFile = fuImpl.hdbFile();
        int id = fuImpl.id();
        HDBManager& manager = HDBRegistry::instance().hdb(hdbFile);
        FUEntry* entry = manager.fuByEntryID(id);
        assert(entry->hasImplementation());
        FUImplementation& impl = entry->implementation();
        copyFiles(impl, hdbFile, dstDirectory);
        delete entry;
    }
 
    // copy RF files
    for (int i = 0; i < implementation_.rfImplementationCount(); i++) {
        RFImplementationLocation& rfImpl =
            implementation_.rfImplementation(i);
        copyBaseRFFiles(rfImpl, dstDirectory);
    }
 
    // copy IU files
    for (int i = 0; i < implementation_.iuImplementationCount(); i++) {
        RFImplementationLocation& rfImpl =
            implementation_.iuImplementation(i);
        copyBaseRFFiles(rfImpl, dstDirectory);
    }
 
    const string DS = FileSystem::DIRECTORY_SEPARATOR;
    string sourceDir = Environment::dataDirPath("ProGe");
    // copy the utility VHDL or Verilog files
    FileSystem::copy(
        sourceDir + DS + ((language_==VHDL)?UTILITY_VHDL_FILE:UTILITY_VERILOG_FILE),
        dstDirectory + DS + ((language_==VHDL)?"vhdl":"verilog") + DS + ((language_==VHDL)?UTILITY_VHDL_FILE:UTILITY_VERILOG_FILE));
}

References assert, FileSystem::copy(), copyBaseRFFiles(), copyFiles(), Environment::dataDirPath(), FileSystem::DIRECTORY_SEPARATOR, DS, HDB::HDBManager::fuByEntryID(), IDF::MachineImplementation::fuImplementation(), IDF::MachineImplementation::fuImplementationCount(), HDB::FUEntry::hasImplementation(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), IDF::UnitImplementationLocation::id(), HDB::FUEntry::implementation(), implementation_, HDB::HDBRegistry::instance(), IDF::MachineImplementation::iuImplementation(), IDF::MachineImplementation::iuImplementationCount(), language_, IDF::MachineImplementation::rfImplementation(), IDF::MachineImplementation::rfImplementationCount(), UTILITY_VERILOG_FILE, UTILITY_VHDL_FILE, and ProGe::VHDL.

Referenced by ProGe::ProcessorGenerator::generateProcessor().

Here is the call graph for this function:

◆ getTemplateInstatiator()

HDLTemplateInstantiator & ProGe::BlockSourceCopier::getTemplateInstatiator ( )

Returns reference to template instantiator instance used by this.

Definition at line 237 of file BlockSourceCopier.cc.

                                          {
    return instantiator_;
}

References instantiator_.

Referenced by DefaultICDecoderGenerator::generate(), and ProGe::ProcessorGenerator::generateProcessor().

◆ instantiateHDLTemplate()

void ProGe::BlockSourceCopier::instantiateHDLTemplate	(	const std::string &	srcFile,
		const std::string &	dstDirectory,
		std::string	newName = `"0"`
	)

Copies given template file to given directory and instantiates it, ie. removes the .tmpl from the filename and converts it to .vhdl while replacing occurances of "ENTITY_STR" with entityStr_.

Parameters

srcFile	The location and name of the .tmpl file to copy
dstDirectory	The directory to copy to and instantiate in.
newName	New name for the file. If "0", only ".tmpl" is removed.

Definition at line 202 of file BlockSourceCopier.cc.

                       {
    const string DS = FileSystem::DIRECTORY_SEPARATOR;
 
    if (!FileSystem::fileExists(srcFile)) {
        string errorMsg = "Source file " + srcFile + " not found.";
        throw IOException(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    if (!FileSystem::fileExists(dstDirectory)) {
        if (!FileSystem::createDirectory(dstDirectory)) {
            string errorMsg = "Unable to create directory " +
                dstDirectory;
            throw IOException(__FILE__, __LINE__, __func__, errorMsg);
        }
    }
 
    string source = FileSystem::fileOfPath(srcFile);
    string dstFile;
 
    if (newName == "0") {
        dstFile = source.erase(source.find(".tmpl", 0), string::npos);
    } else {
        dstFile = newName;
    }
 
    instantiator_.instantiateTemplateFile(
        srcFile, dstDirectory + DS + dstFile);
}

References __func__, FileSystem::createDirectory(), FileSystem::DIRECTORY_SEPARATOR, DS, FileSystem::fileExists(), FileSystem::fileOfPath(), HDLTemplateInstantiator::instantiateTemplateFile(), and instantiator_.

Referenced by DefaultICDecoderGenerator::generate().

Here is the call graph for this function:

◆ isCopied()

bool ProGe::BlockSourceCopier::isCopied ( const std::string & file ) const

private

Tells whether the given file is copied already.

Parameters

file The file.

Returns: True if the file is copied, otherwise false.

Definition at line 357 of file BlockSourceCopier.cc.

                                                       {
    return AssocTools::containsKey(copiedFiles_, file);
}

References AssocTools::containsKey(), and copiedFiles_.

Referenced by copyFiles().

Here is the call graph for this function:

◆ setCopied()

void ProGe::BlockSourceCopier::setCopied ( const std::string & file )

private

Marks the file as copied.

Parameters

file The file.

Definition at line 344 of file BlockSourceCopier.cc.

                                                  {
    copiedFiles_.insert(file);
}

References copiedFiles_.

Referenced by copyFiles().

Member Data Documentation

◆ copiedFiles_

std::set<std::string> ProGe::BlockSourceCopier::copiedFiles_

private

Copied files.

Definition at line 99 of file BlockSourceCopier.hh.

Referenced by isCopied(), and setCopied().

◆ entityStr_

TCEString ProGe::BlockSourceCopier::entityStr_

private

Definition at line 96 of file BlockSourceCopier.hh.

Referenced by BlockSourceCopier().

◆ implementation_

const IDF::MachineImplementation& ProGe::BlockSourceCopier::implementation_

private

The IDF object model.

Definition at line 95 of file BlockSourceCopier.hh.

Referenced by copyProcessorSpecific(), and copyShared().

◆ instantiator_

HDLTemplateInstantiator ProGe::BlockSourceCopier::instantiator_

private

Object that instantiates templates.

Definition at line 101 of file BlockSourceCopier.hh.

Referenced by BlockSourceCopier(), copyProcessorSpecific(), getTemplateInstatiator(), and instantiateHDLTemplate().

◆ language_

const HDL ProGe::BlockSourceCopier::language_

private

Definition at line 97 of file BlockSourceCopier.hh.

Referenced by copyFiles(), copyProcessorSpecific(), and copyShared().

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BlockSourceCopier()

◆ ~BlockSourceCopier()

Member Function Documentation

◆ copyBaseRFFiles()

◆ copyFiles()

◆ copyFromTemplate()

◆ copyProcessorSpecific()

◆ copyShared()

◆ getTemplateInstatiator()

◆ instantiateHDLTemplate()

◆ isCopied()

◆ setCopied()

Member Data Documentation

◆ copiedFiles_

◆ entityStr_

◆ implementation_

◆ instantiator_

◆ language_