#include <ProGeUI.hh>

Inheritance diagram for ProGe::ProGeUI:

Collaboration diagram for ProGe::ProGeUI:

Public Member Functions
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)

Protected Member Functions
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, bool generateIntegratedTestbench)

Protected Attributes
TTAMachine::Machine *	machine_
	The loaded machine.

Private Member Functions
void	checkIfNull (void *nullPointer, const std::string &errorMsg)

void	readLSUParameters (MemInfo &dmem) const

void	readImemParameters (MemInfo &imem) const

void	generateIDF (const ProGeOptions &options, std::ostream &verboseStream)

Private Attributes
BinaryEncoding *	bem_
	The loaded binary encoding map.

IDF::MachineImplementation *	idf_
	The loaded machine implementation.

PluginTools	pluginTool_
	Tool for loading plugin.

ICDecoderGeneratorPlugin *	plugin_
	The loaded IC/decoder generator plugin.

std::string	pluginFile_
	The plugin file.

std::string	entityName_
	Name of the toplevel entity.

ProcessorGenerator	generator_

Static Private Attributes
static const std::string	DEFAULT_ENTITY_STR = "tta0"

Detailed Description

Base class for user intefaces of ProGe.

Definition at line 66 of file ProGeUI.hh.

Constructor & Destructor Documentation

◆ ~ProGeUI()

ProGe::ProGeUI::~ProGeUI ( )

virtual

The destructor.

Definition at line 103 of file ProGeUI.cc.

                  {
    if (machine_ != NULL) {
        delete machine_;
    }
    if (bem_ != NULL) {
        delete bem_;
    }
    if (idf_ != NULL) {
        delete idf_;
    }
    if (plugin_ != NULL) {
        delete plugin_;
    }
}

References bem_, idf_, machine_, and plugin_.

◆ ProGeUI()

ProGe::ProGeUI::ProGeUI ( )

The constructor.

Definition at line 94 of file ProGeUI.cc.

                 :
    machine_(NULL), bem_(NULL), idf_(NULL), plugin_(NULL), pluginFile_(""),
    entityName_(DEFAULT_ENTITY_STR) {
}

Member Function Documentation

◆ checkIfNull()

void ProGe::ProGeUI::checkIfNull	(	void *	nullPointer,
		const std::string &	errorMsg
	)

private

Checks if given pointer is NULL.

Throws a InvalidData exception if given pointer is NULL and sets given error message as exceptions error message.

Parameters

nullPointer	Some pointer.
errorMsg	Error message for the InvalidData exception.

Definition at line 436 of file ProGeUI.cc.

                                                                 {
    if (nullPointer == NULL) {
        throw InvalidData(__FILE__, __LINE__, __func__, errorMsg);
    }
}

References __func__.

Referenced by generateProcessor(), generateTestBench(), and loadICDecoderGeneratorPlugin().

◆ generateIDF()

void ProGe::ProGeUI::generateIDF	(	const ProGeOptions &	options,
		std::ostream &	verboseStream
	)

private

Checking only operations that ADF has instead of them all

