torc::bitstream::Assembler Class Reference

Base class for bitstream assembly. More...

#include <Assembler.hpp>

Inheritance diagram for torc::bitstream::Assembler:

Collaboration diagram for torc::bitstream::Assembler:

Public Types
enum	EOperation { eAND, eOR, eXOR, eNOT }
	Permissible operations on LUT frames. More...
enum	EMergeMode { eSet, eClear }
typedef std::string	string
	Imported type name. More...
typedef std::istream	istream
	Imported type name. More...
typedef torc::physical::DesignSharedPtr	DesignSharedPtr
	Imported type name. More...
typedef torc::physical::InstanceSharedPtr	InstanceSharedPtr
	Imported type name. More...
typedef torc::architecture::DDB	DDB
	Imported type name. More...
typedef boost::filesystem::path	path
	Imported type name. More...
typedef std::map< const string, std::vector< string > >	CompoundSettingMap
	Element name to vector of related element names that collectively affect bits. More...
typedef std::map< const string, std::vector< uint32_t > >	ConfigValuesToBits
	Map from config value to vector of config bits. ConfigValuesToBits. More...
typedef std::map< const string, ConfigValuesToBits >	ConfigSettingsToValues
	Map from config setting to config values. ConfigSettingsToValues. More...
typedef std::map< const string, ConfigSettingsToValues >	SiteTypeToConfigSettings
	Map from site type to config settings. SiteTypeToConfigSettings. More...
typedef std::map< const string, SiteTypeToConfigSettings >	TileTypeToSiteType
	Map from tile type to site types. Includes routing as a site type. More...
typedef std::map< int32_t, map < int32_t, uint32_t > >	FrameWords
	Currently not in use. Datastructure to store LUT frames in efficient and flexible way. More...

Public Member Functions
	Assembler (DDB &inDB)
	Constructor take only Xdl design pointer. More...
virtual	~Assembler (void)
	Destructor does not do anything. More...
virtual int	generateBitstream (DesignSharedPtr inDesignPtr, const path inTargetBitstreamPath, EMergeMode inMergeMode=eSet, path baseBitstreamPath=path())
	Function to generate bitstream, takes target bitstream path and optional base bitstream path. More...
bool	processLut (const string &input, const string &name="string stream")
	Import Lut expression from a string. More...
void	error (const location &l, const string &m)
	Lut parse error handling. More...
void	error (const string &m)
	Lut general error handling. More...
void	failure (void)
	Signals a parsing failure by deasserting the success flag. More...
void	binaryLutFrameOperation (EOperation inOperation)
	Function called from parser when it encounters a bit operator. More...
void	pushLutFrame (string inLiteral)
	Function called from parser when it encounters a literal. More...

Static Public Member Functions
static int	hexCharacterToDec (char inDigit)
	Convert a hex ASCII character to a decimal value. More...

Data Fields
bool	mTraceScanning
	Enable debug output in the flex scanner. More...
bool	mTraceParsing
	Enable debug output in the bison parser. More...
string	mStreamName
	Name of file or input stream for error messages. More...
class torc::LutScanner *	lexer
	Pointer to the current lexer instance. More...

Protected Member Functions
void	initialize (void)
	Initializations done in constructor. More...
void	convertXdlToBitstream (void)
	Initiates Xdl to bitstream conversion. More...
void	saveBitstream (void)
	Save bitstream. More...
void	assembleInstances (void)
	Assemble bitstream for instances. More...
void	assembleNets (void)
	Assemble bitstream for nets. More...
void	assembleRamb (torc::physical::InstanceSharedPtr inInstancePtr)
	Assemble bitstream for Ramb. More...
string	getTiletypeFromSitename (const string &inSiteType)
	Get tile type from site type. More...
virtual void	checkValidityAndMergeBitstream (string inElementName, string inConfigValue, const ConfigSettingsToValues &inConfigMap)
	Verify the configuratino and merge with base bitstream. More...
virtual bool	isLutEquationSetting (const string &inConfigValue)
	Is config value a LUT equation. More...
virtual bool	isRoutethrough (const string &inSetting)
	Is config a _ROUTETHROUGH. More...
virtual bool	isLutRamOrRomSetting (const string &inConfigVal)
	Is config value a LUT ram setting. More...
virtual bool	isRambSite (const string &inSiteType)
	Returns true if the site is some form of RAMB site. More...
virtual bool	isConfigValHexString (const string &inSiteType, const string &inElementName)
	Does the configuration have hex string in config value. More...
bool	isMemoryInitSetting (const string &inConfigName)
	Is ramb memory init setting. More...
bool	isMemoryParityInitSetting (const string &inConfigName)
	Is ramb parity init setting. More...
bool	tileAndSiteExistInLibrary (const string &inTileType, const string &inSiteType)
	Is site present in library database ToDo: This function will need tile type also. More...
bool	elementAndConfigExistInLibrary (const string &inElementName, const string &configValue, ConfigSettingsToValues &inConfigSettingToValues)
	Is configuration present in given map. More...
virtual void	getAnnotatedSiteTypeForSlicel (string &inOutSiteType, const string &siteLocation)
	If slice site type, annotate type as per even or odd column. More...
void	mergeLutEquationBits (const string &inElementName, const string &inConfigValue, ConfigSettingsToValues &inConfigSettingToValues)
	Merge micro-bitstream for Lut equation. More...
void	mergeLutRamOrRomBits (const string &inElementName, const string &inConfigVal, ConfigSettingsToValues &inConfigSettingToValues)
	Merge micro-bitsram for Lut in ram/rom mode. More...
void	mergeCompoundSettingBits (string inElement1Name, string inConfig1Val, InstanceSharedPtr inInstancePtr, const ConfigSettingsToValues &inConfigSettingToValues)
	Merge micro-bitstream for compound setting. More...
void	mergeHexConfigBits (string inElementName, string inConfigVal, const ConfigSettingsToValues &inConfigSettingToValues)
	Merge micro-bitstream for configuration with Hex values. More...
void	mergeRambInitBits (const string &inConfigVal, uint32_t inMemoryInitRow, const vector< uint32_t > &inBitAddresses, uint32_t inBlock)
	Merge micro-bitstreams for ramb memory init values. More...
void	populateLibraryMap (path inLibDBPath)
	Read micro-bitstream library file and populate it in a map. More...
bool	isBigEndianMachine ()
	Check if processor is big endian. More...
void	readWord (std::ifstream &fileStream, uint32_t &outWord)
	Read word from stream and convert endianness if required. More...
uint32_t	reverseEndianness (uint32_t inWord)
	Reverse endianness of input word. More...
virtual bool	isSiteTypeSupported (const string &inSiteType)=0
	Is site supporeted for Xdl to bitstream conversion. More...
virtual void	initializeFrameDataForSite (const string &inSiteName)=0
	Store frame blocks and bit offset for given site. More...
virtual void	initializeFrameDataForTile (TileIndex inTileIndex)=0
	Store frame blocks and bit offset for given tile index. More...
virtual vector< string >	getDependantConfigs (string inElement1Name)=0
	Returs vector of related configurations. More...
virtual bool	isCompoundSetting (string inElementName)=0
	Does element need compound setting. More...
virtual void	mergeWithBaseBitstream (const vector< uint32_t > &inBitAddresses, uint32_t inBlockIndex)=0
	Merge micro-bitstream with base bitstream. More...

Protected Attributes
torc::physical::DesignSharedPtr	mDesignPtr
	Xdl design pointer. More...
path	mTargetBitstreamPath
	Target bitstream path. More...
EMergeMode	mMergeMode
	Merge mode - set bits or clear bits. More...
TileTypeToSiteType	mLibrary
	Micro-bitstream library in map datastructure. More...
const torc::architecture::DDB &	mDB
	Torc database of architecutre on which design is implemented. More...
const torc::architecture::Sites &	mSites
	Sites from the architecture database. More...
const torc::architecture::Tiles &	mTiles
	Tiles from architecture database. More...
bool	mFreeDB
	To track if DB object was allocated in constructor. More...
torc::bitstream::BitstreamSharedPtr	mBitstreamPtr
boost::filesystem::path	mLibraryPath
	Pointer to bitstream object to which micro bitstreams are merged. More...
