ImplementationTester Class Reference

#include <ImplementationTester.hh>

Collaboration diagram for ImplementationTester:

Public Member Functions
	ImplementationTester ()
	ImplementationTester (std::string hdbFile, VhdlSim simulator)
	ImplementationTester (std::string hdbFile, VhdlSim simulator, bool verbose, bool leaveDirty)
virtual	~ImplementationTester ()
void	setVhdlSimulator (VhdlSim simulator)
void	openHdb (std::string hdbFile)
bool	canTestFU (const int entryID, std::string &reason)
bool	canTestRF (const int entryID, std::string &reason)
bool	validateFU (const int entryID, std::vector< std::string > &errors)
bool	validateRF (const int entryID, std::vector< std::string > &errors)
std::set< int >	fuEntryIDs () const
std::set< int >	rfEntryIDs () const

Private Member Functions
bool	fuHasMemoryAccess (HDB::FUEntry *fuEntry) const
bool	fuFullyPipelined (HDB::FUEntry *fuEntry) const
bool	fuHasExternalPorts (HDB::FUEntry *fuEntry) const
bool	fuHasOnePort (HDB::FUEntry *fuEntry) const
HDB::FUEntry *	fuEntryFromHdb (int entryID) const
HDB::RFEntry *	rfEntryFromHdb (int entryID) const
bool	createTempDir ()
std::string	fuTbName (int id) const
std::string	rfTbName (int id) const
void	openTbFile (std::ofstream &fileStream, std::string fileName) const
void	createListOfSimulationFiles (const HDB::HWBlockImplementation *impl, std::vector< std::string > &files) const
void	createTestbench (TestbenchGenerator *tbGen, std::string tbName) const
bool	simulateTestbench (std::string testbench, const HDB::HWBlockImplementation *implementation, std::vector< std::string > &errors) const

Private Attributes
std::string	hdbFile_
HDB::HDBManager *	hdb_
VhdlSim	simulator_
bool	verbose_
bool	leaveDirty_
std::string	tempDir_

Detailed Description

Definition at line 52 of file ImplementationTester.hh.

Constructor & Destructor Documentation

ImplementationTester() [1/3]

ImplementationTester::ImplementationTester

(

)

Default constructor

Definition at line 74 of file ImplementationTester.cc.

                                          : 
    hdbFile_(""),
    hdb_(NULL),
    simulator_(SIM_GHDL), verbose_(false), leaveDirty_(false), tempDir_("") {
}

ImplementationTester() [2/3]

ImplementationTester::ImplementationTester	(	std::string	hdbFile,
		VhdlSim	simulator
	)

Constructor

Parameters

hdbFile	Name of the hdb file
simulator	Name of the HDL simulator to be used

Definition at line 86 of file ImplementationTester.cc.

                                         : 
    hdbFile_(hdbFile),
    hdb_(NULL),
    simulator_(simulator),
    verbose_(false), leaveDirty_(false), tempDir_("") {
 
    hdbFile_ = FileSystem::absolutePathOf(hdbFile_);
    openHdb(hdbFile_);
}

References FileSystem::absolutePathOf(), hdbFile_, and openHdb().

Here is the call graph for this function:

ImplementationTester() [3/3]

ImplementationTester::ImplementationTester	(	std::string	hdbFile,
		VhdlSim	simulator,
		bool	verbose,
		bool	leaveDirty
	)

Constructor

Parameters

hdbFile	Name of the hdb file
simulator	Name of the HDL simulator to be used
verbose	Enable verbose messages
leaveDirty	Don't delete created testbench files

Definition at line 106 of file ImplementationTester.cc.

                                                                        :
    hdbFile_(hdbFile),
    hdb_(NULL),
    simulator_(simulator),
    verbose_(verbose), leaveDirty_(leaveDirty), tempDir_("") {
 
    hdbFile_ = FileSystem::absolutePathOf(hdbFile_);
    openHdb(hdbFile_);
}

References FileSystem::absolutePathOf(), hdbFile_, and openHdb().

Here is the call graph for this function:

~ImplementationTester()

