Memtest HLS

This is a subgroup of Memtest accelerated function with only synthesizable (HLS) functions/classes. More...

Collaboration diagram for Memtest HLS:

Files
file	memtest.hpp
	The Role for a Memtest Example application (UDP or TCP)
file	memtest_library.hpp
	A library for some common functionalities: Network-Related Memory interaction Performance Counters.
file	memtest_pattern_library.hpp
	A library for memory test functionalities: sequence generation, reading, writing.
file	memtest_processing.hpp
	The processing template for the memory test.
file	memtest.cpp
	The Role for a Memtest Example application (UDP or TCP)

Macros
#define	ENABLE_DDR
#define	ROLE_IS_MEMTEST
#define	MEMTEST_COMMANDS_HIGH_BIT   MEMTEST_COMMANDS_BITWIDTH-1
#define	MEMTEST_COMMANDS_LOW_BIT   0
#define	MEMTEST_COMMANDS_BITWIDTH   8
#define	WAIT_FOR_META   0
#define	WAIT_FOR_STREAM_PAIR   1
#define	PROCESSING_PACKET   2
#define	MEMTEST_RETURN_RESULTS   3
#define	PacketFsmType   uint8_t
#define	FSM_WRITE_NEW_DATA   0
#define	FSM_DONE   1
#define	PortFsmType   uint8_t
#define	DEFAULT_TX_PORT   2718
#define	DEFAULT_RX_PORT   2718
#define	MEMDW_512   512
#define	TOTMEMDW_512   16384
#define	CYCLES_UNTIL_TIMEOUT   0x0100
#define	TYPICAL_DDR_LATENCY   4
#define	DDR_LATENCY   52
#define	EXTRA_DDR_LATENCY_DUE_II   (64 + 8)
#define	LOCAL_MEM_WORD_SIZE   512
#define	LOCAL_MEM_ADDR_SIZE   40
#define	LOCAL_MEM_ADDR_SIZE_NON_BYTE_ADDRESSABLE   40
#define	LOCAL_MEM_ADDR_OFFSET   (LOCAL_MEM_WORD_SIZE/8)
#define	LOCAL_MEM_WORD_BYTE_SIZE   (LOCAL_MEM_WORD_SIZE/8)
#define	FAULT_INJECTION
#define	FSM_PROCESSING_WAIT_FOR_META   0
#define	FSM_PROCESSING_PCKT_PROC   1
#define	FSM_PROCESSING_STOP   2
#define	FSM_PROCESSING_START   3
#define	FSM_PROCESSING_BURST_READING   4
#define	FSM_PROCESSING_DATAFLOW_WRITE   5
#define	FSM_PROCESSING_DATAFLOW_READ   6
#define	FSM_PROCESSING_OUTPUT   7
#define	FSM_PROCESSING_OUTPUT_2   8
#define	FSM_PROCESSING_OUTPUT_3   9
#define	FSM_PROCESSING_OUTPUT_4   10
#define	FSM_PROCESSING_OUTPUT_5   11
#define	FSM_PROCESSING_CONTINUOUS_RUN   12
#define	FSM_PROCESSING_WAIT_FOR_DDR_CONTROLLER_EMPTYNESS   13
#define	ProcessingFsmType   uint8_t
#define	MEMTEST_ADDRESS_BITWIDTH   40
#define	MEMTEST_ITERATION_BITWIDTH   16
#define	MEMTEST_BURST_BITWIDTH   16
#define	MEMTEST_ADDRESS_HIGH_BIT   NETWORK_WORD_BIT_WIDTH-1
#define	MEMTEST_ADDRESS_LOW_BIT   NETWORK_WORD_BIT_WIDTH-MEMTEST_ADDRESS_BITWIDTH
#define	MEMTEST_ITERATIONS_HIGH_BIT   MEMTEST_ADDRESS_LOW_BIT-1
#define	MEMTEST_ITERATIONS_LOW_BIT   MEMTEST_ITERATIONS_HIGH_BIT+1-MEMTEST_ITERATION_BITWIDTH
#define	MEMTEST_BURST_HIGH_BIT   MEMTEST_BURST_BITWIDTH-1+MEMTEST_COMMANDS_BITWIDTH
#define	MEMTEST_BURST_LOW_BIT   MEMTEST_BURST_HIGH_BIT+1-MEMTEST_BURST_BITWIDTH
#define	Data_t_in   ap_axiu<INPUT_PTR_WIDTH, 0, 0, 0>
#define	Data_t_out   ap_axiu<OUTPUT_PTR_WIDTH, 0, 0, 0>

Typedefs
typedef ap_uint< 512 >	membus_512_t
typedef membus_512_t	membus_t
typedef ap_uint< 512 >	local_mem_word_t
typedef ap_uint< 40 >	local_mem_addr_t
typedef ap_uint< 40 >	local_mem_addr_non_byteaddressable_t

Enumerations
enum	EchoCtrl {   ECHO_PATH_THRU = 0 , ECHO_STORE_FWD = 1 , ECHO_OFF = 2 , ECHO_PATH_THRU = 0 ,   ECHO_STORE_FWD = 1 , ECHO_OFF = 2 , ECHO_PATH_THRU = 0 , ECHO_STORE_FWD = 1 ,   ECHO_OFF = 2 , ECHO_PATH_THRU = 0 , ECHO_STORE_FWD = 1 , ECHO_OFF = 2 ,   ECHO_PATH_THRU = 0 , ECHO_STORE_FWD = 1 , ECHO_OFF = 2 , ECHO_PATH_THRU = 0 ,   ECHO_STORE_FWD = 1 , ECHO_OFF = 2 , ECHO_PATH_THRU = 0 , ECHO_STORE_FWD = 1 ,   ECHO_OFF = 2 , ECHO_STORE_FWD = 0 , ECHO_PATH_THRU = 1 , ECHO_CTRL_DISABLED = 0 ,   ECHO_PATH_THRU = 1 , ECHO_STORE_FWD = 2 , ECHO_OFF = 3 }
enum	MemTestCmd {   TEST_BURSTSIZE_CMD = 4 , TEST_ENDOFTESTS_CMD = 3 , TEST_STOP_CMD = 2 , TEST_START_CMD = 1 ,   TEST_INVLD_CMD = 0 , WRPTX_IMG_CMD = 2 , WRPTX_TXMAT_CMD = 1 , WRPTX_INVLD_CMD = 0 }

Functions
void	memtest (ap_uint< 32 > *pi_rank, ap_uint< 32 > *pi_size, stream< NetworkWord > &siSHL_This_Data, stream< NetworkWord > &soTHIS_Shl_Data, stream< NetworkMetaStream > &siNrc_meta, stream< NetworkMetaStream > &soNrc_meta, ap_uint< 32 > *po_rx_ports, membus_t *lcl_mem0, membus_t *lcl_mem1)
	Main process of the Memtest Application directives. More...
void	pPortAndDestionation (ap_uint< 32 > *pi_rank, ap_uint< 32 > *pi_size, stream< NodeId > &sDstNode_sig, ap_uint< 32 > *po_rx_ports)
	pPortAndDestionation - Setup the port and the destination rank. More...
void	pRXPath (stream< NetworkWord > &siSHL_This_Data, stream< NetworkMetaStream > &siNrc_meta, stream< NetworkMetaStream > &sRxtoProc_Meta, stream< NetworkWord > &sRxpToProcp_Data, NetworkMetaStream meta_tmp, bool *start_stop, unsigned int *processed_word_rx, unsigned int *processed_bytes_rx)
	Receive Path - From SHELL to THIS. More...
void	pTXPath (stream< NetworkWord > &soTHIS_Shl_Data, stream< NetworkMetaStream > &soNrc_meta, stream< NetworkWord > &sProcpToTxp_Data, stream< NetworkMetaStream > &sRxtoTx_Meta, stream< NodeId > &sDstNode_sig, unsigned int *processed_word_tx, ap_uint< 32 > *pi_rank)
	Transmit Path - From THIS to SHELL. More...
template<typename Tin , typename Tout , unsigned int arraysize>
void	pMyMemtestMemCpy (Tin *in, Tout *out)
	Copy a fixed compile time amount of data to another array. More...
template<typename Tin , typename Tout , const unsigned int arraysize>
void	pMemCpyCircularBuff (Tin *buff, Tout *out_mem, unsigned int elems, unsigned int offset_buff)
	Copy a run-time variable amount of data to another array employing the src as circular buffer i.e., handling overflow. More...
template<typename Tin , typename Tout , const unsigned int burstsize>
void	pReadAxiMemMapped2HlsStream (Tin *main_mem, hls::stream< Tout > &sOut, unsigned int elems)
	Copy a run-time variable amount of data to an hls stream with a given max. More...
template<typename Tin , typename Tout , const unsigned int burstsize, typename Tcntr >
void	pReadAxiMemMapped2HlsStreamCountFirst (Tin *main_mem, hls::stream< Tout > &sOut, unsigned int elems, hls::stream< Tcntr > &cmd)
	Copy a run-time variable amount of data to an hls stream with a given max it assumes also the initialization of a perf counter of "perfCounterMultipleCounts" function. More...
template<typename Tin , typename Tout , const unsigned int burstsize, typename Tcntr >
void	pReadAxiMemMapped2HlsStreamCountActivated (Tin *main_mem, hls::stream< Tout > &sOut, unsigned int elems, hls::stream< Tcntr > &cmd)
	Copy a run-time variable amount of data to an hls stream with a given max it assumes "perfCounterMultipleCounts" function already initialized so it just incr. More...
template<typename Tin , typename Tout , const unsigned int burstsize, typename Tcntr >
void	pReadAxiMemMapped2HlsStreamCountExtern (Tin *main_mem, hls::stream< Tout > &sOut, unsigned int elems, hls::stream< Tcntr > &cmd, bool activated)
	Copy a run-time variable amount of data to an hls stream with a given max it assumes "perfCounterMultipleCounts" function already initialized so it just incr. More...
template<typename Tin , typename Tout , unsigned int counter_precision = 64>
void	perfCounterProc (hls::stream< Tin > &cmd, hls::stream< Tout > &out, int direction, int burst_length, int nmbr_outstanding)
template<typename Tin , typename Tout , unsigned int counter_precision = 64>
void	perfCounterProc2Mem (hls::stream< Tin > &cmd, Tout *out, int direction, int burst_length, int nmbr_outstanding)
template<typename Tin , typename Tout , unsigned int counter_precision = 64>
void	perfCounterProc2MemCountOnly (hls::stream< Tin > &cmd, Tout *out)
	Count Clock Cycles between two events, the first event init the counter the second stop the count. More...
template<typename Tin , typename Tout , unsigned int counter_precision = 64>
void	perfCounterProc2MemCountIncremental (hls::stream< Tin > &cmd, Tout *out)
	Count Clock Cycles between two events, the first event init the counter the second stop the count and increment the out register TODO: seems not working at the csim lvl (never tested below) when executing single DUT step, hanging stream values. More...
template<typename Tin , typename Tout , unsigned int counter_precision = 64>
void	perfCounterMultipleCounts (hls::stream< Tin > &cmd, Tout *out)
	Count Clock Cycles between two events, the first event init the counter the second stop the count, a 0 after the init stop definitevely the counter. More...
template<typename Tevent = bool, const unsigned int counter_width = 32, const unsigned int maximum_counter_value_before_reset = 4000000>
void	pCountClockCycles (hls::stream< Tevent > &sOfEnableCCIncrement, hls::stream< Tevent > &sOfResetCounter, hls::stream< Tevent > &sOfGetTheCounter, hls::stream< ap_uint< counter_width > > &oSClockCounter)
	Count Clock Cycles between two events first sketch TODO: make it working without counting with the stream or reshaping as FSM. More...
template<typename Tin , typename Tout >
Tout	genNextFibonacciNumber (Tin curr, Tin prev)
template<typename ADDR_T , unsigned int sequenceDim, typename BIGWORD_T , typename SMALLWORD_T , unsigned int smallWordDim>
void	genFibonacciNumbers (ADDR_T curr, BIGWORD_T *outBigWord)
template<typename ADDR_T , unsigned int sequenceDim, typename BIGWORD_T , typename SMALLWORD_T , unsigned int smallWordDim>
void	genXoredSequentialNumbers (ADDR_T curr, BIGWORD_T *outBigWord)
template<typename ADDR_T , unsigned int sequenceDim, typename BIGWORD_T , typename SMALLWORD_T , unsigned int smallWordDim>
void	genXoredSequentialNumbersSecondVersion (ADDR_T curr, BIGWORD_T *outBigWord)
template<typename ADDR_T , typename BIGWORD_T >
void	genXoredNumbersSingleWord (ADDR_T curr, BIGWORD_T *outBigWord)
template<typename ADDR_T , typename BIGWORD_T >
void	genSequentialNumbers (ADDR_T curr, BIGWORD_T *outBigWord)
template<const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 16>
void	pWRGenerateData2WriteOnStream (hls::stream< local_mem_word_t > &sOutGeneratedData, ap_uint< 32 > *testCounter, local_mem_addr_t max_addr_ut)
	A function that generate a streams of data according to function and writes them on a stream CHECK: FAULT_INJECTION define insert after the third test some faults. More...
template<typename Tcntr , const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 64*2>
void	pWRStream2WriteMainMemory (hls::stream< Tcntr > &sOutCmd, hls::stream< local_mem_word_t > &sInGeneratedData, membus_t *lcl_mem, local_mem_addr_t max_addr_ut, unsigned int burst_size)
	A function that read a stream of data and write them in a run-time variable burst-size. More...
template<typename Tcntr , const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 64*2>
void	pWriteSimplerTestMemTest (hls::stream< Tcntr > &sOutCmd, membus_t *lcl_mem, local_mem_addr_t max_addr_ut, unsigned int burst_size)
	Simple version of a write memtest that write up to a given maximum address No control on the burst size or on the first faulty address. More...
template<typename Tcntr , const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 64*2>
void	pReadSimplerTestMemTest (hls::stream< Tcntr > &sOutCmd, membus_t *lcl_mem, local_mem_addr_t max_addr_ut, unsigned int burst_size, ap_uint< 32 > *faulty_addresses_cntr, local_mem_addr_t *first_faulty_address)
	Simple version of a read memtest that read up to a given maximum address No control on the burst size or on the first faulty address. More...
template<typename Tcntr , const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 64*2>
void	pRDRead2StreamDataVariableBurstNoMemCpy (hls::stream< Tcntr > &sOutCmd, hls::stream< local_mem_word_t > &sOutReadData, membus_t *lcl_mem, local_mem_addr_t max_addr_ut, unsigned int burst_size)
	Read a variable burst_size amount of data and output on a stream and count the cc needed just 4 transfer but without using memcpy. More...