string	mParentFamilyName
bool	mSuccess
	Flag signaling parsing success. More...
bool	mBigEndian
vector< vector< uint32_t > >	mLutFrameSetStack
	Frame set for literals are pushed to this stack. More...
uint32_t	mLutCurrentReferenceFrameIndex
	Address of 1st frame being affected by Lut equation. More...
uint32_t	mCurrentReferenceWordIndex
	Address of 1st work within frame affected by Lut equation. More...
std::vector< uint32_t >	mLutFrameSetForOne
	Frame set for Lut output assigned to 1. More...
ConfigValuesToBits	mCurrentConfigToBitMap
	Map from Lut config value to micro-bitstreams. More...
string	mLutCurrentEquationLhs
	LHS of Lut equation currently being processed. More...
int	mUnsupportedTileTypeCount
int	mUnsupportedTileCount
int	mUnsupportedPipCount
int	mUnsupportedInstCount
int	mMissingConfigs
std::set< std::string >	mUnsupportedTileTypeSet

Static Protected Attributes
static const string	sLibraryRelativePath = "torc/bitstream/assembler/libraries"
	Path to library folder containing mirco-bitstream database. More...
static const string	sLibraryExtension = ".ldb"
	Extension used for micro-bitstream libraries. More...
static const string	sConfigOff = "#OFF"
	String used when an element is explicity configured off. More...
static const boost::regex	sLutRamOrRomConfigRegEx
	Regex to identify Luts configured as ram/rom. More...
static const boost::regex	sLutConfigRegEx
	Regex to identify Lut configuration. More...
static const boost::regex	sRoutethroughRegEx
	Regex to indentify ROUTETHROUGH configuration in instances. More...

Friends
class	torc::LutParser
	The LutParse has access to our members. More...

Detailed Description

Base class for bitstream assembly.

Definition at line 46 of file Assembler.hpp.

Member Typedef Documentation

typedef std::map<const string, std::vector<string> > torc::bitstream::Assembler::CompoundSettingMap

Element name to vector of related element names that collectively affect bits.

Definition at line 71 of file Assembler.hpp.

typedef std::map<const string, ConfigValuesToBits> torc::bitstream::Assembler::ConfigSettingsToValues

Map from config setting to config values. ConfigSettingsToValues.

Definition at line 75 of file Assembler.hpp.

typedef std::map<const string, std::vector<uint32_t> > torc::bitstream::Assembler::ConfigValuesToBits

Map from config value to vector of config bits. ConfigValuesToBits.

Definition at line 73 of file Assembler.hpp.

typedef torc::architecture::DDB torc::bitstream::Assembler::DDB

Imported type name.

Definition at line 65 of file Assembler.hpp.

typedef torc::physical::DesignSharedPtr torc::bitstream::Assembler::DesignSharedPtr

Imported type name.

Definition at line 61 of file Assembler.hpp.

typedef std::map<int32_t, map<int32_t, uint32_t> > torc::bitstream::Assembler::FrameWords

Currently not in use. Datastructure to store LUT frames in efficient and flexible way.

Definition at line 81 of file Assembler.hpp.

typedef torc::physical::InstanceSharedPtr torc::bitstream::Assembler::InstanceSharedPtr

Imported type name.

Definition at line 63 of file Assembler.hpp.

typedef std::istream torc::bitstream::Assembler::istream

Imported type name.

Definition at line 59 of file Assembler.hpp.

typedef boost::filesystem::path torc::bitstream::Assembler::path

Imported type name.

Definition at line 67 of file Assembler.hpp.

typedef std::map<const string, ConfigSettingsToValues> torc::bitstream::Assembler::SiteTypeToConfigSettings

Map from site type to config settings. SiteTypeToConfigSettings.

Definition at line 77 of file Assembler.hpp.

typedef std::string torc::bitstream::Assembler::string

Imported type name.

Definition at line 57 of file Assembler.hpp.

typedef std::map<const string, SiteTypeToConfigSettings> torc::bitstream::Assembler::TileTypeToSiteType

Map from tile type to site types. Includes routing as a site type.

Definition at line 79 of file Assembler.hpp.

Member Enumeration Documentation

enum torc::bitstream::Assembler::EMergeMode

Enumerator
eSet
eClear

Definition at line 53 of file Assembler.hpp.

{ eSet, eClear }; 

enum torc::bitstream::Assembler::EOperation

Permissible operations on LUT frames.

Enumerator
eAND
eOR
eXOR
eNOT

Definition at line 51 of file Assembler.hpp.

{ eAND, eOR, eXOR, eNOT };

Constructor & Destructor Documentation

torc::bitstream::Assembler::Assembler ( DDB &  inDB )

inline

Constructor take only Xdl design pointer.

Constructor takes Xdl design pointer and architecture database object

Definition at line 90 of file Assembler.hpp.

                         : mTraceScanning(false),
        mTraceParsing(false), mDB(inDB), mSites(mDB.getSites()),
        mTiles(mDB.getTiles()), mFreeDB(false) {
        initialize();
    }

Here is the call graph for this function:

virtual torc::bitstream::Assembler::~Assembler ( void  )

inlinevirtual

Destructor does not do anything.

Definition at line 96 of file Assembler.hpp.

                             { 
        if(mFreeDB) 
            delete &mDB;
    } 

Member Function Documentation

void torc::bitstream::Assembler::assembleInstances ( void  )

protected

Assemble bitstream for instances.

Function to assemble micro-bitstreams for instances of Xdl design. This function iterates over instances, stores frame blocks and bit offset within for site location, and then iterates over config settings of the instance. Ramb instances are handled in separate function. Special cases for configurations are - lut equations, lut in ram/rom mode, compound configuration, and configuration with hex values.

Definition at line 123 of file Assembler.cpp.

                                  {

    std::cout << "Assembling micro-bitstream for instances... count: " << mDesignPtr->getInstanceCount() <<
        std::endl;
    // Get instances begin and end
    InstanceSharedPtrVector::const_iterator pInstance = mDesignPtr->instancesBegin();
    InstanceSharedPtrVector::const_iterator eInstance = mDesignPtr->instancesEnd();

    // Iterate over all the instances
    while(pInstance != eInstance) {

        InstanceSharedPtr instancePtr = *pInstance++;
        string siteType = instancePtr->getType();
        // Check if instance is placed on supported site type
        //if(isSiteTypeSupported(siteType) ) {

            const string &siteName = instancePtr->getSite();
            if(siteName.empty()) {
                std::cout << "   WARNING: Unplaced instance " << instancePtr->getName() << endl;
                continue;
            }
            const string &tileType = getTiletypeFromSitename(siteName);
            std::cout << "  Processing instance " << instancePtr->getName() << " placed on site "
                << siteName << " in tile " << tileType << " with " << instancePtr->getConfigCount() << " configs set."
                << std::endl;

            getAnnotatedSiteTypeForSlicel(siteType, siteName);
            if(!tileAndSiteExistInLibrary(tileType, siteType))
                continue;
            // Store frame blocks and bit offset for current site location
            initializeFrameDataForSite(siteName);

            // RAMB sites are handled in a slightly different manner
            if(isRambSite(siteType)) {
                assembleRamb(instancePtr);
            } else {
                
                // Get the element to config map for the given site type
                SiteTypeToConfigSettings sitetypeToConfigSettings = mLibrary[tileType];
                ConfigSettingsToValues configSettingToValuesMap = sitetypeToConfigSettings[siteType];

                // Go over all the configurations of the instance
                ConfigMap::const_iterator pConfig = instancePtr->configBegin();
                ConfigMap::const_iterator eConfig = instancePtr->configEnd();

                while(pConfig != eConfig) {

                    // Ignore routethrough config setting as they don't set bits in bitstream
                    if(isRoutethrough(pConfig->first)) {
                        pConfig++;
                        continue;
                    }

                    // std::cout << "\tWorking on config " << pConfig->first << "::"
                    //  << pConfig->second.getValue() << std::endl;
                    // Lut equation has to be handled differently from other config setting.
                    // The boolean operation in the LUT equation have to be performed on the relevant bits.
                    if(isLutEquationSetting(pConfig->second.getValue())) {
                        mergeLutEquationBits(pConfig->first, pConfig->second.getValue(), configSettingToValuesMap);
                    } // LUT ROM and RAM settings also need special care
                    else if(isLutRamOrRomSetting(pConfig->second.getValue())) {
                        mergeLutRamOrRomBits(pConfig->first, pConfig->second.getValue(), configSettingToValuesMap);
                    } // Some elements together effect the bitstream.
                    else if(isCompoundSetting(pConfig->first)) {
                        mergeCompoundSettingBits(pConfig->first, pConfig->second.getValue(),
                            instancePtr, configSettingToValuesMap);
                    } // The DSP MASK and PATTERN have hex values
                    else if(isConfigValHexString(instancePtr->getType(), pConfig->first)) {
                        mergeHexConfigBits(pConfig->first, pConfig->second.getValue(), configSettingToValuesMap);
                    } else {
                        // Merge compressed bitstream to main bitstream if valid setting
                        checkValidityAndMergeBitstream(pConfig->first, pConfig->second.getValue(),
                            configSettingToValuesMap);
                    }
                    //std::cout << "\t------------------" << std::endl;
                    pConfig++;
                }
            }
    //  } else {
    //      std::cout << "WARNING: Site " << instancePtr->getType() << " not supported."
    //          << std::endl;
    //  }
    }

}

