LogicXdlGenerator.cpp File Reference

XDL generator for supported logic sites. Generates an XDL for each config and also an harness XDL for each BEL or as required. More...

#include "torc/packer/Virtex5PrimitiveStructure.hpp"
#include "torc/architecture/DDB.hpp"
#include <iostream>
#include <fstream>
#include <map>
#include "iomanip"
#include "torc/common/DirectoryTree.hpp"
#include "torc/Physical.hpp"
#include "SharedFunctions.hpp"

Include dependency graph for LogicXdlGenerator.cpp:

Go to the source code of this file.

Functions
void	InitializeElementReferenceConfigMap ()
std::string	GetReferenceConfigValueForElement (std::string elementName)
void	GenerateReferenceXDLForTheElement (const std::string &elementName, DesignSharedPtr harnessDesignPtr, const std::string &xdlFileName)
torc::physical::DesignSharedPtr	GetTestHarnessDesignForSiteType (std::string siteType, const boost::filesystem::path &harnessFolderPath)
int	FindPrimitiveElementByName (std::string elementName, PrimitiveStructureSharedPtr const primitiveStructurePtr)
void	SetConfigAndGenerateXDL (const std::string &elementName, const std::string &configVal, const std::string &xdlFileName, torc::physical::DesignSharedPtr designPtr)
DesignSharedPtr	GetEmptyDesignWithSameMetadata (torc::physical::DesignSharedPtr designPtr)
static void	GenerateXdlForCompoundSettings (const PrimitiveElement &element1, std::string siteType, PrimitiveStructureSharedPtr const primitiveStructurePtr, torc::physical::DesignSharedPtr designPtr)
void	GenerateXdlForDSPMaskAndPattern (const std::string &elementName, std::string siteType, torc::physical::DesignSharedPtr designPtr)
void	GenerateXdlForLUT (const PrimitiveElement &elem, const std::string &xdlFileNamePartial, torc::physical::DesignSharedPtr designPtr)
void	GenerateXdlForGenericElement (const PrimitiveElement &elem, const std::string &configVal, const std::string &xdlFileNamePartial, torc::physical::DesignSharedPtr designPtr)
void	GenerateXdlForOrphanElements (const PrimitiveElement &elem, const std::string &siteType, torc::physical::DesignSharedPtr designPtr)
void	GenerateXdlForElement (const PrimitiveElement &elem, PrimitiveStructureSharedPtr const primitiveStructurePtr, const std::string &siteType, DesignSharedPtr designPtr)
bool	LibrarySupportForSiteType (const std::string &siteType)
	Returns true if the library supports the site type. More...
bool	IsRAMBSite (const std::string &siteType)
bool	IsDSPSite (const std::string &siteType)
void	GenerateRAMBBaseFile (const std::string &primitiveDefName, torc::physical::DesignSharedPtr designPtr)
int	main (int argc, char **argv)
	Generates XDLs for various site types. An XDL is generated for each. More...

Variables
static const std::string	kXDLReferenceFolder = "reference"
static boost::filesystem::path	gXDLGenerationFolder
static boost::filesystem::path	gXDLReferenceGenerationFolder
static std::map< std::string, std::string >	gElementReferenceConfigMap

Detailed Description

XDL generator for supported logic sites. Generates an XDL for each config and also an harness XDL for each BEL or as required.

Definition in file LogicXdlGenerator.cpp.

Function Documentation

int FindPrimitiveElementByName	(	std::string	elementName,
		PrimitiveStructureSharedPtr const	primitiveStructurePtr
	)