template<const unsigned int max_iterations = 4000000>
void	pRDReadDataStreamAndProduceGold (hls::stream< local_mem_word_t > &sInReadData, local_mem_addr_t max_addr_ut, hls::stream< local_mem_word_t > &sOutReadData, hls::stream< local_mem_word_t > &sOutGoldData)
	Read a data stream and produce the gold expected value. More...
template<const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 16>
void	pRDCmpStreamsCntWordAligned (local_mem_addr_t max_addr_ut, hls::stream< local_mem_word_t > &sInReadData, hls::stream< local_mem_word_t > &sInGoldData, ap_uint< 32 > *faulty_addresses_cntr, local_mem_addr_t *first_faulty_address)
	Read two streams, compare them and output the number of faults and the first faulty address. More...
template<const unsigned int max_iterations = 4000000, const unsigned int unrolling_factor = ( 512 /8), const unsigned int buff_dim = 16>
void	pRDCompareDataStreamsCount (local_mem_addr_t max_addr_ut, hls::stream< local_mem_word_t > &sInReadData, hls::stream< local_mem_word_t > &sInGoldData, ap_uint< 32 > *faulty_addresses_cntr, local_mem_addr_t *first_faulty_address)
	Read two streams, compare them and output the number of faults and the first faulty address, but check every single byte NOT USED. More...
template<typename Tcntr , const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 64*2>
void	pRDMainMemoryRead2StreamData (hls::stream< Tcntr > &sOutCmd, hls::stream< local_mem_word_t > &sOutreadData, membus_t *lcl_mem, local_mem_addr_t max_addr_ut, unsigned int burst_size)
	Read a single word of data and output on a stream and count the cc needed just 4 transfer NOT USED. More...
template<typename Tcntr , const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 64*2>
void	pRDRead2StreamDataVariableBurst (hls::stream< Tcntr > &sOutCmd, hls::stream< local_mem_word_t > &sOutreadData, membus_t *lcl_mem, local_mem_addr_t max_addr_ut, unsigned int burst_size)
	Read a variable burst_size amount of data and output on a stream and count the cc needed just 4 transfer THIS FUNCTION SUFFER FIFO OVERFLOW 4 transfer different from power of 2 numbers NOT USED. More...
template<const unsigned int maximum_number_of_beats = 512>
void	pWriteDataflowMemTest (membus_t *lcl_mem0, local_mem_addr_t max_address_under_test, ap_uint< 64 > *writing_cntr, ap_uint< 32 > *testCounter, unsigned int burst_size)
template<const unsigned int maximum_number_of_beats = 512>
void	pReadDataflowMemTest (membus_t *lcl_mem1, local_mem_addr_t max_address_under_test, ap_uint< 64 > *reading_cntr, ap_uint< 32 > *faulty_addresses_cntr, local_mem_addr_t *first_faulty_address, unsigned int burst_size)
template<const unsigned int counter_width = 64>
void	pTHISProcessingData (stream< NetworkWord > &sRxpToProcp_Data, stream< NetworkWord > &sProcpToTxp_Data, stream< NetworkMetaStream > &sRxtoProc_Meta, stream< NetworkMetaStream > &sProctoTx_Meta, bool *start_stop)
	THIS processing the data once recieved a start command Template function for custom processing. More...

Variables
const unsigned long int	max_counter_cc = 4000000
const unsigned int	top_param_maximum_number_of_beats = 4096

Detailed Description

This is a subgroup of Memtest accelerated function with only synthesizable (HLS) functions/classes.

Macro Definition Documentation

CYCLES_UNTIL_TIMEOUT

#define CYCLES_UNTIL_TIMEOUT   0x0100

Definition at line 96 of file memtest.hpp.

Data_t_in

#define Data_t_in   ap_axiu<INPUT_PTR_WIDTH, 0, 0, 0>

Definition at line 29 of file memtest.cpp.

Data_t_out

#define Data_t_out   ap_axiu<OUTPUT_PTR_WIDTH, 0, 0, 0>

Definition at line 30 of file memtest.cpp.

DDR_LATENCY

#define DDR_LATENCY   52

Definition at line 98 of file memtest.hpp.

DEFAULT_RX_PORT

#define DEFAULT_RX_PORT   2718

Definition at line 83 of file memtest.hpp.

DEFAULT_TX_PORT

#define DEFAULT_TX_PORT   2718

Definition at line 82 of file memtest.hpp.

ENABLE_DDR

#define ENABLE_DDR

Definition at line 42 of file memtest.hpp.

EXTRA_DDR_LATENCY_DUE_II

#define EXTRA_DDR_LATENCY_DUE_II   (64 + 8)

Definition at line 99 of file memtest.hpp.

FAULT_INJECTION

#define FAULT_INJECTION

Definition at line 35 of file memtest_processing.hpp.

FSM_DONE

#define FSM_DONE   1

Definition at line 79 of file memtest.hpp.

FSM_PROCESSING_BURST_READING

#define FSM_PROCESSING_BURST_READING   4

Definition at line 42 of file memtest_processing.hpp.

FSM_PROCESSING_CONTINUOUS_RUN

#define FSM_PROCESSING_CONTINUOUS_RUN   12

Definition at line 50 of file memtest_processing.hpp.

FSM_PROCESSING_DATAFLOW_READ

#define FSM_PROCESSING_DATAFLOW_READ   6

Definition at line 44 of file memtest_processing.hpp.

FSM_PROCESSING_DATAFLOW_WRITE

#define FSM_PROCESSING_DATAFLOW_WRITE   5

Definition at line 43 of file memtest_processing.hpp.

FSM_PROCESSING_OUTPUT

#define FSM_PROCESSING_OUTPUT   7

Definition at line 45 of file memtest_processing.hpp.

FSM_PROCESSING_OUTPUT_2

#define FSM_PROCESSING_OUTPUT_2   8

Definition at line 46 of file memtest_processing.hpp.

FSM_PROCESSING_OUTPUT_3

#define FSM_PROCESSING_OUTPUT_3   9

Definition at line 47 of file memtest_processing.hpp.

FSM_PROCESSING_OUTPUT_4

#define FSM_PROCESSING_OUTPUT_4   10

Definition at line 48 of file memtest_processing.hpp.

FSM_PROCESSING_OUTPUT_5

#define FSM_PROCESSING_OUTPUT_5   11

Definition at line 49 of file memtest_processing.hpp.

FSM_PROCESSING_PCKT_PROC

#define FSM_PROCESSING_PCKT_PROC   1

Definition at line 39 of file memtest_processing.hpp.

FSM_PROCESSING_START

#define FSM_PROCESSING_START   3

Definition at line 41 of file memtest_processing.hpp.

FSM_PROCESSING_STOP

#define FSM_PROCESSING_STOP   2

Definition at line 40 of file memtest_processing.hpp.

FSM_PROCESSING_WAIT_FOR_DDR_CONTROLLER_EMPTYNESS

#define FSM_PROCESSING_WAIT_FOR_DDR_CONTROLLER_EMPTYNESS   13

Definition at line 51 of file memtest_processing.hpp.

FSM_PROCESSING_WAIT_FOR_META

#define FSM_PROCESSING_WAIT_FOR_META   0

Definition at line 38 of file memtest_processing.hpp.

FSM_WRITE_NEW_DATA

#define FSM_WRITE_NEW_DATA   0

Definition at line 78 of file memtest.hpp.

LOCAL_MEM_ADDR_OFFSET

#define LOCAL_MEM_ADDR_OFFSET   (LOCAL_MEM_WORD_SIZE/8)

Definition at line 48 of file memtest_pattern_library.hpp.

LOCAL_MEM_ADDR_SIZE

#define LOCAL_MEM_ADDR_SIZE   40

Definition at line 42 of file memtest_pattern_library.hpp.

LOCAL_MEM_ADDR_SIZE_NON_BYTE_ADDRESSABLE

#define LOCAL_MEM_ADDR_SIZE_NON_BYTE_ADDRESSABLE   40

Definition at line 46 of file memtest_pattern_library.hpp.

LOCAL_MEM_WORD_BYTE_SIZE

#define LOCAL_MEM_WORD_BYTE_SIZE   (LOCAL_MEM_WORD_SIZE/8)

Definition at line 49 of file memtest_pattern_library.hpp.

LOCAL_MEM_WORD_SIZE

#define LOCAL_MEM_WORD_SIZE   512

Definition at line 41 of file memtest_pattern_library.hpp.

MEMDW_512

#define MEMDW_512   512

Definition at line 90 of file memtest.hpp.

MEMTEST_ADDRESS_BITWIDTH

#define MEMTEST_ADDRESS_BITWIDTH   40

Definition at line 56 of file memtest_processing.hpp.

MEMTEST_ADDRESS_HIGH_BIT

#define MEMTEST_ADDRESS_HIGH_BIT   NETWORK_WORD_BIT_WIDTH-1

Definition at line 60 of file memtest_processing.hpp.

MEMTEST_ADDRESS_LOW_BIT

#define MEMTEST_ADDRESS_LOW_BIT   NETWORK_WORD_BIT_WIDTH-MEMTEST_ADDRESS_BITWIDTH

Definition at line 61 of file memtest_processing.hpp.

MEMTEST_BURST_BITWIDTH

#define MEMTEST_BURST_BITWIDTH   16

Definition at line 58 of file memtest_processing.hpp.

MEMTEST_BURST_HIGH_BIT

#define MEMTEST_BURST_HIGH_BIT   MEMTEST_BURST_BITWIDTH-1+MEMTEST_COMMANDS_BITWIDTH

Definition at line 66 of file memtest_processing.hpp.

MEMTEST_BURST_LOW_BIT

#define MEMTEST_BURST_LOW_BIT   MEMTEST_BURST_HIGH_BIT+1-MEMTEST_BURST_BITWIDTH

Definition at line 67 of file memtest_processing.hpp.

MEMTEST_COMMANDS_BITWIDTH

#define MEMTEST_COMMANDS_BITWIDTH   8

Definition at line 69 of file memtest.hpp.

MEMTEST_COMMANDS_HIGH_BIT

#define MEMTEST_COMMANDS_HIGH_BIT   MEMTEST_COMMANDS_BITWIDTH-1

Definition at line 67 of file memtest.hpp.

MEMTEST_COMMANDS_LOW_BIT

#define MEMTEST_COMMANDS_LOW_BIT   0

Definition at line 68 of file memtest.hpp.

MEMTEST_ITERATION_BITWIDTH

#define MEMTEST_ITERATION_BITWIDTH   16

Definition at line 57 of file memtest_processing.hpp.

MEMTEST_ITERATIONS_HIGH_BIT

#define MEMTEST_ITERATIONS_HIGH_BIT   MEMTEST_ADDRESS_LOW_BIT-1

Definition at line 63 of file memtest_processing.hpp.

MEMTEST_ITERATIONS_LOW_BIT

#define MEMTEST_ITERATIONS_LOW_BIT   MEMTEST_ITERATIONS_HIGH_BIT+1-MEMTEST_ITERATION_BITWIDTH

Definition at line 64 of file memtest_processing.hpp.

MEMTEST_RETURN_RESULTS

#define MEMTEST_RETURN_RESULTS   3

Definition at line 74 of file memtest.hpp.

PacketFsmType

#define PacketFsmType   uint8_t

Definition at line 76 of file memtest.hpp.

PortFsmType

#define PortFsmType   uint8_t

Definition at line 80 of file memtest.hpp.

PROCESSING_PACKET

#define PROCESSING_PACKET   2

Definition at line 73 of file memtest.hpp.

ProcessingFsmType

#define ProcessingFsmType   uint8_t

Definition at line 52 of file memtest_processing.hpp.

ROLE_IS_MEMTEST

#define ROLE_IS_MEMTEST

Definition at line 44 of file memtest.hpp.

TOTMEMDW_512

#define TOTMEMDW_512   16384

Definition at line 93 of file memtest.hpp.

TYPICAL_DDR_LATENCY

#define TYPICAL_DDR_LATENCY   4

Definition at line 97 of file memtest.hpp.

WAIT_FOR_META

#define WAIT_FOR_META   0

Definition at line 71 of file memtest.hpp.

WAIT_FOR_STREAM_PAIR

#define WAIT_FOR_STREAM_PAIR   1

Definition at line 72 of file memtest.hpp.

Typedef Documentation

local_mem_addr_non_byteaddressable_t

typedef ap_uint< 40 > local_mem_addr_non_byteaddressable_t

Definition at line 47 of file memtest_pattern_library.hpp.

local_mem_addr_t

typedef ap_uint< 40 > local_mem_addr_t

Definition at line 45 of file memtest_pattern_library.hpp.

local_mem_word_t

typedef ap_uint< 512 > local_mem_word_t

Definition at line 44 of file memtest_pattern_library.hpp.

membus_512_t

typedef ap_uint< 512 > membus_512_t

Definition at line 91 of file memtest.hpp.

membus_t

typedef membus_512_t membus_t

Definition at line 92 of file memtest.hpp.

Enumeration Type Documentation

EchoCtrl

enum EchoCtrl

SHELL/MMIO/EchoCtrl - Config Register

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

Definition at line 49 of file memtest.hpp.

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

MemTestCmd

enum MemTestCmd

Internal MemTest accelerator command

Enumerator
TEST_BURSTSIZE_CMD
TEST_ENDOFTESTS_CMD
TEST_STOP_CMD
TEST_START_CMD
TEST_INVLD_CMD
WRPTX_IMG_CMD
WRPTX_TXMAT_CMD
WRPTX_INVLD_CMD

Definition at line 58 of file memtest.hpp.

                {
    TEST_BURSTSIZE_CMD  = 4,
    TEST_ENDOFTESTS_CMD  = 3,
    TEST_STOP_CMD  = 2,
    TEST_START_CMD = 1,
    TEST_INVLD_CMD = 0
};

Function Documentation

genFibonacciNumbers()

template<typename ADDR_T , unsigned int sequenceDim, typename BIGWORD_T , typename SMALLWORD_T , unsigned int smallWordDim>

void genFibonacciNumbers	(	ADDR_T	curr,
		BIGWORD_T *	outBigWord
	)

