IPRX_TEST

Testbench for the IP Receiver packet handler (IPRX) of the Network Transport Stack (NTS). More...

Collaboration diagram for IPRX_TEST:

Macros
#define	THIS_NAME   "TB"
#define	TRACE_OFF   0x0000
#define	TRACE_CGF   1 << 1
#define	TRACE_ALL   0xFFFF
#define	DEBUG_LEVEL   (TRACE_OFF)
#define	TB_MAX_SIM_CYCLES   250000
#define	TB_STARTUP_DELAY   0
#define	TB_GRACE_TIME   5000

Functions
void	stepSim ()
	Increment the simulation counter. More...
int	createGoldenFiles (EthAddr myMacAddress, string inpDAT_FileName, string outARP_GoldName, string outICMP_GoldName, string outTOE_GoldName, string outUOE_GoldName)
	Create the golden reference files from an input test file. More...
void	iprx_top_wrap (EthAddr piMMIO_MacAddress, Ip4Addr piMMIO_Ip4Address, stream< AxisEth > &siETH_Data, stream< AxisArp > &soARP_Data, stream< AxisIp4 > &soICMP_Data, stream< AxisIp4 > &soICMP_Derr, stream< AxisIp4 > &soUOE_Data, stream< AxisIp4 > &soTOE_Data)
	A wrapper for the Toplevel of the IP Receive handler (IPRX). More...
int	main (int argc, char *argv[])
	Main function. More...

Variables
bool	gTraceEvent
bool	gFatalError
unsigned int	gSimCycCnt
unsigned int	gMaxSimCycles

Detailed Description

Testbench for the IP Receiver packet handler (IPRX) of the Network Transport Stack (NTS).

Macro Definition Documentation

DEBUG_LEVEL

#define DEBUG_LEVEL   (TRACE_OFF)

Definition at line 44 of file test_iprx.cpp.

TB_GRACE_TIME

#define TB_GRACE_TIME   5000

Definition at line 49 of file test_iprx.hpp.

TB_MAX_SIM_CYCLES

#define TB_MAX_SIM_CYCLES   250000

Definition at line 47 of file test_iprx.hpp.

TB_STARTUP_DELAY

#define TB_STARTUP_DELAY   0

Definition at line 48 of file test_iprx.hpp.

THIS_NAME

#define THIS_NAME   "TB"

Definition at line 39 of file test_iprx.cpp.

TRACE_ALL

#define TRACE_ALL   0xFFFF

Definition at line 43 of file test_iprx.cpp.

TRACE_CGF

#define TRACE_CGF   1 << 1

Definition at line 42 of file test_iprx.cpp.

TRACE_OFF

#define TRACE_OFF   0x0000

Definition at line 41 of file test_iprx.cpp.

Function Documentation

createGoldenFiles()

int createGoldenFiles	(	EthAddr	myMacAddress,
		string	inpDAT_FileName,
		string	outARP_GoldName,
		string	outICMP_GoldName,
		string	outTOE_GoldName,
		string	outUOE_GoldName
	)

Create the golden reference files from an input test file.

Parameters

[in]	myMacAddress	The MAC address of the FPGA.
[in]	inpDAT_FileName	The input DAT file to generate from.
[in]	outARP_GoldName	The ARP gold file to create.
[in]	outICMP_GoldName	The ICMP gold file.
[in]	outTOE_GoldName	The TOE gold file.
[in]	outUOE_GoldName	The UOE gold file.

Returns

NTS_OK if successful, otherwise NTS_KO.

Definition at line 72 of file test_iprx.cpp.