Definition at line 527 of file ProGeUI.cc.

                                                            {
    std::ostream nullstream(0);
    std::ostream& verbose =
        Application::increasedVerbose() ? verboseStream : nullstream;
 
    if (!idf_) {
        verbose << "IDF not set, trying automated generation.\n";
        idf_ = new IDF::MachineImplementation();
    }
 
    std::vector<std::string> handledFUs;
 
    // Prefill the handledFUs with values from the .idf-file
    for (auto&& fu : machine_->functionUnitNavigator()) {
        if (idf_->hasFUImplementation(fu->name()) ||
            idf_->hasFUGeneration(fu->name())) {
            handledFUs.emplace_back(fu->name());
        }
    }
 
    std::vector<IDF::FUGenerated::Info> infos =
        ProGeTools::createFUGeneratableOperationInfos(options, verbose);
    //! Checking only operations that ADF has instead of them all
    //  would be faster.
    std::vector<IDF::FUGenerated::DAGOperation> dagops =
        ProGeTools::generateableDAGOperations(infos, verbose);
 
    auto already_handled = [&](const std::string& name) {
        return std::find(handledFUs.begin(), handledFUs.end(), name) !=
               handledFUs.end();
    };
 
    auto select_hdb_implementations = [&]() {
        for (auto&& fu : machine_->functionUnitNavigator()) {
            if (already_handled(fu->name())) {
                continue;
            }
            verbose << " select implementation for " << fu->name() << "... ";
            FUImplementationLocation* loc =
                new IUImplementationLocation("", -1, fu->name());
            if (ProGeTools::checkForSelectableFU(
                    options, *fu, *loc, verbose)) {
                verbose << "OK (selected " << loc->id() << " from "
                        << loc->hdbFile() << ")\n";
                idf_->addFUImplementation(loc);
                handledFUs.emplace_back(fu->name());
            } else {
                verbose << "FAIL\n";
            }
        }
    };
 
    auto generate_implementations = [&]() {
        for (auto&& fu : machine_->functionUnitNavigator()) {
            if (already_handled(fu->name())) {
                continue;
            }
            verbose << " generate implementation for " << fu->name()
                    << "... ";
            IDF::FUGenerated fug(fu->name());
            if (ProGeTools::checkForGeneratableFU(
                    options, *fu, fug, infos, dagops)) {
                verbose << "OK\n";
                idf_->addFuGeneration(fug);
                handledFUs.emplace_back(fug.name());
            } else {
                verbose << "FAIL\n";
            }
        }
    };
 
    // Create or select FUs.
    if (options.preferHDLGeneration) {
        generate_implementations();
        select_hdb_implementations();
    } else {
        select_hdb_implementations();
        generate_implementations();
    }
 
    // IUs.
    for (auto&& iu : machine_->immediateUnitNavigator()) {
        if (idf_->hasIUImplementation(iu->name())) {
            continue;
        }
        verbose << " select implementation for " << iu->name() << "... ";
        IUImplementationLocation* loc =
            new IUImplementationLocation("", -1, iu->name());
        if (ProGeTools::checkForSelectableIU(options, *iu, *loc, verbose)) {
            verbose << "OK (selected " << loc->id() << " from "
                    << loc->hdbFile() << ")\n";
            idf_->addIUImplementation(loc);
        } else {
            verbose << "FAIL\n";
        }
    }
 
    // RFs.
    for (auto&& rf : machine_->registerFileNavigator()) {
        if (idf_->hasRFImplementation(rf->name())) {
            continue;
        }
        verbose << " select implementation for " << rf->name() << "... ";
        RFImplementationLocation* loc =
            new RFImplementationLocation("", -1, rf->name());
        if (ProGeTools::checkForSelectableRF(options, *rf, *loc, verbose)) {
            verbose << "OK (selected " << loc->id() << " from "
                    << loc->hdbFile() << ")\n";
            idf_->addRFImplementation(loc);
        } else {
            verbose << "FAIL\n";
        }
    }
 
    // IC/Decoder plugin.
    if (!idf_->hasICDecoderPluginFile()) {
        idf_->setICDecoderPluginName("DefaultICDecoder");
        idf_->setICDecoderPluginFile("DefaultICDecoderPlugin.so");
    }
    // Set parameters based on argList given in command line.
    // Overrides the matching .idf-file params with the command line params.
    for (auto&& kvp : options.icdArgList) {
        idf_->setICDecoderParameter(kvp.first, kvp.second);
    }
 
    // If ICDecoder parameters are not given, give some defaults based
    //  on the GCU's latency.
    if (idf_->icDecoderParameterCount() == 0) {
        int delaySlots = machine_->controlUnit()->delaySlots();
        if (delaySlots == 3) {
            // Happy old slow default machine.
        } else if (delaySlots == 2) {
            idf_->setICDecoderParameter("bypassinstructionregister", "yes");
        } else {
            throw std::runtime_error(
                "Cannot decide ICDecoder parameters for " +
                std::to_string(delaySlots) + "-stage GCU.");
        }
    }
}