Definition at line 65 of file memtest_pattern_library.hpp.

                                                             {
//#pragma HLS INLINE off
 
// REQUIREMENT: must be a multiple
  //assert( (BIGWORD_T%SMALLWORD_T)==0);
 
  SMALLWORD_T currentFibonacciNumber = static_cast<SMALLWORD_T>(curr);
  SMALLWORD_T prevFibonacciNumber = currentFibonacciNumber + 1;
  SMALLWORD_T nextFibonacciNumber = genNextFibonacciNumber<ADDR_T,SMALLWORD_T>(currentFibonacciNumber,prevFibonacciNumber);
 
  gen_sequence_loop: for (unsigned int i = 0; i < sequenceDim; i++)
  {
#pragma HLS PIPELINE
    (*outBigWord).range(smallWordDim*(i+1)-1,smallWordDim*i)=nextFibonacciNumber;
    prevFibonacciNumber=currentFibonacciNumber;
    currentFibonacciNumber=nextFibonacciNumber;
    nextFibonacciNumber=genNextFibonacciNumber<ADDR_T,SMALLWORD_T>(currentFibonacciNumber,prevFibonacciNumber);
  }
  
 
}

genNextFibonacciNumber()

template<typename Tin , typename Tout >

Tout genNextFibonacciNumber	(	Tin	curr,
		Tin	prev
	)

Functions for generating (pseudo)random sequences or for pattern generation

Definition at line 59 of file memtest_pattern_library.hpp.

                                               {
#pragma HLS INLINE
  return static_cast<Tout>(curr + prev);
}

genSequentialNumbers()

template<typename ADDR_T , typename BIGWORD_T >

void genSequentialNumbers	(	ADDR_T	curr,
		BIGWORD_T *	outBigWord
	)

Definition at line 139 of file memtest_pattern_library.hpp.

                                                              {
#pragma HLS INLINE 
  *outBigWord = curr+1;
}

genXoredNumbersSingleWord()

template<typename ADDR_T , typename BIGWORD_T >

void genXoredNumbersSingleWord	(	ADDR_T	curr,
		BIGWORD_T *	outBigWord
	)

Definition at line 130 of file memtest_pattern_library.hpp.

                                                                   {
#pragma HLS INLINE 
  BIGWORD_T currentNumber = static_cast<BIGWORD_T>(curr);
  BIGWORD_T nextNumber = (currentNumber+1) xor 1;
  *outBigWord=nextNumber;
}

Here is the caller graph for this function:

genXoredSequentialNumbers()

template<typename ADDR_T , unsigned int sequenceDim, typename BIGWORD_T , typename SMALLWORD_T , unsigned int smallWordDim>

void genXoredSequentialNumbers	(	ADDR_T	curr,
		BIGWORD_T *	outBigWord
	)

Definition at line 89 of file memtest_pattern_library.hpp.

                                                                   {
#pragma HLS INLINE off
 
// REQUIREMENT: must be a multiple
  //assert( (BIGWORD_T%SMALLWORD_T)==0);
 
  SMALLWORD_T currentNumber = static_cast<SMALLWORD_T>(curr);
  SMALLWORD_T nextNumber = (currentNumber+1) xor 1;
  SMALLWORD_T prevNumber = currentNumber;
 
  gen_sequence_loop: for (unsigned int i = 0; i < sequenceDim; i++)
  {
#pragma HLS PIPELINE
    (*outBigWord).range(smallWordDim*(i+1)-1,smallWordDim*i)=nextNumber;
    prevNumber = currentNumber;
    currentNumber = nextNumber;
    nextNumber = (nextNumber + 1 ) xor i;
  }
}

genXoredSequentialNumbersSecondVersion()

template<typename ADDR_T , unsigned int sequenceDim, typename BIGWORD_T , typename SMALLWORD_T , unsigned int smallWordDim>

void genXoredSequentialNumbersSecondVersion	(	ADDR_T	curr,
		BIGWORD_T *	outBigWord
	)

Definition at line 111 of file memtest_pattern_library.hpp.

                                                                                {
#pragma HLS INLINE 
// REQUIREMENT: must be a multiple
  //assert( (BIGWORD_T%SMALLWORD_T)==0);
  SMALLWORD_T currentNumber = static_cast<SMALLWORD_T>(curr);
  SMALLWORD_T nextNumber = (currentNumber+1) xor 1;
  SMALLWORD_T prevNumber = currentNumber;
 
  gen_sequence_loop: for (unsigned int i = 0; i < sequenceDim; i++)
  {
#pragma HLS UNROLL
    (*outBigWord).range(smallWordDim*(i+1)-1,smallWordDim*i)=nextNumber;
    prevNumber = currentNumber;
    currentNumber = nextNumber;
    nextNumber = (nextNumber + 1 ) xor i;
  }
}

memtest()

void memtest	(	ap_uint< 32 > *	pi_rank,
		ap_uint< 32 > *	pi_size,
		stream< NetworkWord > &	siSHL_This_Data,
		stream< NetworkWord > &	soTHIS_Shl_Data,
		stream< NetworkMetaStream > &	siNrc_meta,
		stream< NetworkMetaStream > &	soNrc_meta,
		ap_uint< 32 > *	po_rx_ports,
		membus_t *	lcl_mem0,
		membus_t *	lcl_mem1
	)

Main process of the Memtest Application directives.

Deprecated:

This functions is using deprecated AXI stream interface

Returns

Nothing.

Definition at line 39 of file memtest.cpp.

{
  //-- DIRECTIVES FOR THE BLOCK ---------------------------------------------
 //#pragma HLS INTERFACE ap_ctrl_none port=return
 
  //#pragma HLS INTERFACE ap_stable     port=piSHL_This_MmioEchoCtrl
 
#pragma HLS INTERFACE axis register both port=siSHL_This_Data
#pragma HLS INTERFACE axis register both port=soTHIS_Shl_Data
 
#pragma HLS INTERFACE axis register both port=siNrc_meta
#pragma HLS INTERFACE axis register both port=soNrc_meta
 
#pragma HLS INTERFACE ap_ovld register port=po_rx_ports name=poROL_NRC_Rx_ports
#pragma HLS INTERFACE ap_stable register port=pi_rank name=piFMC_ROL_rank
#pragma HLS INTERFACE ap_stable register port=pi_size name=piFMC_ROL_size
 
 
#ifdef ENABLE_DDR
    
const unsigned int ddr_mem_depth = TOTMEMDW_512;//*2;
const unsigned int ddr_latency = DDR_LATENCY;
const unsigned int num_outstanding_transactions = 256;//16;
const unsigned int MAX_BURST_LENGTH_512=64;//Theoretically is  64, 64*512bit = 4096KBytes;
 
// Mapping LCL_MEM0 interface to moMEM_Mp1 channel
#pragma HLS INTERFACE m_axi depth=ddr_mem_depth port=lcl_mem0 bundle=moMEM_Mp1\
  max_read_burst_length=MAX_BURST_LENGTH_512  max_write_burst_length=MAX_BURST_LENGTH_512 offset=direct \
  num_read_outstanding=num_outstanding_transactions num_write_outstanding=num_outstanding_transactions latency=ddr_latency
 
// Mapping LCL_MEM1 interface to moMEM_Mp1 channel
#pragma HLS INTERFACE m_axi depth=ddr_mem_depth port=lcl_mem1 bundle=moMEM_Mp1 \
  max_read_burst_length=MAX_BURST_LENGTH_512  max_write_burst_length=MAX_BURST_LENGTH_512 offset=direct \
  num_read_outstanding=num_outstanding_transactions num_write_outstanding=num_outstanding_transactions latency=ddr_latency
 
#endif
 
  //-- LOCAL VARIABLES ------------------------------------------------------
  NetworkMetaStream  meta_tmp = NetworkMetaStream();
  static stream<NetworkMetaStream> sRxtoProc_Meta("sRxtoProc_Meta");
  static stream<NetworkMetaStream> sProctoTx_Meta("sProctoTx_Meta");
  static stream<NetworkWord>       sProcpToTxp_Data("sProcpToTxp_Data"); 
 #pragma HLS STREAM variable=sProcpToTxp_Data depth=20 dim=1
  static stream<NetworkWord>       sRxpToProcp_Data("sRxpToProcp_Data");
 
  static unsigned int processed_word_rx;
  static unsigned int processed_bytes_rx;
  static unsigned int processed_word_tx;
  //*po_rx_ports = 0x1; //currently work only with default ports...
  static stream<NodeId>            sDstNode_sig   ("sDstNode_sig");
  bool                              start_stop;
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS DATAFLOW
#pragma HLS reset variable=processed_word_rx
#pragma HLS reset variable=processed_word_tx
 
  
//STEP 0: setup the port and the dst of the cluster
// CHANGE THE CLUSTER CONNECTIONS HERE
 pPortAndDestionation(
  pi_rank,
  pi_size, 
  sDstNode_sig,
  po_rx_ports);
 
//STEP 1: received the input data, small parse on 
// the command and fwd to the following step
// CHANGE THE COMMAND PARSING HERE
 pRXPath(
  siSHL_This_Data,
  siNrc_meta,
  sRxtoProc_Meta,
  sRxpToProcp_Data,
  meta_tmp,
  &start_stop,
  &processed_word_rx,
  &processed_bytes_rx);
 
//STEP 2: processing the data. 
// INSERT THE CUSTOM PROCESSING LOGIC HERE
 pTHISProcessingData<64>(
  sRxpToProcp_Data,
  sProcpToTxp_Data,
  sRxtoProc_Meta,
  sProctoTx_Meta,
  &start_stop
  #ifdef ENABLE_DDR
              ,
    lcl_mem0,
    lcl_mem1
  #endif
  );
 
// STEP 3: transmit back the data
// currently steup the tlast once reached max size
// WARNING: it needs a new meta if filled up the MTU
  pTXPath(
  soTHIS_Shl_Data,
  soNrc_meta,
  sProcpToTxp_Data,
  sProctoTx_Meta,
  sDstNode_sig,
  &processed_word_tx,
  pi_rank);
 
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

pCountClockCycles()

template<typename Tevent = bool, const unsigned int counter_width = 32, const unsigned int maximum_counter_value_before_reset = 4000000>

void pCountClockCycles	(	hls::stream< Tevent > &	sOfEnableCCIncrement,
		hls::stream< Tevent > &	sOfResetCounter,
		hls::stream< Tevent > &	sOfGetTheCounter,
		hls::stream< ap_uint< counter_width > > &	oSClockCounter
	)

Count Clock Cycles between two events first sketch TODO: make it working without counting with the stream or reshaping as FSM.

Parameters

[in]	sOfEnableCCIncrement
[in]	sOfResetCounter
[in]	sOfGetTheCounter
[in]	oSClockCounter
[in]	Tevent	the event datatype
[in]	counter_width	the counter precision
[in]	maximum_counter_value_before_reset	the maxmimum amount of cc count before auto reset

Returns

Nothing.

Definition at line 730 of file memtest_library.hpp.

{
 
  static ap_uint<counter_width> internal_counter = 0;
  static bool pop_the_counter = false;
#pragma HLS reset variable=internal_counter
#pragma HLS reset variable=pop_the_counter
//giving priority to the pop
  if(!sOfGetTheCounter.empty()){
    pop_the_counter = sOfGetTheCounter.read();
  }
  if (pop_the_counter && !oSClockCounter.full())
  {
    oSClockCounter.write(internal_counter);
    pop_the_counter=false;
  }
  if(!sOfResetCounter.empty()){
    bool reset_or_not = sOfResetCounter.read();
    if (reset_or_not)
    {
      internal_counter = 0;
    }
  }
  if(!sOfEnableCCIncrement.empty()){
    bool increment = sOfEnableCCIncrement.read();
    if (increment)
    {
      if(internal_counter==maximum_counter_value_before_reset){
        internal_counter=1;
      }else{
        internal_counter++;
      }
#if DEBUG_LEVEL == TRACE_ALL
#ifndef __SYNTHESIS__
  printf("DEBUG pCountClockCycles counter value = %s\n", internal_counter.to_string().c_str());
#endif //__SYNTHESIS__
#endif      
    }
  }
}

perfCounterMultipleCounts()

template<typename Tin , typename Tout , unsigned int counter_precision = 64>

void perfCounterMultipleCounts	(	hls::stream< Tin > &	cmd,
		Tout *	out
	)

Count Clock Cycles between two events, the first event init the counter the second stop the count, a 0 after the init stop definitevely the counter.

Parameters

[in]	cmd	the performance counter cmd stream, first is init second stop(0)/continue(everything else)
[out]	out	the output register of where store the incremental counter value
[in]	Tin	the input datatype
[in]	Tout	the output datatype
[in]	counter_precision	the maxmimum amount of data

Returns

Nothing.

Definition at line 683 of file memtest_library.hpp.

                                                                {
  #pragma HLS interface ap_ctrl_none port=return
    Tin input_cmd=1;
 
    // wait to receive a value to start counting
    ap_uint<counter_precision> cnt = cmd.read();
    reset:
    while (input_cmd != 0)//a zero will stop the counter
    {
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_counter_cc
#if DEBUG_LEVEL == TRACE_ALL
 #ifndef __SYNTHESIS__
  //printf("DEBUG begin to count :D input_cmd value = %s\n", input_cmd.to_string().c_str());
#endif //__SYNTHESIS__
#endif     
// keep counting until a value is available
count:
    while (cmd.read_nb(input_cmd) == false) {
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_counter_cc
#pragma HLS PIPELINE II=1
        cnt++;       
#if DEBUG_LEVEL == TRACE_ALL
 #ifndef __SYNTHESIS__
 // printf("DEBUG perfCounterProc counter value = %s\n", cnt.to_string().c_str());
#endif //__SYNTHESIS__
#endif     
    }
    input_cmd=cmd.read();
  }
  *out +=cnt;
}

perfCounterProc()

template<typename Tin , typename Tout , unsigned int counter_precision = 64>

void perfCounterProc	(	hls::stream< Tin > &	cmd,
		hls::stream< Tout > &	out,
		int	direction,
		int	burst_length,
		int	nmbr_outstanding
	)

Definition at line 546 of file memtest_library.hpp.

{
#pragma HLS INLINE off
 
    Tin input_cmd;
    // wait to receive a value to start counting
    ap_uint<counter_precision> cnt = cmd.read();
// keep counting until a value is available
count:
    while (cmd.read_nb(input_cmd) == false) {
        cnt++;
        #if DEBUG_LEVEL == TRACE_ALL
#ifndef __SYNTHESIS__
  printf("DEBUG perfCounterProc counter value = %s\n", cnt.to_string().c_str());
#endif //__SYNTHESIS__
#endif     
    }
 
    // // write out kernel statistics to global memory
     Tout tmp[1];//was 4
     tmp[0] = cnt;
    // tmp[1] = input_cmd;
     //tmp[1] = burst_length;
    // tmp[3] = nmbr_outstanding;
    //memcpy(out, tmp, 4 * sizeof(Tout));
    out.write(tmp[0]);
    //out.write(tmp[1]);
    //out.write(nmbr_outstanding); this
    //out.write(input_cmd); Xilinx use this to count the errors but we are already counting so...
}

perfCounterProc2Mem()

template<typename Tin , typename Tout , unsigned int counter_precision = 64>

void perfCounterProc2Mem	(	hls::stream< Tin > &	cmd,
		Tout *	out,
		int	direction,
		int	burst_length,
		int	nmbr_outstanding
	)

Definition at line 581 of file memtest_library.hpp.

                                                                                                                 {
  
    Tin input_cmd;
    // wait to receive a value to start counting
    ap_uint<counter_precision> cnt = cmd.read();
// keep counting until a value is available
count:
    while (cmd.read_nb(input_cmd) == false) {
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_counter_cc
        cnt++;
 
#if DEBUG_LEVEL == TRACE_ALL
#ifndef __SYNTHESIS__
  printf("DEBUG perfCounterProc counter value = %s\n", cnt.to_string().c_str());
#endif //__SYNTHESIS__
#endif     
    }
    *out =cnt;
}

perfCounterProc2MemCountIncremental()

template<typename Tin , typename Tout , unsigned int counter_precision = 64>

void perfCounterProc2MemCountIncremental	(	hls::stream< Tin > &	cmd,
		Tout *	out
	)

Count Clock Cycles between two events, the first event init the counter the second stop the count and increment the out register TODO: seems not working at the csim lvl (never tested below) when executing single DUT step, hanging stream values.

Parameters

[in]	cmd	the performance counter cmd stream, first is init second stop
[out]	out	the output register of where increment the counter value
[in]	Tin	the input datatype
[in]	Tout	the output datatype
[in]	counter_precision	the maxmimum amount of data

Returns

Nothing.

Definition at line 651 of file memtest_library.hpp.

                                                                          {
  
    Tin input_cmd;
    // wait to receive a value to start counting
    ap_uint<counter_precision> cnt = cmd.read();
// keep counting until a value is available
count:
    while (cmd.read_nb(input_cmd) == false) {
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_counter_cc
        cnt++;
#if DEBUG_LEVEL == TRACE_ALL
#ifndef __SYNTHESIS__
  printf("DEBUG perfCounterProc counter value = %s\n", cnt.to_string().c_str());
#endif //__SYNTHESIS__
#endif     
    }
    *out +=cnt;
}

perfCounterProc2MemCountOnly()

template<typename Tin , typename Tout , unsigned int counter_precision = 64>

void perfCounterProc2MemCountOnly	(	hls::stream< Tin > &	cmd,
		Tout *	out
	)

Count Clock Cycles between two events, the first event init the counter the second stop the count.

Parameters

[in]	cmd	the performance counter cmd stream, first is init second stop
[out]	out	the output register of where store the counter value
[in]	Tin	the input datatype
[in]	Tout	the output datatype
[in]	counter_precision	the maxmimum amount of data

Returns

Nothing.

Definition at line 615 of file memtest_library.hpp.

                                                                   {
  
    Tin input_cmd;
    // wait to receive a value to start counting
    ap_uint<counter_precision> cnt = cmd.read();
// keep counting until a value is available
count:
    while (cmd.read_nb(input_cmd) == false) {
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_counter_cc
        cnt++;
 
#if DEBUG_LEVEL == TRACE_ALL
#ifndef __SYNTHESIS__
  printf("DEBUG perfCounterProc counter value = %s\n", cnt.to_string().c_str());
#endif //__SYNTHESIS__
#endif     
    }
    *out =cnt;
}

pMemCpyCircularBuff()

template<typename Tin , typename Tout , const unsigned int arraysize>

void pMemCpyCircularBuff	(	Tin *	buff,
		Tout *	out_mem,
		unsigned int	elems,
		unsigned int	offset_buff
	)

Copy a run-time variable amount of data to another array employing the src as circular buffer i.e., handling overflow.

Parameters

[out]	out_mem	the dst ptr
[in]	buff	the src ptr, or the circular buffer
[in]	elems	the current amount of data to tx
[in]	offset_buff	the initial offest in the circular buffer
[in]	Tin	the input datatype
[in]	Tout	the output datatype
[in]	arraysize	the maxmimum amount of data

Returns

Nothing.

Definition at line 398 of file memtest_library.hpp.

                                                                                               {
#pragma HLS INLINE
  unsigned int j = 0;
  circ_buff_loop: for (unsigned int i = 0; i < elems; i++)
  {
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = arraysize
    if(offset_buff+j==arraysize)//
    { 
      offset_buff=0;
      j=1;
      out_mem[i] = buff[0];
    }else{
      out_mem[i] = buff[offset_buff+j];
      j++;
    }
  }
  
}

pMyMemtestMemCpy()

template<typename Tin , typename Tout , unsigned int arraysize>

void pMyMemtestMemCpy	(	Tin *	in,
		Tout *	out
	)

Copy a fixed compile time amount of data to another array.

Parameters

[out]	out	the dst ptr
[in]	in	the src ptr
[in]	Tin	the input datatype
[in]	Tout	the output datatype
[in]	arraysize	the fixed amount of data

Returns

Nothing.

Definition at line 373 of file memtest_library.hpp.

                                         {
#pragma HLS INLINE
  for (unsigned int i = 0; i < arraysize; i++)
  {
#pragma HLS PIPELINE II=1
    *out = *in;
  }
  
}

pPortAndDestionation()

void pPortAndDestionation	(	ap_uint< 32 > *	pi_rank,
		ap_uint< 32 > *	pi_size,
		stream< NodeId > &	sDstNode_sig,
		ap_uint< 32 > *	po_rx_ports
	)

pPortAndDestionation - Setup the port and the destination rank.

Parameters

[in]	pi_rank
[in]	pi_size
[out]	sDstNode_sig
[out]	po_rx_ports

Returns

Nothing.

Definition at line 71 of file memtest_library.hpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
  //-- STATIC VARIABLES (with RESET) ------------------------------------------
  static PortFsmType port_fsm = FSM_WRITE_NEW_DATA;
#pragma HLS reset variable=port_fsm
 
  switch(port_fsm)
  {
    default:
    case FSM_WRITE_NEW_DATA:
        //Triangle app needs to be reset to process new rank
        if(!sDstNode_sig.full())
        {
          NodeId dst_rank = (*pi_rank + 1) % *pi_size;
    #if DEBUG_LEVEL == TRACE_ALL
          printf("rank: %d; size: %d; \n", (int) *pi_rank, (int) *pi_size);
    #endif
          sDstNode_sig.write(dst_rank);
          *po_rx_ports = 0x0; //init the value
          port_fsm = FSM_DONE;
        }
        break;
    case FSM_DONE:
        *po_rx_ports = 0x1; //currently work only with default ports...
        break;
  }
 
}

