inlineOutput.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	outputBITheader (std::ofstream &fout, Endianness e)
void	outputBITheader16bString (std::ofstream &fout, Endianness e, std::string s)
void	outputBITheaderLengthField (std::ofstream &fout, Endianness e)
void	outputCAPheaderConstant (std::ofstream &fout, Endianness e)
void	updateDateAndTime ()
void	writeBitstreamBIN (std::ofstream &fout, Rect2D cmdRect)
void	writeBitstreamBIT (std::ofstream &fout, Rect2D cmdRect)
void	writeBitstreamMain (std::ofstream &fout, Rect2D cmdRect)
void	writeBitstreamMainEmptySLR (std::ofstream &fout, int slr)
void	writeBitstreamMainSingleRegion (std::ofstream &fout, int slr, Rect2D writeRect)
void	writeBitstreamMainSingleSLR (std::ofstream &fout, int slr, Rect2D cmdRect)

Function Documentation

outputBITheader()

void outputBITheader ( std::ofstream &  fout, Endianness  e  )

inline

Definition at line 34 of file inlineOutput.h.

{
    log("Generating bitstream header in " + Endian::to_string(e) + ".");
    outputBITheader16bString(fout, e, std::string("\x0F\xF0\x0F\xF0\x0F\xF0\x0F\xF0"));
    FileIO::write16(fout, 1, e);//16-bit BE value = 1
    FileIO::write8(fout, 'a', e);
    outputBITheader16bString(fout, e, designName);
    FileIO::write8(fout, 'b', e);//8-bit BE value = 'b'
    outputBITheader16bString(fout, e, partName);
    FileIO::write8(fout, 'c', e);//8-bit BE value = 'c'
    outputBITheader16bString(fout, e, fileDate);
    FileIO::write8(fout, 'd', e);//8-bit BE value = 'd'
    outputBITheader16bString(fout, e, fileTime);
    FileIO::write8(fout, 'e', e);//8-bit BE value = 'e'
    headerLocationOfRemainingFileLength = fout.tellp();
    FileIO::write32(fout, 0, e);//32-bit BE value = 0 representing remaining file size. needs to be fixed later
}

References outputBITheader16bString(), Endian::to_string(), FileIO::write16(), FileIO::write32(), and FileIO::write8().

Referenced by XilinxSeries7::assemblerAsmToBit(), XilinxUltraScale::assemblerAsmToBit(), XilinxUltraScalePlus::assemblerAsmToBit(), and writeBitstreamBIT().

Here is the call graph for this function:

Here is the caller graph for this function:

outputBITheader16bString()

void outputBITheader16bString ( std::ofstream &  fout, Endianness  e, std::string  s  )

inline

Definition at line 29 of file inlineOutput.h.

                                                                                  {
    FileIO::write16(fout, static_cast<uint16_t>(s.size() + 1), e);
    FileIO::writeString(fout, s, e);
}

References FileIO::write16(), and FileIO::writeString().

Referenced by outputBITheader().

Here is the call graph for this function:

Here is the caller graph for this function:

outputBITheaderLengthField()

void outputBITheaderLengthField ( std::ofstream &  fout, Endianness  e  )

inline

Definition at line 52 of file inlineOutput.h.

{
    std::streamoff finalFileSize = fout.tellp();
    std::streamoff reportDiff = finalFileSize - (headerLocationOfRemainingFileLength + 4);
    fout.seekp(headerLocationOfRemainingFileLength);
    FileIO::write32(fout, static_cast<uint32_t>(reportDiff), e);
}

References FileIO::write32().

Referenced by XilinxSeries7::assemblerAsmTo(), XilinxUltraScale::assemblerAsmTo(), XilinxUltraScalePlus::assemblerAsmTo(), and writeBitstreamBIT().

Here is the call graph for this function:

Here is the caller graph for this function:

outputCAPheaderConstant()

void outputCAPheaderConstant ( std::ofstream &  fout, Endianness  e  )

inline

Definition at line 60 of file inlineOutput.h.