Definition at line 129 of file LogicXdlGenerator.cpp.

                                                                                                               {

    int elementIndex = -1, index = 0;
    const PrimitiveElementArray& elementsArray = primitiveStructurePtr->getPrimitiveDefPtr()->getElements();
    PrimitiveElementArray::const_iterator pElements = elementsArray.begin();
    PrimitiveElementArray::const_iterator eElements = elementsArray.end();

    // For every primitive element (BEL) in the site
    while(pElements != eElements) {
        if(pElements->getName().compare(elementName) == 0) {
            elementIndex = index;
            break;
        }
        pElements++; index++;
    }
    return elementIndex;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void GenerateRAMBBaseFile	(	const std::string &	primitiveDefName,
		torc::physical::DesignSharedPtr	designPtr
	)

Definition at line 450 of file LogicXdlGenerator.cpp.

                                           {

    /* Generate XDL for designPtr in libraryPath */

    // Create XDL file name of the pattern <Architecture>-<SiteType>-<Element>-<Config>.xdl
    std::stringstream ssXDLFileName;
    ssXDLFileName << kArchitectureName << kNameSeparator << primitiveDefName << kNameSeparator
        << primitiveDefName << kNameSeparator << "BASE.xdl";
    boost::filesystem::path xdlFilePath = gXDLGenerationFolder / ssXDLFileName.str();
    std::fstream xdlExport(xdlFilePath.string().c_str(), std::ios::out);
    torc::physical::XdlExporter fileExporter(xdlExport);
    fileExporter(designPtr);
    xdlExport.close();

    /* Generate XDL for an empty design in tempFolderPath */

    // Get empty design
    DesignSharedPtr emptyDesign = GetEmptyDesignWithSameMetadata(designPtr);
    // Get empty design XDL path and open the file
    boost::filesystem::path emptyDesignPath = gXDLReferenceGenerationFolder / ssXDLFileName.str();
    std::fstream emptyDesignStream(emptyDesignPath.string().c_str(), std::ios::out);
    // Get XDL exporter and export the empty design
    torc::physical::XdlExporter emptyDesignExporter(emptyDesignStream);
    emptyDesignExporter(emptyDesign);
    emptyDesignStream.close();

    return;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void GenerateReferenceXDLForTheElement	(	const std::string &	elementName,
		DesignSharedPtr	harnessDesignPtr,
		const std::string &	xdlFileName
	)

Definition at line 69 of file LogicXdlGenerator.cpp.

                                  {
    // We know harness XDL design has only one instance
    InstanceSharedPtr instancePtr = *(harnessDesignPtr->instancesBegin());
    // If no instance found, just return
    if(!instancePtr) {
        std::cerr << "No instance found in the harness " << harnessDesignPtr->getName() << std::endl;
        return;
    }

    // Set config value to #OFF for the given element
    std::string configValue = GetReferenceConfigValueForElement(elementName);
    instancePtr->setConfig(elementName, "", configValue);

    /* Generate an reference XDL file for this element's custom harness */
    boost::filesystem::path referenceXDLFilePath = gXDLReferenceGenerationFolder / xdlFileName;

    std::ofstream fileStream(referenceXDLFilePath.string().c_str());
    if(!fileStream.good()) {
        std::cerr << "Could not open file " << referenceXDLFilePath.string() << std::endl;
        return;
    }

    // Export design as XDL
    torc::physical::XdlExporter exporter(fileStream);
    exporter(harnessDesignPtr);
    fileStream.close();

    std::cout << "\tGenerated reference XDL " << referenceXDLFilePath.string() << std::endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void GenerateXdlForCompoundSettings ( const PrimitiveElement &  element1, std::string  siteType, PrimitiveStructureSharedPtr const  primitiveStructurePtr, torc::physical::DesignSharedPtr  designPtr  )

static

Definition at line 175 of file LogicXdlGenerator.cpp.

                                                                                                    {

    std::vector<std::string> compoundElements = gCompoundSettingsMap[element1.getName()];
    // For now assume there is only on element in the vector, i.e. there is a compound
    // setting with only two elements.
    if(compoundElements.size() != 1) {
        std::cout << "Compound setting with more than two elements not handled currently"
            << std::endl;
    } else {

        // Generate XDLs with all permutations of configs of the two elements
        // The two element names will be concatenated to form a compound element name Element1Element2.
        // Similarly two config settings will be concatenated to form a compound config name.
        std::string element1Name = element1.getName();
        std::string element2Name = compoundElements[0];
        std::string compoundElementName = element1Name + element2Name;

        // Get the other element
        int elementIndex = FindPrimitiveElementByName(element2Name, primitiveStructurePtr);

        if(elementIndex == -1) {
            std::cout << "Primitive element " << element2Name << " not found" << std::endl;
            return;
        }

        const PrimitiveElement &element2 = primitiveStructurePtr->getPrimitiveDefPtr()->getElements()[elementIndex];

        // Get the first instance
        InstanceSharedPtr instancePtr = *(designPtr->instancesBegin());

        // Store the 2nd elements harness config
        std::string harnessConfig2Val, harnessConfig2Name;
        instancePtr->getConfig(element2Name, harnessConfig2Name, harnessConfig2Val);

        // Set element1 OFF and generate harness
        std::string referenceXdlFileName = siteType + kNameSeparator + compoundElementName + kXDLExtension;
        instancePtr->setConfig(element1Name, "", kConfigOff);
        GenerateReferenceXDLForTheElement(element2Name, designPtr, referenceXdlFileName);

        // Iterate over configs of 1st element
        const PrimitiveElement::StringSet &configs1 = element1.getCfgs();
        PrimitiveElement::StringSet::const_iterator pConfigs1 = configs1.begin();
        PrimitiveElement::StringSet::const_iterator eConfigs1 = configs1.end();

        while(pConfigs1 != eConfigs1) {

            // Iterate over configs of 2nd element.
            const PrimitiveElement::StringSet &configs2 = element2.getCfgs();
            PrimitiveElement::StringSet::const_iterator pConfigs2 = configs2.begin();
            PrimitiveElement::StringSet::const_iterator eConfigs2 = configs2.end();

            while(pConfigs2 != eConfigs2) {

                // Form the XDL file name
                std::string compoundConfigName = *pConfigs1 + *pConfigs2;
                std::string xdlFileName = siteType + kNameSeparator + compoundElementName
                    + kNameSeparator + compoundConfigName + kXDLExtension;

                // Set element1 config and generate primary XDL
                instancePtr->setConfig(element1Name, "", *pConfigs1);
                SetConfigAndGenerateXDL(element2Name, *pConfigs2, xdlFileName, designPtr);
                pConfigs2++;
            }

            pConfigs1++;
        }

        // Set original value of element2
        instancePtr->setConfig(element2Name, harnessConfig2Name, harnessConfig2Val);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void GenerateXdlForDSPMaskAndPattern	(	const std::string &	elementName,
		std::string	siteType,
		torc::physical::DesignSharedPtr	designPtr
	)

Definition at line 248 of file LogicXdlGenerator.cpp.

                                               {

    // We know for Virtex 5 DSP's mask and pattern have 12 hex characters as config value.
    long long configValNumber = 1;

    std::string siteTypeAndElement = siteType + kNameSeparator + elementName;

    std::stringstream xdlReferenceFileName;
    xdlReferenceFileName << siteTypeAndElement << kXDLExtension;
    GenerateReferenceXDLForTheElement(elementName, designPtr, xdlReferenceFileName.str());

    for(int bitPosition = 0; bitPosition < 48; bitPosition++) {
        std::stringstream ssConfigVal;
        ssConfigVal << std::setfill('0') << std::setw(12) << std::hex << configValNumber;

        std::stringstream xdlFileName;
        xdlFileName << siteTypeAndElement << kNameSeparator << bitPosition << kXDLExtension;

        SetConfigAndGenerateXDL(elementName, ssConfigVal.str(), xdlFileName.str(), designPtr);

        configValNumber = configValNumber << 1;

    }

    // Set the config to default again
    InstanceSharedPtr instancePtr = *(designPtr->instancesBegin());
    instancePtr->setConfig(elementName, "", GetReferenceConfigValueForElement(elementName));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void GenerateXdlForElement	(	const PrimitiveElement &	elem,
		PrimitiveStructureSharedPtr const	primitiveStructurePtr,
		const std::string &	siteType,
		DesignSharedPtr	designPtr
	)

Definition at line 385 of file LogicXdlGenerator.cpp.

                               {

    std::cout << "Found a " << elem.getName() << std::endl;

    std::string elementName = elem.getName();

    if(ElementNeedsCompoundSetting(elem.getName())) {
        GenerateXdlForCompoundSettings(elem, siteType, primitiveStructurePtr, designPtr);
    } else if(primitiveStructurePtr->isOrphan(elem) && elem.getName() != "SYNC_ATTR") {
        GenerateXdlForOrphanElements(elem, siteType, designPtr);
    } else {

        std::string siteTypeAndElem = siteType + kNameSeparator + elementName;

        const PrimitiveElement::StringSet &configs = elem.getCfgs();
        PrimitiveElement::StringSet::const_iterator pConfigs = configs.begin();
        PrimitiveElement::StringSet::const_iterator eConfigs = configs.end();

        // Iterate over configs of the primitive
        while(pConfigs != eConfigs) {

            if(primitiveStructurePtr->isLUT(elem, *pConfigs)) {
                GenerateXdlForLUT(elem, siteTypeAndElem, designPtr);
            } else {
                GenerateXdlForGenericElement(elem, *pConfigs, siteTypeAndElem, designPtr);
            }

            pConfigs++;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void GenerateXdlForGenericElement	(	const PrimitiveElement &	elem,
		const std::string &	configVal,
		const std::string &	xdlFileNamePartial,
		torc::physical::DesignSharedPtr	designPtr
	)

Definition at line 338 of file LogicXdlGenerator.cpp.

                                                                                {

    std::stringstream xdlFileName;
    xdlFileName << xdlFileNamePartial << kNameSeparator << configVal << ".xdl";

//  GenerateReferenceXDLForTheElement(elem.getName(), designPtr, xdlFileName.str());

    SetConfigAndGenerateXDL(elem.getName(), configVal, xdlFileName.str(), designPtr);

}

Here is the call graph for this function:

Here is the caller graph for this function:

void GenerateXdlForLUT	(	const PrimitiveElement &	elem,
		const std::string &	xdlFileNamePartial,
		torc::physical::DesignSharedPtr	designPtr
	)

Definition at line 278 of file LogicXdlGenerator.cpp.

                                           {

    std::string elementName = elem.getName();

    std::cout << "Found a LUT " << elementName << std::endl;

    DesignSharedPtr emptyDesign = GetEmptyDesignWithSameMetadata(designPtr);
    InstanceSharedPtr instancePtr = *(designPtr->instancesBegin());
    InstanceSharedPtr emptyInstance = Factory::newInstancePtr(instancePtr->getName(),
        instancePtr->getType(), instancePtr->getTile(), instancePtr->getSite(),
        instancePtr->getBonding());
    emptyDesign->addInstance(emptyInstance);

    const PrimitiveElementPinArray &pins = elem.getPins();
    PrimitiveElementPinArray::const_iterator pPins = pins.begin();
    PrimitiveElementPinArray::const_iterator ePins = pins.end();

    // Generate reference XDL for LUT
    std::string referenceXdlFileName = xdlFileNamePartial + kXDLExtension;
    GenerateReferenceXDLForTheElement(elementName, emptyDesign, referenceXdlFileName);

    //For every output-input pin combination
    while(pPins != ePins) {

        if(pPins->isOutput()) {

            PrimitiveElementPinArray::const_iterator pPinsIn = pins.begin();
            PrimitiveElementPinArray::const_iterator ePinsIn = pins.end();

            while(pPinsIn != ePinsIn) {
                if(pPinsIn->isInput()) {

                    std::string configVal = "#LUT:" + pPins->getName() + "=" + pPinsIn->getName();
                    std::stringstream xdlFileName;
                    xdlFileName << xdlFileNamePartial << kNameSeparator << configVal << ".xdl";
//                  GenerateReferenceXDLForTheElement(elementName, emptyDesign, xdlFileName.str());
                    SetConfigAndGenerateXDL(elementName, configVal, xdlFileName.str(), emptyDesign);
                }
                pPinsIn++;
            }

            // Generate XDLs for output 1 also
            std::string configVal = "#LUT:" + pPins->getName() + "=" + "1";
            std::stringstream xdlFileName1;
            xdlFileName1 << xdlFileNamePartial << kNameSeparator << configVal << ".xdl";
//          GenerateReferenceXDLForTheElement(elementName, emptyDesign, xdlFileName1.str());
            SetConfigAndGenerateXDL(elementName, configVal, xdlFileName1.str(), emptyDesign);

            configVal = "#LUT:" + pPins->getName() + "=" + "0";
            std::stringstream xdlFileName0;
            xdlFileName0 << xdlFileNamePartial << kNameSeparator << configVal << ".xdl";
//          GenerateReferenceXDLForTheElement(elementName, emptyDesign, xdlFileName0.str());
            SetConfigAndGenerateXDL(elementName, configVal, xdlFileName0.str(), emptyDesign);
        }
        pPins++;
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void GenerateXdlForOrphanElements	(	const PrimitiveElement &	elem,
		const std::string &	siteType,
		torc::physical::DesignSharedPtr	designPtr
	)

Definition at line 350 of file LogicXdlGenerator.cpp.

                                                                      {

    std::cout << "  Found a Orphan element " << elem.getName() << std::endl;

    std::string elementName = elem.getName();
    std::string siteTypeAndElem = siteType + kNameSeparator + elementName;

    // Get and empty design with same metadata
    DesignSharedPtr emptyDesign = GetEmptyDesignWithSameMetadata(designPtr);

    // Add an empty instance of same site type and location
    InstanceSharedPtr instancePtr = *(designPtr->instancesBegin());

    InstanceSharedPtr emptyInstance = Factory::newInstancePtr(instancePtr->getName(),
        instancePtr->getType(), instancePtr->getTile(), instancePtr->getSite(),
        instancePtr->getBonding());

    emptyDesign->addInstance(emptyInstance);

    std::string referenceXdlFileName = siteTypeAndElem + kXDLExtension;
    GenerateReferenceXDLForTheElement(elementName, emptyDesign, referenceXdlFileName);

    // Go over all the configs
    const PrimitiveElement::StringSet &configs = elem.getCfgs();
    PrimitiveElement::StringSet::const_iterator pConfigs = configs.begin();
    PrimitiveElement::StringSet::const_iterator eConfigs = configs.end();

    // Iterate over configs of the primitive
    while(pConfigs != eConfigs) {
            GenerateXdlForGenericElement(elem, *pConfigs, siteTypeAndElem, emptyDesign);
        pConfigs++;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

DesignSharedPtr GetEmptyDesignWithSameMetadata

(

torc::physical::DesignSharedPtr

designPtr

)

Definition at line 165 of file LogicXdlGenerator.cpp.

                                                                                      {
    DesignSharedPtr emptyDesign = Factory::newDesignPtr(designPtr->getName(),
        designPtr->getDevice(), designPtr->getPackage(), designPtr->getSpeedGrade(),
        designPtr->getXdlVersion());

    return emptyDesign;
}

Here is the caller graph for this function:

std::string GetReferenceConfigValueForElement

(

std::string

elementName

)

Definition at line 54 of file LogicXdlGenerator.cpp.

                                                                   {
    std::string configValue;
    // if element present in the map of Element->ReferenceConfig, return it.
    std::map<std::string, std::string>::const_iterator pElementConfigMap;
    std::map<std::string, std::string>::const_iterator eElementConfigMap =
        gElementReferenceConfigMap.end();
    pElementConfigMap = gElementReferenceConfigMap.find(elementName);
    if(pElementConfigMap != eElementConfigMap) {
        return pElementConfigMap->second;
    }

    return kConfigOff;
}

Here is the caller graph for this function:

torc::physical::DesignSharedPtr GetTestHarnessDesignForSiteType	(	std::string	siteType,
		const boost::filesystem::path &	harnessFolderPath
	)

Definition at line 101 of file LogicXdlGenerator.cpp.

                                                  {

    boost::filesystem::path harnessFilePath(harnessFolderPath);

    torc::physical::DesignSharedPtr harnessDesignPtr;
    std::stringstream ssHarnessFileName;
    //  ssHarnessFileName << "Virtex5_" << siteType << ".xdl";
    ssHarnessFileName << kArchitectureName << kNameSeparator << siteType << ".xdl";

    harnessFilePath = harnessFilePath / ssHarnessFileName.str();

    std::ifstream fileStream(harnessFilePath.string().c_str());
    if(!fileStream.good()) {
        std::cerr << "Could not open file " << harnessFilePath.string() << std::endl;
        return harnessDesignPtr;
    }
    torc::physical::XdlImporter importer;
    importer(fileStream, ssHarnessFileName.str());

    fileStream.close();

    // Return the design pointer
    harnessDesignPtr = importer.getDesignPtr();
    return harnessDesignPtr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void InitializeElementReferenceConfigMap

(

)

Definition at line 44 of file LogicXdlGenerator.cpp.

                                           {

    gElementReferenceConfigMap["LFSR_EN_SET"] = "SET";
    gElementReferenceConfigMap["TEST_SET_P"] = "SET";
    gElementReferenceConfigMap["MASK"] = "000000000000";
    gElementReferenceConfigMap["PATTERN"] = "000000000000";
}

Here is the caller graph for this function:

bool IsDSPSite

(

const std::string &

siteType

)

Definition at line 442 of file LogicXdlGenerator.cpp.

                                          {
    if(siteType.length() > 3) {
        return siteType.substr(0, 3).compare("DSP") == 0;
    }
    return false;
}

Here is the caller graph for this function:

bool IsRAMBSite

(

const std::string &

siteType

)

Definition at line 434 of file LogicXdlGenerator.cpp.

                                           {
    if(siteType.length() > 3) {
        return siteType.substr(0, 4).compare("RAMB") == 0;
    }
    return false;
}

Here is the caller graph for this function:

bool LibrarySupportForSiteType

(

const std::string &

siteType

)

Returns true if the library supports the site type.

Definition at line 420 of file LogicXdlGenerator.cpp.

                                                          {
    std::cout << "Site type: " << siteType << std::endl;
    return (    siteType.compare("SLICEM") == 0 ||
            siteType.compare("SLICEL") == 0 ||
            siteType.compare("RAMB36_EXP") == 0 ||
            siteType.compare("DSP48E") == 0 ||
            siteType.compare("BUFGCTRL") == 0 ||
            siteType.compare("BUFDS") == 0 ||
            siteType.compare("BUFR") == 0 ||
            siteType.compare("BUFG") == 0);
    //  return 1; //Generate library files for all types just for information.
}

Here is the caller graph for this function:

int main	(	int	argc,
		char **	argv
	)

Generates XDLs for various site types. An XDL is generated for each.

Definition at line 485 of file LogicXdlGenerator.cpp.

                                {

    if(argc != 3) {
        std::cerr << "Invalid arguments. Usage: " << argv[0] <<
            " <harness_folder> <xdl_generation_folder>" << std::endl;
        exit (-1);
    }
    // get the part number
    std::string partNumber = "xc5vfx130t";
    // Initialize the DirectoryTree class
    torc::common::DirectoryTree directoryTree(argv[0]);

    // Check if Harness folder path exists.
    boost::filesystem::path harnessFolderPath = argv[1];
    if(!boost::filesystem::exists(harnessFolderPath)) {
        std::cout << "Folder " << harnessFolderPath.string() << " does not exist" << std::endl;
        exit (-1);
    }

    // Create the xdl generation folder if it doesn't exits
    gXDLGenerationFolder = argv[2];
    if(!boost::filesystem::exists(gXDLGenerationFolder))
        boost::filesystem::create_directory(gXDLGenerationFolder);
    gXDLReferenceGenerationFolder = gXDLGenerationFolder / kXDLReferenceFolder;
    if(!boost::filesystem::exists(gXDLReferenceGenerationFolder))
        boost::filesystem::create_directory(gXDLReferenceGenerationFolder);

    // Initialize the map of element to reference config map
    InitializeElementReferenceConfigMap();
    InitializeCompoundSettingsMap();

    // open and initialize a database
    DDB ddb(partNumber);
    // look up the logic sites in the device
    const Sites& sites = ddb.getSites();
    // define a vector of PrimitiveStructure objects
    typedef std::map<std::string, PrimitiveStructureSharedPtr> PrimitiveStructuresSharedPtrMap;
    PrimitiveStructuresSharedPtrMap primitiveStructures;
    // look up the primitive def types
    typedef const Array<const PrimitiveDef> PrimitiveDefArray;
    PrimitiveDefArray& primitiveDefs = sites.getSiteTypes();
    PrimitiveDefArray::const_iterator p = primitiveDefs.begin();
    PrimitiveDefArray::const_iterator e = primitiveDefs.end();
    // Store the corresponding primitive structures in a map.
    while(p < e) {
        // create a PrimitiveStructure object for this PrimitiveDef
        PrimitiveStructureSharedPtr primitiveStructurePtr(new Virtex5PrimitiveStructure(&*p++));
        const torc::architecture::PrimitiveDef* primitiveDefPtr =
            primitiveStructurePtr->getPrimitiveDefPtr();
        const std::string& primitiveDefName = primitiveDefPtr->getName();
        // insert the PrimitiveStructure into the map
        primitiveStructures[primitiveDefName] = primitiveStructurePtr;
    }

    // iterate through the PrimitiveStructure entries in the map
    PrimitiveStructuresSharedPtrMap::iterator psp = primitiveStructures.begin();
    PrimitiveStructuresSharedPtrMap::iterator pse = primitiveStructures.end();

    // For every site type
    while(psp != pse) {

        // look up the PrimitiveDef name and the PrimitiveStructureSharedPtr
        std::string primitiveDefName = psp->first;
        PrimitiveStructureSharedPtr primitiveStructurePtr = psp->second;

        psp++;
        // If the site type is to be supported
        if(LibrarySupportForSiteType(primitiveDefName)) {

            // Get the designPtr for test harness for this site type
            torc::physical::DesignSharedPtr designPtr = GetTestHarnessDesignForSiteType(
                primitiveDefName, harnessFolderPath);

            if(!designPtr) {
                std::cout << "No test harness for site type " << primitiveDefName << std::endl;
                continue;
            }

            std::cout << "Working on site type " << primitiveDefName << std::endl;

            // Create the XDL file name (partial)
            std::stringstream ssXdlFileName;
            ssXdlFileName << kArchitectureName << kNameSeparator << primitiveDefName;

            if(IsRAMBSite(primitiveDefName)) {
                GenerateRAMBBaseFile(primitiveDefName, designPtr);
            }

            if(IsDSPSite(primitiveDefName)) {
                GenerateXdlForDSPMaskAndPattern("MASK", ssXdlFileName.str(), designPtr);
                GenerateXdlForDSPMaskAndPattern("PATTERN", ssXdlFileName.str(), designPtr);
            }

            // We know the design has only one instance. So, get the first one in the iterator.
            torc::physical::InstanceSharedPtr instancePtr = *(designPtr->instancesBegin());

            const torc::architecture::PrimitiveDef* primitiveDefPtr =
                primitiveStructurePtr->getPrimitiveDefPtr();

            const PrimitiveElementArray& elements = primitiveDefPtr->getElements();

            PrimitiveElementArray::const_iterator pElements = elements.begin();
            PrimitiveElementArray::const_iterator eElements = elements.end();

            // For every primitive element (BEL) in the site
            while(pElements != eElements) {
                const PrimitiveElement &elem = *pElements;
                // Ignore the route through elements
                if(!primitiveStructurePtr->isRoutethrough(elem)) {

                    // Cache the current setting of the element
                    std::string harnessConfigName;
                    std::string harnessConfigVal;
                    instancePtr->getConfig(elem.getName(), harnessConfigName, harnessConfigVal);


                    // Generate XDLs only if the element has a config to be set.
                    if(elem.getCfgs().size() > 0) {
                        // First generate a generic reference XDL for all configs of the element, so that the special elements have option of over writing this harness
                        std::stringstream ssReferenceXdlFileName;
                        ssReferenceXdlFileName << ssXdlFileName.str() << kNameSeparator << elem.getName() << kXDLExtension;
                        GenerateReferenceXDLForTheElement(elem.getName(), designPtr, ssReferenceXdlFileName.str());

                        // Generate XDL for each config of the element.
                        GenerateXdlForElement(elem, primitiveStructurePtr, ssXdlFileName.str(),
                                                designPtr);
                    }

                    // Store back the previous setting of the element
                    instancePtr->setConfig(elem.getName(), harnessConfigName, harnessConfigVal);
                }

                pElements++;
            }
        }
    }
    return 0;
}

Here is the call graph for this function:

void SetConfigAndGenerateXDL	(	const std::string &	elementName,
		const std::string &	configVal,
		const std::string &	xdlFileName,
		torc::physical::DesignSharedPtr	designPtr
	)

Definition at line 148 of file LogicXdlGenerator.cpp.

                                                                          {

    torc::physical::InstanceSharedPtr instancePtr = *(designPtr->instancesBegin());

    instancePtr->setConfig(elementName, "", configVal);
    // create the appropriate file paths
    boost::filesystem::path xdlFilePath = gXDLGenerationFolder / xdlFileName.c_str();

    // Export the design as XDL
    std::fstream xdlExport(xdlFilePath.string().c_str(), std::ios_base::out);
    torc::physical::XdlExporter fileExporter(xdlExport);
    fileExporter(designPtr);
    std::cout << "\tGenerated XDL file " << xdlFileName << std::endl;
}

Here is the caller graph for this function:

Variable Documentation

std::map<std::string, std::string> gElementReferenceConfigMap

static

Definition at line 40 of file LogicXdlGenerator.cpp.

boost::filesystem::path gXDLGenerationFolder

static

Definition at line 38 of file LogicXdlGenerator.cpp.

boost::filesystem::path gXDLReferenceGenerationFolder

static

Definition at line 39 of file LogicXdlGenerator.cpp.

const std::string kXDLReferenceFolder = "reference"

static

Definition at line 35 of file LogicXdlGenerator.cpp.