Memtest Testbench

This is a subgroup of Memtest accelerated function with only testbench-related functions/classes. More...

Collaboration diagram for Memtest Testbench:

Files
file	memtest_host_fwd_tb.cpp
	Testbench for Memtest userspace application for cF (x86, ppc64).
file	test_memtest.cpp
	: Testbench for Memtest.

Macros
#define	THIS_NAME   "TB"
#define	TRACE_OFF   0x0000
#define	TRACE_URIF   1 << 1
#define	TRACE_UAF   1 << 2
#define	TRACE_MMIO   1 << 3
#define	TRACE_ALL   0xFFFF
#define	DEBUG_MULTI_RUNS   True
#define	TB_MULTI_RUNS_ITERATIONS   2
#define	DEBUG_LEVEL   (TRACE_ALL)
#define	OK   true
#define	KO   false
#define	VALID   true
#define	UNVALID   false
#define	DEBUG_TRACE   true
#define	ENABLED   (ap_uint<1>)1
#define	DISABLED   (ap_uint<1>)0
#define	MEMORY_LINES_512   TOTMEMDW_512 /* 64 KiB */

Functions
int	main (int argc, char *argv[])
stream< UdpWord >	sSHL_Uaf_Data ("sSHL_Uaf_Data")
stream< UdpWord >	sUAF_Shl_Data ("sUAF_Shl_Data")
stream< UdpWord >	image_stream_from_memtest ("image_stream_from_memtest")
stream< NetworkMetaStream >	siUdp_meta ("siUdp_meta")
stream< NetworkMetaStream >	soUdp_meta ("soUdp_meta")
void	stepDut ()
	Run a single iteration of the DUT model. More...
int	main (int argc, char **argv)
	Main testbench of Hrris. More...

Variables
ap_uint< 1 >	piSHL_This_MmioPostPktEn
ap_uint< 1 >	piSHL_This_MmioCaptPktEn
ap_uint< 32 >	s_udp_rx_ports = 0x0
ap_uint< 32 >	node_rank
ap_uint< 32 >	cluster_size
unsigned int	simCnt
membus_t	lcl_mem0 [16384]
membus_t	lcl_mem1 [16384]

Detailed Description

This is a subgroup of Memtest accelerated function with only testbench-related functions/classes.

Macro Definition Documentation

DEBUG_LEVEL

#define DEBUG_LEVEL   (TRACE_ALL)

Definition at line 39 of file test_memtest.cpp.

DEBUG_MULTI_RUNS

#define DEBUG_MULTI_RUNS   True

Definition at line 37 of file test_memtest.cpp.

DEBUG_TRACE

#define DEBUG_TRACE   true

Definition at line 49 of file test_memtest.cpp.

DISABLED

#define DISABLED   (ap_uint<1>)0

Definition at line 52 of file test_memtest.cpp.

ENABLED

#define ENABLED   (ap_uint<1>)1

Definition at line 51 of file test_memtest.cpp.

KO

#define KO   false

Definition at line 46 of file test_memtest.cpp.

MEMORY_LINES_512

#define MEMORY_LINES_512   TOTMEMDW_512 /* 64 KiB */

Definition at line 86 of file test_memtest.cpp.

OK

#define OK   true

Definition at line 45 of file test_memtest.cpp.

TB_MULTI_RUNS_ITERATIONS

#define TB_MULTI_RUNS_ITERATIONS   2

Definition at line 38 of file test_memtest.cpp.

THIS_NAME

#define THIS_NAME   "TB"

Definition at line 30 of file test_memtest.cpp.

TRACE_ALL

#define TRACE_ALL   0xFFFF

Definition at line 36 of file test_memtest.cpp.

TRACE_MMIO

#define TRACE_MMIO   1 << 3

Definition at line 35 of file test_memtest.cpp.

TRACE_OFF

#define TRACE_OFF   0x0000

Definition at line 32 of file test_memtest.cpp.

TRACE_UAF

#define TRACE_UAF   1 << 2

Definition at line 34 of file test_memtest.cpp.

TRACE_URIF

#define TRACE_URIF   1 << 1

Definition at line 33 of file test_memtest.cpp.

UNVALID

#define UNVALID   false

Definition at line 48 of file test_memtest.cpp.

VALID

#define VALID   true

Definition at line 47 of file test_memtest.cpp.

Function Documentation

image_stream_from_memtest()

stream<UdpWord> image_stream_from_memtest

