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

Collaboration diagram for Gammacorrection Vivado HLS:

Files
file	gammacorrection.hpp
	The Role for a Gammacorrection Example application (UDP or TCP)

file	xf_config_params.h
	The Gammacorrection IP configuration header.

file	gammacorrection.cpp
	The Role for a Gammacorrection Example application (UDP or TCP)

file	xf_gammacorrection_accel.cpp
	The Gammacorrection top-level.

Macros
#define	WAIT_FOR_META 0

#define	WAIT_FOR_STREAM_PAIR 1

#define	PROCESSING_PACKET 2

#define	GAMMACORRECTION_RETURN_RESULTS 3

#define	PacketFsmType uint8_t

#define	DEFAULT_TX_PORT 2718

#define	DEFAULT_RX_PORT 2718

#define	MEMDW 64

#define	BPERDW (MEMDW/8)

#define	MAX_NB_OF_ELMT_READ 16

#define	MAX_NB_OF_WORDS_READ (MAX_NB_OF_ELMT_READ*sizeof(mat_elmt_t)/BPERDW)

#define	MAX_NB_OF_ELMT_PERDW (BPERDW/sizeof(mat_elmt_t))

#define	RO 0

#define	NO 1

#define	FILTER_WIDTH 3

#define	BLOCK_WIDTH 3

#define	NMS_RADIUS 1

#define	MAXCORNERS 1024

#define	XF_USE_URAM false

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

Typedefs
typedef uint8_t	mat_elmt_t

Functions
void	gammacorrection (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)
	Main process of the Gammacorrection Application directives. More...

void	storeWordToArray (uint64_t input, ap_uint< 64 > img[256 256/(64/8)], unsigned int processed_word, unsigned int *image_loaded)
	Store a word from ethernet to local memory. More...

void	storeWordToAxiStream (NetworkWord word, stream< ap_axiu< 64, 0, 0, 0 > > &img_in_axi_stream, unsigned int processed_word_rx, unsigned int image_loaded)
	Store a word from ethernet to a local AXI stream. More...

void	pRXPath (stream< NetworkWord > &siSHL_This_Data, stream< NetworkMetaStream > &siNrc_meta, stream< NetworkMetaStream > &sRxtoTx_Meta, stream< ap_axiu< 64, 0, 0, 0 > > &img_in_axi_stream, NetworkMetaStream meta_tmp, unsigned int processed_word_rx, unsigned int image_loaded)
	Receive Path - From SHELL to THIS. More...

void	pProcPath (stream< NetworkWord > &sRxpToTxp_Data, stream< ap_axiu< 64, 0, 0, 0 > > &img_in_axi_stream, stream< ap_axiu< 64, 0, 0, 0 > > &img_out_axi_stream, unsigned int processed_word_rx, unsigned int image_loaded)
	Processing Path - Main processing FSM for Vitis kernels. More...

void	pTXPath (stream< NetworkWord > &soTHIS_Shl_Data, stream< NetworkMetaStream > &soNrc_meta, stream< NetworkWord > &sRxpToTxp_Data, stream< NetworkMetaStream > &sRxtoTx_Meta, unsigned int processed_word_tx, ap_uint< 32 > pi_rank, ap_uint< 32 > *pi_size)
	Transmit Path - From THIS to SHELL. More...

void	gammacorrection_accel (xf::cv::Mat< XF_8UC1, 256, 256, XF_NPPC1 > &imgInput1, xf::cv::Mat< XF_8UC1, 256, 256, XF_NPPC1 > &imgOutput, float gammaval)
	Top-level accelerated function of the Gammacorrection Application with xf::cv I/F. More...

void	GammacorrectionAccelArray (ap_uint< 64 > img_inp, ap_uint< 64 > img_out, int rows, int cols, int threshold, int k)
	Top-level accelerated function of the Gammacorrection Application with array I/F. More...

void	GammacorrectionAccelStream (hls::stream< ap_axiu< 64, 0, 0, 0 > > &img_in_axi_stream, hls::stream< ap_axiu< 64, 0, 0, 0 > > &img_out_axi_stream, int rows, int cols, int threshold, int k)
	Top-level accelerated function of the Gammacorrection Application with array I/F. More...

