Memtest

This is the Memtest platform stressing project. The FPGA tests its DRAM memory. More...

Collaboration diagram for Memtest:

Modules
	Memtest Testbench
	This is a subgroup of Memtest accelerated function with only testbench-related functions/classes.
	Memtest HLS
	This is a subgroup of Memtest accelerated function with only synthesizable (HLS) functions/classes.
	Memtest Host
	This is a subgroup of Memtest accelerated function with only host code software.

Files
file	config.h
	The configuration of a Memtest Example application (UDP or TCP)
file	memtest_host.cpp
	Memtest userspace application for cF (x86, ppc64).

Classes
struct	MemoryTestResult

Macros
#define	MAX_TESTABLE_ADDRESS   8000000000
#define	MAX_TEST_REPETITION_BITWIDTH   16
#define	MAX_BURST_SIZE   4096
#define	OK   true
#define	KO   false
#define	CEIL(a, b)   (((a) + (b-1)) / (b))
#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_LEVEL   (TRACE_ALL)
#define	PACK_SIZE   1024
#define	BUF_LEN   65540
#define	TB_SIM_CFP_VITIS
#define	NET_TYPE   udp
#define	tcp   0
#define	udp   1
#define	MAX_MEM_SIZE_BENCHMARKING_POWER_OF_TWO   33
#define	MIN_MEM_SIZE_BENCHMARKING_POWER_OF_TWO   6
#define	MAX_BURST_SIZE_BENCHMARKING   MAX_BURST_SIZE
#define	MIN_BURST_SIZE_BENCHMARKING   1
#define	REPETITIONS_BENCHMARKING   2

Functions
void	print_cFpMemtest (void)
void	delay (unsigned int mseconds)
void	printBits (size_t const size, void const *const ptr)
	print the binary representation of a target pointer buffer of a given size. Assumes little endian. More...
void	ascii2hex (const string &in, string &out)
	Convert a ascii string to a hexadecimal string. More...
template<unsigned int bytes_per_line = 8>
string	createMemTestCommands (unsigned long long int mem_address, unsigned int testingNumber, unsigned int burst_size)
	Create the commands for a memory test with start/max address to test-nop to execute-stop. More...
template<unsigned int bytes_per_line = 8>
string	createMemTestStopCommand ()
unsigned char	hexval (unsigned char c)
	convert a char to its hexadecimal representation. More...
void	hex2ascii (const string &in, string &out)
	Convert a hexadecimal string to a ascii string. More...
template<typename T >
void	number2hexString (const T in, char *out, size_t byteSize)
template<unsigned int bytes_per_line = 8>
string	dumpFileToStringRawDataString (const string inpFileName, int *rawdatalines, size_t outputSize)
	Initialize an input data stream from a file with only data. More...
void	ascii2hexWithSize (const string &in, string &out, size_t bytesize)
	Convert a ascii string to a hexadecimal string. More...
bool	findCharNullPos (char *str)
void	printStringHex (const string inStr, size_t strSize)
	print byte-per-byte a given string in hexadecimal format More...
void	printCharBuffHex (const char *inStr, size_t strSize)
	print byte-per-byte a given char buff in hexadecimal format More...
void	printCharBuffHexSafe (const char *inStr, size_t strSize)
void	string2hexnumerics (const string &in, char *out, size_t byteSize)
	MemoryTestResult::MemoryTestResult ()
	MemoryTestResult::MemoryTestResult (unsigned long long int target_address, unsigned int fault_cntr, unsigned int first_fault_address, unsigned long long int clock_cycles_write, unsigned long long int clock_cycles_read)
template<unsigned int bytes_per_line = 8>
std::vector< MemoryTestResult >	parseMemoryTestOutput (const string longbuf, size_t charOutputSize, int rawdatalines)
	Parse the memory test output contained in astring with a given size. More...
void	createAVGLogFile ()
void	logTheAvgResult (unsigned int iters, unsigned long long int trgt_address, unsigned int brst_size, unsigned int wr_words, double rd_bw, double wr_bw, unsigned int faults)
void	createItLogFile ()
void	logTheSingleResult (unsigned int iters, unsigned long long int trgt_address, unsigned int brst_size, unsigned int wr_words, double rd_bw, double wr_bw, unsigned int faults, unsigned long long int first_faulty_address)
int	main (int argc, char *argv[])

Variables
unsigned long long int	MemoryTestResult::target_address
unsigned int	MemoryTestResult::fault_cntr
unsigned int	MemoryTestResult::first_fault_address
unsigned long long int	MemoryTestResult::clock_cycles_read
unsigned long long int	MemoryTestResult::clock_cycles_write
std::ofstream	loggingAVGFile
const std::string	loggingAVGFileName ="cfp_vitis_memtest_avg.csv"
std::ofstream	loggingMultiItFile
const std::string	loggingMultiItFileName ="cfp_vitis_memtest_multi.csv"

Detailed Description

This is the Memtest platform stressing project. The FPGA tests its DRAM memory.

Macro Definition Documentation

BUF_LEN

#define BUF_LEN   65540

Larger than maximum UDP packet size

Definition at line 54 of file config.h.

CEIL

#define CEIL	(		a,
			b
	)		(((a) + (b-1)) / (b))

Ceiling function without using math.h

Definition at line 37 of file config.h.

DEBUG_LEVEL

#define DEBUG_LEVEL   (TRACE_ALL)

Definition at line 47 of file config.h.

KO

#define KO   false

Definition at line 66 of file common.hpp.

MAX_BURST_SIZE

#define MAX_BURST_SIZE   4096

Definition at line 59 of file common.hpp.

MAX_BURST_SIZE_BENCHMARKING

#define MAX_BURST_SIZE_BENCHMARKING   MAX_BURST_SIZE

Definition at line 46 of file memtest_host.cpp.

MAX_MEM_SIZE_BENCHMARKING_POWER_OF_TWO

#define MAX_MEM_SIZE_BENCHMARKING_POWER_OF_TWO   33

Definition at line 43 of file memtest_host.cpp.

MAX_TEST_REPETITION_BITWIDTH

#define MAX_TEST_REPETITION_BITWIDTH   16

Definition at line 58 of file common.hpp.

MAX_TESTABLE_ADDRESS

#define MAX_TESTABLE_ADDRESS   8000000000

Definition at line 57 of file common.hpp.

MIN_BURST_SIZE_BENCHMARKING

#define MIN_BURST_SIZE_BENCHMARKING   1

Definition at line 47 of file memtest_host.cpp.

MIN_MEM_SIZE_BENCHMARKING_POWER_OF_TWO

#define MIN_MEM_SIZE_BENCHMARKING_POWER_OF_TWO   6

Definition at line 45 of file memtest_host.cpp.

NET_TYPE

#define NET_TYPE   udp

The network socket type: tcp or udp

Definition at line 60 of file config.h.

OK

#define OK   true

Definition at line 65 of file common.hpp.

PACK_SIZE

#define PACK_SIZE   1024

This is our custom MTU. We must use a multiple of 8 (Bytes per transaction)! 1450 4086 udp pack size; note that OSX limits < 8100 bytes