(

"image_stream_from_memtest"

)

main() [1/2]

int main	(	int	argc,
		char **	argv
	)

Main testbench of Hrris.

Returns

0 upon success, nrErr else.

Definition at line 119 of file test_memtest.cpp.

                                {
 
    //------------------------------------------------------
    //-- TESTBENCH LOCAL VARIABLES
    //------------------------------------------------------
    int         nrErr = 0;
 
    printf("#####################################################\n");
    printf("## TESTBENCH STARTS HERE                           ##\n");
    printf("#####################################################\n");
// consider to execute : ulimit -s unlimited
// if any stack/memory related issue before executing
 
    if (argc < 3 || argc > 5) {
        printf("Usage : %s <number of address to test> , <testing times> , <burst size> <command string ready2go> ;provided %d\n", argv[0], argc);
        return -1;
    }
 
    //------------------------------------------------------
    //-- TESTBENCH Input parsing
    //------------------------------------------------------
    string strInput_memaddrUT = argv[1];
    string strInput_nmbrTest = argv[2];
    string strInput_burstSize = argv[3];
    string strInput_commandstring= "";
    if(argc > 4)
    {
      strInput_commandstring.assign(argv[4]);
    }
    unsigned long long int memory_addr_under_test=0;
    unsigned int testingNumber = 1;
    unsigned int burst_size = 1;
    if (!strInput_memaddrUT.length() || !strInput_nmbrTest.length()) {
        printf("ERROR: Empty string provided. Aborting...\n");
        return -1;
    }
    else {
      try
      {
       memory_addr_under_test = stoull(strInput_memaddrUT);
      }
      catch(const std::exception& e)
      {
        std::cerr << e.what() << '\n';
        memory_addr_under_test = 65; //at least a fault
      }
      try
      {     
        testingNumber = stoul(strInput_nmbrTest);
      }
      catch(const std::exception& e)
      {
        std::cerr << e.what() << '\n';
        testingNumber = 3; //at least see the fault
      }
 
      try
      {     
        burst_size = stoul(strInput_burstSize);
      }
      catch(const std::exception& e)
      {
        std::cerr << e.what() << '\n';
        burst_size = 1; //at least see the fault
      }
      
 
      printf("Succesfully loaded string ... %s\n", argv[1]);
      printf("Succesfully loaded the address number %u and the number of testings %u, with busrt size %u\n", memory_addr_under_test, testingNumber, burst_size);
      // Ensure that the selection of MTU is a multiple of 8 (Bytes per transaction)
      assert(PACK_SIZE % 8 == 0);
    }
 
    //------------------------------------------------------
    //-- TESTBENCH LOCAL VARIABLES FOR MEMTEST
    //------------------------------------------------------
    //unsigned int sim_time = testingNumber * ((2 * (memory_addr_under_test/64+2)) + 5 + 1) + 2 + 1 + 20; // # of tests*((2*(rd/wr addresses + 2 state update))+start+out*4) + meta+start + 10 random cycles
    unsigned int sim_time = 1 + 3 + testingNumber * (1 + 2 + 5) + 1 + 2 + 10;     // meta-pckt-brst testnmbr*(strt-wr-rd-out1-out2-out3-out4-out5) + final cntstart + 2 tx + 10 rand
    size_t charInputSize = 8*2; //a single tdata is the current command dimension for this test, plus the burst cmd
    size_t charOutputSize = 8*1+((8 * (2 + 1 + 1 + 1)) * testingNumber); //overdimensioned: eventual stop, 4 (address, fault cntr, flt addr, ccs) for each test foreach test
 
    unsigned int tot_input_transfers = CEIL(( 2 ) * 8,PACK_SIZE);// only a single tx + 1
    unsigned int tot_output_transfers =  charOutputSize%PACK_SIZE==0 ? charOutputSize/PACK_SIZE : charOutputSize/PACK_SIZE + 1; // check if bigger output than mtu
    // if(charOutputSize>PACK_SIZE){
    //   tot_output_transfers = charOutputSize%PACK_SIZE==0 ? charOutputSize/PACK_SIZE : charOutputSize/PACK_SIZE + 1;
    // }
 
    char *charOutput = (char*)malloc((charOutputSize)* sizeof(char)); // 
     //char * charOutput = new char[(charOutputSize)* sizeof(char)];
    char *charInput = (char*)malloc(charInputSize* sizeof(char)); // 
    //char * charInput = new char[(charInputSize)* sizeof(char)]; //
 
    if (!charOutput || !charInput) {
        printf("ERROR: Cannot allocate memory for output string. Aborting...\n");
        return -1;
    }
    std::vector<MemoryTestResult> testResults_vector;
    
    //------------------------------------------------------
    //-- STEP-1.1 : CREATE MEMORY FOR OUTPUT IMAGES
    //------------------------------------------------------
  unsigned int bytes_per_line = 8;
  string strInput;
  strInput.reserve(charInputSize+1);
  string strGold;
  strGold.reserve(charOutputSize+1);
  
#ifdef SIM_STOP_COMPUTATION // stop the comptuation with a stop command after some CCs
  
  std::string strStop; 
    char stop_cmd [bytes_per_line];
    for (unsigned int k = 0; k < bytes_per_line; k++) {
        if (k != 0) {
            stop_cmd[k] = (char)0;
        }
        else {
            stop_cmd[k] = (char)2;
        }
     }
  strStop.append(stop_cmd,8);
#endif //SIM_STOP_COMPUTATION
 
 
    simCnt = 0;
    nrErr  = 0;
// Assumption: if the user knows how to format the command stream she/he does by itself (
// otheriwse the TB takes care and create the commands based on the inputs
    if(!strInput_commandstring.length()){
      strInput=createMemTestCommands(memory_addr_under_test, testingNumber, burst_size);
    }else{
      //char * char_command = new char[strInput_commandstring.length()+1];
      char * char_command = (char*)malloc((strInput_commandstring.length()+1)* sizeof(char));
      char_command[0]='\0';//initi just for the sake
      char tmp_char_cmd [1];
      tmp_char_cmd[1] = (char)0;
      unsigned int tmp_int_cmd = 0;
      //char_command = new char[strInput_commandstring.length()];
    //  cout << strInput_commandstring << endl;
    //   for (int i = 0; i < strInput_commandstring.length(); i++)
    //   {
    //     tmp_char_cmd[1] = strInput_commandstring[i];
    //     tmp_int_cmd = (unsigned int)atoi(tmp_char_cmd);
    //     memcpy(char_command+i,(char*)&tmp_int_cmd, sizeof(char));
    //     tmp_char_cmd[1] = (char)0;
    //     tmp_int_cmd = 0;
    //   }
    //   strInput.append(char_command,strInput_commandstring.length());
    //   printStringHex(strInput_commandstring, strInput_commandstring.length());
    //   printCharBuffHex(char_command, strInput_commandstring.length());
    //   printStringHex(strInput, strInput_commandstring.length());
    strInput=createMemTestCommands(memory_addr_under_test, testingNumber, burst_size);
        if(char_command != NULL){
          cout << "Clearing the char command" << endl;
          delete[] char_command;
          char_command = NULL;
        }
    }
    //Create the expected result
    strGold = createMemTestGoldenOutput(memory_addr_under_test, testingNumber, true);
 
    if (!dumpStringToFile(strInput, "ifsSHL_Uaf_Data.dat", simCnt)) {
      nrErr++;
    }
    //Set the tlast every PACK_SIZE/8 commands if big output tests
    if (!dumpStringToFileWithLastSetEveryGnoPackets(strGold, "verify_UAF_Shl_Data.dat", simCnt, PACK_SIZE/8)){ 
      nrErr++;
    }
 
#ifdef SIM_STOP_COMPUTATION // stop the comptuation with a stop command after some CCs
    if (!dumpStringToFile(strStop, "ifsSHL_Uaf_STOPData.dat", simCnt)){ 
      nrErr++;
    }
#endif // SIM_STOP_COMPUTATION
 
 
#ifdef DEBUG_MULTI_RUNS // test if the HLS kernel has reinit issues with streams leftovers or other stuffs
for(int iterations=0; iterations < TB_MULTI_RUNS_ITERATIONS; iterations++){
#endif //DEBUG_MULTI_RUNS
 
#ifdef ENABLE_DDR
for(int i=0; i < MEMORY_LINES_512; i++){
  lcl_mem0[i]=0;
  lcl_mem1[i]=0;
}
#endif//ENABLE_DDR
  //------------------------------------------------------
  //-- STEP-2.1 : CREATE TRAFFIC AS INPUT STREAMS
  //------------------------------------------------------
  if (nrErr == 0) {
    if (!setInputDataStream(sSHL_Uaf_Data, "sSHL_Uaf_Data", "ifsSHL_Uaf_Data.dat", simCnt)) { 
        printf("### ERROR : Failed to set input data stream \"sSHL_Uaf_Data\". \n");
        nrErr++;
    }
    //there are tot_input_transfers streams from the the App to the Role
    NetworkMeta tmp_meta = NetworkMeta(1,DEFAULT_RX_PORT,0,DEFAULT_RX_PORT,0);
    for (unsigned int i=0; i<tot_input_transfers; i++) {
      siUdp_meta.write(NetworkMetaStream(tmp_meta));
    } 
 
      //set correct node_rank and cluster_size
    node_rank = 1;
    cluster_size = 2;
  }
    //------------------------------------------------------
    //-- STEP-3 : MAIN TRAFFIC LOOP
    //------------------------------------------------------
    while (!nrErr) {
      // Keep enough simulation time for sequntially executing the FSMs of the main  functions 
      // (Rx-Tx)
      if (simCnt < sim_time) 
      {
        //+1
          stepDut();
          if(simCnt > 2)
          {
            assert(s_udp_rx_ports == 0x1);
          }
 
  #ifdef SIM_STOP_COMPUTATION // stop the comptuation with a stop command after some CCs manual insertion with define
          if(simCnt == testingNumber * ((2 * (memory_addr_under_test+1))) + 2){
            if (!setInputDataStream(sSHL_Uaf_Data, "sSHL_Uaf_Data", "ifsSHL_Uaf_STOPData.dat", simCnt)) { 
            printf("### ERROR : Failed to set input data stream \"sSHL_Uaf_Data\". \n");
            nrErr++;
            }
            //there are tot_input_transfers streams from the the App to the Role
            NetworkMeta tmp_meta = NetworkMeta(1,DEFAULT_RX_PORT,0,DEFAULT_RX_PORT,0);
            for (unsigned int i=0; i<tot_input_transfers; i++) {
              siUdp_meta.write(NetworkMetaStream(tmp_meta));
            }        
            //set correct node_rank and cluster_size
                  node_rank = 1;
                  cluster_size = 2;
            }
  #endif //SIM_STOP_COMPUTATION
    } else {
        printf("## End of simulation at cycle=%3d. \n", simCnt);
        break;
    }
 
  }  // End: while()
 
    //-------------------------------------------------------
    //-- STEP-4 : DRAIN AND WRITE OUTPUT FILE STREAMS
    //-------------------------------------------------------
    //---- UAF-->SHELL Data ----
    if (!getOutputDataStream(sUAF_Shl_Data, "sUAF_Shl_Data", "ofsUAF_Shl_Data.dat", simCnt))
    {
        nrErr++;
    }
    //---- UAF-->SHELL META ----
    if( !soUdp_meta.empty())
    {
      unsigned int i = 0;
      while( !soUdp_meta.empty())
      {
        i++;
        NetworkMetaStream tmp_meta = soUdp_meta.read();
        printf("NRC received NRCmeta stream from rank %d to rank %d.\n", (int) tmp_meta.tdata.src_rank, (int) tmp_meta.tdata.dst_rank);
        assert(tmp_meta.tdata.src_rank == node_rank);
        //ensure forwarding behavior
        assert(tmp_meta.tdata.dst_rank == ((tmp_meta.tdata.src_rank + 1) % cluster_size));
      }
      //verify the output prediction
      assert(i == tot_output_transfers);
    }
    else {
      printf("Error No metadata received...\n");
      nrErr++;
    }
    
    //-------------------------------------------------------
    //-- STEP-5 : FROM THE OUTPUT FILE CREATE AN ARRAY
    //------------------------------------------------------- 
    if (!dumpFileToString("ifsSHL_Uaf_Data.dat", charInput, simCnt)) {
      printf("### ERROR : Failed to set string from file \"ofsUAF_Shl_Data.dat\". \n");
      nrErr++;
    }
    printf("Input string : ");
    for (unsigned int i = 0; i <  charInputSize; i++)
       printf("%x", charInput[i]); //hex print since not real chars
    printf("\n");    
    if (!dumpFileToString("ofsUAF_Shl_Data.dat", charOutput, simCnt)) {
      printf("### ERROR : Failed to set string from file \"ofsUAF_Shl_Data.dat\". \n");
      nrErr++;
    }
    
    //__file_write("./hls_out.txt", charOutput, charOutputSize);
    string out_string;
    out_string.reserve(charOutputSize);
    string tmpToDebug = string(charOutput,charOutputSize);
    out_string.append(tmpToDebug,0, charOutputSize);
    dumpStringToFileOnlyRawData(out_string, "./hls_out.txt", simCnt, charOutputSize);
    printf("Output string: ");
    for (unsigned int i = 0; i < charOutputSize; i++)
       printf("%x", charOutput[i]); //hex print since not real chars 
    printf("\n");
  out_string.clear();
 
    //------------------------------------------------------
    //-- STEP-6 : COMPARE GOLD AND OUTPUT FILE STREAMS
    //------------------------------------------------------
    int rc1 = system("diff --brief -w -i -y ../../../../test/ofsUAF_Shl_Data.dat \
                                            ../../../../test/verify_UAF_Shl_Data.dat");
    
    if (rc1)
    {
        printf("## Error : File \'ofsUAF_Shl_Data.dat\' does not match \'verify_UAF_Shl_Data.dat\'.\n");
    } else {
      printf("Output data in file \'ofsUAF_Shl_Data.dat\' verified.\n");
    }
    
// #ifdef ENABLE_DDR
// for(int i=0; i < MEMORY_LINES_512; i++){
//   if(lcl_mem0[i]!=lcl_mem1[i]){
//       cout << "Main mem difference :" << lcl_mem0[i] << " " << lcl_mem1[i] << endl;
//   }else{
//     cout << "ok ";
//   }
// }
// #endif//ENABLE_DDR
 
    //------------------------------------------------------
    //-- STEP-7 [OPTIONAL] : Parse the output stream
    //------------------------------------------------------
  const string ouf_file ="./hls_out.txt";
  int rawdatalines=0;
  string longbuf_string;
  longbuf_string.reserve(charOutputSize);
  longbuf_string = dumpFileToStringRawDataString(ouf_file, &rawdatalines, charOutputSize);
 
  testResults_vector=parseMemoryTestOutput(longbuf_string,charOutputSize,rawdatalines);
  //------------------------------------------------------
  //-- STEP-8 : Clear everything
  //------------------------------------------------------
  longbuf_string.clear();
  testResults_vector.clear();
  cout<< endl << "  End the TB with iteration " << iterations << endl << endl;
 
  nrErr += rc1;
 
  printf("#####################################################\n");
  if (nrErr) 
  {
      printf("## ERROR - TESTBENCH FAILED (RC=%d) !!!             ##\n", nrErr);
  } else {
      printf("## SUCCESSFULL END OF TESTBENCH (RC=0)             ##\n");
  }
  printf("#####################################################\n");
 
  simCnt = 0;//reset sim counter
  nrErr=0;
#ifdef DEBUG_MULTI_RUNS
}
 #endif//DEBUG_MULTI_RUNS
 
 
//free dynamic memory
if(charOutput != NULL){
 free(charOutput);
 charOutput = NULL;
}
if(charInput != NULL){
  free(charInput);
  charInput = NULL;
}
  return(nrErr);
}

