MedianBlur Testbench

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

Collaboration diagram for MedianBlur Testbench:

Files
file	median_blur_host_fwd_tb.cpp
	Testbench for MedianBlur userspace application for cF (x86, ppc64).
file	xf_ocv_ref.hpp
	The MedianBlur reference functions used in TB.
file	test_median_blur.cpp
	: Testbench for MedianBlur.

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

Functions
int	main (int argc, char *argv[])
void	ocv_ref (cv::Mat img_gray, cv::Mat &ocv_out_img, int ksize)
stream< UdpWord >	sSHL_Uaf_Data ("sSHL_Uaf_Data")
stream< UdpWord >	sUAF_Shl_Data ("sUAF_Shl_Data")
stream< UdpWord >	image_stream_from_median_blur ("image_stream_from_median_blur")
stream< NetworkMetaStream >	siUdp_meta ("siUdp_meta")
stream< NetworkMetaStream >	soUdp_meta ("soUdp_meta")
stream< DmCmd >	sROL_Shl_Mem_RdCmdP0 ("sROL_Shl_Mem_RdCmdP0")
stream< DmSts >	sSHL_Rol_Mem_RdStsP0 ("sSHL_Rol_Mem_RdStsP0")
stream< Axis< 512 > >	sSHL_Rol_Mem_ReadP0 ("sSHL_Rol_Mem_ReadP0")
stream< DmCmd >	sROL_Shl_Mem_WrCmdP0 ("sROL_Shl_Mem_WrCmdP0")
stream< DmSts >	sSHL_Rol_Mem_WrStsP0 ("sSHL_Rol_Mem_WrStsP0")
stream< Axis< 512 > >	sROL_Shl_Mem_WriteP0 ("sROL_Shl_Mem_WriteP0")
void	stepDut ()
	Run a single iteration of the DUT model. More...
int	main (int argc, char **argv)
	Main testbench of Hrris. More...

Variables
ap_uint< 1 >	piSHL_This_MmioPostPktEn
ap_uint< 1 >	piSHL_This_MmioCaptPktEn
ap_uint< 32 >	s_udp_rx_ports = 0x0
ap_uint< 32 >	node_rank
ap_uint< 32 >	cluster_size
membus_t	lcl_mem0 [(1+(IMGSIZE - 1)/(512/8))]
membus_t	lcl_mem1 [(1+(IMGSIZE - 1)/(512/8))]
int	simCnt

Detailed Description

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

Macro Definition Documentation

DEBUG_LEVEL

#define DEBUG_LEVEL   (TRACE_ALL)

Definition at line 53 of file test_median_blur.cpp.

DEBUG_TRACE

#define DEBUG_TRACE   true

Definition at line 63 of file test_median_blur.cpp.

DISABLED

#define DISABLED   (ap_uint<1>)0

Definition at line 72 of file test_median_blur.cpp.

ENABLE_DDR_EMULATE_DELAY_IN_TB

#define ENABLE_DDR_EMULATE_DELAY_IN_TB

Definition at line 69 of file test_median_blur.cpp.

ENABLED

#define ENABLED   (ap_uint<1>)1

Definition at line 71 of file test_median_blur.cpp.

KO

#define KO   false

Definition at line 60 of file test_median_blur.cpp.

MEMORY_LINES_512

#define MEMORY_LINES_512   TOTMEMDW_512 /* 64 KiB */

Definition at line 112 of file test_median_blur.cpp.

OK

#define OK   true

Definition at line 59 of file test_median_blur.cpp.

TB_TRIALS

#define TB_TRIALS   2

Definition at line 66 of file test_median_blur.cpp.

THIS_NAME

#define THIS_NAME   "TB"

Definition at line 45 of file test_median_blur.cpp.

TRACE_ALL

#define TRACE_ALL   0xFFFF

Definition at line 51 of file test_median_blur.cpp.

TRACE_MMIO

#define TRACE_MMIO   1 << 3

Definition at line 50 of file test_median_blur.cpp.

TRACE_OFF

#define TRACE_OFF   0x0000

Definition at line 47 of file test_median_blur.cpp.

TRACE_UAF

#define TRACE_UAF   1 << 2

Definition at line 49 of file test_median_blur.cpp.

TRACE_URIF

#define TRACE_URIF   1 << 1

Definition at line 48 of file test_median_blur.cpp.

UNVALID

#define UNVALID   false

Definition at line 62 of file test_median_blur.cpp.

VALID

#define VALID   true

Definition at line 61 of file test_median_blur.cpp.

Function Documentation

image_stream_from_median_blur()

stream<UdpWord> image_stream_from_median_blur