Variables
uint8_t	enqueueFSM = 0

uint8_t	dequeueFSM = 1

uint8_t	GammacorrectionFSM = 0

Detailed Description

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

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

Macro Definition Documentation

◆ BLOCK_WIDTH

#define BLOCK_WIDTH 3

Definition at line 36 of file xf_config_params.h.

◆ BPERDW

#define BPERDW (MEMDW/8)

Definition at line 52 of file gammacorrection.hpp.

◆ Data_t

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

Definition at line 35 of file gammacorrection.cpp.

◆ DEFAULT_RX_PORT

#define DEFAULT_RX_PORT 2718

Definition at line 48 of file gammacorrection.hpp.

◆ DEFAULT_TX_PORT

#define DEFAULT_TX_PORT 2718

Definition at line 47 of file gammacorrection.hpp.

◆ FILTER_WIDTH

#define FILTER_WIDTH 3

Definition at line 35 of file xf_config_params.h.

◆ GAMMACORRECTION_RETURN_RESULTS

#define GAMMACORRECTION_RETURN_RESULTS 3

Definition at line 42 of file gammacorrection.hpp.

◆ MAX_NB_OF_ELMT_PERDW

#define MAX_NB_OF_ELMT_PERDW (BPERDW/sizeof(mat_elmt_t))

Definition at line 58 of file gammacorrection.hpp.

◆ MAX_NB_OF_ELMT_READ

#define MAX_NB_OF_ELMT_READ 16

Definition at line 54 of file gammacorrection.hpp.

◆ MAX_NB_OF_WORDS_READ

#define MAX_NB_OF_WORDS_READ (MAX_NB_OF_ELMT_READ*sizeof(mat_elmt_t)/BPERDW)

Definition at line 57 of file gammacorrection.hpp.

◆ MAXCORNERS

#define MAXCORNERS 1024

Definition at line 39 of file xf_config_params.h.

◆ MEMDW

#define MEMDW 64

Definition at line 51 of file gammacorrection.hpp.

◆ NMS_RADIUS

#define NMS_RADIUS 1

Definition at line 37 of file xf_config_params.h.

◆ NO

#define NO 1

Definition at line 33 of file xf_config_params.h.

◆ PacketFsmType

#define PacketFsmType uint8_t

Definition at line 44 of file gammacorrection.hpp.

◆ PROCESSING_PACKET

#define PROCESSING_PACKET 2

Definition at line 41 of file gammacorrection.hpp.

◆ RO

#define RO 0

Definition at line 32 of file xf_config_params.h.

◆ WAIT_FOR_META

#define WAIT_FOR_META 0

Definition at line 39 of file gammacorrection.hpp.

◆ WAIT_FOR_STREAM_PAIR

#define WAIT_FOR_STREAM_PAIR 1

Definition at line 40 of file gammacorrection.hpp.

◆ XF_USE_URAM

#define XF_USE_URAM false

Definition at line 41 of file xf_config_params.h.

Typedef Documentation

◆ mat_elmt_t

typedef uint8_t mat_elmt_t

Definition at line 55 of file gammacorrection.hpp.

Function Documentation

◆ gammacorrection()

void gammacorrection	(	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
	)

Main process of the Gammacorrection Application directives.

Deprecated:: This functions is using deprecated AXI stream interface

Returns: Nothing.