Here is the call graph for this function:

main() [2/2]

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

Main testbench for the user-application for Memtest on host. Server

Returns

O on success, 1 on fail

Definition at line 54 of file memtest_host_fwd_tb.cpp.

                                  {
 
    if ((argc < 2) || (argc > 3)) { // Test for correct number of parameters
        cerr << "Usage: " << argv[0] << " <Server Port> <optional simulation mode>" << endl;
        exit(1);
    }
 
    unsigned short servPort = atoi(argv[1]); // First arg:  local port
    unsigned int num_batch = 0;
    string clean_cmd, synth_cmd;
    unsigned int testingNumber=3;
    string strInput_nmbrTest="";
 
 
//Infinite Loop Logic
bool endOfLooping=false;    
while(!endOfLooping){
 
    //------------------------------------------------------
    //-- Setup the RX
    //------------------------------------------------------
    try {
    #if NET_TYPE == udp
        UDPSocket sock(servPort);
    #else
    TCPServerSocket servSock(servPort);     // Server Socket object
    TCPSocket *servsock = servSock.accept();     // Wait for a client to connect
    #endif
        char buffer[BUF_LEN]; // Buffer for echo string
        unsigned int recvMsgSize; // Size of received message
        string sourceAddress; // Address of datagram source
        unsigned short sourcePort; // Port of datagram source
        
    #if NET_TYPE == tcp
    // TCP client handling
    cout << "Handling client ";
    try {
      cout << servsock->getForeignAddress() << ":";
    } catch (SocketException e) {
        cerr << "Unable to get foreign address" << endl;
      }
    try {
      cout << servsock->getForeignPort();
    } catch (SocketException e) {
        cerr << "Unable to get foreign port" << endl;
      }
    cout << endl;
    #endif
    
    //------------------------------------------------------
    //-- RX Step
    //------------------------------------------------------
    clock_t last_cycle_rx = clock();
    // Block until receive message from a client
    int input_string_total_len = 0;
    //int receiving_now = PACK_SIZE;
    int total_pack = 1;
    int bytes_in_last_pack;
    size_t total_size =0;
    bool msg_received = false;
    cout << " ___________________________________________________________________ " << endl;
    cout << "/                                                                   \\" << endl;
    cout << "INFO: Proxy tb batch # " << ++num_batch << endl;       
        char * longbuf = new char[PACK_SIZE * (total_pack+1)];
    // RX Loop
        for (int i = 0; msg_received != true; i++, total_pack++) {
        #if NET_TYPE == udp
            recvMsgSize = sock.recvFrom(buffer, BUF_LEN, sourceAddress, sourcePort);
        #else
        recvMsgSize = servsock->recv(buffer, receiving_now);
        #endif
        input_string_total_len += recvMsgSize;
        bytes_in_last_pack = recvMsgSize;
        bool nullcharfound = findCharNullPos(buffer);
        memcpy(longbuf+(i*PACK_SIZE), buffer, recvMsgSize);
        total_size += recvMsgSize;
        longbuf[total_size+1]='\0';
 
        if (nullcharfound != true) {
        cout << "INFO: The string is not entirely fit in packet " <<  total_pack << endl;
        }
        else {
        msg_received = true;
        }
        }
 
        cout << "INFO: Received packet from " << sourceAddress << ":" << sourcePort << endl;
 
    string input_string;
    input_string.append(longbuf,total_size);
    if (input_string.length() == 0) {
        cerr << "ERROR: received an empty string! Aborting..." << endl;
            return -1;
    }
    //------------------------------------------------------
    //-- DECODING LOGIC for output size determination and end of looping
    //------------------------------------------------------
    unsigned long long int memory_addr_under_test = 0;
    testingNumber = 0;
    unsigned int burst_size = 0;
 
    cout << "Begin the decoding step" << endl;
    //printStringHex(input_string,input_string.length());
    //printBits(input_string.length(),input_string.c_str());
 
    // revert the input string and extract substring
    reverse(input_string.begin(), input_string.end());
 
    //------------------------------------------------------
    //-- DECODING LOGIC check which command was
    //------------------------------------------------------
    string substr_tmp, to_translate_String;
    substr_tmp = input_string.substr(7,1);
    ascii2hexWithSize(substr_tmp,to_translate_String,1);
    if(to_translate_String.compare("2")==0){
        endOfLooping=true;
        string cmd_string = createMemTestStopCommand();
        char cmd_stop [8];
        strncpy(cmd_stop,cmd_string.c_str(),8);
        unsigned int sending_bytes=8;
        #if NET_TYPE == udp
        sock.sendTo( cmd_stop, sending_bytes, sourceAddress, sourcePort);
        #else
        servsock->send(cmd_stop, sending_bytes);
        #endif
        cout << "A stop received, going to sleep the EMU :)" << endl;
        cout << "\\___________________________________________________________________/" << endl;
        #if NET_TYPE == tcp
        delete servsock;
        #endif
        continue;
    }
    reverse(input_string.begin(), input_string.end());
    //printStringHex(input_string,input_string.length());
    //printBits(input_string.length(),input_string.c_str());
 
    //------------------------------------------------------
    //-- DECODING LOGIC for output and TB setup
    //------------------------------------------------------
    char myTmpOutBuff[8];
    //how many test to perform
    substr_tmp = input_string.substr(1,2);
    for(int i=0; i < 8; i++){myTmpOutBuff[i]=(char)0;}
    strncpy(myTmpOutBuff,substr_tmp.c_str(),2);
    testingNumber = *reinterpret_cast<unsigned long long*>(myTmpOutBuff);
    substr_tmp.clear();
 
    //the maximum address to test
    for(int i=0; i < 8; i++){myTmpOutBuff[i]=(char)0;}
    substr_tmp=input_string.substr(3,5);
    memcpy(myTmpOutBuff,substr_tmp.c_str(),5);
    memory_addr_under_test = *reinterpret_cast<unsigned long long*>(myTmpOutBuff);
    substr_tmp.clear();
 
    //the selected burst size
    substr_tmp = input_string.substr(9,2);
    printBits(2,substr_tmp.c_str());
    for(int i=0; i < 8; i++){myTmpOutBuff[i]=(char)0;}
    memcpy(myTmpOutBuff,substr_tmp.c_str(),2);
    burst_size = *reinterpret_cast<unsigned long long*>(myTmpOutBuff);
    substr_tmp.clear();
    for(int i=0; i < 8; i++){myTmpOutBuff[i]=(char)0;}
 
 
    reverse(input_string.begin(), input_string.end());
    cout << input_string << endl;
    //------------------------------------------------------
    //-- EMULATION preparing the emulation mode, default is fcsim
    //------------------------------------------------------
    synth_cmd = " ";
    string exec_cmd = "make fcsim ";
    string ouf_file = "../../../../../../ROLE/custom/hls/memtest/memtest_prj/solution1/fcsim/build/hls_out.txt";
    if (argc >= 3) {
        if (atoi(argv[2]) == 2) {
        exec_cmd = "make csim";
        ouf_file = "../../../../../../ROLE/custom/hls/memtest/memtest_prj/solution1/csim/build/hls_out.txt";
        }
        else if (atoi(argv[2]) == 3) {
            synth_cmd = "make csynth && ";
        exec_cmd = "make cosim";
        ouf_file = "../../../../../../ROLE/custom/hls/memtest/memtest_prj/solution1/sim/wrapc_pc/build/hls_out.txt";
        }
        else if (atoi(argv[2]) == 4) {
        exec_cmd = "make kcachegrind";
        ouf_file = "../../../../../../ROLE/custom/hls/memtest/memtest_prj/solution1/fcsim/build/hls_out.txt";
        }
    }
    // Calling the actual TB over its typical makefile procedure, but passing the save file
    // Skip the rebuilding phase on the 2nd run. However ensure that it's a clean recompile
    // the first time.
    clean_cmd = " ";
    if (num_batch == 1) {
        clean_cmd = "make clean && ";
    }
    string str_command = "cd ../../../../../../ROLE/custom/hls/memtest/ && ";
    str_command = str_command.append(clean_cmd + synth_cmd+ exec_cmd);
    size_t str_command_size = str_command.length();
    string final_cmd = " TEST_NUMBER=" + std::to_string(testingNumber) + " INPUT_STRING=" + std::to_string(memory_addr_under_test) + " BURST_SIZE=" + std::to_string(burst_size) +  " && cd ../../../../HOST/custom/memtest/languages/cplusplus/build/ ";
    str_command = str_command.append(final_cmd);
    str_command_size+=final_cmd.length();
 
    char *command =(char*)malloc((str_command_size+1)* sizeof(char));
    for(int i=0; i < (str_command_size+1); i++){
        command[i]=str_command[i];
    }
    cout << "Calling TB with command:" << command << endl; 
    system(command); 
 
    //clean dynamic memory
    input_string.clear();
    str_command.clear();
    final_cmd.clear();
    free(command);
 
    //------------------------------------------------------
    //-- TB output parsing
    //------------------------------------------------------
    ssize_t size = __file_size(ouf_file.c_str());
    size_t charOutputSize = 8*1+((8 * (2 + 1+ 1 + 1)) * testingNumber); //stop, 4 for each test, potential stop?
 
    int rawdatalines=0;
    int rc = 0;
    string out_string;
    delete [] longbuf;
 
    longbuf =  new char[charOutputSize+1];
    out_string.reserve(charOutputSize);
    out_string =  dumpFileToStringRawDataString(ouf_file.c_str(), &rawdatalines, charOutputSize);
    memcpy(longbuf,out_string.data(),charOutputSize);
 
    if (rc < 0) {
        cerr << "ERROR: Cannot read file " << ouf_file << " . Aborting..."<< endl;
        return -1;
    }
 
    clock_t next_cycle_rx = clock();
        double duration_rx = (next_cycle_rx - last_cycle_rx) / (double) CLOCKS_PER_SEC;
        cout << "INFO: Effective FPS RX:" << (1 / duration_rx) << " \tkbps:" << (PACK_SIZE * 
                total_pack / duration_rx / 1024 * 8) << endl;
        last_cycle_rx = next_cycle_rx;
    
 
    //------------------------------------------------------
    //--  TX step
    //------------------------------------------------------
    
    unsigned int total_retx_pack = 1;
    total_retx_pack = charOutputSize%PACK_SIZE==0 ? charOutputSize/PACK_SIZE : charOutputSize/PACK_SIZE + 1;
    if (out_string.length() == 0) {
          cerr << "ERROR: Received empty string!" << endl; 
          return -1;
    }
    else {
        cout << "INFO: Succesfully received string from TB : " << out_string << endl; 
        //printStringHex(out_string, charOutputSize);
        cout << "INFO: Will forward it back to host app ... total_pack=" << total_retx_pack << endl; 
    }
 
    // TX Loop
    unsigned int sending_now = PACK_SIZE;
    clock_t last_cycle_tx = clock();
    unsigned int bytes_in_last_pack_in = charOutputSize - (total_retx_pack - 1) * PACK_SIZE;
        for (int i = 0; i < total_retx_pack; i++) {
        if ( i == total_retx_pack - 1 ) {
        sending_now = bytes_in_last_pack_in;
        }
        #if NET_TYPE == udp
        sock.sendTo( longbuf+(i * PACK_SIZE), sending_now, sourceAddress, sourcePort);
        #else
        servsock->send( & longbuf[i * PACK_SIZE], sending_now);
        #endif
    }
        clock_t next_cycle_tx = clock();
        double duration_tx = (next_cycle_tx - last_cycle_tx) / (double) CLOCKS_PER_SEC;
        cout << "INFO: Effective FPS TX:" << (1 / duration_tx) << " \tkbps:" << (PACK_SIZE * 
               total_retx_pack / duration_tx / 1024 * 8) << endl;
        last_cycle_tx = next_cycle_tx; 
        delete [] longbuf;
        cout << "\\___________________________________________________________________/" << endl;
    #if NET_TYPE == tcp
        delete servsock;
    #endif
    out_string.clear();
    } catch (SocketException & e) {
        cerr << e.what() << endl;
        exit(1);
    }
    
    //------------------------------------------------------
    //--  Now loop until stop or crash :D
    //------------------------------------------------------
    }//while
    return 0;
}