Here is the caller graph for this function:

pRDCmpStreamsCntWordAligned()

template<const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 16>

void pRDCmpStreamsCntWordAligned	(	local_mem_addr_t	max_addr_ut,
		hls::stream< local_mem_word_t > &	sInReadData,
		hls::stream< local_mem_word_t > &	sInGoldData,
		ap_uint< 32 > *	faulty_addresses_cntr,
		local_mem_addr_t *	first_faulty_address
	)

Read two streams, compare them and output the number of faults and the first faulty address.

Parameters

[in]	max_addr_ut	the maximum address to test
[in]	sInReadData	the read data stream
[in]	sInGoldData	the gold data stream
[out]	faulty_addresses_cntr	the fault cntr ptr
[out]	first_faulty_address	the first fault address ptr

Returns

Nothing.

Definition at line 601 of file memtest_pattern_library.hpp.

{
#pragma HLS INLINE off
#pragma HLS interface ap_ctrl_none port=return
    local_mem_addr_t curr_address_ut;
    static local_mem_word_t testingVector[buff_dim];
    static local_mem_word_t goldenVector[buff_dim];
    local_mem_addr_non_byteaddressable_t maddr_non_byte=0;
    static bool cmp_ok [buff_dim];
    static ap_uint<32> faulty_addresses_cntr_support_array [buff_dim];
 
    static bool first_fault_found  = false;
    static ap_uint<32> faulty_addresses_cntr_local;
 
      reading_loop:
  for (curr_address_ut = 0, faulty_addresses_cntr_local=0; curr_address_ut < max_addr_ut; curr_address_ut++)
  {
#pragma HLS PIPELINE
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_iterations
#pragma HLS dependence variable=faulty_addresses_cntr_support_array inter RAW distance=buff_dim true
 
    if (!sInReadData.empty() && !sInGoldData.empty())
    {
      testingVector[maddr_non_byte%buff_dim] = sInReadData.read(); 
      goldenVector[maddr_non_byte%buff_dim] = sInGoldData.read(); 
 
      int idx=maddr_non_byte%buff_dim;
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
          std::cout << maddr_non_byte << " tst=" << testingVector[idx] << " vs gld=" << goldenVector[idx] << std::endl;
      #endif
      #endif
      bool cmp_results = testingVector[idx] == goldenVector[idx];
      cmp_ok[idx]=cmp_results;
      if(!cmp_results ){
        faulty_addresses_cntr_support_array[idx]++;
        if (!first_fault_found)
        {
          *first_faulty_address=curr_address_ut*64;
          first_fault_found = true;
        }else{
          first_fault_found = first_fault_found;
        }
      }
 
        maddr_non_byte++;
    }else{
      curr_address_ut--;
    }
  }
 // std::cout << std::endl;
 
  for (int i = 0; i < buff_dim; i++)
  {
#pragma HLS PIPELINE
    faulty_addresses_cntr_local += faulty_addresses_cntr_support_array[i];
    faulty_addresses_cntr_support_array[i]=0;
  }
  
  first_fault_found=false;
*faulty_addresses_cntr=faulty_addresses_cntr_local;
 
}

pRDCompareDataStreamsCount()

template<const unsigned int max_iterations = 4000000, const unsigned int unrolling_factor = ( 512 /8), const unsigned int buff_dim = 16>

void pRDCompareDataStreamsCount	(	local_mem_addr_t	max_addr_ut,
		hls::stream< local_mem_word_t > &	sInReadData,
		hls::stream< local_mem_word_t > &	sInGoldData,
		ap_uint< 32 > *	faulty_addresses_cntr,
		local_mem_addr_t *	first_faulty_address
	)

Read two streams, compare them and output the number of faults and the first faulty address, but check every single byte NOT USED.

Deprecated:

Parameters

[in]	max_addr_ut	the maximum address to test
[in]	sInReadData	the read data stream
[in]	sInGoldData	the gold data stream
[out]	faulty_addresses_cntr	the fault cntr ptr
[out]	first_faulty_address	the first fault address ptr

Returns

Nothing.

Definition at line 688 of file memtest_pattern_library.hpp.

{
//#pragma HLS INLINE off
    const unsigned int dble_wrd_dim =  LOCAL_MEM_ADDR_OFFSET * 2;
    const unsigned int support_dim  =  LOCAL_MEM_ADDR_OFFSET  * 2;
 
 
    local_mem_addr_t curr_address_ut;
    static local_mem_word_t testingVector[buff_dim];
    static local_mem_word_t goldenVector[buff_dim];
    local_mem_addr_non_byteaddressable_t maddr_non_byte=0;
 
 
    static ap_uint<8> testingVector_bytes [support_dim];
    static ap_uint<8> goldenVector_bytes [support_dim];
    static bool cmp_ok [support_dim];
    static ap_uint<32> faulty_addresses_cntr_support_array [support_dim];
 
#pragma HLS array_partition variable=faulty_addresses_cntr_support_array cyclic factor=2 dim=1
#pragma HLS array_partition variable=testingVector_bytes cyclic factor=2 dim=1
#pragma HLS array_partition variable=goldenVector_bytes cyclic factor=2 dim=1
#pragma HLS array_partition variable=cmp_ok cyclic factor=2 dim=1
 
    static bool first_fault_found  = false;
    static ap_uint<32> faulty_addresses_cntr_local;
 
    ap_uint<1> k;
      reading_loop:
  for (curr_address_ut = 0, k=0, faulty_addresses_cntr_local=0; curr_address_ut < max_addr_ut; k++, curr_address_ut++)
  {
#pragma HLS PIPELINE
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_iterations
    if (!sInReadData.empty() && !sInGoldData.empty())
    {
      testingVector[maddr_non_byte%buff_dim] = sInReadData.read(); 
      goldenVector[maddr_non_byte%buff_dim] = sInGoldData.read(); 
          golden_comparison: for (int i = 0; i < LOCAL_MEM_ADDR_OFFSET; i++)
       {
    //#pragma HLS UNROLL factor=unrolling_factor skip_exit_check
            int idx = (i + k*LOCAL_MEM_ADDR_OFFSET);
            testingVector_bytes[idx]=testingVector[maddr_non_byte%buff_dim].range((i+1)*8-1,i*8);
            goldenVector_bytes[idx]=goldenVector[maddr_non_byte%buff_dim].range((i+1)*8-1,i*8);
        #if DEBUG_LEVEL == TRACE_ALL
        #ifndef __SYNTHESIS__
            std::cout << " tst=" << testingVector_bytes[idx] << " vs gld=" << goldenVector_bytes[idx] ;
        #endif
        #endif
 
          cmp_ok[idx] = testingVector_bytes[idx] == goldenVector_bytes[idx];
          if(!cmp_ok[idx] ){
            faulty_addresses_cntr_support_array[i+k]++;
            if (!first_fault_found)
            {
              *first_faulty_address=i+curr_address_ut*64;
              first_fault_found = true;
            }else{
              first_fault_found = first_fault_found;
            }
          }
       }
        #if DEBUG_LEVEL == TRACE_ALL
        #ifndef __SYNTHESIS__
       std::cout << std::endl;
       #endif
       #endif
       //sInCmpRes.write(tmpOut);
        maddr_non_byte++;
    }else{
      k--;
      curr_address_ut--;
    }
  }
 
  flt_cntr_loop: for (int i = 0; i < support_dim; i++)
  {
#pragma HLS PIPELINE
    faulty_addresses_cntr_local += faulty_addresses_cntr_support_array[i];
    faulty_addresses_cntr_support_array[i]=0;
  }
  
  first_fault_found=false;
*faulty_addresses_cntr=faulty_addresses_cntr_local;
 
}

pRDMainMemoryRead2StreamData()

template<typename Tcntr , const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 64*2>