{
    for(int i = 0 ; i < 16 ; i++) // 64 bytes of 0xFF
        FileIO::write32(fout, 0xFFFFFFFF, e);//32-bit BE value = 0xFFFFFFFF
    FileIO::write32(fout, 0x000000BB, e);
    FileIO::write32(fout, 0x11220044, e);
    FileIO::write32(fout, 0xFFFFFFFF, e);
    FileIO::write32(fout, 0xFFFFFFFF, e);
    FileIO::write32(fout, XCAP_getSyncInstruction(), e);
}

References FileIO::write32(), and XCAP_getSyncInstruction().

Referenced by XilinxSeries7::assemblerAsmTo(), XilinxUltraScale::assemblerAsmTo(), XilinxUltraScalePlus::assemblerAsmTo(), writeBitstreamMainEmptySLR(), and writeBitstreamMainSingleSLR().

Here is the call graph for this function:

Here is the caller graph for this function:

updateDateAndTime()

void updateDateAndTime ( )

inline

Definition at line 17 of file inlineOutput.h.

{
    time_t timestamp = time(0);
    struct tm  tstruct;
    char       buf[80];
    tstruct = *localtime(&timestamp);
    strftime(buf, sizeof(buf), "%Y/%m/%d", &tstruct);
    fileDate = std::string(buf);
    strftime(buf, sizeof(buf), "%H:%M:%S", &tstruct);
    fileTime = std::string(buf);
}

Referenced by XilinxSeries7::disassemblerBinToAsm(), XilinxUltraScale::disassemblerBinToAsm(), XilinxUltraScalePlus::disassemblerBinToAsm(), and writeBitstreamBIT().

Here is the caller graph for this function:

writeBitstreamBIN()

void writeBitstreamBIN ( std::ofstream &  fout, Rect2D  cmdRect  )

inline

Definition at line 207 of file inlineOutput.h.

{
    outputBitstreamGlobalHeaderSequence(fout, (!selectedOptions.partialNotFull), loadedBitstreamEndianness);
    writeBitstreamMain(fout, cmdRect);
    outputBitstreamGlobalFooterSequence(fout, (!selectedOptions.partialNotFull), loadedBitstreamEndianness);
}

References writeBitstreamMain().

Referenced by XilinxSeries7::writeBitstream(), XilinxUltraScale::writeBitstream(), and XilinxUltraScalePlus::writeBitstream().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitstreamBIT()

void writeBitstreamBIT ( std::ofstream &  fout, Rect2D  cmdRect  )

inline

Definition at line 189 of file inlineOutput.h.

{
    //if needing to ensure all .bit files MUST be bigendian, uncomment next line
    //ensureSelectedEndianness(Endianness::BE);
    if(selectedOptions.partialNotFull)
        designName.append(";PARTIAL=TRUE");
    designName.append(";bytemanVersion=").append(VERSION).append(":").append(VERSION_BUILD);
    
    updateDateAndTime();
    outputBITheader(fout, loadedBitstreamEndianness);//.bit always big endian
    
    outputBitstreamGlobalHeaderSequence(fout, (!selectedOptions.partialNotFull), loadedBitstreamEndianness);
    writeBitstreamMain(fout, cmdRect);
    outputBitstreamGlobalFooterSequence(fout, (!selectedOptions.partialNotFull), loadedBitstreamEndianness);
    
    outputBITheaderLengthField(fout, loadedBitstreamEndianness);
}

References outputBITheader(), outputBITheaderLengthField(), updateDateAndTime(), and writeBitstreamMain().

Referenced by XilinxSeries7::writeBitstream(), XilinxUltraScale::writeBitstream(), and XilinxUltraScalePlus::writeBitstream().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitstreamMain()

void writeBitstreamMain ( std::ofstream &  fout, Rect2D  cmdRect  )

inline

Definition at line 152 of file inlineOutput.h.