Definition at line 51 of file config.h.

REPETITIONS_BENCHMARKING

#define REPETITIONS_BENCHMARKING   2

Definition at line 48 of file memtest_host.cpp.

TB_SIM_CFP_VITIS

#define TB_SIM_CFP_VITIS

Definition at line 57 of file config.h.

tcp

cat GET request dos socat stdio shut none time cat post_role socat shut none tcp   0

Definition at line 65 of file config.h.

TRACE_ALL

#define TRACE_ALL   0xFFFF

Definition at line 46 of file config.h.

TRACE_MMIO

#define TRACE_MMIO   1 << 3

Definition at line 45 of file config.h.

TRACE_OFF

#define TRACE_OFF   0x0000

Definition at line 42 of file config.h.

TRACE_UAF

#define TRACE_UAF   1 << 2

Definition at line 44 of file config.h.

TRACE_URIF

#define TRACE_URIF   1 << 1

Definition at line 43 of file config.h.

udp

#define udp   1

Definition at line 66 of file config.h.

Function Documentation

ascii2hex()

void ascii2hex	(	const string &	in,
		string &	out
	)

Convert a ascii string to a hexadecimal string.

Parameters

[in]	in	the input ascii string
[out]	out	the output hexadecimal string

Definition at line 119 of file common.hpp.

{
 std::stringstream sstream;
    for ( string::const_iterator item = in.begin(); item != in.end(); item++){
        sstream << std::hex << int(*item);
    }
    out=sstream.str(); 
}

ascii2hexWithSize()

void ascii2hexWithSize	(	const string &	in,
		string &	out,
		size_t	bytesize
	)

Convert a ascii string to a hexadecimal string.

Parameters

[in]	in	the input ascii string
[out]	out	the output hexadecimal string
[in]	bytesize	the input ascii string size

Definition at line 331 of file common.hpp.

{
 std::stringstream sstream;
    for ( int i=0; i<bytesize; i++){
        sstream << std::hex << int(in[i]);
    }
    out=sstream.str(); 
}

Here is the caller graph for this function:

createAVGLogFile()

void createAVGLogFile

(

)

Definition at line 557 of file common.hpp.

                       {
  if (FILE *file = fopen(loggingAVGFileName.c_str(), "r")){
    fclose(file);
  }else{
    loggingAVGFile.open(loggingAVGFileName, std::ios_base::app);
    loggingAVGFile << "TimeStamp,Iterations[#],Trgt_Address[Byte],Brst_size[#beats],WrittenWords[512b],AVG_RD_BW[Gbit/s],AVG_WR_BW[Gbit/s],AVG_faults[#],PowOfTwoBytes\n";
    loggingAVGFile.close();
  }
}

Here is the caller graph for this function:

createItLogFile()

void createItLogFile

(

)

Definition at line 586 of file common.hpp.

                      {
  if (FILE *file = fopen(loggingMultiItFileName.c_str(), "r")){
    fclose(file);
  }else{
    loggingMultiItFile.open(loggingMultiItFileName, std::ios_base::app);
    loggingMultiItFile << "TimeStamp,Iteration[#],Trgt_Address[Byte],";
    loggingMultiItFile << "Brst_size[#beats],WrittenWords[512b],RD_BW[Gbit/s],WR_BW[Gbit/s],";
    loggingMultiItFile << "faults[#],first_faulty_address[byte],PowOfTwoBytes\n";
    loggingMultiItFile.close();
  }
}

Here is the caller graph for this function:

createMemTestCommands()

template<unsigned int bytes_per_line = 8>

string createMemTestCommands	(	unsigned long long int	mem_address,
		unsigned int	testingNumber,
		unsigned int	burst_size
	)

Create the commands for a memory test with start/max address to test-nop to execute-stop.

Parameters

[in]	mem_address	max target address to test
[out]	out	the output string with start/max address-nops4trgtCCsNeeded-stop
[in]	testingNumber	the number of tests to perform on the memory

Definition at line 137 of file common.hpp.

{
  string out;
    char start_cmd [bytes_per_line];
    char stop_cmd [bytes_per_line];
    char value_cmd[bytes_per_line];
    char burst_cmd[bytes_per_line];
    //WARNING: currently hardcoded way of start and stop commands with a 1 and 2 for start and stop respectively
    for (unsigned int k = 0; k < bytes_per_line; k++) {
       value_cmd[k]    = (char)0;
        if (k != 0) {
            stop_cmd[k] = (char)0;
            start_cmd[k] = (char)0;
            burst_cmd[k] = (char)0;
        }
        else {
            start_cmd[k] = (char)1; 
            stop_cmd[k] = (char)2;
            burst_cmd[k] = (char)4;
        }
     }
  memcpy(start_cmd+1, (char*)&testingNumber, 2);
    out = out.append(start_cmd,3);
  memcpy(value_cmd, (char*)&mem_address, 5);
  out = out.append(value_cmd,5);
  memcpy(burst_cmd+1,(char*)&burst_size,2);
  out = out.append(burst_cmd,8);  
  return string(out);
  }

Here is the caller graph for this function:

createMemTestStopCommand()

template<unsigned int bytes_per_line = 8>

string createMemTestStopCommand

(

)

Definition at line 168 of file common.hpp.

{
  string out;
  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;
    }
  }
  out.append(stop_cmd,bytes_per_line);
  return out;
}

Here is the caller graph for this function:

delay()

void delay

(

unsigned int

mseconds

)

Definition at line 85 of file common.hpp.

{
    clock_t goal = mseconds + clock();
    while (goal > clock());
}

Here is the call graph for this function:

Here is the caller graph for this function:

dumpFileToStringRawDataString()

template<unsigned int bytes_per_line = 8>

string dumpFileToStringRawDataString	(	const string	inpFileName,
		int *	rawdatalines,
		size_t	outputSize
	)

Initialize an input data stream from a file with only data.

Parameters

[in]	inpFileName	the name of the input file to read from.
[out]	strOutput	the output string to set.

Returns

OK if successful otherwise KO.

Definition at line 279 of file common.hpp.

                                                                                                      {
    string      strLine;
    string      tmp_Out;
    ifstream    inpFileStream;
    string      datFile = inpFileName;
    string charOutput;
    //charOutput.reserve(outputSize);
    //strLine.reserve(outputSize);
    //tmp_Out.reserve(bytes_per_line);
    unsigned long long int  mylongunsigned;
    unsigned long long int  zero_byte=0;
    unsigned int i = 0;
    char my_tmp_buf [bytes_per_line];
    //-- STEP-1 : OPEN FILE
    inpFileStream.open(datFile.c_str());
 
    if ( !inpFileStream ) {
        cout << "### ERROR : Could not open the input data file " << datFile << endl;
        return "";
    }
 
    //-- STEP-2 : SET DATA STREAM
    while (inpFileStream) {
 
        if (!inpFileStream.eof()) {
 
            getline(inpFileStream, strLine);
            memcpy(my_tmp_buf,&zero_byte, bytes_per_line);
            if (strLine.empty()) continue;
            *rawdatalines+=1;
            mylongunsigned=stoul(strLine,nullptr,16);
            hex2ascii(strLine, tmp_Out);
            // Write to strOutput
      memcpy(my_tmp_buf,(char *)&mylongunsigned, sizeof(unsigned long long int));
      charOutput.append(my_tmp_buf, bytes_per_line);
      i++;
        }
    }
    //-- STEP-3: CLOSE FILE
    inpFileStream.close();
    //tmp_Out.clear();
 
    return string(charOutput);
}