Referenced by generateProcessor().

Here is the call graph for this function:

◆ generateProcessor()

void ProGe::ProGeUI::generateProcessor	(	const ProGeOptions &	options,
		int	imemWidthInMAUs,
		std::ostream &	errorStream = `std::cerr`,
		std::ostream &	warningStream = `std::cerr`,
		std::ostream &	verboseStream = `std::cerr`
	)

Generates the processor with the loaded data.

Parameters

imemWidthInMAUs	Width of the instruction memory in MAUs.
language	The language to generate.
dstDirectory	The destination directory.
sharedDstDirectory	The destination directory for VHDL files.
entityString	The string that is used as the top level entity name and to differentiate the entity and package names in processor-specific HDL files.
errorStream	Stream where error messages are written.
warningStream	Stream where warning messages are written.

Exceptions

InvalidData	If ADF or IDF is not loaded.
IOException	If an IO exception occurs.
DynamicLibraryException	If the default plugin cannot be opened.
InvalidData	If HDB or IDF is erroneous or if BEM is not compatible with the machine.
IllegalMachine	If the machine is illegal.
OutOfRange	If the given instruction memory width is not positive.
InstanceNotFound	Something missing from HDB.
IllegalParameters	IC/Decoder plugin parameter not recognized

Definition at line 298 of file ProGeUI.cc.

                                         {
    entityName_ = options.entityName;
 
    checkIfNull(machine_, "ADF not loaded");
 
    generateIDF(options, verboseStream);
 
    if (bem_ == NULL) {
        BEMGenerator generator(*machine_);
        bem_ = generator.generate();
    }
 
    // validate IDF against machine
    IDFValidator idfValidator(*idf_, *machine_);
    if (!idfValidator.validate()) {
        string errorMsg = idfValidator.errorMessage(0);
        throw InvalidData(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    // validate BEM against machine
    BEMValidator bemValidator(*bem_, *machine_);
    if (!bemValidator.validate()) {
        string errorMsg("");
        if (bemValidator.errorCount() > 0) {
            errorMsg = bemValidator.errorMessage(0);
        }
        throw InvalidData(__FILE__, __LINE__, __func__, errorMsg);
    } else if (bemValidator.warningCount() > 0) {
        for (int i = 0; i < bemValidator.warningCount(); i++) {
            warningStream << bemValidator.warningMessage(i) << std::endl;
        }
    }
 
    if (plugin_ == NULL) {
        if (!idf_->hasICDecoderPluginFile() ||
            !idf_->hasICDecoderPluginName()) {
            string errorMsg = "IC/decoder generator plugin not defined";
            throw InvalidData(__FILE__, __LINE__, __func__, errorMsg);
        } else {
            loadICDecoderGeneratorPlugin(
                idf_->icDecoderPluginFile(), idf_->icDecoderPluginName());
 
            // set plugin parameters
            for (unsigned i = 0; i < idf_->icDecoderParameterCount(); i++) {
                plugin_->setParameter(
                    idf_->icDecoderParameterName(i),
                    idf_->icDecoderParameterValue(i));
            }
            plugin_->readParameters();
        }
    }
    // remove unconnected sockets (if any) before generation
    ProGe::ProcessorGenerator::removeUnconnectedSockets(
        *machine_, warningStream);
 
    try {
        generator_.generateProcessor(
            options, *machine_, *idf_, *plugin_, imemWidthInMAUs, errorStream,
            warningStream, verboseStream);
    } catch (Exception& e) {
        std::cerr << e.errorMessage() << std::endl;
    }
}

References __func__, bem_, checkIfNull(), entityName_, BEMValidator::errorCount(), Exception::errorMessage(), BEMValidator::errorMessage(), IDFValidator::errorMessage(), BEMGenerator::generate(), generateIDF(), ProGe::ProcessorGenerator::generateProcessor(), generator_, IDF::MachineImplementation::hasICDecoderPluginFile(), IDF::MachineImplementation::hasICDecoderPluginName(), IDF::MachineImplementation::icDecoderParameterCount(), IDF::MachineImplementation::icDecoderParameterName(), IDF::MachineImplementation::icDecoderParameterValue(), IDF::MachineImplementation::icDecoderPluginFile(), IDF::MachineImplementation::icDecoderPluginName(), idf_, loadICDecoderGeneratorPlugin(), machine_, options, plugin_, ProGe::ICDecoderGeneratorPlugin::readParameters(), ProGe::ProcessorGenerator::removeUnconnectedSockets(), ProGe::ICDecoderGeneratorPlugin::setParameter(), BEMValidator::validate(), IDFValidator::validate(), BEMValidator::warningCount(), and BEMValidator::warningMessage().

Referenced by GenerateProcessor::generateProcessor(), and GenerateProcessorDialog::onOK().

Here is the call graph for this function:

◆ generateScripts()

void ProGe::ProGeUI::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
	)

Generates vhdl compilation and simulation scripts.

Parameters

dstDir	Destination directory for the scripts.
progeOutDir	ProGe output directory.
progeOutDir	Shared HDL output directory.
testBenchDir	Directory where a test bench is stored.

Definition at line 416 of file ProGeUI.cc.

                                                                       {
    ProGeScriptGenerator sGen(
        language, *idf_, dstDir, progeOutDir, sharedOutDir, testBenchDir,
        entityName_, simulationRuntime);
    sGen.generateAll();
}

References entityName_, ProGeScriptGenerator::generateAll(), and idf_.

Referenced by GenerateProcessor::generateProcessor(), and GenerateProcessorDialog::onOK().

Here is the call graph for this function:

◆ generateTestBench()

void ProGe::ProGeUI::generateTestBench	(	const ProGe::HDL	language,
		const std::string &	dstDir,
		const std::string &	progeOutDir
	)

Generates a test bench for simulating.

Parameters

dstDir	Destination directory for the test bench.
progeOutDir	ProGe output directory.

Exceptions

InvalidData If Machine or implementation not loaded.

Definition at line 375 of file ProGeUI.cc.

                                  {
 
    checkIfNull(machine_, "ADF not loaded");
    checkIfNull(idf_, "IDF not loaded");
 
    if (language == Verilog) {
        // Note: deprecated legacy test bench. Still used since the new test
        // bench does not yet support generation for verilog.
        ProGeTestBenchGenerator tbGen = ProGeTestBenchGenerator();
        tbGen.generate(
            language, *machine_, *idf_, dstDir, progeOutDir, entityName_);
    } else {
        // New test bench generation to be replacing the old one. WIP and
        // first used to generate test benches for TTA processors.
        try {
            TestBenchBlock coreTestbench(
                generator_.generatorContext(),
                generator_.processorTopLevel());
            coreTestbench.write(Path(progeOutDir), language);
        } catch (Exception& e) {
            // There is one case the new test bench can not handle: same data
            // address spaces shared by two LSUs.
            ProGeTestBenchGenerator tbGen = ProGeTestBenchGenerator();
            tbGen.generate(
                language, *machine_, *idf_, dstDir, progeOutDir, entityName_);
        }
    }
}

References checkIfNull(), entityName_, ProGeTestBenchGenerator::generate(), generator_, ProGe::ProcessorGenerator::generatorContext(), idf_, machine_, ProGe::ProcessorGenerator::processorTopLevel(), ProGe::Verilog, and ProGe::TestBenchBlock::write().

Referenced by GenerateProcessor::generateProcessor(), and GenerateProcessorDialog::onOK().

Here is the call graph for this function:

◆ integrateProcessor()

void ProGe::ProGeUI::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,
		bool	generateIntegratedTestbench
	)