{
    bool overlap[MAX_SLRS];
    for(int slr = 0 ; slr < numberOfSLRs ; slr++){
        //Check if there is overlap between selected regions and the current SLR.
        Rect2D slrCoordsRect = {{0, 0}, {0, 0}};
        slrCoordsRect.position.row = SLRinfo[slr].fromRow * CLB_PER_CLOCK_REGION;
        slrCoordsRect.size.row = (SLRinfo[slr].toRow - SLRinfo[slr].fromRow + 1) * CLB_PER_CLOCK_REGION;
        slrCoordsRect.size.col = maxNumberOfCols;
        overlap[slr] = false;
        if(selectedOptions.partialNotFull){
            for (Rect2D selRect : regionSelection) {
                if(!rect::empty(rect::getOverlap(selRect, slrCoordsRect))){
                    overlap[slr] = true;
                    break;
                }
            }
            if(!rect::empty(rect::getOverlap(cmdRect, slrCoordsRect)))
                overlap[slr] = true;
        } else {// full bitstream output
            overlap[slr] = true;
        }
    }
    for(int slr = 0 ; slr < numberOfSLRs ; slr++){
        if(overlap[slr])
            writeBitstreamMainSingleSLR(fout, slr, cmdRect);
        else
            writeBitstreamMainEmptySLR(fout, slr);
    }
    for(int slr = numberOfSLRs - 2 ; slr >= 0 ; slr--){
        if(overlap[slr])
            outputBitstreamSLRWrapUpSequence(fout, slr, (!selectedOptions.partialNotFull), loadedBitstreamEndianness);
        else
            outputBitstreamEmptySLRWrapUpSequence(fout, slr, false, loadedBitstreamEndianness);
    }
}

References Coord2D::col, rect::empty(), rect::getOverlap(), Rect2D::position, Coord2D::row, Rect2D::size, writeBitstreamMainEmptySLR(), and writeBitstreamMainSingleSLR().

Referenced by writeBitstreamBIN(), and writeBitstreamBIT().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitstreamMainEmptySLR()

void writeBitstreamMainEmptySLR ( std::ofstream &  fout, int  slr  )

inline

Definition at line 71 of file inlineOutput.h.

{
    outputCAPheaderConstant(fout, loadedBitstreamEndianness);
    outputBitstreamEmptySLRHeaderSequence(fout, slr, false, loadedBitstreamEndianness);
}

References outputCAPheaderConstant().

Referenced by writeBitstreamMain().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitstreamMainSingleRegion()

void writeBitstreamMainSingleRegion ( std::ofstream &  fout, int  slr, Rect2D  writeRect  )

inline

Definition at line 77 of file inlineOutput.h.

{
    void *blankFrame = calloc(WORDS_PER_FRAME, 4);
    
    if(rect::empty(writeRect)) // If output region is empty, just return
        return;
    int srcR  = writeRect.position.row / CLB_PER_CLOCK_REGION;
    int sizeR = writeRect.size.row / CLB_PER_CLOCK_REGION;
    for(int r = 0 ; r < sizeR ; r++){
        int fromCol = writeRect.position.col;
        int toCol = writeRect.position.col + writeRect.size.col;
        if(selectedOptions.skipUnused){
            for( ; (fromCol < numberOfCols[r] && LUT_isFrameUnusedForResourceLetter[(uint8_t)resourceString[srcR + r][fromCol]]) ; fromCol++);
            for( ; (toCol > 0 && LUT_isFrameUnusedForResourceLetter[(uint8_t)resourceString[srcR + r][toCol]]) ; toCol--);
            if(fromCol >= toCol)
                continue;
        }
        if(selectedOptions.clb){
            int framesToWrite = numberOfFramesBeforeCol[r][toCol]-numberOfFramesBeforeCol[r][fromCol];
            uint32_t farValue = XCAP_getFAR(slr, BLOCKTYPE_LOGIC, srcR + r, fromCol, 0);
            if(selectedOptions.blank){
                XCAP_writeRegister(fout, XCAP::Register::FAR, farValue, loadedBitstreamEndianness);
                XCAP_writeCommand(fout, XCAP::Command::WCFG, loadedBitstreamEndianness);
                XCAP_writeNOP(fout, 1, 0, loadedBitstreamEndianness);
                XCAP_writeFDRI(fout, ((framesToWrite + 1)*WORDS_PER_FRAME), loadedBitstreamEndianness);
                for(int i = 0 ; i <= framesToWrite ; i++)
                    fout.write((char*)blankFrame, WORDS_PER_FRAME * 4);
            }//selectedOptions.blank
            XCAP_writeRegister(fout, XCAP::Register::FAR, farValue, loadedBitstreamEndianness);
            XCAP_writeCommand(fout, XCAP::Command::WCFG, loadedBitstreamEndianness);
            XCAP_writeNOP(fout, 1, 0, loadedBitstreamEndianness);
            XCAP_writeFDRI(fout, ((framesToWrite + 1)*WORDS_PER_FRAME), loadedBitstreamEndianness);
            
            fout.write((char*)&bitstreamCLB[srcR + r][fromCol][0], framesToWrite * WORDS_PER_FRAME * 4);
            fout.write((char*)blankFrame, WORDS_PER_FRAME * 4);
        }//selectedOptions.clb
        if(selectedOptions.bram){
            int framesToWrite = FRAMES_PER_BRAM_CONTENT_COLUMN * (numberOfBRAMsBeforeCol[r][toCol]-numberOfBRAMsBeforeCol[r][fromCol]);
            if(framesToWrite > 0) {
                uint32_t farValue = XCAP_getFAR(slr, BLOCKTYPE_BLOCKRAM, srcR + r, numberOfBRAMsBeforeCol[r][fromCol], 0);
                XCAP_writeRegister(fout, XCAP::Register::FAR, farValue, loadedBitstreamEndianness);
                XCAP_writeCommand(fout, XCAP::Command::WCFG, loadedBitstreamEndianness);
                XCAP_writeNOP(fout, 1, 0, loadedBitstreamEndianness);
                XCAP_writeFDRI(fout, ((framesToWrite + 1)*WORDS_PER_FRAME), loadedBitstreamEndianness);
                
                fout.write((char*)&bitstreamBRAM[srcR + r][numberOfBRAMsBeforeCol[r][fromCol]][0], framesToWrite * WORDS_PER_FRAME * 4);
                fout.write((char*)blankFrame, WORDS_PER_FRAME * 4);
            }
        }//selectedOptions.bram
    }
}