{
    const char *myName  = concat3(THIS_NAME, "/", "CGF");
 
    ifstream    ifsDAT;
    string      ofNameArray[4] = { outARP_GoldName, outICMP_GoldName, \
                                   outTOE_GoldName, outUOE_GoldName };
    ofstream    ofsArray[4]; // Stored in the same alphabetic same order
 
    string          strLine;
    char            currPath[FILENAME_MAX];
    deque<SimEthFrame> ethRxFramer; // Double-ended queue of frames for IPRX
    int  ret = NTS_OK;
    int  inpChunks=0, arpChunks=0, icmpChunks=0, tcpChunks=0, udpChunks=0, outChunks=0;
    int  inpFrames=0, arpFrames=0, icmpFrames=0, tcpFrames=0, udpFrames=0, outFrames=0;
    int  inpBytes=0,  arpBytes=0,  icmpBytes=0,  tcpBytes=0,  udpBytes=0,  outBytes=0;
    bool assessTkeepTlast = true;
 
    //-- STEP-1 : OPEN INPUT FILE AND ASSESS ITS EXTENSION
    ifsDAT.open(inpDAT_FileName.c_str());
    if (!ifsDAT) {
        getcwd(currPath, sizeof(currPath));
        printError(myName, "Cannot open the file: %s \n\t (FYI - The current working directory is: %s) \n", inpDAT_FileName.c_str(), currPath);
        return(NTS_KO);
    }
    if (not isDatFile(inpDAT_FileName)) {
        printError(myName, "Cannot create golden files from input file \'%s\' because file is not of type \'.dat\'.\n", inpDAT_FileName.c_str());
        ifsDAT.close();
        return(NTS_KO);
    }
 
    //-- STEP-2 : OPEN THE OUTPUT GOLD FILES
    for (int i=0; i<4; i++) {
        remove(ofNameArray[i].c_str());
        if (!ofsArray[i].is_open()) {
            ofsArray[i].open (ofNameArray[i].c_str(), ofstream::out);
            if (!ofsArray[i]) {
                printFatal(THIS_NAME, "Could not open the output gold file \'%s\'. \n", ofNameArray[i].c_str());
            }
        }
    }
 
    //-- STEP-3 : READ AND PARSE THE INPUT ETHERNET FILE
    while ((ifsDAT.peek() != EOF) && (ret != NTS_KO)) {
        SimEthFrame    ethFrame;
        AxisEth        axisEth;
        vector<string> stringVector;
        string         stringBuffer;
        bool           endOfFrame=false;
        bool           rc;
        // Build a new frame from data file
        while ((ifsDAT.peek() != EOF) && (!endOfFrame)) {
            //-- Read one line at a time from the input DAT file
            getline(ifsDAT, stringBuffer);
            stringVector = myTokenizer(stringBuffer, ' ');
            //-- Read an AxisChunk from line
            rc = readAxisRawFromLine(axisEth, stringBuffer);
            if (rc) {
                if (axisEth.isValid()) {
                    ethFrame.pushChunk(axisEth);
                    if (axisEth.getLE_TLast() == 1) {
                        inpFrames++;
                        endOfFrame = true;
                    }
                }
                else {
                    // We always abort the stream as this point by asserting
                    // 'tlast' and de-asserting 'tkeep'.
                    ethFrame.pushChunk(AxisEth(axisEth.getLE_TData(), 0x00, 1));
                    inpFrames++;
                    endOfFrame = true;
                }
                inpChunks++;
                inpBytes += axisEth.getLen();
            }
        }
        if (endOfFrame) {
            // Assess MAC_DA is valid
            EthAddr  macDA = ethFrame.getMacDestinAddress();
            if((macDA != myMacAddress) and (macDA != 0xFFFFFFFFFFFF)) {
                printWarn(THIS_NAME, "Frame #%d is dropped because MAC_DA does not match.\n", inpFrames);
            }
            else {
                // Parse this frame and generate corresponding golden file(s)
                EtherType etherType = ethFrame.getTypeLength();
                SimIp4Packet  ipPacket;
                SimArpPacket  arpPacket;
                if (etherType.to_uint() >= 0x0600) {
                    switch (etherType.to_uint()) {
                    case ETH_ETHERTYPE_ARP:
                        arpPacket = ethFrame.getArpPacket();
                        if (DEBUG_LEVEL & TRACE_CGF) {
                            printInfo(myName, "Frame #%d is an ARP frame.\n", inpFrames);
                        }
                        if (ethFrame.sizeOfPayload() > 0) {
                            if (ethFrame.writeToDatFile(ofsArray[0]) == false) {
                                printError(myName, "Failed to write ARP frame to DAT file.\n");
                                rc = NTS_KO;
                            }
                            arpFrames += 1;
                            arpChunks += arpPacket.size();
                            arpBytes  += arpPacket.length();
                        }
                        else {
                            printError(myName, "This Ethernet frame has zero payload bytes!?\n");
                            rc = NTS_KO;
                        }
                        break;
                    case ETH_ETHERTYPE_IP4:
                        ipPacket = ethFrame.getIpPacket();
                        if (ipPacket.getIpVersion() != 4) {
                            printWarn(myName, "Frame #%d is dropped because IP version is not \'4\'.\n", inpFrames);
                            continue;
                        }
                        else if (DEBUG_LEVEL & TRACE_CGF) {
                            printInfo(myName, "Frame #%d is an IPv4 frame (EtherType=0x%4.4X).\n",
                                      inpFrames, etherType.to_uint());
                        }
                        if (ipPacket.verifyIpHeaderChecksum()) {
                            if (ethFrame.sizeOfPayload() > 0) {
                                if (ipPacket.writeToDatFile(ofsArray[2]) == false) {
                                    printError(THIS_NAME, "Failed to write IPv4 packet to DAT file.\n");
                                    rc = NTS_KO;
                                }
                            }
                            switch (ipPacket.getIpProtocol()) {
                            case 1:  // ICMP
                                icmpFrames += 1;
                                icmpChunks += ipPacket.size();
                                icmpBytes  += ipPacket.length();
                                break;
                            case 6:  // TCP
                                tcpFrames += 1;
                                tcpChunks += ipPacket.size();
                                tcpBytes  += ipPacket.length();
                                break;
                            case 17: // UDP
                                udpFrames += 1;
                                udpChunks += ipPacket.size();
                                udpBytes  += ipPacket.length();
                                break;
                            default:
                                printError(myName, "Unknown IP protocol #%d.\n",
                                           ipPacket.getIpProtocol());
                                rc = NTS_KO;
                            }
                        }
                        else {
                            printWarn(myName, "Frame #%d is dropped because IPv4 header checksum does not match.\n", inpFrames);
                        }
                        break;
                    default:
                        printError(myName, "Unsupported protocol 0x%4.4X.\n", etherType.to_ushort());
                        rc = NTS_KO;
                        break;
                    }
                }
            }
        }
    }
 
    //-- STEP-3: CLOSE FILES
    ifsDAT.close();
    for (int i=0; i<4; i++) {
        ofsArray[i].close();
    }
 
    //-- STEP-4: PRINT RESULTS
    outFrames = arpFrames + icmpFrames + tcpFrames + udpFrames;
    outChunks = arpChunks + icmpChunks + tcpChunks + udpChunks;
    outBytes  = arpBytes  + icmpBytes  + tcpBytes  + udpBytes;
    printInfo(myName, "Done with the creation of the golden files.\n");
    printInfo(myName, "\tProcessed %5d chunks in %4d frames, for a total of %6d bytes.\n",
              inpChunks, inpFrames, inpBytes);
    printInfo(myName, "\tGenerated %5d chunks in %4d frames, for a total of %6d bytes.\n\n",
              outChunks, outFrames, outBytes);
    printInfo(myName, "\tARP  : %5d chunks in %4d frames, for a total of %6d bytes.\n",
              arpChunks, arpFrames, arpBytes);
    printInfo(myName, "\tICMP : %5d chunks in %4d frames, for a total of %6d bytes.\n",
              icmpChunks, icmpFrames, icmpBytes);
    printInfo(myName, "\tTCP  : %5d chunks in %4d frames, for a total of %6d bytes.\n",
              tcpChunks, tcpFrames, tcpBytes);
    printInfo(myName, "\tUDP  : %5d chunks in %4d frames, for a total of %6d bytes.\n\n",
              udpChunks, udpFrames, udpBytes);
 
    return(ret);
}