ImplementationTester::~ImplementationTester ( )

virtual

Destructor

Definition at line 120 of file ImplementationTester.cc.

                                            {
    if (leaveDirty_) {
        if (tempDir_.empty()) {
            std::cout << "No testbench files created" << std::endl;
        } else {
            std::cout << "Testbench files are stored at " << tempDir_ 
                      << std::endl;
        }
    } else {
        // clear created files
        if (!tempDir_.empty()) {
            FileSystem::removeFileOrDirectory(tempDir_);
        }
    }
}

References leaveDirty_, FileSystem::removeFileOrDirectory(), and tempDir_.

Here is the call graph for this function:

Member Function Documentation

canTestFU()

bool ImplementationTester::canTestFU	(	const int	entryID,
		std::string &	reason
	)

Tests whether a FU can be tested

Parameters

entryID	Entry ID of the FU
reason	If FU can't be tested this string holds the reason why

Returns

True if can be tested

Definition at line 175 of file ImplementationTester.cc.

                                                                    {
 
    bool canTest = true;
    HDB::FUEntry* fuEntry = NULL;
    try {
        fuEntry = fuEntryFromHdb(entryID);
    } catch (KeyNotFound& e) {
        std::ostringstream errorStream;
        errorStream << "ID " << entryID << " does not exist in HDB "
                    << hdbFile_;
        reason = errorStream.str();
        return false;
    }
    if (!fuEntry->hasArchitecture()) {
        reason = "FU entry does not have architecture";
        canTest = false;
    } else if (!fuEntry->hasImplementation()) {
        reason = "FU entry does not have implementation";
        canTest = false;
    } else if (fuHasMemoryAccess(fuEntry)) {
        reason = "Simulation of memory accessing FUs is not supported";
        canTest = false;
    } else if (!fuFullyPipelined(fuEntry)) {
        reason = "Simulation of non-pipelined FUs in not supported";
        canTest = false;
    } else if (fuHasExternalPorts(fuEntry)) {
        reason = "Simulation of FUs with external ports is not supported";
        canTest = false;
    } else if (fuHasOnePort(fuEntry)) {
        reason = "FU has only one port";
        canTest = false;
    }
    delete fuEntry;
    return canTest;
}

References fuEntryFromHdb(), fuFullyPipelined(), fuHasExternalPorts(), fuHasMemoryAccess(), fuHasOnePort(), HDB::FUEntry::hasArchitecture(), HDB::FUEntry::hasImplementation(), and hdbFile_.

Referenced by HDBTester::testFU(), and validateFU().

Here is the call graph for this function:

canTestRF()

bool ImplementationTester::canTestRF	(	const int	entryID,
		std::string &	reason
	)

Tests whether a RF can be tested

Parameters

entryID	Entry ID of the RF
reason	If RF can't be tested this string holds the reason why

Returns

True if can be tested

Definition at line 219 of file ImplementationTester.cc.

                                                                    {
 
    bool canTest = true;
    HDB::RFEntry* rfEntry = NULL;
    try {
        rfEntry = rfEntryFromHdb(entryID);
    } catch (KeyNotFound& e) {
        std::ostringstream errorStream;
        errorStream << "ID " << entryID << " does not exist in HDB "
                    << hdbFile_;
        reason = errorStream.str();
        return false;
    }
    if (!rfEntry->hasArchitecture()) {
        reason = "RF entry does not have architecture";
        canTest = false;
    } else if (!rfEntry->hasImplementation()) {
        reason = "RF entry does not have implementation";
        canTest = false;
    } else if (rfEntry->architecture().readPortCount() == 0) {
        reason = "RF does not have a read port";
        canTest = false;
    } else if (rfEntry->architecture().writePortCount() == 0) {
        reason = "RF does not have a write port";
        canTest = false;
    } else if (rfEntry->architecture().bidirPortCount() != 0) {
        reason = "RF has bidirectional ports";
        canTest = false;
    } else if (rfEntry->architecture().latency() != 1) {
        reason = "RF does not have latency of 1 cycle";
        canTest = false;
    }
    delete rfEntry;
    return canTest;
}