protected

Definition at line 443 of file ProGeUI.cc.

                                                                {
    string platformDir = progeOutDir + FileSystem::DIRECTORY_SEPARATOR +
        "platform";
 
    MemInfo imemInfo;
    imemInfo.type = imem;
    readImemParameters(imemInfo);
 
    PlatformIntegrator* integrator = NULL;
    // TODO: append new integrators here
    if (platformIntegrator == "Stratix2DSP") {
        integrator = new Stratix2DSPBoardIntegrator(
            machine_, idf_, language, progeOutDir, coreEntityName,
            platformDir, programName, fmax, warningStream, errorStream,
            imemInfo, dmem);
    } else if (platformIntegrator == "KoskiIntegrator") {
        integrator = new KoskiIntegrator(
            machine_, idf_, language, progeOutDir, coreEntityName,
            platformDir, programName, fmax, warningStream, errorStream,
            imemInfo, dmem);
    } else if (platformIntegrator == "AvalonIntegrator") {
        integrator = new AvalonIntegrator(
            machine_, idf_, language, progeOutDir, coreEntityName,
            platformDir, programName, fmax, warningStream, errorStream,
            imemInfo, dmem);
    } else if (platformIntegrator == "Stratix3DevKit") {
        integrator = new Stratix3DevKitIntegrator(
            machine_, idf_, language, progeOutDir, coreEntityName,
            platformDir, programName, fmax, warningStream, errorStream,
            imemInfo, dmem);
    } else if (platformIntegrator == "AlmaIFIntegrator") {
        integrator = new AlmaIFIntegrator(
            machine_, idf_, language, progeOutDir, coreEntityName,
            platformDir, programName, fmax, warningStream, errorStream,
            imemInfo, dmem, syncReset, generateIntegratedTestbench);
    } else {
        string errorMsg = "Unknown platform integrator: "
            + platformIntegrator;
        InvalidData exc(__FILE__, __LINE__, __func__, errorMsg);
        throw exc;
    }
    if (!deviceFamily.empty()) {
        integrator->setDeviceFamily(deviceFamily);
    }
    if (!deviceName.empty()) {
        integrator->setDeviceName(deviceName);
    }
 
    if (FileSystem::absolutePathOf(sharedOutputDir) != 
        FileSystem::absolutePathOf(progeOutDir)) {
        integrator->setSharedOutputDir(sharedOutputDir);
    }
 
    const NetlistBlock& ttaToplevel = generator_.processorTopLevel();
 
    try {
        integrator->integrateProcessor(&ttaToplevel);
    } catch (Exception& e) {
        delete integrator;
        throw e;
    }
    delete integrator;
}