(

"image_stream_from_median_blur"

)

main() [1/2]

int main	(	int	argc,
		char **	argv
	)

Main testbench of Hrris.

Returns

0 upon success, nrErr else.

hls_out_img.data = (unsigned char *)imgOutput.copyFrom();

Definition at line 157 of file test_median_blur.cpp.

                                {
 
    //------------------------------------------------------
    //-- TESTBENCH LOCAL VARIABLES
    //------------------------------------------------------
    int nrErr;
    unsigned int tb_trials = 0;
 
    printf("#####################################################\n");
    printf("## MAIN TESTBENCH STARTS HERE                      ##\n");
    printf("#####################################################\n");
 
    
    //------------------------------------------------------
    //-- TESTBENCH LOCAL VARIABLES FOR MEDIANBLUR
    //------------------------------------------------------
    cv::Mat in_img, img_gray;
    cv::Mat hls_out_img, ocv_out_img;
 
    if (argc != 2) {
        printf("Usage : %s <input image> \n", argv[0]);
        return -1;
    }
    in_img = cv::imread(argv[1], 0); // reading in the color image
 
    if (!in_img.data) {
        printf("ERROR: Failed to load the image ... %s\n!", argv[1]);
        return -1;
    }
    else {
      printf("INFO: Succesfully loaded image ... %s\n", argv[1]);
      if (in_img.total() != FRAME_WIDTH * FRAME_HEIGHT) {
        printf("WARNING: Resizing input image %s from [%u x %u] to  [%u x %u] !\n", argv[1], in_img.rows, in_img.cols, FRAME_WIDTH, FRAME_HEIGHT);
        cv::resize(in_img, in_img, cv::Size(FRAME_WIDTH, FRAME_HEIGHT), 0, 0, cv::INTER_LINEAR);
      }
      // Ensure that the selection of MTU is a multiple of 8 (Bytes per transaction)
      assert(PACK_SIZE % 8 == 0);
    }
 
    #ifdef ENABLE_DDR
    memset(lcl_mem0,  0x0, sizeof(lcl_mem0));
    memset(lcl_mem1,  0x0, sizeof(lcl_mem1));
    
    DmCmd           dmCmd_MemCmdP0;
    DmSts           dmSts_MemWrStsP0;
    DmSts           dmSts_MemRdStsP0;
    Axis<MEMDW_512> memP0;
    ap_uint<64>     currentMemPattern = 0;
  
    unsigned int ddr_addr_in = 0x0;
    unsigned int ddr_write_req_iter = 0;
    unsigned int wait_cycles_to_ack_ddr_status = 0;
    unsigned int count_cycles_to_ack_ddr_status = 0;
    bool ddr_write_sts_req = false;
    #endif
    
 
    //------------------------------------------------------
    //-- STEP-1.1 : CREATE MEMORY FOR OUTPUT IMAGES
    //------------------------------------------------------
    //  cvtColor(in_img, img_gray, CV_BGR2GRAY);
    // Convert rgb into grayscale
    hls_out_img.create(in_img.rows, in_img.cols, CV_8U); // create memory for hls output image
    ocv_out_img.create(in_img.rows, in_img.cols, CV_8U); // create memory for opencv output image
 
    #if NO
    static xf::cv::Mat<TYPE, HEIGHT, WIDTH, XF_NPPC1> imgInput(in_img.rows, in_img.cols);
    static xf::cv::Mat<TYPE, HEIGHT, WIDTH, XF_NPPC1> imgOutput(in_img.rows, in_img.cols);
    static xf::cv::Mat<TYPE, HEIGHT, WIDTH, XF_NPPC1> imgOutputTb(in_img.rows, in_img.cols);
    imgInput.copyTo(in_img.data);
    ap_uint<INPUT_PTR_WIDTH>  *imgInputArray    = (ap_uint<INPUT_PTR_WIDTH>*)  malloc(in_img.rows * in_img.cols * sizeof(ap_uint<INPUT_PTR_WIDTH>));
    ap_uint<OUTPUT_PTR_WIDTH> *imgOutputArrayTb = (ap_uint<OUTPUT_PTR_WIDTH>*) malloc(in_img.rows * in_img.cols * sizeof(ap_uint<OUTPUT_PTR_WIDTH>));
    ap_uint<OUTPUT_PTR_WIDTH> *imgOutputArray   = (ap_uint<OUTPUT_PTR_WIDTH>*) malloc(in_img.rows * in_img.cols * sizeof(ap_uint<OUTPUT_PTR_WIDTH>));
    xf::cv::xfMat2Array<INPUT_PTR_WIDTH, TYPE, HEIGHT, WIDTH, NPIX>(imgInput, imgInputArray);
    #endif
 
    #if RO
    static xf::cv::Mat<TYPE, HEIGHT, WIDTH, XF_NPPC8> imgInput(in_img.rows, in_img.cols);
    static xf::cv::Mat<TYPE, HEIGHT, WIDTH, XF_NPPC8> imgOutput(in_img.rows, in_img.cols);
    static xf::cv::Mat<TYPE, HEIGHT, WIDTH, XF_NPPC1> imgOutputTb(in_img.rows, in_img.cols);
    #endif
    
    while (tb_trials++ < TB_TRIALS) {
   
 
        printf ( "##################################################### \n" );
        printf ( "## TESTBENCH #%u STARTS HERE                        ##\n", tb_trials );
        printf ( "##################################################### \n" );
 
 
        simCnt = 0;
        nrErr  = 0;
 
#if NO
        if ( !dumpImgToFile ( imgInput, "ifsSHL_Uaf_Data.dat", simCnt ) ) {
            nrErr++;
        }
#endif
 
#if RO
        // imgInput.copyTo(img_gray.data);
        imgInput = xf::cv::imread<TYPE, HEIGHT, WIDTH, XF_NPPC8> ( argv[1], 0 );
#endif
 
 
 
        //------------------------------------------------------
        //-- STEP-1.2 : RUN MEDIANBLUR DETECTOR FROM OpenCV LIBRARY
        //------------------------------------------------------
        // ksize: aperture linear size; it must be odd and greater than 1, for example: 3, 5, 7 ...
        int ksize = WINDOW_SIZE ;
        ocv_ref ( in_img, ocv_out_img, ksize);
 
 
 
        //------------------------------------------------------
        //-- STEP-2.1 : CREATE TRAFFIC AS INPUT STREAMS
        //------------------------------------------------------
        if ( nrErr == 0 ) {
            if ( !setInputDataStream ( sSHL_Uaf_Data, "sSHL_Uaf_Data", "ifsSHL_Uaf_Data.dat", simCnt ) ) {
                printf ( "### ERROR : Failed to set input data stream \"sSHL_Uaf_Data\". \n" );
                nrErr++;
            }
 
            //there are TOT_TRANSFERS streams from the the App to the Role
            NetworkMeta tmp_meta = NetworkMeta ( 1,DEFAULT_RX_PORT,0,DEFAULT_RX_PORT,0 );
            for ( int i=0; i<TOT_TRANSFERS; i++ ) {
                siUdp_meta.write ( NetworkMetaStream ( tmp_meta ) );
            }
            //set correct node_rank and cluster_size
            node_rank = 1;
            cluster_size = 2;
        }
 
        //------------------------------------------------------
        //-- STEP-2.2 : SET THE PASS-THROUGH MODE
        //------------------------------------------------------
        //piSHL_This_MmioEchoCtrl.write(ECHO_PATH_THRU);
        //[TODO] piSHL_This_MmioPostPktEn.write(DISABLED);
        //[TODO] piSHL_This_MmioCaptPktEn.write(DISABLED);
 
        //------------------------------------------------------
        //-- STEP-3 : MAIN TRAFFIC LOOP
        //------------------------------------------------------
        while ( !nrErr ) {
 
            // Keep enough simulation time for sequntially executing the FSMs of the main 3 functions
            // (Rx-Proc-Tx)
            if ( simCnt < MIN_RX_LOOPS + MIN_RX_LOOPS + MIN_TX_LOOPS + 10
#ifdef ENABLE_DDR
#ifdef ENABLE_DDR_EMULATE_DELAY_IN_TB 
                + (TYPICAL_DDR_LATENCY + EXTRA_DDR_LATENCY_DUE_II + DDR_LATENCY) * MEMORY_LINES_512
#endif
#endif
               ) {
                stepDut();
 
                if ( simCnt > 2 ) {
                    assert ( s_udp_rx_ports == PORTS_OPENED );
                }
 
if (simCnt < 0)
    exit(0);
#ifdef ENABLE_DDR
 
                if ( !sROL_Shl_Mem_WrCmdP0.empty() ) {
                    printf ( "DEBUG tb: Read a memory write command from SHELL/Mem/Mp0 \n" );
                    //-- Read a memory write command from SHELL/Mem/Mp0
                    sROL_Shl_Mem_WrCmdP0.read ( dmCmd_MemCmdP0 );
                    //assert ( dmCmd_MemCmdP0.bbt == CHECK_CHUNK_SIZE );
                    assert ( dmCmd_MemCmdP0.type == 1 && dmCmd_MemCmdP0.dsa == 0 && dmCmd_MemCmdP0.eof == 1 && dmCmd_MemCmdP0.drr == 1 && dmCmd_MemCmdP0.tag == 0x0 );
                    ddr_addr_in = (unsigned int)dmCmd_MemCmdP0.saddr / BPERMDW_512; // Convert the byte-aligned address to local mem of stack tb.
                    printf ( "DEBUG tb: Requesting writting to address %u (max depth = %u) an amount of %u bytes (%u memory lines), ddr_write_req_iter=%u\n", ddr_addr_in,  MEMORY_LINES_512-1, (unsigned int)dmCmd_MemCmdP0.bbt, (unsigned int)(1 + (dmCmd_MemCmdP0.bbt - 1) / BPERMDW_512), ddr_write_req_iter);
                    assert (ddr_addr_in <= MEMORY_LINES_512-1);
                    //ddr_write_req_iter++;
                    //printf ( "DEBUG tb: (ddr_write_req_iter)%(MEMORY_LINES_512-1)=%u\n", (ddr_write_req_iter)%(MEMORY_LINES_512-1));
                    if ((++ddr_write_req_iter)%(MEMORY_LINES_512) == 0) {
                        ddr_write_req_iter = 0;
                    }
                    printf ( "DEBUG tb: ddr_write_req_iter=%u\n", ddr_write_req_iter);
 
#ifdef ENABLE_DDR_EMULATE_DELAY_IN_TB
                    /*
                     * 16                   ->  emulate a response in 16 cycles
                     * 1                    ->  emulate immediate response
                     * CYCLES_UNTIL_TIMEOUT ->  on purpose timeout
                     */ 
                    if (ddr_write_req_iter == 1) {
                        wait_cycles_to_ack_ddr_status = TYPICAL_DDR_LATENCY;
                    }
                    else if (ddr_write_req_iter == 2) {
                        wait_cycles_to_ack_ddr_status = TYPICAL_DDR_LATENCY;
                    }
                    else {
                        wait_cycles_to_ack_ddr_status = TYPICAL_DDR_LATENCY;
                    }
                    if (!sSHL_Rol_Mem_WrStsP0.empty()) {
                        printf("WARNING: Emptying sSHL_Rol_Mem_WrStsP0 fifo.\n");
                        dmSts_MemWrStsP0  = sSHL_Rol_Mem_WrStsP0.read();
                    }
#else
                    wait_cycles_to_ack_ddr_status = 0;
#endif
                    count_cycles_to_ack_ddr_status = 0;
                    ddr_write_sts_req = false;
                }
 
                if ( !sROL_Shl_Mem_WriteP0.empty() ) {
                    sROL_Shl_Mem_WriteP0.read ( memP0 );
                    printf ( "DEBUG tb: Write a memory line from SHELL/Mem/Mp0 \n" );
 
                    assert ( memP0.tkeep == 0xffffffffffffffff );
 
                    /* Read from AXI stream DDR interface and write to the memory mapped interface of
                     * DDR channel P0. In the real HW, this is enabled by the AXI interconnect and AXI
                     * Datamover, being instantiated in VHDL.
                     * */
                    // printf ( "DEBUG tb: Writting to address 0x%x : %u an amount of %u bytes\n", ddr_addr_in, memP0.tdata.to_long(), BPERMDW_512);
                    std::cout << "DEBUG tb: Writting to address 0x" << std::hex << ddr_addr_in << " : " << memP0.tdata << " an amount of " << std::dec << BPERMDW_512 << " bytes" << std::endl;
                    //lcl_mem0[ddr_addr_in++] = memP0.tdata;
                    memcpy(&lcl_mem0[ddr_addr_in++], &memP0.tdata, BPERMDW_512);
                    ddr_write_sts_req = true;
                }
                // When we have emulated the writting to lcl_mem0, we acknowledge with a P0 status
                if ((ddr_write_sts_req == true) && !sSHL_Rol_Mem_WrStsP0.full() && (memP0.tlast == true)) {
                    if (count_cycles_to_ack_ddr_status++ == wait_cycles_to_ack_ddr_status) {
                        dmSts_MemWrStsP0.tag = 0;
                        dmSts_MemWrStsP0.okay = 1;
                        dmSts_MemWrStsP0.interr = 0;
                        dmSts_MemWrStsP0.slverr = 0;
                        dmSts_MemWrStsP0.decerr = 0;
                        printf ( "DEBUG tb: Write a memory status command to SHELL/Mem/Mp0 \n" );
                            sSHL_Rol_Mem_WrStsP0.write ( dmSts_MemWrStsP0 );
                            ddr_write_sts_req = false;
                    }
                    else{
                        printf ( "DEBUG tb: Waiting to write a memory status command to SHELL/Mem/Mp0 [%u out of %u] cycles\n", count_cycles_to_ack_ddr_status, wait_cycles_to_ack_ddr_status);
                    }
                }
 
 
 
#endif // ENABLE_DDR
 
 
                //if( !soUdp_meta.empty())
                //{
                //  NetworkMetaStream tmp_meta = soUdp_meta.read();
                //  printf("NRC received NRCmeta stream from node_rank %d.\n", (int) tmp_meta.tdata.src_rank);
                //}
 
 
            } else {
#ifdef ENABLE_DDR
                if (!sSHL_Rol_Mem_WrStsP0.empty()) {
                    printf("WARNING: Emptying sSHL_Rol_Mem_WrStsP0 fifo.\n");
                    dmSts_MemWrStsP0  = sSHL_Rol_Mem_WrStsP0.read();
                }
#endif
                printf ( "## End of simulation at cycle=%3d. \n", simCnt );
                break;
            }
 
        }  // End: while()
 
        //-------------------------------------------------------
        //-- STEP-4 : DRAIN AND WRITE OUTPUT FILE STREAMS
        //-------------------------------------------------------
        //---- UAF-->SHELL Data ----
        if ( !getOutputDataStream ( sUAF_Shl_Data, "sUAF_Shl_Data", "ofsUAF_Shl_Data.dat", simCnt ) ) {
            nrErr++;
        }
        //---- UAF-->SHELL META ----
        if ( !soUdp_meta.empty() ) {
            int i = 0;
            while ( !soUdp_meta.empty() ) {
                i++;
                NetworkMetaStream tmp_meta = soUdp_meta.read();
                printf ( "NRC received NRCmeta stream from rank %d to rank %d.\n", ( int ) tmp_meta.tdata.src_rank, ( int ) tmp_meta.tdata.dst_rank );
                assert ( tmp_meta.tdata.src_rank == node_rank );
                //ensure forwarding behavior
                assert ( tmp_meta.tdata.dst_rank == ( ( tmp_meta.tdata.src_rank + 1 ) % cluster_size ) );
            }
            //printf("DEBUG: i=%u\tTOT_TRANSFERS=%u\n", i, TOT_TRANSFERS);
            assert ( i == TOT_TRANSFERS );
        } else {
            printf ( "Error No metadata received...\n" );
            nrErr++;
        }
 
        //-------------------------------------------------------
        //-- STEP-5 : FROM THE OUTPUT FILE CREATE AN ARRAY
        //-------------------------------------------------------
        if ( !setInputFileToArray ( "ofsUAF_Shl_Data.dat", imgOutputArray, simCnt ) ) {
            printf ( "### ERROR : Failed to set input array from file \"ofsUAF_Shl_Data.dat\". \n" );
            nrErr++;
        }
        xf::cv::Array2xfMat<OUTPUT_PTR_WIDTH, TYPE, HEIGHT, WIDTH, NPIX> ( imgOutputArray, imgOutput );
 
 
        //------------------------------------------------------
        //-- STEP-6 : COMPARE INPUT AND OUTPUT FILE STREAMS
        //------------------------------------------------------
        int rc1 = system ( "diff --brief -w -i -y ../../../../test/ofsUAF_Shl_Data.dat \
                                            ../../../../test/verify_UAF_Shl_Data.dat" );
        if ( rc1 ) {
            printf ( "## Error : File \'ofsUAF_Shl_Data.dat\' does not match \'verify_UAF_Shl_Data.dat\'.\n" );
        } else {
            printf ( "Output data in file \'ofsUAF_Shl_Data.dat\' verified.\n" );
        }
 
        nrErr += rc1;
 
        printf ( "#####################################################\n" );
        if ( nrErr ) {
            printf ( "## ERROR - TESTBENCH #%u FAILED (RC=%d) !!!        ##\n", tb_trials, nrErr );
        } else {
            printf ( "## SUCCESSFULL END OF TESTBENCH #%u (RC=0)          ##\n", tb_trials );
        }
        printf ( "#####################################################\n" );
 
 
 
 
 
    } // End tb trials while loop
 
 
 
 
 
 
 
 
    #if NO
 
    // L2 Vitis MedianBlur
    medianBlurAccelArray(imgInputArray, imgOutputArrayTb, in_img.rows, in_img.cols);
    xf::cv::Array2xfMat<OUTPUT_PTR_WIDTH, TYPE, HEIGHT, WIDTH, NPIX>(imgOutputArrayTb, imgOutputTb);
        
    // L1 Vitis MedianBlur 
    //median_blur_accel(imgInput, imgOutput, Thresh, k);
    
    #endif
 
    #if RO
 
    median_blur_accel(imgInput, imgOutputTb);
 
    #endif
 
    xf::cv::imwrite("hls_out_tb.jpg", imgOutputTb);
    xf::cv::imwrite("hls_out.jpg", imgOutput);
    cv::imwrite("ocv_ref_out.jpg", ocv_out_img);
 
    unsigned int val;
    unsigned short int row, col;
 
    cv::Mat out_img;
    out_img = in_img.clone();
 
    std::vector<cv::Point> hls_points;
    std::vector<cv::Point> ocv_points;
    std::vector<cv::Point> common_pts;
 
    xf::cv::Mat<TYPE, HEIGHT, WIDTH, NPIX>* select_imgOutput;
 
    // Select which output you want to process for image outputs and corners comparisons:
    // &imgOutput   : The processed image by MedianBlur IP inside the ROLE (i.e. I/O traffic is passing through SHELL)
    // &imgOutputTb : The processed image by MedianBlur IP in this testbench (i.e. I/O traffic is done in testbench)
    select_imgOutput = &imgOutput;
 
    // Clear memory
    free(imgOutputArrayTb);
    free(imgOutputArray);
    free(imgInputArray);
    
    
    return(nrErr);
}