References HDB::RFEntry::architecture(), HDB::RFArchitecture::bidirPortCount(), HDB::RFEntry::hasArchitecture(), HDB::RFEntry::hasImplementation(), hdbFile_, HDB::RFArchitecture::latency(), HDB::RFArchitecture::readPortCount(), rfEntryFromHdb(), and HDB::RFArchitecture::writePortCount().

Referenced by HDBTester::testRF(), and validateRF().

Here is the call graph for this function:

createListOfSimulationFiles()

void ImplementationTester::createListOfSimulationFiles ( const HDB::HWBlockImplementation *  impl, std::vector< std::string > &  files  ) const

private

Creates a list of HDL files of a FU/RF implementation

Parameters

impl	FU/RF implementation
files	Vector containing the HDL files

Definition at line 510 of file ImplementationTester.cc.

                                       {
 
    for (int i = 0; i < impl->implementationFileCount(); i++) {
        string fullPath = "";
        string filename = impl->file(i).pathToFile();
        if (FileSystem::isAbsolutePath(filename)) {
            fullPath = filename;
        } else {
            string hdbPath = FileSystem::directoryOfPath(hdbFile_);
            fullPath = hdbPath + FileSystem::DIRECTORY_SEPARATOR + filename;
        }
        files.push_back(fullPath);
    }
}

References FileSystem::DIRECTORY_SEPARATOR, FileSystem::directoryOfPath(), HDB::HWBlockImplementation::file(), hdbFile_, HDB::HWBlockImplementation::implementationFileCount(), FileSystem::isAbsolutePath(), and HDB::BlockImplementationFile::pathToFile().

Referenced by simulateTestbench().

Here is the call graph for this function:

createTempDir()

bool ImplementationTester::createTempDir ( )

private

Definition at line 453 of file ImplementationTester.cc.

                                    {
 
    tempDir_ = FileSystem::createTempDirectory();
    return !tempDir_.empty();
}

References FileSystem::createTempDirectory(), and tempDir_.

Referenced by validateFU(), and validateRF().

Here is the call graph for this function:

createTestbench()

void ImplementationTester::createTestbench ( TestbenchGenerator *  tbGen, std::string  tbName  ) const

private

Definition at line 566 of file ImplementationTester.cc.

                                                       {
    
    ofstream fileStream;
    openTbFile(fileStream, tbName);
    tbGen->generateTestbench(fileStream);
    fileStream.close();
}

References TestbenchGenerator::generateTestbench(), and openTbFile().

Referenced by validateFU(), and validateRF().

Here is the call graph for this function:

fuEntryFromHdb()

HDB::FUEntry * ImplementationTester::fuEntryFromHdb ( int  entryID ) const

private

Definition at line 427 of file ImplementationTester.cc.

                                                      {
 
    if (!hdb_) {
      InvalidData e(
            __FILE__, __LINE__, "ImplementationTester",
            "HDB is not defined");
        throw e;
    }
    return hdb_->fuByEntryID(entryID);
}

References HDB::HDBManager::fuByEntryID(), and hdb_.

Referenced by canTestFU(), and validateFU().

Here is the call graph for this function:

fuEntryIDs()

std::set< int > ImplementationTester::fuEntryIDs

(

)

const

Definition at line 369 of file ImplementationTester.cc.

                                       {
 
    if (!hdb_) {
      InvalidData e(
            __FILE__, __LINE__, "ImplementationTester",
            "HDB is not defined");
        throw e;
    }
    return hdb_->fuEntryIDs();
}

References HDB::HDBManager::fuEntryIDs(), and hdb_.

Referenced by HDBTester::testAllEntries().

Here is the call graph for this function:

fuFullyPipelined()

bool ImplementationTester::fuFullyPipelined ( HDB::FUEntry *  fuEntry ) const

private

Definition at line 403 of file ImplementationTester.cc.

                                                                 {
 
    HDB::FUArchitecture arch = fuEntry->architecture();
    return arch.architecture().pipelineElementCount() == 0;
}