Here is the call graph for this function:

Here is the caller graph for this function:

iprx_top_wrap()

void iprx_top_wrap	(	EthAddr	piMMIO_MacAddress,
		Ip4Addr	piMMIO_Ip4Address,
		stream< AxisEth > &	siETH_Data,
		stream< AxisArp > &	soARP_Data,
		stream< AxisIp4 > &	soICMP_Data,
		stream< AxisIp4 > &	soICMP_Derr,
		stream< AxisIp4 > &	soUOE_Data,
		stream< AxisIp4 > &	soTOE_Data
	)

A wrapper for the Toplevel of the IP Receive handler (IPRX).

Parameters

[in]	piMMIO_MacAddress	The MAC address from MMIO (in network order).
[in]	piMMIO_Ip4Address	The IPv4 address from MMIO (in network order).
[in]	siETH_Data	Data stream from ETHernet MAC layer (ETH).
[out]	soARP_Data	Data stream to Address Resolution Protocol (ARP) server.
[out]	soICMP_Data	Data stream to Internet Control Message Protocol (ICMP) engine.
[out]	soICMP_Derr	Data stream in error to [ICMP].
[out]	soUOE_Data	Data stream to UDP Offload Engine (UOE).
[out]	soTOE_Data	Data stream to TCP Offload Engine (TOE).