Here is the call graph for this function:

void torc::bitstream::Assembler::assembleNets ( void  )

protected

Assemble bitstream for nets.

Function to assemble micro-bitstreams for net of Xdl design.

Definition at line 210 of file Assembler.cpp.

                             {
    // Get the iterators to nets
    NetSharedPtrVector::const_iterator pNets = mDesignPtr->netsBegin();
    NetSharedPtrVector::const_iterator eNets = mDesignPtr->netsEnd();

    std::cout << "Assembling micro-bitstreams for Nets... count: " << mDesignPtr->getNetCount()
        << std::endl;
    // Iterate over nets
    while(pNets != eNets) {

        NetSharedPtr netPtr = *pNets;
        // std::cout << "  Processing net: " << netPtr->getName() << std::endl;

        // Iterate over pips in the net
        Net::PipConstIterator pPips = netPtr->pipsBegin();
        Net::PipConstIterator ePips = netPtr->pipsEnd();
        while(pPips != ePips) {
            Pip pip = *pPips++;
            // Store frame blocks and bit offset for this tile
            TileIndex tileIndex = mTiles.findTileIndex(pip.getTileName());
            initializeFrameDataForTile(tileIndex);

            const TileInfo& tileInfo = mTiles.getTileInfo(tileIndex);
            string tileType = mTiles.getTileTypeName(tileInfo.getTypeIndex());
            if(!tileAndSiteExistInLibrary(tileType, "routing")) {
                mUnsupportedPipCount++;
                continue;
            }
            ConfigSettingsToValues configSettingToValuesMap = mLibrary[tileType]["routing"];
            // std::cout << "\tTile " << tileInfo.getName() << " Src: " << pip.getSourceWireName()
            //  << " Sink: " << pip.getSinkWireName() << std::endl;
            checkValidityAndMergeBitstream(pip.getSourceWireName(), pip.getSinkWireName(),
                configSettingToValuesMap);

        }

        pNets++;
    }

}

Here is the call graph for this function:

void torc::bitstream::Assembler::assembleRamb ( torc::physical::InstanceSharedPtr  inInstancePtr )

protected

Assemble bitstream for Ramb.

Assemble micro-bitstream for ramb site. First the base micro-bitstream is merged. Micro-bitstream info for memory and parity init values are gathered from ll files.

Definition at line 260 of file Assembler.cpp.

                                                            {
    // Get the element to config map for the given site type
    const string &tileType = getTiletypeFromSitename(inInstancePtr->getSite());
    ConfigSettingsToValues configSettingToValuesMap = mLibrary[tileType][inInstancePtr->getType()];

    // Open the RAMBIT memory file and store data in a vector
    // This file stores memory address to bitstream address map
    string memoryMapFileName = mParentFamilyName + "-" + tileType + "-map.bits";
    string rambMemoryMapFilePath = mLibraryPath.string() + "/memory/" + memoryMapFileName;
    std::ifstream rambMemoryBitFile(rambMemoryMapFilePath.c_str(), std::ios::binary);
    if(!rambMemoryBitFile.is_open()) {
        std::cout << "Could not open bram memory map file " << rambMemoryMapFilePath << std::endl;
        return;
    }

    std::vector<uint32_t> bitAddresses;
    uint32_t count = 0, bitAddress = 0;
    while(!rambMemoryBitFile.eof()) {
        // Alternate number is ignored.
        rambMemoryBitFile.read((char *) &count, 4);
        rambMemoryBitFile.read((char *) &bitAddress, 4);
        bitAddress = ntohl(bitAddress);
        bitAddresses.push_back(bitAddress);
    }
    rambMemoryBitFile.close();

    // Open the RAMB parity bit file and store the data in a vector
    string parMapFileName = mParentFamilyName + "-" + tileType + "-map-par.bits";
    string rambParityBitFilePath = mLibraryPath.string() + "/memory/" + parMapFileName;
    std::ifstream rambParityBitFile(rambParityBitFilePath.c_str(), std::ios::binary);
    if(!rambParityBitFile.is_open()) {
        std::cerr << "ERROR: Could not open file " << rambParityBitFilePath << std::endl;
        return;
    }
    std::vector<uint32_t> parityBitAddresses;
    count = 0, bitAddress = 0;
    while(!rambParityBitFile.eof()) {
        rambParityBitFile.read((char *) &count, 4);
        rambParityBitFile.read((char *) &bitAddress, 4);
        bitAddress = ntohl(bitAddress);
        parityBitAddresses.push_back(bitAddress);
    }
    rambParityBitFile.close();

    // Before going over configs, merge the RAMB base bits.
    mergeWithBaseBitstream(configSettingToValuesMap[inInstancePtr->getType()]["BASE"], 0);

    // Go over all the configurations of the instance
    ConfigMap::const_iterator pConfig = inInstancePtr->configBegin();
    ConfigMap::const_iterator eConfig = inInstancePtr->configEnd();
    while(pConfig != eConfig) {

        std::cout << "\tWorking on config " << pConfig->first << "::"
            << pConfig->second.getValue() << std::endl;

        // ToDo: Most of the code for memory and parity is same with only the bit address being different.
        //  Try to merge the two if statements.
        // RAMB memory and parity init values have to be handled differently.
        if(isMemoryInitSetting(pConfig->first)) {

            // Get the row number from config name. Last two character are row number in hex form.
            stringstream ssRow;
            uint32_t memoryInitRow;
            ssRow << std::hex << pConfig->first.substr(pConfig->first.length() - 2, 2);
            ssRow >> memoryInitRow;

            mergeRambInitBits(pConfig->second.getValue(), memoryInitRow, bitAddresses, 1);
        } else if(isMemoryParityInitSetting(pConfig->first)) {

            // Get the row number from config name. Last two character are row number in hex form.
            stringstream ssRow;
            uint32_t memoryInitRow;
            ssRow << std::hex << pConfig->first.substr(pConfig->first.length() - 2, 2);
            ssRow >> memoryInitRow;
            mergeRambInitBits(pConfig->second.getValue(), memoryInitRow, parityBitAddresses, 1);
        } else {
            // Merge compressed bitstream to main bitstream
            checkValidityAndMergeBitstream(pConfig->first, pConfig->second.getValue(), configSettingToValuesMap);
        }
        pConfig++;
    }
}

Here is the call graph for this function:

void torc::bitstream::Assembler::binaryLutFrameOperation

(

Assembler::EOperation

inOperation

)

Function called from parser when it encounters a bit operator.

Perform bit operation on two frame set from stack for lut operation.

