udp_app_flash

This module implements a set of UDP-oriented tests and functions. More...

Collaboration diagram for udp_app_flash:

Files
file	udp_app_flash.cpp
	: UDP Application Flash (UAF)
file	udp_app_flash.hpp
	: UDP Application Flash (UAF)
file	udp_app_flash_top.cpp
	: Top level with I/O ports for UDP Application Flash (UAF)
file	udp_app_flash_top.hpp
	: Top of UDP Application Flash (UAF)
file	simu_udp_app_flash_env.cpp
	: Simulation environment for the UDP Application Flash (UAF).
file	test_udp_app_flash.cpp
	: Testbench for UDP Application Flash (UAF).
file	test_udp_app_flash.hpp
	: Testbench for the UDP Application Flash (UAF).
file	test_udp_app_flash_top.cpp
	: Testbench for toplevel of the UDP Application Flash.
file	test_udp_app_flash_top.hpp
	: Testbench for toplevel of the UDP Application Flash.

Macros
#define	THIS_NAME   "UAF"
#define	TRACE_OFF   0x0000
#define	TRACE_ESF   1 << 1
#define	TRACE_RXP   1 << 2
#define	TRACE_TXP   1 << 3
#define	TRACE_ALL   0xFFFF
#define	DEBUG_LEVEL   (TRACE_OFF)
#define	MTU   1500
#define	ECHO_PATH_THRU_PORT   8803
#define	THIS_NAME   "SIM"
#define	TRACE_OFF   0x0000
#define	TRACE_USIF   1 << 1
#define	TRACE_UAF   1 << 2
#define	TRACE_CGTF   1 << 3
#define	TRACE_DUMTF   1 << 4
#define	TRACE_ALL   0xFFFF
#define	DEBUG_LEVEL   (TRACE_OFF)
#define	TB_MAX_CYCLES   500
#define	TB_GRACE_TIME   500
#define	VALID   true
#define	UNVALID   false
#define	DEBUG_TRACE   true
#define	ENABLED   (ap_uint<1>)1
#define	DISABLED   (ap_uint<1>)0
#define	DEFAULT_FPGA_IP4_ADDR   0x0A0CC801
#define	DEFAULT_FPGA_LSN_PORT   0x2263
#define	DEFAULT_FPGA_SND_PORT   0xA263
#define	DEFAULT_HOST_IP4_ADDR   0x0A0CC832
#define	DEFAULT_HOST_LSN_PORT   0x80
#define	DEFAULT_HOST_SND_PORT   0x8080
#define	DEFAULT_DATAGRAM_LEN   32
#define	THIS_NAME   "TB_UAF"
#define	THIS_NAME   "TB_UAF_TOP"

Enumerations
enum	EchoCtrl {   ECHO_PATH_THRU = 0 , ECHO_STORE_FWD = 1 , ECHO_OFF = 2 , ECHO_PATH_THRU = 0 ,   ECHO_STORE_FWD = 1 , ECHO_OFF = 2 , ECHO_PATH_THRU = 0 , ECHO_STORE_FWD = 1 ,   ECHO_OFF = 2 , ECHO_PATH_THRU = 0 , ECHO_STORE_FWD = 1 , ECHO_OFF = 2 ,   ECHO_PATH_THRU = 0 , ECHO_STORE_FWD = 1 , ECHO_OFF = 2 , ECHO_PATH_THRU = 0 ,   ECHO_STORE_FWD = 1 , ECHO_OFF = 2 , ECHO_PATH_THRU = 0 , ECHO_STORE_FWD = 1 ,   ECHO_OFF = 2 , ECHO_STORE_FWD = 0 , ECHO_PATH_THRU = 1 , ECHO_CTRL_DISABLED = 0 ,   ECHO_PATH_THRU = 1 , ECHO_STORE_FWD = 2 , ECHO_OFF = 3 }

Functions
void	stepDut ()
	Run a single iteration of the DUT model. More...
bool	setInputDataStream (stream< UdpWord > &sDataStream, const string dataStreamName, const string inpFileName)
	Initialize an input data stream from a file. More...
bool	readDataStream (stream< UdpWord > &sDataStream, UdpWord *udpWord)
	Read data from a stream. More...
bool	dumpDataToFile (UdpWord *udpWord, ofstream &outFileStream)
	Dump a data word to a file. More...
bool	getOutputDataStream (stream< UdpWord > &sDataStream, const string dataStreamName, const string outFileName)
	Fill an output file with data from an output stream. More...
void	pUdpEchoStoreAndForward (CmdBit *piSHL_Enable, stream< UdpAppData > &siRXp_Data, stream< UdpAppMeta > &siRXp_Meta, stream< UdpAppDLen > &siRXp_DLen, stream< UdpAppData > &soTXp_Data, stream< UdpAppMeta > &soTXp_Meta, stream< UdpAppDLen > &soTXp_DLen)
	Echo loopback between the Rx and Tx ports of the UDP connection. More...
void	pUdpTxPath (CmdBit *piSHL_Mmio_Enable, stream< UdpAppData > &siEPt_Data, stream< UdpAppMeta > &siEPt_Meta, stream< UdpAppDLen > &siEPt_DLen, stream< UdpAppData > &siESf_Data, stream< UdpAppMeta > &siESf_Meta, stream< UdpAppDLen > &siESf_DLen, stream< UdpAppData > &soUSIF_Data, stream< UdpAppMeta > &soUSIF_Meta, stream< UdpAppDLen > &soUSIF_DLen)
	Transmit Path - From THIS to USIF. More...
void	pUdpRxPath (CmdBit *piSHL_Mmio_Enable, stream< UdpAppData > &siUSIF_Data, stream< UdpAppMeta > &siUSIF_Meta, stream< UdpAppDLen > &siUSIF_DLen, stream< UdpAppData > &soEPt_Data, stream< UdpAppMeta > &soEPt_Meta, stream< UdpAppDLen > &soEPt_DLen, stream< UdpAppData > &soESf_Data, stream< UdpAppMeta > &soESf_Meta, stream< UdpAppDLen > &soESf_DLen)
	UDP Receive Path (RXp) - From SHELL->ROLE/USIF to THIS. More...
void	udp_app_flash (CmdBit *piSHL_Mmio_En, stream< UdpAppData > &siUSIF_Data, stream< UdpAppMeta > &siUSIF_Meta, stream< UdpAppDLen > &siUSIF_DLen, stream< UdpAppData > &soUSIF_Data, stream< UdpAppMeta > &soUSIF_Meta, stream< UdpAppDLen > &soUSIF_DLen)
	Main process of the UDP Application Flash (UAF) More...
void	udp_app_flash_top (CmdBit *piSHL_Mmio_En, stream< UdpAppData > &siUSIF_Data, stream< UdpAppMeta > &siUSIF_Meta, stream< UdpAppDLen > &siUSIF_DLen, stream< UdpAppData > &soUSIF_Data, stream< UdpAppMeta > &soUSIF_Meta, stream< UdpAppDLen > &soUSIF_DLen)
	Top of UDP Application Flash (UAF) More...
void	stepSim ()
	Increment the simulation counter. More...
void	increaseSimTime (unsigned int cycles)
	Increase the simulation time of the testbench. More...
bool	readDatagramFromFile (const char *myName, SimUdpDatagram &appDatagram, ifstream &ifsData, SocketPair &sockPair, queue< UdpAppMeta > &udpMetaQueue, queue< UdpAppDLen > &udpDLenQueue, int &inpChunks, int &inpDgrms, int &inpBytes)
	Read a datagram from a DAT file. More...
int	createGoldenTxFiles (EchoCtrl tbCtrlMode, string inpData_FileName, queue< UdpAppMeta > &udpMetaQueue, queue< UdpAppDLen > &udpDLenQueue, string outData_GoldName, string outMeta_GoldName, string outDLen_GoldName)
	Create the golden UDP Tx files from an input test file. More...
int	createUdpRxTraffic (stream< AxisApp > &ssData, const string ssDataName, stream< UdpAppMeta > &ssMeta, const string ssMetaName, stream< UdpAppDLen > &ssDLen, const string ssMDLenName, string datFile, queue< UdpAppMeta > &metaQueue, queue< UdpAppDLen > &dlenQueue, int &nrFeededChunks)
	Create the UDP Rx traffic as streams from an input test file. More...
bool	drainUdpMetaStreamToFile (stream< UdpAppMeta > &ss, string ssName, string datFile, int &nrChunks, int &nrFrames, int &nrBytes)
	Empty an UdpMeta stream to a DAT file. More...
bool	drainUdpDLenStreamToFile (stream< UdpAppDLen > &ss, string ssName, string datFile, int &nrChunks, int &nrFrames, int &nrBytes)
	Empty a UdpDLen stream to a DAT file. More...
int	main (int argc, char *argv[])
	Main function for the test of the UDP Application Flash (UAF). More...

Variables
bool	gTraceEvent
unsigned int	gSimCycCnt
bool	gTraceEvent
bool	gFatalError
unsigned int	gMaxSimCycles
unsigned int	gSimCycCnt
unsigned int	gMaxSimCycles
unsigned int	gSimCycCnt = 0
bool	gTraceEvent = false
bool	gFatalError = false
unsigned int	gMaxSimCycles = 500 + 500
unsigned int	gSimCycCnt
unsigned int	gMaxSimCycles
unsigned int	gSimCycCnt = 0
bool	gTraceEvent = false
bool	gFatalError = false
unsigned int	gMaxSimCycles = 500 + 500

Detailed Description

This module implements a set of UDP-oriented tests and functions.

Macro Definition Documentation

DEBUG_LEVEL [1/2]

#define DEBUG_LEVEL   (TRACE_OFF)

Definition at line 67 of file udp_app_flash.cpp.

DEBUG_LEVEL [2/2]

#define DEBUG_LEVEL   (TRACE_OFF)

Definition at line 68 of file simu_udp_app_flash_env.cpp.

DEBUG_TRACE

#define DEBUG_TRACE   true

Definition at line 50 of file simu_udp_app_flash_env.hpp.

DEFAULT_DATAGRAM_LEN

#define DEFAULT_DATAGRAM_LEN   32

Definition at line 69 of file simu_udp_app_flash_env.hpp.

DEFAULT_FPGA_IP4_ADDR

#define DEFAULT_FPGA_IP4_ADDR   0x0A0CC801

Definition at line 62 of file simu_udp_app_flash_env.hpp.

DEFAULT_FPGA_LSN_PORT

#define DEFAULT_FPGA_LSN_PORT   0x2263

Definition at line 63 of file simu_udp_app_flash_env.hpp.

DEFAULT_FPGA_SND_PORT

#define DEFAULT_FPGA_SND_PORT   0xA263

Definition at line 64 of file simu_udp_app_flash_env.hpp.

DEFAULT_HOST_IP4_ADDR

#define DEFAULT_HOST_IP4_ADDR   0x0A0CC832

Definition at line 65 of file simu_udp_app_flash_env.hpp.

DEFAULT_HOST_LSN_PORT

#define DEFAULT_HOST_LSN_PORT   0x80

Definition at line 66 of file simu_udp_app_flash_env.hpp.

DEFAULT_HOST_SND_PORT

#define DEFAULT_HOST_SND_PORT   0x8080