Here is the call graph for this function:

main() [2/2]

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

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

Returns

O on success, 1 on fail

Definition at line 46 of file median_blur_host_fwd_tb.cpp.

                                  {
 
    if ((argc < 2) || (argc > 3)) { // Test for correct number of parameters
        cerr << "Usage: " << argv[0] << " <Server Port> <optional simulation mode>" << endl;
        exit(1);
    }
 
    if (!isNumeric(argv[1])) {
        cerr << "ERROR: Unidentified provided port : " << argv[1] << " . Aborting..." << endl;
        exit(1);
    }
    
    unsigned short servPort = atoi(argv[1]); // First arg:  local port
    unsigned int num_frame = 0;
    string clean_cmd;
 
#ifdef SHOW_WINDOWS
    namedWindow("tb_recv", WINDOW_AUTOSIZE);
#endif // SHOW_WINDOWS
 
    try {
        #if NET_TYPE == udp
        UDPSocket sock(servPort);
    #else
    TCPServerSocket servSock(servPort);     // Server Socket object
    TCPSocket *servsock = servSock.accept();     // Wait for a client to connect
    #endif
        char buffer[BUF_LEN]; // Buffer for echo string
        int recvMsgSize; // Size of received message
        string sourceAddress; // Address of datagram source
        
    #if NET_TYPE == tcp
    // TCP client handling
    cout << "Handling client ";
    try {
      cout << servsock->getForeignAddress() << ":";
    } catch (SocketException e) {
        cerr << "Unable to get foreign address" << endl;
      }
    try {
      cout << servsock->getForeignPort();
    } catch (SocketException e) {
        cerr << "Unable to get foreign port" << endl;
      }
    cout << endl;
    #endif
        
 
        // RX Step
        clock_t last_cycle_rx = clock();
        while (1) {
            // Block until receive message from a client
    
        int total_pack = 1 + (FRAME_TOTAL - 1) / PACK_SIZE;
            int bytes_in_last_pack = (FRAME_TOTAL) - (total_pack - 1) * PACK_SIZE;      
        int receiving_now = PACK_SIZE;
            cout << " ___________________________________________________________________ " << endl;
            cout << "/                                                                   \\" << endl;
        cout << "INFO: Proxy tb Frame # " << ++num_frame << endl;       
            cout << "INFO: Expecting length of packs:" << total_pack << endl;
            char * longbuf = new char[PACK_SIZE * total_pack];
        
        // RX Loop
            for (int i = 0; i < total_pack; i++) {
            if ( i == total_pack - 1 ) {
                    receiving_now = bytes_in_last_pack;
                }
        #if NET_TYPE == udp
                recvMsgSize = sock.recvFrom(buffer, BUF_LEN, sourceAddress, servPort);
        #else
        recvMsgSize = servsock->recv(buffer, receiving_now);
        #endif
                if (recvMsgSize != receiving_now) {
                    cerr << "ERROR: Received unexpected size pack:" << recvMsgSize << endl;
                    continue;
                }
                memcpy( & longbuf[i * PACK_SIZE], buffer, receiving_now);
            }
 
            cout << "INFO: Received packet from " << sourceAddress << ":" << servPort << endl;
 
            cv::Mat frame = cv::Mat(FRAME_HEIGHT, FRAME_WIDTH, INPUT_TYPE_HOST, longbuf); // OR vec.data() instead of ptr
        if (frame.size().width == 0) {
                cerr << "ERROR: receive failure!" << endl;
                continue;
            }
#ifdef SHOW_WINDOWS
            imshow("tb_recv", frame);
#endif // SHOW_WINDOWS
 
        // We save the image received from network in order to process it with the median_blur HLS TB
        imwrite("../../../../../../ROLE/vision/hls/median_blur/test/input_from_udp_to_fpga.png", frame);
        
        // Select simulation mode, default fcsim
        string synth_cmd = " ";
        string exec_cmd = "make fcsim -j 4";
        string ouf_file = "../../../../../../ROLE/vision/hls/median_blur/median_blur_prj/solution1/fcsim/build/hls_out.jpg";
        if (argc == 3) {
          if (atoi(argv[2]) == 2) {
        exec_cmd = "make csim";
        ouf_file = "../../../../../../ROLE/vision/hls/median_blur/median_blur_prj/solution1/csim/build/hls_out.jpg";
          }
          else if (atoi(argv[2]) == 3) {
        synth_cmd = "make csynth && ";
        exec_cmd = "make cosim";
        ouf_file = "../../../../../../ROLE/vision/hls/median_blur/median_blur_prj/solution1/sim/wrapc_pc/hls_out.jpg";
          }
          else if (atoi(argv[2]) == 4) {
        exec_cmd = "make kcachegrind";
        ouf_file = "../../../../../../ROLE/vision/hls/median_blur/median_blur_prj/solution1/fcsim/build/hls_out.jpg";
          }
        }
        // Calling the actual TB over its typical makefile procedure, but passing the save file
        // Skip the rebuilding phase on the 2nd run. However ensure that it's a clean recompile
        // the first time.
        clean_cmd = " ";
        if (num_frame == 1) {
          clean_cmd = "make clean && ";
        }
        string str_command = "cd ../../../../../../ROLE/vision/hls/median_blur/ && " + clean_cmd + synth_cmd + "\
                  INPUT_IMAGE=./test/input_from_udp_to_fpga.png " + exec_cmd + " && \
                  cd ../../../../HOST/vision/median_blur/languages/cplusplus/build/ "; 
        const char *command = str_command.c_str(); 
        cout << "Calling TB with command:" << command << endl; 
        system(command); 
 
            free(longbuf);
 
        clock_t next_cycle_rx = clock();
            double duration_rx = (next_cycle_rx - last_cycle_rx) / (double) CLOCKS_PER_SEC;
            cout << "INFO: Effective FPS RX:" << (1 / duration_rx) << " \tkbps:" << (PACK_SIZE * 
                    total_pack / duration_rx / 1024 * 8) << endl;
            last_cycle_rx = next_cycle_rx;
    
 
        // TX step
        frame = cv::imread(ouf_file, cv::IMREAD_GRAYSCALE); // reading in the image in grey scale
        if (!frame.data) {
          cerr << "ERROR: Failed to load the image " << ouf_file << endl; 
          return -1;
        }
        else {
          cout << "INFO: Succesfully loaded image " << ouf_file << endl; 
        }
            
        assert(frame.total() == FRAME_WIDTH * FRAME_HEIGHT);
        
            imshow("tb_send", frame);
        
        // Ensure that the send Mat is in continuous memory space. Typically, imread or resize 
        // will return such a continuous Mat, but we should check it.
        assert(frame.isContinuous());
        
        // TX Loop
        unsigned int sending_now = PACK_SIZE;
        clock_t last_cycle_tx = clock();
            for (int i = 0; i < total_pack; i++) {
                if ( i == total_pack - 1 ) {
                    sending_now = bytes_in_last_pack;
        }
        #if NET_TYPE == udp
        sock.sendTo( & frame.data[i * PACK_SIZE], sending_now, sourceAddress, servPort);
        #else
        //sock.send( & frame.data[i * PACK_SIZE], sending_now);
        servsock->send( & frame.data[i * PACK_SIZE], sending_now);
        #endif
        }
            
            clock_t next_cycle_tx = clock();
            double duration_tx = (next_cycle_tx - last_cycle_tx) / (double) CLOCKS_PER_SEC;
            cout << "INFO: Effective FPS TX:" << (1 / duration_tx) << " \tkbps:" << (PACK_SIZE * 
                    total_pack / duration_tx / 1024 * 8) << endl;
            last_cycle_tx = next_cycle_tx; 
            cout << "\\___________________________________________________________________/" << endl;
        break;} // while loop
        #if NET_TYPE == tcp
        delete servsock;
    #endif
    } catch (SocketException & e) {
        cerr << e.what() << endl;
        exit(1);
    }
    return 0;
}