Definition at line 747 of file Assembler.cpp.

                                                                       {

    bool debug = false;
    if(debug) {
        std::cout << "In DoBinaryOperation " << inOperation << std::endl;
    }
    std::vector<uint32_t> lutWords1 = mLutFrameSetStack.back();
    std::vector<uint32_t> lutWordsNew;
    mLutFrameSetStack.pop_back();
    std::vector<uint32_t> lutWords2;
    if(inOperation == eOR || inOperation == eAND || inOperation == eXOR) {
        lutWords2 = mLutFrameSetStack.back();
        mLutFrameSetStack.pop_back();
    } else if(inOperation == eNOT) {
        lutWords2 = mLutFrameSetForOne;
    } else {
        cout << "WARNING: Unknown LUT operation " << inOperation << std::endl;
        return;
    }
    std::vector<uint32_t>::const_iterator pWord1 = lutWords1.begin();
    std::vector<uint32_t>::const_iterator eWord1 = lutWords1.end();
    std::vector<uint32_t>::const_iterator pWord2 = lutWords2.begin();
    std::vector<uint32_t>::const_iterator eWord2 = lutWords2.end();
    if(inOperation == eOR) {
        while(pWord1 != eWord1 && pWord2 != eWord2) {
            lutWordsNew.push_back((*pWord1 | *pWord2));
            pWord1++;
            pWord2++;
        }
    } else if(inOperation == eAND) {
        while(pWord1 != eWord1) {
            lutWordsNew.push_back((*pWord1 & *pWord2));
            pWord1++;
            pWord2++;
        }
    } else if(inOperation == eXOR || inOperation == eNOT) {
        while(pWord1 != eWord1) {
            lutWordsNew.push_back((*pWord1 ^ *pWord2));
            pWord1++;
            pWord2++;
        }
    }

    if(debug) {
        std::cout << "LUT frames after the logic " << std::endl;
        for(std::vector<uint32_t>::const_iterator iter = lutWordsNew.begin(); iter
            != lutWordsNew.end(); iter++) {
            std::cout << "   " << Hex32(*iter);
        }
        std::cout << std::endl;
    }

    mLutFrameSetStack.push_back(lutWordsNew);
}

Here is the caller graph for this function:

void torc::bitstream::Assembler::checkValidityAndMergeBitstream ( string  inElementName, string  inConfigValue, const ConfigSettingsToValues &  inConfigMap  )

protectedvirtual

Verify the configuratino and merge with base bitstream.

Check if configurations is present in library. If yes, merge the corresponding bits with the bitstream.

Definition at line 357 of file Assembler.cpp.

                                                           {

    ConfigSettingsToValues::const_iterator pConfigSettings = inConfigSettingToValues.find(inElementName);
    // If element found in the map
    if(pConfigSettings != inConfigSettingToValues.end()) {
        ConfigValuesToBits::const_iterator pConfigValues = pConfigSettings->second.find(inConfigVal);
        //If config value found in the config to bit map
        if(pConfigValues != pConfigSettings->second.end()) {
            // std::cout << "  Setting: " << inElementName << " . Config: " << inConfigVal << std::endl;
            mergeWithBaseBitstream(pConfigValues->second, 0);
        } else {
            mMissingConfigs++;
            std::cout << "WARNING: Config value " << inConfigVal << " for setting " << inElementName
                << " not found in library." << std::endl;
        }
    } else {
        mMissingConfigs++;
        std::cout << "WARNING: Config setting " << inElementName << " not found in library." << std::endl;
    }
}

void torc::bitstream::Assembler::convertXdlToBitstream ( void  )

protected

Initiates Xdl to bitstream conversion.

Protected function to internally initiate micro-bitstream assembly process. This function should be called after design ptr, base bitstream, and library have be initialized.

Definition at line 104 of file Assembler.cpp.

                                      {
    assembleInstances();

    assembleNets();
    
    std::cout << "Unsupported tile type count " << mUnsupportedTileTypeSet.size() << std::endl;
    for(std::set<std::string>::iterator iter = mUnsupportedTileTypeSet.begin(); iter != mUnsupportedTileTypeSet.end(); iter++) {
        std::cout << "   " << *iter << std::endl;
    }
    std::cout << "Unsupported tile count : " << mUnsupportedTileCount << std::endl;
    std::cout << "Unsupported pip count : " << mUnsupportedPipCount << std::endl;
    std::cout << "Missing configs of supported tiles : " << mMissingConfigs << std::endl;
    
}

Here is the call graph for this function:

bool torc::bitstream::Assembler::elementAndConfigExistInLibrary ( const string &  inElementName, const string &  configValue, ConfigSettingsToValues &  inConfigSettingToValues  )

protected

Is configuration present in given map.

Returns true if configuration is preseRnt in library.

Definition at line 379 of file Assembler.cpp.

                                                                                  {
    // Check if element exists
    ConfigSettingsToValues::iterator pConfigSettings = inConfigSettingToValues.find(inElementName);
    if(pConfigSettings != inConfigSettingToValues.end()) {

        // Check if config exists
        ConfigValuesToBits::iterator pConfigValues = pConfigSettings->second.find(inConfigValue);
        if(pConfigValues != pConfigSettings->second.end())
            return true;
    }
    std::cout << "WARNING: Config setting " << inElementName << " with value " << inConfigValue
        << " not found in library" << std::endl;
    return false;
}

void torc::bitstream::Assembler::error	(	const location &	l,
		const string &	m
	)

Lut parse error handling.

Definition at line 849 of file Assembler.cpp.

                                                        {
    failure();
    cerr << l << ": " << m << std::endl;
}

Here is the caller graph for this function:

void torc::bitstream::Assembler::error

(

const string &

m

)

Lut general error handling.

Definition at line 854 of file Assembler.cpp.

                                     {
    failure();
    cerr << m << std::endl;
}

void torc::bitstream::Assembler::failure ( void  )

inline

Signals a parsing failure by deasserting the success flag.

Definition at line 135 of file Assembler.hpp.

{ mSuccess = false; }

int torc::bitstream::Assembler::generateBitstream ( DesignSharedPtr  inDesignPtr, const path  inTargetBitstreamPath, EMergeMode  inMergeMode = eSet, path  baseBitstreamPath = path()  )

virtual

Function to generate bitstream, takes target bitstream path and optional base bitstream path.

Reimplemented in torc::bitstream::VirtexAssembler.