Definition at line 67 of file simu_udp_app_flash_env.hpp.

DISABLED

#define DISABLED   (ap_uint<1>)0

Definition at line 53 of file simu_udp_app_flash_env.hpp.

ECHO_PATH_THRU_PORT

#define ECHO_PATH_THRU_PORT   8803

Definition at line 63 of file udp_app_flash.hpp.

ENABLED

#define ENABLED   (ap_uint<1>)1

Definition at line 52 of file simu_udp_app_flash_env.hpp.

MTU

#define MTU   1500

Definition at line 51 of file udp_app_flash.hpp.

TB_GRACE_TIME

#define TB_GRACE_TIME   500

Definition at line 47 of file simu_udp_app_flash_env.hpp.

TB_MAX_CYCLES

#define TB_MAX_CYCLES   500

Definition at line 46 of file simu_udp_app_flash_env.hpp.

THIS_NAME [1/4]

#define THIS_NAME   "UAF"

Definition at line 60 of file udp_app_flash.cpp.

THIS_NAME [2/4]

#define THIS_NAME   "SIM"

HELPERS FOR THE DEBUGGING TRACES .e.g: DEBUG_LEVEL = (TRACE_USIF | TRACE_UAF)

Definition at line 60 of file simu_udp_app_flash_env.cpp.

THIS_NAME [3/4]

#define THIS_NAME   "TB_UAF"

Definition at line 52 of file test_udp_app_flash.cpp.

THIS_NAME [4/4]

#define THIS_NAME   "TB_UAF_TOP"

Definition at line 52 of file test_udp_app_flash_top.cpp.

TRACE_ALL [1/2]

#define TRACE_ALL   0xFFFF

Definition at line 66 of file udp_app_flash.cpp.

TRACE_ALL [2/2]

#define TRACE_ALL   0xFFFF

Definition at line 67 of file simu_udp_app_flash_env.cpp.

TRACE_CGTF

#define TRACE_CGTF   1 << 3

Definition at line 65 of file simu_udp_app_flash_env.cpp.

TRACE_DUMTF

#define TRACE_DUMTF   1 << 4

Definition at line 66 of file simu_udp_app_flash_env.cpp.

TRACE_ESF

#define TRACE_ESF   1 << 1

Definition at line 63 of file udp_app_flash.cpp.

TRACE_OFF [1/2]

#define TRACE_OFF   0x0000

Definition at line 62 of file udp_app_flash.cpp.

TRACE_OFF [2/2]

#define TRACE_OFF   0x0000

Definition at line 62 of file simu_udp_app_flash_env.cpp.

TRACE_RXP

#define TRACE_RXP   1 << 2

Definition at line 64 of file udp_app_flash.cpp.

TRACE_TXP

#define TRACE_TXP   1 << 3

Definition at line 65 of file udp_app_flash.cpp.

TRACE_UAF

#define TRACE_UAF   1 << 2

Definition at line 64 of file simu_udp_app_flash_env.cpp.

TRACE_USIF

#define TRACE_USIF   1 << 1

Definition at line 63 of file simu_udp_app_flash_env.cpp.

UNVALID

#define UNVALID   false

Definition at line 49 of file simu_udp_app_flash_env.hpp.

VALID

#define VALID   true

Definition at line 48 of file simu_udp_app_flash_env.hpp.

Enumeration Type Documentation

EchoCtrl

enum EchoCtrl

SHELL/MMIO/EchoCtrl - Config Register

Enumerator
ECHO_PATH_THRU
ECHO_STORE_FWD
ECHO_OFF
ECHO_PATH_THRU
ECHO_STORE_FWD
ECHO_OFF
ECHO_PATH_THRU
ECHO_STORE_FWD
ECHO_OFF
ECHO_PATH_THRU
ECHO_STORE_FWD
ECHO_OFF
ECHO_PATH_THRU
ECHO_STORE_FWD
ECHO_OFF
ECHO_PATH_THRU
ECHO_STORE_FWD
ECHO_OFF
ECHO_PATH_THRU
ECHO_STORE_FWD
ECHO_OFF
ECHO_STORE_FWD
ECHO_PATH_THRU
ECHO_CTRL_DISABLED
ECHO_PATH_THRU
ECHO_STORE_FWD
ECHO_OFF

Definition at line 44 of file udp_app_flash.hpp.

              {
    ECHO_CTRL_DISABLED = 0,
    ECHO_PATH_THRU     = 1,
    ECHO_STORE_FWD     = 2,
    ECHO_OFF           = 3
};

Function Documentation

createGoldenTxFiles()

int createGoldenTxFiles	(	EchoCtrl	tbCtrlMode,
		string	inpData_FileName,
		queue< UdpAppMeta > &	udpMetaQueue,
		queue< UdpAppDLen > &	udpDLenQueue,
		string	outData_GoldName,
		string	outMeta_GoldName,
		string	outDLen_GoldName
	)

Create the golden UDP Tx files from an input test file.

Parameters

[in]	tbCtrlMode	The testbench mode of operation.
[in]	inpData_FileName	The input data file to generate from.
[out]	udpMetaQueue	A ref to a container queue which holds the sequence of UDP socket-pairs.
[out]	udpDLenQueue	A ref to a container queue which holds the sequence of UDP datagram lengths.
[in]	outData_GoldName	The output datagram gold file to create.
[in]	outMeta_GoldName	The output metadata gold file to create.
[in]	outDLen_GoldName	The output data len gold file to create.

Returns

NTS_ OK if successful, otherwise NTS_KO.

Definition at line 177 of file simu_udp_app_flash_env.cpp.

{
    const char *myName  = concat3(THIS_NAME, "/", "CGTF");
 
    const Ip4Addr hostDefaultIp4Address = 0x0A0CC832;   //  10.012.200.50
    const Ip4Addr fpgaDefaultIp4Address = 0x0A0CC807;   //  10.012.200.7
    const UdpPort fpgaDefaultUdpLsnPort = ECHO_PATH_THRU_PORT;
    const UdpPort hostDefaultUdpLsnPort = fpgaDefaultUdpLsnPort;
    const UdpPort hostDefaultUdpSndPort = 32768+ECHO_PATH_THRU_PORT; // 41571
    const UdpPort fpgaDefaultUdpSndPort = hostDefaultUdpSndPort;
 
    ifstream    ifsData;
    ofstream    ofsDataGold;
    ofstream    ofsMetaGold;
    ofstream    ofsDLenGold;
 
    char        currPath[FILENAME_MAX];
    int         ret=NTS_OK;
    int         inpChunks=0,  outChunks=0;
    int         inpDgrms=0,   outDgrms=0;
    int         inpBytes=0,   outBytes=0;
 
    //-- STEP-1 : OPEN INPUT TEST FILE ----------------------------------------
    if (not isDatFile(inpData_FileName)) {
        printError(myName, "Cannot create golden files from input file \'%s\' because file is not of type \'.dat\'.\n",
                   inpData_FileName.c_str());
        return(NTS_KO);
    }
    else {
        ifsData.open(inpData_FileName.c_str());
        if (!ifsData) {
            getcwd(currPath, sizeof(currPath));
            printError(myName, "Cannot open the file: %s \n\t (FYI - The current working directory is: %s) \n",
                       inpData_FileName.c_str(), currPath);
            return(NTS_KO);
        }
    }
 
    //-- STEP-2 : OPEN THE OUTPUT GOLD FILES ----------------------------------
    remove(outData_GoldName.c_str());
    remove(outMeta_GoldName.c_str());
    remove(outDLen_GoldName.c_str());
    if (!ofsDataGold.is_open()) {
        ofsDataGold.open (outData_GoldName.c_str(), ofstream::out);
        if (!ofsDataGold) {
            printFatal(THIS_NAME, "Could not open the output gold file \'%s\'. \n",
                       outData_GoldName.c_str());
        }
    }
    if (!ofsMetaGold.is_open()) {
        ofsMetaGold.open (outMeta_GoldName.c_str(), ofstream::out);
        if (!ofsMetaGold) {
            printFatal(THIS_NAME, "Could not open the output gold file \'%s\'. \n",
                       outMeta_GoldName.c_str());
        }
    }
    if (!ofsDLenGold.is_open()) {
        ofsDLenGold.open (outDLen_GoldName.c_str(), ofstream::out);
        if (!ofsDLenGold) {
            printFatal(THIS_NAME, "Could not open the output gold file \'%s\'. \n",
                       outDLen_GoldName.c_str());
        }
    }
 
    //-- STEP-3 : READ AND PARSE THE INPUT TEST FILE --------------------------
    SockAddr  hostSock = SockAddr(hostDefaultIp4Address, hostDefaultUdpSndPort);
    SockAddr  fpgaSock = SockAddr(fpgaDefaultIp4Address, fpgaDefaultUdpLsnPort);
    int       dgmCnt = 0;
    do {
        SimUdpDatagram appDatagram(8);
        SocketPair     currSockPair(hostSock, fpgaSock);
        UdpAppDLen     udpAppDLen = 0;
        bool           endOfDgm=false;
        //-- Retrieve one APP datagram from input DAT file (can be up to 2^16-1 bytes)
        endOfDgm = readDatagramFromFile(myName, appDatagram, ifsData,
                                        currSockPair, udpMetaQueue, udpDLenQueue,
                                        inpChunks, inpDgrms, inpBytes);
        if (endOfDgm) {
            //-- Swap the IP_SA/IP_DA but keep UDP_SP/UDP/DP as is
            SocketPair goldSockPair(SockAddr(currSockPair.dst.addr, currSockPair.src.port),
                                    SockAddr(currSockPair.src.addr, currSockPair.dst.port));
            // Dump the socket pair to file
            if (tbCtrlMode == ECHO_CTRL_DISABLED) {
                writeSocketPairToFile(goldSockPair, ofsMetaGold);
                if (DEBUG_LEVEL & TRACE_CGTF) {
                    printInfo(myName, "Writing new socket-pair to gold file:\n");
                    printSockPair(myName, goldSockPair);
                }
            }
 
            // Dump the data len to file
            if (tbCtrlMode == ECHO_CTRL_DISABLED) {
                UdpAppDLen appDLen;
                if (currSockPair.dst.port == ECHO_PATH_THRU_PORT) {
                    //-- The traffic will be forwarded in 'ECHO-CUT-THRU' mode
                    // [TODO] if (dgmCnt % 2) {
                    // [TODO]     //-- Datagram counter is an ODD value
                    // [TODO]     //-- Enable the 'STREAMING-MODE' by setting 'DLen' to zero.
                    // [TODO]     appDLen = 0;
                    // [TODO] }
                    // [TODO] else {
                        appDLen = appDatagram.length() - UDP_HEADER_LEN;
                    // [TODO] }
                }
                else {
                    appDLen = appDatagram.length() - UDP_HEADER_LEN;
                }
 
                writeApUintToFile(appDLen, ofsDLenGold);
                if (DEBUG_LEVEL & TRACE_CGTF) {
                    printInfo(myName, "Writing new datagram len (%d) to gold file:\n", appDLen.to_int());
                }
            }
 
            // Dump UDP datagram payload to gold file
            if (tbCtrlMode == ECHO_CTRL_DISABLED) {
                if (appDatagram.writePayloadToDatFile(ofsDataGold) == false) {
                    printError(myName, "Failed to write UDP payload to GOLD file.\n");
                    ret = NTS_KO;
                }
                else {
                    outDgrms  += 1;
                    outChunks += appDatagram.size();
                    outBytes  += appDatagram.length();
                }
            }
            dgmCnt++;
        } // End-of:if (endOfDgm) {
 
    } while(ifsData.peek() != EOF);
 
    //-- STEP-4: CLOSE FILES
    ifsData.close();
    ofsDataGold.close();
    ofsMetaGold.close();
    ofsDLenGold.close();
 
    //-- STEP-5: PRINT RESULTS
    printInfo(myName, "Done with the creation of the golden file.\n");
    printInfo(myName, "\tProcessed %5d chunks in %4d datagrams, for a total of %6d bytes.\n",
              inpChunks, inpDgrms, inpBytes);
    printInfo(myName, "\tGenerated %5d chunks in %4d datagrams, for a total of %6d bytes.\n",
              outChunks, outDgrms, outBytes);
    return NTS_OK;
}