This process is a wrapper for the 'iprx_top' entity. It instantiates such an entity and further connects it with base 'AxisRaw' streams as expected by the 'iprx_top'.

Definition at line 281 of file test_iprx.cpp.

{
    //-- LOCAL INPUT and OUTPUT STREAMS -------------------
    static stream<AxisRaw>     ssiETH_Data ("ssiETH_Data");
    static stream<AxisRaw>     ssoARP_Data ("ssoARP_Data");
    static stream<AxisRaw>     ssoICMP_Data("ssoICMP_Data");
    static stream<AxisRaw>     ssoICMP_Derr("ssoICMP_Derr");
    static stream<AxisRaw>     ssoUOE_Data ("ssoUOE_Data");
    static stream<AxisRaw>     ssoTOE_Data ("ssoTOE_Data");
 
    //-- INPUT STREAM CASTING -----------------------------
    pAxisRawCast(siETH_Data, ssiETH_Data);
 
    //-- MAIN IPRX_TOP PROCESS ----------------------------
    iprx_top(
        piMMIO_MacAddress,
        piMMIO_Ip4Address,
        ssiETH_Data,
        ssoARP_Data,
        ssoICMP_Data,
        ssoICMP_Derr,
        ssoUOE_Data,
        ssoTOE_Data);
 
    //-- OUTPUT STREAM CASTING ----------------------------
    pAxisRawCast(ssoARP_Data,  soARP_Data);
    pAxisRawCast(ssoICMP_Data, soICMP_Data);
    pAxisRawCast(ssoICMP_Derr, soICMP_Derr);
    pAxisRawCast(ssoUOE_Data,  soUOE_Data);
    pAxisRawCast(ssoTOE_Data,  soTOE_Data);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

main()

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

Main function.

Parameters

[in]

inpFile

The pathname of the input test vector file.

Definition at line 333 of file test_iprx.cpp.

                                 {
 
    //------------------------------------------------------
    //-- TESTBENCH GLOBAL VARIABLES
    //------------------------------------------------------
    gTraceEvent   = false;
    gFatalError   = false;
    gSimCycCnt    = 0;
    gMaxSimCycles = TB_STARTUP_DELAY + TB_MAX_SIM_CYCLES;
 
    //------------------------------------------------------
    //-- TESTBENCH LOCAL VARIABLES
    //------------------------------------------------------
    int         nrErr  = 0;     // Tb error counter.
 
    string      ofsARP_Data_FileName = "../../../../test/simOutFiles/soARP_Data.dat";
    string      ofsTOE_Data_FileName = "../../../../test/simOutFiles/soTOE_Data.dat";
    string      ofsUOE_Data_FileName = "../../../../test/simOutFiles/soUOE_Data.dat";
    string      ofsICMP_Data_FileName= "../../../../test/simOutFiles/soICMP_Data.dat";
    string      dataFileArray[4] = { ofsARP_Data_FileName, ofsTOE_Data_FileName, \
                                     ofsUOE_Data_FileName, ofsICMP_Data_FileName };
 
    string      ofsARP_Gold_FileName = "../../../../test/simOutFiles/soARP_Gold.dat";
    string      ofsTOE_Gold_FileName = "../../../../test/simOutFiles/soTOE_Gold.dat";
    string      ofsUOE_Gold_FileName = "../../../../test/simOutFiles/soUOE_Gold.dat";
    string      ofsICMP_Gold_FileName= "../../../../test/simOutFiles/soICMP_Gold.dat";
    string      goldFileArray[4] = { ofsARP_Gold_FileName, ofsTOE_Gold_FileName, \
                                     ofsUOE_Gold_FileName, ofsICMP_Gold_FileName };
 
    Ip4Addr     myIp4Address = 0x01010101;
    EthAddr     myMacAddress = 0x010203040506;
    int         errCount    = 0;
 
    //------------------------------------------------------
    //-- DUT STREAM INTERFACES and RELATED VARIABLEs
    //------------------------------------------------------
    //-- Incoming streams
    stream<AxisEth> ssETH_IPRX_Data  ("ssETH_IPRX_Data");
    int             nrETH_IPRX_Chunks = 0;
    int             nrETH_IPRX_Frames = 0;
    int             nrETH_IPRX_Bytes  = 0;
    //-- Outgoing streams
    stream<AxisArp> ssIPRX_ARP_Data  ("ssIPRX_ARP_Data");
    int             nrIPRX_ARP_Chunks = 0;
    int             nrIPRX_ARP_Frames = 0;
    int             nrIPRX_ARP_Bytes  = 0;
    stream<AxisIp4> ssIPRX_TOE_Data  ("ssIPRX_TOE_Data");
    int             nrIPRX_TOE_Chunks = 0;
    int             nrIPRX_TOE_Frames = 0;
    int             nrIPRX_TOE_Bytes  = 0;
    stream<AxisIp4> ssIPRX_UOE_Data  ("ssIPRX_UOE_Data");
    int             nrIPRX_UOE_Chunks = 0;
    int             nrIPRX_UOE_Frames = 0;
    int             nrIPRX_UOE_Bytes  = 0;
    stream<AxisIp4> ssIPRX_ICMP_Data ("ssIPRX_ICMP_Data");
    int             nrIPRX_ICMP_Chunks = 0;
    int             nrIPRX_ICMP_Frames = 0;
    int             nrIPRX_ICMP_Bytes  = 0;
    stream<AxisIp4> ssIPRX_ICMP_DErr ("ssIPRX_ICMP_DErr");
 
    //------------------------------------------------------
    //-- OPEN INPUT TEST VECTOR FILE
    //------------------------------------------------------
    if (argc != 2) {
        printFatal(THIS_NAME, "Missing testbench parameter:\n\t Expecting an input test vector file.\n");
    }
 
    //------------------------------------------------------
    //-- CREATE DUT INPUT TRAFFIC AS STREAMS
    //------------------------------------------------------
    if (feedAxisFromFile<AxisEth>(ssETH_IPRX_Data, "ssETH_IPRX_Data", string(argv[1]),
            nrETH_IPRX_Chunks, nrETH_IPRX_Frames, nrETH_IPRX_Bytes)) {
        printInfo(THIS_NAME, "Done with the creation of the input traffic as streams:\n");
        printInfo(THIS_NAME, "\tGenerated %d chunks in %d frames, for a total of %d bytes.\n\n",
                                nrETH_IPRX_Chunks, nrETH_IPRX_Frames, nrETH_IPRX_Bytes);
    }
    else {
        printError(THIS_NAME, "Failed to create traffic as input stream. \n");
        nrErr++;
    }
 
    //------------------------------------------------------
    //-- CREATE OUTPUT GOLD TRAFFIC
    //------------------------------------------------------
    if (not createGoldenFiles(myMacAddress, string(argv[1]),
                              ofsARP_Gold_FileName, ofsICMP_Gold_FileName,
                              ofsTOE_Gold_FileName, ofsUOE_Gold_FileName)) {
        printError(THIS_NAME, "Failed to create golden files. \n");
        nrErr++;
    }
 
    printInfo(THIS_NAME, "############################################################################\n");
    printInfo(THIS_NAME, "## TESTBENCH 'test_iprx' STARTS HERE                                      ##\n");
    printInfo(THIS_NAME, "############################################################################\n");
    printInfo(THIS_NAME, "This testbench will be executed with the following parameters: \n");
    for (int i=1; i<argc; i++) {
        printInfo(THIS_NAME, "\t==> Param[%d] = %s\n", (i-1), argv[i]);
    }
    printf("\n\n");
 
    int tbRun = nrETH_IPRX_Chunks + TB_GRACE_TIME;
 
    while (tbRun) {
        //-- RUN DUT --------------------------------------
      #if HLS_VERSION == 2017
        iprx_top(
            myMacAddress,
            myIp4Address,
            ssETH_IPRX_Data,
            ssIPRX_ARP_Data,
            ssIPRX_ICMP_Data,
            ssIPRX_ICMP_DErr,
            ssIPRX_UOE_Data,
            ssIPRX_TOE_Data);
      #else
        iprx_top_wrap(
            myMacAddress,
            myIp4Address,
            ssETH_IPRX_Data,
            ssIPRX_ARP_Data,
            ssIPRX_ICMP_Data,
            ssIPRX_ICMP_DErr,
            ssIPRX_UOE_Data,
            ssIPRX_TOE_Data);
      #endif
        tbRun--;
        stepSim();
    }
 
    //---------------------------------------------------------------
    //-- DRAIN DUT OUTPUT STREAMS
    //---------------------------------------------------------------
    if (not drainAxisToFile<AxisIp4>(ssIPRX_TOE_Data, "ssIPRX_TOE_Data", ofsTOE_Data_FileName,
            nrIPRX_TOE_Chunks, nrIPRX_TOE_Frames, nrIPRX_TOE_Bytes)) {
        printError(THIS_NAME, "Failed to drain TOE traffic from DUT. \n");
        nrErr++;
    }
    if (not drainAxisToFile<AxisIp4>(ssIPRX_UOE_Data, "ssIPRX_UOE_Data", ofsUOE_Data_FileName,
            nrIPRX_UOE_Chunks, nrIPRX_UOE_Frames, nrIPRX_UOE_Bytes)) {
        printError(THIS_NAME, "Failed to drain UDP traffic from DUT. \n");
        nrErr++;
    }
    if (not drainAxisToFile<AxisArp>(ssIPRX_ARP_Data, "ssIPRX_ARP_Data", ofsARP_Data_FileName,
            nrIPRX_ARP_Chunks, nrIPRX_ARP_Frames, nrIPRX_ARP_Bytes)) {
        printError(THIS_NAME, "Failed to drain ARP traffic from DUT. \n");
        nrErr++;
    }
    if (not drainAxisToFile<AxisIp4>(ssIPRX_ICMP_Data, "ssIPRX_ICMP_Data", ofsICMP_Data_FileName,
            nrIPRX_ICMP_Chunks, nrIPRX_ICMP_Frames, nrIPRX_ICMP_Bytes)) {
        printError(THIS_NAME, "Failed to drain ICMP traffic from DUT. \n");
        nrErr++;
    }
 
    printInfo(THIS_NAME, "############################################################################\n");
    printInfo(THIS_NAME, "## TESTBENCH 'test_iprx' ENDS HERE                                        ##\n");
    printInfo(THIS_NAME, "############################################################################\n");
    stepSim();
 
    //---------------------------------------------------------------
    //-- COMPARE OUTPUT DAT and GOLD STREAMS
    //---------------------------------------------------------------
    int    res[4] = { 0, 0, 0, 0 };
    for (int i=0; i<4; i++ ) {
        res[i] = system(("diff --brief -w " + std::string(dataFileArray[i]) + " " + std::string(goldFileArray[i]) + " ").c_str());
        if (res[i]) {
            printError(THIS_NAME, "File \'%s\' does not match \'%s\'.\n", dataFileArray[i].c_str(), goldFileArray[i].c_str());
            nrErr += 1;
        }
    }
 
    //---------------------------------------------------------------
    //-- PRINT TESTBENCH STATUS
    //---------------------------------------------------------------
    printf("\n\n");
    printInfo(THIS_NAME, "This testbench was executed with the following ETH test-file: \n");
    for (int i=1; 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:

stepSim()

void stepSim

(

)

Increment the simulation counter.

Definition at line 49 of file test_iprx.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);
    }
}

Here is the caller graph for this function:

Variable Documentation

gFatalError

bool gFatalError

Definition at line 57 of file test_iprx.hpp.

gMaxSimCycles

unsigned int gMaxSimCycles

Definition at line 59 of file test_iprx.hpp.

gSimCycCnt

unsigned int gSimCycCnt

GLOBAL VARIABLES USED BY THE SIMULATION ENVIRONMENT

Definition at line 58 of file test_iprx.hpp.

gTraceEvent

bool gTraceEvent

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

Definition at line 56 of file test_iprx.hpp.