References HDB::FUArchitecture::architecture(), HDB::FUEntry::architecture(), and TTAMachine::FunctionUnit::pipelineElementCount().

Referenced by canTestFU().

Here is the call graph for this function:

fuHasExternalPorts()

bool ImplementationTester::fuHasExternalPorts ( HDB::FUEntry *  fuEntry ) const

private

Definition at line 411 of file ImplementationTester.cc.

                                                                  {
 
    HDB::FUImplementation* fuImpl = &fuEntry->implementation();
    return fuImpl->externalPortCount() != 0;
}

References HDB::FUImplementation::externalPortCount(), and HDB::FUEntry::implementation().

Referenced by canTestFU().

Here is the call graph for this function:

fuHasMemoryAccess()

bool ImplementationTester::fuHasMemoryAccess ( HDB::FUEntry *  fuEntry ) const

private

Definition at line 395 of file ImplementationTester.cc.

                                                                 {
 
    HDB::FUArchitecture arch = fuEntry->architecture();
    return arch.architecture().hasAddressSpace();
}

References HDB::FUArchitecture::architecture(), HDB::FUEntry::architecture(), and TTAMachine::FunctionUnit::hasAddressSpace().

Referenced by canTestFU().

Here is the call graph for this function:

fuHasOnePort()

bool ImplementationTester::fuHasOnePort ( HDB::FUEntry *  fuEntry ) const

private

Definition at line 419 of file ImplementationTester.cc.

                                                            {
 
    HDB::FUImplementation* fuImpl = &fuEntry->implementation();
    return fuImpl->architecturePortCount() == 1;
}

References HDB::FUImplementation::architecturePortCount(), and HDB::FUEntry::implementation().

Referenced by canTestFU().

Here is the call graph for this function:

fuTbName()

std::string ImplementationTester::fuTbName ( int  id ) const

private

Creates name for the testbench file

Parameters

id	ID number of the FU

Returns

testbench name

Definition at line 467 of file ImplementationTester.cc.

                                           {
 
    std::ostringstream name;
    name << tempDir_ << FileSystem::DIRECTORY_SEPARATOR
         << "tb_fu_" << id << ".vhdl";
    return name.str();
}

References FileSystem::DIRECTORY_SEPARATOR, and tempDir_.

Referenced by validateFU().

openHdb()

void ImplementationTester::openHdb

(

std::string

hdbFile

)

Tries to open hdb file

Parameters

hdbFile

Name of the hdb file

Definition at line 154 of file ImplementationTester.cc.

                                               {
 
    try {
        hdb_ = &HDB::CachedHDBManager::instance(hdbFile_);
    } catch (const Exception& e) {
        InvalidData excep(
            __FILE__, __LINE__, "ImplementationTester", 
            "Error while loading input data: " + e.errorMessage());
        throw excep;
    }
    hdbFile_ = hdbFile;
}

References Exception::errorMessage(), hdb_, hdbFile_, and HDB::CachedHDBManager::instance().

Referenced by ImplementationTester(), and ImplementationTester().

Here is the call graph for this function:

openTbFile()

void ImplementationTester::openTbFile ( std::ofstream &  fileStream, std::string  fileName  ) const

private

Definition at line 492 of file ImplementationTester.cc.

                                                       {
 
    fileStream.open(fileName.c_str());
    if (!fileStream) {
        IOException(__FILE__, __LINE__, "ImplementationTester",
                    "Failed to open file " + fileName + " for writing!");
    }
}

Referenced by createTestbench().

rfEntryFromHdb()

HDB::RFEntry * ImplementationTester::rfEntryFromHdb ( int  entryID ) const

private

Definition at line 440 of file ImplementationTester.cc.

                                                      {
 
    if (!hdb_) {
      InvalidData e(
            __FILE__, __LINE__, "ImplementationTester",
            "HDB is not defined");
        throw e;
    }
    return hdb_->rfByEntryID(entryID);
}

References hdb_, and HDB::HDBManager::rfByEntryID().

Referenced by canTestRF(), and validateRF().

Here is the call graph for this function:

rfEntryIDs()