Definition at line 366 of file gammacorrection.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
  
  
   //-- LOCAL VARIABLES ------------------------------------------------------
   NetworkMetaStream  meta_tmp = NetworkMetaStream();
   static stream<NetworkWord>       sRxpToTxp_Data("sRxpToTxP_Data"); // FIXME: works even with no static
   static stream<NetworkMetaStream> sRxtoTx_Meta("sRxtoTx_Meta");
   static unsigned int processed_word_rx;
   static unsigned int processed_word_tx;
   static unsigned int image_loaded;
   const int img_packets = IMG_PACKETS;
   const int tot_transfers = TOT_TRANSFERS;
   static stream<Data_t> img_in_axi_stream ("img_in_axi_stream" );
   static stream<Data_t> img_out_axi_stream("img_out_axi_stream"); 
   //static Stream<Data_t, IMG_PACKETS>  img_in_axi_stream ("img_in_axi_stream");
   //static Stream<Data_t, IMG_PACKETS>  img_out_axi_stream ("img_out_axi_stream");
   *po_rx_ports = 0x1; //currently work only with default ports...
  
   
   //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
 #pragma HLS DATAFLOW 
 //#pragma HLS STREAM variable=sRxpToTxp_Data depth=TOT_TRANSFERS 
 #pragma HLS stream variable=sRxtoTx_Meta depth=tot_transfers 
 #pragma HLS reset variable=enqueueFSM
 #pragma HLS reset variable=dequeueFSM
 #pragma HLS reset variable=GammacorrectionFSM
 #pragma HLS reset variable=processed_word_rx
 #pragma HLS reset variable=processed_word_tx
 #pragma HLS reset variable=image_loaded
 #pragma HLS stream variable=img_in_axi_stream depth=img_packets
 #pragma HLS stream variable=img_out_axi_stream depth=img_packets
   
  
 #ifdef USE_HLSLIB_DATAFLOW
   /*
    * Use this snippet to early check for C++ errors related to dataflow and bounded streams (empty 
    * and full) during simulation. It can also be both synthesized and used in co-simulation.
    * Practically we use hlslib when we want to run simulation as close as possible to the HW, by 
    * executing all functions of dataflow in thread-safe parallel executions, i.e the function 
    * HLSLIB_DATAFLOW_FINALIZE() acts as a barrier for the threads spawned to serve every function 
    * called in HLSLIB_DATAFLOW_FUNCTION(func, args...).
    */
   // Dataflow functions running in parallel
   HLSLIB_DATAFLOW_INIT();
   
   HLSLIB_DATAFLOW_FUNCTION(pRXPath, 
                siSHL_This_Data,
                siNrc_meta,
                sRxtoTx_Meta,
                img_in_axi_stream,
                meta_tmp,
                &processed_word_rx,
                &image_loaded);
   
   HLSLIB_DATAFLOW_FUNCTION(pProcPath,
                sRxpToTxp_Data,
                    img_in_axi_stream,
                    img_out_axi_stream,
                    &processed_word_rx,
                    &image_loaded); 
  
   HLSLIB_DATAFLOW_FUNCTION(pTXPath,
                soTHIS_Shl_Data,
                soNrc_meta,
                sRxpToTxp_Data,
                sRxtoTx_Meta,
                &processed_word_tx,
                pi_rank,
                pi_size);
  
   HLSLIB_DATAFLOW_FINALIZE();
   
 #else // !USE_HLSLIB_DATAFLOW
  pRXPath(
     siSHL_This_Data,
         siNrc_meta,
     sRxtoTx_Meta,
     img_in_axi_stream,
         meta_tmp,    
         &processed_word_rx,
     &image_loaded);
   
   
   pProcPath(sRxpToTxp_Data,
         img_in_axi_stream,
         img_out_axi_stream,
         &processed_word_rx,
         &image_loaded);  
  
   pTXPath(
         soTHIS_Shl_Data,
         soNrc_meta,
     sRxpToTxp_Data,
     sRxtoTx_Meta,
         &processed_word_tx,
         pi_rank,
         pi_size);
 #endif // USE_HLSLIB_DATAFLOW
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gammacorrection_accel()

void gammacorrection_accel	(	xf::cv::Mat< XF_8UC1, 256, 256, XF_NPPC1 > &	imgInput1,
		xf::cv::Mat< XF_8UC1, 256, 256, XF_NPPC1 > &	imgOutput,
		float	gammaval
	)

Top-level accelerated function of the Gammacorrection Application with xf::cv I/F.

Returns: Nothing.

Definition at line 38 of file xf_gammacorrection_accel.cpp.

                                            {
     xf::cv::gammacorrection<IN_TYPE, OUT_TYPE, HEIGHT, WIDTH, NPC1>(imgInput1, imgOutput, gammaval);
 }