Here is the call graph for this function:

Here is the caller graph for this function:

findCharNullPos()

bool findCharNullPos

(

char *

str

)

Definition at line 340 of file common.hpp.

                                  {
    unsigned int len = strlen(str);
    bool f = false;
    for(unsigned int i=0; i<=len; i++) {
    if(str[i]=='\0') {
      printf("DEBUG: null character position: %d\n",i+1);
      f = true;
    }
    }
    if(f == false) {
    printf("DEBUG: null character not found\n");
    }
    return f;
}

Here is the caller graph for this function:

hex2ascii()

void hex2ascii	(	const string &	in,
		string &	out
	)

Convert a hexadecimal string to a ascii string.

Parameters

[in]	in	the input hexadecimal string
[out]	out	the output ascii string

Definition at line 251 of file common.hpp.

{
    out.clear();
    out.reserve(in.length() / 2);
    for (string::const_iterator p = in.begin(); p != in.end(); p++)
    {
       unsigned char c = hexval(*p);
       p++;
       if (p == in.end()) break; // incomplete last digit - should report error
       c = (c << 4) + hexval(*p); // + takes precedence over <<
       out.push_back(c);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

hexval()

unsigned char hexval

(

unsigned char

c

)

convert a char to its hexadecimal representation.

Parameters

[in]

c

the standard char value to convert to hex

Returns

the hexadecimal value of the input

Definition at line 234 of file common.hpp.

{
    if ('0' <= c && c <= '9')
        return c - '0';
    else if ('a' <= c && c <= 'f')
        return c - 'a' + 10;
    else if ('A' <= c && c <= 'F')
        return c - 'A' + 10;
    else abort();
}

Here is the caller graph for this function:

logTheAvgResult()

void logTheAvgResult	(	unsigned int	iters,
		unsigned long long int	trgt_address,
		unsigned int	brst_size,
		unsigned int	wr_words,
		double	rd_bw,
		double	wr_bw,
		unsigned int	faults
	)

Definition at line 567 of file common.hpp.

  {
    loggingAVGFile.open(loggingAVGFileName, std::ios_base::app);
    std::time_t instant_time = std::time(0);   // get time now
    std::tm* now = std::localtime(&instant_time);
    loggingAVGFile << (now->tm_year + 1900)<< '-' << (now->tm_mon + 1) << '-' <<  now->tm_mday << "," << iters<< ",";
    loggingAVGFile<<trgt_address<< ","<<brst_size<< ","<<wr_words<< ",";
    loggingAVGFile<<rd_bw<< ","<<wr_bw<< ","<< faults <<",";
    loggingAVGFile << (int) log2(trgt_address)<<"\n";
    loggingAVGFile.close();
}

Here is the caller graph for this function:

logTheSingleResult()

void logTheSingleResult	(	unsigned int	iters,
		unsigned long long int	trgt_address,
		unsigned int	brst_size,
		unsigned int	wr_words,
		double	rd_bw,
		double	wr_bw,
		unsigned int	faults,
		unsigned long long int	first_faulty_address
	)

Definition at line 598 of file common.hpp.

  {
    loggingMultiItFile.open(loggingMultiItFileName, std::ios_base::app);
    std::time_t instant_time = std::time(0);   // get time now
    std::tm* now = std::localtime(&instant_time);
    loggingMultiItFile << (now->tm_year + 1900)<< '-' << (now->tm_mon + 1) << '-' <<  now->tm_mday << "," << iters<< ",";
    loggingMultiItFile<<trgt_address<< ","<<brst_size<< ","<<wr_words<< ",";
    loggingMultiItFile<<rd_bw<< ","<<wr_bw<< ","<< faults;
    loggingMultiItFile<<","<<first_faulty_address<<"," << (int) log2(trgt_address)<<"\n";
    loggingMultiItFile.close();
}

Here is the caller graph for this function:

main()

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

Main testbench and user-application for Memtest on host. Client

Returns

O on success, 1 on fail

Definition at line 59 of file memtest_host.cpp.

{
    if ((argc < 3) || (argc > 7)) { // Test for correct number of arguments
        cerr << "Usage: " << argv[0] << " <Server> <Server Port> <number of address to test> <testing times> <burst size> <optional list/interactive mode (type list or nothing)>\n";
        exit(1);
    }
#endif
    cout << argc << endl;
    
    //------------------------------------------------------
    //-- STEP-1 : Socket and variables definition
    //------------------------------------------------------
    
    #ifndef PY_WRAP
    assert (argc >= 6);
    string s_servAddress = argv[1]; // First arg: server address
    char *s_servPort = argv[2];
    bool net_type = NET_TYPE;
    #endif
 
    string servAddress = s_servAddress;
    unsigned short servPort;
    if (net_type == udp) {
    servPort = Socket::resolveService(s_servPort, "udp");
    }
    else if (net_type == tcp) {
    servPort = atoi(s_servPort);
    }
    else {
    cout << "ERROR: Invalid type of socket type provided: " << net_type  << " Choosed one of (tcp=0 or udp=1)" << endl;
    }
    
    char buffer[BUF_LEN]; // Buffer for echo string
    unsigned int recvMsgSize; // Size of received message
    unsigned int num_frame = 0;
    std::string input_string;
    std::string strInput_memaddrUT;
    std::string strInput_nmbrTest;
    std::string strInput_burstSize;
    
    std::string strInput_listMode;
 
    unsigned long long int memory_addr_under_test=0;
    unsigned int testingNumber = 1;
    unsigned int burst_size = 1;
    //UDPSocket *udpsock_p;
    //TCPSocket *tcpsock_p;
  
    print_cFpMemtest();
    
    try {
        //------------------------------------------------------
        //-- STEP-2 : Initialize socket connection
        //------------------------------------------------------    
    #if NET_TYPE == udp
        #ifndef TB_SIM_CFP_VITIS
        UDPSocket udpsock(servPort); // NOTE: It is very important to set port here in order to call 
                                     // bind() in the UDPSocket constructor
        #else // TB_SIM_CFP_VITIS
        UDPSocket udpsock; // NOTE: In HOST TB the port is already binded by memtest_host_fwd_tb.cpp
        #endif // TB_SIM_CFP_VITIS
    //    udpsock_p = &udpsock;
    #else  // tcp
        TCPSocket tcpsock(servAddress, servPort);
    //    tcpsock_p = &tcpsock;
    #endif // udp/tcp
        
        //------------------------------------------------------------------------------------
        //-- STEP-3 : Create a string from input argument
        //------------------------------------------------------------------------------------
    #ifdef PY_WRAP
    input_string.assign(input_str); //TBC
    #else
    strInput_memaddrUT.assign(argv[3]);
    strInput_nmbrTest.assign(argv[4]);
    strInput_burstSize.assign(argv[5]);
    #endif
    // memory_addr_under_test = stoull(strInput_memaddrUT);
    // testingNumber = stoul(strInput_nmbrTest);
    // burst_size = stoul(strInput_burstSize);
 
    try{
        memory_addr_under_test = stoull(strInput_memaddrUT);
    } catch  (const std::exception& e) {
        std::cerr << e.what() << '\n';
        cout << "WARNING something bad happened in the insertion, hence default used" << endl;
        memory_addr_under_test = 64;
    }
    if(memory_addr_under_test > MAX_TESTABLE_ADDRESS || memory_addr_under_test<=0){
        cout << "WARNING the address inserted is not allowed, hence default use" << endl;
        memory_addr_under_test = 64;
        strInput_memaddrUT.assign(to_string(memory_addr_under_test));
    }
    unsigned int max_testingNumber = ((int) pow(2,MAX_TEST_REPETITION_BITWIDTH) - 1);
    try{
        testingNumber = stoul(strInput_nmbrTest);
    } catch (const std::exception& e) {
        std::cerr << e.what() << '\n';
        cout << "WARNING something bad happened in the insertion, hence default used" << endl;
        testingNumber = 2;
    }
    if(testingNumber > max_testingNumber || testingNumber<=0){
        cout << "WARNING the repetition inserted is not allowed, hence default use" << endl;
        testingNumber = 2;
        strInput_nmbrTest.assign(to_string(testingNumber));
    }
    try{
        burst_size = stoul(strInput_burstSize);
    } catch  (const std::exception& e) {
        std::cerr << e.what() << '\n';
        cout << "WARNING something bad happened in the insertion, hence default used" << endl;
        burst_size = 16;
    }
    if(burst_size > MAX_BURST_SIZE || burst_size<=0){
        cout << "WARNING the burst size inserted is not allowed, hence default use" << endl;
        burst_size = 16;
        strInput_burstSize.assign(to_string(burst_size));
    }
 
 
    unsigned long long int max_size_mem_size = pow(2,MAX_MEM_SIZE_BENCHMARKING_POWER_OF_TWO);
    unsigned long long int min_size_mem_size = pow(2,MIN_MEM_SIZE_BENCHMARKING_POWER_OF_TWO);
    unsigned int max_burst_size = MAX_BURST_SIZE_BENCHMARKING;
    unsigned int min_burst_size = MIN_BURST_SIZE_BENCHMARKING;
    unsigned int desired_repetitions = REPETITIONS_BENCHMARKING;
    unsigned int burst_size_opposite = min_burst_size;
    
    if(argc==7){
        strInput_listMode.assign(argv[6]);
    }else{
        strInput_listMode.assign("");
    }
    bool use_the_list_mode=false;
    if(strInput_listMode.compare("list")==0){
        use_the_list_mode=true;
        std::cout << "Employing the List mode with max of " << max_size_mem_size << std::endl;
    }
 
    //------------------------------------------------------------------------------------
    //-- STEP-4 : Infinite Loop for reexecutinge the application! :D
    //------------------------------------------------------------------------------------
    string user_choice = "r";
    createAVGLogFile();
    createItLogFile();
    if(use_the_list_mode){
        testingNumber=desired_repetitions;
        memory_addr_under_test=min_size_mem_size;
        burst_size=max_burst_size;
    }//else take user params
    //Iterating and interactive loop
    while (user_choice.compare("q") != 0 ) // quit
    {
    
        unsigned int test_pack = 1;
        size_t charOutputSizeRoughBytes=8*1+((8 * (2 + 1 + 1 + 1)) * testingNumber);
        test_pack = charOutputSizeRoughBytes%PACK_SIZE==0 ? charOutputSizeRoughBytes/PACK_SIZE : charOutputSizeRoughBytes/PACK_SIZE + 1;
        size_t charOutputSize = PACK_SIZE*(test_pack); 
        string initial_input_string(input_string);
 
        cout << " Creating mem test commands with " << memory_addr_under_test << " " <<  testingNumber << " " << burst_size << " as addr, iters, brst" << endl;
        input_string=createMemTestCommands(memory_addr_under_test, testingNumber,burst_size);
        size_t charInputSize = 8*2; //a single tdata*burst
 
        if (input_string.length() == 0) {
                cerr << "Empty string provided. Aborting...\n\n" << endl;
                exit(1);
            }
        
        clock_t start_cycle_main = clock();
        cout << " ___________________________________________________________________ " << endl;
        cout << "/                                                                   \\" << endl;
        cout << "INFO: Batch # " << ++num_frame << endl;
            
        // Ensure that the selection of MTU is a multiple of 8 (Bytes per transaction)
        assert(PACK_SIZE % 8 == 0);
    
        //packt host2FPGA
        unsigned int total_out_pack  =  1 + (input_string.length() - 1) / PACK_SIZE;// only a single tx
        unsigned int total_out_bytes = charInputSize;
        unsigned int bytes_out_last_pack = input_string.length() - (total_out_pack-1) * PACK_SIZE;
 
        //packt FPGA2host
        unsigned int total_in_pack  = test_pack;
        unsigned int total_in_bytes = total_in_pack * PACK_SIZE;
        unsigned int bytes_in_last_pack_in = charOutputSizeRoughBytes - (total_in_pack - 1) * PACK_SIZE;
 
        cout << "INFO: Network socket : " << ((net_type == tcp) ? "TCP" : "UDP") << endl;
        cout << "INFO: Total packets to send = " << total_out_pack << endl;
        cout << "INFO: Total packets to receive = " << total_in_pack << endl;
        cout << "INFO: Total bytes to send   = " << total_out_bytes << endl;
        cout << "INFO: Total bytes to receive   = " << total_in_bytes << endl;
        cout << "INFO: Total bytes rx " << total_in_bytes << " packets = "  << total_in_pack << endl;
        cout << "INFO: Bytes in last packet tx          = " << bytes_out_last_pack << endl;
        cout << "INFO: Bytes in last packet  rx         = " << bytes_in_last_pack_in << endl;
        cout << "INFO: Packet size (custom MTU)      = " << PACK_SIZE << endl;
            
        //------------------------------------------------------
        //-- STEP-5 : RUN MEMTEST FROM cF (HW)
        //------------------------------------------------------
        clock_t start_cycle_memtest_hw = clock();
            
        //------------------------------------------------------
        //-- STEP-5.1 : TX Loop
        //------------------------------------------------------
        clock_t last_cycle_tx = clock();
        unsigned int sending_now = PACK_SIZE;
        for (unsigned int i = 0; i < total_out_pack; i++) {
            if ( i == total_out_pack - 1 ) {
            sending_now = bytes_out_last_pack;
            }
            #if NET_TYPE == udp
            //printStringHex(input_string,charInputSize*sizeof(char));
            //printBits(charInputSize,input_string.c_str());
            udpsock.sendTo( & input_string[i * PACK_SIZE], sending_now, servAddress, servPort);
            #else
                tcpsock.send( & input_string[i * PACK_SIZE], sending_now);
            #endif
            delay(1000);  
        }
        clock_t next_cycle_tx = clock();
        double duration_tx = (next_cycle_tx - last_cycle_tx) / (double) CLOCKS_PER_SEC;
        cout << "INFO: Effective SPS TX:" << (1 / duration_tx) << " \tkbps:" << (PACK_SIZE * 
            total_out_pack / duration_tx / 1024 * 8) << endl;
        last_cycle_tx = next_cycle_tx;
    
            
        //------------------------------------------------------
        //-- STEP-5.2 : RX Loop
        //------------------------------------------------------    
        clock_t last_cycle_rx = clock();
        unsigned int bytes_received = 0;
        unsigned int receiving_now = PACK_SIZE;
        cout << "INFO: Expecting length of packs:" << total_in_pack << endl;
        char * longbuf = new char[PACK_SIZE * total_in_pack+1];
        for (unsigned int i = 0; i < total_in_pack; ) {
                if ( i == total_in_pack - 1 ) {
                    receiving_now = bytes_in_last_pack_in;
                }
            #if NET_TYPE == udp               
            recvMsgSize = udpsock.recvFrom(buffer, BUF_LEN, servAddress, servPort);
            #else
            recvMsgSize = tcpsock.recv(buffer, BUF_LEN);
            #endif
            if (recvMsgSize != receiving_now) {
            cerr << "WARNING: Received unexpected size pack:" << recvMsgSize << ". Expected: " << 
                receiving_now << endl;
                }
                memcpy( longbuf+(i*bytes_received), buffer, recvMsgSize);
            cout << "DEBUG: recvMsgSize=" << recvMsgSize << endl;
            bytes_received  += recvMsgSize;
            i ++;
        }
 
        cout << "INFO: Received packet from " << servAddress << ":" << servPort << endl;
    
        #ifdef PY_WRAP
        char *output_string = output_str;
        #else
        char *output_string = new char [(PACK_SIZE * total_in_pack*sizeof(char))];
        #endif
        memcpy( output_string, longbuf, bytes_received*sizeof(char));
        output_string[PACK_SIZE * total_in_pack]='\0';
        cout << "INFO: Received string : " << output_string << endl;
        //printCharBuffHex(output_string,bytes_received);
 
        clock_t next_cycle_rx = clock();
        double duration_rx = (next_cycle_rx - last_cycle_rx) / (double) CLOCKS_PER_SEC;
        cout << "INFO: Effective SPS RX:" << (1 / duration_rx) << " \tkbps:" << (PACK_SIZE * 
                    total_in_pack / duration_rx / 1024 * 8) << endl;
        last_cycle_rx = next_cycle_rx;
        
        clock_t end_cycle_memtest_hw = next_cycle_rx;
            
        double duration_memtest_hw = (end_cycle_memtest_hw - start_cycle_memtest_hw) / 
                                        (double) CLOCKS_PER_SEC;
        cout << "INFO: HW exec. time:" << duration_memtest_hw << " seconds" << endl;
        cout << "INFO: Effective SPS HW:" << (1 / duration_memtest_hw) << " \tkbps:" << 
                    (PACK_SIZE * total_in_pack / duration_memtest_hw / 1024 * 8) << endl;     
            
        double duration_main = (clock() - start_cycle_main) / (double) CLOCKS_PER_SEC;
        cout << "INFO: Effective SPS E2E:" << (1 / duration_main) << endl;
        cout << "\\___________________________________________________________________/" << endl
        << endl;
        //------------------------------------------------------
        //-- STEP-5.3 : Parsing and displaying
        //------------------------------------------------------ 
        cout << " ___________________________________________________________________ " << endl;
        cout << "/                                                                   \\" << endl;
        cout <<"INFO: Entering in the output parsing section  "<< endl;
        std::vector<MemoryTestResult> testResults_vector;
        string output_to_parse_string;
        output_to_parse_string.append(output_string,charOutputSizeRoughBytes);
        int rawdatalines = charOutputSizeRoughBytes / 8;;
        testResults_vector=parseMemoryTestOutput(output_to_parse_string,charOutputSizeRoughBytes,rawdatalines);
        //otuput showing
        cout << "INFO: Test Results appearing" << endl;
        cout << " The Memory test run for  " << testResults_vector.size() << " iterations " << endl;
        unsigned int mem_word_size = 512;
        unsigned int mem_word_byte_size = mem_word_size/8;
        double rd_bndwdth=0.0;
        double wr_bndwdth=0.0;
        double avg_rd_bndwdth=0.0;
        double avg_wr_bndwdth=0.0;
        int avg_fault_cnt = 0;
        int iterations=0;
        unsigned long long int written_words=0;
        for(auto it = std::begin(testResults_vector); it != std::end(testResults_vector); ++it) {
            cout << " Test number " << it - testResults_vector.begin() << " stress " <<     it->target_address << " addresses "  << endl;
            cout << " it presented " << it->fault_cntr << " faults " << endl;
            cout << " and the first faulty address (if any) was " << it->first_fault_address << endl;
            written_words = ((it->target_address) %mem_word_byte_size) == 0 ? ((it->target_address)/mem_word_byte_size)  : (((it->target_address)/mem_word_byte_size) + 1);
            rd_bndwdth = ( (double)written_words*(double)mem_word_size / ( (double)it->clock_cycles_read * 6.4 ) ); // Gbit/T
            wr_bndwdth = ( (double)written_words*(double)mem_word_size / ( (double)it->clock_cycles_write * 6.4 ) );
            cout << " RD BW " << rd_bndwdth  << "[GBit/s], with  " << it->clock_cycles_read << " ccs" <<  endl;
            cout << " WR BW " << wr_bndwdth << "[GBit/s], with  " << it->clock_cycles_write << " ccs" <<  endl;
            cout << endl << endl;
            avg_rd_bndwdth += rd_bndwdth;
            avg_wr_bndwdth += wr_bndwdth;
            avg_fault_cnt += it->fault_cntr;
            iterations++;
 
            logTheSingleResult(iterations, it->target_address, burst_size, written_words, rd_bndwdth, wr_bndwdth, it->fault_cntr, it->first_fault_address);
        }
        avg_rd_bndwdth = avg_rd_bndwdth / iterations;
        avg_wr_bndwdth = avg_wr_bndwdth / iterations;
        avg_fault_cnt = avg_fault_cnt / iterations;
        cout << "Based on " << iterations << " iterations, AVG WR " << avg_wr_bndwdth << " AVG RD " << avg_rd_bndwdth << " AVG faults " << avg_fault_cnt << endl;
 
        logTheAvgResult(iterations, memory_addr_under_test, burst_size, written_words, avg_rd_bndwdth, avg_wr_bndwdth, avg_fault_cnt);
        //clear dynamic memory
        delete [] longbuf;
        delete [] output_string;
        testResults_vector.clear();
        output_to_parse_string.clear();
        input_string.clear();
        initial_input_string.clear();
        strInput_memaddrUT.clear();
        strInput_nmbrTest.clear();
        //------------------------------------------------------
        //-- STEP-5.4 : Interaction part
        //------------------------------------------------------ 
        //Need to close the application and send to the accelerator a stop for signaling a termination
        if (user_choice.compare("rq")==0)
        {
            cout << "INFO: going to close the application and send a stop command as the user requested." << endl;
            user_choice.clear();
            string cmd_string = createMemTestStopCommand();
            char stop_char_buff [8];
            memcpy(stop_char_buff, cmd_string.data(), 8);
            sending_now = 8;
            //printCharBuffHex(stop_char_buff,8);
            #if NET_TYPE == udp
                udpsock.sendTo(stop_char_buff, sending_now, servAddress, servPort);
            #else
                tcpsock.send(stop_char_buff, sending_now);
            #endif
            delay(1000); 
            #if NET_TYPE == udp               
            recvMsgSize = udpsock.recvFrom(buffer, BUF_LEN, servAddress, servPort);
            #else
            recvMsgSize = tcpsock.recv(buffer, BUF_LEN);
            #endif
            delay(1000); 
            char output_stop [8];
            memcpy(output_stop,buffer,8);
            if(strcmp(output_stop,stop_char_buff)==0){
                cout << "INFO: Accelerator answered ok" << endl;
            }else{
                cout << "INFO: Bad answer received, take care "<< endl;
                //printStringHex(output_stop,8);
            }
            cout << "INFO: IBM ZRL Memtest is closing." << endl<< "Goodbye :D" << endl;
            break;
        }
        
        user_choice.clear();
        string confirmation="";
 
        cout << "That is all from this application." << endl;
 
        if(use_the_list_mode){
            user_choice.assign("r");
            testingNumber=desired_repetitions;
            burst_size=burst_size/2;
            burst_size_opposite=burst_size_opposite*2;
            cout << " burst size  " << burst_size << " burst oppostit " << burst_size_opposite << endl; 
            if(burst_size_opposite>max_burst_size){ //if iterated all the burst sizes quit
    //          memory_addr_under_test=min_size_mem_size;
                burst_size=max_burst_size;
                burst_size_opposite=min_burst_size;
                memory_addr_under_test=memory_addr_under_test*2;
                memory_addr_under_test=memory_addr_under_test==max_size_mem_size ? memory_addr_under_test-64 : memory_addr_under_test;
                if(memory_addr_under_test>max_size_mem_size){ //if iterated all the mem trgt address increment the burst
                    user_choice.assign("q");
                }
            }
            //unsigned long long int max_gb =  8*pow(10,9);
            //memory_addr_under_test=memory_addr_under_test%max_gb;
 
        }else{
 
            while (user_choice.empty() || (confirmation.compare("y")!=0) || ( (confirmation.compare("y")==0)  && (user_choice.compare("r")!=0 && user_choice.compare("q")!=0) && user_choice.compare("rq")!=0) )
            {
                cout << "What do you want to do now?" << endl;
                cout << " <r>: run a new test, <q>: quit, <rq>: run a new test and quit "<<endl;
                cout << "Please type your choice "<<endl;
                cin >> user_choice;
                cout << "Your choice is " << user_choice << ", is it ok? (y/n) " << endl;
                cin >> confirmation;
            }
            if (user_choice.compare("q")!=0)
            {
                confirmation.clear();
                const unsigned long long int max_testable_address = MAX_TESTABLE_ADDRESS;
                while ( strInput_memaddrUT.empty() || strInput_nmbrTest.empty() || strInput_burstSize.empty() || (confirmation.compare("y")!=0))
                {
                    cout << "Please type in the maximum address to test (no more than "<< to_string(max_testable_address) << ")"<< endl;
                    cin >> strInput_memaddrUT;
                    try{
                        memory_addr_under_test = stoull(strInput_memaddrUT);
                    } catch  (const std::exception& e) {
                        std::cerr << e.what() << '\n';
                        cout << "WARNING something bad happened in the insertion, hence default used" << endl;
                        memory_addr_under_test = 64;
                    }
                    if(memory_addr_under_test > MAX_TESTABLE_ADDRESS || memory_addr_under_test<=0){
                        cout << "WARNING the address inserted is not allowed, hence default use" << endl;
                        memory_addr_under_test = 64;
                        strInput_memaddrUT.assign(to_string(memory_addr_under_test));
                    }
                    unsigned int max_testingNumber = ((int) pow(2,MAX_TEST_REPETITION_BITWIDTH) - 1);
                    cout << "Please type in the repetition of the test (no more than " << to_string(max_testingNumber) << ")"<< endl;
                    cin >> strInput_nmbrTest;
                    try{
                        testingNumber = stoul(strInput_nmbrTest);
                    } catch (const std::exception& e) {
                        std::cerr << e.what() << '\n';
                        cout << "WARNING something bad happened in the insertion, hence default used" << endl;
                        testingNumber = 3;
                    }
                    if(testingNumber > max_testingNumber || testingNumber<=0){
                        cout << "WARNING something bad happened in the insertion, hence default used" << endl;
                        testingNumber = 2;
                        strInput_nmbrTest.assign(to_string(testingNumber));
                    }
                    cout << "Please type in the desired burst size (no more than "<< to_string(MAX_BURST_SIZE) << ")"<< endl;
                    cin >> strInput_burstSize;
                    try{
                        burst_size = stoul(strInput_burstSize);
                    } catch  (const std::exception& e) {
                        std::cerr << e.what() << '\n';
                        cout << "WARNING something bad happened in the insertion, hence default used" << endl;
                        burst_size = 16;
                    }
                    if(burst_size > MAX_BURST_SIZE || burst_size<=0){
                        cout << "WARNING the burst size inserted is not allowed, hence default use" << endl;
                        burst_size = 16;
                        strInput_burstSize.assign(to_string(burst_size));
                    }
                    cout << "Your choice is to test " << testingNumber << " times up to address " << memory_addr_under_test  << " burst size " << burst_size << ", is it ok? (y/n) " << endl;
                    cin >> confirmation;
                }
            }
        }  //else interactive
        if (user_choice.compare("q")==0)
        {
            cout << "INFO: IBM ZRL Memtest is closing." << endl<< "Goodbye :D" << endl;
            user_choice.clear();
            string cmd_string = createMemTestStopCommand();
            char stop_char_buff [8];
            memcpy(stop_char_buff, cmd_string.data(), 8);
            sending_now = 8;
            //printCharBuffHex(stop_char_buff,8);
            #if NET_TYPE == udp
                udpsock.sendTo(stop_char_buff, sending_now, servAddress, servPort);
            #else
                tcpsock.send(stop_char_buff, sending_now);
            #endif
            delay(1000); 
            #if NET_TYPE == udp               
            recvMsgSize = udpsock.recvFrom(buffer, BUF_LEN, servAddress, servPort);
            #else
            recvMsgSize = tcpsock.recv(buffer, BUF_LEN);
            #endif
            delay(1000); 
            char output_stop [8];
            memcpy(output_stop,buffer,8);
            if(strcmp(output_stop,stop_char_buff)==0){
                cout << "INFO: Accelerator answered ok" << endl;
            }else{
                cout << "INFO: Bad answer received, take care "<< endl;
                //printStringHex(output_stop,8);
            }
            cout << "INFO: IBM ZRL Memtest is closing." << endl<< "Goodbye :D" << endl;
            break;
        } // if to quit
        
    }//end of while loop
 
// Destructor closes the socket
}catch (SocketException & e) {
    cerr << e.what() << endl;
    cout << "INFO: there was a SocketException, now aborting" << endl;
    exit(1);
}
 
 
    return 0;
}

Here is the call graph for this function:

MemoryTestResult() [1/2]

MemoryTestResult::MemoryTestResult ( )

inline

Definition at line 421 of file common.hpp.

{}

MemoryTestResult() [2/2]

MemoryTestResult::MemoryTestResult ( unsigned long long int  target_address, unsigned int  fault_cntr, unsigned int  first_fault_address, unsigned long long int  clock_cycles_write, unsigned long long int  clock_cycles_read  )

inline

Definition at line 422 of file common.hpp.

                                              :
    target_address(target_address), 
    fault_cntr(fault_cntr), 
    first_fault_address(first_fault_address),  
    clock_cycles_write(clock_cycles_write),
    clock_cycles_read(clock_cycles_read) {}

number2hexString()

template<typename T >

void number2hexString	(	const T	in,
		char *	out,
		size_t	byteSize
	)

Definition at line 266 of file common.hpp.

{
    std::sprintf(out,byteSize, "%x", (char*)&in);
}

parseMemoryTestOutput()

template<unsigned int bytes_per_line = 8>

std::vector<MemoryTestResult> parseMemoryTestOutput	(	const string	longbuf,
		size_t	charOutputSize,
		int	rawdatalines
	)

Parse the memory test output contained in astring with a given size.

Parameters

[in]	longbuf	the buffer containing the output
[in]	charOutputSize	the bytesize of the buffer
[in]	rawdatalines	the number of lines in the given outbuf

Returns

vectpr of MemoryTestResult data strcuture

Definition at line 444 of file common.hpp.

{
  std::vector<MemoryTestResult> testResults_vector;
 
  int rawiterations = charOutputSize / 8; //should be equivalent to rawdatalines
  unsigned int mem_word_size = 512;
  unsigned int mem_word_byte_size = mem_word_size/8;
  bool is_stop_present = rawdatalines % (3+1+1) == 0; //guard to check if multiple data of 3 64bytes or with 
 
  int k = 1;
  char myTmpOutBuff [bytes_per_line];
  for (int i = 0; i < bytes_per_line; ++i)
  {
      myTmpOutBuff[i]=(char)0;
  }
  unsigned int testingNumber_out=0, fault_cntr_out=0, fault_addr_out=0;
  unsigned long long int max_memory_addr_out=0, clock_cycles_read=0, clock_cycles_write=0;
  for (int i = 1; i < rawdatalines+1; i++)
  {
    string tmp_outbuff;
    tmp_outbuff= longbuf.substr((i-1)*bytes_per_line,bytes_per_line);
    if(is_stop_present && k==7){
      cout << "DEBUG the stop is present and is here" << endl;
    } else  if( ( (i == rawdatalines-1) || (i == rawdatalines) ) && k==6){ //check it is either the last or one before the last
      //substr extraction and parsing
      //strncpy(myTmpOutBuff,tmp_outbuff.c_str()+1,bytes_per_line-1);
      //testingNumber_out = *reinterpret_cast<unsigned long long*>(myTmpOutBuff);
      memcpy(&testingNumber_out,tmp_outbuff.c_str()+1,bytes_per_line/2);
 
    #if DEBUG_LEVEL == TRACE_ALL
      cout << "DEBUG last command with the iterations " << testingNumber_out << endl;
    #endif
    }else if(k==5){
      //strncpy(myTmpOutBuff,tmp_outbuff.c_str(),bytes_per_line);
      //clock_cycles_read = *reinterpret_cast<unsigned long long int*>(myTmpOutBuff);
      memcpy(&clock_cycles_read,tmp_outbuff.c_str(),bytes_per_line);
 
          #if DEBUG_LEVEL == TRACE_ALL
      cout << "DEBUG clock_cycles_read (or the fourth half data pckt) " << clock_cycles_read << endl;
      cout << "DEBUG clock_cycles_write (or the fourth half data pckt) " << clock_cycles_write << endl;
    #endif
      MemoryTestResult tmpResult(max_memory_addr_out,fault_cntr_out,fault_addr_out,clock_cycles_write,clock_cycles_read);
      testResults_vector.push_back(tmpResult);
      if(!( (i+1 == rawdatalines-1) || (i+1 == rawdatalines) )){
        k=0;
    #if DEBUG_LEVEL == TRACE_ALL
      cout << "DEBUG reinit the counter" << endl;
    #endif
      }
      unsigned int written_words = max_memory_addr_out%mem_word_byte_size == 0 ? max_memory_addr_out/mem_word_byte_size  : max_memory_addr_out/mem_word_byte_size + 1;
      double rd_bndwdth = ( (double)written_words*(double)mem_word_size / ( (double)tmpResult.clock_cycles_read * ( 6.4 ) ) ); // Gbit/T
      double wr_bndwdth = ( (double)written_words*(double)mem_word_size / ( (double)tmpResult.clock_cycles_write * ( 6.4 ) ) );
    #if DEBUG_LEVEL == TRACE_ALL
      cout << "Written " << written_words << " words" << endl;
      cout << "DEBUG overall test results: target address " << tmpResult.target_address << " ";
      cout << "Fault counter: " << tmpResult.fault_cntr << " ";
      cout << "First fault at address: " << tmpResult.first_fault_address << " "  << endl;
      cout << " RD BW " << rd_bndwdth  << "[GBit/s] with cc equal to " << tmpResult.clock_cycles_read << " "  << endl;
      cout << " WR BW " << wr_bndwdth << "[GBit/s] with cc equal to " << tmpResult.clock_cycles_write << " "  << endl;
    #endif
    } else  if(k==4){ //clock cycless
      //char mySecondTmpOutBuff[bytes_per_line/2];
      //string additional_string;
      //init the buffer
      //for(int i=0;i<bytes_per_line;i++){myTmpOutBuff[i]=(char)0;mySecondTmpOutBuff[i%(bytes_per_line/2)]=(char)0;}
      // additional_string=tmp_outbuff.substr(bytes_per_line/2,bytes_per_line/2);
      //
      // tmp_outbuff = tmp_outbuff.erase(bytes_per_line/2,bytes_per_line/2);
      // strncpy(myTmpOutBuff,tmp_outbuff.c_str(),bytes_per_line/2);
      // clock_cycles_read = *reinterpret_cast<unsigned int*>(myTmpOutBuff);
      //
      // strncpy(mySecondTmpOutBuff,additional_string.c_str(),bytes_per_line/2);
      // clock_cycles_write = *reinterpret_cast<unsigned int*>(mySecondTmpOutBuff);
      //strncpy(myTmpOutBuff,tmp_outbuff.c_str(),bytes_per_line);
      //clock_cycles_write = *reinterpret_cast<unsigned long long int*>(myTmpOutBuff);
      memcpy(&clock_cycles_write,tmp_outbuff.c_str(),bytes_per_line);
 
    }else if(k==3){ // first fault address
      //substr extraction and parsing
      //strncpy(myTmpOutBuff,tmp_outbuff.c_str(),bytes_per_line);
      //fault_addr_out = *reinterpret_cast<unsigned long long int *>(myTmpOutBuff);
      memcpy(&fault_addr_out,tmp_outbuff.c_str(),bytes_per_line/2);
 
    #if DEBUG_LEVEL == TRACE_ALL
      cout << "DEBUG first fault address (or the third data pckt) " << fault_addr_out << endl;
    #endif
    }else if(k==2){ // fault cntr
      //strncpy(myTmpOutBuff,tmp_outbuff.c_str(),bytes_per_line);
      //fault_cntr_out = *reinterpret_cast<unsigned long long int *>(myTmpOutBuff);
      memcpy(&fault_cntr_out,tmp_outbuff.c_str(),bytes_per_line/2);
 
    #if DEBUG_LEVEL == TRACE_ALL
      cout << "DEBUG the fault counters (or the second data pack) " <<  fault_cntr_out << endl;
    #endif
    }else { //max addrss
      //substr extraction and parsing
      // strncpy(myTmpOutBuff,tmp_outbuff.c_str(),bytes_per_line);
      // max_memory_addr_out = *reinterpret_cast<unsigned long long *>(myTmpOutBuff);
      memcpy(&max_memory_addr_out,tmp_outbuff.c_str(),bytes_per_line);
      #if DEBUG_LEVEL == TRACE_ALL
      cout << "DEBUG max address (or the first data pack) " << max_memory_addr_out << endl;
    #endif
    }
    k++;
    tmp_outbuff.clear();
  }
  return testResults_vector;
}

Here is the caller graph for this function:

print_cFpMemtest()

void print_cFpMemtest

(

void

)

Definition at line 69 of file common.hpp.

{
    // http://patorjk.com/software/taag/#p=display&f=ANSI%20Shadow&t=cFp_Memtest
        cout <<  "                                                          " << endl;
    cout <<  "...build with:                                            " << endl;
    cout <<  " ██████╗███████╗██████╗    ███╗   ███╗███████╗███╗   ███╗████████╗███████╗███████╗████████╗" << endl;
    cout <<  "██╔════╝██╔════╝██╔══██╗   ████╗ ████║██╔════╝████╗ ████║╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝" << endl;
    cout <<  "██║     █████╗  ██████╔╝   ██╔████╔██║█████╗  ██╔████╔██║   ██║   █████╗  ███████╗   ██║   " << endl;
    cout <<  "██║     ██╔══╝  ██╔═══╝    ██║╚██╔╝██║██╔══╝  ██║╚██╔╝██║   ██║   ██╔══╝  ╚════██║   ██║   " << endl;
    cout <<  "╚██████╗██║     ██║███████╗██║ ╚═╝ ██║███████╗██║ ╚═╝ ██║   ██║   ███████╗███████║   ██║   " << endl;
    cout <<  " ╚═════╝╚═╝     ╚═╝╚══════╝╚═╝     ╚═╝╚══════╝╚═╝     ╚═╝   ╚═╝   ╚══════╝╚══════╝   ╚═╝   " << endl;
    cout <<  "A cloudFPGA project from IBM ZRL               v0.1 --dco " << endl;
    cout <<  "                                                          " << endl;
}

Here is the caller graph for this function:

printBits()

void printBits	(	size_t const	size,
		void const *const	ptr
	)

print the binary representation of a target pointer buffer of a given size. Assumes little endian.

Parameters

[in]	size	the bytesize to print from ptr.
[in]	ptr	the buffer pointer.

Returns

nothing, print to stdout.

Definition at line 98 of file common.hpp.

{
    unsigned char *b = (unsigned char*) ptr;
    unsigned char byte;
    int i, j;
    
    for (i = size-1; i >= 0; i--) {
        for (j = 7; j >= 0; j--) {
            byte = (b[i] >> j) & 1;
            printf("%u", byte);
        }
    }
    puts("");
}

Here is the caller graph for this function:

printCharBuffHex()

void printCharBuffHex	(	const char *	inStr,
		size_t	strSize
	)

print byte-per-byte a given char buff in hexadecimal format

Parameters

[in]	inStr	char buff to print
[in]	strSize	bytsize to print (can be even less, NOT more )

Definition at line 382 of file common.hpp.

                                                         {
    #if DEBUG_LEVEL == TRACE_ALL
    printf("Going to prit a hex char buff :D\n");
  #endif
    for (size_t i = 0; i < strSize; i++)
    {
        printf("%x",inStr[i]);
    }
    printf("\n");
    
}

printCharBuffHexSafe()

void printCharBuffHexSafe	(	const char *	inStr,
		size_t	strSize
	)

Definition at line 394 of file common.hpp.

                                                             {
    printf("Going to prit a hex char buff :D\n");
    for (size_t i = 0; i < strSize; i++)
    {
        char tmp = inStr[i];
        printf("%x",tmp);
    }
    printf("\n");
    
}

printStringHex()

void printStringHex	(	const string	inStr,
		size_t	strSize
	)

print byte-per-byte a given string in hexadecimal format

Parameters

[in]	inStr	string to print
[in]	strSize	bytsize to print (can be even less, NOT more )

Definition at line 363 of file common.hpp.

                                                       {
    #if DEBUG_LEVEL == TRACE_ALL
    printf("Going to print a hex string :D\n");
  #endif
    for (size_t i = 0; i < strSize; i++)
    {
        printf("%x",inStr[i]);
    }
    printf("\n");
    
}

string2hexnumerics()

void string2hexnumerics	(	const string &	in,
		char *	out,
		size_t	byteSize
	)

Definition at line 405 of file common.hpp.

{
    for (int i = 0; i < byteSize; i++)
    {
        std::sprintf(out+i, "%d", (int)in[i]);
    }
}

Variable Documentation

clock_cycles_read

unsigned long long int MemoryTestResult::clock_cycles_read

Definition at line 418 of file common.hpp.

clock_cycles_write

unsigned long long int MemoryTestResult::clock_cycles_write

Definition at line 419 of file common.hpp.

fault_cntr

unsigned int MemoryTestResult::fault_cntr

Definition at line 416 of file common.hpp.

first_fault_address

unsigned int MemoryTestResult::first_fault_address

Definition at line 417 of file common.hpp.

loggingAVGFile

std::ofstream loggingAVGFile

Definition at line 554 of file common.hpp.

loggingAVGFileName

const std::string loggingAVGFileName ="cfp_vitis_memtest_avg.csv"

Definition at line 555 of file common.hpp.

loggingMultiItFile

std::ofstream loggingMultiItFile

Definition at line 582 of file common.hpp.

loggingMultiItFileName

const std::string loggingMultiItFileName ="cfp_vitis_memtest_multi.csv"

Definition at line 583 of file common.hpp.

target_address

unsigned long long int MemoryTestResult::target_address

Definition at line 415 of file common.hpp.