void pRDMainMemoryRead2StreamData	(	hls::stream< Tcntr > &	sOutCmd,
		hls::stream< local_mem_word_t > &	sOutreadData,
		membus_t *	lcl_mem,
		local_mem_addr_t	max_addr_ut,
		unsigned int	burst_size
	)

Read a single word of data and output on a stream and count the cc needed just 4 transfer
NOT USED.

Deprecated:

Parameters

[out]	sOutCmd	the perf counter cmd stream
[out]	sOutreadData	the read data stream
[in]	lcl_mem	the virtual memory mapped pointer
[in]	max_addr_ut	the maximum address to test
[in]	burst_size	the run-time variable burst size

Returns

Nothing.

Definition at line 795 of file memtest_pattern_library.hpp.

{
#pragma HLS INLINE off
 
    local_mem_addr_t curr_address_ut;
    static local_mem_addr_t curr_reading_addr;
    static local_mem_word_t tmp_out[buff_dim];
#pragma HLS array_partition variable=tmp_out cyclic factor=2 dim=1
 
  sOutCmd.write(0);
  int i, reading_i;
  read_data_from_main_mem:
  for (i = 0, curr_address_ut = 0, curr_reading_addr=0, reading_i=0; curr_address_ut < max_addr_ut; )
  {
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_iterations
    if (!sOutreadData.full())
    {
 
      memcpy(tmp_out+reading_i, lcl_mem+curr_address_ut, sizeof(local_mem_word_t));
      if(reading_i > curr_reading_addr+1){
        sOutreadData.write(tmp_out[curr_reading_addr]);
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
        std::cout << " writing a memory word " << curr_reading_addr << " I have to reach " << i << std::endl;
      #endif
      #endif
        curr_reading_addr++;
 
      }
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
      std::cout << "read the " << reading_i << " memory word, outputreading at  " << curr_reading_addr << " i at " << i << std::endl;
      #endif
      #endif
 
      if(reading_i==buff_dim-1){
        reading_i=0;
      }else{
        reading_i++;
      }
      curr_address_ut++;
      i++;
    }
  }
 
  sOutCmd.write(0);
  i--;
  reading_i=i%buff_dim;
  sent_out_remaining_buff: 
  for (int j = 0; j < buff_dim; j++)
  {
#pragma HLS LOOP_TRIPCOUNT min = 1 max = buff_dim
#pragma HLS PIPELINE II=1
    if (!sOutreadData.full())
    {
      if(j==curr_reading_addr && i >= curr_reading_addr){
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
        std::cout << " writing a memory word " << curr_reading_addr << " I have to reach " << i << std::endl;
      #endif
      #endif
        sOutreadData.write(tmp_out[curr_reading_addr]);
        curr_reading_addr++;
        tmp_out[j]=0;
      }else{
        tmp_out[j]=0;
      }
    }else{
      j--;
    }
  }
  curr_reading_addr=0;
 
}

pRDRead2StreamDataVariableBurst()

template<typename Tcntr , const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 64*2>

void pRDRead2StreamDataVariableBurst	(	hls::stream< Tcntr > &	sOutCmd,
		hls::stream< local_mem_word_t > &	sOutreadData,
		membus_t *	lcl_mem,
		local_mem_addr_t	max_addr_ut,
		unsigned int	burst_size
	)

Read a variable burst_size amount of data and output on a stream and count the cc needed just 4 transfer
THIS FUNCTION SUFFER FIFO OVERFLOW 4 transfer different from power of 2 numbers NOT USED.

Deprecated:

Parameters

[out]	sOutCmd	the perf counter cmd stream
[out]	sOutreadData	the read data stream
[in]	lcl_mem	the virtual memory mapped pointer
[in]	max_addr_ut	the maximum address to test
[in]	burst_size	the run-time variable burst size

Returns

Nothing.

Definition at line 892 of file memtest_pattern_library.hpp.

{
#pragma HLS INLINE off
 
    local_mem_addr_t curr_address_ut;
    static local_mem_word_t tmp_out[buff_dim];
#pragma HLS array_partition variable=tmp_out cyclic factor=2 dim=1
    static local_mem_addr_t curr_reading_addr;
    static unsigned int end_distance=0;
    static int ptrs_distance=0;
    static int ptrs_distance_opposite=0;
    static bool transfer_less_than_burst = false;
    static bool activated_cntr = false;
    static bool can_read_data = false;
 
  read_data_from_main_mem:
  int reading_mm_i = 0;//how much filled the buff
  int consumed_fifo_i = 0;//how much already outputed
  int missing_words=0;
  unsigned int total_consumed_words=0;
  unsigned int total_readfrom_mm_words=0;
  bool fifo_is_not_full=false;
  for (curr_address_ut = 0, curr_reading_addr=0; curr_address_ut < max_addr_ut; )
  {
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_iterations
    if (!sOutreadData.full())
    {
 
      end_distance = max_addr_ut-curr_reading_addr;
      ptrs_distance = total_readfrom_mm_words - total_consumed_words;
      ptrs_distance_opposite = total_consumed_words - total_readfrom_mm_words;
      transfer_less_than_burst = burst_size>end_distance;
      fifo_is_not_full = ptrs_distance <= burst_size;
          //i have data to crunch, and eithre the fifo can read a burst or consumed enough to tx less than a burst)
      can_read_data=(end_distance > 0) && (fifo_is_not_full  || (ptrs_distance<=end_distance && transfer_less_than_burst));
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
          std::cout << "Max " << max_addr_ut << " reading at " << curr_reading_addr << " reading fifo at " << reading_mm_i <<  " consumed at " << consumed_fifo_i << std::endl;
          std::cout << "End dst " << end_distance << " ptrs dst " << ptrs_distance << " is last? " << transfer_less_than_burst << std::endl;
          std::cout << "curr_address_ut " << curr_address_ut << std::endl;  
      #endif
      #endif
      //if more than a burst size to available or the last iteration
      if(can_read_data){
        if (!transfer_less_than_burst)
        {
          //read a burst
          if(!activated_cntr){
            sOutCmd.write(0);
            activated_cntr = true;
          }else{
            sOutCmd.write(1);
          }
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
          std::cout << "BURST reading " << burst_size << " words from " << curr_reading_addr << " address, to  " << reading_mm_i << std::endl;
      #endif
      #endif
          memcpy(tmp_out+reading_mm_i, lcl_mem+curr_reading_addr, sizeof(local_mem_word_t)*burst_size);
          sOutCmd.write(1);
          std::cout << "before " << curr_reading_addr;
          curr_reading_addr+=burst_size;
          std::cout << " afterwards " << curr_reading_addr << std::endl;
          total_readfrom_mm_words+=burst_size;
          reading_mm_i=(reading_mm_i+burst_size)%buff_dim;
        }else{
          //read the missing words
          missing_words= end_distance%burst_size;
          std::cout << "before of before 1" << curr_reading_addr << std::endl;
          if(!activated_cntr){
            sOutCmd.write(0);
            activated_cntr = true;
          }else{
            sOutCmd.write(1);
          }
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
          std::cout << "LAST reading " << missing_words << " words from " << curr_reading_addr << " address, to  " << reading_mm_i << std::endl;
      #endif
      #endif
          total_readfrom_mm_words+=missing_words;
          std::cout << "before of before 3" << curr_reading_addr << std::endl;
          memcpy(tmp_out+reading_mm_i, lcl_mem+curr_reading_addr, sizeof(local_mem_word_t)*(end_distance%burst_size));
          sOutCmd.write(1);
 
          std::cout << "before " << curr_reading_addr;
          curr_reading_addr+=missing_words;
          std::cout << " afterwards " << curr_reading_addr << std::endl;
          reading_mm_i=(reading_mm_i+missing_words)%buff_dim;
        }
      }
 
      if(ptrs_distance > 0 || can_read_data){
        sOutreadData.write(tmp_out[consumed_fifo_i]);
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
        std::cout << " consumin a read memory word " << consumed_fifo_i << " I have to reach " << reading_mm_i << std::endl;
        std::cout << " The readmemoryword is  " << tmp_out[consumed_fifo_i]  << std::endl;
      #endif
     #endif
 
        if(consumed_fifo_i==buff_dim-1){
          consumed_fifo_i=0;
        }else{
          consumed_fifo_i++;
        }
        total_consumed_words++;
      }
      //if() still data to read and to consume
      curr_address_ut++;
      //else{
      //  curr_address_ut=max_addr_ut;
      //}
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
        std::cout <<std::endl;
      #endif
     #endif
    }
  }
  sOutCmd.write(0);
  //reset
  end_distance=0;
  transfer_less_than_burst = false;
  activated_cntr=false;
  can_read_data=false;
  ptrs_distance=0;
}

pRDRead2StreamDataVariableBurstNoMemCpy()

template<typename Tcntr , const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 64*2>

void pRDRead2StreamDataVariableBurstNoMemCpy	(	hls::stream< Tcntr > &	sOutCmd,
		hls::stream< local_mem_word_t > &	sOutReadData,
		membus_t *	lcl_mem,
		local_mem_addr_t	max_addr_ut,
		unsigned int	burst_size
	)

Read a variable burst_size amount of data and output on a stream and count the cc needed just 4 transfer but without using memcpy.

Parameters

[out]	sOutCmd	the perf counter cmd stream
[out]	sOutReadData	the read data stream
[in]	lcl_mem	the virtual memory mapped pointer
[in]	max_addr_ut	the maximum address to test
[in]	burst_size	the run-time variable burst size

Returns

Nothing.

Definition at line 434 of file memtest_pattern_library.hpp.

{
#pragma HLS INLINE off
#pragma HLS interface ap_ctrl_none port=return
 
    local_mem_addr_t curr_address_ut;
    static local_mem_word_t tmp_out[buff_dim];
#pragma HLS array_partition variable=tmp_out cyclic factor=2 dim=1
    static local_mem_addr_t curr_reading_addr;
    static unsigned int end_distance=0;
    static bool transfer_less_than_burst = false;
    static bool activated_cntr = false;
    static bool can_read_data = false;
 
  read_data_from_main_mem:
  int reading_mm_i = 0;//how much filled the buff
  int consumed_fifo_i = 0;//how much already outputed
  int missing_words=0;
  for (curr_address_ut = 0, curr_reading_addr=0; curr_address_ut < max_addr_ut; )
  {
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_iterations
    if (!sOutReadData.full())
    {
      end_distance = max_addr_ut-curr_reading_addr;
      transfer_less_than_burst = burst_size>end_distance;
      //i have data to crunch, and eithre the fifo can read a burst or consumed enough to tx less than a burst)
      can_read_data=(end_distance > 0) ;
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
          std::cout << "Max " << max_addr_ut << " reading at " << curr_reading_addr << " reading fifo at " << reading_mm_i <<  " consumed at " << consumed_fifo_i << std::endl;
          std::cout << "End dst " << end_distance << " is last? " << transfer_less_than_burst << std::endl;
          std::cout << "curr_address_ut " << curr_address_ut << std::endl;  
      #endif
      #endif
      //if more than a burst size to available or the last iteration
      if(can_read_data){
        if (!transfer_less_than_burst)
        {
          //read a burst
          if(!activated_cntr){
            activated_cntr = true;
          pReadAxiMemMapped2HlsStreamCountFirst<membus_t,
          local_mem_word_t,64>(lcl_mem+curr_reading_addr, 
          sOutReadData, burst_size, sOutCmd);
          }else{
          pReadAxiMemMapped2HlsStreamCountActivated<membus_t,
          local_mem_word_t,64>(lcl_mem+curr_reading_addr, 
          sOutReadData, burst_size, sOutCmd);
          }
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
          std::cout << "BURST reading " << burst_size << " words from " << curr_reading_addr << " address, to  " << reading_mm_i << std::endl;
      #endif
      #endif
          curr_reading_addr+=burst_size;
          reading_mm_i=(reading_mm_i+burst_size)%buff_dim;
        }else{
          //read the missing words
          missing_words= end_distance%burst_size;
          if(!activated_cntr){
            activated_cntr = true;
          pReadAxiMemMapped2HlsStreamCountFirst<membus_t,
          local_mem_word_t,64>(lcl_mem+curr_reading_addr,
           sOutReadData, missing_words, sOutCmd);
          }else{
          pReadAxiMemMapped2HlsStreamCountActivated<membus_t,
          local_mem_word_t,64>(lcl_mem+curr_reading_addr, 
          sOutReadData, missing_words, sOutCmd);
          }
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
          std::cout << "LAST reading " << missing_words << " words from " << curr_reading_addr << " address, to  " << reading_mm_i << std::endl;
      #endif
      #endif
          curr_reading_addr+=missing_words;
          reading_mm_i=(reading_mm_i+missing_words)%buff_dim;
        }
      }
 
      //if() still data to read and to consume
      curr_address_ut++;
      //else{
      //  curr_address_ut=max_addr_ut;
      //}
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
        std::cout <<std::endl;
      #endif
     #endif
    }
  }
  sOutCmd.write(0);
  //reset
  end_distance=0;
  transfer_less_than_burst = false;
  activated_cntr=false;
  can_read_data=false;
}

Here is the call graph for this function:

pRDReadDataStreamAndProduceGold()

template<const unsigned int max_iterations = 4000000>

void pRDReadDataStreamAndProduceGold	(	hls::stream< local_mem_word_t > &	sInReadData,
		local_mem_addr_t	max_addr_ut,
		hls::stream< local_mem_word_t > &	sOutReadData,
		hls::stream< local_mem_word_t > &	sOutGoldData
	)

Read a data stream and produce the gold expected value.

Parameters

[in]	sInReadData	the input read data stream
[in]	max_addr_ut	the maximum address to test
[in]	sOutReadData	the copy of the input data stream
[in]	sOutGoldData	the golden expected value stream

Returns

Nothing.

Definition at line 554 of file memtest_pattern_library.hpp.

{
#pragma HLS interface ap_ctrl_none port=return
    static local_mem_addr_t curr_address_ut= 0;
    local_mem_word_t testingVector;
    local_mem_word_t goldenVector;
 
  generate_loop:
  for (; curr_address_ut < max_addr_ut; )
  {
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_iterations
    if (!sInReadData.empty() && !sOutReadData.full() &&  !sOutGoldData.full())
    {
      testingVector = sInReadData.read(); 
 
      // genXoredSequentialNumbersSecondVersion<local_mem_addr_non_byteaddressable_t, LOCAL_MEM_WORD_SIZE/32,
      //  local_mem_word_t, ap_uint<32>,32>(local_mem_addr_non_byteaddressable, &goldenVector);
      genXoredNumbersSingleWord<local_mem_addr_t,
      local_mem_word_t>(curr_address_ut, &goldenVector);
      //genSequentialNumbers<local_mem_addr_non_byteaddressable_t,local_mem_word_t>(curr_address_ut*64, &goldenVector);
 
      sOutReadData.write(testingVector);
      sOutGoldData.write(goldenVector);
      curr_address_ut++;
    }
  }
  curr_address_ut = 0;
}