References Coord2D::col, rect::empty(), XCAP::FAR, Rect2D::position, Coord2D::row, Rect2D::size, XCAP::WCFG, XCAP_getFAR(), XCAP_writeCommand(), XCAP_writeFDRI(), XCAP_writeNOP(), and XCAP_writeRegister().

Referenced by writeBitstreamMainSingleSLR().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitstreamMainSingleSLR()

void writeBitstreamMainSingleSLR ( std::ofstream &  fout, int  slr, Rect2D  cmdRect  )

inline

Definition at line 129 of file inlineOutput.h.

{
    Rect2D slrCoordsRect = {{0, 0}, {0, 0}};
    slrCoordsRect.position.row = SLRinfo[slr].fromRow * CLB_PER_CLOCK_REGION;
    slrCoordsRect.size.row = (SLRinfo[slr].toRow - SLRinfo[slr].fromRow + 1) * CLB_PER_CLOCK_REGION;
    slrCoordsRect.size.col = maxNumberOfCols;
    
    outputCAPheaderConstant(fout, loadedBitstreamEndianness);
    outputBitstreamSLRHeaderBitstreamSequence(fout, slr, (!selectedOptions.partialNotFull), loadedBitstreamEndianness);
    
    if(selectedOptions.partialNotFull){
        for (Rect2D selRect : regionSelection) {
            writeBitstreamMainSingleRegion(fout, slr, rect::getOverlap(selRect, slrCoordsRect));
        }
        writeBitstreamMainSingleRegion(fout, slr, rect::getOverlap(cmdRect, slrCoordsRect));
    } else {// full
        writeBitstreamMainSingleRegion(fout, slr, slrCoordsRect);
    }
    
    outputBitstreamSLRFooterBitstreamSequence(fout, slr, (!selectedOptions.partialNotFull), loadedBitstreamEndianness);
    outputBitstreamSLRHeaderAfterBitstreamSequence(fout, slr, (!selectedOptions.partialNotFull), loadedBitstreamEndianness);
}

References Coord2D::col, rect::getOverlap(), outputCAPheaderConstant(), Rect2D::position, Coord2D::row, Rect2D::size, and writeBitstreamMainSingleRegion().

Referenced by writeBitstreamMain().

Here is the call graph for this function:

Here is the caller graph for this function: