Convert an XDL to bitstream by merging the compressed bitstreams from library. More...

#include <algorithm>
#include "Xdl2Bit.h"
#include "torc/packer/Virtex5PrimitiveStructure.hpp"
#include "torc/architecture/DDB.hpp"
#include "torc/common/DirectoryTree.hpp"
#include "torc/Physical.hpp"
#include "torc/Bitstream.hpp"
#include "SharedFunctions.hpp"

Include dependency graph for Xdl2Bit.cpp:

Go to the source code of this file.

Functions
static std::vector< uint32_t >	gLUTWordsForOne (4, 0xFFFFFFFF)

void	convertXdlToBitstream (DesignSharedPtr inDesignPtr, Bitstream &outBitstream, const Sites &sites, const Tiles &tiles, TiletypeElementMap &library)

void	assembleInstances (DesignSharedPtr inDesignPtr, Bitstream &outBitstream, const Sites &sites, const Tiles &tiles, TiletypeElementMap &library)

void	assembleRambInstance (InstanceSharedPtr instance, Bitstream &outBitstream, VirtexFrameBlocks &frameBlocks, uint32_t wordOffset, TiletypeElementMap &library)

void	assembleNets (DesignSharedPtr inDesignPtr, Bitstream &outBitstream, const Sites &sites, const Tiles &tiles, TiletypeElementMap &library)

VirtexFrameBlocks	GetFrameBlocksFromSiteName (Bitstream &inBitstream, const std::string &siteName, const Sites &sites, const Tiles &tiles, uint32_t &outWordOffset)

VirtexFrameBlocks	GetFrameBlocksFromTileIndex (Bitstream &inBitstream, TileIndex tileIndex, const Tiles &tiles, uint32_t &outWordOffset)

void	checkValidityAndMergeBitstream (std::string elementName, std::string configVal, const ElementConfigMap &elementMap, VirtexFrameBlocks &frameBlocks, uint32_t wordOffset, Bitstream &outBitstream)

void	MergeCompressedBitToMainBits (const std::vector< uint32_t > &bitAddresses, Bitstream &outBitstream, VirtexFrameBlocks &frameBlocks, uint32_t wordOffset, uint32_t blockIndex=0)

void	mergeLutBits (const std::string &elementName, const std::string &configValue, Bitstream &outBitstream, VirtexFrameBlocks &frameBlocks, uint32_t wordOffset, ElementConfigMap &elementMap)

void	mergeLutRamOrRomBits (const std::string &elementName, const std::string &configVal, Bitstream &outBitstream, VirtexFrameBlocks &frameBlocks, uint32_t wordOffset, TiletypeElementMap &library)

void	mergeCompoundSettingBits (std::string element1Name, std::string config1Val, InstanceSharedPtr instancePtr, const ElementConfigMap &elementMap, VirtexFrameBlocks &frameBlocks, uint32_t wordOffset, Bitstream &outBitstream)

void	mergeDspMaskOrPattern (std::string elementName, std::string configVal, InstanceSharedPtr instancePtr, const ElementConfigMap &elementMap, VirtexFrameBlocks &frameBlocks, uint32_t wordOffset, Bitstream &outBitstream)

void	mergeRambInitBits (const std::string &configVal, uint32_t memoryInitRow, Bitstream &outBitstream, VirtexFrameBlocks &frameBlocks, uint32_t wordOffset, const vector< uint32_t > &bitAddresses, uint32_t block)

bool	isLutEquationSetting (const std::string &configValue)

bool	isLutRamOrRomSetting (const std::string &configVal)

bool	isMemoryInitSetting (const std::string &configName)

bool	isMemoryParityInitSetting (const std::string &configName)

bool	siteExistsInLibrary (const std::string &siteType, TiletypeElementMap &library)

bool	elementAndConfigExistInLibrary (const std::string &elementName, const std::string &configValue, ElementConfigMap &elementMap)

static TiletypeElementMap	populateLibraryMap (boost::filesystem::path libDBPath)

int	main (int argc, char **argv)
	Converts XDL file to bitstream by merging primitive bitstreams from library. More...

void	PushFrameToStack (std::string literal)

void	DoBinaryOperation (std::string operation)

bool	isSiteTypeSupported (const std::string &siteType)

bool	isRambSite (const std::string &siteType)

Variables
static vector< vector< uint32_t > >	gStackOfFrames

static uint32_t	gCurrentReferenceFrameIndex

static uint32_t	gCUrrentReferenceWordIndex

static ConfigBitMap	gcurrentConfigBitMap

static std::string	gLUTEquationLeft

Detailed Description

Convert an XDL to bitstream by merging the compressed bitstreams from library.

Definition in file Xdl2Bit.cpp.

Function Documentation