Here is the call graph for this function:

pReadAxiMemMapped2HlsStream()

template<typename Tin , typename Tout , const unsigned int burstsize>

void pReadAxiMemMapped2HlsStream	(	Tin *	main_mem,
		hls::stream< Tout > &	sOut,
		unsigned int	elems
	)

Copy a run-time variable amount of data to an hls stream with a given max.

Parameters

[out]	main_mem	the src ptr to read
[in]	sOut	the dst hls stream
[in]	elems	the current amount of data to tx
[in]	Tin	the input datatype
[in]	Tout	the output datatype
[in]	burstsize	the maxmimum amount of data

Returns

Nothing.

Definition at line 432 of file memtest_library.hpp.

                                                                                          {
#pragma HLS INLINE
  mmloop: for (unsigned int i = 0; i < elems; i++)
  {
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = burstsize
    Tout tmp  = main_mem[i];
    sOut.write(tmp);
  }
  
}

pReadAxiMemMapped2HlsStreamCountActivated()

template<typename Tin , typename Tout , const unsigned int burstsize, typename Tcntr >

void pReadAxiMemMapped2HlsStreamCountActivated	(	Tin *	main_mem,
		hls::stream< Tout > &	sOut,
		unsigned int	elems,
		hls::stream< Tcntr > &	cmd
	)

Copy a run-time variable amount of data to an hls stream with a given max it assumes "perfCounterMultipleCounts" function already initialized so it just incr.

Parameters

[out]	main_mem	the src ptr to read
[in]	sOut	the dst hls stream
[in]	elems	the current amount of data to tx
[in]	cmd	the performance counter cmd stream
[in]	Tin	the input datatype
[in]	Tout	the output datatype
[in]	burstsize	the maxmimum amount of data
[in]	Tcntr	the cmd perf counter datatype

Returns

Nothing.

Definition at line 491 of file memtest_library.hpp.

                                                                                                                               {
#pragma HLS INLINE
  cmd.write(1);
  mmloop: for (unsigned int i = 0; i < elems; i++)
  {
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = burstsize
    Tout tmp  = main_mem[i];
    sOut.write(tmp);
  }
  cmd.write(1);
}

Here is the caller graph for this function:

pReadAxiMemMapped2HlsStreamCountExtern()

template<typename Tin , typename Tout , const unsigned int burstsize, typename Tcntr >

void pReadAxiMemMapped2HlsStreamCountExtern	(	Tin *	main_mem,
		hls::stream< Tout > &	sOut,
		unsigned int	elems,
		hls::stream< Tcntr > &	cmd,
		bool	activated
	)

Copy a run-time variable amount of data to an hls stream with a given max it assumes "perfCounterMultipleCounts" function already initialized so it just incr.

Parameters

[out]	main_mem	the src ptr to read
[in]	sOut	the dst hls stream
[in]	elems	the current amount of data to tx
[in]	cmd	the performance counter cmd stream
[in]	Tin	the input datatype
[in]	Tout	the output datatype
[in]	burstsize	the maxmimum amount of data
[in]	Tcntr	the cmd perf counter datatype

Returns

Nothing.

Definition at line 520 of file memtest_library.hpp.

                                                                                                                                            {
#pragma HLS INLINE
  cmd.write(activated);
  mmloop: for (unsigned int i = 0; i < elems; i++)
  {
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = burstsize
    Tout tmp  = main_mem[i];
    sOut.write(tmp);
  }
  cmd.write(1);
}

pReadAxiMemMapped2HlsStreamCountFirst()

template<typename Tin , typename Tout , const unsigned int burstsize, typename Tcntr >

void pReadAxiMemMapped2HlsStreamCountFirst	(	Tin *	main_mem,
		hls::stream< Tout > &	sOut,
		unsigned int	elems,
		hls::stream< Tcntr > &	cmd
	)

Copy a run-time variable amount of data to an hls stream with a given max it assumes also the initialization of a perf counter of "perfCounterMultipleCounts" function.

Parameters

[out]	main_mem	the src ptr to read
[in]	sOut	the dst hls stream
[in]	elems	the current amount of data to tx
[in]	cmd	the performance counter cmd stream
[in]	Tin	the input datatype
[in]	Tout	the output datatype
[in]	burstsize	the maxmimum amount of data
[in]	Tcntr	the cmd perf counter datatype

Returns

Nothing.

Definition at line 461 of file memtest_library.hpp.

                                                                                                                           {
#pragma HLS INLINE
cmd.write(0);
  mmloop: for (unsigned int i = 0; i < elems; i++)
  {
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = burstsize
    Tout tmp  = main_mem[i];
    sOut.write(tmp);
  }
  cmd.write(1);
  
}

Here is the caller graph for this function:

pReadDataflowMemTest()

template<const unsigned int maximum_number_of_beats = 512>

void pReadDataflowMemTest	(	membus_t *	lcl_mem1,
		local_mem_addr_t	max_address_under_test,
		ap_uint< 64 > *	reading_cntr,
		ap_uint< 32 > *	faulty_addresses_cntr,
		local_mem_addr_t *	first_faulty_address,
		unsigned int	burst_size
	)

Definition at line 107 of file memtest_processing.hpp.

  {
  #pragma HLS INLINE off
 
 static hls::stream<ap_uint<64>> sReadPrfCntr_cmd("sReadPrfCntr_cmd"); 
 #pragma HLS STREAM variable=sReadPrfCntr_cmd depth=maximum_number_of_beats dim=1
 static hls::stream<local_mem_word_t> generatedReadData("generatedReadData"); 
 #pragma HLS STREAM variable=generatedReadData depth=maximum_number_of_beats dim=1
  static hls::stream<local_mem_word_t> sReadData("sReadData"); 
 #pragma HLS STREAM variable=sReadData depth=maximum_number_of_beats dim=1
  static hls::stream<local_mem_word_t> sGoldData("sGoldData"); 
 #pragma HLS STREAM variable=sGoldData depth=maximum_number_of_beats dim=1
 
  static hls::stream<ap_uint<64>> sComparisonData("sComparisonData"); 
 #pragma HLS STREAM variable=sComparisonData depth=64 dim=1
 //  static hls::stream<local_mem_addr_t> sFaultyAddresses("sFaultyAddresses"); 
 // #pragma HLS STREAM variable=sFaultyAddresses depth=64 dim=1
 
#pragma HLS DATAFLOW
 
 
    #ifdef SIMPLER_BANDWIDTH_TEST
      //Step 1 write data
      pReadSimplerTestMemTest<ap_uint<64>>(sReadPrfCntr_cmd, lcl_mem1, max_address_under_test, burst_size, faulty_addresses_cntr, first_faulty_address);
      //Step 2 count
      perfCounterProc2MemCountOnly<ap_uint<64>,ap_uint<64>,64>(sReadPrfCntr_cmd, reading_cntr);
    #else
      //Step 1: Generate the data
      pRDRead2StreamDataVariableBurstNoMemCpy<ap_uint<64>,4000000,maximum_number_of_beats>( sReadPrfCntr_cmd, generatedReadData, lcl_mem1, max_address_under_test,burst_size);
      //Step 2: write 
      pRDReadDataStreamAndProduceGold<4000000>(generatedReadData, max_address_under_test, sReadData, sGoldData); 
      //Step 2.b: count 
      perfCounterMultipleCounts<ap_uint<64>,ap_uint<64>,64>(sReadPrfCntr_cmd, reading_cntr);
      //Step 3: compare
      pRDCmpStreamsCntWordAligned<4000000,maximum_number_of_beats>(max_address_under_test,sReadData, sGoldData,faulty_addresses_cntr, first_faulty_address);
    #endif   
}

pReadSimplerTestMemTest()

template<typename Tcntr , const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 64*2>

void pReadSimplerTestMemTest	(	hls::stream< Tcntr > &	sOutCmd,
		membus_t *	lcl_mem,
		local_mem_addr_t	max_addr_ut,
		unsigned int	burst_size,
		ap_uint< 32 > *	faulty_addresses_cntr,
		local_mem_addr_t *	first_faulty_address
	)

Simple version of a read memtest that read up to a given maximum address No control on the burst size or on the first faulty address.

Parameters

[out]	sOutCmd	the perf counter cmd stream
[in]	lcl_mem	the virtual memory mapped pointer
[in]	max_addr_ut	the maximum address to test
[in]	burst_size	the run-time variable burst size NOT MEANINGFUL HERE
[out]	faulty_addresses_cntr	the fault cntr
[out]	first_faulty_address	the fairst faulty address NOT MEANINGFUL HERE

Returns

Nothing.

Definition at line 390 of file memtest_pattern_library.hpp.

{
  local_mem_addr_t curr_address_ut;
  int faults = 0;
//Step 1) start counting
  sOutCmd.write(0);
  for (curr_address_ut = 0; curr_address_ut < max_addr_ut; curr_address_ut++){
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_iterations
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
  printf("Tst=%s vs gld=%s\n",lcl_mem[curr_address_ut].to_string().c_str(),(curr_address_ut+1).to_string().c_str());
  #endif 
  #endif
//Step 2) read a simple pattern and fault checks
    faults +=  (lcl_mem[curr_address_ut]!=(curr_address_ut+1)) ? 1 : 0;
  }
//Step 3) stop counting
  sOutCmd.write(0);
  *faulty_addresses_cntr = faults;
  *first_faulty_address = 0;
}

pRXPath()

void pRXPath	(	stream< NetworkWord > &	siSHL_This_Data,
		stream< NetworkMetaStream > &	siNrc_meta,
		stream< NetworkMetaStream > &	sRxtoProc_Meta,
		stream< NetworkWord > &	sRxpToProcp_Data,
		NetworkMetaStream	meta_tmp,
		bool *	start_stop,
		unsigned int *	processed_word_rx,
		unsigned int *	processed_bytes_rx
	)

Receive Path - From SHELL to THIS.

Parameters

[in]	siSHL_This_Data
[in]	siNrc_meta
[out]	sRxtoTx_Meta
[out]	sRxpToProcp_Data
[out]	start_stop
[out]	meta_tmp
[out]	processed_word

Returns

Nothing.

Definition at line 121 of file memtest_library.hpp.

{
    //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
     #pragma  HLS INLINE  off
    //-- LOCAL VARIABLES ------------------------------------------------------
 
 
static PacketFsmType enqueueFSM = WAIT_FOR_META;
#pragma HLS reset variable=enqueueFSM
 
 
    NetworkWord    netWord;
    ap_uint<16> max_iterations;
    static bool start_stop_local = false;
    static bool prev_was_start = false;
#pragma HLS reset variable=start_stop_local
 
    *start_stop = start_stop_local;
  switch(enqueueFSM)
  {
    case WAIT_FOR_META: 
    #if DEBUG_LEVEL == TRACE_ALL
      printf("DEBUG in pRXPath: enqueueFSM - WAIT_FOR_META, *processed_word_rx=%u, *processed_bytes_rx=%u\n",
       *processed_word_rx, *processed_bytes_rx);
    #endif
      if ( !siNrc_meta.empty() && !sRxtoProc_Meta.full() )
      {
        meta_tmp = siNrc_meta.read();//not sure if I have to continue to test or not, hence sending the meta or not is different
        meta_tmp.tlast = 1; //just to be sure...
        sRxtoProc_Meta.write(meta_tmp); //valid destination
        enqueueFSM = PROCESSING_PACKET;
      }
      break;
 
    case PROCESSING_PACKET:
    #if DEBUG_LEVEL == TRACE_ALL
      printf("DEBUG in pRXPath: enqueueFSM - PROCESSING_PACKET, *processed_word_rx=%u, *processed_bytes_rx=%u\n",
       *processed_word_rx, *processed_bytes_rx);
    #endif
      
      if ( !siSHL_This_Data.empty() && !sRxpToProcp_Data.full() )
      {
        //-- Read incoming data chunk
        netWord = siSHL_This_Data.read();
 
        switch(netWord.tdata.range(MEMTEST_COMMANDS_HIGH_BIT,MEMTEST_COMMANDS_LOW_BIT))//the command is in the first two bits
        {
          case(TEST_START_CMD):
            start_stop_local=true;
            *start_stop=true;
            sRxpToProcp_Data.write(netWord);
            prev_was_start=true;
      #if DEBUG_LEVEL == TRACE_ALL
        printf("Hallo, I received a start command :D\n");
      #endif
            break;
          case(TEST_STOP_CMD):
            start_stop_local=false;
            *start_stop=false;
            netWord.tdata=TEST_STOP_CMD;
            netWord.tlast = 1;
            sRxpToProcp_Data.write(netWord);
            prev_was_start=false;
      #if DEBUG_LEVEL == TRACE_ALL
        printf("Hallo, I received a stop command D:\n");
      #endif
            break;
 
          case(TEST_BURSTSIZE_CMD):
      #if DEBUG_LEVEL == TRACE_ALL
      printf("Hallo, I received a burst size command :), and prev_was_start=%u\n",prev_was_start);
      #endif
            if (prev_was_start)
            {
              sRxpToProcp_Data.write(netWord);
 
            }else{
              netWord.tdata=TEST_INVLD_CMD;
              sRxpToProcp_Data.write(netWord);
            }
            prev_was_start=false;
            break;
          default:
            if (start_stop_local)
            {
              //some data manipulation here
              // everything is running and should no sending anything back
            } else {
              netWord.tdata=TEST_INVLD_CMD;
              prev_was_start=false;
              sRxpToProcp_Data.write(netWord);
            }
            break;
 
        } 
        //no need to forwarding every packet to the processing, hence commenting out
        //sRxpToProcp_Data.write(netWord);
        if(netWord.tlast == 1)
        {
          enqueueFSM = WAIT_FOR_META;
        }
      }
      break;
  }
 
 
}

Here is the caller graph for this function:

pTHISProcessingData()

template<const unsigned int counter_width = 64>

void pTHISProcessingData	(	stream< NetworkWord > &	sRxpToProcp_Data,
		stream< NetworkWord > &	sProcpToTxp_Data,
		stream< NetworkMetaStream > &	sRxtoProc_Meta,
		stream< NetworkMetaStream > &	sProctoTx_Meta,
		bool *	start_stop
	)

THIS processing the data once recieved a start command Template function for custom processing.

Parameters