Here is the call graph for this function:

createUdpRxTraffic()

int createUdpRxTraffic	(	stream< AxisApp > &	ssData,
		const string	ssDataName,
		stream< UdpAppMeta > &	ssMeta,
		const string	ssMetaName,
		stream< UdpAppDLen > &	ssDLen,
		const string	ssMDLenName,
		string	datFile,
		queue< UdpAppMeta > &	metaQueue,
		queue< UdpAppDLen > &	dlenQueue,
		int &	nrFeededChunks
	)

Create the UDP Rx traffic as streams from an input test file.

Parameters

	[in/out]	ssData A ref to the data stream to set.
[in]	ssDataName	The name of the data stream to set.
	[in/out]	ssMeta A ref to the metadata stream to set.
[in]	ssMetaName	The name of the metadata stream to set.
	[in/out]	ssDLen A ref to the data len stream to set.
[in]	ssDLenName	The name of the data len stream to set.
[in]	datFileName	The path to the DAT file to read from.
[in]	metaQueue	A ref to a queue of metadata.
[in]	dlenQueue	A ref to a queue of data len.
[out]	nrChunks	A ref to the number of fed chunks.

Returns

NTS_ OK if successful, otherwise NTS_KO.

Definition at line 353 of file simu_udp_app_flash_env.cpp.

{
 
    int  nrUSIF_UAF_MetaChunks = 0;
    int  nrUSIF_UAF_MetaGrams  = 0;
    int  nrUSIF_UAF_MetaBytes  = 0;
 
    //-- STEP-1: FEED AXIS DATA STREAM FROM DAT FILE --------------------------
    int  nrDataChunks=0, nrDataGrams=0, nrDataBytes=0;
    if (feedAxisFromFile(ssData, ssDataName, datFile,
                         nrDataChunks, nrDataGrams, nrDataBytes)) {
        printInfo(THIS_NAME, "Done with the creation of UDP-Data traffic as a stream:\n");
        printInfo(THIS_NAME, "\tGenerated %d chunks in %d datagrams, for a total of %d bytes.\n\n",
                  nrDataChunks, nrDataGrams, nrDataBytes);
        nrFeededChunks = nrDataChunks;
    }
    else {
        printError(THIS_NAME, "Failed to create UDP-Data traffic as input stream. \n");
        return NTS_KO;
    }
 
    //-- STEP-2: FEED METADATA STREAM FROM QUEUE ------------------------------
    while (!metaQueue.empty()) {
        ssMeta.write(metaQueue.front());
        metaQueue.pop();
    }
 
    //-- STEP-3: FEED DATA LEN STREAM ROM QUEUE -------------------------------
    while (!dlenQueue.empty()) {
        ssDLen.write(dlenQueue.front());
        dlenQueue.pop();
    }
 
    return NTS_OK;
 
} // End-of: createUdpRxTraffic()

Here is the call graph for this function:

Here is the caller graph for this function:

drainUdpDLenStreamToFile()

bool drainUdpDLenStreamToFile	(	stream< UdpAppDLen > &	ss,
		string	ssName,
		string	datFile,
		int &	nrChunks,
		int &	nrFrames,
		int &	nrBytes
	)

Empty a UdpDLen stream to a DAT file.

Parameters

	[in/out]	ss A ref to the UDP data len to drain.