void assembleInstances	(	DesignSharedPtr	inDesignPtr,
		Bitstream &	outBitstream,
		const Sites &	sites,
		const Tiles &	tiles,
		TiletypeElementMap &	library
	)

Definition at line 247 of file Xdl2Bit.cpp.

                                                                          {
 
     std::cout << "Going through instances..." << std::endl;
     // Get instances begin and end
     InstanceSharedPtrVector::const_iterator pInstance = inDesignPtr->instancesBegin();
     InstanceSharedPtrVector::const_iterator eInstance = inDesignPtr->instancesEnd();
 
     // Iterate over all the instances
     while(pInstance != eInstance) {
 
         InstanceSharedPtr instancePtr = *pInstance;
         const std::string &siteType = instancePtr->getType();
 
         // Check if instance is placed on supported site type
         if(isSiteTypeSupported(instancePtr->getType()) && siteExistsInLibrary(siteType, library)) {
 
             std::string siteName = instancePtr->getSite();
 
             // Get the frame set for this site
             uint32_t wordOffset = 0;
             VirtexFrameBlocks frameBlocks = GetFrameBlocksFromSiteName(outBitstream, siteName,
                 sites, tiles, wordOffset);
 
             std::cout << "Instance " << instancePtr->getName() << " placed on site "
                 << siteName << " has " << instancePtr->getConfigCount()
                 << " configs set." << std::endl;
 
             // RAMB sites are handled in a slightly different manner
             if(isRambSite(siteType)) {
                 assembleRambInstance(instancePtr, outBitstream, frameBlocks,
                     wordOffset, library);
             } else {
 
                 // Get the element to config map for the given site type
                 ElementConfigMap elementMap = library[siteType];
 
                 // Go over all the configurations of the instance
                 ConfigMap::const_iterator pConfig = instancePtr->configBegin();
                 ConfigMap::const_iterator eConfig = instancePtr->configEnd();
 
                 while(pConfig != eConfig) {
 
                     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())) {
                         mergeLutBits(pConfig->first, pConfig->second.getValue(), outBitstream,
                             frameBlocks, wordOffset, elementMap);
                     } // LUT ROM and RAM settings also need special care
                     else if(isLutRamOrRomSetting(pConfig->second.getValue())) {
                         mergeLutRamOrRomBits(pConfig->first,
                             pConfig->second.getValue(), outBitstream, frameBlocks, wordOffset,
                             library);
                     }  // Some elements together effect the bitstream.
                     else if(elementNeedsCompoundSetting(pConfig->first)) {
                         mergeCompoundSettingBits(pConfig->first, pConfig->second.getValue(),
                             instancePtr, elementMap, frameBlocks, wordOffset, outBitstream);
                     } // The DSP MASK and PATTERN have hex values
                     else if(DSPMaskOrPatternConfig(instancePtr->getType(), pConfig->first)) {
                         mergeDspMaskOrPattern(pConfig->first, pConfig->second.getValue(),
                             instancePtr, elementMap, frameBlocks, wordOffset, outBitstream);
                     } else {
                         // Merge compressed bitstream to main bitstream if valid setting
                         checkValidityAndMergeBitstream(pConfig->first, pConfig->second.getValue(),
                             elementMap, frameBlocks, wordOffset, outBitstream);
                     }
                     std::cout << "\t------------------" << std::endl;
                     pConfig++;
                 }
             }
         } else {
             std::cout << "Site " << instancePtr->getType() << " not supported." << std::endl;
         }
         pInstance++;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void assembleNets	(	DesignSharedPtr	inDesignPtr,
		Bitstream &	outBitstream,
		const Sites &	sites,
		const Tiles &	tiles,
		TiletypeElementMap &	library
	)

Definition at line 418 of file Xdl2Bit.cpp.

                                                                          {
 
     // Get the iterators to nets
     NetSharedPtrVector::const_iterator pNets = inDesignPtr->netsBegin();
     NetSharedPtrVector::const_iterator eNets = inDesignPtr->netsEnd();
 
     std::cout << "Working on NETs... count: " << inDesignPtr->getNetCount() << std::endl;
     // Go over all the nets
     while(pNets != eNets) {
 
         NetSharedPtr netPtr = *pNets;
         std::cout << "Net: " << netPtr->getName() << std::endl;
 
         // Go over all the pips in the net
         Net::PipConstIterator pPips = netPtr->pipsBegin();
         Net::PipConstIterator ePips = netPtr->pipsEnd();
         while(pPips != ePips) {
 
             // Get word offset for this tile
             TileIndex tileIndex = tiles.findTileIndex(pPips->getTileName());
             const TileInfo& tileInfo = tiles.getTileInfo(tileIndex);
             std::string tileType = tiles.getTileTypeName(tileInfo.getTypeIndex());
             uint32_t wordOffset = 0;
             VirtexFrameBlocks frameBlocks = GetFrameBlocksFromTileIndex(outBitstream, tileIndex,
                 tiles, wordOffset);
 
             ElementConfigMap elementMap = library[tileType];
             std::cout << "\tTile " << tileInfo.getName() << " Src: " << pPips->getSourceWireName()
                 << std::endl;
             checkValidityAndMergeBitstream(pPips->getSourceWireName(), pPips->getSinkWireName(),
                 elementMap, frameBlocks, wordOffset, outBitstream);
             pPips++;
         }
 
         pNets++;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void assembleRambInstance	(	InstanceSharedPtr	instance,
		Bitstream &	outBitstream,
		VirtexFrameBlocks &	frameBlocks,
		uint32_t	wordOffset,
		TiletypeElementMap &	library
	)

Definition at line 328 of file Xdl2Bit.cpp.

                                                                                       {
 
     // Get the element to config map for the given site type
     ElementConfigMap elementMap = library[instance->getType()];
 
     std::cout << "  Instance " << instance->getName() << " has " << instance->getConfigCount()
         << " configs set." << std::endl;
 
     // Open the RAMBIT file and store data in a vector
     // This file stores memory address to bitstream address map
     std::string rambBitFileName = "library/memory/bram-map.bits";
     std::ifstream rambBitFile(rambBitFileName.c_str(), std::ios::binary);
     if(!rambBitFile.is_open()) {
         std::cout << "Could not open file " << rambBitFileName << std::endl;
         return;
     }
     std::vector<uint32_t> bitAddresses;
     uint32_t count = 0, bitAddress = 0;
     while(!rambBitFile.eof()) {
         // One number is ignored.
         rambBitFile.read((char *) &count, 4);
         rambBitFile.read((char *) &bitAddress, 4);
         bitAddress = ntohl(bitAddress);
         bitAddresses.push_back(bitAddress);
     }
     rambBitFile.close();
 
     // Open the RAMB parity bit file and store the data in a vector
     std::string rambParityBitFileName = "library/memory/bram-map-par.bits";
     std::ifstream rambParityBitFile(rambParityBitFileName.c_str(), std::ios::binary);
     if(!rambParityBitFile.is_open()) {
         std::cout << "Could not open file " << rambParityBitFileName << 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.
     MergeCompressedBitToMainBits(elementMap[instance->getType()]["BASE"], outBitstream,
         frameBlocks, wordOffset);
 
     // Go over all the configurations of the instance
     ConfigMap::const_iterator pConfig = instance->configBegin();
     ConfigMap::const_iterator eConfig = instance->configEnd();
     while(pConfig != eConfig) {
 
         std::cout << "\tBRAM Working on config " << pConfig->first << " value "
             << pConfig->second.getValue() << std::endl;
 
         // RAMB memory and parity init values have to be handled differently.
         // The boolean operation in the LUT equation have to be performed on the relevant bits.
         if(isMemoryInitSetting(pConfig->first)) {
 
             // Get the row number from config name. Last two character are row number in hex form.
             std::stringstream ssRow;
             uint32_t memoryInitRow;
             ssRow << std::hex << pConfig->first.substr(pConfig->first.length() - 2, 2);
             ssRow >> memoryInitRow;
 
             mergeRambInitBits(pConfig->second.getValue(), memoryInitRow,
                 outBitstream, frameBlocks, wordOffset, bitAddresses, 1);
         } else if(isMemoryParityInitSetting(pConfig->first)) {
 
             // Get the row number from config name. Last two character are row number in hex form.
             std::stringstream ssRow;
             uint32_t memoryInitRow;
             ssRow << std::hex << pConfig->first.substr(pConfig->first.length() - 2, 2);
             ssRow >> memoryInitRow;
             mergeRambInitBits(pConfig->second.getValue(), memoryInitRow,
                 outBitstream, frameBlocks, wordOffset, parityBitAddresses, 1);
         } else {
             // Merge compressed bitstream to main bitstream
             checkValidityAndMergeBitstream(pConfig->first, pConfig->second.getValue(), elementMap,
                 frameBlocks, wordOffset, outBitstream);
         }
         std::cout << "------------------" << std::endl;
         pConfig++;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void checkValidityAndMergeBitstream	(	std::string	elementName,
		std::string	configVal,
		const ElementConfigMap &	elementMap,
		VirtexFrameBlocks &	frameBlocks,
		uint32_t	wordOffset,
		Bitstream &	outBitstream
	)

Definition at line 495 of file Xdl2Bit.cpp.

                              {
 
     ElementConfigMap::const_iterator elementIter = elementMap.find(elementName);
     // If element found in the map
     if(elementIter != elementMap.end()) {
         ConfigBitMap::const_iterator configIter = elementIter->second.find(configVal);
         //If config value found in the config to bit map
         if(configIter != elementIter->second.end()) {
             MergeCompressedBitToMainBits(configIter->second, outBitstream, frameBlocks, wordOffset,
                 0);
         } else {
             std::cout << "Config " << configVal << " for element " << elementName
                 << " not found in library." << std::endl;
         }
     } else {
         std::cout << "Element " << elementName << " not found in library." << std::endl;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void convertXdlToBitstream	(	DesignSharedPtr	inDesignPtr,
		Bitstream &	outBitstream,
		const Sites &	sites,
		const Tiles &	tiles,
		TiletypeElementMap &	library
	)

Definition at line 230 of file Xdl2Bit.cpp.

                                                                          {
 
     assembleInstances(inDesignPtr, outBitstream, sites, tiles, library);
 
     assembleNets(inDesignPtr, outBitstream, sites, tiles, library);
 
     // Update the frame words in packets
     Virtex5 *virtexBitstreamPtr = dynamic_cast<Virtex5 *>(&outBitstream);
     if(virtexBitstreamPtr) {
         virtexBitstreamPtr->updateFullFrameBlocks();
     }
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void DoBinaryOperation ( std::string operation )

Definition at line 817 of file Xdl2Bit.cpp.

                                             {
 
     bool debug = false;
 
     if(debug) {
         std::cout << "In DoBinaryOperation " << operation << std::endl;
     }
     std::vector<uint32_t> lutWords1 = gStackOfFrames.back();
     std::vector<uint32_t> lutWordsNew;
     gStackOfFrames.pop_back();
     std::vector<uint32_t> lutWords2;
     if(operation == "OR" || operation == "AND" || operation == "XOR") {
         lutWords2 = gStackOfFrames.back();
         gStackOfFrames.pop_back();
     } else if(operation == "NOT") {
         lutWords2 = gLUTWordsForOne;
     } else {
         cout << "Unknown operation " << operation << 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(operation == "OR") {
         while(pWord1 != eWord1 && pWord2 != eWord2) {
             lutWordsNew.push_back((*pWord1 | *pWord2));
             pWord1++;
             pWord2++;
         }
     } else if(operation == "AND") {
         while(pWord1 != eWord1) {
             lutWordsNew.push_back((*pWord1 & *pWord2));
             pWord1++;
             pWord2++;
         }
     } else if(operation == "XOR" || operation == "NOT") {
         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;
     }
 
     gStackOfFrames.push_back(lutWordsNew);
 
 }

Here is the call graph for this function:

bool elementAndConfigExistInLibrary	(	const std::string &	elementName,
		const std::string &	configValue,
		ElementConfigMap &	elementMap
	)

Definition at line 121 of file Xdl2Bit.cpp.

                                                                                                                               {
     // Check if element exists
     ElementConfigMap::iterator pElement = elementMap.find(elementName);
     if(pElement != elementMap.end()) {
 
         // Check if config exists
         ConfigBitMap::iterator pConfig = pElement->second.find(configValue);
         if(pConfig != pElement->second.end())
             return true;
     }
     std::cout << "Element " << elementName << " with config " << configValue << " not found in library" << std::endl;
     return false;
 }

Here is the caller graph for this function:

VirtexFrameBlocks GetFrameBlocksFromSiteName	(	Bitstream &	inBitstream,
		const std::string &	siteName,
		const Sites &	sites,
		const Tiles &	tiles,
		uint32_t &	outWordOffset
	)

Definition at line 458 of file Xdl2Bit.cpp.

                                                                       {
 
     SiteIndex siteIndex = sites.findSiteIndex(siteName);
     const Site& site = sites.getSite(siteIndex);
 
     // look up the site tile index
     TileIndex tileIndex = site.getTileIndex();
     return GetFrameBlocksFromTileIndex(inBitstream, tileIndex, tiles, outWordOffset);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

VirtexFrameBlocks GetFrameBlocksFromTileIndex	(	Bitstream &	inBitstream,
		TileIndex	tileIndex,
		const Tiles &	tiles,
		uint32_t &	outWordOffset
	)

Definition at line 470 of file Xdl2Bit.cpp.

                                                   {
 
     const TileInfo& tileInfo = tiles.getTileInfo(tileIndex);
     const TileRow &tileRow = tileInfo.getRow();
     const TileCol &tileCol = tileInfo.getCol();
 
     Virtex5 *virtex5BitStream = dynamic_cast<Virtex5 *> (&inBitstream);
     uint32_t bitIndexBegin = 0, bitIndexEnd = 0;
     uint32_t primaryXdlCol = virtex5BitStream->getPrimaryXdlColumn(tileCol);
     VirtexFrameBlocks returnFrameBlocks = virtex5BitStream->getXdlFrames(tileRow, primaryXdlCol,
         bitIndexBegin, bitIndexEnd);
 
     // Each frame covers the full height of clock region which contains many rows of tiles.
     // The library contains configuration bits only for the first row. So the word index has to
     // be offset to reach the correct row. The bit index remains same across rows.
     outWordOffset = 0;
     if(bitIndexBegin != bitIndexEnd) {
         outWordOffset = Virtex5::eFrameLength - (bitIndexEnd >> 5); // eFrameLength is number of words in a frame
     }
 
     return returnFrameBlocks;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static std::vector<uint32_t> gLUTWordsForOne	(	4	,
		0xFFFFFFFF
	)

static

Here is the caller graph for this function:

bool isLutEquationSetting ( const std::string & configValue )

Definition at line 100 of file Xdl2Bit.cpp.

                                                         {
     return regex_match(configValue, kLUTConfigRegEx);
 }

Here is the caller graph for this function:

bool isLutRamOrRomSetting ( const std::string & configVal )

Definition at line 104 of file Xdl2Bit.cpp.

                                                       {
     return regex_match(configVal, kLUTRAMorROMConfigRegEx);
 }

Here is the caller graph for this function:

bool isMemoryInitSetting ( const std::string & configName )

Definition at line 108 of file Xdl2Bit.cpp.

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

Here is the caller graph for this function:

bool isMemoryParityInitSetting ( const std::string & configName )

Definition at line 112 of file Xdl2Bit.cpp.

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

Here is the caller graph for this function:

bool isRambSite ( const std::string & siteType )

Definition at line 881 of file Xdl2Bit.cpp.

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

Here is the caller graph for this function:

bool isSiteTypeSupported ( const std::string & siteType )

Definition at line 875 of file Xdl2Bit.cpp.

                                                     {
     return (siteType.compare("SLICEL") == 0 || siteType.compare("SLICEM") == 0 || siteType.compare(
         "RAMB36_EXP") == 0 || siteType.compare("DSP48E") == 0);
 }

Here is the caller graph for this function:

int main	(	int	argc,
		char **	argv
	)

Converts XDL file to bitstream by merging primitive bitstreams from library.

Definition at line 139 of file Xdl2Bit.cpp.

                                 {
 
     if(argc != 3) {
         std::cerr << "Usage: " << argv[0] << " <XDL file path> <library path>" << std::endl;
         return -1;
     }
 
     // Initialize the DirectoryTree class
     torc::common::DirectoryTree directoryTree(argv[0]);
 
     // Open the XDL file and check if it opens successfully
     std::string xdlFileName(argv[1]);
     std::fstream xdlFileStream(xdlFileName.c_str());
     if(!xdlFileStream.good()) {
         std::cout << "Could not open file " << xdlFileName << std::endl;
         return -1;
     }
 
     // Check if the library path exists
     boost::filesystem::path libraryPath(argv[2]);
     if(!boost::filesystem::exists(libraryPath)) {
         std::cout << "Library folder - " << libraryPath.string() << " - does not exist "
             << std::endl;
         return -1;
     }
 
     // This map holds which elements have compound setting
     InitializeCompoundSettingsMap();
 
     // Import the XDL file
     torc::physical::XdlImporter importer;
     importer(xdlFileStream, xdlFileName);
     // Get the design pointer
     DesignSharedPtr designPtr = importer.getDesignPtr();
     // Get the part number
     std::string partNumber = designPtr->getDevice();
     // Open the database and get sites and tiles
     DDB ddb(partNumber);
 
     const Sites &sites = ddb.getSites();
     const Tiles &tiles = ddb.getTiles();
 
     // Get null bitstream file path
     boost::filesystem::path nullBTPath = libraryPath / "null_bitstreams";
     std::string nullBitFileName = partNumber + ".bit";
     nullBTPath = nullBTPath / nullBitFileName;
     if(!boost::filesystem::exists(nullBTPath)) {
         std::cout << "Null bitstream file - " << nullBTPath.string() << " - does not exist."
             << std::endl;
         return -1;
     }
 
     // Get the compressed bitstreams library database file path
     std::string libDBFileName = ddb.getFamilyName() + ".ldb";
     boost::filesystem::path libDBPath = libraryPath / libDBFileName;
     if(!boost::filesystem::exists(libDBPath)) {
         std::cout << "Library database file - " << libDBPath.string() << " - does not exist."
             << std::endl;
         return -1;
     }
 
     // Populate map data structure from the library database
     TiletypeElementMap library = populateLibraryMap(libDBPath);
 
     // Open a NULL bitstream of the Device
     std::ifstream nullBitstream;
     nullBitstream.open(nullBTPath.string().c_str());
 
     Virtex5 bitstream;
     bitstream.read(nullBitstream);
     bitstream.setDesignName(designPtr->getName());
     bitstream.initializeDeviceInfo(bitstream.getDeviceName());
     bitstream.initializeFrameMaps();
     bitstream.initializeFullFrameBlocks();
 
     // Go over the XDL and merge the required bits to bitstream
     convertXdlToBitstream(designPtr, bitstream, sites, tiles, library);
 
     // Write the bitstream to a file.
     std::string customBitstreamPath =
         boost::filesystem::path(xdlFileName).replace_extension().string() + ".custom.bit";
     std::ofstream customBitstreamFile(customBitstreamPath.c_str(), std::ios::binary);
     std::cout << "Writing custom bitstream file " << customBitstreamPath << std::endl;
     bitstream.write(customBitstreamFile);
 
     xdlFileStream.close();
     customBitstreamFile.close();
     return 0;
 }

Here is the call graph for this function:

void mergeCompoundSettingBits	(	std::string	element1Name,
		std::string	config1Val,
		InstanceSharedPtr	instancePtr,
		const ElementConfigMap &	elementMap,
		VirtexFrameBlocks &	frameBlocks,
		uint32_t	wordOffset,
		Bitstream &	outBitstream
	)

Definition at line 686 of file Xdl2Bit.cpp.

                                                                                   {
 
     std::vector<std::string> compoundElements = gCompoundSettingsMap[element1Name];
     // 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 {
 
         std::cout << "\tIt is a compound setting." << std::endl;
 
         // 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 = element1Name + element2Name;
 
         // Find the 2nd element config in the instance
         std::string config2Val, config2Name;
         instancePtr->getConfig(element2Name, config2Name, config2Val);
 
         // Element 2 config not set
         if(config2Val.compare(kConfigOff) == 0) {
             std::cout << "Illegal configuration. Element " << element2Name << " must be set "
                 << " along with element " << element1Name << std::endl;
             return;
         }
 
         // Get compound config val
         std::string compoundConfigVal = config1Val + config2Val;
 
         // Verify setting and merge bits
         checkValidityAndMergeBitstream(compoundElementName, compoundConfigVal, elementMap,
             frameBlocks, wordOffset, outBitstream);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void MergeCompressedBitToMainBits	(	const std::vector< uint32_t > &	bitAddresses,
		Bitstream &	outBitstream,
		VirtexFrameBlocks &	frameBlocks,
		uint32_t	wordOffset,
		uint32_t	blockIndex = `0`
	)

Definition at line 518 of file Xdl2Bit.cpp.

                          {
 
     int32_t numSetBits = bitAddresses.size();
     std::cout << "\tNumber of bits set: " << numSetBits << std::endl;
 
     VirtexFrameSet& frameSet = frameBlocks.mBlock[blockIndex];
     if(!frameSet.empty()) {
         for(int i = 0; i < numSetBits; i++) {
             uint32_t bitAddr = bitAddresses[i];
             int32_t bitIndex = bitAddr & 0x000000FF; // get the lowest byte
             int32_t wordIndex = (bitAddr & 0x0000FF00) >> 8;
             // Library setting is for first row of clock region. Word index has to be offset to reach the correct row.
             wordIndex += wordOffset;
             int32_t frameIndex = (bitAddr & 0xFFFF0000) >> 16;
             std::cout << "\t  Frame: " << Hex32(frameIndex) << " Word: " << Hex32(wordIndex)
                 << " bit: " << Hex32(bitIndex) << std::endl;
             VirtexFrameSharedPtr virtexFrame = frameSet[frameIndex];
 
             VirtexFrame::word_t currentWord = virtexFrame->getWords()[wordIndex];
             VirtexFrame::word_t word = (1 << (bitIndex)) | currentWord;
             virtexFrame->setWord(wordIndex, word);
 
         }
     } else {
         std::cout << "Unknown frame type." << std::endl;
     }
 
 }

Here is the caller graph for this function:

void mergeDspMaskOrPattern	(	std::string	elementName,
		std::string	configVal,
		InstanceSharedPtr	instancePtr,
		const ElementConfigMap &	elementMap,
		VirtexFrameBlocks &	frameBlocks,
		uint32_t	wordOffset,
		Bitstream &	outBitstream
	)

Definition at line 725 of file Xdl2Bit.cpp.

                                                                                   {
 
     std::vector<uint32_t> bitAddresses;
 
     // Go over all the characters of the config val string
     for(uint32_t charIndex = 0; charIndex < configVal.length(); charIndex++) {
         std::stringstream sshexChar;
         sshexChar << std::hex << configVal[configVal.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;
                 std::stringstream ssConfigBitIndex;
                 ssConfigBitIndex << configBitIndex;
                 checkValidityAndMergeBitstream(elementName, ssConfigBitIndex.str(), elementMap,
                     frameBlocks, wordOffset, outBitstream);
             }
             hexDigit = hexDigit >> 1;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void mergeLutBits	(	const std::string &	elementName,
		const std::string &	configValue,
		Bitstream &	outBitstream,
		VirtexFrameBlocks &	frameBlocks,
		uint32_t	wordOffset,
		ElementConfigMap &	elementMap
	)

Definition at line 551 of file Xdl2Bit.cpp.

                                                        {
 
     // Get the right hand side and lefthand side of the LUT equation.
     std::vector<std::string> splitVector;
     boost::algorithm::split(splitVector, configValue, 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
     gLUTEquationLeft = splitVector[0];
     std::string equationRight = splitVector[1];
 
     // Store the frames for LUT setting constant 1. XOR with these frames give NOT functionality.
     std::string lutEquationForOne = gLUTEquationLeft + "=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(elementName, lutEquationForOne, elementMap)) {
         gcurrentConfigBitMap = elementMap[elementName];
         std::vector<uint32_t> bitAddressesForOne = gcurrentConfigBitMap[lutEquationForOne];
 
         gCurrentReferenceFrameIndex = bitAddressesForOne[0] >> 16;
         gCUrrentReferenceWordIndex = (bitAddressesForOne[0] & 0x0000FF00) >> 8;
 
         gLUTWordsForOne.clear();
         gLUTWordsForOne.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);
 
             gLUTWordsForOne[frameIndex - gCurrentReferenceFrameIndex] = gLUTWordsForOne[frameIndex
                 - gCurrentReferenceFrameIndex] | frameWord;
         }
 
         // Set the string to be scanned
         yy_scan_string(equationRight.c_str());
         // Call the Bison parse function
         int parseResult = yyparse();
 
         if(parseResult != 0) {
             std::cout << "Error in parsing LUT equation " << configValue << std::endl;
             exit(-1);
         }
 
         // Build bit addresses out of the last frame in gStackOfFrames
         std::vector<uint32_t> combinedLUTWords = gStackOfFrames[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(((gCurrentReferenceFrameIndex + frameOffset) << 16)
                         | (gCUrrentReferenceWordIndex << 8) | bitIndex);
                 }
                 tempWord = tempWord >> 1;
                 bitIndex++;
             }
         }
 
         MergeCompressedBitToMainBits(bitAddresses, outBitstream, frameBlocks, wordOffset);
         gStackOfFrames.clear();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void mergeLutRamOrRomBits	(	const std::string &	elementName,
		const std::string &	configVal,
		Bitstream &	outBitstream,
		VirtexFrameBlocks &	frameBlocks,
		uint32_t	wordOffset,
		TiletypeElementMap &	library
	)

Definition at line 628 of file Xdl2Bit.cpp.

                                  {
 
     // Since memory content are similar for SLICEL and SLICEM,
     // they are stored in library under element name SLICE
     ElementConfigMap &elementMap = library["SLICE"];
 
     // Get the right hand side and lefthand side of the LUT equation.
     std::vector<std::string> splitVector;
     boost::algorithm::split(splitVector, configVal, boost::algorithm::is_any_of("="));
     // Remove the first two characters - 0x - from the hex value
     std::string memoryValue = splitVector[1].substr(2);
 
     if(memoryValue.length() != 8 && memoryValue.length() != 16) {
         std::cout << "Error: Illegal configuration of element " << elementName << 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
     std::string elementNameForMemoryMode = elementName.substr(0, 1);
     std::vector<uint32_t> bitAddressesForROM;
 
     if(!elementAndConfigExistInLibrary(elementNameForMemoryMode, "ROM", elementMap))
         return;
 
     bitAddressesForROM = elementMap[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++) {
 
         std::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;
                 std::stringstream ssConfigBitIndex;
                 ssConfigBitIndex << memoryAddress;
                 bitAddresses.push_back(bitAddressesForROM[memoryAddress]);
             }
             hexDigit = hexDigit << 1;
         }
     }
     MergeCompressedBitToMainBits(bitAddresses, outBitstream, frameBlocks, wordOffset, 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void mergeRambInitBits	(	const std::string &	configVal,
		uint32_t	memoryInitRow,
		Bitstream &	outBitstream,
		VirtexFrameBlocks &	frameBlocks,
		uint32_t	wordOffset,
		const vector< uint32_t > &	bitAddresses,
		uint32_t	block
	)

Definition at line 753 of file Xdl2Bit.cpp.

                                                   {
 
     vector<uint32_t> bitAddresses; // vector to hold bit addresses of set memory bits
 
     uint32_t configValLength = configVal.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++) {
         std::stringstream sshexChar;
         sshexChar << std::hex << configVal[configValLength - charIndex - 1];
         uint32_t hexDigit;
         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 = memoryInitRow * numBitsPerConfig + configBitIndex;
 
                 bitAddresses.push_back(ramBitAddress[memoryAddress]);
             }
             hexDigit = hexDigit >> 1;
         }
     }
     MergeCompressedBitToMainBits(bitAddresses, outBitstream, frameBlocks, wordOffset, block);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static TiletypeElementMap populateLibraryMap ( boost::filesystem::path libDBPath )

static

Definition at line 888 of file Xdl2Bit.cpp.

                                                                             {
 
     TiletypeElementMap tileMap;
     std::ifstream libDB(libDBPath.string().c_str(), std::ios::binary);
     if(!libDB.good()) {
         std::cout << "Could not open DB file " << libDBPath.string() << std::endl;
         libDB.exceptions(std::ios::failbit);
         exit(-1);
     }
     std::cout << "Opened DB file " << libDBPath.string() << std::endl;
     char buffer[1024];
     libDB.read(buffer, 16);
     buffer[16] = '\0';
     std::string libDBSanity(buffer);
     std::cout << "Sanity string " << libDBSanity << std::endl;
     if(libDBSanity != "<<<<BITLIBDB>>>>") {
         std::cout << "This file seems to be currupt- " << libDBPath.string() << std::endl;
         exit(-1);
     }
     uint32_t tileTypeCount = 0;
     libDB.read((char *) &tileTypeCount, sizeof(uint32_t));
     std::cout << "Tile type count " << tileTypeCount << std::endl;
     for(uint32_t tileIndex = 0; tileIndex < tileTypeCount; tileIndex++) {
         uint32_t tileNameCharCount = 0;
         libDB.read((char *) &tileNameCharCount, 4);
         libDB.read(buffer, tileNameCharCount);
         buffer[tileNameCharCount] = '\0';
         std::string tileType(buffer);
         uint32_t elementCount = 0;
         libDB.read((char *) &elementCount, 4);
         //      std::cout << "Tile type " << tileType << ". Element count " << elementCount << std::endl;
 
         ElementConfigMap elementMap;
 
         // Iterate over the elements
         for(uint32_t elementIndex = 0; elementIndex < elementCount; elementIndex++) {
             // Get element name char count
             uint32_t elementCharCount = 0;
             libDB.read((char *) &elementCharCount, 4);
             libDB.read(buffer, elementCharCount);
             buffer[elementCharCount] = '\0';
             std::string element(buffer);
 
             uint32_t configCount = 0;
             libDB.read((char *) &configCount, 4);
 
             //          std::cout << "   Element " << element << ". Config count " << configCount << std::endl;
 
             ConfigBitMap configMap;
 
             // Iterate over configs
             for(uint32_t configIndex = 0; configIndex < configCount; configIndex++) {
                 uint32_t configCharCount = 0;
                 libDB.read((char *) &configCharCount, 4);
                 //              std::cout << "\tConfig char count " << configCharCount;
                 libDB.read(buffer, configCharCount);
                 buffer[configCharCount] = '\0';
                 std::string config(buffer);
                 //              std::cout << "\t" << config << std::endl;
 
                 // Read the compressed word count
                 uint32_t wordCount = 0;
                 libDB.read((char *) &wordCount, 4);
                 std::vector<uint32_t> words;
                 uint32_t word;
                 for(uint32_t i = 0; i < wordCount; i++) {
                     libDB.read((char *) &word, 4);
 
                     words.push_back(word);
                 }
                 configMap[config] = words;
             }
             elementMap[element] = configMap;
 
         }
         tileMap[tileType] = elementMap;
 
     }
     return tileMap;
 }

Here is the caller graph for this function:

void PushFrameToStack ( std::string literal )

Definition at line 784 of file Xdl2Bit.cpp.

                                          {
 
     bool debug = false;
 
     if(debug) {
         std::cout << "In PushFrameToStack " << literal << std::endl;
     }
 
     std::vector<uint32_t> bitAddresses = gcurrentConfigBitMap[gLUTEquationLeft + "=" + literal];
 
     // 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 - gCurrentReferenceFrameIndex] = lutWords[frameIndex
             - gCurrentReferenceFrameIndex] | 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;
     }
 
     gStackOfFrames.push_back(lutWords);
 
 }

bool siteExistsInLibrary	(	const std::string &	siteType,
		TiletypeElementMap &	library
	)

Definition at line 116 of file Xdl2Bit.cpp.

                                                                                  {
     TiletypeElementMap::iterator pLibrary = library.find(siteType);
     return (pLibrary != library.end());
 }

Here is the caller graph for this function:

Variable Documentation

ConfigBitMap gcurrentConfigBitMap

static

Definition at line 41 of file Xdl2Bit.cpp.

uint32_t gCurrentReferenceFrameIndex

static

Definition at line 37 of file Xdl2Bit.cpp.

uint32_t gCUrrentReferenceWordIndex

static

Definition at line 38 of file Xdl2Bit.cpp.

std::string gLUTEquationLeft

static

Definition at line 42 of file Xdl2Bit.cpp.

vector<vector<uint32_t> > gStackOfFrames

static

Definition at line 36 of file Xdl2Bit.cpp.

Functions

Variables

Detailed Description

Function Documentation

Variable Documentation