◆ GammacorrectionAccelArray()

void GammacorrectionAccelArray	(	ap_uint< 64 > *	img_inp,
		ap_uint< 64 > *	img_out,
		int	rows,
		int	cols,
		int	threshold,
		int	k
	)

Top-level accelerated function of the Gammacorrection Application with array I/F.

Returns: Nothing.

Definition at line 53 of file xf_gammacorrection_accel.cpp.

                                                                                                                      {
 // clang-format off
 /*    #pragma HLS INTERFACE m_axi     port=img_inp  offset=slave bundle=gmem1
     #pragma HLS INTERFACE m_axi     port=img_out  offset=slave bundle=gmem2
  
     #pragma HLS INTERFACE s_axilite port=rows     bundle=control
     #pragma HLS INTERFACE s_axilite port=cols     bundle=control
     #pragma HLS INTERFACE s_axilite port=threshold     bundle=control
     #pragma HLS INTERFACE s_axilite port=k     bundle=control
     #pragma HLS INTERFACE s_axilite port=return   bundle=control
     // clang-format on
 */
     const int pROWS = HEIGHT;
     const int pCOLS = WIDTH;
     const int pNPC1 = NPIX;
  
     xf::cv::Mat<XF_8UC1, HEIGHT, WIDTH, NPIX> in_mat(rows, cols);
 // clang-format off
     #pragma HLS stream variable=in_mat.data depth=2
     // clang-format on
  
     xf::cv::Mat<XF_8UC1, HEIGHT, WIDTH, NPIX> out_mat(rows, cols);
 // clang-format off
     #pragma HLS stream variable=out_mat.data depth=2
 // clang-format on
  
 // clang-format off
     #pragma HLS DATAFLOW
     // clang-format on
     xf::cv::Array2xfMat<INPUT_PTR_WIDTH, IN_TYPE, HEIGHT, WIDTH, NPIX>(img_inp, in_mat);
     float gammaval = 0.2;
     xf::cv::gammacorrection<IN_TYPE, OUT_TYPE, HEIGHT, WIDTH, NPC1>(in_mat, out_mat, gammaval); 
     xf::cv::xfMat2Array<OUTPUT_PTR_WIDTH, OUT_TYPE, HEIGHT, WIDTH, NPIX>(out_mat, img_out);
 }

Here is the caller graph for this function:

◆ GammacorrectionAccelStream()

void GammacorrectionAccelStream	(	hls::stream< ap_axiu< 64, 0, 0, 0 > > &	img_in_axi_stream,
		hls::stream< ap_axiu< 64, 0, 0, 0 > > &	img_out_axi_stream,
		int	rows,
		int	cols,
		int	threshold,
		int	k
	)

Top-level accelerated function of the Gammacorrection Application with array I/F.

Returns: Nothing.

Definition at line 99 of file xf_gammacorrection_accel.cpp.

                                               {
     // clang-format on
  
     const int pROWS = HEIGHT;
     const int pCOLS = WIDTH;
     const int pNPC1 = NPIX;
  
     xf::cv::Mat<IN_TYPE, HEIGHT, WIDTH, NPIX> in_mat(rows, cols);
     // clang-format off
     #pragma HLS stream variable=in_mat.data depth=2
     // clang-format on
  
     xf::cv::Mat<OUT_TYPE, HEIGHT, WIDTH, NPIX> out_mat(rows, cols);
     // clang-format off
     #pragma HLS stream variable=out_mat.data depth=2
     // clang-format on
  
     // clang-format off
     #pragma HLS DATAFLOW
     // clang-format on
  
     xf::cv::axiStrm2xfMat<INPUT_PTR_WIDTH, IN_TYPE, HEIGHT, WIDTH, NPIX>(
       img_in_axi_stream, in_mat);  
     float gammaval = 0.2;
     xf::cv::gammacorrection<IN_TYPE, OUT_TYPE, HEIGHT, WIDTH, NPC1>(in_mat, out_mat, gammaval);    
     xf::cv::xfMat2axiStrm<OUTPUT_PTR_WIDTH, OUT_TYPE, HEIGHT, WIDTH, NPIX>(
       out_mat, img_out_axi_stream);
     
     
 }