Definition at line 64 of file Assembler.cpp.

                                {
    
    mDesignPtr = inDesignPtr;
    mMergeMode = inMergeMode;
    mTargetBitstreamPath = inTargetBitstreamPath;

    if(mDesignPtr->getDevice() != mDB.getDeviceName()) {
        std::cout << "Xdl device differs from database device" << std::endl;
        return -1;
    }
    // User hasn't specified base bitstream path
    if(baseBitstreamPath.empty()) {
        // Null bitstreams are stored in library folder

        const string partNumber = mDesignPtr->getDevice();
        string nullBitFileName = partNumber + ".bit";
        baseBitstreamPath = mLibraryPath / "null_bitstreams" / nullBitFileName;
    } 
    if(!boost::filesystem::exists(baseBitstreamPath)) {
        std::cout << "Base bitstream file - " << baseBitstreamPath.string()
            << " - does not exist." << std::endl;
        return -1;
    }
    // Load the base bitstream file
    std::cout << "Loading base bitstream " << baseBitstreamPath << std::endl;
    std::ifstream baseBitstream;
    baseBitstream.open(baseBitstreamPath.string().c_str());
    mBitstreamPtr = torc::bitstream::Factory::newBitstreamPtr(baseBitstreamPath);
    // Initialize different settings of bitstream object.
    mBitstreamPtr->setDesignName(mDesignPtr->getName());
    mBitstreamPtr->initializeDeviceInfo(mBitstreamPtr->getDeviceName());
    mBitstreamPtr->initializeFrameMaps();
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void torc::bitstream::Assembler::getAnnotatedSiteTypeForSlicel ( string &  inOutSiteType, const string &  siteLocation  )

protectedvirtual

If slice site type, annotate type as per even or odd column.

Definition at line 396 of file Assembler.cpp.

                                                                                               {

    if(boost::regex_search(inOutSiteType.begin(), inOutSiteType.end(), boost::regex("SLICEL"))){
        // Get the column number of site location
        boost::smatch matchResults;
        boost::regex columnExpr("_X(\\d+)Y");
        if(boost::regex_search(siteLocation, matchResults, columnExpr)) {
            // First match is the whole string
            int column = boost::lexical_cast<int>(matchResults[1]);
            if(column % 2 == 0) 
                inOutSiteType = inOutSiteType + "E";
            else
                inOutSiteType = inOutSiteType + "O";
        }
    }
}

virtual vector<string> torc::bitstream::Assembler::getDependantConfigs ( string  inElement1Name )

protectedpure virtual

Returs vector of related configurations.

Implemented in torc::bitstream::Virtex5Assembler, torc::bitstream::Virtex7Assembler, and torc::bitstream::VirtexAssembler.

string torc::bitstream::Assembler::getTiletypeFromSitename ( const string &  inSiteName )

protected

Get tile type from site type.

Get tile type from site location(name) ToDo: A lot of this code is present in initializeFrameDataForSite()

Definition at line 345 of file Assembler.cpp.

                                                                  {
    SiteIndex siteIndex = mSites.findSiteIndex(inSiteName);
    const Site& site = mSites.getSite(siteIndex);
    TileIndex tileIndex = site.getTileIndex();
    const TileInfo& tileInfo = mTiles.getTileInfo(tileIndex);
    string tileType = mTiles.getTileTypeName(tileInfo.getTypeIndex());
    return tileType; 

}

Here is the call graph for this function:

static int torc::bitstream::Assembler::hexCharacterToDec ( char  inDigit )

inlinestatic

Convert a hex ASCII character to a decimal value.

Returns

The equivalent decimal value, or -1 if the input is not a valid hex digit.

Definition at line 139 of file Assembler.hpp.

                                                          {
            // handle numeric hex digits
            if(inDigit >= '0' && inDigit <= '9') return inDigit - '0';
            // force lower case to upper case
            inDigit &= 0xdf;
            // handle alphabetic hex digits
            if(inDigit >= 'A' && inDigit <= 'F') return inDigit - 'A' + 10;
            // reject non-hex digits
            return -1;
        }

Here is the caller graph for this function:

void torc::bitstream::Assembler::initialize ( void  )

protected

Initializations done in constructor.

Called from constructor to initialize the object. Populates mirco-bitstream data from library in a map.

Definition at line 46 of file Assembler.cpp.

                               {

    mUnsupportedTileCount = 0;
    mUnsupportedTileTypeCount = 0;
    mUnsupportedPipCount = 0;
    mMissingConfigs = 0;
    mLibraryPath = torc::common::DirectoryTree::getExecutablePath() / sLibraryRelativePath;
    if(!boost::filesystem::exists(mLibraryPath)) {
        std::cerr << "ERROR: Library folder " << mLibraryPath << " does not exist." << std::endl;
        throw 1;
    }

    mBigEndian = isBigEndianMachine();
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void torc::bitstream::Assembler::initializeFrameDataForSite ( const string &  inSiteName )

protectedpure virtual

Store frame blocks and bit offset for given site.

Implemented in torc::bitstream::VirtexAssembler.

virtual void torc::bitstream::Assembler::initializeFrameDataForTile ( TileIndex  inTileIndex )

protectedpure virtual

Store frame blocks and bit offset for given tile index.

Implemented in torc::bitstream::Virtex5Assembler, torc::bitstream::Virtex7Assembler, and torc::bitstream::VirtexAssembler.

bool torc::bitstream::Assembler::isBigEndianMachine ( )

inlineprotected

Check if processor is big endian.

Definition at line 268 of file Assembler.hpp.

                                  {
            uint32_t check = 0x01020304;
            char *p = (char *)✓
            return  (p[0] == 0x01);
        }

virtual bool torc::bitstream::Assembler::isCompoundSetting ( string  inElementName )

protectedpure virtual

Does element need compound setting.

Implemented in torc::bitstream::VirtexAssembler, torc::bitstream::Virtex5Assembler, and torc::bitstream::Virtex7Assembler.

virtual bool torc::bitstream::Assembler::isConfigValHexString ( const string &  inSiteType, const string &  inElementName  )

inlineprotectedvirtual

Does the configuration have hex string in config value.

Definition at line 200 of file Assembler.hpp.

                                             {

            if (inSiteType.compare("DSP48E") == 0) {
                if (inElementName.compare("PATTERN") == 0 || inElementName.compare(
                        "MASK") == 0) {
                    return true;
                }
            }
            return false;
        }

virtual bool torc::bitstream::Assembler::isLutEquationSetting ( const string &  inConfigValue )

inlineprotectedvirtual

Is config value a LUT equation.

Definition at line 179 of file Assembler.hpp.

                                                                       {
            return boost::regex_match(inConfigValue, sLutConfigRegEx);
        }

virtual bool torc::bitstream::Assembler::isLutRamOrRomSetting ( const string &  inConfigVal )

inlineprotectedvirtual

Is config value a LUT ram setting.

Definition at line 187 of file Assembler.hpp.

                                                                     {
            return boost::regex_match(inConfigVal, sLutRamOrRomConfigRegEx);
        }

bool torc::bitstream::Assembler::isMemoryInitSetting ( const string &  inConfigName )

inlineprotected

Is ramb memory init setting.

Definition at line 212 of file Assembler.hpp.

                                                             {
            return inConfigName.length() == 7 && inConfigName.substr(0, 5).compare(
                    "INIT_") == 0;
        }

bool torc::bitstream::Assembler::isMemoryParityInitSetting ( const string &  inConfigName )

inlineprotected

Is ramb parity init setting.

Definition at line 217 of file Assembler.hpp.

                                                                   {
            return inConfigName.substr(0, 6).compare("INITP_") == 0;
        }

virtual bool torc::bitstream::Assembler::isRambSite ( const string &  inSiteType )

inlineprotectedvirtual

Returns true if the site is some form of RAMB site.

This function might have to be reimplemented in different architectures as name of RAMB site might change.

Definition at line 193 of file Assembler.hpp.

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

virtual bool torc::bitstream::Assembler::isRoutethrough ( const string &  inSetting )

inlineprotectedvirtual

Is config a _ROUTETHROUGH.

Definition at line 183 of file Assembler.hpp.

                                                             {
            return boost::regex_match(inSetting, sRoutethroughRegEx);
        }

bool torc::bitstream::Assembler::isSiteTypeSupported ( const string &  inSiteType )

protectedpure virtual

Is site supporeted for Xdl to bitstream conversion.

Different architectures will have different sites supported. Derived classes should override this function.

Implemented in torc::bitstream::VirtexAssembler, torc::bitstream::Virtex5Assembler, and torc::bitstream::Virtex7Assembler.

Definition at line 253 of file Assembler.cpp.

                                                            {
    return false;
}

void torc::bitstream::Assembler::mergeCompoundSettingBits ( string  inElement1Name, string  inConfig1Val, InstanceSharedPtr  inInstancePtr, const ConfigSettingsToValues &  inConfigSettingToValues  )

protected

Merge micro-bitstream for compound setting.

Merge micro-bitstream for compound setting. There are some settings which together affect the bitstream.

Definition at line 550 of file Assembler.cpp.

                                                                                            {

    std::vector<string> compoundElements = getDependantConfigs(inElement1Name);
    // 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
            << "WARNING: Compound setting with more than two configurations not handled currently"
            << std::endl;
    } else {

        // 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 element2Name = compoundElements[0];
        std::string compoundElementName = inElement1Name + element2Name;

        // Find the 2nd element config in the instance
        std::string config2Val, config2Name;
        inInstancePtr->getConfig(element2Name, config2Name, config2Val);

        // Element 2 config not set
        if(config2Val.compare(sConfigOff) == 0) {
            std::cout << "Illegal configuration. Element " << element2Name << " must be set "
                << " along with element " << inElement1Name << std::endl;
            return;
        }

        // Get compound config val
        std::string compoundConfigVal = inConfig1Val + config2Val;

        // Verify setting and merge bits
        checkValidityAndMergeBitstream(compoundElementName, compoundConfigVal, inConfigSettingToValues);
    }

}

Here is the call graph for this function:

void torc::bitstream::Assembler::mergeHexConfigBits ( string  inElementName, string  inConfigVal, const ConfigSettingsToValues &  inConfigSettingToValues  )

protected

Merge micro-bitstream for configuration with Hex values.

Merge micro-bitstream for configurations with hex values. The hex string is parsed character by character and micro-bitstream for every set bit is retrived from library and merged with base bitstream.

Definition at line 590 of file Assembler.cpp.

                                                           {
    std::vector<uint32_t> inBitAddresses;

    // Go over all the characters of the config val string
    for(uint32_t charIndex = 0; charIndex < inConfigVal.length(); charIndex++) {
        stringstream sshexChar;
        sshexChar << std::hex << inConfigVal[inConfigVal.length() - charIndex - 1];
        uint32_t hexDigit;
        sshexChar >> hexDigit;
        // Go over all the bits of the hex digit
        for(int bitIndex = 0; hexDigit != 0; bitIndex++) {
            if(hexDigit & 1) {
                int configBitIndex = (charIndex << 2) + bitIndex;
                stringstream ssConfigBitIndex;
                ssConfigBitIndex << configBitIndex;
                checkValidityAndMergeBitstream(inElementName, ssConfigBitIndex.str(), inConfigSettingToValues);
            }
            hexDigit = hexDigit >> 1;
        }
    }
}

Here is the call graph for this function:

void torc::bitstream::Assembler::mergeLutEquationBits ( const string &  inElementName, const string &  inConfigValue, ConfigSettingsToValues &  inConfigSettingToValues  )

protected

Merge micro-bitstream for Lut equation.

Merge micro-bitstream for Lut equation. The bit operations (AND, OR, etc.) are performed on the micro-bitstreams corresponding to every literal. Bit operation NOT is performed by XORing with micro-bitstream for LUT output assigned to 1. The lut equation is parsed using bison and flex. When a literal is encountered, the set of frames corresponding to literal is pushed on to a stack. When a bit operator is encountered, two set of frames is poped from the stack and the bit operations is performed on the two set of frames and result is pushed back to stack.

Todo:

Do we really want to abort here just because the user has an incorrect expression?

Definition at line 420 of file Assembler.cpp.

                                                     {

    // Get the right hand side and lefthand side of the LUT equation.
    std::vector<string> splitVector;
    boost::algorithm::split(splitVector, inConfigValue, boost::algorithm::is_any_of("="));

    // The left side tell which output (O5 or O6) is being affected. Store it in a global
    // so that it can be used by functions called from bison
    mLutCurrentEquationLhs = splitVector[0];
    string equationRight = splitVector[1];

    // Store the frames for LUT setting constant 1. XOR with these frames give NOT functionality.
    string lutEquationForOne = mLutCurrentEquationLhs + "=1";

    // Currently all the frames of a LUT setting are not stored. We know only 4 words get affected by LUT setting -
    // 4 frames and a word in each frame. So instead we store only 4 words and the frame index and word index.
    if(elementAndConfigExistInLibrary(inElementName, lutEquationForOne, inConfigSettingToValues)) {
        mCurrentConfigToBitMap = inConfigSettingToValues[inElementName];
        std::vector<uint32_t> bitAddressesForOne = mCurrentConfigToBitMap[lutEquationForOne];

        mLutCurrentReferenceFrameIndex = bitAddressesForOne[0] >> 16;
        mCurrentReferenceWordIndex = (bitAddressesForOne[0] & 0x0000FF00) >> 8;

        mLutFrameSetForOne.clear();
        mLutFrameSetForOne.resize(4, uint32_t(0));
        for(std::vector<uint32_t>::const_iterator bitIter = bitAddressesForOne.begin(); bitIter
            != bitAddressesForOne.end(); bitIter++) {
            int32_t bitIndex = (*bitIter) & 0x000000FF;
            int32_t frameIndex = (*bitIter) >> 16;
            uint32_t frameWord = 1 << (bitIndex - 1);

            mLutFrameSetForOne[frameIndex - mLutCurrentReferenceFrameIndex]
                = mLutFrameSetForOne[frameIndex - mLutCurrentReferenceFrameIndex] | frameWord;
        }

        if(!processLut(equationRight.c_str(), inConfigValue)) {
            std::cout << "ERROR: Error in parsing LUT equation " << inConfigValue << std::endl;
            /// \todo Do we really want to abort here just because the user has an incorrect expression?
            exit(-1);
        }

        // Build bit addresses out of the last frame in gStackOfFrames
        std::vector<uint32_t> combinedLUTWords = mLutFrameSetStack[0];
        std::vector<uint32_t> bitAddresses;
        uint32_t frameOffset = 0;
        for(std::vector<uint32_t>::const_iterator wordIter = combinedLUTWords.begin(); wordIter
            != combinedLUTWords.end(); wordIter++, frameOffset++) {

            uint32_t tempWord = *wordIter;
            uint32_t bitIndex = 1;
            while(tempWord != 0) {

                // check if the LSB is 1
                if(tempWord & 1) {
                    // store the combined address
                    bitAddresses.push_back(((mLutCurrentReferenceFrameIndex + frameOffset) << 16)
                        | (mCurrentReferenceWordIndex << 8) | bitIndex);
                }
                tempWord = tempWord >> 1;
                bitIndex++;
            }
        }

        mergeWithBaseBitstream(bitAddresses, 0);
        mLutFrameSetStack.clear();
    }
}

Here is the call graph for this function:

void torc::bitstream::Assembler::mergeLutRamOrRomBits ( const string &  inElementName, const string &  inConfigVal, ConfigSettingsToValues &  inConfigSettingToValues  )

protected

Merge micro-bitsram for Lut in ram/rom mode.

Merge micro-bitstream for lut in ram/rom mode. The lut ram/rom memory address to bit address map is obtained from ll files.

Definition at line 491 of file Assembler.cpp.

                                                                     {

    // Since memory content are similar for SLICEL and SLICEM,
    // they are stored in library under element name SLICE
    // ConfigSettingsToValues &configSettingToValuesMap = mLibrary["CLBLM"]["SLICE"];

    // Get the right hand side and lefthand side of the LUT equation.
    std::vector<string> splitVector;
    boost::algorithm::split(splitVector, inConfigVal, boost::algorithm::is_any_of("="));
    // Remove the first two characters - 0x - from the hex value
    string memoryValue = splitVector[1].substr(2);

    if(memoryValue.length() != 8 && memoryValue.length() != 16) {
        std::cout << "WARNING: Illegal configuration of element " << inElementName << std::endl;
        return;
    }

    // When output O5 of LUT is configured, it has only 8 hex characters in the memory string,
    // and they belong to the higher memory address of 16 hex characters.
    if(memoryValue.length() == 8) {
        memoryValue = "00000000" + memoryValue;
    }

    // Get the bit address vector
    // Since X5LUT and X6LUT use the same memory address to bit address map,
    // element name is changed to use only 1st letter of the name, viz X (A, B, C or D)
    // and config name is changed to ROM
    string elementNameForMemoryMode = inElementName.substr(0, 1);
    std::vector<uint32_t> bitAddressesForROM;

    if(!elementAndConfigExistInLibrary(elementNameForMemoryMode, "ROM", inConfigSettingToValues))
        return;

    bitAddressesForROM = inConfigSettingToValues[elementNameForMemoryMode]["ROM"];
    std::vector<uint32_t> bitAddresses;
    // Iterate over the memory string from left to right
    for(uint32_t charIndex = 0; charIndex < memoryValue.length(); charIndex++) {

        stringstream sshexChar;
        sshexChar << std::hex << memoryValue[charIndex];
        uint32_t hexDigit;
        sshexChar >> hexDigit;
        // Go over the bits of the hex digit from left to right
        for(int bitIndex = 0; hexDigit != 0; bitIndex++) {
            if(hexDigit & 8) {
                uint32_t memoryAddress = (charIndex << 2) + bitIndex;
                stringstream ssConfigBitIndex;
                ssConfigBitIndex << memoryAddress;
                bitAddresses.push_back(bitAddressesForROM[memoryAddress]);
            }
            hexDigit = hexDigit << 1;
        }
    }
    mergeWithBaseBitstream(bitAddresses, 0);
}

Here is the call graph for this function:

void torc::bitstream::Assembler::mergeRambInitBits ( const string &  inConfigVal, uint32_t  inMemoryInitRow, const vector< uint32_t > &  inRamBitAddress, uint32_t  inBlock  )

protected

Merge micro-bitstreams for ramb memory init values.

Merges micro-bitstream for ramb init (both memory and parity) values.

Definition at line 614 of file Assembler.cpp.

                                                               {

    vector<uint32_t> bitAddresses; // vector to hold bit addresses of set memory bits

    uint32_t configValLength = inConfigVal.length();
    uint32_t numBitsPerConfig = configValLength << 2; // 4 bits every hex character

    // Go over the memory string from right to left
    for(uint32_t charIndex = 0; charIndex < configValLength; charIndex++) {
        //stringstream sshexChar;
        //sshexChar << std::hex << configVal[configValLength - charIndex - 1];
        int hexDigit;
        hexDigit = hexCharacterToDec(inConfigVal[configValLength - charIndex - 1]);
        //sshexChar >> hexDigit;
        // Go over the bits of hex digit from right to left
        for(int bitIndex = 0; hexDigit != 0; bitIndex++) {
            if(hexDigit & 1) {
                // Get memory address of set bit taking into account which row of memory is being processed
                uint32_t configBitIndex = (charIndex << 2) + bitIndex;
                uint32_t memoryAddress = inMemoryInitRow * numBitsPerConfig + configBitIndex;

                bitAddresses.push_back(inRamBitAddress[memoryAddress]);
            }
            hexDigit = hexDigit >> 1;
        }
    }
    mergeWithBaseBitstream(bitAddresses, inBlock);
}

virtual void torc::bitstream::Assembler::mergeWithBaseBitstream ( const vector< uint32_t > &  inBitAddresses, uint32_t  inBlockIndex  )

protectedpure virtual

Merge micro-bitstream with base bitstream.

Implemented in torc::bitstream::VirtexAssembler.

void torc::bitstream::Assembler::populateLibraryMap ( path  inLibDBPath )

protected

Read micro-bitstream library file and populate it in a map.

Loads micro-bitstream library from given path and populates the data in a map.

Definition at line 646 of file Assembler.cpp.

                                                                  {

    std::ifstream libDB(inLibDBPath.string().c_str(), std::ios::binary);
    if(!libDB.good()) {
        std::cout << "Could not open micro-bitstream DB file " << inLibDBPath.string() << std::endl;
        libDB.exceptions(std::ios::failbit);
        exit(-1);
    }
    std::cout << "Opened micro-bitstream DB file " << inLibDBPath.string() << std::endl;
    char buffer[1024];
    libDB.read(buffer, 16);
    buffer[16] = '\0';
    string libDBSanity(buffer);
    std::cout << "Sanity string " << libDBSanity << std::endl;
    if(libDBSanity != "<<<<BITLIBDB>>>>") {
        std::cout << "This file seems to be currupt- " << inLibDBPath.string() << std::endl;
        exit(-1);
    }
    uint32_t tileTypeCount = 0;
    readWord(libDB, tileTypeCount);
    std::cout << "Tile type count " << tileTypeCount << std::endl;

    for(uint32_t tileIndex = 0; tileIndex < tileTypeCount; tileIndex++) {
        uint32_t tileNameCharCount = 0;
        readWord(libDB, tileNameCharCount);
        libDB.read(buffer, tileNameCharCount);
        buffer[tileNameCharCount] = '\0';
        string tileType(buffer);
        uint32_t sitetypeCount = 0;
        readWord(libDB, sitetypeCount);
        std::cout << "Tile type: " << tileType << ". Site count: " << sitetypeCount << std::endl;

        SiteTypeToConfigSettings sitetypeToSettingsMap;

        // Iterate over the elements
        for(uint32_t sitetypeIndex = 0; sitetypeIndex < sitetypeCount; sitetypeIndex++) {
            // Get element name char count
            uint32_t sitetypeCharCount = 0;
            readWord(libDB, sitetypeCharCount);
            libDB.read(buffer, sitetypeCharCount);
            buffer[sitetypeCharCount] = '\0';
            string sitetype(buffer);

            uint32_t configSettingCount = 0;
            readWord(libDB, configSettingCount);
            //std::cout << "   Site " << sitetype << ". Config setting count " << configSettingCount << std::endl;

            ConfigSettingsToValues configSettingToValues;

            // Iterate over configs
            for(uint32_t configSettingIndex = 0; configSettingIndex < configSettingCount; configSettingIndex++) {
                uint32_t configSettingCharCount = 0;
                readWord(libDB, configSettingCharCount);
                //              std::cout << "\tConfig char count " << configSettingCharCount;
                libDB.read(buffer, configSettingCharCount);
                buffer[configSettingCharCount] = '\0';
                string configSetting(buffer);
                //std::cout << "\t" << configSetting << std::endl;

                uint32_t configValuesCount = 0;
                readWord(libDB, configValuesCount);

                ConfigValuesToBits configMap;

                for(uint32_t configValueIndex = 0; configValueIndex < configValuesCount; configValueIndex++) {
                    uint32_t configValueCharCount = 0;
                    readWord(libDB, configValueCharCount);
                    libDB.read(buffer, configValueCharCount);
                    buffer[configValueCharCount] = 0;
                    string configValue(buffer);
                    // Read the compressed word count
                    uint32_t wordCount = 0;
                    readWord(libDB, wordCount);
                    std::vector<uint32_t> addresses;
                    uint32_t word;
                    for(uint32_t i = 0; i < wordCount; i++) {
                        readWord(libDB, word);
                        addresses.push_back(word);
                    }
                    configMap[configValue] = addresses; 
                }

                configSettingToValues[configSetting] = configMap;
            }
            sitetypeToSettingsMap[sitetype] = configSettingToValues;
        }
        mLibrary[tileType] = sitetypeToSettingsMap;
    }
}

Here is the caller graph for this function:

bool torc::bitstream::Assembler::processLut	(	const string &	input,
		const string &	name = "string stream"
	)

Import Lut expression from a string.

Parameters

input	Input stream.
name	Stream name to use for error messages.

Returns

true if successfully parsed.

Definition at line 835 of file Assembler.cpp.

                                                               {
    mStreamName = name;
    istringstream iss(in);
    mSuccess = true;

    LutScanner scanner(&iss);
    scanner.set_debug(mTraceScanning);
    this->lexer = &scanner;
    LutParser parser(*this);
    parser.set_debug_level(mTraceParsing);
    bool result = parser.parse() == 0;
    return mSuccess && result;
}

Here is the call graph for this function:

void torc::bitstream::Assembler::pushLutFrame

(

string

inLiteral

)

Function called from parser when it encounters a literal.

Push set of frames corresponding to literal passed for current lut equation.

Todo:

May need to find a more general to access and push passthrough frame sets

Definition at line 803 of file Assembler.cpp.

                                             {
    bool debug = false;

    if(debug) {
        std::cout << "In PushFrameToStack " << inLiteral << std::endl;
    }

    std::vector<uint32_t> bitAddresses = mCurrentConfigToBitMap[mLutCurrentEquationLhs + "="
        + inLiteral];

    /// \todo May need to find a more general to access and push passthrough frame sets
    // We know LUT bits go across 4 frames and effect the same word in each frame
    std::vector<uint32_t> lutWords(4, 0);
    for(std::vector<uint32_t>::const_iterator bitIter = bitAddresses.begin(); bitIter
        != bitAddresses.end(); bitIter++) {
        int32_t bitIndex = (*bitIter) & 0x000000FF;
        int32_t frameIndex = (*bitIter) >> 16;
        uint32_t frameWord = 1 << (bitIndex - 1);

        lutWords[frameIndex - mLutCurrentReferenceFrameIndex] |= frameWord;
    }

    if(debug) {
        for(std::vector<uint32_t>::const_iterator iter = lutWords.begin(); iter != lutWords.end(); iter++) {
            std::cout << "   " << Hex32(*iter);
        }
        std::cout << std::endl;
    }

    mLutFrameSetStack.push_back(lutWords);
}

Here is the caller graph for this function:

void torc::bitstream::Assembler::readWord ( std::ifstream &  fileStream, uint32_t &  outWord  )

inlineprotected

Read word from stream and convert endianness if required.

Definition at line 274 of file Assembler.hpp.

                                                                  {
            fileStream.read((char *) &outWord, sizeof(uint32_t));
            if(mBigEndian)
                outWord = reverseEndianness(outWord);
        }

Here is the call graph for this function:

uint32_t torc::bitstream::Assembler::reverseEndianness ( uint32_t  inWord )

inlineprotected

Reverse endianness of input word.

Definition at line 280 of file Assembler.hpp.

                                                    {
            uint32_t outWord = 0;
            char *in = (char *)&inWord;
            char *out = (char *)&outWord;
            uint wordSize = sizeof(inWord);
            for(uint i = 0; i< wordSize; i++) {
                out[i] = in[wordSize-i-1];
            }
            return outWord;
        }

Here is the caller graph for this function:

void torc::bitstream::Assembler::saveBitstream ( void  )

protected

Save bitstream.

Save the assembled bitstream.

Definition at line 737 of file Assembler.cpp.

                              {

    std::ofstream customBitstreamFile(mTargetBitstreamPath.string().c_str(), std::ios::binary);
    std::cout << "Writing custom bitstream file " << mTargetBitstreamPath << std::endl;
    mBitstreamPtr->write(customBitstreamFile);

    customBitstreamFile.close();
}

bool torc::bitstream::Assembler::tileAndSiteExistInLibrary ( const string &  inTileType, const string &  inSiteType  )

inlineprotected

Is site present in library database ToDo: This function will need tile type also.

Definition at line 222 of file Assembler.hpp.

                                                                                           {
            
            //unused(inSiteType);
            TileTypeToSiteType::iterator pTiles = mLibrary.find(inTileType);
            if(pTiles == mLibrary.end()) {
                mUnsupportedTileCount++;
                mUnsupportedTileTypeSet.insert(inTileType+"-"+inSiteType);
                return false;
            } else {
                SiteTypeToConfigSettings::iterator pSites = pTiles->second.find(inSiteType);
                if(pSites == pTiles->second.end()) {
                    mUnsupportedTileCount++;
                    mUnsupportedTileTypeSet.insert(inTileType+"-"+inSiteType);
                    return false;
                }
            }
            return true;
        }

Friends And Related Function Documentation

friend class torc::LutParser

friend

The LutParse has access to our members.

Definition at line 158 of file Assembler.hpp.

Field Documentation

class torc::LutScanner* torc::bitstream::Assembler::lexer

Pointer to the current lexer instance.

This serves to connect the parser to the scanner, and is used by the yylex macro.

Definition at line 116 of file Assembler.hpp.

bool torc::bitstream::Assembler::mBigEndian

protected

Definition at line 320 of file Assembler.hpp.

torc::bitstream::BitstreamSharedPtr torc::bitstream::Assembler::mBitstreamPtr

protected

Definition at line 316 of file Assembler.hpp.

ConfigValuesToBits torc::bitstream::Assembler::mCurrentConfigToBitMap

protected

Map from Lut config value to micro-bitstreams.

Definition at line 326 of file Assembler.hpp.

uint32_t torc::bitstream::Assembler::mCurrentReferenceWordIndex

protected

Address of 1st work within frame affected by Lut equation.

Definition at line 324 of file Assembler.hpp.

const torc::architecture::DDB& torc::bitstream::Assembler::mDB

protected

Torc database of architecutre on which design is implemented.

Definition at line 312 of file Assembler.hpp.

torc::physical::DesignSharedPtr torc::bitstream::Assembler::mDesignPtr

protected

Xdl design pointer.

Definition at line 308 of file Assembler.hpp.

bool torc::bitstream::Assembler::mFreeDB

protected

To track if DB object was allocated in constructor.

Definition at line 315 of file Assembler.hpp.

TileTypeToSiteType torc::bitstream::Assembler::mLibrary

protected

Micro-bitstream library in map datastructure.

Definition at line 311 of file Assembler.hpp.

boost::filesystem::path torc::bitstream::Assembler::mLibraryPath

protected

Pointer to bitstream object to which micro bitstreams are merged.

Definition at line 317 of file Assembler.hpp.

string torc::bitstream::Assembler::mLutCurrentEquationLhs

protected

LHS of Lut equation currently being processed.

Definition at line 327 of file Assembler.hpp.

uint32_t torc::bitstream::Assembler::mLutCurrentReferenceFrameIndex

protected

Address of 1st frame being affected by Lut equation.

Definition at line 323 of file Assembler.hpp.

std::vector<uint32_t> torc::bitstream::Assembler::mLutFrameSetForOne

protected

Frame set for Lut output assigned to 1.

Definition at line 325 of file Assembler.hpp.

vector<vector<uint32_t> > torc::bitstream::Assembler::mLutFrameSetStack

protected

Frame set for literals are pushed to this stack.

Definition at line 322 of file Assembler.hpp.

EMergeMode torc::bitstream::Assembler::mMergeMode

protected

Merge mode - set bits or clear bits.

Definition at line 310 of file Assembler.hpp.

int torc::bitstream::Assembler::mMissingConfigs

protected

Definition at line 333 of file Assembler.hpp.

string torc::bitstream::Assembler::mParentFamilyName

protected

Definition at line 318 of file Assembler.hpp.

const torc::architecture::Sites& torc::bitstream::Assembler::mSites

protected

Sites from the architecture database.

Definition at line 313 of file Assembler.hpp.

string torc::bitstream::Assembler::mStreamName

Name of file or input stream for error messages.

Definition at line 112 of file Assembler.hpp.

bool torc::bitstream::Assembler::mSuccess

protected

Flag signaling parsing success.

Definition at line 319 of file Assembler.hpp.

path torc::bitstream::Assembler::mTargetBitstreamPath

protected

Target bitstream path.

Definition at line 309 of file Assembler.hpp.

const torc::architecture::Tiles& torc::bitstream::Assembler::mTiles

protected

Tiles from architecture database.

Definition at line 314 of file Assembler.hpp.

bool torc::bitstream::Assembler::mTraceParsing

Enable debug output in the bison parser.

Definition at line 110 of file Assembler.hpp.

bool torc::bitstream::Assembler::mTraceScanning

Enable debug output in the flex scanner.

Definition at line 108 of file Assembler.hpp.

int torc::bitstream::Assembler::mUnsupportedInstCount

protected

Definition at line 332 of file Assembler.hpp.

int torc::bitstream::Assembler::mUnsupportedPipCount

protected

Definition at line 331 of file Assembler.hpp.

int torc::bitstream::Assembler::mUnsupportedTileCount

protected

Definition at line 330 of file Assembler.hpp.

int torc::bitstream::Assembler::mUnsupportedTileTypeCount

protected

Definition at line 329 of file Assembler.hpp.

std::set<std::string> torc::bitstream::Assembler::mUnsupportedTileTypeSet

protected

Definition at line 334 of file Assembler.hpp.

const string torc::bitstream::Assembler::sConfigOff = "#OFF"

staticprotected

String used when an element is explicity configured off.

Definition at line 338 of file Assembler.hpp.

const string torc::bitstream::Assembler::sLibraryExtension = ".ldb"

staticprotected

Extension used for micro-bitstream libraries.

Definition at line 337 of file Assembler.hpp.

const string torc::bitstream::Assembler::sLibraryRelativePath = "torc/bitstream/assembler/libraries"

staticprotected

Path to library folder containing mirco-bitstream database.

Definition at line 336 of file Assembler.hpp.

const boost::regex torc::bitstream::Assembler::sLutConfigRegEx

staticprotected

Regex to identify Lut configuration.

Definition at line 340 of file Assembler.hpp.

const boost::regex torc::bitstream::Assembler::sLutRamOrRomConfigRegEx

staticprotected

Regex to identify Luts configured as ram/rom.

Definition at line 339 of file Assembler.hpp.

const boost::regex torc::bitstream::Assembler::sRoutethroughRegEx

staticprotected

Regex to indentify ROUTETHROUGH configuration in instances.

Definition at line 341 of file Assembler.hpp.

---

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

• Assembler.hpp
• Assembler.cpp