std::set< int > ImplementationTester::rfEntryIDs

(

)

const

Definition at line 382 of file ImplementationTester.cc.

                                       {
 
    if (!hdb_) {
      InvalidData e(
            __FILE__, __LINE__, "ImplementationTester",
            "HDB is not defined");
        throw e;
    }
    return hdb_->rfEntryIDs();
}

References hdb_, and HDB::HDBManager::rfEntryIDs().

Referenced by HDBTester::testAllEntries().

Here is the call graph for this function:

rfTbName()

std::string ImplementationTester::rfTbName ( int  id ) const

private

Creates name for the testbench file

Parameters

id	ID number of the RF

Returns

testbench name

Definition at line 482 of file ImplementationTester.cc.

                                           {
 
    std::ostringstream name;
    name << tempDir_ << FileSystem::DIRECTORY_SEPARATOR
         << "tb_rf_" << id << ".vhdl";
    return name.str();
}

References FileSystem::DIRECTORY_SEPARATOR, and tempDir_.

Referenced by validateRF().

setVhdlSimulator()

void ImplementationTester::setVhdlSimulator

(

VhdlSim

simulator

)

Set VHDL simulator to be used in simulation

Parameters

simulator

Name of the HDL simulator to be used

Definition at line 143 of file ImplementationTester.cc.

                                                        {
    simulator_ = simulator;
}

References simulator_.

simulateTestbench()

bool ImplementationTester::simulateTestbench ( std::string  testbench, const HDB::HWBlockImplementation *  implementation, std::vector< std::string > &  errors  ) const

private

Compiles and simulates the testbech

Parameters

testbench	Name of the testbench file
implementation	Implementation of the FU/RF
errors	Error messages from the compilation/simulation

Returns

True if compilation and simulation were successfull

Definition at line 536 of file ImplementationTester.cc.

                                        {
 
    vector<string> hdlFiles;
    createListOfSimulationFiles(implementation, hdlFiles);
 
    ImplementationSimulator* sim = NULL;
    if (simulator_ == SIM_GHDL) {
        sim = new GhdlSimulator(testbench, hdlFiles, verbose_, leaveDirty_);
    } else if (simulator_ == SIM_MODELSIM) {
        sim = new ModelsimSimulator(
            testbench, hdlFiles, verbose_, leaveDirty_);
    }
 
    if (!sim->compile(errors)) {
        delete sim;
        return false;
    }
    
    bool success = true;
    if (!sim->simulate(errors)) {
        success = false;
    }
    delete sim;
    return success;
}

References ImplementationSimulator::compile(), createListOfSimulationFiles(), implementation, leaveDirty_, SIM_GHDL, SIM_MODELSIM, ImplementationSimulator::simulate(), simulator_, and verbose_.

Referenced by validateFU(), and validateRF().

Here is the call graph for this function:

validateFU()

bool ImplementationTester::validateFU	(	const int	entryID,
		std::vector< std::string > &	errors
	)

Validates that FU behaviour model and implementation are equal

Parameters

entryID	Entry ID of the FU
errors	Error messages from the validation process

Returns

True if there were no errors

Definition at line 263 of file ImplementationTester.cc.

                                                     {
 
    if (tempDir_.empty()) {
        if (!createTempDir()) {
            IOException exp(__FILE__, __LINE__, "ImplementationTester",
                            "Couldn't create temp directory");
            throw exp;
        }
    }
 
    string reason;
    if (!canTestFU(entryID, reason)) {
        InvalidData e(
            __FILE__, __LINE__, "ImplementationTester",
            "Cannot test FU: " + reason);
        throw e;
    }
    
    HDB::FUEntry* fuEntry = NULL;
    try {
        fuEntry = fuEntryFromHdb(entryID);
    } catch (KeyNotFound& e) {
        std::ostringstream errorStream;
        errorStream << "ID " << entryID << " does not exist in HDB "
                    << hdbFile_;
        string errorMsg = errorStream.str();
        errors.push_back(errorMsg);
        return false;
    }
    
    FUTestbenchGenerator tbGen(fuEntry);
    
    ofstream fileStream;
    string tbName = fuTbName(entryID);
 
    createTestbench(&tbGen, tbName);
 
    bool success = 
        simulateTestbench(tbName, &fuEntry->implementation(), errors);
    
    if (!leaveDirty_) {
        FileSystem::removeFileOrDirectory(tbName);
    }
 
    delete fuEntry;
    return success;
}