References __func__, FileSystem::absolutePathOf(), FileSystem::DIRECTORY_SEPARATOR, generator_, idf_, PlatformIntegrator::integrateProcessor(), machine_, ProGe::ProcessorGenerator::processorTopLevel(), readImemParameters(), PlatformIntegrator::setDeviceFamily(), PlatformIntegrator::setDeviceName(), PlatformIntegrator::setSharedOutputDir(), and MemInfo::type.

Referenced by GenerateProcessor::generateProcessor().

Here is the call graph for this function:

◆ loadBinaryEncoding() [1/2]

void ProGe::ProGeUI::loadBinaryEncoding ( const BinaryEncoding & bem )

Definition at line 170 of file ProGeUI.cc.

                                                     {
    bem_ = new BinaryEncoding(bem.saveState());
}

References bem_, and BinaryEncoding::saveState().

Referenced by GenerateProcessor::generateProcessor(), and GenerateProcessorDialog::onOK().

Here is the call graph for this function:

◆ loadBinaryEncoding() [2/2]

void ProGe::ProGeUI::loadBinaryEncoding ( const std::string & bemFile )

protected

Loads the binary encoding from the given BEM file.

Parameters

bemFile The BEM file.

Exceptions

SerializerException	If the file cannot be read or is erroneous.
ObjectStateLoadingException	If the object model cannot be constructed.