[in]	sRxpToProcp_Data	stream of data from rx to proc interface
[out]	sProcpToTxp_Data	stream of data from proc to tx interface
[in]	start_stop	start and stop command
[in]	lcl_mem0	shell-role mp1 memory mapped interfce virtual ptr 0
[in]	lcl_mem1	shell-role mp1 memory mapped interfce virtual ptr 1

Returns

Nothing.

Definition at line 191 of file memtest_processing.hpp.

 {
    //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma  HLS INLINE off
    //-- LOCAL VARIABLES ------------------------------------------------------
    NetworkWord    netWord;
    NetworkWord    outNetWord;
    static NetworkMetaStream  outNetMeta = NetworkMetaStream();;
    static ProcessingFsmType processingFSM  = FSM_PROCESSING_WAIT_FOR_META;
 
    static ap_uint<16> max_iterations;
 
    static local_mem_addr_t first_faulty_address;
 
    static ap_uint<32> faulty_addresses_cntr;
 
    static local_mem_addr_t max_address_under_test; // byte addressable;
    static size_t bytes_sent_for_tx =0;
 
#pragma HLS reset variable=processingFSM
#pragma HLS reset variable=outNetMeta
#pragma HLS reset variable=max_iterations
#pragma HLS reset variable=first_faulty_address
#pragma HLS reset variable=faulty_addresses_cntr
#pragma HLS reset variable=max_address_under_test
#pragma HLS reset variable=processingFSM
#pragma HLS reset variable=bytes_sent_for_tx
 
    static ap_uint<32> testCounter;
    static ap_uint<counter_width> reading_cntr = 0;
    static ap_uint<counter_width> writing_cntr = 0;
    static unsigned int burst_size=1;
    static local_mem_addr_t tmp_wordaligned_address = 0;
    static int emptycntr=0;
 
#pragma HLS reset variable=testCounter
#pragma HLS reset variable=tmp_wordaligned_address
#pragma HLS reset variable=burst_size
 
 
//assuming that whnever I send a start I must complete the run and then restart unless a stop
// or stopping once done with the run iterations
    switch(processingFSM)
    {
      case FSM_PROCESSING_WAIT_FOR_META:
    #if DEBUG_LEVEL == TRACE_ALL
      printf("DEBUG proc FSM, I am in the WAIT_FOR_META state\n");
    #endif
      //resetting once per test suite
      max_address_under_test = 0;
      max_iterations=0;
      bytes_sent_for_tx = 0;
      burst_size=1;
      if ( !sRxtoProc_Meta.empty()  && !sProctoTx_Meta.full())
      {
        outNetMeta = sRxtoProc_Meta.read();
        sProctoTx_Meta.write(outNetMeta);
        processingFSM = FSM_PROCESSING_PCKT_PROC;
      }
      break;
 
      case FSM_PROCESSING_PCKT_PROC:
    #if DEBUG_LEVEL == TRACE_ALL
      printf("DEBUG proc FSM, I am in the PROCESSING_PCKT_PROC state\n");
    #endif
//parse the received data
      if ( !sRxpToProcp_Data.empty() && !sProcpToTxp_Data.full())
      {
        netWord = sRxpToProcp_Data.read();
        switch (netWord.tdata.range(MEMTEST_COMMANDS_HIGH_BIT,MEMTEST_COMMANDS_LOW_BIT))
        {
        case TEST_INVLD_CMD:
          /* FWD an echo of the invalid*/
    #if DEBUG_LEVEL == TRACE_ALL
          printf("DEBUG processing the packet with invalid cmd\n");
    #endif
          sProcpToTxp_Data.write(netWord);
          processingFSM = FSM_PROCESSING_WAIT_FOR_META;
          break;
        case TEST_STOP_CMD:
          /* call with stop (never started), unset, fwd the stop */
    #if DEBUG_LEVEL == TRACE_ALL
         printf("DEBUG processing the packet with stop cmd\n");
    #endif
          outNetWord.tdata=TEST_STOP_CMD;
          outNetWord.tkeep = 0xFF;
          outNetWord.tlast = 1;
          sProcpToTxp_Data.write(outNetWord);
          processingFSM = FSM_PROCESSING_WAIT_FOR_META;
          break;    
        default:
          /* Execute the test if not invalid or stop*/
    #if DEBUG_LEVEL == TRACE_ALL
          printf("DEBUG processing the packet with the address within cmd\n");
    #endif
          max_address_under_test = netWord.tdata(MEMTEST_ADDRESS_HIGH_BIT,MEMTEST_ADDRESS_LOW_BIT);
          max_iterations = netWord.tdata.range(MEMTEST_ITERATIONS_HIGH_BIT,MEMTEST_ITERATIONS_LOW_BIT);
    #if DEBUG_LEVEL == TRACE_ALL
    #ifndef __SYNTHESIS__
         printf("DEBUG processing the packet with the address %s within cmd %s\n", max_address_under_test.to_string().c_str(), max_iterations.to_string().c_str());
    #endif //__SYNTHESIS__
    #endif
          processingFSM = FSM_PROCESSING_BURST_READING;
          break;
        }
      }
      break;
 
      case FSM_PROCESSING_BURST_READING:
        #if DEBUG_LEVEL == TRACE_ALL
        printf("DEBUG proc FSM, I am in the FSM_PROCESSING_BURST_READING state\n");
       #endif
//parse the received data
      if ( !sRxpToProcp_Data.empty())
      {
        netWord = sRxpToProcp_Data.read();
    #if DEBUG_LEVEL == TRACE_ALL
        std::cout << netWord.tdata.to_string() << std::endl;
    #endif
        switch (netWord.tdata.range(MEMTEST_COMMANDS_HIGH_BIT,MEMTEST_COMMANDS_LOW_BIT))
        {
        case TEST_BURSTSIZE_CMD:
          /* extract the busrt size*/
          burst_size = netWord.tdata.range(MEMTEST_BURST_HIGH_BIT,MEMTEST_BURST_LOW_BIT);
 
    #if DEBUG_LEVEL == TRACE_ALL
          printf("DEBUG processing the packet with burst cmd, and burst size=%u\n",burst_size);
    #endif
          processingFSM = FSM_PROCESSING_START;
          break;
 
 
        default:
          /*unkown stuff hence using a burst with 1 beat*/
    #if DEBUG_LEVEL == TRACE_ALL
    #ifndef __SYNTHESIS__
          printf("DEBUG processing the packet with smth bad within cmd: %s\n",netWord.tdata.range(MEMTEST_COMMANDS_HIGH_BIT,MEMTEST_COMMANDS_LOW_BIT).to_string().c_str());
    #endif
    #endif
          burst_size=1;
          sProcpToTxp_Data.write(netWord);
          processingFSM = FSM_PROCESSING_START;
          break;
        }
      }
      break;
 
//The hw can begin to do something
      case FSM_PROCESSING_START:
      // sOCMDPerfCounter.write(0);//init the counter
    #if DEBUG_LEVEL == TRACE_ALL
        printf("DEBUG proc FSM, I am in the START state\n");
    #endif
    //setting everything ready to start
        first_faulty_address = 0; 
        faulty_addresses_cntr = 0;
       if(max_address_under_test%64==0){
          tmp_wordaligned_address = max_address_under_test/64;
       } else {
         tmp_wordaligned_address = (max_address_under_test/64+1);
       }
    #if DEBUG_LEVEL == TRACE_ALL
    #ifndef __SYNTHESIS__
        std::cout << " testing the address word aligned" << tmp_wordaligned_address.to_string() << std::endl;
    #endif
    #endif
        reading_cntr = 0;
        writing_cntr = 0;
        testCounter = 0;
        processingFSM = FSM_PROCESSING_DATAFLOW_WRITE;//FSM_PROCESSING_WRITE;
        break;
 
  //run continuously, hence more than once
      case FSM_PROCESSING_CONTINUOUS_RUN:
        testCounter += 1;
        reading_cntr = 0;
        writing_cntr = 0;
        faulty_addresses_cntr = 0;
        first_faulty_address = 0; 
 
        //stopping conditions: either a Stop or the maximum iterations
        if(*start_stop && testCounter < max_iterations){
    #if DEBUG_LEVEL == TRACE_ALL
    #ifndef __SYNTHESIS__
          printf("DEBUG processing continuous run (still run, iter %s) max iters: %s\n",testCounter.to_string().c_str(),max_iterations.to_string().c_str());
    #endif //__SYNTHESIS__
    #endif
        // check if need another meta to send out!
        // if already over the MTU size, or with a command (stop case) or with another iteration I need to send out another meta
          if(bytes_sent_for_tx >= PACK_SIZE){
            sProctoTx_Meta.write(outNetMeta);
    #if DEBUG_LEVEL == TRACE_ALL
        std::cout <<  "DEBUG: writing an additional meta with bytes sent equal to " << bytes_sent_for_tx << std::endl;
    #endif
            bytes_sent_for_tx = 0;
          }
        processingFSM = FSM_PROCESSING_DATAFLOW_WRITE;
 
          break;
        }else{
    #if DEBUG_LEVEL == TRACE_ALL
    #ifndef __SYNTHESIS__
          printf("DEBUG processing continuous run (stop the run at iter %s) max iters: %s \n",testCounter.to_string().c_str(),max_iterations.to_string().c_str());
    #endif //__SYNTHESIS__
    #endif
          //signal the end of the packet with the iteration of the tests performed
          outNetWord.tdata.range(MEMTEST_COMMANDS_HIGH_BIT,MEMTEST_COMMANDS_LOW_BIT)=TEST_ENDOFTESTS_CMD;
          outNetWord.tdata.range(NETWORK_WORD_BIT_WIDTH-1,MEMTEST_COMMANDS_HIGH_BIT+1)=testCounter;
          outNetWord.tkeep = 0xFF;
          outNetWord.tlast = 1;
          sProcpToTxp_Data.write(outNetWord);
          processingFSM = FSM_PROCESSING_WAIT_FOR_META;
          break;
        }
 
      //Begin to process
      case FSM_PROCESSING_DATAFLOW_WRITE:
    #if DEBUG_LEVEL == TRACE_ALL
      printf("DEBUG processing write dataflow\n");
    #endif
    pWriteDataflowMemTest<top_param_maximum_number_of_beats>( lcl_mem0, 
    tmp_wordaligned_address , &writing_cntr,&testCounter,burst_size);
      processingFSM = FSM_PROCESSING_DATAFLOW_READ;
      break;
 
      case FSM_PROCESSING_WAIT_FOR_DDR_CONTROLLER_EMPTYNESS:
      #if DEBUG_LEVEL == TRACE_ALL
        printf("DEBUG processing the output of a run\n");
      #endif
        emptycntr++;
        if(emptycntr==DDR_LATENCY+1){
          processingFSM = FSM_PROCESSING_DATAFLOW_READ;
          emptycntr=0;
        }
      break;
 
      case FSM_PROCESSING_DATAFLOW_READ:
#if DEBUG_LEVEL == TRACE_ALL 
      printf("DEBUG processing read dataflow\n");
#endif
      pReadDataflowMemTest<top_param_maximum_number_of_beats>(lcl_mem1, 
      tmp_wordaligned_address ,&reading_cntr,&faulty_addresses_cntr, &first_faulty_address,burst_size);
      processingFSM = FSM_PROCESSING_OUTPUT;
      break;
 
      case FSM_PROCESSING_OUTPUT:
    #if DEBUG_LEVEL == TRACE_ALL
      printf("DEBUG processing the output of a run\n");
    #endif
      if(!sProcpToTxp_Data.full()){
          outNetWord.tdata = max_address_under_test;
          outNetWord.tkeep = 0xFF;
          outNetWord.tlast = 0;
          sProcpToTxp_Data.write(outNetWord);
          bytes_sent_for_tx += 8;
          processingFSM = FSM_PROCESSING_OUTPUT_2;
      }
      break;
 
      case FSM_PROCESSING_OUTPUT_2:
    #if DEBUG_LEVEL == TRACE_ALL
    #ifndef __SYNTHESIS__
      printf("DEBUG processing the output of a run part 2; faulty address cntr %s\n",faulty_addresses_cntr.to_string().c_str());
    #endif
    #endif
      if(!sProcpToTxp_Data.full()){
          outNetWord.tdata=faulty_addresses_cntr;
          outNetWord.tkeep = 0xFF;
          outNetWord.tlast = 0;
          sProcpToTxp_Data.write(outNetWord);
          bytes_sent_for_tx += 8 ;
          processingFSM = FSM_PROCESSING_OUTPUT_3;
      }
      break;
      case FSM_PROCESSING_OUTPUT_3:
    #if DEBUG_LEVEL == TRACE_ALL
    #ifndef __SYNTHESIS__
      printf("DEBUG processing the output of a run part 3: first faulty address %s\n",first_faulty_address.to_string().c_str());
    #endif
    #endif
      if(!sProcpToTxp_Data.full()){
          outNetWord.tdata=first_faulty_address;
          outNetWord.tkeep = 0xFF;
          outNetWord.tlast = 0;
          sProcpToTxp_Data.write(outNetWord);
          bytes_sent_for_tx += 8;
          processingFSM = FSM_PROCESSING_OUTPUT_4;
      }
      break;
      case FSM_PROCESSING_OUTPUT_4:
    #if DEBUG_LEVEL == TRACE_ALL
      printf("DEBUG processing the output of a run part 4\n");
    #endif
      if(!sProcpToTxp_Data.full()){
          outNetWord.tdata = writing_cntr;
          outNetWord.tkeep = 0xFF;
          outNetWord.tlast = 0;
          sProcpToTxp_Data.write(outNetWord);
          bytes_sent_for_tx += 8;
          processingFSM = FSM_PROCESSING_OUTPUT_5;
      }
      break;
      case FSM_PROCESSING_OUTPUT_5:
    #if DEBUG_LEVEL == TRACE_ALL
      printf("DEBUG processing the output of a run part 4\n");
    #endif
      if(!sProcpToTxp_Data.full()){
          outNetWord.tdata= reading_cntr; 
          outNetWord.tkeep = 0xFF;
          outNetWord.tlast = 0;
          sProcpToTxp_Data.write(outNetWord);
          bytes_sent_for_tx += 8;
          processingFSM = FSM_PROCESSING_CONTINUOUS_RUN;
      }
      break;
 
    }
};

pTXPath()

void pTXPath	(	stream< NetworkWord > &	soTHIS_Shl_Data,
		stream< NetworkMetaStream > &	soNrc_meta,
		stream< NetworkWord > &	sProcpToTxp_Data,
		stream< NetworkMetaStream > &	sRxtoTx_Meta,
		stream< NodeId > &	sDstNode_sig,
		unsigned int *	processed_word_tx,
		ap_uint< 32 > *	pi_rank
	)