Here is the caller graph for this function:

◆ pProcPath()

void pProcPath	(	stream< NetworkWord > &	sRxpToTxp_Data,
		stream< ap_axiu< 64, 0, 0, 0 > > &	img_in_axi_stream,
		stream< ap_axiu< 64, 0, 0, 0 > > &	img_out_axi_stream,
		unsigned int *	processed_word_rx,
		unsigned int *	image_loaded
	)

Processing Path - Main processing FSM for Vitis kernels.

Parameters

[out]	sRxpToTxp_Data
[in]	img_in_axi_stream
[in]	img_out_axi_stream
[out]	processed_word_rx
[in]	image_loaded

Returns: Nothing.

Definition at line 179 of file gammacorrection.cpp.

 {
     //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
     //#pragma HLS DATAFLOW interval=1
     #pragma  HLS INLINE
     //-- LOCAL VARIABLES ------------------------------------------------------
     NetworkWord newWord;
     uint16_t Thresh = 442;
     float K = 0.04;
     uint16_t k = K * (1 << 16); // Convert to Q0.16 format
   
   
   switch(GammacorrectionFSM)
   {
     case WAIT_FOR_META: 
       printf("DEBUG in pProcPath: WAIT_FOR_META\n");
       if ( (*image_loaded) == 1 )
       {
         GammacorrectionFSM = PROCESSING_PACKET;
     *processed_word_rx = 0;
       }
       break;
  
     case PROCESSING_PACKET:
       printf("DEBUG in pProcPath: PROCESSING_PACKET\n");
       if ( !img_in_axi_stream.empty() && !img_out_axi_stream.full() )
       {
     GammacorrectionAccelStream(img_in_axi_stream, img_out_axi_stream, WIDTH, HEIGHT, Thresh, k);
     if ( !img_out_axi_stream.empty() )  
     {
       GammacorrectionFSM = GAMMACORRECTION_RETURN_RESULTS;
     } 
       }
       break;
       
     case GAMMACORRECTION_RETURN_RESULTS:
       printf("DEBUG in pProcPath: GAMMACORRECTION_RETURN_RESULTS\n");
       if ( !img_out_axi_stream.empty() && !sRxpToTxp_Data.full() )
       {
     
     Data_t temp = img_out_axi_stream.read();
     if ( img_out_axi_stream.empty() ) 
     {
       temp.last = 1;
       GammacorrectionFSM = WAIT_FOR_META;
     }
     else
     {
       temp.last = 0;
     }
     //TODO: find why Vitis kernel does not set keep and last by itself
     temp.keep = 255;
     newWord = NetworkWord(temp.data, temp.keep, temp.last); 
     sRxpToTxp_Data.write(newWord);
       }
       break;
       
   } // end switch
  
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pRXPath()

void pRXPath	(	stream< NetworkWord > &	siSHL_This_Data,
		stream< NetworkMetaStream > &	siNrc_meta,
		stream< NetworkMetaStream > &	sRxtoTx_Meta,
		stream< ap_axiu< 64, 0, 0, 0 > > &	img_in_axi_stream,
		NetworkMetaStream	meta_tmp,
		unsigned int *	processed_word_rx,
		unsigned int *	image_loaded
	)

Receive Path - From SHELL to THIS.

Parameters

[in]	siSHL_This_Data
[in]	siNrc_meta
[out]	sRxtoTx_Meta
[out]	img_in_axi_stream
[out]	meta_tmp
[out]	processed_word
[out]	image_loaded

Returns: Nothing.

Definition at line 115 of file gammacorrection.cpp.

 {
     //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
     //#pragma HLS DATAFLOW interval=1
      #pragma  HLS INLINE
     //-- LOCAL VARIABLES ------------------------------------------------------
     UdpWord    udpWord;
  
   switch(enqueueFSM)
   {
     case WAIT_FOR_META: 
       printf("DEBUG in pRXPath: enqueueFSM - WAIT_FOR_META, *processed_word_rx=%u\n",
          *processed_word_rx);
       if ( !siNrc_meta.empty() && !sRxtoTx_Meta.full() )
       {
         meta_tmp = siNrc_meta.read();
         meta_tmp.tlast = 1; //just to be sure...
         sRxtoTx_Meta.write(meta_tmp);
         enqueueFSM = PROCESSING_PACKET;
       }
       //*processed_word_rx = 0;
       *image_loaded = 0;
       break;
  
     case PROCESSING_PACKET:
       printf("DEBUG in pRXPath: enqueueFSM - PROCESSING_PACKET, *processed_word_rx=%u\n",
          *processed_word_rx);
       if ( !siSHL_This_Data.empty() && !img_in_axi_stream.full() )
       {
         //-- Read incoming data chunk
         udpWord = siSHL_This_Data.read();
     storeWordToAxiStream(udpWord, img_in_axi_stream, processed_word_rx, image_loaded);
         if(udpWord.tlast == 1)
         {
           enqueueFSM = WAIT_FOR_META;
         }
       }
       break;
   }
  
  
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pTXPath()

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

Transmit Path - From THIS to SHELL.

Parameters

[out]	soTHIS_Shl_Data
[out]	soNrc_meta
[in]	sRxpToTxp_Data
[in]	sRxtoTx_Meta
[in]	pi_rank
[in]	pi_size

Returns: Nothing.

Definition at line 262 of file gammacorrection.cpp.

 {
     //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
     //#pragma HLS DATAFLOW interval=1
     #pragma  HLS INLINE
     //-- LOCAL VARIABLES ------------------------------------------------------
     UdpWord      udpWordTx;
     NetworkMeta  meta_in = NetworkMeta();
   
   switch(dequeueFSM)
   {
     case WAIT_FOR_STREAM_PAIR:
       printf("DEBUG in pTXPath: dequeueFSM=%d - WAIT_FOR_STREAM_PAIR, *processed_word_tx=%u\n", 
          dequeueFSM, *processed_word_tx);
       //-- Forward incoming chunk to SHELL
       *processed_word_tx = 0;
       
       /*
       printf("!sRxpToTxp_Data.empty()=%d\n", !sRxpToTxp_Data.empty());
       printf("!sRxtoTx_Meta.empty()=%d\n", !sRxtoTx_Meta.empty());
       printf("!soTHIS_Shl_Data.full()=%d\n", !soTHIS_Shl_Data.full());
       printf("!soNrc_meta.full()=%d\n", !soNrc_meta.full());
       */
       
       if (( !sRxpToTxp_Data.empty() && !sRxtoTx_Meta.empty() 
           && !soTHIS_Shl_Data.full() &&  !soNrc_meta.full() )) 
       {
         udpWordTx = sRxpToTxp_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) 
     {
         udpWordTx.tlast = 1;
     }
         soTHIS_Shl_Data.write(udpWordTx);
  
         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
  
         //printf("rank: %d; size: %d; \n", (int) *pi_rank, (int) *pi_size);
         meta_out_stream.tdata.dst_rank = (*pi_rank + 1) % *pi_size;
         //printf("meat_out.dst_rank: %d\n", (int) meta_out_stream.tdata.dst_rank);
  
         meta_out_stream.tdata.dst_port = DEFAULT_TX_PORT;
         meta_out_stream.tdata.src_rank = (NodeId) *pi_rank;
         meta_out_stream.tdata.src_port = DEFAULT_RX_PORT;
     //meta_out_stream.tdata.len = meta_in.len; 
         soNrc_meta.write(meta_out_stream);
  
     (*processed_word_tx)++;
     
         if(udpWordTx.tlast != 1)
         {
           dequeueFSM = PROCESSING_PACKET;
         }
       }
       break;
  
     case PROCESSING_PACKET: 
       printf("DEBUG in pTXPath: dequeueFSM=%d - PROCESSING_PACKET, *processed_word_tx=%u\n", 
          dequeueFSM, *processed_word_tx);
       if( !sRxpToTxp_Data.empty() && !soTHIS_Shl_Data.full())
       {
         udpWordTx = sRxpToTxp_Data.read();
  
     // This is a normal termination of the axi stream from vitis functions
     if(udpWordTx.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) 
     {
         udpWordTx.tlast = 1;
         dequeueFSM = WAIT_FOR_STREAM_PAIR;
     }
     
         soTHIS_Shl_Data.write(udpWordTx);
       }
       break;
   }
 }

Here is the caller graph for this function:

◆ storeWordToArray()

void storeWordToArray	(	uint64_t	input,
		ap_uint< 64 >	img[256 *256/(64/8)],
		unsigned int *	processed_word,
		unsigned int *	image_loaded
	)

Store a word from ethernet to local memory.

Returns: Nothing.

Definition at line 47 of file gammacorrection.cpp.

 {
   #pragma HLS INLINE
   
   img[*processed_word] = (ap_uint<INPUT_PTR_WIDTH>) input;
   printf("DEBUG in storeWordToArray: input = %u = 0x%16.16llX \n", input, input);
   printf("DEBUG in storeWordToArray: img[%u]= %u = 0x%16.16llX \n", *processed_word, 
   (uint64_t)img[*processed_word], (uint64_t)img[*processed_word]);
   if (*processed_word < IMG_PACKETS-1) {
     *processed_word++;
   }
   else {
     printf("DEBUG in storeWordToArray: WARNING - you've reached the max depth of img[%u]. Will put *processed_word = 0.\n", *processed_word);
     *processed_word = 0;
     *image_loaded = 1;
   }
 }

◆ storeWordToAxiStream()

void storeWordToAxiStream	(	NetworkWord	word,
		stream< ap_axiu< 64, 0, 0, 0 > > &	img_in_axi_stream,
		unsigned int *	processed_word_rx,
		unsigned int *	image_loaded
	)

Store a word from ethernet to a local AXI stream.

Returns: Nothing.

Definition at line 71 of file gammacorrection.cpp.

 {   
   #pragma HLS INLINE
   
   Data_t v;
   v.data = word.tdata;
   v.keep = word.tkeep;
   v.last = word.tlast;
   
   //Data_t v;
   //v = word.tdata;
   
   img_in_axi_stream.write(v);
   
   if (*processed_word_rx < IMG_PACKETS-1) {
     (*processed_word_rx)++;
   }
   else {
     printf("DEBUG in storeWordToAxiStream: WARNING - you've reached the max depth of img. Will put *processed_word_rx = 0.\n");
     *processed_word_rx = 0;
     *image_loaded = 1;
   }
 }

Here is the caller graph for this function:

Variable Documentation

◆ dequeueFSM

uint8_t dequeueFSM = 1

Definition at line 38 of file gammacorrection.cpp.

◆ enqueueFSM

uint8_t enqueueFSM = 0

Definition at line 37 of file gammacorrection.cpp.

◆ GammacorrectionFSM

uint8_t GammacorrectionFSM = 0

Definition at line 39 of file gammacorrection.cpp.

Files

Macros

Typedefs

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ BLOCK_WIDTH

◆ BPERDW

◆ Data_t

◆ DEFAULT_RX_PORT

◆ DEFAULT_TX_PORT

◆ FILTER_WIDTH

◆ GAMMACORRECTION_RETURN_RESULTS

◆ MAX_NB_OF_ELMT_PERDW

◆ MAX_NB_OF_ELMT_READ

◆ MAX_NB_OF_WORDS_READ

◆ MAXCORNERS

◆ MEMDW

◆ NMS_RADIUS

◆ NO

◆ PacketFsmType

◆ PROCESSING_PACKET

◆ RO

◆ WAIT_FOR_META

◆ WAIT_FOR_STREAM_PAIR

◆ XF_USE_URAM

Typedef Documentation

◆ mat_elmt_t

Function Documentation

◆ gammacorrection()

◆ gammacorrection_accel()

◆ GammacorrectionAccelArray()

◆ GammacorrectionAccelStream()

◆ pProcPath()

◆ pRXPath()

◆ pTXPath()

◆ storeWordToArray()

◆ storeWordToAxiStream()

Variable Documentation

◆ dequeueFSM

◆ enqueueFSM

◆ GammacorrectionFSM