References canTestFU(), createTempDir(), createTestbench(), fuEntryFromHdb(), fuTbName(), hdbFile_, HDB::FUEntry::implementation(), leaveDirty_, FileSystem::removeFileOrDirectory(), simulateTestbench(), and tempDir_.

Referenced by HDBTester::testFU().

Here is the call graph for this function:

validateRF()

bool ImplementationTester::validateRF	(	const int	entryID,
		std::vector< std::string > &	errors
	)

Validates that RF behaviour model and implementation are equal

Parameters

entryID	Entry ID of the RF
errors	Error messages from the validation process

Returns

True if there were no errors

Definition at line 321 of file ImplementationTester.cc.

                                                     {
 
    if (tempDir_.empty()) {
        if (!createTempDir()) {
            IOException exp(__FILE__, __LINE__, "ImplementationTester",
                            "Couldn't create temp directory");
            throw exp;
        }
    }
 
    string reason;
    if (!canTestRF(entryID, reason)) {
        InvalidData e(
            __FILE__, __LINE__, "ImplementationTester",
            "Cannot test RF: " + reason);
        throw e;
    }
    
    HDB::RFEntry* rfEntry = NULL;
    try {
        rfEntry = rfEntryFromHdb(entryID);
    } catch (KeyNotFound& e) {
        std::ostringstream errorStream;
        errorStream << "ID " << entryID << " does not exist in HDB "
                    << hdbFile_;
        string errorMsg = errorStream.str();
        errors.push_back(errorMsg);
        return false;
    }
 
    RFTestbenchGenerator tbGen(rfEntry);
    string tbName = rfTbName(entryID);
 
    createTestbench(&tbGen, tbName);
 
    bool success = 
        simulateTestbench(tbName, &rfEntry->implementation(), errors);
    
    if (!leaveDirty_) {
        FileSystem::removeFileOrDirectory(tbName);
    }
    delete rfEntry;
    return success;
}

References canTestRF(), createTempDir(), createTestbench(), hdbFile_, HDB::RFEntry::implementation(), leaveDirty_, FileSystem::removeFileOrDirectory(), rfEntryFromHdb(), rfTbName(), simulateTestbench(), and tempDir_.

Referenced by HDBTester::testRF().

Here is the call graph for this function:

Member Data Documentation

hdb_

HDB::HDBManager* ImplementationTester::hdb_

private

Definition at line 117 of file ImplementationTester.hh.

Referenced by fuEntryFromHdb(), fuEntryIDs(), openHdb(), rfEntryFromHdb(), and rfEntryIDs().

hdbFile_

std::string ImplementationTester::hdbFile_

private

Definition at line 116 of file ImplementationTester.hh.

Referenced by canTestFU(), canTestRF(), createListOfSimulationFiles(), ImplementationTester(), ImplementationTester(), openHdb(), validateFU(), and validateRF().

leaveDirty_

bool ImplementationTester::leaveDirty_

private

Definition at line 121 of file ImplementationTester.hh.

Referenced by simulateTestbench(), validateFU(), validateRF(), and ~ImplementationTester().

simulator_

VhdlSim ImplementationTester::simulator_

private

Definition at line 119 of file ImplementationTester.hh.

Referenced by setVhdlSimulator(), and simulateTestbench().

tempDir_

std::string ImplementationTester::tempDir_

private

Definition at line 123 of file ImplementationTester.hh.

Referenced by createTempDir(), fuTbName(), rfTbName(), validateFU(), validateRF(), and ~ImplementationTester().

verbose_

bool ImplementationTester::verbose_

private

Definition at line 120 of file ImplementationTester.hh.

Referenced by simulateTestbench().

---

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

• ImplementationTester.hh
• ImplementationTester.cc