Transmit Path - From THIS to SHELL.

Parameters

[out]	soTHIS_Shl_Data
[out]	soNrc_meta
[in]	sProcpToTxp_Data
[in]	sRxtoTx_Meta
[in]	pi_rank
[in]	sDstNode_sig

Returns

Nothing.

Definition at line 251 of file memtest_library.hpp.

{
    //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
    //#pragma HLS DATAFLOW interval=1
    #pragma  HLS INLINE off
    //-- LOCAL VARIABLES ------------------------------------------------------
    NetworkWord      netWordTx;
    NetworkMeta  meta_in = NetworkMeta();
    static NodeId dst_rank;
    static PacketFsmType dequeueFSM = WAIT_FOR_META;
    #pragma HLS reset variable=dequeueFSM
  
  switch(dequeueFSM)
  {
    case WAIT_FOR_META:
      if(!sDstNode_sig.empty())
      {
        dst_rank = sDstNode_sig.read();
        dequeueFSM = WAIT_FOR_STREAM_PAIR;
        //Triangle app needs to be reset to process new rank
      }
      break;
    case WAIT_FOR_STREAM_PAIR:
    #if DEBUG_LEVEL == TRACE_ALL
      printf("DEBUG in pTXPath: dequeueFSM=%d - WAIT_FOR_STREAM_PAIR, *processed_word_tx=%u\n", 
       dequeueFSM, *processed_word_tx);
    #endif
      //-- Forward incoming chunk to SHELL
      *processed_word_tx = 0;
 
      if (( !sProcpToTxp_Data.empty() && !sRxtoTx_Meta.empty() 
          && !soTHIS_Shl_Data.full() &&  !soNrc_meta.full() )) 
      {
        netWordTx = sProcpToTxp_Data.read();
 
  // in case MTU=8 ensure tlast is set in WAIT_FOR_STREAM_PAIR and don't visit PROCESSING_PACKET
  if (PACK_SIZE == 8) 
  {
      netWordTx.tlast = 1;
  }
        soTHIS_Shl_Data.write(netWordTx);
 
        meta_in = sRxtoTx_Meta.read().tdata;
        NetworkMetaStream meta_out_stream = NetworkMetaStream();
        meta_out_stream.tlast = 1;
        meta_out_stream.tkeep = 0xFF; //just to be sure
 
        meta_out_stream.tdata.dst_rank = dst_rank;
        meta_out_stream.tdata.src_rank = (NodeId) *pi_rank;
        meta_out_stream.tdata.dst_port = meta_in.src_port;
        meta_out_stream.tdata.src_port = meta_in.dst_port;
 
        soNrc_meta.write(meta_out_stream);
 
        (*processed_word_tx)++;
  
        if(netWordTx.tlast != 1)
        {
          dequeueFSM = PROCESSING_PACKET;
        }
      }
      break;
 
    case PROCESSING_PACKET: 
    #if DEBUG_LEVEL == TRACE_ALL
      printf("DEBUG in pTXPath: dequeueFSM=%d - PROCESSING_PACKET, *processed_word_tx=%u\n", 
       dequeueFSM, *processed_word_tx);
    #endif
      if( !sProcpToTxp_Data.empty() && !soTHIS_Shl_Data.full())
      {
        netWordTx = sProcpToTxp_Data.read();
 
  // This is a normal termination of the axi stream from vitis functions
  if(netWordTx.tlast == 1)
  {
    dequeueFSM = WAIT_FOR_STREAM_PAIR;
  }
  
  // This is our own termination based on the custom MTU we have set in PACK_SIZE.
  // TODO: We can map PACK_SIZE to a dynamically assigned value either through MMIO or header
  //       in order to have a functional bitstream for any MTU size
  (*processed_word_tx)++;
  if (((*processed_word_tx)*8) % PACK_SIZE == 0) 
  {
      netWordTx.tlast = 1;
      dequeueFSM = WAIT_FOR_STREAM_PAIR;
  }
  
        soTHIS_Shl_Data.write(netWordTx);
      }
      break;
  }
}

Here is the caller graph for this function:

pWRGenerateData2WriteOnStream()

template<const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 16>

void pWRGenerateData2WriteOnStream	(	hls::stream< local_mem_word_t > &	sOutGeneratedData,
		ap_uint< 32 > *	testCounter,
		local_mem_addr_t	max_addr_ut
	)

A function that generate a streams of data according to function and writes them on a stream CHECK: FAULT_INJECTION define insert after the third test some faults.

Parameters

[out]	sOutGeneratedData	the output stream for deta generation
[in]	max_addr_ut	the maximum address to test
[in]	testCounter	the current times of re-executing this test

Returns

Nothing.

Definition at line 164 of file memtest_pattern_library.hpp.

{
#pragma HLS INLINE off
    static local_mem_word_t tmp_out [buff_dim];
#pragma HLS array_partition variable=tmp_out cyclic factor=2 dim=1
 
    static local_mem_addr_t curr_address_ut=0;
  generate_loop:
  for (; curr_address_ut < max_addr_ut; )
  {
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_iterations
//if free to generate or need backpressure
    if (!sOutGeneratedData.full())
    {
      //Step 1) Generated the data according to a function
 
      //  genXoredSequentialNumbersSecondVersion
      //  <local_mem_addr_non_byteaddressable_t, LOCAL_MEM_WORD_SIZE/32, local_mem_word_t,
      //   ap_uint<32>,32>(maddr_non_byte, 
      //    tmp_out+(maddr_non_byte));
      //genSequentialNumbers<local_mem_addr_non_byteaddressable_t,local_mem_word_t>(curr_address_ut*64, tmp_out+(maddr_non_byte));
      genXoredNumbersSingleWord<local_mem_addr_t,
      local_mem_word_t>(curr_address_ut, tmp_out+(curr_address_ut%buff_dim));
 
//Step 2) Optional fault injection
      local_mem_word_t tmp_out_scalar;
      #ifdef FAULT_INJECTION
          //TODO:  place for control fault injection with a function?
          if(*testCounter >= 2 && curr_address_ut > 0){
              tmp_out_scalar = tmp_out[curr_address_ut%buff_dim] & static_cast<local_mem_word_t>(0);
            }else{
              tmp_out_scalar = tmp_out[curr_address_ut%buff_dim];
            }
      #else // FAULT_INJECTION
        tmp_out_scalar = tmp_out[curr_address_ut%buff_dim];
      #endif // FAULT_INJECTION
      //Step 3) write out to the next macrostep and going to the next element
      sOutGeneratedData.write(tmp_out_scalar);
      curr_address_ut++;
    }
    //else account for a newer cycle to write
  }
  curr_address_ut=0;
  
 
}

Here is the call graph for this function:

pWriteDataflowMemTest()

template<const unsigned int maximum_number_of_beats = 512>

void pWriteDataflowMemTest	(	membus_t *	lcl_mem0,
		local_mem_addr_t	max_address_under_test,
		ap_uint< 64 > *	writing_cntr,
		ap_uint< 32 > *	testCounter,
		unsigned int	burst_size
	)

Definition at line 76 of file memtest_processing.hpp.

{
  #pragma HLS INLINE off
     static hls::stream<ap_uint<64>> sWritePrfCntr_cmd("sWritePrfCntr_cmd"); 
     #pragma HLS STREAM variable=sWritePrfCntr_cmd depth=64 dim=1
     static hls::stream<local_mem_word_t> generatedWriteData("generatedWriteData"); 
     #pragma HLS STREAM variable=generatedWriteData depth=64 dim=1
    #pragma HLS DATAFLOW
 
    #ifdef SIMPLER_BANDWIDTH_TEST
          //Step 1 write data
          pWriteSimplerTestMemTest<ap_uint<64>>(sWritePrfCntr_cmd, lcl_mem0, max_address_under_test, burst_size);
          //Step 2 count
          perfCounterProc2MemCountOnly<ap_uint<64>,ap_uint<64>,64>(sWritePrfCntr_cmd, writing_cntr);
    #else
          //Step 1: Generate the data
          pWRGenerateData2WriteOnStream<4000000>(generatedWriteData,testCounter,max_address_under_test);
          //Step 2: write 
          pWRStream2WriteMainMemory<ap_uint<64>,4000000,maximum_number_of_beats>(sWritePrfCntr_cmd, generatedWriteData, lcl_mem0, max_address_under_test, burst_size);
          //Step 2.b: count 
          perfCounterMultipleCounts<ap_uint<64>,ap_uint<64>,64>(sWritePrfCntr_cmd, writing_cntr);
    #endif     
}

pWriteSimplerTestMemTest()

template<typename Tcntr , const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 64*2>

void pWriteSimplerTestMemTest	(	hls::stream< Tcntr > &	sOutCmd,
		membus_t *	lcl_mem,
		local_mem_addr_t	max_addr_ut,
		unsigned int	burst_size
	)

Simple version of a write memtest that write up to a given maximum address No control on the burst size or on the first faulty address.

Parameters

[out]	sOutCmd	the perf counter cmd stream
[in]	lcl_mem	the virtual memory mapped pointer
[in]	max_addr_ut	the maximum address to test
[in]	burst_size	the run-time variable burst size NOT MEANINGFUL HERE

Returns

Nothing.

Definition at line 343 of file memtest_pattern_library.hpp.

{
//Step 1) start counting
  sOutCmd.write(0);
  local_mem_addr_t curr_address_ut;
//Step 2) write a simple pattern
  for (curr_address_ut = 0; curr_address_ut < max_addr_ut; curr_address_ut++)
  {
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_iterations
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
    printf("Writing address %s with max %s\n",curr_address_ut.to_string().c_str(), max_addr_ut.to_string().c_str());
    #endif
    #endif
    lcl_mem[curr_address_ut]=curr_address_ut+1;
  }
//Step 3) stop counting
  sOutCmd.write(0);
}

pWRStream2WriteMainMemory()

template<typename Tcntr , const unsigned int max_iterations = 4000000, const unsigned int buff_dim = 64*2>

void pWRStream2WriteMainMemory	(	hls::stream< Tcntr > &	sOutCmd,
		hls::stream< local_mem_word_t > &	sInGeneratedData,
		membus_t *	lcl_mem,
		local_mem_addr_t	max_addr_ut,
		unsigned int	burst_size
	)

A function that read a stream of data and write them in a run-time variable burst-size.

Parameters

[out]	sOutCmd	the output stream for cmd generation
[in]	sInGeneratedData	the input stream of generated data
[out]	lcl_mem	the memory mapped ptr
[in]	max_addr_ut	the maximum address to test
[in]	burst_size	the run-time variable burst size to write

Returns

Nothing.

Definition at line 228 of file memtest_pattern_library.hpp.

{
#pragma HLS INLINE off
    local_mem_addr_t curr_address_ut;
    local_mem_addr_t curr_writing_addr;
    static local_mem_word_t tmp_out[buff_dim];
    static unsigned int end_distance=0;
    static bool last_iteration = false;
    static bool activated_cntr = false;
#pragma HLS array_partition variable=tmp_out block factor=2 dim=1
 
  int idx, written_i;
  int ptrs_difference=0;
  unsigned int last_words=max_addr_ut;
  unsigned int maximum_usable_fifo_words=buff_dim-buff_dim%burst_size;
  read_and_write:
  for (curr_address_ut = 0, idx=0, curr_writing_addr=0, written_i=0; curr_address_ut < max_addr_ut; curr_address_ut++)
  {
#pragma HLS PIPELINE II=1
#pragma HLS LOOP_TRIPCOUNT min = 1 max = max_iterations
    if (!sInGeneratedData.empty())
    {
      tmp_out[idx] = sInGeneratedData.read();
        #if DEBUG_LEVEL == TRACE_ALL
        #ifndef __SYNTHESIS__
        std::cout << tmp_out[idx] << std::endl;
        #endif//synth
        #endif//debug lvl
      //if stored enough data to begin the bursting OR this is last iteration
      end_distance = max_addr_ut-curr_address_ut;
      last_iteration = 1>=end_distance;
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
      std::cout << "test addr " << idx << " current address " << curr_address_ut << " max addr " << max_addr_ut << std::endl;
      std::cout << "ptrs_difference " << ptrs_difference << " last_iteration " << last_iteration <<std::endl;
      #endif
      #endif
//accumulated a burst or last iteration
      if ((ptrs_difference>0 && ptrs_difference>=burst_size-1) || (last_iteration))
      {
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
      std::cout << "Burst filled or last iteration, end distance will be= " << end_distance << std::endl;
      #endif
      #endif
        if (!last_iteration)
        {
      #if DEBUG_LEVEL == TRACE_ALL
      #ifndef __SYNTHESIS__
          std::cout << "BURST transferring " << burst_size << " words at " << curr_writing_addr << " address, from  " << written_i << std::endl;
      #endif
      #endif
          if(!activated_cntr){
            sOutCmd.write(0);
            activated_cntr = true;
          }else{
            sOutCmd.write(1);
          }
          memcpy(lcl_mem+curr_writing_addr, tmp_out+written_i, sizeof(local_mem_word_t)*burst_size);
          sOutCmd.write(1);
          curr_writing_addr+=burst_size;
          written_i= (written_i+burst_size)%maximum_usable_fifo_words;
          ptrs_difference-=burst_size;
          last_words=end_distance;
        }else{
      #if DEBUG_LEVEL == TRACE_ALL
      //#ifndef __SYNTHESIS__
          std::cout << "LAST transferring " << last_words << " words at " << curr_writing_addr << " address, from  " << written_i << std::endl;
      //#endif
      #endif
          if(!activated_cntr){
            sOutCmd.write(0);
            activated_cntr = true;
          }else{
            sOutCmd.write(1);
          }
          memcpy(lcl_mem+curr_writing_addr, tmp_out+written_i, sizeof(local_mem_word_t)*(last_words));
          sOutCmd.write(1);
          curr_writing_addr+=(last_words);
          written_i=(written_i+last_words)%maximum_usable_fifo_words;
          ptrs_difference-=last_words;
        }
      }
      if(idx==maximum_usable_fifo_words-1){
        idx=0;
      }else{
        idx++;
      }
      ptrs_difference++;
    }else{
      curr_address_ut--;
    }
  }
    sOutCmd.write(0);//quit everything
    end_distance=0;
    last_iteration = false;
}

Variable Documentation

max_counter_cc

const unsigned long int max_counter_cc = 4000000

Definition at line 540 of file memtest_library.hpp.

top_param_maximum_number_of_beats

const unsigned int top_param_maximum_number_of_beats = 4096

Definition at line 69 of file memtest_processing.hpp.