Definition at line 143 of file ProGeUI.cc.

                                                    {
    BEMSerializer serializer;
    serializer.setSourceFile(bemFile);
    bem_ = serializer.readBinaryEncoding();
}

References bem_, BEMSerializer::readBinaryEncoding(), and XMLSerializer::setSourceFile().

Here is the call graph for this function:

◆ loadICDecoderGeneratorPlugin()

void ProGe::ProGeUI::loadICDecoderGeneratorPlugin	(	const std::string &	pluginFile,
		const std::string &	pluginName
	)

protected

Loads the given IC/decoder generator plugin.

Parameters

pluginFile	The file that implements the plugin.
pluginName	Name of the plugin.

Exceptions

FileNotFound	If the module is not found.
DynamicLibraryException	If the module cannot be opened.
InvalidData	If the machine or BEM is not loaded yet.

Definition at line 239 of file ProGeUI.cc.

                                                              {
    pluginFile_ = pluginFile;
 
    checkIfNull(machine_, "ADF not loaded");
    if (bem_ == NULL) {
        string errorMsg = "BEM not loaded";
        throw InvalidData(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    // initialize the plugin tool
    vector<string> pluginPaths = Environment::icDecoderPluginPaths();
    for (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&) {
        string errorMsg = "Plugin file '" + pluginFile + "' doesn't exist";
        throw FileNotFound(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    ICDecoderGeneratorPlugin* (*creator)(
        TTAMachine::Machine&, BinaryEncoding&);
    pluginTool_.importSymbol(
        "create_generator_plugin_" + pluginName, creator, pluginFile);
    plugin_ = creator(*machine_, *bem_);
    assert(plugin_ != NULL);
}

References __func__, PluginTools::addSearchPath(), assert, bem_, checkIfNull(), Environment::icDecoderPluginPaths(), PluginTools::importSymbol(), machine_, plugin_, pluginFile_, pluginTool_, and PluginTools::registerModule().

Referenced by generateProcessor().

Here is the call graph for this function:

◆ loadMachine() [1/2]

void ProGe::ProGeUI::loadMachine ( const std::string & adfFile )

protected

Loads machine from the given ADF file.

Parameters

adfFile The ADF file.

Exceptions

SerializerException	If the file cannot be read or is erroneous.
ObjectStateLoadingException	If the machine cannot be constructed.

Definition at line 128 of file ProGeUI.cc.

                                             {
    ADFSerializer serializer;
    serializer.setSourceFile(adfFile);
    machine_ = serializer.readMachine();
}

References machine_, ADFSerializer::readMachine(), and XMLSerializer::setSourceFile().

Here is the call graph for this function:

◆ loadMachine() [2/2]

void ProGe::ProGeUI::loadMachine ( const TTAMachine::Machine & adf )

Definition at line 165 of file ProGeUI.cc.

                                                 {
    machine_ = new TTAMachine::Machine(adf);
}

References machine_.

Referenced by GenerateProcessor::generateProcessor(), and GenerateProcessorDialog::onOK().

◆ loadMachineImplementation() [1/2]

void ProGe::ProGeUI::loadMachineImplementation ( const IDF::MachineImplementation & idf )

Definition at line 175 of file ProGeUI.cc.

                                                                      {
    idf_ = new IDF::MachineImplementation(idf.saveState());
}

References idf_, and IDF::MachineImplementation::saveState().

Referenced by GenerateProcessor::generateProcessor(), and GenerateProcessorDialog::onOK().

Here is the call graph for this function:

◆ loadMachineImplementation() [2/2]

void ProGe::ProGeUI::loadMachineImplementation ( const std::string & idfFile )

protected

Loads the machine implementation from the given IDF file.

Parameters

idfFile The IDF file.

Exceptions

SerializerException	If the file cannot be read or is erroneous.
ObjectStateLoadingException	If the object model cannot be constructed.

Definition at line 158 of file ProGeUI.cc.

                                                           {
    IDFSerializer serializer;
    serializer.setSourceFile(idfFile);
    idf_ = serializer.readMachineImplementation();
}

References idf_, IDF::IDFSerializer::readMachineImplementation(), and XMLSerializer::setSourceFile().

Here is the call graph for this function:

◆ loadProcessorConfiguration()

void ProGe::ProGeUI::loadProcessorConfiguration ( const std::string & configurationFile )

protected

Loads the given processor configuration.

Parameters

configurationFile The PCF file.

Exceptions

UnreachableStream	If the PCF file cannot be read.
SerializerException	If some files defined in PCF cannot be read or is erroneous.
ObjectStateLoadingException	If some of the object models cannot be constructed.

Definition at line 190 of file ProGeUI.cc.

                                                                      {
    std::ifstream fileStream(configurationFile.c_str());
    if (!fileStream.good()) {
        string errorMsg = "Unable to read the PCF from '" +
            configurationFile + "'.";
        throw UnreachableStream(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    ProcessorConfigurationFile pcf(fileStream);
    pcf.setPCFDirectory(FileSystem::directoryOfPath(configurationFile));
 
    // load machine
    try {
        string adfFile = pcf.architectureName();
        ADFSerializer serializer;
        serializer.setSourceFile(adfFile);
        machine_ = serializer.readMachine();
    } catch (const KeyNotFound&) {
    }
 
    // load BEM
    try {
        string bemFile = pcf.encodingMapName();
        BEMSerializer serializer;
        serializer.setSourceFile(bemFile);
        bem_ = serializer.readBinaryEncoding();
    } catch (const KeyNotFound&) {
    }
 
    // load IDF
    try {
        string idfFile = pcf.implementationName();
        IDFSerializer serializer;
        serializer.setSourceFile(idfFile);
        idf_ = serializer.readMachineImplementation();
    } catch (const KeyNotFound&) {
    }
}

References __func__, ProcessorConfigurationFile::architectureName(), bem_, FileSystem::directoryOfPath(), ProcessorConfigurationFile::encodingMapName(), idf_, ProcessorConfigurationFile::implementationName(), machine_, BEMSerializer::readBinaryEncoding(), ADFSerializer::readMachine(), IDF::IDFSerializer::readMachineImplementation(), ProcessorConfigurationFile::setPCFDirectory(), and XMLSerializer::setSourceFile().

Referenced by GenerateProcessor::generateProcessor().

Here is the call graph for this function:

◆ readImemParameters()

void ProGe::ProGeUI::readImemParameters ( MemInfo & imem ) const

private

Definition at line 514 of file ProGeUI.cc.

                                               {
    imem.mauWidth = bem_->width();
    // imem width in MAUs is fixed to 1 in ProGe
    imem.widthInMaus = 1;
    imem.asName = machine_->controlUnit()->addressSpace()->name();
    imem.portAddrw = machine_->controlUnit()->returnAddressPort()->width();
 
    int lastAddr = machine_->controlUnit()->addressSpace()->end();
    imem.asAddrw = MathTools::requiredBits(lastAddr);
    imem.isShared = machine_->controlUnit()->addressSpace()->isShared();
}

References TTAMachine::FunctionUnit::addressSpace(), MemInfo::asAddrw, MemInfo::asName, bem_, TTAMachine::Machine::controlUnit(), TTAMachine::AddressSpace::end(), MemInfo::isShared, TTAMachine::AddressSpace::isShared(), machine_, MemInfo::mauWidth, TTAMachine::Component::name(), MemInfo::portAddrw, MathTools::requiredBits(), TTAMachine::ControlUnit::returnAddressPort(), TTAMachine::BaseFUPort::width(), BinaryEncoding::width(), and MemInfo::widthInMaus.

Referenced by integrateProcessor().

Here is the call graph for this function:

◆ readLSUParameters()

void ProGe::ProGeUI::readLSUParameters ( MemInfo & dmem ) const

private

Member Data Documentation

◆ bem_

BinaryEncoding* ProGe::ProGeUI::bem_

private

The loaded binary encoding map.

Definition at line 120 of file ProGeUI.hh.

Referenced by generateProcessor(), loadBinaryEncoding(), loadBinaryEncoding(), loadICDecoderGeneratorPlugin(), loadProcessorConfiguration(), readImemParameters(), and ~ProGeUI().

◆ DEFAULT_ENTITY_STR

const std::string ProGe::ProGeUI::DEFAULT_ENTITY_STR = "tta0"

staticprivate

Definition at line 134 of file ProGeUI.hh.

◆ entityName_

std::string ProGe::ProGeUI::entityName_

private

Name of the toplevel entity.

Definition at line 130 of file ProGeUI.hh.

Referenced by generateProcessor(), generateScripts(), and generateTestBench().

◆ generator_

ProcessorGenerator ProGe::ProGeUI::generator_

private

Definition at line 132 of file ProGeUI.hh.

Referenced by generateProcessor(), generateTestBench(), and integrateProcessor().

◆ idf_

IDF::MachineImplementation* ProGe::ProGeUI::idf_

private

The loaded machine implementation.

Definition at line 122 of file ProGeUI.hh.

Referenced by generateIDF(), generateProcessor(), generateScripts(), generateTestBench(), integrateProcessor(), loadMachineImplementation(), loadMachineImplementation(), loadProcessorConfiguration(), and ~ProGeUI().

◆ machine_

TTAMachine::Machine* ProGe::ProGeUI::machine_

protected

The loaded machine.

Definition at line 107 of file ProGeUI.hh.

Referenced by generateIDF(), generateProcessor(), GenerateProcessor::generateProcessor(), generateTestBench(), integrateProcessor(), loadICDecoderGeneratorPlugin(), loadMachine(), loadMachine(), loadProcessorConfiguration(), readImemParameters(), and ~ProGeUI().

◆ plugin_

ICDecoderGeneratorPlugin* ProGe::ProGeUI::plugin_

private

The loaded IC/decoder generator plugin.

Definition at line 126 of file ProGeUI.hh.

Referenced by generateProcessor(), loadICDecoderGeneratorPlugin(), and ~ProGeUI().

◆ pluginFile_

std::string ProGe::ProGeUI::pluginFile_

private

The plugin file.

Definition at line 128 of file ProGeUI.hh.

Referenced by loadICDecoderGeneratorPlugin().

◆ pluginTool_

PluginTools ProGe::ProGeUI::pluginTool_

private

Tool for loading plugin.

Definition at line 124 of file ProGeUI.hh.

Referenced by loadICDecoderGeneratorPlugin().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~ProGeUI()

◆ ProGeUI()

Member Function Documentation

◆ checkIfNull()

◆ generateIDF()

◆ generateProcessor()

◆ generateScripts()

◆ generateTestBench()

◆ integrateProcessor()

◆ loadBinaryEncoding() [1/2]

◆ loadBinaryEncoding() [2/2]

◆ loadICDecoderGeneratorPlugin()

◆ loadMachine() [1/2]

◆ loadMachine() [2/2]

◆ loadMachineImplementation() [1/2]

◆ loadMachineImplementation() [2/2]

◆ loadProcessorConfiguration()

◆ readImemParameters()

◆ readLSUParameters()

Member Data Documentation

◆ bem_

◆ DEFAULT_ENTITY_STR

◆ entityName_

◆ generator_

◆ idf_

◆ machine_

◆ plugin_

◆ pluginFile_

◆ pluginTool_