Here is the call graph for this function:

ocv_ref()

void ocv_ref	(	cv::Mat	img_gray,
		cv::Mat &	ocv_out_img,
		int	ksize
	)

Definition at line 62 of file xf_ocv_ref.hpp.

                                                            {
 
    cv::medianBlur (img_gray, ocv_out_img, ksize);
 
}

siUdp_meta()

stream<NetworkMetaStream> siUdp_meta

(

"siUdp_meta"

)

Here is the caller graph for this function:

soUdp_meta()

stream<NetworkMetaStream> soUdp_meta

(

"soUdp_meta"

)

Here is the caller graph for this function:

sROL_Shl_Mem_RdCmdP0()

stream<DmCmd> sROL_Shl_Mem_RdCmdP0

(

"sROL_Shl_Mem_RdCmdP0"

)

Here is the caller graph for this function:

sROL_Shl_Mem_WrCmdP0()

stream<DmCmd> sROL_Shl_Mem_WrCmdP0

(

"sROL_Shl_Mem_WrCmdP0"

)

Here is the caller graph for this function:

sROL_Shl_Mem_WriteP0()

stream<Axis< 512 > > sROL_Shl_Mem_WriteP0

(

"sROL_Shl_Mem_WriteP0"

)

Here is the caller graph for this function:

sSHL_Rol_Mem_RdStsP0()

stream<DmSts> sSHL_Rol_Mem_RdStsP0

(

"sSHL_Rol_Mem_RdStsP0"

)

Here is the caller graph for this function:

sSHL_Rol_Mem_ReadP0()

stream<Axis< 512 > > sSHL_Rol_Mem_ReadP0

(

"sSHL_Rol_Mem_ReadP0"

)

Here is the caller graph for this function:

sSHL_Rol_Mem_WrStsP0()

stream<DmSts> sSHL_Rol_Mem_WrStsP0

(

"sSHL_Rol_Mem_WrStsP0"

)

Here is the caller graph for this function:

sSHL_Uaf_Data()

stream<UdpWord> sSHL_Uaf_Data

(

"sSHL_Uaf_Data"

)

Here is the caller graph for this function:

stepDut()

void stepDut

(

)

Run a single iteration of the DUT model.

Returns

Nothing.

Definition at line 127 of file test_median_blur.cpp.

               {
    median_blur(
        &node_rank, &cluster_size,
        sSHL_Uaf_Data, sUAF_Shl_Data,
        siUdp_meta, soUdp_meta,
        &s_udp_rx_ports
        #ifdef ENABLE_DDR
                        ,
        // sROL_Shl_Mem_RdCmdP0,
        // sSHL_Rol_Mem_RdStsP0,
        // sSHL_Rol_Mem_ReadP0,
        sROL_Shl_Mem_WrCmdP0,
        sSHL_Rol_Mem_WrStsP0,
        sROL_Shl_Mem_WriteP0,
        lcl_mem0,
        lcl_mem1
      #endif
      );
    simCnt++;
    printf("[%4.4d] STEP DUT \n", simCnt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sUAF_Shl_Data()

stream<UdpWord> sUAF_Shl_Data

(

"sUAF_Shl_Data"

)

Here is the caller graph for this function:

Variable Documentation

cluster_size

ap_uint<32> cluster_size

Definition at line 93 of file test_median_blur.cpp.

lcl_mem0

membus_t lcl_mem0[(1+(IMGSIZE - 1)/(512/8))]

Definition at line 113 of file test_median_blur.cpp.

lcl_mem1

membus_t lcl_mem1[(1+(IMGSIZE - 1)/(512/8))]

Definition at line 114 of file test_median_blur.cpp.

node_rank

ap_uint<32> node_rank

Definition at line 92 of file test_median_blur.cpp.

piSHL_This_MmioCaptPktEn

ap_uint<1> piSHL_This_MmioCaptPktEn

Definition at line 82 of file test_median_blur.cpp.

piSHL_This_MmioPostPktEn

ap_uint<1> piSHL_This_MmioPostPktEn

Definition at line 81 of file test_median_blur.cpp.

s_udp_rx_ports

ap_uint<32> s_udp_rx_ports = 0x0

Definition at line 89 of file test_median_blur.cpp.

simCnt

int simCnt

Definition at line 120 of file test_median_blur.cpp.