[in]	ssName	The name of the data len stream to drain.
[in]	fileName	The DAT file to write to.
	[out	nrChunks A ref to the number of written chunks.
[out]	nrFrames	A ref to the number of written AXI4 streams.
[out]	nrBytes	A ref to the number of written bytes.

Returns

NTS_OK if successful, otherwise NTS_KO.

Definition at line 472 of file simu_udp_app_flash_env.cpp.

                                                                    {
    ofstream    outFileStream;
    char        currPath[FILENAME_MAX];
    UdpAppDLen  udpDLen;
 
    const char *myName  = concat3(THIS_NAME, "/", "DUDTF");
 
    //-- REMOVE PREVIOUS FILE
    remove(ssName.c_str());
 
    //-- OPEN FILE
    if (!outFileStream.is_open()) {
        outFileStream.open(datFile.c_str(), ofstream::out);
        if (!outFileStream) {
            printError(THIS_NAME, "Cannot open the file: \'%s\'.\n", datFile.c_str());
            return(NTS_KO);
        }
    }
 
    // Assess that file has ".dat" extension
    if ( datFile.find_last_of ( '.' ) != string::npos ) {
        string extension ( datFile.substr( datFile.find_last_of ( '.' ) + 1 ) );
        if (extension != "dat") {
            printError(THIS_NAME, "Cannot dump SocketPair stream to file \'%s\' because file is not of type \'DAT\'.\n", datFile.c_str());
            outFileStream.close();
            return(NTS_KO);
        }
    }
 
    //-- READ FROM STREAM AND WRITE TO FILE
    while (!(ss.empty())) {
        ss.read(udpDLen);
        writeApUintToFile(udpDLen, outFileStream);
        nrChunks++;
        nrBytes += 2;
        nrFrames++;
        if (DEBUG_LEVEL & TRACE_DUMTF) {
            printInfo(myName, "Writing new datagram length file. Len=%d.\n", udpDLen.to_int());
        }
    }
 
    //-- CLOSE FILE
    outFileStream.close();
 
    return(NTS_OK);
}

Here is the call graph for this function:

drainUdpMetaStreamToFile()

bool drainUdpMetaStreamToFile	(	stream< UdpAppMeta > &	ss,
		string	ssName,
		string	datFile,
		int &	nrChunks,
		int &	nrFrames,
		int &	nrBytes
	)

Empty an UdpMeta stream to a DAT file.

Parameters

	[in/out]	ss A ref to the UDP metadata stream to drain.
[in]	ssName	The name of the UDP metadata stream to drain.
[in]	fileName	The DAT file to write to.
	[out	nrChunks A ref to the number of written chunks.
[out]	nrFrames	A ref to the number of written AXI4 streams.
[out]	nrBytes	A ref to the number of written bytes.

Returns

NTS_OK if successful, otherwise NTS_KO.

Definition at line 409 of file simu_udp_app_flash_env.cpp.

                                                                    {
    ofstream    outFileStream;
    char        currPath[FILENAME_MAX];
    UdpAppMeta  udpMeta;
 
    const char *myName  = concat3(THIS_NAME, "/", "DUMTF");
 
    //-- REMOVE PREVIOUS FILE
    remove(ssName.c_str());
 
    //-- OPEN FILE
    if (!outFileStream.is_open()) {
        outFileStream.open(datFile.c_str(), ofstream::out);
        if (!outFileStream) {
            printError(THIS_NAME, "Cannot open the file: \'%s\'.\n", datFile.c_str());
            return(NTS_KO);
        }
    }
 
    // Assess that file has ".dat" extension
    if ( datFile.find_last_of ( '.' ) != string::npos ) {
        string extension ( datFile.substr( datFile.find_last_of ( '.' ) + 1 ) );
        if (extension != "dat") {
            printError(THIS_NAME, "Cannot dump SocketPair stream to file \'%s\' because file is not of type \'DAT\'.\n", datFile.c_str());
            outFileStream.close();
            return(NTS_KO);
        }
    }
 
    //-- READ FROM STREAM AND WRITE TO FILE
    while (!(ss.empty())) {
        ss.read(udpMeta);
        SocketPair socketPair(SockAddr(udpMeta.ip4SrcAddr, udpMeta.udpSrcPort),
                              SockAddr(udpMeta.ip4DstAddr, udpMeta.udpDstPort));
        writeSocketPairToFile(socketPair, outFileStream);
        nrChunks++;
        nrBytes += 12;
        nrFrames++;
        if (DEBUG_LEVEL & TRACE_DUMTF) {
            printInfo(myName, "Writing new socket-pair to file:\n");
            printSockPair(myName, socketPair);
        }
    }
 
    //-- CLOSE FILE
    outFileStream.close();
 
    return(NTS_OK);
}

Here is the call graph for this function:

dumpDataToFile()

bool dumpDataToFile	(	UdpWord *	udpWord,
		ofstream &	outFileStream
	)

Dump a data word to a file.

Parameters

[in]	udpWord,a	pointer to the data word to dump.
[in]	outFileStream,the	output file stream to write to.

Returns

OK if successful, otherwise KO.

Definition at line 162 of file test_triangle_app.cpp.

                                                               {
    if (!outFileStream.is_open()) {
        printf("### ERROR : Output file stream is not open. \n");
        return(KO);
    }
    outFileStream << hex << noshowbase << setfill('0') << setw(16) << udpWord->tdata.to_uint64();
    outFileStream << " ";
    outFileStream << hex << noshowbase << setfill('0') << setw(2)  << udpWord->tkeep.to_int();
    outFileStream << " ";
    outFileStream << setw(1) << udpWord->tlast.to_int() << "\n";
    return(OK);
}

Here is the caller graph for this function:

getOutputDataStream()

bool getOutputDataStream	(	stream< UdpWord > &	sDataStream,
		const string	dataStreamName,
		const string	outFileName
	)

Fill an output file with data from an output stream.

Parameters

[in]	sDataStream,the	output data stream to set.
[in]	dataStreamName,the	name of the data stream.
[in]	outFileName,the	name of the output file to write to.

Returns

OK if successful, otherwise KO.

Definition at line 185 of file test_triangle_app.cpp.

{
    string      strLine;
    ofstream    outFileStream;
    string      datFile = "../../../../test/" + outFileName;
    UdpWord     udpWord;
    bool        rc = OK;
 
    //-- STEP-1 : OPEN FILE
    outFileStream.open(datFile.c_str());
    if ( !outFileStream ) {
        cout << "### ERROR : Could not open the output data file " << datFile << endl;
        return(KO);
    }
 
    //-- STEP-2 : EMPTY STREAM AND DUMP DATA TO FILE
    while (!sDataStream.empty()) {
        if (readDataStream(sDataStream, &udpWord) == VALID) {
            // Print DUT/Data to console
            printf("[%4.4d] TB is draining output stream [%s] - Data read = {D=0x%16.16llX, K=0x%2.2X, L=%d} \n",
                    simCnt, dataStreamName.c_str(),
                    udpWord.tdata.to_long(), udpWord.tkeep.to_int(), udpWord.tlast.to_int());
            if (!dumpDataToFile(&udpWord, outFileStream)) {
                rc = KO;
                break;
            }
        }
    }
 
    //-- STEP-3: CLOSE FILE
    outFileStream.close();
 
    return(rc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

increaseSimTime()

void increaseSimTime

(

unsigned int

cycles

)

Increase the simulation time of the testbench.

Parameters

[in]

The

number of cycles to increase.

Definition at line 89 of file simu_udp_app_flash_env.cpp.

                                          {
    gMaxSimCycles += cycles;
}

main()

int main	(	int	argc,
		char *	argv[]
	)

Main function for the test of the UDP Application Flash (UAF).

Main function for the test of the UDP Application Flash (UAF) TOP.

Definition at line 62 of file test_udp_app_flash.cpp.

                                 {
 
    gSimCycCnt = 0;
 
    //------------------------------------------------------
    //-- TESTBENCH LOCAL VARIABLES
    //------------------------------------------------------
    int      nrErr  = 0;
    EchoCtrl tbCtrlMode = ECHO_CTRL_DISABLED;
 
    //------------------------------------------------------
    //-- NONE-STREAM-BASED INTERFACES
    //------------------------------------------------------
    // INFO - The UAF is specified to use the block-level IO protocol
    // 'ap_ctrl_none'. This core uses also a few configurations signals
    // which are not stream-based and which prevent the design from
    // being verified in C/RTL co-simulation mode. In oder to comply
    // with the 'Interface Synthesis Requirements' of UG902, the design
    // is compiled with a preprocessor macro that statically defines the
    // testbench mode of operation. This avoid the following error issued
    // when trying to C/RTL co-simulate this component:
    //   @E [SIM-345] Cosim only supports the following 'ap_ctrl_none'
    //      designs: (1) combinational designs; (2) pipelined design with
    //      task interval of 1; (3) designs with array streaming or
    //      hls_stream ports.
    //   @E [SIM-4] *** C/RTL co-simulation finished: FAIL **
   //------------------------------------------------------
    CmdBit              sSHL_UAF_Mmio_Enable    = CMD_ENABLE;
#if TB_MODE == 0
    ap_uint<2>          sSHL_UAF_Mmio_EchoCtrl  = ECHO_CTRL_DISABLED;
    ap_uint<1>          sSHL_UAF_Mmio_PostPktEn = 0;
    ap_uint<1>          sSHL_UAF_Mmio_CaptPktEn = 0;
#elif TB_MODE == 1
    ap_uint<2>          sSHL_UAF_Mmio_EchoCtrl  = ECHO_PATH_THRU;
    ap_uint<1>          sSHL_UAF_Mmio_PostPktEn = 0;
    ap_uint<1>          sSHL_UAF_Mmio_CaptPktEn = 0;
#elif TB_MODE == 2
    ap_uint<2>          sSHL_UAF_Mmio_EchoCtrl  = ECHO_STORE_FWD;
    ap_uint<1>          sSHL_UAF_Mmio_PostPktEn = 0;
    ap_uint<1>          sSHL_UAF_Mmio_CaptPktEn = 0;
#else
    ap_uint<2>          sSHL_UAF_Mmio_EchoCtrl  = ECHO_OFF;
    ap_uint<1>          sSHL_UAF_Mmio_PostPktEn = 0;
    ap_uint<1>          sSHL_UAF_Mmio_CaptPktEn = 0;
#endif
 
    //------------------------------------------------------
    //-- DUT STREAM INTERFACES and RELATED VARIABLEs
    //------------------------------------------------------
    stream<UdpAppData>  ssUSIF_UAF_Data  ("ssUSIF_UAF_Data");
    stream<UdpAppMeta>  ssUSIF_UAF_Meta  ("ssUSIF_UAF_Meta");
    stream<UdpAppDLen>  ssUSIF_UAF_DLen  ("ssUSIF_UAF_DLen");
    stream<UdpAppData>  ssUAF_USIF_Data  ("ssUAF_USIF_Data");
    stream<UdpAppMeta>  ssUAF_USIF_Meta  ("ssUAF_USIF_Meta");
    stream<UdpAppDLen>  ssUAF_USIF_DLen  ("ssUAF_USIF_DLen");
 
    //------------------------------------------------------
    //-- PARSING THE TESBENCH ARGUMENTS
    //------------------------------------------------------
    if (argc < 3) {
        printFatal(THIS_NAME, "Expected a minimum of 2 parameters with the following synopsis:\n \t\t mode(0|1|2)   siUAF_<Filename>.dat\n");
    }
    tbCtrlMode = EchoCtrl(atoi(argv[1]));
    if (tbCtrlMode != sSHL_UAF_Mmio_EchoCtrl) {
        printFatal(THIS_NAME, "tbCtrlMode (%d) does not match TB_MODE (%d). Modify the CFLAG and re-compile.\n", tbCtrlMode, TB_MODE);
    }
 
    switch (tbCtrlMode) {
    case ECHO_CTRL_DISABLED:
        break;
    case ECHO_PATH_THRU:
    case ECHO_STORE_FWD:
    case ECHO_OFF:
        printFatal(THIS_NAME, "The 'ECHO' mode %d is no longer supported since the removal of the MMIO EchoCtrl bits. \n", tbCtrlMode);
        break;
    default:
        printFatal(THIS_NAME, "Unknown testing mode '%d' (or not yet implemented). \n");
    }
 
    printf("#####################################################\n");
    printf("## TESTBENCH STARTS HERE                           ##\n");
    printf("#####################################################\n");
    printInfo(THIS_NAME, "This testbench will be executed with the following parameters: \n");
    printInfo(THIS_NAME, "\t==> TB Mode  = %c\n", *argv[1]);
    for (int i=2; i<argc; i++) {
        printInfo(THIS_NAME, "\t==> Param[%d] = %s\n", (i-1), argv[i]);
    }
    printf("\n");
 
    if (tbCtrlMode == ECHO_CTRL_DISABLED) {
 
        //-- DUT OUTPUT TRAFFIC AS STREAMS ------------------------------
        ofstream ofsUSIF_Data;  // APP data streams delivered to USIF
        const char *ofsUSIF_Data_FileName      = "../../../../test/simOutFiles/soUSIF_Data.dat";
        ofstream ofsUSIF_Meta;  // APP meta streams delivered to USIF
        const char *ofsUSIF_Meta_FileName      = "../../../../test/simOutFiles/soUSIF_Meta.dat";
        ofstream ofsUSIF_DLen;  // APP data len streams delivered to USIF
        const char *ofsUSIF_DLen_FileName      = "../../../../test/simOutFiles/soUSIF_DLen.dat";
 
        string   ofsUSIF_Data_Gold_FileName = "../../../../test/simOutFiles/soUSIF_Data_Gold.dat";
        string   ofsUSIF_Meta_Gold_FileName = "../../../../test/simOutFiles/soUSIF_Meta_Gold.dat";
        string   ofsUSIF_DLen_Gold_FileName = "../../../../test/simOutFiles/soUSIF_DLen_Gold.dat";
 
        //-- STEP-1: The setting of the ECHO mode is already done via CFLAGS
        printInfo(THIS_NAME, "### TEST_MODE = ECHO_CTRL_DISABLED #########\n");
 
        //-- STEP-2: Remove previous old files and open new files
        if (not isDatFile(ofsUSIF_Data_FileName)) {
            printError(THIS_NAME, "File \'%s\' is not of type \'DAT\'.\n", ofsUSIF_Data_FileName);
            nrErr++;
        }
        else {
            remove(ofsUSIF_Data_FileName);
        }
        if (not isDatFile(ofsUSIF_Meta_FileName)) {
            printError(THIS_NAME, "File \'%s\' is not of type \'DAT\'.\n", ofsUSIF_Meta_FileName);
            nrErr++;
        }
        else {
            remove(ofsUSIF_Meta_FileName);
            if (!ofsUSIF_Meta.is_open()) {
                ofsUSIF_Meta.open(ofsUSIF_Meta_FileName, ofstream::out);
                if (!ofsUSIF_Meta) {
                    printError(THIS_NAME, "Cannot open the file: \'%s\'.\n", ofsUSIF_Meta_FileName);
                    nrErr++;
                }
            }
        }
        if (not isDatFile(ofsUSIF_DLen_FileName)) {
            printError(THIS_NAME, "File \'%s\' is not of type \'DAT\'.\n", ofsUSIF_DLen_FileName);
            nrErr++;
        }
        else {
            remove(ofsUSIF_DLen_FileName);
            if (!ofsUSIF_DLen.is_open()) {
                ofsUSIF_DLen.open(ofsUSIF_DLen_FileName, ofstream::out);
                if (!ofsUSIF_DLen) {
                    printError(THIS_NAME, "Cannot open the file: \'%s\'.\n", ofsUSIF_DLen_FileName);
                    nrErr++;
                }
            }
        }
 
        //-- STEP-3: Create golden Tx files
        queue<UdpAppMeta>   udpMetaQueue;
        queue<UdpAppDLen>   udpDLenQueue;
        if (NTS_OK == createGoldenTxFiles(tbCtrlMode, string(argv[2]), udpMetaQueue, udpDLenQueue,
                ofsUSIF_Data_Gold_FileName, ofsUSIF_Meta_Gold_FileName, ofsUSIF_DLen_Gold_FileName) != NTS_OK) {
            printError(THIS_NAME, "Failed to create golden Tx files. \n");
            nrErr++;
        }
 
        //-- STEP-4: Create the USIF->UAF INPUT {Data,Meta} as streams
        int nrUSIF_UAF_Chunks=0;
        if (not createUdpRxTraffic(ssUSIF_UAF_Data, "ssUSIF_UAF_Data",
                                   ssUSIF_UAF_Meta, "ssUSIF_UAF_Meta",
                                   ssUSIF_UAF_DLen, "ssUSIF_UAF_DLen",
                                   string(argv[2]),
                                   udpMetaQueue, udpDLenQueue,
                                   nrUSIF_UAF_Chunks)) {
            printFatal(THIS_NAME, "Failed to create the USIF->UAF traffic as streams.\n");
        }
 
        //-- STEP-5: Run simulation
        int tbRun = (nrErr == 0) ? (nrUSIF_UAF_Chunks + TB_GRACE_TIME) : 0;
        while (tbRun) {
            udp_app_flash(
                    //-- SHELL / Mmio Interfaces
                    &sSHL_UAF_Mmio_Enable,
                    //[NOT_USED] sSHL_UAF_Mmio_EchoCtrl,
                    //[NOT_USED] sSHL_UAF_Mmio_PostPktEn,
                    //[NOT_USED] sSHL_UAF_Mmio_CaptPktEn,
                    //-- USIF / Rx Data Interfaces
                    ssUSIF_UAF_Data,
                    ssUSIF_UAF_Meta,
                    ssUSIF_UAF_DLen,
                    //-- USIF / Tx Data Interfaces
                    ssUAF_USIF_Data,
                    ssUAF_USIF_Meta,
                    ssUAF_USIF_DLen);
            tbRun--;
            stepSim();
        }
 
        printInfo(THIS_NAME, "############################################################################\n");
        printInfo(THIS_NAME, "## TESTBENCH 'test_udp_app_flash' ENDS HERE                               ##\n");
        printInfo(THIS_NAME, "############################################################################\n");
        stepSim();
 
        //-- STEP-6a: Drain UAF-->USIF DATA OUTPUT STREAM
        int nrUAF_USIF_DataChunks=0, nrUAF_USIF_DataGrams=0, nrUAF_USIF_DataBytes=0;
        if (not drainAxisToFile(ssUAF_USIF_Data, "ssUAF_USIF_Data",
            ofsUSIF_Data_FileName, nrUAF_USIF_DataChunks, nrUAF_USIF_DataGrams, nrUAF_USIF_DataBytes)) {
            printError(THIS_NAME, "Failed to drain UAF-to-USIF data traffic from DUT. \n");
            nrErr++;
        }
        else {
            printInfo(THIS_NAME, "Done with the draining of the UAF-to-USIF data traffic:\n");
            printInfo(THIS_NAME, "\tReceived %d chunks in %d datagrams, for a total of %d bytes.\n\n",
                      nrUAF_USIF_DataChunks, nrUAF_USIF_DataGrams, nrUAF_USIF_DataBytes);
        }
        //-- STEP-6b: Drain UAF-->USIF META OUTPUT STREAM
        int nrUAF_USIF_MetaChunks=0, nrUAF_USIF_MetaGrams=0, nrUAF_USIF_MetaBytes=0;
        if (not drainUdpMetaStreamToFile(ssUAF_USIF_Meta, "ssUAF_USIF_Meta",
            ofsUSIF_Meta_FileName, nrUAF_USIF_MetaChunks, nrUAF_USIF_MetaGrams, nrUAF_USIF_MetaBytes)) {
            printError(THIS_NAME, "Failed to drain UAF-to-USIF meta traffic from DUT. \n");
            nrErr++;
        }
        //-- STEP-6c: Drain UAF-->USIF DLEN OUTPUT STREAM
        int nrUAF_USIF_DLenChunks=0, nrUAF_USIF_DLenGrams=0, nrUAF_USIF_DLenBytes=0;
        if (not drainUdpDLenStreamToFile(ssUAF_USIF_DLen, "ssUAF_USIF_DLen",
            ofsUSIF_DLen_FileName, nrUAF_USIF_DLenChunks, nrUAF_USIF_DLenGrams, nrUAF_USIF_DLenBytes)) {
            printError(THIS_NAME, "Failed to drain UAF-to-USIF dlen traffic from DUT. \n");
            nrErr++;
        }
 
        //-- STEP-7: Compare output DAT vs gold DAT
        int res;
        ifstream ifsFile;
 
        ifsFile.open(ofsUSIF_Data_FileName, ofstream::in);
        if (!ifsFile) {
            printError(THIS_NAME, "Cannot open the file: \'%s\'.\n", ofsUSIF_Data_FileName);
            nrErr++;
        }
        else if (not (ifsFile.peek() == ifstream::traits_type::eof())) {
            res = myDiffTwoFiles(std::string(ofsUSIF_Data_FileName),
                                 std::string(ofsUSIF_Data_Gold_FileName));
            if (res) {
                printError(THIS_NAME, "File \'%s\' does not match \'%s\'.\n", \
                           ofsUSIF_Data_FileName, ofsUSIF_Data_Gold_FileName.c_str());
               nrErr += 1;
            }
        }
        else {
            printError(THIS_NAME, "File \"%s\" is empty.\n", ofsUSIF_Data_FileName);
            nrErr++;
        }
        ifsFile.close();
 
        ifsFile.open(ofsUSIF_DLen_FileName, ofstream::in);
        if (!ifsFile) {
            printError(THIS_NAME, "Cannot open the file: \'%s\'.\n", ofsUSIF_DLen_FileName);
            nrErr++;
        }
        else if (not (ifsFile.peek() == ifstream::traits_type::eof())) {
            res = myDiffTwoFiles(std::string(ofsUSIF_DLen_FileName),
                                 std::string(ofsUSIF_DLen_Gold_FileName));
            if (res) {
                printError(THIS_NAME, "File \'%s\' does not match \'%s\'.\n", \
                           ofsUSIF_DLen_FileName, ofsUSIF_DLen_Gold_FileName.c_str());
               nrErr += 1;
            }
        }
        else {
            printError(THIS_NAME, "File \"%s\" is empty.\n", ofsUSIF_DLen_FileName);
            nrErr++;
        }
        ifsFile.close();
 
    }  // End-of: if (tbCtrlMode == ECHO_CTRL_DISABLED) {
 
 
    //---------------------------------------------------------------
    //-- PRINT TESTBENCH STATUS
    //---------------------------------------------------------------
    printf("\n\n");
    printInfo(THIS_NAME, "This testbench was executed with the following parameters: \n");
    printInfo(THIS_NAME, "\t==> TB Mode  = %c\n", *argv[1]);
    for (int i=2; i<argc; i++) {
        printInfo(THIS_NAME, "\t==> Param[%d] = %s\n", (i-1), argv[i]);
    }
 
    if (nrErr) {
        printError(THIS_NAME, "###########################################################\n");
        printError(THIS_NAME, "#### TEST BENCH FAILED : TOTAL NUMBER OF ERROR(S) = %2d ####\n", nrErr);
        printError(THIS_NAME, "###########################################################\n\n");
 
        printInfo(THIS_NAME, "FYI - You may want to check for \'ERROR\' and/or \'WARNING\' alarms in the LOG file...\n\n");
    }
    else {
        printInfo(THIS_NAME, "#############################################################\n");
        printInfo(THIS_NAME, "####               SUCCESSFUL END OF TEST                ####\n");
        printInfo(THIS_NAME, "#############################################################\n");
    }
 
    return nrErr;
 
}

Here is the call graph for this function:

pUdpEchoStoreAndForward()

void pUdpEchoStoreAndForward	(	CmdBit *	piSHL_Enable,
		stream< UdpAppData > &	siRXp_Data,
		stream< UdpAppMeta > &	siRXp_Meta,
		stream< UdpAppDLen > &	siRXp_DLen,
		stream< UdpAppData > &	soTXp_Data,
		stream< UdpAppMeta > &	soTXp_Meta,
		stream< UdpAppDLen > &	soTXp_DLen
	)

Echo loopback between the Rx and Tx ports of the UDP connection.

Parameters

[in]	piSHL_Enable	Enable signal from [SHELL].
[in]	siRXp_Data	UDP datagram from RxPath (RXp).
[in]	siRXp_Meta	UDP metadata from [RXp].
[in]	siRXp_DLen	UDP data len from [RXp].
[out]	soTXp_Data	UDP datagram to TxPath (TXp).
[out]	soTXp_Meta	UDP metadata to [TXp].
[out]	soTXp_DLen	UDP data len to [TXp].

The echo is said to operate in "store-and-forward" mode because every received packet is stored into the DDR4 memory before being read again from the DDR4 and and sent back.

[TODO - Implement this process as a real store-and-forward]

Definition at line 87 of file udp_app_flash.cpp.

{
    //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
    #pragma HLS INLINE off
    #pragma HLS PIPELINE II=1  enable_flush
 
    const char *myName  = concat3(THIS_NAME, "/", "ESf");
 
    //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
    static enum FsmStates { ESF_META=0, ESF_STREAM } \
                               esf_fsmState = ESF_META;
    #pragma HLS reset variable=esf_fsmState
    static UdpAppDLen          esf_byteCnt;
    #pragma HLS reset variable=esf_byteCnt
 
    if (*piSHL_Enable != 1) {
        return;
    }
 
    //=====================================================
    //== PROCESS DATA FORWARDING
    //=====================================================
    if ( !siRXp_Data.empty() and !soTXp_Data.full() ) {
        UdpAppData appData = siRXp_Data.read();
        soTXp_Data.write(appData);
        esf_byteCnt += appData.getLen();
        if (appData.getTLast()) {
            esf_byteCnt = 0;
        }
    }
 
    //=====================================================
    //== PROCESS META FORWARDING
    //=====================================================
    if ( !siRXp_Meta.empty() and !soTXp_Meta.full() and
         !siRXp_DLen.empty() and !soTXp_DLen.full() ) {
        UdpAppMeta appMeta = siRXp_Meta.read();
        UdpAppDLen appDLen = siRXp_DLen.read();
        soTXp_Meta.write(appMeta);
        soTXp_DLen.write(appDLen);
    }
}    // End-of: pEchoStoreAndForward()

Here is the call graph for this function:

Here is the caller graph for this function:

pUdpRxPath()

void pUdpRxPath	(	CmdBit *	piSHL_Mmio_Enable,
		stream< UdpAppData > &	siUSIF_Data,
		stream< UdpAppMeta > &	siUSIF_Meta,
		stream< UdpAppDLen > &	siUSIF_DLen,
		stream< UdpAppData > &	soEPt_Data,
		stream< UdpAppMeta > &	soEPt_Meta,
		stream< UdpAppDLen > &	soEPt_DLen,
		stream< UdpAppData > &	soESf_Data,
		stream< UdpAppMeta > &	soESf_Meta,
		stream< UdpAppDLen > &	soESf_DLen
	)

UDP Receive Path (RXp) - From SHELL->ROLE/USIF to THIS.

Parameters

[in]	piSHL_Mmio_Enable	Enable signal from [SHELL].
[in]	piSHL_Mmio_EchoCtrl	Configuration of the echo function.
[in]	siUSIF_Data	Datagram from UdpShellInterface (USIF).
[in]	siUSIF_Meta	Metadata from [USIF].
[in]	siUSIF_DLen	Data len from [USIF].
[out]	soEPt_Data	Datagram to EchoPassTrough (EPt).
[out]	soEPt_Meta	Metadata to [EPt].
[out]	soEPt_DLen	Data len to [EPt].
[out]	soESf_Data	Datagram to EchoStoreAndForward (ESf).
[out]	soESf_Meta	Metadata to [ESf].
[out]	soESf_DLen	Metadata to [ESf].

This Process waits for a new datagram to read and forwards it to the EchoPathThrough (EPt) or EchoStoreAndForward (ESf) process upon the setting of the UDP destination port.

Warning

When operating with AP_FIFOs instead of AXIS interfaces, it may be necessary to drain the incoming FIFos after a reset (see e.g. the state RXP_DRAIN_INPUT_FIFOS)

Definition at line 351 of file udp_app_flash.cpp.

{
    //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
    #pragma HLS INLINE off
    #pragma HLS PIPELINE II=1 enable_flush
 
    const char *myName  = concat3(THIS_NAME, "/", "RXp");
 
    //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
    static enum FsmStates { RXP_IDLE=0, RXP_META_EPT, RXP_META_ESF,
                                        RXP_DATA_EPT, RXP_DATA_ESF,
                                        RXP_DLEN_EPT, RXP_DLEN_ESF,
                                        RXP_DRAIN_INPUT_FIFOS } \
                               rxp_fsmState = RXP_IDLE;
    #pragma HLS reset variable=rxp_fsmState
 
    //-- STATIC DATAFLOW VARIABLES ---------------------------------------------
    static UdpAppMeta rxp_appMeta;
    static UdpAppDLen rxp_appDLen;
    static UdpAppDLen rxp_byteCnt;
 
    //-- DYNAMIC VARIABLES -----------------------------------------------------
    UdpAppData  appData;
 
    switch (rxp_fsmState) {
    case RXP_IDLE:
        if (*piSHL_Mmio_Enable == CMD_DISABLE) {
            rxp_fsmState  = RXP_DRAIN_INPUT_FIFOS;
        }
        else if (!siUSIF_Meta.empty() and !siUSIF_DLen.empty()) {
            siUSIF_Meta.read(rxp_appMeta);
            siUSIF_DLen.read(rxp_appDLen);
            rxp_byteCnt = 0;
            switch (rxp_appMeta.udpDstPort) {
            case ECHO_PATH_THRU_PORT:
                // (DstPort == 8803) Echo this traffic in path-through mode
                if (DEBUG_LEVEL & TRACE_RXP) { printInfo(myName, "Entering Rx path-through mode (DstPort=%4.4d)\n", rxp_appMeta.udpDstPort.to_uint()); }
                rxp_fsmState  = RXP_META_EPT;
                break;
            default:
                // (DstPort != 8803) Echo this traffic in store-and-forward mode
                if (DEBUG_LEVEL & TRACE_RXP) { printInfo(myName, "Entering Rx store-and-forward mode (DstPort=%4.4d)\n", rxp_appMeta.udpDstPort.to_uint()); }
                rxp_fsmState  = RXP_META_ESF;
                break;
            }
        }
        break;
    case RXP_DRAIN_INPUT_FIFOS:
        // Drain all the incoming FIFOs as long as MMIO control signal is disabled
        if(!siUSIF_Data.empty()) {
            siUSIF_Data.read();
        }
        else if(!siUSIF_Meta.empty()) {
            siUSIF_Meta.read();
        }
        else if(!siUSIF_DLen.empty()) {
            siUSIF_DLen.read();
        }
        else {
            rxp_fsmState = RXP_IDLE;
        }
        break;
    case RXP_META_EPT:
        if (!soEPt_Meta.full()) {
            //-- Forward incoming metadata to pEchoPathThrough
            soEPt_Meta.write(rxp_appMeta);
            rxp_fsmState = RXP_DATA_EPT;
        }
        break;
    case RXP_META_ESF:
        if (!soESf_Meta.full()) {
            //-- Forward incoming metadata to pEchoStoreAndForward
            soESf_Meta.write(rxp_appMeta);
            rxp_fsmState = RXP_DATA_ESF;
        }
        break;
    case RXP_DATA_EPT:
        if (!siUSIF_Data.empty() and !soEPt_Data.full()) {
            //-- Read incoming data and forward to pEchoPathThrough
            siUSIF_Data.read(appData);
            soEPt_Data.write(appData);
            rxp_byteCnt = rxp_byteCnt + appData.getLen();
            if (appData.getTLast()) {
                rxp_fsmState = RXP_DLEN_EPT;
            }
        }
        break;
    case RXP_DATA_ESF:
        if (!siUSIF_Data.empty() and !soESf_Data.full()) {
            //-- Read incoming data and forward to pEchoStoreAndForward
            siUSIF_Data.read(appData);
            soESf_Data.write(appData);
            rxp_byteCnt = rxp_byteCnt + appData.getLen();
            if (appData.getTLast()) {
                rxp_fsmState = RXP_DLEN_ESF;
            }
        }
        break;
    case RXP_DLEN_EPT:
        if (!soEPt_DLen.full()) {
            //-- Forward the computed data length to pEchoPathThrough
            if (rxp_byteCnt != rxp_appDLen) {
                printFatal(myName, "Received number of bytes (%d) differs from the advertised data length (%d)\n", rxp_byteCnt.to_uint(), rxp_appDLen.to_uint());
            }
            soEPt_DLen.write(rxp_byteCnt);
            rxp_fsmState = RXP_IDLE;
        }
        break;
    case RXP_DLEN_ESF:
        if (!soESf_DLen.full()) {
            //-- Forward the computed data length to pEchoPathThrough
            if (rxp_byteCnt != rxp_appDLen) {
                printFatal(myName, "Received number of bytes (%d) differs from the advertised data length (%d)\n", rxp_byteCnt.to_uint(), rxp_appDLen.to_uint());
            }
            soESf_DLen.write(rxp_byteCnt);
            rxp_fsmState = RXP_IDLE;
        }
        break;
    }  // End-of: switch (rxp_fsmState) {
 
}  // End-of: pRxPath()

Here is the call graph for this function:

Here is the caller graph for this function:

pUdpTxPath()

void pUdpTxPath	(	CmdBit *	piSHL_Mmio_Enable,
		stream< UdpAppData > &	siEPt_Data,
		stream< UdpAppMeta > &	siEPt_Meta,
		stream< UdpAppDLen > &	siEPt_DLen,
		stream< UdpAppData > &	siESf_Data,
		stream< UdpAppMeta > &	siESf_Meta,
		stream< UdpAppDLen > &	siESf_DLen,
		stream< UdpAppData > &	soUSIF_Data,
		stream< UdpAppMeta > &	soUSIF_Meta,
		stream< UdpAppDLen > &	soUSIF_DLen
	)

Transmit Path - From THIS to USIF.

Parameters

[in]	piSHL_Mmio_Enable	Enable signal from [SHELL].
[in]	piSHL_Mmio_EchoCtrl	Configuration of the echo function.
[in]	siEPt_Data	Datagram from pEchoPassTrough (EPt).
[in]	siEPt_Meta	Metadata from [EPt].
[in]	siEPt_DLen	Data len from [EPt].
[in]	siESf_Data	Datagram from pEchoStoreAndForward (ESf).
[in]	siESf_Meta	Metadata from [ESf].
[in]	siESf_DLen	Data len from [ESf].
[out]	soUSIF_Data	Datagram to UdpShellInterface (USIF).
[out]	soUSIF_Meta	Metadata to [USIF].
[out]	soUSIF_DLen	Data len to [USIF].

The 'EchoPathThrough' forwards the datagrams in either DATAGRAM_MODE or STREAMING_MODE. The mode is defined by the content of the 'DLen' field: 1) DATAGRAM_MODE: If the 'DLen' field is loaded with a length != 0, this length is used as reference for handling the incoming datagram. If the length is larger than 1472 bytes (.i.e, MTU-IP_HEADER_LEN-UDP_HEADER_LEN), the UDP Offload Engine (UOE) of the NTS is expected to split the incoming datagram and generate as many sub-datagrams as required to transport all 'DLen' bytes over Ethernet. frames. 2) STREAMING_MODE: If the 'DLen' field is configured with a length==0, the corresponding stream is expected to be forwarded by the UOE of the NTS based on the same metadata information until the 'TLAST' bit of the data stream is set. In this mode, the UOE will wait for the reception of 1472 bytes before generating a new UDP-over-IPv4 packet, unless the 'TLAST' bit of the data stream is set.

Definition at line 168 of file udp_app_flash.cpp.

{
    //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
    #pragma HLS INLINE off
    #pragma HLS PIPELINE II=1 enable_flush
 
    const char *myName  = concat3(THIS_NAME, "/", "TXp");
 
    //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
    static enum FsmStates { TXP_IDLE=0,   TXP_META,
                            TXP_DATA_EPT, TXP_DATA_ESF, TXP_DRAIN_INPUT_FIFOS } \
                               txp_fsmState = TXP_IDLE;
    #pragma HLS reset variable=txp_fsmState
    static enum DgmMode   { STRM_MODE=0, DGRM_MODE } \
                               txp_fwdMode = DGRM_MODE;
    #pragma HLS reset variable=txp_fwdMode
 
    //-- STATIC DATAFLOW VARIABLES ---------------------------------------------
    static ap_int<17>  txp_lenCnt;
    static UdpAppMeta  txp_appMeta;
    static UdpAppDLen  txp_appDLen;
    static enum EchoMode   { EPT_MODE=0, ESF_MODE } \
                       txp_echoMode = EPT_MODE;
 
    //-- DYNAMIC VARIABLES -----------------------------------------------------
    UdpAppData    appData;
 
    switch (txp_fsmState) {
    case TXP_IDLE:
        if (*piSHL_Mmio_Enable == CMD_DISABLE) {
            txp_fsmState  = TXP_DRAIN_INPUT_FIFOS;
        }
        else if (!siEPt_Meta.empty() and !siEPt_DLen.empty()) {
            txp_appMeta = siEPt_Meta.read();
            txp_appDLen = siEPt_DLen.read();
            txp_echoMode = EPT_MODE;
            txp_fsmState = TXP_META;
        }
        else if (!siESf_Meta.empty() and !siESf_DLen.empty()) {
            txp_appMeta = siESf_Meta.read();
            txp_appDLen = siESf_DLen.read();
            txp_echoMode = ESF_MODE;
            txp_fsmState = TXP_META;
        }
        if (txp_appDLen == 0) {
            txp_fwdMode = STRM_MODE;
            txp_lenCnt = 0;
        }
        else {
            txp_fwdMode = DGRM_MODE;
            txp_lenCnt = txp_appDLen;
        }
        break;
    case TXP_META:
        if (!soUSIF_Meta.full() and !soUSIF_DLen.full()) {
            // Swap IP_SA/IP_DA as well as UPD_SP/UDP_DP
            UdpAppMeta udpMeta(txp_appMeta.ip4DstAddr, txp_appMeta.udpDstPort,
                               txp_appMeta.ip4SrcAddr, txp_appMeta.udpSrcPort);
            soUSIF_Meta.write(udpMeta);
            soUSIF_DLen.write(txp_appDLen);
            if (txp_echoMode == EPT_MODE) {
                txp_fsmState = TXP_DATA_EPT;
            }
            else {
                txp_fsmState = TXP_DATA_ESF;
            }
        }
        break;
    case TXP_DATA_EPT:
        if (!siEPt_Data.empty() and !soUSIF_Data.full()) {
            appData = siEPt_Data.read();
            if (txp_fwdMode == STRM_MODE) {
                txp_lenCnt = txp_lenCnt + appData.getLen();  // Just for tracing
                if (appData.getTLast()) {
                    txp_fsmState = TXP_IDLE;
                    if (DEBUG_LEVEL & TRACE_TXP) {
                        printInfo(myName, "ECHO_PATH_THRU + STREAM   MODE - Finished forwarding %d bytes.\n", txp_lenCnt.to_uint());
                    }
                }
            }
            else {
                txp_lenCnt = txp_lenCnt - appData.getLen();
                if ((txp_lenCnt <= 0) or (appData.getTLast())) {
                    txp_fsmState = TXP_IDLE;
                    if (DEBUG_LEVEL & TRACE_TXP) {
                        printInfo(myName, "ECHO_PATH_THRU + DATAGRAM MODE - Finished datagram forwarding.\n");
                    }
                }
                else {
                    appData.setTLast(0);
                }
            }
            soUSIF_Data.write(appData);
        }
        break;
    case TXP_DATA_ESF:
        if (!siESf_Data.empty() and !soUSIF_Data.full()) {
            appData = siESf_Data.read();
            if (txp_fwdMode == STRM_MODE) {
                txp_lenCnt = txp_lenCnt + appData.getLen();  // Just for tracing
                if (appData.getTLast()) {
                    txp_fsmState = TXP_IDLE;
                    if (DEBUG_LEVEL & TRACE_TXP) {
                        printInfo(myName, "ECHO_STORE_FWD + STREAM   MODE - Finished forwarding %d bytes.\n", txp_lenCnt.to_uint());
                    }
                }
            }
            else {
                txp_lenCnt = txp_lenCnt - appData.getLen();
                if ((txp_lenCnt <= 0) or (appData.getTLast())) {
                    txp_fsmState = TXP_IDLE;
                    if (DEBUG_LEVEL & TRACE_TXP) {
                        printInfo(myName, "ECHO_STORE_FWD + DATAGRAM MODE - Finished datagram forwarding.\n");
                    }
                }
                else {
                    appData.setTLast(0);
                }
            }
            soUSIF_Data.write(appData);
        }
        break;
    case TXP_DRAIN_INPUT_FIFOS:
        // Drain all the incoming FIFOs as long as MMIO control signal is disabled
        if(!siEPt_Data.empty()) {
            siEPt_Data.read();
        }
        else if(!siEPt_Meta.empty()) {
            siEPt_Meta.read();
        }
        else if(!siEPt_DLen.empty()) {
            siEPt_Meta.read();
        }
        else if(!siESf_Data.empty()) {
            siEPt_Data.read();
        }
        else if(!siESf_Meta.empty()) {
            siEPt_Meta.read();
        }
        else if(!siESf_DLen.empty()) {
            siEPt_Meta.read();
        }
        else {
            txp_fsmState = TXP_IDLE;
        }
        break;
    }  // End-of: switch (txp_fsmState) {
 
}  // End-of: pTxPath()

Here is the call graph for this function:

Here is the caller graph for this function:

readDatagramFromFile()

bool readDatagramFromFile	(	const char *	myName,
		SimUdpDatagram &	appDatagram,
		ifstream &	ifsData,
		SocketPair &	sockPair,
		queue< UdpAppMeta > &	udpMetaQueue,
		queue< UdpAppDLen > &	udpDLenQueue,
		int &	inpChunks,
		int &	inpDgrms,
		int &	inpBytes
	)

Read a datagram from a DAT file.

Parameters

[in]	myName	The name of the caller process.
[in]	appDatagram	A reference to the datagram to read.
[in]	ifsData	The input file stream to read from.
[out]	sockPair	A ref to the current active socket pair.
[out]	udpMetaQueue	A ref to a container queue which holds the sequence of UDP socket-pairs.
[out]	udpDLenQueue	A ref to a container queue which holds the sequence of UDP data lengths.
[out]	inpChunks	A ref to the number of processed chunks.
[out]	inptDgrms	A ref to the number of processed datagrams.
[out]	inpBytes	A ref to the number of processed bytes.

Returns

true if successful, otherwise false.

SIMULATION ENVIRONMENT FUNCTIONS

Definition at line 107 of file simu_udp_app_flash_env.cpp.

                                                                            {
 
    string          stringBuffer;
    vector<string>  stringVector;
    UdpAppData      udpAppData;
    UdpAppDLen      udpAppDLen=0;
    bool            endOfDgm=false;
    bool            rc;
 
    do {
        //-- Read one line at a time from the input test DAT file
        getline(ifsData, stringBuffer);
        stringVector = myTokenizer(stringBuffer, ' ');
        //-- Read the Host Socket Address from line (if present)
        rc = readHostSocketFromLine(sockPair.src, stringBuffer);
        if (rc) {
            if (DEBUG_LEVEL & TRACE_CGTF) {
                printInfo(myName, "Read a new HOST socket address from DAT file:\n");
                printSockAddr(myName, sockPair.src);
            }
        }
        //-- Read the Fpga Socket Address from line (if present)
        rc = readFpgaSocketFromLine(sockPair.dst, stringBuffer);
        if (rc) {
            if (DEBUG_LEVEL & TRACE_CGTF) {
                printInfo(myName, "Read a new FPGA socket address from DAT file:\n");
                printSockAddr(myName, sockPair.dst);
            }
        }
        //-- Read an AxiWord from line
        rc = readAxisRawFromLine(udpAppData, stringBuffer);
        if (rc) {
            appDatagram.pushChunk(AxisUdp(udpAppData.getLE_TData(),
                                          udpAppData.getLE_TKeep(),
                                          udpAppData.getLE_TLast()));
            inpChunks++;
            inpBytes += udpAppData.getLen();
            udpAppDLen += udpAppData.getLen();
            if (udpAppData.getLE_TLast() == 1) {
                inpDgrms++;
                udpMetaQueue.push(UdpAppMeta(sockPair.src.addr, sockPair.src.port,
                                             sockPair.dst.addr, sockPair.dst.port));
                udpDLenQueue.push(udpAppDLen);
                endOfDgm = true;
            }
        }
    } while ((ifsData.peek() != EOF) && (!endOfDgm));
 
    return endOfDgm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

readDataStream()

bool readDataStream	(	stream< UdpWord > &	sDataStream,
		UdpWord *	udpWord
	)

Read data from a stream.

Parameters

[in]	sDataStream,the	output data stream to read.
[in]	dataStreamName,the	name of the data stream.
[out]	udpWord,a	pointer to the storage location of the data to read.

Returns

VALID if a data was read, otherwise UNVALID.

Definition at line 147 of file test_triangle_app.cpp.

                                                                     {
    // Get the DUT/Data results
    sDataStream.read(*udpWord);
    return(VALID);
}

Here is the caller graph for this function:

setInputDataStream()

bool setInputDataStream	(	stream< UdpWord > &	sDataStream,
		const string	dataStreamName,
		const string	inpFileName
	)

Initialize an input data stream from a file.

Parameters

[in]	sDataStream,the	input data stream to set.
[in]	dataStreamName,the	name of the data stream.
[in]	inpFileName,the	name of the input file to read from.

Returns

OK if successful, otherwise KO.

Definition at line 93 of file test_triangle_app.cpp.

                                                                                                             {
    string      strLine;
    ifstream    inpFileStream;
    string      datFile = "../../../../test/" + inpFileName;
    UdpWord     udpWord;
 
    //-- STEP-1 : OPEN FILE
    inpFileStream.open(datFile.c_str());
    if ( !inpFileStream ) {
        cout << "### ERROR : Could not open the input data file " << datFile << endl;
        return(KO);
    }
 
    //-- STEP-2 : SET DATA STREAM
    while (inpFileStream) {
 
        if (!inpFileStream.eof()) {
 
            getline(inpFileStream, strLine);
            if (strLine.empty()) continue;
            sscanf(strLine.c_str(), "%llx %x %d", &udpWord.tdata, &udpWord.tkeep, &udpWord.tlast);
 
            // Write to sDataStream
            if (sDataStream.full()) {
                printf("### ERROR : Stream is full. Cannot write stream with data from file \"%s\".\n", inpFileName.c_str());
                return(KO);
            } else {
                sDataStream.write(udpWord);
                // Print Data to console
                printf("[%4.4d] TB is filling input stream [%s] - Data write = {D=0x%16.16llX, K=0x%2.2X, L=%d} \n",
                        simCnt, dataStreamName.c_str(),
                        udpWord.tdata.to_long(), udpWord.tkeep.to_int(), udpWord.tlast.to_int());
            }
        }
    }
 
    //-- STEP-3: CLOSE FILE
    inpFileStream.close();
 
    return(OK);
}

Here is the caller graph for this function:

stepDut()

void stepDut

(

)

Run a single iteration of the DUT model.

Returns

Nothing.

Definition at line 74 of file test_triangle_app.cpp.

               {
    triangle_app(
        &node_rank, &size,
      sSHL_Uaf_Data, sUAF_Shl_Data,
      siUdp_meta, soUdp_meta,
      &s_udp_rx_ports);
    simCnt++;
    printf("[%4.4d] STEP DUT \n", simCnt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

stepSim()

void stepSim

(

)

Increment the simulation counter.

SIMULATION UTILITY HELPERS

Definition at line 73 of file simu_udp_app_flash_env.cpp.

               {
    gSimCycCnt++;
    if (gTraceEvent || ((gSimCycCnt % 1000) == 0)) {
        printInfo(THIS_NAME, "-- [@%4.4d] -----------------------------\n", gSimCycCnt);
        gTraceEvent = false;
    }
    else if (0) {
        printInfo(THIS_NAME, "------------------- [@%d] ------------\n", gSimCycCnt);
    }
}

udp_app_flash()

void udp_app_flash	(	CmdBit *	piSHL_Mmio_En,
		stream< UdpAppData > &	siUSIF_Data,
		stream< UdpAppMeta > &	siUSIF_Meta,
		stream< UdpAppDLen > &	siUSIF_DLen,
		stream< UdpAppData > &	soUSIF_Data,
		stream< UdpAppMeta > &	soUSIF_Meta,
		stream< UdpAppDLen > &	soUSIF_DLen
	)

Main process of the UDP Application Flash (UAF)

Parameters

[in]	piSHL_Mmio_En	Enable signal from [SHELL/MMIO].
[in]	piSHL_Mmio_EchoCtrl	Configures the echo function.
[in]	piSHL_Mmio_PostPktEn	Enables posting of UDP packets.
[in]	piSHL_Mmio_CaptPktEn	Enables capture of UDP packets.
[in]	siUSIF_Data	UDP datagram from UdpShellInterface (USIF).
[in]	siUSIF_Meta	UDP metadata from [USIF].
[in]	siUSIF_DLen	UDP data len from [USIF].
[out]	soUSIF_Data	UDP datagram to [USIF].
[out]	soUSIF_Meta	UDP metadata to [USIF].
[out]	soUSIF_DLen	UDP data len to [USIF].

@info This core is designed with non-blocking read and write streams in mind. FYI, this is the normal way of operation for an internal stream and for an interface using the 'ap_fifo' protocol.

Warning

This core will not work properly if operated with a handshake interface(ap_hs) or an AXI-Stream interface (axis) because these two interfaces do not support non-blocking accesses.

ENTITY - UDP APPLICATION FLASH (UAF)

Definition at line 506 of file udp_app_flash.cpp.

{
    //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
    #pragma HLS DATAFLOW
    #pragma HLS INLINE off
 
    //--------------------------------------------------------------------------
    //-- LOCAL STREAMS (Sorted by the name of the modules which generate them)
    //--------------------------------------------------------------------------
 
    //-- Rx Path (RXp) ---------------------------------------------------------
    static stream<UdpAppData>     ssRXpToTXp_Data    ("ssRXpToTXp_Data");
    #pragma HLS STREAM   variable=ssRXpToTXp_Data    depth=2048
    static stream<UdpAppMeta>     ssRXpToTXp_Meta    ("ssRXpToTXp_Meta");
    #pragma HLS STREAM   variable=ssRXpToTXp_Meta    depth=64
    static stream<UdpAppDLen>     ssRXpToTXp_DLen    ("ssRXpToTXp_DLen");
    #pragma HLS STREAM   variable=ssRXpToTXp_DLen    depth=64
 
    static stream<UdpAppData>     ssRXpToESf_Data    ("ssRXpToESf_Data");
    #pragma HLS STREAM   variable=ssRXpToESf_Data    depth=1024
    static stream<UdpAppMeta>     ssRXpToESf_Meta    ("ssRXpToESf_Meta");
    #pragma HLS STREAM   variable=ssRXpToESf_Meta    depth=32
    static stream<UdpAppDLen>     ssRXpToESf_DLen    ("ssRXpToESf_DLen");
    #pragma HLS STREAM   variable=ssRXpToESf_DLen    depth=32
 
    //-- Echo Store and Forward (ESf) ------------------------------------------
    static stream<UdpAppData>     ssESfToTXp_Data    ("ssESfToTXp_Data");
    #pragma HLS STREAM   variable=ssESfToTXp_Data    depth=1024
    static stream<UdpAppMeta>     ssESfToTXp_Meta    ("ssESfToTXp_Meta");
    #pragma HLS STREAM   variable=ssESfToTXp_Meta    depth=32
    static stream<UdpAppDLen>     ssESfToTXp_DLen    ("ssESfToTXp_DLen");
    #pragma HLS STREAM   variable=ssESfToTXp_DLen    depth=32
 
    //-- PROCESS FUNCTIONS ----------------------------------------------------
    //
    //
    //                     +----------+
    //           +-------->|   pESf   |----------+
    //           |         +----------+          |
    //           |          --------+            |
    //           |  +--------> sEPt |---------+  |
    //           |  |       --------+         |  |
    //     +--+--+--+--+                   +--+--+--+--+
    //     |   pRXp    |                   |   pTXp    |
    //     +------+----+                   +-----+-----+
    //          /|\                              |
    //           |                               |
    //           |                               |
    //           |                              \|/
    //
    //-------------------------------------------------------------------------
    pUdpRxPath(
            piSHL_Mmio_En,
            //[NOT_USED] piSHL_Mmio_EchoCtrl,
            siUSIF_Data,
            siUSIF_Meta,
            siUSIF_DLen,
            ssRXpToTXp_Data,
            ssRXpToTXp_Meta,
            ssRXpToTXp_DLen,
            ssRXpToESf_Data,
            ssRXpToESf_Meta,
            ssRXpToESf_DLen);
 
    pUdpEchoStoreAndForward(
            piSHL_Mmio_En,
            ssRXpToESf_Data,
            ssRXpToESf_Meta,
            ssRXpToESf_DLen,
            ssESfToTXp_Data,
            ssESfToTXp_Meta,
            ssESfToTXp_DLen);
 
    pUdpTxPath(
            piSHL_Mmio_En,
            //[NOT_USED] piSHL_Mmio_EchoCtrl,
            ssRXpToTXp_Data,
            ssRXpToTXp_Meta,
            ssRXpToTXp_DLen,
            ssESfToTXp_Data,
            ssESfToTXp_Meta,
            ssESfToTXp_DLen,
            soUSIF_Data,
            soUSIF_Meta,
            soUSIF_DLen);
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

udp_app_flash_top()

void udp_app_flash_top	(	CmdBit *	piSHL_Mmio_En,
		stream< UdpAppData > &	siUSIF_Data,
		stream< UdpAppMeta > &	siUSIF_Meta,
		stream< UdpAppDLen > &	siUSIF_DLen,
		stream< UdpAppData > &	soUSIF_Data,
		stream< UdpAppMeta > &	soUSIF_Meta,
		stream< UdpAppDLen > &	soUSIF_DLen
	)

Top of UDP Application Flash (UAF)

INTERFACE SYNTHESIS DIRECTIVES

Parameters

[in]	piSHL_Mmio_EchoCtrl	Configures the echo function.
[in]	piSHL_Mmio_PostPktEn	Enables posting of UDP packets.
[in]	piSHL_Mmio_CaptPktEn	Enables capture of UDP packets.
[in]	siUSIF_Data	UDP datagram from UdpShellInterface (USIF).
[in]	siUSIF_Meta	UDP metadata from [USIF].
[in]	siUSIF_DLen	UDP data len from [USIF].
[out]	soUSIF_Data	UDP datagram to [USIF].
[out]	soUSIF_Meta	UDP metadata to [USIF].
[out]	soUSIF_DLen	UDP data len to [USIF].

@info This toplevel exemplifies the instantiation of a core that uses AP_FIFO interfaces instead of AXIS.

ENTITY - UDP APPLICATION FLASH TOP (UAF_TOP)

Definition at line 130 of file udp_app_flash_top.cpp.

{
    //-- DIRECTIVES FOR THE INTERFACES ----------------------------------------
    #pragma HLS INTERFACE ap_ctrl_none port=return
 
  #if defined TAF_USE_NON_FIFO_IO
    #pragma HLS INTERFACE ap_stable register port=piSHL_Mmio_EchoCtrl  name=piSHL_Mmio_EchoCtrl
    #pragma HLS INTERFACE ap_stable port=piSHL_Mmio_PostPktEn
    #pragma HLS INTERFACE ap_stable port=piSHL_Mmio_CaptPktEn
  #endif
 
  #if defined (UAF_USE_AP_FIFO)
    //-- [USIF] INTERFACES ------------------------------------------------------
    #pragma HLS INTERFACE ap_fifo   port=siUSIF_Data    name=siUSIF_Data
    #pragma HLS DATA_PACK       variable=siUSIF_Data
    #pragma HLS INTERFACE ap_fifo   port=siUSIF_Meta    name=siUSIF_Meta
    #pragma HLS DATA_PACK       variable=siUSIF_Meta
    #pragma HLS INTERFACE ap_fifo   port=siUSIF_DLen    name=siUSIF_DLen
 
    #pragma HLS INTERFACE ap_fifo   port=soUSIF_Data    name=soUSIF_Data
    #pragma HLS DATA_PACK       variable=soUSIF_Data
    #pragma HLS INTERFACE ap_fifo   port=soUSIF_Meta    name=soUSIF_Meta
    #pragma HLS DATA_PACK       variable=soUSIF_Meta
    #pragma HLS INTERFACE ap_fifo   port=soUSIF_DLen    name=soUSIF_DLen
  #else
    //-- [USIF] INTERFACES ------------------------------------------------------
    #pragma HLS INTERFACE axis off  port=siUSIF_Data    name=siUSIF_Data
    #pragma HLS INTERFACE axis off  port=siUSIF_Meta    name=siUSIF_Meta
    #pragma HLS DATA_PACK       variable=siUSIF_Meta
    #pragma HLS INTERFACE axis off  port=siUSIF_DLen    name=siUSIF_DLen
 
    #pragma HLS INTERFACE axis off  port=soUSIF_Data    name=soUSIF_Data
    #pragma HLS INTERFACE axis off  port=soUSIF_Meta    name=soUSIF_Meta
    #pragma HLS DATA_PACK       variable=soUSIF_Meta
    #pragma HLS INTERFACE axis off  port=soUSIF_DLen    name=soUSIF_DLen
  #endif
 
    //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
#if HLS_VERSION == 2017
    #pragma HLS DATAFLOW
#else
    #pragma HLS DATAFLOW disable_start_propagation
#endif
    #pragma HLS INTERFACE ap_ctrl_none port=return
 
    //-- INSTANTIATE TOPLEVEL --------------------------------------------------
    udp_app_flash (
        //-- SHELL / Mmio Interfaces
        piSHL_Mmio_En,
    #if defined UAF_USE_NON_FIFO_IO
        piSHL_Mmio_EchoCtrl,
        piSHL_Mmio_PostPktEn,
        piSHL_Mmio_CaptPktEn,
    #endif
        //-- USIF / Rx Data Interfaces
        siUSIF_Data,
        siUSIF_Meta,
        siUSIF_DLen,
        //-- USIF / Tx Data Interfaces
        soUSIF_Data,
        soUSIF_Meta,
        soUSIF_DLen);
 
}

Here is the call graph for this function:

Variable Documentation

gFatalError [1/3]

bool gFatalError

extern

Definition at line 152 of file tb_nal.cpp.

gFatalError [2/3]

bool gFatalError = false

Definition at line 46 of file test_udp_app_flash.hpp.

gFatalError [3/3]

bool gFatalError = false

Definition at line 43 of file test_udp_app_flash_top.hpp.

gMaxSimCycles [1/5]

unsigned int gMaxSimCycles

extern

Definition at line 69 of file test_arp.hpp.

gMaxSimCycles [2/5]

unsigned int gMaxSimCycles

extern

Definition at line 69 of file test_arp.hpp.

gMaxSimCycles [3/5]

unsigned int gMaxSimCycles = 500 + 500

Definition at line 47 of file test_udp_app_flash.hpp.

gMaxSimCycles [4/5]

unsigned int gMaxSimCycles

extern

Definition at line 69 of file test_arp.hpp.

gMaxSimCycles [5/5]

unsigned int gMaxSimCycles = 500 + 500

Definition at line 44 of file test_udp_app_flash_top.hpp.

gSimCycCnt [1/5]

unsigned int gSimCycCnt

extern

GLOBAL VARIABLES USED BY THE SIMULATION ENVIRONMENT

Definition at line 150 of file tb_nal.cpp.

gSimCycCnt [2/5]

unsigned int gSimCycCnt

extern

GLOBAL VARIABLES USED BY THE SIMULATION ENVIRONMENT

Definition at line 150 of file tb_nal.cpp.

gSimCycCnt [3/5]

unsigned int gSimCycCnt = 0

GLOBAL VARIABLES USED BY THE SIMULATION ENVIRONMENT

Definition at line 44 of file test_udp_app_flash.hpp.

gSimCycCnt [4/5]

unsigned int gSimCycCnt

extern

GLOBAL VARIABLES USED BY THE SIMULATION ENVIRONMENT

Definition at line 150 of file tb_nal.cpp.

gSimCycCnt [5/5]

unsigned int gSimCycCnt = 0

GLOBAL VARIABLES USED BY THE SIMULATION ENVIRONMENT

Definition at line 41 of file test_udp_app_flash_top.hpp.

gTraceEvent [1/4]

bool gTraceEvent

extern

HELPERS FOR THE DEBUGGING TRACES .e.g: DEBUG_LEVEL = (RXP_TRACE | ESF_TRACE)

HELPERS FOR THE DEBUGGING TRACES .e.g: DEBUG_LEVEL = (MDL_TRACE | IPS_TRACE)

Definition at line 151 of file tb_nal.cpp.

gTraceEvent [2/4]

bool gTraceEvent

extern

HELPERS FOR THE DEBUGGING TRACES .e.g: DEBUG_LEVEL = (MDL_TRACE | IPS_TRACE)

Definition at line 151 of file tb_nal.cpp.

gTraceEvent [3/4]

bool gTraceEvent = false

HELPERS FOR THE DEBUGGING TRACES .e.g: DEBUG_LEVEL = (MDL_TRACE | IPS_TRACE)

Definition at line 45 of file test_udp_app_flash.hpp.

gTraceEvent [4/4]

bool gTraceEvent = false

HELPERS FOR THE DEBUGGING TRACES .e.g: DEBUG_LEVEL = (MDL_TRACE | IPS_TRACE)

Definition at line 42 of file test_udp_app_flash_top.hpp.