Here is the call graph for this function:

siUdp_meta()

stream<NetworkMetaStream> siUdp_meta

(

"siUdp_meta"

)

Here is the caller graph for this function:

soUdp_meta()

stream<NetworkMetaStream> soUdp_meta

(

"soUdp_meta"

)

Here is the caller graph for this function:

sSHL_Uaf_Data()

stream< UdpWord > sSHL_Uaf_Data

(

"sSHL_Uaf_Data"

)

Here is the caller graph for this function:

stepDut()

void stepDut

(

)

Run a single iteration of the DUT model.

Returns

Nothing.

Definition at line 94 of file test_memtest.cpp.

               {
    memtest(
      &node_rank, &cluster_size,
      sSHL_Uaf_Data, sUAF_Shl_Data,
      siUdp_meta, soUdp_meta,
      &s_udp_rx_ports
      #ifdef ENABLE_DDR
                      ,
        lcl_mem0,
        lcl_mem0
      #endif
      );
    simCnt++;
    #if DEBUG_LEVEL > TRACE_OFF
    printf("[%4.4d] STEP DUT \n", simCnt);
    #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

sUAF_Shl_Data()

stream< UdpWord > sUAF_Shl_Data

(

"sUAF_Shl_Data"

)

Here is the caller graph for this function:

Variable Documentation

cluster_size

ap_uint<32> cluster_size

Definition at line 74 of file test_memtest.cpp.

lcl_mem0

membus_t lcl_mem0[ 16384]

Definition at line 87 of file test_memtest.cpp.

lcl_mem1

membus_t lcl_mem1[ 16384]

Definition at line 88 of file test_memtest.cpp.

node_rank

ap_uint<32> node_rank

Definition at line 73 of file test_memtest.cpp.

piSHL_This_MmioCaptPktEn

ap_uint<1> piSHL_This_MmioCaptPktEn

Definition at line 63 of file test_memtest.cpp.

piSHL_This_MmioPostPktEn

ap_uint<1> piSHL_This_MmioPostPktEn

Definition at line 62 of file test_memtest.cpp.

s_udp_rx_ports

ap_uint<32> s_udp_rx_ports = 0x0

Definition at line 70 of file test_memtest.cpp.

simCnt

unsigned int simCnt

Definition at line 79 of file test_memtest.cpp.