NAL

Network Abstraction Layer (NAL). The NAL separates the privileged management traffic from the unprivileged Role traffic. It also abstracts the details of port opening, connection handling and IP Address translation. The documentation of NAL is available at https://pages.github.ibm.com/cloudFPGA/Doc/pages/cfdk.html#network-abstraction-layer-nal. More...

Collaboration diagram for NAL:

Files
file	cam8.hpp
	: A Content Address Memory (CAM) for 16 entries.
file	cam8.hpp
	: A Content Address Memory (CAM) for 16 entries.
file	hss.cpp
	: The Housekeeping Sub System (HSS) of the NAL core.
file	hss.hpp
	: The Housekeeping Sub System (HSS) of the NAL core.
file	nal.hpp
	: The cloudFPGA Network Abstraction Layer (NAL) between NTS and ROlE. The NAL core manages the NTS Stack and maps the network streams to the user's ROLE or the FMC while hiding some complexity of UOE and TOE.
file	nal.hpp
	: The cloudFPGA Network Abstraction Layer (NAL) between NTS and ROlE. The NAL core manages the NTS Stack and maps the network streams to the user's ROLE or the FMC while hiding some complexity of UOE and TOE.
file	tss.cpp
	: The TCP Sub System (TSS) of the NAL core.
file	tss.hpp
	: The TCP Sub System (TSS) of the NAL core.
file	uss.cpp
	: The UDP Sub System (USS) of the NAL core.
file	uss.hpp
	: The UDP Sub System (USS) of the NAL core.

Classes
class	KeyValuePair< K, V >
struct	Cam16< K, V >
struct	Cam8< K, V >
struct	NalEventNotif
struct	NalNewTableEntry
struct	NalNewTcpConRep
struct	NalConfigUpdate
struct	NalMrtUpdate
struct	NalStatusUpdate
struct	NalPortUpdate
struct	NalWaitingData

Macros
#define	_NAL_KVP_DEF_
#define	_NAL_KVP_DEF_
#define	XNAL_PIFMC_NAL_CTRLLINK_AXI_ADDR_CTRLLINK_V_BASE   0x200
#define	XNAL_PIFMC_NAL_CTRLLINK_AXI_ADDR_CTRLLINK_V_HIGH   0x3ff
#define	XNAL_PIFMC_NAL_CTRLLINK_AXI_WIDTH_CTRLLINK_V   32
#define	XNAL_PIFMC_NAL_CTRLLINK_AXI_DEPTH_CTRLLINK_V   96
#define	NAL_CTRL_LINK_SIZE   (XNAL_PIFMC_NAL_CTRLLINK_AXI_ADDR_CTRLLINK_V_HIGH/4)
#define	NAL_CTRL_LINK_CONFIG_START_ADDR   (0x200/4)
#define	NAL_CTRL_LINK_CONFIG_END_ADDR   (0x23F/4)
#define	NAL_CTRL_LINK_STATUS_START_ADDR   (0x240/4)
#define	NAL_CTRL_LINK_STATUS_END_ADDR   (0x27F/4)
#define	NAL_CTRL_LINK_MRT_START_ADDR   (0x280/4)
#define	NAL_CTRL_LINK_MRT_END_ADDR   (0x37F/4)
#define	MAX_MRT_SIZE   64
#define	THIS_NAME   "NAL"
#define	TRACE_OFF   0x0000
#define	TRACE_RDP   1 << 1
#define	TRACE_WRP   1 << 2
#define	TRACE_SAM   1 << 3
#define	TRACE_LSN   1 << 4
#define	TRACE_CON   1 << 5
#define	TRACE_ALL   0xFFFF
#define	DEBUG_LEVEL   (TRACE_ALL)
#define	DEFAULT_TX_PORT   2718
#define	DEFAULT_RX_PORT   2718
#define	MAX_NAL_SESSIONS   (TOE_MAX_SESSIONS)
#define	NAL_STREAMING_SPLIT_TCP   (ZYC2_MSS)
#define	NAL_MAX_FIFO_DEPTHS_BYTES   2000
#define	NUMBER_CONFIG_WORDS   16
#define	NUMBER_STATUS_WORDS   16
#define	NAL_NUMBER_CONFIG_WORDS   NUMBER_CONFIG_WORDS
#define	NAL_NUMBER_STATUS_WORDS   NUMBER_STATUS_WORDS
#define	NAL_CONNECTION_TIMEOUT   160000000
#define	NAL_TCP_RX_DATA_DELAY_CYCLES   80
#define	NAL_MMIO_STABILIZE_TIME   150
#define	UNUSED_TABLE_ENTRY_VALUE   0x111000
#define	UNUSED_SESSION_ENTRY_VALUE   0xFFFE
#define	INVALID_MRT_VALUE   0xFFFFF
#define	NAL_CONFIG_OWN_RANK   0
#define	NAL_CONFIG_MRT_VERSION   1
#define	NAL_CONFIG_SAVED_UDP_PORTS   2
#define	NAL_CONFIG_SAVED_TCP_PORTS   3
#define	NAL_CONFIG_SAVED_FMC_PORTS   4
#define	NAL_STATUS_MRT_VERSION   0
#define	NAL_STATUS_OPEN_UDP_PORTS   1
#define	NAL_STATUS_OPEN_TCP_PORTS   2
#define	NAL_STATUS_FMC_PORT_PROCESSED   3
#define	NAL_STATUS_OWN_RANK   13
#define	NAL_UNAUTHORIZED_ACCESS   4
#define	NAL_AUTHORIZED_ACCESS   5
#define	NAL_STATUS_SEND_STATE   6
#define	NAL_STATUS_RECEIVE_STATE   7
#define	NAL_STATUS_GLOBAL_STATE   8
#define	NAL_STATUS_LAST_RX_NODE_ID   9
#define	NAL_STATUS_RX_NODEID_ERROR   10
#define	NAL_STATUS_LAST_TX_NODE_ID   11
#define	NAL_STATUS_TX_NODEID_ERROR   12
#define	NAL_STATUS_PACKET_CNT_RX   14
#define	NAL_STATUS_PACKET_CNT_TX   15
#define	VALID   true
#define	UNVALID   false
#define	DEBUG_TRACE   true
#define	THIS_NAME   "TB"
#define	TRACE_OFF   0x0000
#define	TRACE_TOE   1 << 1
#define	TRACE_ROLE   1 << 2
#define	TRACE_ALL   0xFFFF
#define	DEBUG_LEVEL   (TRACE_TOE | TRACE_ROLE)
#define	MAX_SIM_CYCLES   450
#define	DEFAULT_FPGA_IP4_ADDR   0x0A0CC801
#define	DEFAULT_FPGA_LSN_PORT   0x0057
#define	DEFAULT_HOST_IP4_ADDR   0x0A0CC832
#define	DEFAULT_HOST_LSN_PORT   0x80
#define	DEFAULT_SESSION_ID   42
#define	DEFAULT_SESSION_LEN   32
#define	DEFAULT_TCP_LEN_REP   16

Typedefs
typedef bool	StsBool
typedef ap_uint< 16 >	UdpSrcPort
typedef ap_uint< 16 >	UdpDstPort
typedef ap_uint< 16 >	UdpPort
typedef ap_uint< 16 >	UdpLen
typedef UdpLen	UdpAppDLen
typedef UdpAppDLen	UdpPLen
typedef ap_uint< 16 >	PacketLen
typedef ap_uint< 64 >	NalTriple

Enumerations
enum	DropCmd { KEEP_CMD =false , DROP_CMD , KEEP_CMD =false , DROP_CMD }
enum	FsmStateUdp {   FSM_RESET = 0 , FSM_W8FORMETA , FSM_W8FORREQS , FSM_FIRST_ACC ,   FSM_ACC , FSM_WRITE_META , FSM_DROP_PACKET }
enum	OpnFsmStates { OPN_IDLE = 0 , OPN_REQ , OPN_REP , OPN_DONE }
enum	LsnFsmStates { LSN_IDLE = 0 , LSN_SEND_REQ , LSN_WAIT_ACK , LSN_DONE }
enum	RrhFsmStates {   RRH_RESET = 0 , RRH_WAIT_NOTIF , RRH_PROCESS_NOTIF , RRH_START_REQUEST ,   RRH_PROCESS_REQUEST , RRH_WAIT_FMC , RRH_WAIT_ROLE , RRH_DRAIN }
enum	RrhEnqFsmStates { RRH_ENQ_RESET = 0 , RRH_ENQ_STREAM }
enum	RdpFsmStates {   RDP_RESET = 0 , RDP_WAIT_META , RDP_W8FORREQS_1 , RDP_W8FORREQS_2 ,   RDP_FILTER_META , RDP_STREAM_ROLE , RDP_STREAM_FMC , RDP_WRITE_META_ROLE ,   RDP_WRITE_META_FMC , RDP_DROP_PACKET }
enum	WrpFsmStates {   WRP_RESET = 0 , WRP_WAIT_META , WRP_STREAM_FMC , WRP_W8FORREQS_1 ,   WRP_W8FORREQS_11 , WRP_W8FORREQS_2 , WRP_W8FORREQS_22 , WRP_WAIT_CONNECTION ,   WRP_STREAM_ROLE , WRP_DROP_PACKET }
enum	WbuFsmStates {   WBU_WAIT_META = 0 , WBU_SND_REQ , WBU_WAIT_REP , WBU_STREAM ,   WBU_DROP , WBU_DRAIN }
enum	CacheInvalFsmStates {   CACHE_WAIT_FOR_VALID = 0 , CACHE_VALID , CACHE_INV_SEND_0 , CACHE_INV_SEND_1 ,   CACHE_INV_SEND_2 , CACHE_INV_SEND_3 }
enum	ClsFsmStates { CLS_IDLE = 0 , CLS_NEXT , CLS_WAIT4RESP }
enum	DeqFsmStates { DEQ_WAIT_META = 0 , DEQ_STREAM_DATA , DEQ_SEND_NOTIF }
enum	TableFsmStates { TAB_FSM_READ = 0 , TAB_FSM_WRITE }
enum	AxiLiteFsmStates {   A4L_RESET = 0 , A4L_STATUS_UPDATE , A4L_COPY_CONFIG , A4L_COPY_CONFIG_2 ,   A4L_COPY_MRT , A4L_COPY_STATUS , A4L_COPY_FINISH , A4L_WAIT_FOR_SUB_FSMS }
enum	ConfigBcastStates {   CB_WAIT = 0 , CB_START , CB_1 , CB_2 ,   CB_3_0 , CB_3_1 , CB_3_2 }
enum	PortFsmStates {   PORT_RESET = 0 , PORT_IDLE , PORT_L4_RESET , PORT_NEW_UDP_REQ ,   PORT_NEW_UDP_REP , PORT_NEW_FMC_REQ , PORT_NEW_FMC_REP , PORT_NEW_TCP_REQ ,   PORT_NEW_TCP_REP , PORT_L7_RESET , PORT_WAIT_PR , PORT_START_TCP_CLS_0 ,   PORT_START_TCP_CLS_1 , PORT_START_TCP_CLS_2 , PORT_START_UDP_CLS , PORT_SEND_UPDATE }
enum	PortType { FMC = 0 , UDP , TCP }
enum	NalCntIncType {   NID_MISS_RX = 0 , NID_MISS_TX , PCOR_TX , TCP_CON_FAIL ,   LAST_RX_PORT , LAST_RX_NID , LAST_TX_PORT , LAST_TX_NID ,   PACKET_RX , PACKET_TX , UNAUTH_ACCESS , AUTH_ACCESS ,   FMC_TCP_BYTES }
enum	RxFsmStates { RX_WAIT_META =0 , RX_STREAM }
enum	RoleFsmStates { ROLE_WAIT_META =0 , ROLE_STREAM }
enum	LsnStates { LSN_WAIT_REQ , LSN_SEND_ACK }
enum	OpnStates { OPN_WAIT_REQ , OPN_SEND_REP , OPN_TIMEOUT }
enum	RxpStates {   RXP_SEND_NOTIF , RXP_WAIT_DREQ , RXP_SEND_META , RXP_SEND_DATA ,   RXP_DONE }
enum	TxpStates { TXP_WAIT_REQ , TXP_WAIT_DATA , TXP_RECV_DATA }

Functions
uint8_t	selectConfigUpdatePropagation (uint16_t config_addr)
void	axi4liteProcessing (ap_uint< 32 > ctrlLink[64+16+16], stream< NalConfigUpdate > &sToPortLogic, stream< NalConfigUpdate > &sToUdpRx, stream< NalConfigUpdate > &sToTcpRx, stream< NalConfigUpdate > &sToStatusProc, stream< NalMrtUpdate > &sMrtUpdate, stream< uint32_t > &mrt_version_update_0, stream< uint32_t > &mrt_version_update_1, stream< NalStatusUpdate > &sStatusUpdate)
	Contains the Axi4 Lite secondary endpoint and reads the MRT and configuration values from it as well as writes the status values. It notifies all other concerned processes on MRT or configuration updates and is notified on status updates. More...
void	pMrtAgency (stream< NalMrtUpdate > &sMrtUpdate, stream< NodeId > &sGetIpReq_UdpTx, stream< Ip4Addr > &sGetIpRep_UdpTx, stream< NodeId > &sGetIpReq_TcpTx, stream< Ip4Addr > &sGetIpRep_TcpTx, stream< Ip4Addr > &sGetNidReq_UdpRx, stream< NodeId > &sGetNidRep_UdpRx, stream< Ip4Addr > &sGetNidReq_TcpRx, stream< NodeId > &sGetNidRep_TcpRx)
	Can access the BRAM that contains the MRT and replies to lookup requests. More...
void	pPortLogic (ap_uint< 1 > *layer_4_enabled, ap_uint< 1 > *layer_7_enabled, ap_uint< 1 > *role_decoupled, ap_uint< 1 > *piNTS_ready, ap_uint< 16 > *piMMIO_FmcLsnPort, ap_uint< 32 > *pi_udp_rx_ports, ap_uint< 32 > *pi_tcp_rx_ports, stream< NalConfigUpdate > &sConfigUpdate, stream< UdpPort > &sUdpPortsToOpen, stream< UdpPort > &sUdpPortsToClose, stream< TcpPort > &sTcpPortsToOpen, stream< bool > &sUdpPortsOpenFeedback, stream< bool > &sTcpPortsOpenFeedback, stream< bool > &sMarkToDel_unpriv, stream< NalPortUpdate > &sPortUpdate, stream< bool > &sStartTclCls)
	Translates the one-hot encoded open-port vectors from the Role (i.e. piUdpRxPorts and piTcpRxPorts) to absolute port numbers If the input vector changes, or during a reset of the Role, the necessary open or close requests are send to pUdpLsn, pUdpCls, pTcpLsn, and pTcpCls. More...
void	pCacheInvalDetection (ap_uint< 1 > *layer_4_enabled, ap_uint< 1 > *layer_7_enabled, ap_uint< 1 > *role_decoupled, ap_uint< 1 > *piNTS_ready, stream< uint32_t > &mrt_version_update, stream< bool > &inval_del_sig, stream< bool > &cache_inval_0, stream< bool > &cache_inval_1, stream< bool > &cache_inval_2, stream< bool > &cache_inval_3)
	Detects if the caches of the USS and TSS have to be invalidated and signals this to the concerned processes. More...
void	pTcpAgency (stream< SessionId > &sGetTripleFromSid_Req, stream< NalTriple > &sGetTripleFromSid_Rep, stream< NalTriple > &sGetSidFromTriple_Req, stream< SessionId > &sGetSidFromTriple_Rep, stream< NalNewTableEntry > &sAddNewTriple_TcpRrh, stream< NalNewTableEntry > &sAddNewTriple_TcpCon, stream< SessionId > &sDeleteEntryBySid, stream< bool > &inval_del_sig, stream< SessionId > &sMarkAsPriv, stream< bool > &sMarkToDel_unpriv, stream< bool > &sGetNextDelRow_Req, stream< SessionId > &sGetNextDelRow_Rep)
	Contains the SessionId-Triple CAM for TCP sessions. It replies to stram requests. More...
ap_uint< 32 >	getRightmostBitPos (ap_uint< 32 > num)
NalTriple	newTriple (Ip4Addr ipRemoteAddres, TcpPort tcpRemotePort, TcpPort tcpLocalPort)
Ip4Addr	getRemoteIpAddrFromTriple (NalTriple triple)
TcpPort	getRemotePortFromTriple (NalTriple triple)
TcpPort	getLocalPortFromTriple (NalTriple triple)
uint8_t	extractByteCnt (AxisRaw currWord)
uint8_t	extractByteCnt (NetworkWord currWord)
void	pStatusMemory (stream< NalEventNotif > &internal_event_fifo, ap_uint< 1 > *layer_7_enabled, ap_uint< 1 > *role_decoupled, stream< NalConfigUpdate > &sConfigUpdate, stream< uint32_t > &mrt_version_update, stream< NalPortUpdate > &sNalPortUpdate, stream< NalStatusUpdate > &sStatusUpdate)
	Maps the individual event notification of the USS/TSS processes to the status array as part of the Axi4Lite address space. Forwards status changes to Axi4Lite processing. More...
void	eventFifoMerge (stream< NalEventNotif > &internal_event_fifo_0, stream< NalEventNotif > &internal_event_fifo_1, stream< NalEventNotif > &internal_event_fifo_2, stream< NalEventNotif > &internal_event_fifo_3, stream< NalEventNotif > &merged_fifo)
	Merges multiple fifos, where the order of the fifo represents also the priorities. More...
void	nal_main (ap_uint< 32 > ctrlLink[64+16+16], ap_uint< 1 > *layer_4_enabled, ap_uint< 1 > *layer_7_enabled, ap_uint< 1 > *role_decoupled, ap_uint< 1 > *piNTS_ready, ap_uint< 16 > *piMMIO_FmcLsnPort, ap_uint< 32 > *piMMIO_CfrmIp4Addr, ap_uint< 32 > *myIpAddress, ap_uint< 32 > *pi_udp_rx_ports, stream< NetworkWord > &siUdp_data, stream< NetworkWord > &soUdp_data, stream< NetworkMetaStream > &siUdp_meta, stream< NetworkMetaStream > &soUdp_meta, ap_uint< 32 > *pi_tcp_rx_ports, stream< NetworkWord > &siTcp_data, stream< NetworkMetaStream > &siTcp_meta, stream< NetworkWord > &soTcp_data, stream< NetworkMetaStream > &soTcp_meta, stream< NetworkWord > &siFMC_data, stream< TcpSessId > &siFMC_SessId, stream< NetworkWord > &soFMC_data, stream< TcpSessId > &soFMC_SessId, stream< UdpPort > &soUOE_LsnReq, stream< StsBool > &siUOE_LsnRep, stream< UdpPort > &soUOE_ClsReq, stream< StsBool > &siUOE_ClsRep, stream< UdpAppData > &siUOE_Data, stream< UdpAppMeta > &siUOE_Meta, stream< UdpAppDLen > &siUOE_DLen, stream< UdpAppData > &soUOE_Data, stream< UdpAppMeta > &soUOE_Meta, stream< UdpAppDLen > &soUOE_DLen, stream< TcpAppNotif > &siTOE_Notif, stream< TcpAppRdReq > &soTOE_DReq, stream< TcpAppData > &siTOE_Data, stream< TcpAppMeta > &siTOE_SessId, stream< TcpAppLsnReq > &soTOE_LsnReq, stream< TcpAppLsnRep > &siTOE_LsnRep, stream< TcpAppData > &soTOE_Data, stream< TcpAppSndReq > &soTOE_SndReq, stream< TcpAppSndRep > &siTOE_SndRep, stream< TcpAppOpnReq > &soTOE_OpnReq, stream< TcpAppOpnRep > &siTOE_OpnRep, stream< TcpAppClsReq > &soTOE_ClsReq)
	Main process of the Network Abstraction Layer (NAL) More...
void	pTcpLsn (stream< TcpAppLsnReq > &soTOE_LsnReq, stream< TcpAppLsnRep > &siTOE_LsnRep, stream< TcpPort > &sTcpPortsToOpen, stream< bool > &sTcpPortsOpenFeedback)
	Request the TOE to start listening (LSn) for incoming connections on a specific port (.i.e open connection for reception mode). More...
void	pTcpRxNotifEnq (ap_uint< 1 > *layer_4_enabled, ap_uint< 1 > *piNTS_ready, stream< TcpAppNotif > &siTOE_Notif, stream< TcpAppNotif > &sTcpNotif_buffer)
	Enqueus the incoming notificiations from TOE into the internal buffer. More...
void	pTcpRRh (ap_uint< 1 > *layer_4_enabled, ap_uint< 1 > *piNTS_ready, ap_uint< 32 > *piMMIO_CfrmIp4Addr, ap_uint< 16 > *piMMIO_FmcLsnPort, stream< TcpAppNotif > &siTOE_Notif, stream< TcpAppRdReq > &soTOE_DReq, stream< NalNewTableEntry > &sAddNewTriple_TcpRrh, stream< SessionId > &sMarkAsPriv, stream< SessionId > &sDeleteEntryBySid, stream< TcpAppRdReq > &sRDp_ReqNotif, stream< PacketLen > &fmc_write_cnt_sig, stream< PacketLen > &role_write_cnt_sig)
	ReadRequestHandler (RRh). Waits for a notification indicating the availability of new data for the ROLE or FMC. More...
void	pTcpRDp (ap_uint< 1 > *layer_4_enabled, ap_uint< 1 > *piNTS_ready, stream< TcpAppRdReq > &sRDp_ReqNotif, stream< TcpAppData > &siTOE_Data, stream< TcpAppMeta > &siTOE_SessId, stream< NetworkWord > &soFMC_data, stream< TcpSessId > &soFMC_SessId, stream< NetworkWord > &soTcp_data, stream< NetworkMetaStream > &soTcp_meta, stream< NalConfigUpdate > &sConfigUpdate, stream< Ip4Addr > &sGetNidReq_TcpRx, stream< NodeId > &sGetNidRep_TcpRx, stream< SessionId > &sGetTripleFromSid_Req, stream< NalTriple > &sGetTripleFromSid_Rep, ap_uint< 32 > *piMMIO_CfrmIp4Addr, ap_uint< 16 > *piMMIO_FmcLsnPort, ap_uint< 1 > *layer_7_enabled, ap_uint< 1 > *role_decoupled, stream< bool > &cache_inval_sig, stream< NalEventNotif > &internal_event_fifo)
	Read Path (RDp) - From TOE to ROLE or FMC. Process waits for a new data segment to read and forwards it to ROLE or FMC. Invalid packets are dropped. More...
void	pRoleTcpRxDeq (ap_uint< 1 > *layer_7_enabled, ap_uint< 1 > *role_decoupled, stream< NetworkWord > &sRoleTcpDataRx_buffer, stream< NetworkMetaStream > &sRoleTcpMetaRx_buffer, stream< NetworkWord > &soTcp_data, stream< NetworkMetaStream > &soTcp_meta, stream< PacketLen > &role_write_cnt_sig)
	Terminates the internal TCP RX FIFOs and forwards packets to the Role. More...
void	pFmcTcpRxDeq (stream< NetworkWord > &sFmcTcpDataRx_buffer, stream< TcpSessId > &sFmcTcpMetaRx_buffer, stream< NetworkWord > &soFmc_data, stream< TcpSessId > &soFmc_meta, stream< PacketLen > &fmc_write_cnt_sig)
	Terminates the internal TCP RX FIFOs and forwards packets to the FMC. More...
void	pTcpWRp (ap_uint< 1 > *layer_4_enabled, ap_uint< 1 > *piNTS_ready, stream< NetworkWord > &siFMC_data, stream< TcpSessId > &siFMC_SessId, stream< NetworkWord > &siTcp_data, stream< NetworkMetaStream > &siTcp_meta, stream< TcpAppData > &soTOE_Data, stream< TcpAppMeta > &soTOE_SessId, stream< TcpDatLen > &soTOE_len, stream< NodeId > &sGetIpReq_TcpTx, stream< Ip4Addr > &sGetIpRep_TcpTx, stream< NalTriple > &sGetSidFromTriple_Req, stream< SessionId > &sGetSidFromTriple_Rep, stream< NalTriple > &sNewTcpCon_Req, stream< NalNewTcpConRep > &sNewTcpCon_Rep, stream< bool > &cache_inval_sig, stream< NalEventNotif > &internal_event_fifo)
	Write Path (WRp) - From ROLE or FMC to TOE. Process waits for a new data segment to write and forwards it to TOE. More...
void	pTcpWBu (ap_uint< 1 > *layer_4_enabled, ap_uint< 1 > *piNTS_ready, stream< TcpAppData > &siWrp_Data, stream< TcpAppMeta > &siWrp_SessId, stream< TcpDatLen > &siWrp_len, stream< TcpAppData > &soTOE_Data, stream< TcpAppSndReq > &soTOE_SndReq, stream< TcpAppSndRep > &siTOE_SndRep)
	Write Buffer (WBu) - From WRp to TOE. Process to synchronize with TOE's TX buffer (and it's available space). In case of streaming mode (i.e. ROLE's length was 0), WRp takes care of splitting the data and writing the right len. More...
void	pTcpCOn (stream< TcpAppOpnReq > &soTOE_OpnReq, stream< TcpAppOpnRep > &siTOE_OpnRep, stream< NalNewTableEntry > &sAddNewTriple_TcpCon, stream< NalTriple > &sNewTcpCon_Req, stream< NalNewTcpConRep > &sNewTcpCon_Rep)
	Client connection to remote HOST or FPGA socket (COn). More...
void	pTcpCls (stream< TcpAppClsReq > &soTOE_ClsReq, stream< bool > &sGetNextDelRow_Req, stream< SessionId > &sGetNextDelRow_Rep, stream< bool > &sStartTclCls)
	Asks the TOE to close Tcp connections, based on the request from pPortLogic. More...
void	pUdpTX (stream< NetworkWord > &siUdp_data, stream< NetworkMetaStream > &siUdp_meta, stream< UdpAppData > &soUOE_Data, stream< UdpAppMeta > &soUOE_Meta, stream< UdpAppDLen > &soUOE_DLen, stream< NodeId > &sGetIpReq_UdpTx, stream< Ip4Addr > &sGetIpRep_UdpTx, const ap_uint< 32 > *ipAddrBE, stream< bool > &cache_inval_sig, stream< NalEventNotif > &internal_event_fifo)
	Processes the outgoing UDP packets (i.e. ROLE -> Network). More...
void	pUoeUdpTxDeq (ap_uint< 1 > *layer_4_enabled, ap_uint< 1 > *piNTS_ready, stream< UdpAppData > &sUoeTxBuffer_Data, stream< UdpAppMeta > &sUoeTxBuffer_Meta, stream< UdpAppDLen > &sUoeTxBuffer_DLen, stream< UdpAppData > &soUOE_Data, stream< UdpAppMeta > &soUOE_Meta, stream< UdpAppDLen > &soUOE_DLen)
	Terminates the internal UDP TX FIFOs and forwards packets to the UOE. More...
void	pUdpLsn (stream< UdpPort > &soUOE_LsnReq, stream< StsBool > &siUOE_LsnRep, stream< UdpPort > &sUdpPortsToOpen, stream< bool > &sUdpPortsOpenFeedback)
	Asks the UOE to open new UDP ports for listening, based on the request from pPortLogic. More...
void	pUdpRx (ap_uint< 1 > *layer_7_enabled, ap_uint< 1 > *role_decoupled, stream< NetworkWord > &soUdp_data, stream< NetworkMetaStream > &soUdp_meta, stream< UdpAppData > &siUOE_Data, stream< UdpAppMeta > &siUOE_Meta, stream< UdpAppDLen > &siUOE_DLen, stream< NalConfigUpdate > &sConfigUpdate, stream< Ip4Addr > &sGetNidReq_UdpRx, stream< NodeId > &sGetNidRep_UdpRx, stream< bool > &cache_inval_sig, stream< NalEventNotif > &internal_event_fifo)
	Processes the incoming UDP packets (i.e. Network -> ROLE ). More...
void	pRoleUdpRxDeq (ap_uint< 1 > *layer_7_enabled, ap_uint< 1 > *role_decoupled, stream< NetworkWord > &sRoleUdpDataRx_buffer, stream< NetworkMetaStream > &sRoleUdpMetaRx_buffer, stream< NetworkWord > &soUdp_data, stream< NetworkMetaStream > &soUdp_meta)
	Terminates the internal UDP RX FIFOs and forwards packets to the Role. More...
void	pUdpCls (stream< UdpPort > &soUOE_ClsReq, stream< StsBool > &siUOE_ClsRep, stream< UdpPort > &sUdpPortsToClose)
	Asks the UOE to close UDP ports, based on the request from pPortLogic. More...
stream< UdpPort >	sNRC_UOE_LsnReq ("sNRC_UOE_LsnReq")
stream< StsBool >	sUOE_NRC_LsnRep ("sUOE_NRC_LsnRep")
stream< UdpPort >	sNRC_UOE_ClsReq ("sNRC_UOE_ClsReq")
stream< StsBool >	sUOE_NRC_ClsRep ("sUOE_NRC_ClsRep")
stream< UdpAppData >	sUOE_NRC_Data ("sUOE_NRC_Data")
stream< UdpAppMeta >	sUOE_NRC_Meta ("sUOE_NRC_Meta")
stream< UdpAppDLen >	sUOE_NRC_DLen ("sUOE_NRC_DLen")
stream< UdpAppData >	sNRC_UOE_Data ("sNRC_UOE_Data")
stream< UdpAppMeta >	sNRC_UOE_Meta ("sNRC_UOE_Meta")
stream< UdpAppDLen >	sNRC_UOE_DLen ("sNRC_UOE_DLen")
stream< NetworkMetaStream >	siUdp_meta ("siUdp_meta")
stream< NetworkMetaStream >	soUdp_meta ("soUdp_meta")
stream< NetworkWord >	sROLE_NRC_Data ("sROLE_NRC_Data")
stream< NetworkWord >	sNRC_Role_Data ("sNRC_Role_Data")
stream< NetworkWord >	sROLE_Nrc_Tcp_data ("sROLE_Nrc_Tcp_data")
stream< NetworkMetaStream >	sROLE_Nrc_Tcp_meta ("sROLE_Nrc_Tcp_meta")
stream< NetworkWord >	sNRC_Role_Tcp_data ("sNRC_Role_Tcp_data")
stream< NetworkMetaStream >	sNRC_Role_Tcp_meta ("sNRC_Role_Tcp_meta")
stream< NetworkWord >	sFMC_Nrc_Tcp_data ("sFMC_Nrc_Tcp_data")
stream< TcpSessId >	sFMC_Nrc_Tcp_sessId ("sFMC_Nrc_Tcp_sessId")
stream< NetworkWord >	sNRC_FMC_Tcp_data ("sNRC_FMC_Tcp_data")
stream< TcpSessId >	sNRC_FMC_Tcp_sessId ("sNRC_FMC_Tcp_sessId")
stream< TcpAppNotif >	sTOE_Nrc_Notif ("sTOE_Nrc_Notif")
stream< TcpAppRdReq >	sNRC_Toe_DReq ("sNrc_TOE_DReq")
stream< TcpAppData >	sTOE_Nrc_Data ("sTOE_Nrc_Data")
stream< TcpAppMeta >	sTOE_Nrc_SessId ("sTOE_Nrc_SessId")
stream< TcpAppLsnReq >	sNRC_Toe_LsnReq ("sNRC_TOE_LsnReq")
stream< TcpAppLsnRep >	sTOE_Nrc_LsnAck ("sTOE_Nrc_LsnAck")
stream< TcpAppData >	sNRC_Toe_Data ("sNRC_TOE_Data")
stream< TcpAppSndReq >	sNRC_Toe_SndReq ("sNRC_TOE_SndReq")
stream< TcpAppSndRep >	sTOE_Nrc_SndRep ("sTOE_NRC_SndRep")
stream< TcpAppOpnReq >	sNRC_Toe_OpnReq ("sNRC_Toe_OpnReq")
stream< TcpAppOpnRep >	sTOE_Nrc_OpnRep ("sTOE_NRC_OpenRep")
stream< TcpAppClsReq >	sNRC_Toe_ClsReq ("sNRC_TOE_ClsReq")
void	stepDut ()
	Run a single iteration of the DUT model. More...
bool	setInputDataStream (stream< UdpAppData > &sDataStream, const string dataStreamName, const string inpFileName)
	Initialize an input data stream from a file. More...
bool	setInputDataStream (stream< NetworkWord > &sDataStream, const string dataStreamName, const string inpFileName)
bool	setInputMetaStream (stream< UdpAppMeta > &sMetaStream, const string dataStreamName, const string inpFileName)
	Initialize an input meta stream from a file. More...
bool	readDataStream (stream< UdpAppData > &sDataStream, UdpAppData *udpWord)
	Read data from a stream. More...
bool	readMetaStream (stream< UdpAppMeta > &sMetaStream, const string metaStreamName, UdpAppMeta *udpMeta)
	Read an output metadata stream from the DUT. More...
bool	readPLenStream (stream< UdpPLen > &sPLenStream, const string plenStreamName, UdpPLen *udpPLen)
	Read an output payload length stream from the DUT. More...
bool	dumpDataToFile (UdpAppData *udpWord, ofstream &outFileStream)
	Dump a data word to a file. More...
bool	dumpDataToFile (NetworkWord *udpWord, ofstream &outFileStream)
bool	dumpMetaToFile (UdpAppMeta *udpMeta, ofstream &outFileStream)
	Dump a metadata information to a file. More...
bool	dumpPLenToFile (UdpPLen *udpPLen, ofstream &outFileStream)
	Dump a payload length information to a file. More...
bool	getOutputDataStream (stream< UdpAppData > &sDataStream, const string dataStreamName, const string outFileName)
	Fill an output file with data from an output stream. More...
bool	getOutputDataStream (stream< NetworkWord > &sDataStream, const string dataStreamName, const string outFileName)
bool	getOutputMetaStream (stream< UdpAppMeta > &sMetaStream, const string metaStreamName, const string outFileName)
	Fill an output file with metadata from an output stream. More...
bool	getOutputPLenStream (stream< UdpPLen > &sPLenStream, const string plenStreamName, const string outFileName)
	Fill an output file with payload length from an output stream. More...
void	pFMC (stream< NetworkWord > &siTRIF_Data, stream< TcpSessId > &siTRIF_SessId, stream< NetworkWord > &soTRIF_Data, stream< TcpSessId > &soTRIF_SessId)
	Emulate the behavior of the FMC. More...
void	pROLE (stream< NetworkWord > &siTRIF_Data, stream< NetworkMetaStream > &siTRIF_meta, stream< NetworkWord > &soTRIF_Data, stream< NetworkMetaStream > &soTRIF_meta)
	Emulate the behavior of the ROLE. More...
void	pTOE (int &nrErr, stream< TcpAppNotif > &soTRIF_Notif, stream< TcpAppRdReq > &siTRIF_DReq, stream< TcpAppData > &soTRIF_Data, stream< TcpAppMeta > &soTRIF_SessId, stream< TcpAppLsnReq > &siTRIF_LsnReq, stream< TcpAppLsnRep > &soTRIF_LsnAck, stream< TcpAppData > &siTRIF_Data, stream< TcpAppSndReq > &siTRIF_SndReq, stream< TcpAppSndRep > &soTRIF_SndRep, stream< TcpAppOpnReq > &siTRIF_OpnReq, stream< TcpAppOpnRep > &soTRIF_OpnRep)
int	main ()
	Main Testbench Loop; Emulates also the behavior of the UDP Offload Engine (UOE). More...

Variables
bool	gTraceEvent
ap_uint< 1 >	layer_4_enabled = 0b1
ap_uint< 1 >	layer_7_enabled = 0b1
ap_uint< 1 >	role_decoupled = 0b0
ap_uint< 1 >	sNTS_Nrc_ready = 0b1
ap_uint< 32 >	sIpAddress = 0x0a0b0c0d
ap_uint< 32 >	ctrlLink [64+16+16]
ap_uint< 32 >	s_udp_rx_ports = 0x1
ap_uint< 32 >	s_tcp_rx_ports = 0x1
ap_uint< 32 >	myIpAddress
ap_uint< 16 >	sMMIO_FmcLsnPort = 8803
ap_uint< 32 >	sMMIO_CfrmIp4Addr = 0x0A0CC832
unsigned int	gSimCycCnt = 0
bool	gTraceEvent = false
bool	gFatalError = false
unsigned int	simCnt
int	tcp_packets_send = 0
int	tcp_packets_recv = 0
int	tcp_recv_frag_cnt = 0
int	tcp_packets_expected_timeout = 0
int	tcp_timout_packet_drop = 0
enum RxFsmStates	rxFsmState = RX_WAIT_META
enum RoleFsmStates	roleFsmState = ROLE_WAIT_META
Ip4Addr	hostIp4Addr = 0
	Emulate the behavior of the TCP Offload Engine (TOE). More...
TcpPort	fpgaLsnPort = -1
TcpPort	hostSrcPort = 80
int	loop = 1
enum LsnStates	lsnState = LSN_WAIT_REQ
enum OpnStates	opnState = OPN_WAIT_REQ
enum RxpStates	rxpState = RXP_SEND_NOTIF
enum TxpStates	txpState = TXP_WAIT_REQ
int	opnStartupDelay = 0
int	rxpStartupDelay = 100
int	txpStartupDelay = 0
TcpAppRdReq	appRdReq
AppMeta	sessionId = 42
AppMeta	sessionId_reply = 42
int	byteCnt = 0
int	segCnt = 0
int	nrSegToSend = 3
ap_uint< 64 >	data =0
TcpSegLen	tcpSegLen = 32
const char *	myLsnName = "NAL" "/" "TOE/Listen"
const char *	myOpnName = "NAL" "/" "TOE/OpnCon"
const char *	myRxpName = "NAL" "/" "TOE/RxPath"
const char *	myTxpName = "NAL" "/" "TOE/TxPath"

Detailed Description

Network Abstraction Layer (NAL). The NAL separates the privileged management traffic from the unprivileged Role traffic. It also abstracts the details of port opening, connection handling and IP Address translation. The documentation of NAL is available at https://pages.github.ibm.com/cloudFPGA/Doc/pages/cfdk.html#network-abstraction-layer-nal.

Macro Definition Documentation

_NAL_KVP_DEF_ [1/2]

#define _NAL_KVP_DEF_

Definition at line 40 of file cam16.hpp.

_NAL_KVP_DEF_ [2/2]

#define _NAL_KVP_DEF_

Definition at line 39 of file cam8.hpp.

DEBUG_LEVEL [1/2]

#define DEBUG_LEVEL   (TRACE_ALL)

Definition at line 123 of file nal.hpp.

DEBUG_LEVEL [2/2]

#define DEBUG_LEVEL   (TRACE_TOE | TRACE_ROLE)

Definition at line 58 of file tb_nal.cpp.

DEBUG_TRACE

#define DEBUG_TRACE   true

Definition at line 45 of file tb_nal.cpp.

DEFAULT_FPGA_IP4_ADDR

#define DEFAULT_FPGA_IP4_ADDR   0x0A0CC801

Definition at line 70 of file tb_nal.cpp.

DEFAULT_FPGA_LSN_PORT

#define DEFAULT_FPGA_LSN_PORT   0x0057

Definition at line 71 of file tb_nal.cpp.

DEFAULT_HOST_IP4_ADDR

#define DEFAULT_HOST_IP4_ADDR   0x0A0CC832

Definition at line 72 of file tb_nal.cpp.

DEFAULT_HOST_LSN_PORT

#define DEFAULT_HOST_LSN_PORT   0x80

Definition at line 73 of file tb_nal.cpp.

DEFAULT_RX_PORT

#define DEFAULT_RX_PORT   2718

Definition at line 139 of file nal.hpp.

DEFAULT_SESSION_ID

#define DEFAULT_SESSION_ID   42

Definition at line 75 of file tb_nal.cpp.

DEFAULT_SESSION_LEN

#define DEFAULT_SESSION_LEN   32

Definition at line 76 of file tb_nal.cpp.

DEFAULT_TCP_LEN_REP

#define DEFAULT_TCP_LEN_REP   16

Definition at line 79 of file tb_nal.cpp.

DEFAULT_TX_PORT

#define DEFAULT_TX_PORT   2718

Definition at line 138 of file nal.hpp.

INVALID_MRT_VALUE

#define INVALID_MRT_VALUE   0xFFFFF

Definition at line 203 of file nal.hpp.

MAX_MRT_SIZE

#define MAX_MRT_SIZE   64

Definition at line 94 of file nal.hpp.

MAX_NAL_SESSIONS

#define MAX_NAL_SESSIONS   (TOE_MAX_SESSIONS)

Definition at line 186 of file nal.hpp.

MAX_SIM_CYCLES

#define MAX_SIM_CYCLES   450

Definition at line 63 of file tb_nal.cpp.

NAL_AUTHORIZED_ACCESS

#define NAL_AUTHORIZED_ACCESS   5

Definition at line 231 of file nal.hpp.

NAL_CONFIG_MRT_VERSION

#define NAL_CONFIG_MRT_VERSION   1

Definition at line 216 of file nal.hpp.

NAL_CONFIG_OWN_RANK

#define NAL_CONFIG_OWN_RANK   0

Definition at line 215 of file nal.hpp.

NAL_CONFIG_SAVED_FMC_PORTS

#define NAL_CONFIG_SAVED_FMC_PORTS   4

Definition at line 219 of file nal.hpp.

NAL_CONFIG_SAVED_TCP_PORTS

#define NAL_CONFIG_SAVED_TCP_PORTS   3

Definition at line 218 of file nal.hpp.

NAL_CONFIG_SAVED_UDP_PORTS

#define NAL_CONFIG_SAVED_UDP_PORTS   2

Definition at line 217 of file nal.hpp.

NAL_CONNECTION_TIMEOUT

#define NAL_CONNECTION_TIMEOUT   160000000

Definition at line 196 of file nal.hpp.

NAL_CTRL_LINK_CONFIG_END_ADDR

#define NAL_CTRL_LINK_CONFIG_END_ADDR   (0x23F/4)

Definition at line 84 of file nal.hpp.

NAL_CTRL_LINK_CONFIG_START_ADDR

#define NAL_CTRL_LINK_CONFIG_START_ADDR   (0x200/4)

Definition at line 83 of file nal.hpp.

NAL_CTRL_LINK_MRT_END_ADDR

#define NAL_CTRL_LINK_MRT_END_ADDR   (0x37F/4)

Definition at line 88 of file nal.hpp.

NAL_CTRL_LINK_MRT_START_ADDR

#define NAL_CTRL_LINK_MRT_START_ADDR   (0x280/4)

Definition at line 87 of file nal.hpp.

NAL_CTRL_LINK_SIZE

#define NAL_CTRL_LINK_SIZE   (XNAL_PIFMC_NAL_CTRLLINK_AXI_ADDR_CTRLLINK_V_HIGH/4)

Definition at line 82 of file nal.hpp.

NAL_CTRL_LINK_STATUS_END_ADDR

#define NAL_CTRL_LINK_STATUS_END_ADDR   (0x27F/4)

Definition at line 86 of file nal.hpp.

NAL_CTRL_LINK_STATUS_START_ADDR

#define NAL_CTRL_LINK_STATUS_START_ADDR   (0x240/4)

Definition at line 85 of file nal.hpp.

NAL_MAX_FIFO_DEPTHS_BYTES

#define NAL_MAX_FIFO_DEPTHS_BYTES   2000

Definition at line 190 of file nal.hpp.

NAL_MMIO_STABILIZE_TIME

#define NAL_MMIO_STABILIZE_TIME   150

Definition at line 199 of file nal.hpp.

NAL_NUMBER_CONFIG_WORDS

#define NAL_NUMBER_CONFIG_WORDS   NUMBER_CONFIG_WORDS

Definition at line 193 of file nal.hpp.

NAL_NUMBER_STATUS_WORDS

#define NAL_NUMBER_STATUS_WORDS   NUMBER_STATUS_WORDS

Definition at line 194 of file nal.hpp.

NAL_STATUS_FMC_PORT_PROCESSED

#define NAL_STATUS_FMC_PORT_PROCESSED   3

Definition at line 224 of file nal.hpp.

NAL_STATUS_GLOBAL_STATE

#define NAL_STATUS_GLOBAL_STATE   8

Definition at line 235 of file nal.hpp.

NAL_STATUS_LAST_RX_NODE_ID

#define NAL_STATUS_LAST_RX_NODE_ID   9

Definition at line 236 of file nal.hpp.

NAL_STATUS_LAST_TX_NODE_ID

#define NAL_STATUS_LAST_TX_NODE_ID   11

Definition at line 238 of file nal.hpp.

NAL_STATUS_MRT_VERSION

#define NAL_STATUS_MRT_VERSION   0

Definition at line 221 of file nal.hpp.

NAL_STATUS_OPEN_TCP_PORTS

#define NAL_STATUS_OPEN_TCP_PORTS   2

Definition at line 223 of file nal.hpp.

NAL_STATUS_OPEN_UDP_PORTS

#define NAL_STATUS_OPEN_UDP_PORTS   1

Definition at line 222 of file nal.hpp.

NAL_STATUS_OWN_RANK

#define NAL_STATUS_OWN_RANK   13

Definition at line 225 of file nal.hpp.

NAL_STATUS_PACKET_CNT_RX

#define NAL_STATUS_PACKET_CNT_RX   14

Definition at line 241 of file nal.hpp.

NAL_STATUS_PACKET_CNT_TX

#define NAL_STATUS_PACKET_CNT_TX   15

Definition at line 242 of file nal.hpp.

NAL_STATUS_RECEIVE_STATE

#define NAL_STATUS_RECEIVE_STATE   7

Definition at line 234 of file nal.hpp.

NAL_STATUS_RX_NODEID_ERROR

#define NAL_STATUS_RX_NODEID_ERROR   10

Definition at line 237 of file nal.hpp.

NAL_STATUS_SEND_STATE

#define NAL_STATUS_SEND_STATE   6

Definition at line 233 of file nal.hpp.

NAL_STATUS_TX_NODEID_ERROR

#define NAL_STATUS_TX_NODEID_ERROR   12

Definition at line 239 of file nal.hpp.

NAL_STREAMING_SPLIT_TCP

#define NAL_STREAMING_SPLIT_TCP   (ZYC2_MSS)

Definition at line 187 of file nal.hpp.

NAL_TCP_RX_DATA_DELAY_CYCLES

#define NAL_TCP_RX_DATA_DELAY_CYCLES   80

Definition at line 197 of file nal.hpp.

NAL_UNAUTHORIZED_ACCESS

#define NAL_UNAUTHORIZED_ACCESS   4

Definition at line 229 of file nal.hpp.

NUMBER_CONFIG_WORDS

#define NUMBER_CONFIG_WORDS   16

Definition at line 191 of file nal.hpp.

NUMBER_STATUS_WORDS

#define NUMBER_STATUS_WORDS   16

Definition at line 192 of file nal.hpp.

THIS_NAME [1/2]

#define THIS_NAME   "NAL"

Definition at line 113 of file nal.hpp.

THIS_NAME [2/2]

#define THIS_NAME   "TB"

Definition at line 51 of file tb_nal.cpp.

TRACE_ALL [1/2]

#define TRACE_ALL   0xFFFF

Definition at line 121 of file nal.hpp.

TRACE_ALL [2/2]

#define TRACE_ALL   0xFFFF

Definition at line 56 of file tb_nal.cpp.

TRACE_CON

#define TRACE_CON   1 << 5

Definition at line 120 of file nal.hpp.

TRACE_LSN

#define TRACE_LSN   1 << 4

Definition at line 119 of file nal.hpp.

TRACE_OFF [1/2]

#define TRACE_OFF   0x0000

Definition at line 115 of file nal.hpp.

TRACE_OFF [2/2]

#define TRACE_OFF   0x0000

Definition at line 53 of file tb_nal.cpp.

TRACE_RDP

#define TRACE_RDP   1 << 1

Definition at line 116 of file nal.hpp.

TRACE_ROLE

#define TRACE_ROLE   1 << 2

Definition at line 55 of file tb_nal.cpp.

TRACE_SAM

#define TRACE_SAM   1 << 3

Definition at line 118 of file nal.hpp.

TRACE_TOE

#define TRACE_TOE   1 << 1

Definition at line 54 of file tb_nal.cpp.

TRACE_WRP

#define TRACE_WRP   1 << 2

Definition at line 117 of file nal.hpp.

UNUSED_SESSION_ENTRY_VALUE

#define UNUSED_SESSION_ENTRY_VALUE   0xFFFE

Definition at line 202 of file nal.hpp.

UNUSED_TABLE_ENTRY_VALUE

#define UNUSED_TABLE_ENTRY_VALUE   0x111000

Definition at line 201 of file nal.hpp.

UNVALID

#define UNVALID   false

Definition at line 44 of file tb_nal.cpp.

VALID

#define VALID   true

Definition at line 43 of file tb_nal.cpp.

XNAL_PIFMC_NAL_CTRLLINK_AXI_ADDR_CTRLLINK_V_BASE

#define XNAL_PIFMC_NAL_CTRLLINK_AXI_ADDR_CTRLLINK_V_BASE   0x200

Definition at line 78 of file nal.hpp.

XNAL_PIFMC_NAL_CTRLLINK_AXI_ADDR_CTRLLINK_V_HIGH

#define XNAL_PIFMC_NAL_CTRLLINK_AXI_ADDR_CTRLLINK_V_HIGH   0x3ff

Definition at line 79 of file nal.hpp.

XNAL_PIFMC_NAL_CTRLLINK_AXI_DEPTH_CTRLLINK_V

#define XNAL_PIFMC_NAL_CTRLLINK_AXI_DEPTH_CTRLLINK_V   96

Definition at line 81 of file nal.hpp.

XNAL_PIFMC_NAL_CTRLLINK_AXI_WIDTH_CTRLLINK_V

#define XNAL_PIFMC_NAL_CTRLLINK_AXI_WIDTH_CTRLLINK_V   32

Definition at line 80 of file nal.hpp.

Typedef Documentation

NalTriple

typedef ap_uint<64> NalTriple

Definition at line 273 of file nal.hpp.

PacketLen

typedef ap_uint<16> PacketLen

Definition at line 260 of file nal.hpp.

StsBool

typedef bool StsBool

Definition at line 246 of file nal.hpp.

UdpAppDLen

typedef UdpLen UdpAppDLen

Definition at line 255 of file nal.hpp.

UdpDstPort

typedef ap_uint<16> UdpDstPort

Definition at line 248 of file nal.hpp.

UdpLen

typedef ap_uint<16> UdpLen

Definition at line 250 of file nal.hpp.

UdpPLen

typedef UdpAppDLen UdpPLen

Definition at line 258 of file nal.hpp.

UdpPort

typedef ap_uint<16> UdpPort

Definition at line 249 of file nal.hpp.

UdpSrcPort

typedef ap_uint<16> UdpSrcPort

Definition at line 247 of file nal.hpp.

Enumeration Type Documentation

AxiLiteFsmStates

enum AxiLiteFsmStates

Enumerator
A4L_RESET
A4L_STATUS_UPDATE
A4L_COPY_CONFIG
A4L_COPY_CONFIG_2
A4L_COPY_MRT
A4L_COPY_STATUS
A4L_COPY_FINISH
A4L_WAIT_FOR_SUB_FSMS

Definition at line 168 of file nal.hpp.

                      {A4L_RESET = 0, A4L_STATUS_UPDATE, A4L_COPY_CONFIG, A4L_COPY_CONFIG_2, \
  //A4L_BROADCAST_CONFIG_1, A4L_BROADCAST_CONFIG_2,
  A4L_COPY_MRT, A4L_COPY_STATUS, A4L_COPY_FINISH, A4L_WAIT_FOR_SUB_FSMS};

CacheInvalFsmStates

enum CacheInvalFsmStates

Enumerator
CACHE_WAIT_FOR_VALID
CACHE_VALID
CACHE_INV_SEND_0
CACHE_INV_SEND_1
CACHE_INV_SEND_2
CACHE_INV_SEND_3

Definition at line 160 of file nal.hpp.

{CACHE_WAIT_FOR_VALID = 0, CACHE_VALID, CACHE_INV_SEND_0, CACHE_INV_SEND_1, CACHE_INV_SEND_2, CACHE_INV_SEND_3};

ClsFsmStates

enum ClsFsmStates

Enumerator
CLS_IDLE
CLS_NEXT
CLS_WAIT4RESP

Definition at line 162 of file nal.hpp.

{CLS_IDLE = 0, CLS_NEXT, CLS_WAIT4RESP};

ConfigBcastStates

enum ConfigBcastStates

Enumerator
CB_WAIT
CB_START
CB_1
CB_2
CB_3_0
CB_3_1
CB_3_2

Definition at line 172 of file nal.hpp.

{CB_WAIT = 0, CB_START, CB_1, CB_2, CB_3_0, CB_3_1, CB_3_2};

DeqFsmStates

enum DeqFsmStates

Enumerator
DEQ_WAIT_META
DEQ_STREAM_DATA
DEQ_SEND_NOTIF

Definition at line 164 of file nal.hpp.

{DEQ_WAIT_META = 0, DEQ_STREAM_DATA, DEQ_SEND_NOTIF};

DropCmd

enum DropCmd

Enumerator
KEEP_CMD
DROP_CMD
KEEP_CMD
DROP_CMD

Definition at line 125 of file nal.hpp.

{KEEP_CMD=false, DROP_CMD};

FsmStateUdp

enum FsmStateUdp

Enumerator
FSM_RESET
FSM_W8FORMETA
FSM_W8FORREQS
FSM_FIRST_ACC
FSM_ACC
FSM_WRITE_META
FSM_DROP_PACKET

Definition at line 141 of file nal.hpp.

                 {FSM_RESET = 0, FSM_W8FORMETA, FSM_W8FORREQS, FSM_FIRST_ACC, FSM_ACC, \
  FSM_WRITE_META, FSM_DROP_PACKET};

LsnFsmStates

enum LsnFsmStates

Enumerator
LSN_IDLE
LSN_SEND_REQ
LSN_WAIT_ACK
LSN_DONE

Definition at line 146 of file nal.hpp.

{LSN_IDLE = 0, LSN_SEND_REQ, LSN_WAIT_ACK, LSN_DONE};

LsnStates

enum LsnStates

Enumerator
LSN_WAIT_REQ
LSN_SEND_ACK

Definition at line 816 of file tb_nal.cpp.

{ LSN_WAIT_REQ,   LSN_SEND_ACK}  lsnState = LSN_WAIT_REQ;

NalCntIncType

enum NalCntIncType

Enumerator
NID_MISS_RX
NID_MISS_TX
PCOR_TX
TCP_CON_FAIL
LAST_RX_PORT
LAST_RX_NID
LAST_TX_PORT
LAST_TX_NID
PACKET_RX
PACKET_TX
UNAUTH_ACCESS
AUTH_ACCESS
FMC_TCP_BYTES

Definition at line 181 of file nal.hpp.

                   {NID_MISS_RX = 0, NID_MISS_TX, PCOR_TX, TCP_CON_FAIL, LAST_RX_PORT, \
  LAST_RX_NID, LAST_TX_PORT, LAST_TX_NID, PACKET_RX, PACKET_TX, UNAUTH_ACCESS, \
    AUTH_ACCESS, FMC_TCP_BYTES};

OpnFsmStates

enum OpnFsmStates

Enumerator
OPN_IDLE
OPN_REQ
OPN_REP
OPN_DONE

Definition at line 144 of file nal.hpp.

{OPN_IDLE = 0, OPN_REQ, OPN_REP, OPN_DONE};

OpnStates

enum OpnStates

Enumerator
OPN_WAIT_REQ
OPN_SEND_REP
OPN_TIMEOUT

Definition at line 817 of file tb_nal.cpp.

{ OPN_WAIT_REQ,   OPN_SEND_REP, OPN_TIMEOUT}  opnState = OPN_WAIT_REQ;

PortFsmStates

enum PortFsmStates

Enumerator
PORT_RESET
PORT_IDLE
PORT_L4_RESET
PORT_NEW_UDP_REQ
PORT_NEW_UDP_REP
PORT_NEW_FMC_REQ
PORT_NEW_FMC_REP
PORT_NEW_TCP_REQ
PORT_NEW_TCP_REP
PORT_L7_RESET
PORT_WAIT_PR
PORT_START_TCP_CLS_0
PORT_START_TCP_CLS_1
PORT_START_TCP_CLS_2
PORT_START_UDP_CLS
PORT_SEND_UPDATE

Definition at line 175 of file nal.hpp.

                   {PORT_RESET = 0, PORT_IDLE, PORT_L4_RESET, PORT_NEW_UDP_REQ, PORT_NEW_UDP_REP, \
  PORT_NEW_FMC_REQ, PORT_NEW_FMC_REP, PORT_NEW_TCP_REQ, PORT_NEW_TCP_REP, PORT_L7_RESET, \
    PORT_WAIT_PR, PORT_START_TCP_CLS_0, PORT_START_TCP_CLS_1, PORT_START_TCP_CLS_2, PORT_START_UDP_CLS, PORT_SEND_UPDATE};

PortType

enum PortType

Enumerator
FMC
UDP
TCP

Definition at line 179 of file nal.hpp.

{FMC = 0, UDP, TCP};

RdpFsmStates

enum RdpFsmStates

Enumerator
RDP_RESET
RDP_WAIT_META
RDP_W8FORREQS_1
RDP_W8FORREQS_2
RDP_FILTER_META
RDP_STREAM_ROLE
RDP_STREAM_FMC
RDP_WRITE_META_ROLE
RDP_WRITE_META_FMC
RDP_DROP_PACKET

Definition at line 152 of file nal.hpp.

                  {RDP_RESET = 0, RDP_WAIT_META, RDP_W8FORREQS_1, RDP_W8FORREQS_2, RDP_FILTER_META, RDP_STREAM_ROLE, RDP_STREAM_FMC, \
  RDP_WRITE_META_ROLE, RDP_WRITE_META_FMC, RDP_DROP_PACKET};

RoleFsmStates

enum RoleFsmStates

Enumerator
ROLE_WAIT_META
ROLE_STREAM

Definition at line 734 of file tb_nal.cpp.

{ ROLE_WAIT_META=0, ROLE_STREAM } roleFsmState = ROLE_WAIT_META;

RrhEnqFsmStates

enum RrhEnqFsmStates

Enumerator
RRH_ENQ_RESET
RRH_ENQ_STREAM

Definition at line 150 of file nal.hpp.

{RRH_ENQ_RESET = 0, RRH_ENQ_STREAM};

RrhFsmStates

enum RrhFsmStates

Enumerator
RRH_RESET
RRH_WAIT_NOTIF
RRH_PROCESS_NOTIF
RRH_START_REQUEST
RRH_PROCESS_REQUEST
RRH_WAIT_FMC
RRH_WAIT_ROLE
RRH_DRAIN

Definition at line 148 of file nal.hpp.

{RRH_RESET = 0, RRH_WAIT_NOTIF, RRH_PROCESS_NOTIF, RRH_START_REQUEST, RRH_PROCESS_REQUEST, RRH_WAIT_FMC, RRH_WAIT_ROLE, RRH_DRAIN};

RxFsmStates

enum RxFsmStates

Enumerator
RX_WAIT_META
RX_STREAM

Definition at line 681 of file tb_nal.cpp.

{ RX_WAIT_META=0, RX_STREAM } rxFsmState = RX_WAIT_META;

RxpStates

enum RxpStates

Enumerator
RXP_SEND_NOTIF
RXP_WAIT_DREQ
RXP_SEND_META
RXP_SEND_DATA
RXP_DONE

Definition at line 818 of file tb_nal.cpp.

{ RXP_SEND_NOTIF, RXP_WAIT_DREQ, RXP_SEND_META, RXP_SEND_DATA, RXP_DONE} rxpState = RXP_SEND_NOTIF;

TableFsmStates

enum TableFsmStates

Enumerator
TAB_FSM_READ
TAB_FSM_WRITE

Definition at line 166 of file nal.hpp.

{TAB_FSM_READ = 0, TAB_FSM_WRITE};

TxpStates

enum TxpStates

Enumerator
TXP_WAIT_REQ
TXP_WAIT_DATA
TXP_RECV_DATA

Definition at line 819 of file tb_nal.cpp.

{ TXP_WAIT_REQ, TXP_WAIT_DATA,  TXP_RECV_DATA} txpState = TXP_WAIT_REQ;

WbuFsmStates

enum WbuFsmStates

Enumerator
WBU_WAIT_META
WBU_SND_REQ
WBU_WAIT_REP
WBU_STREAM
WBU_DROP
WBU_DRAIN

Definition at line 158 of file nal.hpp.

{WBU_WAIT_META = 0, WBU_SND_REQ, WBU_WAIT_REP, WBU_STREAM, WBU_DROP, WBU_DRAIN};

WrpFsmStates

enum WrpFsmStates

Enumerator
WRP_RESET
WRP_WAIT_META
WRP_STREAM_FMC
WRP_W8FORREQS_1
WRP_W8FORREQS_11
WRP_W8FORREQS_2
WRP_W8FORREQS_22
WRP_WAIT_CONNECTION
WRP_STREAM_ROLE
WRP_DROP_PACKET

Definition at line 155 of file nal.hpp.

                  {WRP_RESET = 0, WRP_WAIT_META, WRP_STREAM_FMC, WRP_W8FORREQS_1,  WRP_W8FORREQS_11, WRP_W8FORREQS_2, WRP_W8FORREQS_22, WRP_WAIT_CONNECTION, \
  WRP_STREAM_ROLE, WRP_DROP_PACKET};

Function Documentation

axi4liteProcessing()

void axi4liteProcessing	(	ap_uint< 32 >	ctrlLink[64+16+16],
		stream< NalConfigUpdate > &	sToPortLogic,
		stream< NalConfigUpdate > &	sToUdpRx,
		stream< NalConfigUpdate > &	sToTcpRx,
		stream< NalConfigUpdate > &	sToStatusProc,
		stream< NalMrtUpdate > &	sMrtUpdate,
		stream< uint32_t > &	mrt_version_update_0,
		stream< uint32_t > &	mrt_version_update_1,
		stream< NalStatusUpdate > &	sStatusUpdate
	)

Contains the Axi4 Lite secondary endpoint and reads the MRT and configuration values from it as well as writes the status values. It notifies all other concerned processes on MRT or configuration updates and is notified on status updates.

Parameters

	[in/out]	ctrlLink, the Axi4Lite bus
[out]	sToPortLogic,notification	of configuration changes
[out]	sToUdpRx,notification	of configuration changes
[out]	sToTcpRx,notification	of configuration changes
[out]	sToStatusProc,notification	of configuration changes
[out]	sMrtUpdate,notification	of MRT content changes
[out]	mrt_version_update_0,notification	of MRT version change
[out]	mrt_version_update_1,notification	of MRT version change
[in]	sStatusUpdate,Satus	update notification for Axi4Lite proc

Definition at line 79 of file hss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
  //no pipeline, isn't compatible to AXI4Lite bus
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static uint16_t tableCopyVariable = 0;
  static bool tables_initialized = false;
  static AxiLiteFsmStates a4lFsm = A4L_COPY_CONFIG; //start with config after reset
  static ConfigBcastStates cbFsm = CB_WAIT;
  static uint32_t processed_mrt_version = 0;
  static ConfigBcastStates mbFsm = CB_WAIT;
 
#pragma HLS reset variable=tableCopyVariable
#pragma HLS reset variable=tables_initialized
#pragma HLS reset variable=a4lFsm
#pragma HLS reset variable=cbFsm
#pragma HLS reset variable=processed_mrt_version
#pragma HLS reset variable=mbFsm
 
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static ap_uint<32> config[NUMBER_CONFIG_WORDS];
  static ap_uint<32> status[NUMBER_STATUS_WORDS];
 
  static ap_uint<16> configProp = 0x0;
  static NalConfigUpdate cu_toCB = NalConfigUpdate();
  static ap_uint<32> new_word;
 
  static ap_uint<32> localMRT[MAX_MRT_SIZE];
  //#pragma HLS RESOURCE variable=localMRT core=RAM_2P_BRAM
  //#pragma HLS ARRAY_PARTITION variable=localMRT complete dim=1
  //FIXME: maybe optimize and remove localMRT here (send updates when indicated by version?)
 
 
  //#pragma HLS ARRAY_PARTITION variable=status cyclic factor=4 dim=1
  //#pragma HLS ARRAY_PARTITION variable=config cyclic factor=4 dim=1
 
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
  NalConfigUpdate cu = NalConfigUpdate();
  uint32_t new_mrt_version;
  ap_uint<32> new_ip4node;
 
 
  if(!tables_initialized)
  {
    // ----- tables init -----
    for(int i = 0; i < MAX_MRT_SIZE; i++)
    {
      //localMRT[i] = 0x0;
      localMRT[i] = 0x1; //to force init of MRT agency
    }
    for(int i = 0; i < NUMBER_CONFIG_WORDS; i++)
    {
      config[i] = 0x0;
    }
    for(int i = 0; i < NUMBER_STATUS_WORDS; i++)
    {
      status[i] = 0x0;
    }
    tables_initialized = true;
  } else {
 
    // ----- AXI4Lite Processing -----
 
    switch(a4lFsm)
    {
      default:
        //case A4L_RESET:
        //  // ----- tables init -----
        //  for(int i = 0; i < MAX_MRT_SIZE; i++)
        //  {
        //    localMRT[i] = 0x0;
        //  }
        //  for(int i = 0; i < NUMBER_CONFIG_WORDS; i++)
        //  {
        //    config[i] = 0x0;
        //  }
        //  for(int i = 0; i < NUMBER_STATUS_WORDS; i++)
        //  {
        //    status[i] = 0x0;
        //  }
        //  tableCopyVariable = 0;
        //  a4lFsm = A4L_STATUS_UPDATE;
        //  break;
      case A4L_STATUS_UPDATE:
        if(!sStatusUpdate.empty())
        {
          // ----- apply updates -----
          NalStatusUpdate su = sStatusUpdate.read();
          status[su.status_addr] = su.new_value;
          printf("[A4l] got status update for address %d with value %d\n", (int) su.status_addr, (int) su.new_value);
        } else {
          a4lFsm = A4L_COPY_CONFIG;
        }
        break;
      case A4L_COPY_CONFIG:
        //TODO: necessary? Or does this AXI4Lite anyways "in the background"?
        //or do we need to copy it explicetly, but could do this also every ~2 seconds?
 
        //printf("[A4l] copy config %d\n", tableCopyVariable);
        new_word = ctrlLink[tableCopyVariable];
        if(new_word != config[tableCopyVariable])
        {
          configProp = selectConfigUpdatePropagation(tableCopyVariable);
          cu = NalConfigUpdate(tableCopyVariable, new_word);
          cbFsm = CB_START;
          //config[tableCopyVariable] = new_word;
          a4lFsm = A4L_COPY_CONFIG_2;
        } else {
          tableCopyVariable++;
          if(tableCopyVariable >= NUMBER_CONFIG_WORDS)
          {
            tableCopyVariable = 0;
            a4lFsm = A4L_COPY_MRT;
          }
        }
        break;
      case A4L_COPY_CONFIG_2:
        printf("[A4l] waiting CB broadcast\n");
        if(cbFsm == CB_WAIT)
        {
          config[tableCopyVariable] = new_word;
          tableCopyVariable++;
          if(tableCopyVariable >= NUMBER_CONFIG_WORDS)
          {
            tableCopyVariable = 0;
            a4lFsm = A4L_COPY_MRT;
          } else {
            a4lFsm = A4L_COPY_CONFIG;
          }
        }
        break;
      case A4L_COPY_MRT:
        //printf("[A4l] copy MRT %d\n", tableCopyVariable);
        new_ip4node = ctrlLink[tableCopyVariable + NUMBER_CONFIG_WORDS + NUMBER_STATUS_WORDS];
        if (new_ip4node != localMRT[tableCopyVariable])
        {
          NalMrtUpdate mu = NalMrtUpdate(tableCopyVariable, new_ip4node);
          sMrtUpdate.write(mu);
          localMRT[tableCopyVariable] = new_ip4node;
          printf("[A4l] update MRT at %d with %d\n", tableCopyVariable, (int) new_ip4node);
          NalMrtUpdate mrt_update = NalMrtUpdate(tableCopyVariable, new_ip4node);
          sMrtUpdate.write(mrt_update);
        }
        tableCopyVariable++;
        if(tableCopyVariable >= MAX_MRT_SIZE)
        {
          tableCopyVariable = 0;
          a4lFsm = A4L_COPY_STATUS;
        }
        break;
      case A4L_COPY_STATUS:
        ctrlLink[NUMBER_CONFIG_WORDS + tableCopyVariable] = status[tableCopyVariable];
        tableCopyVariable++;
        if(tableCopyVariable >= NUMBER_STATUS_WORDS)
        {
          //tableCopyVariable = 0;
          a4lFsm = A4L_COPY_FINISH;
        }
        break;
      case A4L_COPY_FINISH:
        tableCopyVariable = 0;
        //acknowledge the processed version
        new_mrt_version = (uint32_t) config[NAL_CONFIG_MRT_VERSION];
        if(new_mrt_version != processed_mrt_version)
        {
          printf("\t\t\t[A4L:CtrlLink:Info] Acknowledged MRT version %d.\n", (int) new_mrt_version);
          mbFsm = CB_START;
          processed_mrt_version = new_mrt_version;
        }
        a4lFsm = A4L_WAIT_FOR_SUB_FSMS;
        break;
      case A4L_WAIT_FOR_SUB_FSMS:
        printf("[A4l] SubFSMs state mb: %d; cb: %d\n", (int) mbFsm, (int) cbFsm);
        if(mbFsm == CB_WAIT && cbFsm == CB_WAIT)
        {
          a4lFsm = A4L_STATUS_UPDATE;
          printf("[A4l] SubFSMs done...continue\n");
        }
        break;
    }
 
    // ----- Config Broadcast -----
 
    switch(cbFsm)
    {
      default:
      case CB_WAIT:
        //NOP
        break;
      case CB_START:
        cu_toCB = cu;
        switch (configProp) {
          default:
          case 0:
            cbFsm = CB_WAIT; //currently not used
            break;
          case 1:
            cbFsm = CB_1;
            break;
          case 2:
            cbFsm = CB_2;
            break;
          case 3:
            cbFsm = CB_3_0;
            printf("[A4l] Issued rank update: %d\n", (int) cu.update_value);
            break;
        }
        break;
      case CB_1:
        //(currently not used)
        //if(!sToTcpAgency.full())
        //{
        //      sToTcpAgency.write(cu_toCB);
        cbFsm = CB_WAIT;
        //}
        break;
      case CB_2:
        if(!sToPortLogic.full())
        {
          sToPortLogic.write(cu_toCB);
          cbFsm = CB_WAIT;
        }
        break;
      case CB_3_0:
        if(!sToUdpRx.full())
        {
          sToUdpRx.write(cu_toCB);
          cbFsm = CB_3_1;
        }
        break;
      case CB_3_1:
        if(!sToTcpRx.full())
        {
          sToTcpRx.write(cu_toCB);
          cbFsm = CB_3_2;
        }
        break;
      case CB_3_2:
        if(!sToStatusProc.full())
        {
          sToStatusProc.write(cu_toCB);
          cbFsm = CB_WAIT;
        }
        break;
    }
 
    // ----- MRT version broadcast ----
 
    switch(mbFsm)
    {
      default:
      case CB_WAIT:
        //NOP
        break;
      case CB_START:
        mbFsm = CB_1;
        printf("[A4l] Issued Mrt update: %d\n", (int) processed_mrt_version);
        break;
      case CB_1:
        if(!mrt_version_update_0.full())
        {
          mrt_version_update_0.write(processed_mrt_version);
          mbFsm = CB_2;
        }
        break;
      case CB_2:
        if(!mrt_version_update_1.full())
        {
          mrt_version_update_1.write(processed_mrt_version);
          mbFsm = CB_WAIT;
        }
        break;
    }
 
  } // else
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

dumpDataToFile() [1/2]

bool dumpDataToFile	(	NetworkWord *	udpWord,
		ofstream &	outFileStream
	)

Definition at line 462 of file tb_nal.cpp.

                                                                   {
    if (!outFileStream.is_open()) {
        printf("### ERROR : Output file stream is not open. \n");
        return(KO);
    }
    outFileStream << hex << noshowbase << uppercase << setfill('0') << setw(16) << udpWord->tdata.to_uint64();
    outFileStream << " ";
    outFileStream << hex << noshowbase << nouppercase << setfill('0') << setw(2)  << udpWord->tkeep.to_int();
    outFileStream << " ";
    outFileStream << setw(1) << udpWord->tlast.to_int() << "\n";
    return(OK);
}

Here is the call graph for this function:

dumpDataToFile() [2/2]

bool dumpDataToFile	(	UdpAppData *	udpWord,
		ofstream &	outFileStream
	)

Dump a data word to a file.

Parameters

[in]	udpWord,a	pointer to the data word to dump.
[in]	outFileStream,the	output file stream to write to.

Returns

OK if successful, otherwise KO.

Definition at line 449 of file tb_nal.cpp.

                                                                  {
    if (!outFileStream.is_open()) {
        printf("### ERROR : Output file stream is not open. \n");
        return(KO);
    }
    outFileStream << hex << noshowbase << uppercase << setfill('0') << setw(16) << udpWord->getTData().to_uint64();
    outFileStream << " ";
    outFileStream << hex << noshowbase << nouppercase << setfill('0') << setw(2)  << udpWord->getTKeep().to_int();
    outFileStream << " ";
    outFileStream << setw(1) << udpWord->getTLast().to_int() << "\n";
    return(OK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

dumpMetaToFile()

bool dumpMetaToFile	(	UdpAppMeta *	udpMeta,
		ofstream &	outFileStream
	)

Dump a metadata information to a file.

Parameters

[in]	udpMeta,a	pointer to the metadata structure to dump.
[in]	outFileStream,the	output file stream to write to.

Returns

OK if successful, otherwise KO.

Definition at line 483 of file tb_nal.cpp.

                                                                  {
    if (!outFileStream.is_open()) {
        printf("### ERROR : Output file stream is not open. \n");
        return(KO);
    }
    outFileStream << hex << noshowbase << setfill('0') << setw(4) << udpMeta->udpSrcPort.to_int();
    outFileStream << " ";
    outFileStream << hex << noshowbase << setfill('0') << setw(8) << udpMeta->ip4SrcAddr.to_int();
    outFileStream << " ";
    outFileStream << hex << noshowbase << setfill('0') << setw(4) << udpMeta->udpDstPort.to_int();
    outFileStream << " ";
    outFileStream << hex << noshowbase << setfill('0') << setw(8) << udpMeta->ip4DstAddr.to_int();
    outFileStream << "\n";
    return(OK);
}

Here is the caller graph for this function:

dumpPLenToFile()

bool dumpPLenToFile	(	UdpPLen *	udpPLen,
		ofstream &	outFileStream
	)

Dump a payload length information to a file.

Parameters

[in]	udpPLen,a	pointer to the payload length to dump.
[in]	outFileStream,the	output file stream to write to.

Returns

OK if successful, otherwise KO.

Definition at line 507 of file tb_nal.cpp.

                                                               {
    if (!outFileStream.is_open()) {
        printf("### ERROR : Output file stream is not open. \n");
        return(KO);
    }
    outFileStream << hex << noshowbase << setfill('0') << setw(4) << udpPLen->to_int();
    outFileStream << "\n";
    return(OK);
}

Here is the caller graph for this function:

eventFifoMerge()

void eventFifoMerge	(	stream< NalEventNotif > &	internal_event_fifo_0,
		stream< NalEventNotif > &	internal_event_fifo_1,
		stream< NalEventNotif > &	internal_event_fifo_2,
		stream< NalEventNotif > &	internal_event_fifo_3,
		stream< NalEventNotif > &	merged_fifo
	)

Merges multiple fifos, where the order of the fifo represents also the priorities.

Definition at line 412 of file nal.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
 
  //if else tree for lower latency, the event fifos should have enough buffer...
 
  if(!internal_event_fifo_0.empty() && !merged_fifo.full())
  {
    NalEventNotif tmp = internal_event_fifo_0.read();
    printf("[INFO] Internal Event Processing received event %d with update value %d from fifo_0\n", \
        (int) tmp.type, (int) tmp.update_value);
    merged_fifo.write(tmp);
  }
  else if(!internal_event_fifo_1.empty() && !merged_fifo.full() )
  {
    NalEventNotif tmp = internal_event_fifo_1.read();
    printf("[INFO] Internal Event Processing received event %d with update value %d from fifo_1\n", \
        (int) tmp.type, (int) tmp.update_value);
    merged_fifo.write(tmp);
  }
  else if(!internal_event_fifo_2.empty()  && !merged_fifo.full())
  {
    NalEventNotif tmp = internal_event_fifo_2.read();
    printf("[INFO] Internal Event Processing received event %d with update value %d from fifo_2\n", \
        (int) tmp.type, (int) tmp.update_value);
    merged_fifo.write(tmp);
  }
  else if(!internal_event_fifo_3.empty() && !merged_fifo.full())
  {
    NalEventNotif tmp = internal_event_fifo_3.read();
    printf("[INFO] Internal Event Processing received event %d with update value %d from fifo_3\n", \
        (int) tmp.type, (int) tmp.update_value);
    merged_fifo.write(tmp);
  }
}

Here is the caller graph for this function:

extractByteCnt() [1/2]

uint8_t extractByteCnt

(

AxisRaw

currWord

)

Definition at line 94 of file nal.cpp.

{
#pragma HLS INLINE
 
  uint8_t ret = 0;
 
  switch (currWord.getLE_TKeep()) {
    case 0b11111111:
      ret = 8;
      break;
    case 0b01111111:
      ret = 7;
      break;
    case 0b00111111:
      ret = 6;
      break;
    case 0b00011111:
      ret = 5;
      break;
    case 0b00001111:
      ret = 4;
      break;
    case 0b00000111:
      ret = 3;
      break;
    case 0b00000011:
      ret = 2;
      break;
    default:
    case 0b00000001:
      ret = 1;
      break;
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

extractByteCnt() [2/2]

uint8_t extractByteCnt

(

NetworkWord

currWord

)

Definition at line 130 of file nal.cpp.

{
#pragma HLS INLINE
 
  uint8_t ret = 0;
 
  switch (currWord.tkeep) {
    case 0b11111111:
      ret = 8;
      break;
    case 0b01111111:
      ret = 7;
      break;
    case 0b00111111:
      ret = 6;
      break;
    case 0b00011111:
      ret = 5;
      break;
    case 0b00001111:
      ret = 4;
      break;
    case 0b00000111:
      ret = 3;
      break;
    case 0b00000011:
      ret = 2;
      break;
    default:
    case 0b00000001:
      ret = 1;
      break;
  }
  return ret;
}

getLocalPortFromTriple()

TcpPort getLocalPortFromTriple

(

NalTriple

triple

)

Definition at line 86 of file nal.cpp.

{
#pragma HLS INLINE
  ap_uint<16> ret = (ap_uint<16>) (triple & 0xFFFF);
  return (TcpPort) ret;
}

Here is the caller graph for this function:

getOutputDataStream() [1/2]

bool getOutputDataStream	(	stream< NetworkWord > &	sDataStream,
		const string	dataStreamName,
		const string	outFileName
	)

Definition at line 562 of file tb_nal.cpp.

{
    string      strLine;
    ofstream    outFileStream;
    string      datFile = "../../../../test/" + outFileName;
    UdpAppData  udpWord;
    bool        rc = OK;
 
    //-- STEP-1 : OPEN FILE
    outFileStream.open(datFile.c_str());
    if ( !outFileStream ) {
        cout << "### ERROR : Could not open the output data file " << datFile << endl;
        return(KO);
    }
 
    //-- STEP-2 : EMPTY STREAM AND DUMP DATA TO FILE
    while (!sDataStream.empty()) {
      NetworkWord wordtmp = sDataStream.read();
      udpWord = UdpAppData(wordtmp.tdata, wordtmp.tkeep, wordtmp.tlast);
            // Print DUT/Data to console
            printf("[%4.4d] TB is draining output stream [%s] - Data read = {D=0x%16.16llX, K=0x%2.2X, L=%d} \n",
                    simCnt, dataStreamName.c_str(),
                    udpWord.getTData().to_uint64(), udpWord.getTData().to_int(), udpWord.getTData().to_int());
            if (!dumpDataToFile(&udpWord, outFileStream)) {
                rc = KO;
                break;
            }
    }
 
    //-- STEP-3: CLOSE FILE
    outFileStream.close();
 
    return(rc);
}

Here is the call graph for this function:

getOutputDataStream() [2/2]

bool getOutputDataStream	(	stream< UdpAppData > &	sDataStream,
		const string	dataStreamName,
		const string	outFileName
	)

Fill an output file with data from an output stream.

Parameters

[in]	sDataStream,the	output data stream to set.
[in]	dataStreamName,the	name of the data stream.
[in]	outFileName,the	name of the output file to write to.

Returns

OK if successful, otherwise KO.

Definition at line 526 of file tb_nal.cpp.

{
    string      strLine;
    ofstream    outFileStream;
    string      datFile = "../../../../test/" + outFileName;
    UdpAppData  udpWord;
    bool        rc = OK;
 
    //-- STEP-1 : OPEN FILE
    outFileStream.open(datFile.c_str());
    if ( !outFileStream ) {
        cout << "### ERROR : Could not open the output data file " << datFile << endl;
        return(KO);
    }
 
    //-- STEP-2 : EMPTY STREAM AND DUMP DATA TO FILE
    while (!sDataStream.empty()) {
        if (readDataStream(sDataStream, &udpWord) == VALID) {
            // Print DUT/Data to console
            printf("[%4.4d] TB is draining output stream [%s] - Data read = {D=0x%16.16llX, K=0x%2.2X, L=%d} \n",
                    simCnt, dataStreamName.c_str(),
                    udpWord.getTData().to_uint64(), udpWord.getTKeep().to_int(), udpWord.getTLast().to_int());
            if (!dumpDataToFile(&udpWord, outFileStream)) {
                rc = KO;
                break;
            }
        }
    }
 
    //-- STEP-3: CLOSE FILE
    outFileStream.close();
 
    return(rc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getOutputMetaStream()

bool getOutputMetaStream	(	stream< UdpAppMeta > &	sMetaStream,
		const string	metaStreamName,
		const string	outFileName
	)

Fill an output file with metadata from an output stream.

Parameters

[in]	sMetaStream,the	output metadata stream to set.
[in]	metaStreamName,the	name of the metadata stream.
[in]	outFileName,the	name of the output file to write to.

Returns

OK if successful, otherwise KO.

Definition at line 607 of file tb_nal.cpp.

{
    string      strLine;
    ofstream    outFileStream;
    string      datFile = "../../../../test/" + outFileName;
    UdpAppMeta  udpMeta;
    bool        rc = OK;
 
    //-- STEP-1 : OPEN FILE
    outFileStream.open(datFile.c_str());
    if ( !outFileStream ) {
        cout << "### ERROR : Could not open the output data file " << datFile << endl;
        return(KO);
    }
 
    //-- STEP-2 : EMPTY STREAM AND DUMP METADATA TO FILE
    while (!sMetaStream.empty()) {
        if (readMetaStream(sMetaStream, metaStreamName, &udpMeta) == VALID) {
            if (!dumpMetaToFile(&udpMeta, outFileStream)) {
                rc = KO;
                break;
            }
        }
    }
 
    //-- STEP-3: CLOSE FILE
    outFileStream.close();
 
    return(rc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getOutputPLenStream()

bool getOutputPLenStream	(	stream< UdpPLen > &	sPLenStream,
		const string	plenStreamName,
		const string	outFileName
	)

Fill an output file with payload length from an output stream.

Parameters

[in]	sPLenStream,the	output payload length stream to set.
[in]	plenStreamName,the	name of the payload length stream.
[in]	outFileName,the	name of the output file to write to.

Returns

OK if successful, otherwise KO.

Definition at line 648 of file tb_nal.cpp.

{
    string      strLine;
    ofstream    outFileStream;
    string      datFile = "../../../../test/" + outFileName;
    UdpPLen     udpPLen;
    bool        rc = OK;
 
    //-- STEP-1 : OPEN FILE
    outFileStream.open(datFile.c_str());
    if ( !outFileStream ) {
        cout << "### ERROR : Could not open the output data file " << datFile << endl;
        return(KO);
    }
 
    //-- STEP-2 : EMPTY STREAM AND DUMP PAYLOAD LENGTH TO FILE
    while (!sPLenStream.empty()) {
        if (readPLenStream(sPLenStream, plenStreamName, &udpPLen) == VALID) {
            if (!dumpPLenToFile(&udpPLen, outFileStream)) {
                rc = KO;
                break;
            }
        }
    }
 
    //-- STEP-3: CLOSE FILE
    outFileStream.close();
 
    return(rc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getRemoteIpAddrFromTriple()

Ip4Addr getRemoteIpAddrFromTriple

(

NalTriple

triple

)

Definition at line 70 of file nal.cpp.

{
#pragma HLS INLINE
  ap_uint<32> ret = ((ap_uint<32>) (triple >> 32)) & 0xFFFFFFFF;
  return (Ip4Addr) ret;
}

Here is the caller graph for this function:

getRemotePortFromTriple()

TcpPort getRemotePortFromTriple

(

NalTriple

triple

)

Definition at line 78 of file nal.cpp.

{
#pragma HLS INLINE
  ap_uint<16> ret = ((ap_uint<16>) (triple >> 16)) & 0xFFFF;
  return (TcpPort) ret;
}

Here is the caller graph for this function:

getRightmostBitPos()

ap_uint< 32 > getRightmostBitPos

(

ap_uint< 32 >

num

)

Definition at line 43 of file nal.cpp.

{
#pragma HLS INLINE off
  ap_uint<32> one_hot = num & -num;
  ap_uint<32> pos = 0;
  for (int i = 0; i < 32; i++)
  {
#pragma HLS unroll
    if(one_hot <= 1)
    {
      break;
    }
    pos++;
    one_hot >>= 1;
  }
  //printf("[NAL:RigthmostBit] returning %d for input %d\n", (int) pos, (int) num);
  return pos;
}

Here is the caller graph for this function:

main()

int main

(

)

Main Testbench Loop; Emulates also the behavior of the UDP Offload Engine (UOE).

Definition at line 1084 of file tb_nal.cpp.

           {
 
    //------------------------------------------------------
    //-- TESTBENCH LOCAL VARIABLES
    //------------------------------------------------------
    int         nrErr = 0;
 
    printf("#####################################################\n");
    printf("## TESTBENCH 'tb_nrc' STARTS HERE                  ##\n");
    printf("#####################################################\n");
 
    simCnt = 0;
    nrErr  = 0;
  
    //prepare MRT (routing table)
    for(int i = 0; i < MAX_MRT_SIZE + NUMBER_CONFIG_WORDS + NUMBER_STATUS_WORDS; i++)
    {
        ctrlLink[i] = 0;
    }
 
    //ctrlLink[0] = 1; //own rank 
    ctrlLink[NAL_CONFIG_MRT_VERSION] = 1;
    ctrlLink[NUMBER_CONFIG_WORDS + NUMBER_STATUS_WORDS + 0] = 0x0a0b0c01; //10.11.12.1
    ctrlLink[NUMBER_CONFIG_WORDS + NUMBER_STATUS_WORDS + 1] = 0x0a0b0c0d; //10.11.12.13
    ctrlLink[NUMBER_CONFIG_WORDS + NUMBER_STATUS_WORDS + 2] = 0x0a0b0c0e; //10.11.12.14
 
    //------------------------------------------------------
    //-- STEP-1 : OPEN PORT REQUEST
    //------------------------------------------------------
    //printf("========================= BEGIN UDP Port Opening =========================\n");
    //for (int i=0; i<32; ++i) {
    //  //we need ~18 cycles to copy all configs, and then a few more to copy the MRT
    //    stepDut();
    //    if ( !sNRC_UOE_LsnReq.empty() ) {
    //        sNRC_UOE_LsnReq.read();
    //        printf("[%4.4d] NRC->UOE_OpnReq : DUT is requesting to open a port.\n", simCnt);
    //        stepDut();
    //        sUOE_NRC_LsnRep.write(true);
    //        printf("[%4.4d] NRC->UOE_OpnAck : TB  acknowledges the port opening.\n", simCnt);
    //    }
    //}
    //printf("========================= END   UDP Port Opening =========================\n");
 
    //if (nrErr == 0) {
    //    if (!setInputDataStream(sROLE_NRC_Data, "sROLE_NRC_Data", "ifsROLE_Urif_Data.dat")) {
    //        printf("### ERROR : Failed to set input data stream \"sROLE_DataStream\". \n");
    //        nrErr++;
    //    }
    //    
    //    //there are 2 streams from the ROLE to UDMX
    //    NetworkMeta tmp_meta = NetworkMeta(1,DEFAULT_RX_PORT,2,DEFAULT_RX_PORT,0);
    //    siUdp_meta.write(NetworkMetaStream(tmp_meta));
    //    siUdp_meta.write(NetworkMetaStream(tmp_meta));
 
    //    if (!setInputDataStream(sUOE_NRC_Data, "sUOE_NRC_Data", "ifsUDMX_Urif_Data.dat")) {
    //        printf("### ERROR : Failed to set input data stream \"sUOE_DataStream\". \n");
    //        nrErr++;
    //    }
    //    //if (!setInputMetaStream(sUDMX_Urif_Meta, "sUDMX_Urif_Meta", "ifsUDMX_Urif_Data.dat")) {
    //    //    printf("### ERROR : Failed to set input meta stream \"sUDMX_MetaStream\". \n");
    //    //    nrErr++;
    //    //}
    //    //there are 3 streams from the UDMX to NRC
    //    //UdpMeta     socketPair = SocketPair({DEFAULT_RX_PORT, 0x0A0B0C0E}, {DEFAULT_RX_PORT, 0x0A0B0C01});
    //    UdpMeta     socketPair = SocketPair({0x0A0B0C0E, DEFAULT_RX_PORT}, {0x0A0B0C01, DEFAULT_RX_PORT});
    //    sUOE_NRC_Meta.write(socketPair);
    //    sUOE_NRC_Meta.write(socketPair);
    //    sUOE_NRC_Meta.write(socketPair);
    //    // Print Metadata to console
    //    printf("[%4.4d] TB is filling input stream [Meta] - Metadata = {{SP=0x%4.4X,SA=0x%8.8X} {DP=0x%4.4X,DA=0x%8.8X}} \n",
    //    simCnt, socketPair.udpSrcPort.to_int(), socketPair.ip4SrcAddr.to_int(), socketPair.udpDstPort.to_int(), socketPair.ip4DstAddr.to_int());
    //}
 
    //------------------------------------------------------
    //-- STEP-3 : MAIN TRAFFIC LOOP
    //------------------------------------------------------
    bool sof = true;
    gSimCycCnt = simCnt; // Simulation cycle counter as a global variable
    nrErr      = 0; // Total number of testbench errors
 
    printf("#####################################################\n");
    printf("## MAIN LOOP STARTS HERE                           ##\n");
    printf("#####################################################\n");
    
    //Test FMC first
    sessionId   = DEFAULT_SESSION_ID;
    tcpSegLen   = DEFAULT_SESSION_LEN;
    hostIp4Addr = DEFAULT_HOST_IP4_ADDR;
    fpgaLsnPort = 8803;
 
 
    while (!nrErr) 
    {
 
      //if (simCnt < 42)
      if (gSimCycCnt < MAX_SIM_CYCLES)
      {
 
        if(simCnt < 32)
        {
          //UDP port logic
          if ( !sNRC_UOE_LsnReq.empty() ) {
            sNRC_UOE_LsnReq.read();
            printf("[%4.4d] NRC->UOE_OpnReq : DUT is requesting to open a port.\n", simCnt);
            sUOE_NRC_LsnRep.write(true);
            printf("[%4.4d] NRC->UOE_OpnAck : TB  acknowledges the port opening.\n", simCnt);
          }
        }
 
        //------------------------------------------------------
        //-- CREATE UDP TRAFFIC AS INPUT STREAMS
        //------------------------------------------------------
        if (simCnt == 32) 
        {
          //by now, the config should have been copied
 
          if (!setInputDataStream(sROLE_NRC_Data, "sROLE_NRC_Data", "ifsROLE_Urif_Data.dat")) {
            printf("### ERROR : Failed to set input data stream \"sROLE_DataStream\". \n");
            nrErr++;
          }
 
          //there are 2 streams from the ROLE to UDMX
          NetworkMeta tmp_meta = NetworkMeta(1,DEFAULT_RX_PORT,2,DEFAULT_RX_PORT,0);
          siUdp_meta.write(NetworkMetaStream(tmp_meta));
          siUdp_meta.write(NetworkMetaStream(tmp_meta));
 
          if (!setInputDataStream(sUOE_NRC_Data, "sUOE_NRC_Data", "ifsUDMX_Urif_Data.dat")) {
            printf("### ERROR : Failed to set input data stream \"sUOE_DataStream\". \n");
            nrErr++;
          }
          //if (!setInputMetaStream(sUDMX_Urif_Meta, "sUDMX_Urif_Meta", "ifsUDMX_Urif_Data.dat")) {
          //    printf("### ERROR : Failed to set input meta stream \"sUDMX_MetaStream\". \n");
          //    nrErr++;
          //}
          //there are 3 streams from the UDMX to NRC
          //UdpMeta     socketPair = SocketPair({0x0A0B0C0E, DEFAULT_RX_PORT}, {0x0A0B0C01, DEFAULT_RX_PORT});
          UdpAppMeta udpMeta = UdpAppMeta(0x0A0B0C0E, DEFAULT_RX_PORT, 0x0A0B0C01, DEFAULT_RX_PORT);
          sUOE_NRC_Meta.write(udpMeta);
          sUOE_NRC_Meta.write(udpMeta);
          sUOE_NRC_Meta.write(udpMeta);
          //the length of the streams are in ifsUDMX_Urif_Data.dat
          sUOE_NRC_DLen.write(38);
          sUOE_NRC_DLen.write(23);
          sUOE_NRC_DLen.write(60);
 
          // Print Metadata to console
          //printf("[%4.4d] TB is filling input stream [Meta] - Metadata = {{SP=0x%4.4X,SA=0x%8.8X} {DP=0x%4.4X,DA=0x%8.8X}} \n",
          //simCnt, socketPair.udpSrcPort.to_int(), socketPair.ip4SrcAddr.to_int(), socketPair.udpDstPort.to_int(), socketPair.ip4DstAddr.to_int());
        }
 
        //-------------------------------------------------
        //-- EMULATE TOE
        //-------------------------------------------------
        pTOE(
            nrErr,
            //-- TOE / Tx Data Interfaces
            sTOE_Nrc_Notif,
            sNRC_Toe_DReq,
            sTOE_Nrc_Data,
            sTOE_Nrc_SessId,
            //-- TOE / Listen Interfaces
            sNRC_Toe_LsnReq,
            sTOE_Nrc_LsnAck,
            //-- TOE / Tx Data Interfaces
            sNRC_Toe_Data,
            sNRC_Toe_SndReq,
            sTOE_Nrc_SndRep,
            //sTOE_Nrc_DSts,
            //-- TOE / Open Interfaces
            sNRC_Toe_OpnReq,
            sTOE_Nrc_OpnRep
            );
 
        //-------------------------------------------------
        //-- RUN DUT
        //-------------------------------------------------
        stepDut();
 
        //UDP meta
        if( !soUdp_meta.empty())
        {
          NetworkMetaStream tmp_meta = soUdp_meta.read();
          printf("Role received NRCmeta stream from rank %d.\n", (int) tmp_meta.tdata.src_rank);
        }
 
        //-------------------------------------------------
        //-- EMULATE APP 1 (FMC)
        //-------------------------------------------------
        pFMC(
            //-- TRIF / Rx Data Interface
            sNRC_FMC_Tcp_data,
            sNRC_FMC_Tcp_sessId,
            //-- TRIF / Tx Data Interface
            sFMC_Nrc_Tcp_data,
            sFMC_Nrc_Tcp_sessId);
        
        //if(simCnt % 50 == 0)
        //{
        //  //to update MRT version
        //  ctrlLink[NAL_CONFIG_MRT_VERSION] = ctrlLink[NAL_NUMBER_CONFIG_WORDS + NAL_STATUS_MRT_VERSION];
        //}
 
        //-------------------------------------------------
        //-- EMULATE APP 2 (ROLE-TCP)
        //-------------------------------------------------
        pROLE(
            //-- TRIF / Rx Data Interface
            sNRC_Role_Tcp_data,
            sNRC_Role_Tcp_meta,
            //-- TRIF / Tx Data Interface
            sROLE_Nrc_Tcp_data,
            sROLE_Nrc_Tcp_meta);
        
        //------------------------------------------------------
        //-- INCREMENT SIMULATION COUNTER
        //------------------------------------------------------
        fflush(stdout);
        fflush(stderr);
        gSimCycCnt++;
        if (gTraceEvent || ((gSimCycCnt % 1000) == 0)) {
            printf("-- [@%4.4d] -----------------------------\n", gSimCycCnt);
            gTraceEvent = false;
        }
        if(simCnt == 180)
        {
          if(rxpState != RXP_DONE)
          {
            nrErr++;
            printf("[TB-ERROR] RXP engine is not in expected state!\n");
          }
        //now test ROLE
        sessionId   = DEFAULT_SESSION_ID + 1;
        tcpSegLen   = DEFAULT_SESSION_LEN;
        hostIp4Addr = ctrlLink[NUMBER_CONFIG_WORDS + NUMBER_STATUS_WORDS + 0];
        fpgaLsnPort = 2718;
        rxpState = RXP_SEND_NOTIF;
        //i.e. three segments (nrSegToSend)
        }
        if(simCnt == 210)
        {
          s_tcp_rx_ports = 0b101;
          //open 2720
        }
        if(simCnt == 223)
        {
          if(rxpState != RXP_DONE)
          {
            nrErr++;
            printf("[TB-ERROR] RXP engine is not in expected state!\n");
          }
          sessionId   = DEFAULT_SESSION_ID + 2;
          sessionId_reply   = DEFAULT_SESSION_ID + 3;
          tcpSegLen   = DEFAULT_SESSION_LEN;
          hostIp4Addr = ctrlLink[NUMBER_CONFIG_WORDS + NUMBER_STATUS_WORDS + 2];
          fpgaLsnPort = 2720;
          rxpState = RXP_SEND_NOTIF;
          //i.e. three segments (nrSegToSend)
        }
        
        //if(simCnt == 243)
        //{
        //  s_tcp_rx_ports = 0b1101;
        //}
        if(simCnt == 269)
        {
          if(rxpState != RXP_DONE)
          {
            nrErr++;
            printf("[TB-ERROR] RXP engine is not in expected state!\n");
          }
          //test again, but this time with connection timeout
          sessionId   = DEFAULT_SESSION_ID + 4;
          sessionId_reply   = DEFAULT_SESSION_ID + 5;
          tcpSegLen   = DEFAULT_SESSION_LEN;
          hostIp4Addr = ctrlLink[NUMBER_CONFIG_WORDS + NUMBER_STATUS_WORDS + 0];
          fpgaLsnPort = 2720;
          hostSrcPort = 8443;
          rxpState = RXP_SEND_NOTIF;
          opnState = OPN_TIMEOUT;
          tcp_packets_expected_timeout = 3;
          tcp_timout_packet_drop = 3;
        }
 
        if(simCnt >= 269 && tcp_timout_packet_drop > 0 && !sNRC_Toe_OpnReq.empty())
        {
          //drain OpnReq stream
          tcp_timout_packet_drop--;
          printf("=== Drain OpenReq: ");
          printSockAddr("Main-Loop", sNRC_Toe_OpnReq.read());
        }
        
        //TODO:
        //open other ports later?
 
        } else {
            printf("## End of simulation at cycle=%3d. \n", simCnt);
            break;
        }
 
    }  // End: while()
    printf("-- [@%4.4d] -----------------------------\n", gSimCycCnt);
    printf("############################################################################\n");
    printf("## TESTBENCH 'tb_nal' ENDS HERE                                           ##\n");
 
    nrErr += (tcp_packets_send - (tcp_packets_recv - tcp_recv_frag_cnt + tcp_packets_expected_timeout));
    if(tcp_packets_send != (tcp_packets_recv - tcp_recv_frag_cnt + tcp_packets_expected_timeout))
    {
      printf("\tERROR: some packets are lost: send %d TCP packets, received %d (fragmented parts %d, expected timeout for packets %d)!\n", tcp_packets_send, tcp_packets_recv-tcp_recv_frag_cnt, tcp_recv_frag_cnt, tcp_packets_expected_timeout);
    } else {
      printf("\tSummary: Send %d TCP packets, Received %d TCP packets (fragmented parts %d, expected Timout packets %d).\n",tcp_packets_send, tcp_packets_recv-tcp_recv_frag_cnt, tcp_recv_frag_cnt, tcp_packets_expected_timeout);
    }
    printf("############################################################################\n\n");
 
    if(ctrlLink[NUMBER_CONFIG_WORDS + NAL_STATUS_MRT_VERSION] != 1)
    {
      //A4L needs >161 steps to acknowledge it.
       printf("ERROR: NAL status is reporting the wrong MRT version (%d)!\n", (int) ctrlLink[NUMBER_CONFIG_WORDS + NAL_STATUS_MRT_VERSION]);
       nrErr++;
    }
 
    //-------------------------------------------------------
    //-- STEP-4 : DRAIN AND WRITE OUTPUT FILE STREAMS
    //-------------------------------------------------------
    //---- URIF-->ROLE ----
    if (!getOutputDataStream(sNRC_Role_Data, "sNRC_Role_Data", "ofsURIF_Role_Data.dat"))
        nrErr++;
    //---- URIF->UDMX ----
    if (!getOutputDataStream(sNRC_UOE_Data, "sNRC_UOE_Data", "ofsURIF_Udmx_Data.dat"))
            nrErr++;
    if (!getOutputMetaStream(sNRC_UOE_Meta, "sNRC_UOE_Meta", "ofsURIF_Udmx_Meta.dat"))
        nrErr++;
    if (!getOutputPLenStream(sNRC_UOE_DLen, "sNRC_UOE_DLen", "ofsURIF_Udmx_PLen.dat"))
        nrErr++;
 
    // there should be no left over data
    while(!sNRC_Toe_OpnReq.empty())
    {
      printf("=== Draining leftover TCP request: ");
      printSockAddr("Post-Loop", sNRC_Toe_OpnReq.read());
      printf("===\n");
      nrErr++;
    }
 
 
    //------------------------------------------------------
    //-- STEP-5 : COMPARE INPUT AND OUTPUT FILE STREAMS
    //------------------------------------------------------
    int rc1 = system("diff --brief -w -i -y ../../../../test/ofsURIF_Role_Data.dat \
                                            ../../../../test/ifsUDMX_Urif_Data.dat");
    if (rc1)
        printf("## Error : File \'ofsURIF_Role_Data.dat\' does not match \'ifsUDMX_Urif_Data.dat\'.\n");
 
    int rc2 = system("diff --brief -w -i -y ../../../../test/ofsURIF_Udmx_Data.dat \
                                            ../../../../test/ifsROLE_Urif_Data.dat");
    if (rc2)
        printf("## Error : File \'ofsURIF_Udmx_Data.dat\' does not match \'ifsROLE_Urif_Data.dat\'.\n");
    nrErr += rc1 + rc2;
 
    printf("#####################################################\n");
    if (nrErr)
        printf("## ERROR - TESTBENCH FAILED (RC=%d) !!!             ##\n", nrErr);
    else
        printf("## SUCCESSFULL END OF TESTBENCH (RC=0)             ##\n");
 
    printf("#####################################################\n");
 
    return(nrErr);
}

Here is the call graph for this function:

nal_main()

void nal_main	(	ap_uint< 32 >	ctrlLink[64+16+16],
		ap_uint< 1 > *	layer_4_enabled,
		ap_uint< 1 > *	layer_7_enabled,
		ap_uint< 1 > *	role_decoupled,
		ap_uint< 1 > *	piNTS_ready,
		ap_uint< 16 > *	piMMIO_FmcLsnPort,
		ap_uint< 32 > *	piMMIO_CfrmIp4Addr,
		ap_uint< 32 > *	myIpAddress,
		ap_uint< 32 > *	pi_udp_rx_ports,
		stream< NetworkWord > &	siUdp_data,
		stream< NetworkWord > &	soUdp_data,
		stream< NetworkMetaStream > &	siUdp_meta,
		stream< NetworkMetaStream > &	soUdp_meta,
		ap_uint< 32 > *	pi_tcp_rx_ports,
		stream< NetworkWord > &	siTcp_data,
		stream< NetworkMetaStream > &	siTcp_meta,
		stream< NetworkWord > &	soTcp_data,
		stream< NetworkMetaStream > &	soTcp_meta,
		stream< NetworkWord > &	siFMC_data,
		stream< TcpSessId > &	siFMC_SessId,
		stream< NetworkWord > &	soFMC_data,
		stream< TcpSessId > &	soFMC_SessId,
		stream< UdpPort > &	soUOE_LsnReq,
		stream< StsBool > &	siUOE_LsnRep,
		stream< UdpPort > &	soUOE_ClsReq,
		stream< StsBool > &	siUOE_ClsRep,
		stream< UdpAppData > &	siUOE_Data,
		stream< UdpAppMeta > &	siUOE_Meta,
		stream< UdpAppDLen > &	siUOE_DLen,
		stream< UdpAppData > &	soUOE_Data,
		stream< UdpAppMeta > &	soUOE_Meta,
		stream< UdpAppDLen > &	soUOE_DLen,
		stream< TcpAppNotif > &	siTOE_Notif,
		stream< TcpAppRdReq > &	soTOE_DReq,
		stream< TcpAppData > &	siTOE_Data,
		stream< TcpAppMeta > &	siTOE_SessId,
		stream< TcpAppLsnReq > &	soTOE_LsnReq,
		stream< TcpAppLsnRep > &	siTOE_LsnRep,
		stream< TcpAppData > &	soTOE_Data,
		stream< TcpAppSndReq > &	soTOE_SndReq,
		stream< TcpAppSndRep > &	siTOE_SndRep,
		stream< TcpAppOpnReq > &	soTOE_OpnReq,
		stream< TcpAppOpnRep > &	siTOE_OpnRep,
		stream< TcpAppClsReq > &	soTOE_ClsReq
	)

Main process of the Network Abstraction Layer (NAL)

Definition at line 464 of file nal.cpp.

{
 
  // ----- directives for AXI buses (AXI4 stream, AXI4 Lite) -----
#pragma HLS INTERFACE s_axilite depth=512 port=ctrlLink bundle=piFMC_NAL_ctrlLink_AXI
 
#pragma HLS INTERFACE axis register both port=siUdp_data
#pragma HLS INTERFACE axis register both port=soUdp_data
 
#pragma HLS INTERFACE axis register both port=siUdp_meta
#pragma HLS INTERFACE axis register both port=soUdp_meta
 
#pragma HLS INTERFACE axis register both port=soUOE_LsnReq
#pragma HLS INTERFACE axis register both port=siUOE_LsnRep
#pragma HLS INTERFACE axis register both port=soUOE_ClsReq
#pragma HLS INTERFACE axis register both port=siUOE_ClsRep
 
#pragma HLS INTERFACE axis register both port=siUOE_Data
#pragma HLS INTERFACE axis register both port=siUOE_Meta
#pragma HLS DATA_PACK                variable=siUOE_Meta
#pragma HLS INTERFACE axis register both port=siUOE_DLen
 
#pragma HLS INTERFACE axis register both port=soUOE_Data
#pragma HLS INTERFACE axis register both port=soUOE_Meta
#pragma HLS DATA_PACK                variable=soUOE_Meta
#pragma HLS INTERFACE axis register both port=soUOE_DLen
 
#pragma HLS INTERFACE axis register both port=siTcp_data
#pragma HLS INTERFACE axis register both port=soTcp_data
#pragma HLS INTERFACE axis register both port=siTcp_meta
#pragma HLS INTERFACE axis register both port=soTcp_meta
 
#pragma HLS INTERFACE axis register both port=siTOE_Notif
#pragma HLS DATA_PACK                variable=siTOE_Notif
#pragma HLS INTERFACE axis register both port=soTOE_DReq
#pragma HLS DATA_PACK                variable=soTOE_DReq
#pragma HLS INTERFACE axis register both port=siTOE_Data
#pragma HLS INTERFACE axis register both port=siTOE_SessId
 
#pragma HLS INTERFACE axis register both port=soTOE_LsnReq
#pragma HLS INTERFACE axis register both port=siTOE_LsnRep
 
#pragma HLS INTERFACE axis register both port=soTOE_Data
#pragma HLS INTERFACE axis register both port=soTOE_SndReq
#pragma HLS DATA_PACK                variable=soTOE_SndReq
#pragma HLS INTERFACe axis register both port=siTOE_SndRep
#pragma HLS DATA_PACK                variable=siTOE_SndRep
 
#pragma HLS INTERFACE axis register both port=soTOE_OpnReq
#pragma HLS DATA_PACK                variable=soTOE_OpnReq
#pragma HLS INTERFACE axis register both port=siTOE_OpnRep
#pragma HLS DATA_PACK                variable=siTOE_OpnRep
 
#pragma HLS INTERFACE axis register both port=soTOE_ClsReq
 
  // ----- common directives -----
 
#pragma HLS INTERFACE ap_ctrl_none port=return
 
#pragma HLS INTERFACE ap_vld register port=layer_4_enabled    name=piLayer4enabled
#pragma HLS INTERFACE ap_vld register port=layer_7_enabled    name=piLayer7enabled
#pragma HLS INTERFACE ap_vld register port=role_decoupled     name=piRoleDecoup_active
#pragma HLS INTERFACE ap_vld register port=piNTS_ready        name=piNTS_ready
 
#pragma HLS INTERFACE ap_vld register port=myIpAddress        name=piMyIpAddress
#pragma HLS INTERFACE ap_vld register port=pi_udp_rx_ports    name=piROL_Udp_Rx_ports
#pragma HLS INTERFACE ap_vld register port=piMMIO_FmcLsnPort  name=piMMIO_FmcLsnPort
#pragma HLS INTERFACE ap_vld register port=piMMIO_CfrmIp4Addr name=piMMIO_CfrmIp4Addr
 
#pragma HLS INTERFACE ap_vld register port=pi_tcp_rx_ports    name=piROL_Tcp_Rx_ports
 
#pragma HLS INTERFACE ap_fifo port=siFMC_data
#pragma HLS INTERFACE ap_fifo port=soFMC_data
#pragma HLS INTERFACE ap_fifo port=siFMC_SessId
#pragma HLS INTERFACE ap_fifo port=soFMC_SessId
 
 
#pragma HLS DATAFLOW
 
 
  //===========================================================
  //  core wide STATIC variables
 
  static stream<NalEventNotif> internal_event_fifo_0 ("internal_event_fifo_0");
  static stream<NalEventNotif> internal_event_fifo_1 ("internal_event_fifo_1");
  static stream<NalEventNotif> internal_event_fifo_2 ("internal_event_fifo_2");
  static stream<NalEventNotif> internal_event_fifo_3 ("internal_event_fifo_3");
  static stream<NalEventNotif> merged_fifo           ("sEvent_Merged_Fifo");
  //static stream<NalConfigUpdate>   sA4lToTcpAgency    ("sA4lToTcpAgency"); //(currently not used)
  static stream<NalConfigUpdate>   sA4lToPortLogic    ("sA4lToPortLogic");
  static stream<NalConfigUpdate>   sA4lToUdpRx        ("sA4lToUdpRx");
  static stream<NalConfigUpdate>   sA4lToTcpRx        ("sA4lToTcpRx");
  static stream<NalConfigUpdate>   sA4lToStatusProc   ("sA4lToStatusProc");
  static stream<NalMrtUpdate>      sA4lMrtUpdate      ("sA4lMrtUpdate");
  static stream<NalStatusUpdate>   sStatusUpdate    ("sStatusUpdate");
  static stream<NodeId>            sGetIpReq_UdpTx    ("sGetIpReq_UdpTx");
  static stream<Ip4Addr>           sGetIpRep_UdpTx    ("sGetIpRep_UdpTx");
  static stream<NodeId>            sGetIpReq_TcpTx    ("sGetIpReq_TcpTx");
  static stream<Ip4Addr>           sGetIpRep_TcpTx    ("sGetIpRep_TcpTx");
  static stream<Ip4Addr>           sGetNidReq_UdpRx    ("sGetNidReq_UdpRx");
  static stream<NodeId>            sGetNidRep_UdpRx    ("sGetNidRep_UdpRx");
  static stream<Ip4Addr>           sGetNidReq_TcpRx    ("sGetNidReq_TcpRx");
  static stream<NodeId>            sGetNidRep_TcpRx    ("sGetNidRep_TcpRx");
  static stream<Ip4Addr>           sGetNidReq_TcpTx    ("sGetNidReq_TcpTx");
  static stream<NodeId>            sGetNidRep_TcpTx    ("sGetNidRep_TcpTx");
 
  static stream<UdpPort>      sUdpPortsToClose   ("sUdpPortsToClose");
  static stream<UdpPort>      sUdpPortsToOpen    ("sUdpPortsToOpen");
  static stream<TcpPort>      sTcpPortsToOpen      ("sTcpPortsToOpen");
  static stream<bool>       sUdpPortsOpenFeedback ("sUdpPortsOpenFeedback");
  static stream<bool>       sTcpPortsOpenFeedback ("sTcpPortsOpenFeedback");
 
 
  static stream<NetworkWord>          sRoleTcpDataRx_buffer ("sRoleTcpDataRx_buffer");
  static stream<NetworkMetaStream>    sRoleTcpMetaRx_buffer ("sRoleTcpMetaRx_buffer");
  static stream<TcpAppData>           sTcpWrp2Wbu_data  ("sTcpWrp2Wbu_data");
  static stream<TcpAppMeta>           sTcpWrp2Wbu_sessId ("sTcpWrp2Wbu_sessId");
  static stream<TcpDatLen>            sTcpWrp2Wbu_len  ("sTcpWrp2Wbu_len");
 
  static stream<SessionId>          sGetTripleFromSid_Req    ("sGetTripleFromSid_Req");
  static stream<NalTriple>          sGetTripleFromSid_Rep    ("sGetTripleFromSid_Rep");
  static stream<NalTriple>          sGetSidFromTriple_Req    ("sGetSidFromTriple_Req");
  static stream<SessionId>          sGetSidFromTriple_Rep    ("sGetSidFromTriple_Rep");
  static stream<NalNewTableEntry>   sAddNewTriple_TcpRrh     ("sAddNewTriple_TcpRrh");
  static stream<NalNewTableEntry>   sAddNewTriple_TcpCon     ("sAddNewTriple_TcpCon");
  static stream<SessionId>          sDeleteEntryBySid        ("sDeleteEntryBySid");
  static stream<SessionId>          sMarkAsPriv              ("sMarkAsPriv");
  static stream<bool>               sMarkToDel_unpriv        ("sMarkToDel_unpriv");
  static stream<bool>               sGetNextDelRow_Req       ("sGetNextDelRow_Req");
  static stream<SessionId>          sGetNextDelRow_Rep       ("sGetNextDelRow_Rep");
  static stream<TcpAppRdReq>        sRDp_ReqNotif      ("sRDp_ReqNotif");
 
  static stream<NalTriple>      sNewTcpCon_Req       ("sNewTcpCon_Req");
  static stream<NalNewTcpConRep>    sNewTcpCon_Rep           ("sNewTcpConRep");
  static stream<TcpAppNotif>       sTcpNotif_buffer   ("sTcpNotif_buffer");
 
  //static ap_uint<32> localMRT[MAX_MRT_SIZE];
 
  static stream<uint32_t>           sMrtVersionUpdate_0 ("sMrtVersionUpdate_0");
  static stream<uint32_t>           sMrtVersionUpdate_1 ("sMrtVersionUpdate_1");
 
  static stream<bool>      sCacheInvalSig_0      ("sCacheInvalSig_0");
  static stream<bool>      sCacheInvalSig_1      ("sCacheInvalSig_1");
  static stream<bool>      sCacheInvalSig_2      ("sCacheInvalSig_2");
  static stream<bool>      sCacheInvalSig_3      ("sCacheInvalSig_3");
 
  static stream<PacketLen>      sRoleFifoEmptySig     ("sRoleFifoEmptySig");
  static stream<PacketLen>      sFmcFifoEmptySig     ("sFmcFifoEmptySig");
 
  static stream<bool>      sStartTclCls_sig      ("sStartTclCls_sig");
  static stream<NalPortUpdate> sNalPortUpdate    ("sNalPortUpdate");
 
  static stream<NetworkWord>          sRoleUdpDataRx_buffer ("sRoleUdpDataRx_buffer");
  static stream<NetworkMetaStream>    sRoleUdpMetaRx_buffer ("sRoleUdpMetaRx_buffer");
 
  static stream<UdpAppData>          sUoeTxBuffer_Data ("sUoeTxBuffer_Data");
  static stream<UdpAppMeta>          sUoeTxBuffer_Meta ("sUoeTxBuffer_Meta");
  static stream<UdpAppDLen>          sUoeTxBuffer_DLen ("sUoeTxBuffer_DLen");
 
  static stream<bool>                 sCacheInvalDel_Notif ("sCacheInvalDel_Notif");
 
  static stream<NetworkWord>         sFmcTcpDataRx_buffer ("sFmcTcpDataRx_buffer");
  static stream<TcpSessId>           sFmcTcpMetaRx_buffer ("sFmcTcpMetaRx_buffer");
 
 
#pragma HLS STREAM variable=internal_event_fifo_0 depth=16
#pragma HLS STREAM variable=internal_event_fifo_1 depth=16
#pragma HLS STREAM variable=internal_event_fifo_2 depth=16
#pragma HLS STREAM variable=internal_event_fifo_3 depth=16
#pragma HLS STREAM variable=merged_fifo depth=64
 
  //#pragma HLS STREAM variable=sA4lToTcpAgency  depth=16 //(currently not used)
#pragma HLS STREAM variable=sA4lToPortLogic  depth=8
#pragma HLS STREAM variable=sA4lToUdpRx      depth=8
#pragma HLS STREAM variable=sA4lToTcpRx      depth=8
#pragma HLS STREAM variable=sA4lToStatusProc depth=8
#pragma HLS STREAM variable=sA4lMrtUpdate    depth=16
#pragma HLS STREAM variable=sStatusUpdate    depth=128 //should be larger than ctrlLink size
 
#pragma HLS STREAM variable=sGetIpReq_UdpTx  depth=16 //MRT process takes longer -> better more buffer
#pragma HLS STREAM variable=sGetIpRep_UdpTx  depth=16
#pragma HLS STREAM variable=sGetIpReq_TcpTx  depth=16
#pragma HLS STREAM variable=sGetIpRep_TcpTx  depth=16
#pragma HLS STREAM variable=sGetNidReq_UdpRx depth=16
#pragma HLS STREAM variable=sGetNidRep_UdpRx depth=16
#pragma HLS STREAM variable=sGetNidReq_TcpRx depth=16
#pragma HLS STREAM variable=sGetNidRep_TcpRx depth=16
#pragma HLS STREAM variable=sGetNidReq_TcpTx depth=16
#pragma HLS STREAM variable=sGetNidRep_TcpTx depth=16
 
#pragma HLS STREAM variable=sUdpPortsToClose      depth=4
#pragma HLS STREAM variable=sUdpPortsToOpen       depth=4
#pragma HLS STREAM variable=sUdpPortsOpenFeedback depth=4
#pragma HLS STREAM variable=sTcpPortsToOpen       depth=4
#pragma HLS STREAM variable=sTcpPortsOpenFeedback depth=4
 
 
#pragma HLS STREAM variable=sRoleTcpDataRx_buffer depth=252 //NAL_MAX_FIFO_DEPTS_BYTES/8 (+2)
#pragma HLS STREAM variable=sRoleTcpMetaRx_buffer depth=32
 
#pragma HLS STREAM variable=sTcpWrp2Wbu_data      depth=252 //NAL_MAX_FIFO_DEPTS_BYTES/8 (+2)
#pragma HLS STREAM variable=sTcpWrp2Wbu_sessId    depth=32
#pragma HLS STREAM variable=sTcpWrp2Wbu_len       depth=32
 
 
#pragma HLS STREAM variable=sGetTripleFromSid_Req    depth=8
#pragma HLS STREAM variable=sGetTripleFromSid_Rep    depth=8
#pragma HLS STREAM variable=sGetSidFromTriple_Req    depth=8
#pragma HLS STREAM variable=sGetSidFromTriple_Rep    depth=8
#pragma HLS STREAM variable=sAddNewTriple_TcpRrh     depth=8
#pragma HLS STREAM variable=sAddNewTriple_TcpCon     depth=8
#pragma HLS STREAM variable=sDeleteEntryBySid        depth=8
#pragma HLS STREAM variable=sMarkAsPriv              depth=8
#pragma HLS STREAM variable=sMarkToDel_unpriv        depth=8
#pragma HLS STREAM variable=sGetNextDelRow_Req       depth=8
#pragma HLS STREAM variable=sGetNextDelRow_Rep       depth=8
#pragma HLS STREAM variable=sRDp_ReqNotif            depth=8
 
#pragma HLS STREAM variable=sNewTcpCon_Req       depth=4
#pragma HLS STREAM variable=sNewTcpCon_Rep       depth=4
 
  //#pragma HLS STREAM variable=sTcpNotif_buffer     depth=1024
#pragma HLS STREAM variable=sTcpNotif_buffer     depth=8192
 
  //#pragma HLS RESOURCE variable=localMRT core=RAM_2P_BRAM
  //#pragma HLS ARRAY_PARTITION variable=localMRT cyclic factor=8 dim=1
  //#pragma HLS ARRAY_PARTITION variable=localMRT complete dim=1
 
#pragma HLS STREAM variable=sMrtVersionUpdate_0  depth=4
#pragma HLS STREAM variable=sMrtVersionUpdate_1  depth=4
 
#pragma HLS STREAM variable=sCacheInvalSig_0 depth=4
#pragma HLS STREAM variable=sCacheInvalSig_1 depth=4
#pragma HLS STREAM variable=sCacheInvalSig_2 depth=4
#pragma HLS STREAM variable=sCacheInvalSig_3 depth=4
 
#pragma HLS STREAM variable=sRoleFifoEmptySig depth=8
#pragma HLS STREAM variable=sFmcFifoEmptySig depth=8
 
#pragma HLS STREAM variable=sStartTclCls_sig depth=4
#pragma HLS STREAM variable=sNalPortUpdate   depth=8
 
  //#pragma HLS STREAM variable=sRoleUdpDataRx_buffer depth=252 //NAL_MAX_FIFO_DEPTS_BYTES/8 (+2)
  //#pragma HLS STREAM variable=sRoleUdpMetaRx_buffer depth=32
#pragma HLS STREAM variable=sRoleUdpDataRx_buffer depth=512 // ~2 * NAL_MAX_FIFO_DEPTS_BYTES/8 (+2)
#pragma HLS STREAM variable=sRoleUdpMetaRx_buffer depth=64
 
#pragma HLS STREAM variable=sUoeTxBuffer_Data  depth=252 //NAL_MAX_FIFO_DEPTS_BYTES/8 (+2)
#pragma HLS STREAM variable=sUoeTxBuffer_Meta  depth=32
#pragma HLS STREAM variable=sUoeTxBuffer_DLen  depth=32
 
#pragma HLS STREAM variable=sCacheInvalDel_Notif  depth=4
 
#pragma HLS STREAM variable=sFmcTcpDataRx_buffer depth=252 //NAL_MAX_FIFO_DEPTS_BYTES/8 (+2)
#pragma HLS STREAM variable=sFmcTcpMetaRx_buffer depth=32
 
 
  //===========================================================
  // check for chache invalidation and changes to ports
  // restore saved states after a reset
 
  pCacheInvalDetection(layer_4_enabled, layer_7_enabled, role_decoupled, piNTS_ready, sMrtVersionUpdate_0,
      sCacheInvalDel_Notif, sCacheInvalSig_0, sCacheInvalSig_1, sCacheInvalSig_2, sCacheInvalSig_3);
 
  pPortLogic(layer_4_enabled, layer_7_enabled, role_decoupled, piNTS_ready, piMMIO_FmcLsnPort,
      pi_udp_rx_ports, pi_tcp_rx_ports, sA4lToPortLogic, sUdpPortsToOpen, sUdpPortsToClose,
      sTcpPortsToOpen, sUdpPortsOpenFeedback, sTcpPortsOpenFeedback, sMarkToDel_unpriv,
      sNalPortUpdate, sStartTclCls_sig);
 
  //=================================================================================================
  // TX UDP
 
  pUdpTX(siUdp_data, siUdp_meta, sUoeTxBuffer_Data, sUoeTxBuffer_Meta, sUoeTxBuffer_DLen,
      sGetIpReq_UdpTx, sGetIpRep_UdpTx,
      myIpAddress, sCacheInvalSig_0, internal_event_fifo_0);
 
  pUoeUdpTxDeq(layer_4_enabled, piNTS_ready, sUoeTxBuffer_Data, sUoeTxBuffer_Meta, sUoeTxBuffer_DLen,
      soUOE_Data, soUOE_Meta, soUOE_DLen);
 
  //=================================================================================================
  // RX UDP
 
  pUdpLsn(soUOE_LsnReq, siUOE_LsnRep, sUdpPortsToOpen, sUdpPortsOpenFeedback);
 
  pUdpRx(layer_7_enabled, role_decoupled, sRoleUdpDataRx_buffer, sRoleUdpMetaRx_buffer,
      siUOE_Data, siUOE_Meta, siUOE_DLen,
      sA4lToUdpRx, sGetNidReq_UdpRx, sGetNidRep_UdpRx,
      sCacheInvalSig_1, internal_event_fifo_1);
 
  pRoleUdpRxDeq(layer_7_enabled, role_decoupled, sRoleUdpDataRx_buffer, sRoleUdpMetaRx_buffer,
      soUdp_data, soUdp_meta);
 
  //=================================================================================================
  // UDP Port Close
 
  pUdpCls(soUOE_ClsReq, siUOE_ClsRep, sUdpPortsToClose);
 
  //=================================================================================================
  // TCP pListen
  pTcpLsn(soTOE_LsnReq, siTOE_LsnRep, sTcpPortsToOpen, sTcpPortsOpenFeedback);
 
  //=================================================================================================
  // TCP Read Request Handler
 
  pTcpRxNotifEnq(layer_4_enabled, piNTS_ready, siTOE_Notif, sTcpNotif_buffer);
 
  pTcpRRh(layer_4_enabled, piNTS_ready, piMMIO_CfrmIp4Addr, piMMIO_FmcLsnPort, sTcpNotif_buffer,
      soTOE_DReq, sAddNewTriple_TcpRrh, sMarkAsPriv, sDeleteEntryBySid,  sRDp_ReqNotif,
      sFmcFifoEmptySig, sRoleFifoEmptySig);
 
  //=================================================================================================
  // TCP Read Path
  pTcpRDp(layer_4_enabled, piNTS_ready, sRDp_ReqNotif, siTOE_Data, siTOE_SessId, 
      sFmcTcpDataRx_buffer, sFmcTcpMetaRx_buffer,
      sRoleTcpDataRx_buffer, sRoleTcpMetaRx_buffer,
      sA4lToTcpRx, sGetNidReq_TcpRx, sGetNidRep_TcpRx, sGetTripleFromSid_Req, sGetTripleFromSid_Rep,
      //sMarkAsPriv, 
      piMMIO_CfrmIp4Addr, piMMIO_FmcLsnPort, layer_7_enabled, role_decoupled,
      sCacheInvalSig_2, internal_event_fifo_2);
 
  pFmcTcpRxDeq(sFmcTcpDataRx_buffer, sFmcTcpMetaRx_buffer, soFMC_data, soFMC_SessId, sFmcFifoEmptySig);
 
  pRoleTcpRxDeq(layer_7_enabled, role_decoupled, sRoleTcpDataRx_buffer, sRoleTcpMetaRx_buffer, soTcp_data, soTcp_meta, sRoleFifoEmptySig);
 
  //=================================================================================================
  // TCP Write Path
  pTcpWRp(layer_4_enabled, piNTS_ready, siFMC_data, siFMC_SessId, siTcp_data, siTcp_meta,
      sTcpWrp2Wbu_data, sTcpWrp2Wbu_sessId, sTcpWrp2Wbu_len,
      sGetIpReq_TcpTx, sGetIpRep_TcpTx,
      //sGetNidReq_TcpTx, sGetNidRep_TcpTx,
      sGetSidFromTriple_Req, sGetSidFromTriple_Rep, sNewTcpCon_Req, sNewTcpCon_Rep,
      sCacheInvalSig_3, internal_event_fifo_3);
 
  pTcpWBu(layer_4_enabled, piNTS_ready, sTcpWrp2Wbu_data, sTcpWrp2Wbu_sessId, sTcpWrp2Wbu_len,
      soTOE_Data, soTOE_SndReq, siTOE_SndRep);
 
  //=================================================================================================
  // TCP start remote connection
  pTcpCOn(soTOE_OpnReq, siTOE_OpnRep, sAddNewTriple_TcpCon, sNewTcpCon_Req, sNewTcpCon_Rep);
 
  //=================================================================================================
  // TCP connection close
  pTcpCls(soTOE_ClsReq, sGetNextDelRow_Req, sGetNextDelRow_Rep, sStartTclCls_sig);
 
  //=================================================================================================
  // TCP Table Management
 
  pTcpAgency(sGetTripleFromSid_Req, sGetTripleFromSid_Rep, sGetSidFromTriple_Req, sGetSidFromTriple_Rep,
      sAddNewTriple_TcpRrh, sAddNewTriple_TcpCon, sDeleteEntryBySid, sCacheInvalDel_Notif,
      sMarkAsPriv, sMarkToDel_unpriv, sGetNextDelRow_Req, sGetNextDelRow_Rep);
 
  //===========================================================
  //  update status, config, MRT
 
  eventFifoMerge( internal_event_fifo_0, internal_event_fifo_1, internal_event_fifo_2, internal_event_fifo_3, merged_fifo);
 
  pStatusMemory(merged_fifo, layer_7_enabled, role_decoupled, sA4lToStatusProc, sMrtVersionUpdate_1, sNalPortUpdate, sStatusUpdate);
 
 
  axi4liteProcessing(ctrlLink,
      //sA4lToTcpAgency, //(currently not used)
      sA4lToPortLogic, sA4lToUdpRx,
      sA4lToTcpRx, sA4lToStatusProc,
      sA4lMrtUpdate,
      //localMRT,
      sMrtVersionUpdate_0, sMrtVersionUpdate_1,
      sStatusUpdate);
 
 
  pMrtAgency(sA4lMrtUpdate, sGetIpReq_UdpTx, sGetIpRep_UdpTx, sGetIpReq_TcpTx, sGetIpRep_TcpTx, sGetNidReq_UdpRx, sGetNidRep_UdpRx, sGetNidReq_TcpRx, sGetNidRep_TcpRx);
 
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

newTriple()

NalTriple newTriple	(	Ip4Addr	ipRemoteAddres,
		TcpPort	tcpRemotePort,
		TcpPort	tcpLocalPort
	)

Definition at line 62 of file nal.cpp.

{
#pragma HLS INLINE
  NalTriple new_entry = (((ap_uint<64>) ipRemoteAddres) << 32) | (((ap_uint<32>) tcpRemotePort) << 16) | tcpLocalPort;
  return new_entry;
}

Here is the caller graph for this function:

pCacheInvalDetection()

void pCacheInvalDetection	(	ap_uint< 1 > *	layer_4_enabled,
		ap_uint< 1 > *	layer_7_enabled,
		ap_uint< 1 > *	role_decoupled,
		ap_uint< 1 > *	piNTS_ready,
		stream< uint32_t > &	mrt_version_update,
		stream< bool > &	inval_del_sig,
		stream< bool > &	cache_inval_0,
		stream< bool > &	cache_inval_1,
		stream< bool > &	cache_inval_2,
		stream< bool > &	cache_inval_3
	)

Detects if the caches of the USS and TSS have to be invalidated and signals this to the concerned processes.

Parameters

[in]	layer_4_enabled,external	signal if layer 4 is enabled
[in]	layer_7_enabled,external	signal if layer 7 is enabled
[in]	role_decoupled,external	signal if the role is decoupled
[in]	piNTS_ready,external	signal if NTS is up and running
[in]	mrt_version_update,notification	of MRT version change
[in]	inval_del_sig,notification	of connection closing
[out]	cache_inval_0,signals	that caches must be invalidated
[out]	cache_inval_1,signals	that caches must be invalidated
[out]	cache_inval_2,signals	that caches must be invalidated
[out]	cache_inval_3,signals	that caches must be invalidated

Definition at line 889 of file hss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static CacheInvalFsmStates cache_fsm = CACHE_WAIT_FOR_VALID;
  static uint32_t mrt_version_current = 0;
 
#pragma HLS RESET variable=cache_fsm
#pragma HLS RESET variable=mrt_version_current
 
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static ap_uint<1> role_state;
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
 
  //===========================================================
 
  switch (cache_fsm)
  {
    default:
    case CACHE_WAIT_FOR_VALID:
      if(*layer_4_enabled == 1 && *piNTS_ready == 1)
      {
        role_state = *role_decoupled;
        cache_fsm = CACHE_VALID;
      }
      break;
    case CACHE_VALID:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0 || *role_decoupled != role_state || *layer_7_enabled == 0)
      {
        if(*role_decoupled == 0 || *layer_4_enabled == 0 || *piNTS_ready == 0)
        { //not layer_7_enabled == 0, since this would also be valid during PR
          //role_decoupled == 0, if layer_7_enabled == 0 but no PR, so we invalidate the cache
          //but wait until a PR is done
 
          //i.e. after a PR
          cache_fsm = CACHE_INV_SEND_0;
          printf("[pCacheInvalDetection] Detected cache invalidation condition!\n");
        } else {
          //not yet invalid
          role_state = *role_decoupled;
        }
      } else if(!mrt_version_update.empty())
      {
        uint32_t tmp = mrt_version_update.read();
        if(tmp != mrt_version_current)
        {
          mrt_version_current = tmp;
          cache_fsm = CACHE_INV_SEND_0;
        }
      } else if(!inval_del_sig.empty())
      {
        bool sig = inval_del_sig.read();
        if(sig)
        {
          cache_fsm = CACHE_INV_SEND_2;
          //we only need to invalidate the Cache of the TCP processes
          //(2 and 3)
        }
      }
      break;
    case CACHE_INV_SEND_0:
      //UDP RX
      if(!cache_inval_0.full())
      {
        cache_inval_0.write(true);
        cache_fsm = CACHE_INV_SEND_1;
      }
      break;
    case CACHE_INV_SEND_1:
      //UDP TX
      if(!cache_inval_1.full())
      {
        cache_inval_1.write(true);
        cache_fsm = CACHE_INV_SEND_2;
      }
      break;
    case CACHE_INV_SEND_2:
      //TCP RDp
      if(!cache_inval_2.full())
      {
        cache_inval_2.write(true);
        cache_fsm = CACHE_INV_SEND_3;
      }
      break;
    case CACHE_INV_SEND_3:
      //TCP WRp
      if(!cache_inval_3.full())
      {
        cache_inval_3.write(true);
        cache_fsm = CACHE_WAIT_FOR_VALID;
      }
      break;
  }
}

Here is the caller graph for this function:

pFMC()

void pFMC	(	stream< NetworkWord > &	siTRIF_Data,
		stream< TcpSessId > &	siTRIF_SessId,
		stream< NetworkWord > &	soTRIF_Data,
		stream< TcpSessId > &	soTRIF_SessId
	)

Emulate the behavior of the FMC.

Parameters

[in]	siTRIF_Data,Data	to TcpRoleInterface (TRIF).
[in]	siTRIF_SessId,Session	ID to [TRIF].
[out]	soROLE_Data,Data	stream to [TRIF].
[out]	soROLE_SessId	SessionID to [TRFI].

Definition at line 693 of file tb_nal.cpp.

{
    NetworkWord currWord;
    TcpSessId   tcpSessId;
 
    const char *myRxName  = concat3(THIS_NAME, "/", "FMC-Rx");
    const char *myTxName  = concat3(THIS_NAME, "/", "FMC-Tx");
 
    switch (rxFsmState ) {
    case RX_WAIT_META:
        if (!siTRIF_SessId.empty() and !soTRIF_SessId.full()) {
            //tcpSessId = siTRIF_SessId.read().tdata;
            tcpSessId = siTRIF_SessId.read();
            soTRIF_SessId.write(tcpSessId);
            rxFsmState  = RX_STREAM;
            printf("FMC received sessionID: %d\n", tcpSessId.to_uint());
        }
        break;
    case RX_STREAM:
        if (!siTRIF_Data.empty() && !soTRIF_Data.full()) {
            siTRIF_Data.read(currWord);
            //if (DEBUG_LEVEL & TRACE_ROLE) {
                 printAxiWord(myRxName, currWord);
            //}
            soTRIF_Data.write(currWord);
            if (currWord.tlast == 1) {
                rxFsmState  = RX_WAIT_META;
            }
        }
        break;
    }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

pFmcTcpRxDeq()

void pFmcTcpRxDeq	(	stream< NetworkWord > &	sFmcTcpDataRx_buffer,
		stream< TcpSessId > &	sFmcTcpMetaRx_buffer,
		stream< NetworkWord > &	soFmc_data,
		stream< TcpSessId > &	soFmc_meta,
		stream< PacketLen > &	fmc_write_cnt_sig
	)

Terminates the internal TCP RX FIFOs and forwards packets to the FMC.

Definition at line 1012 of file tss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static DeqFsmStates deqFsmState = DEQ_WAIT_META;
#pragma HLS RESET variable=deqFsmState
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static PacketLen current_bytes_written = 0;
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
  NetworkWord cur_word = NetworkWord();
  TcpSessId cur_meta = TcpSessId();
 
  switch(deqFsmState)
  {
    default:
    case DEQ_SEND_NOTIF:
      if(!fmc_write_cnt_sig.full())
      {
        fmc_write_cnt_sig.write(current_bytes_written);
        current_bytes_written = 0;
        deqFsmState = DEQ_WAIT_META;
      }
      break;
    case DEQ_WAIT_META:
      if(!sFmcTcpDataRx_buffer.empty() && !sFmcTcpMetaRx_buffer.empty()
          && !soFmc_data.full() && !soFmc_meta.full()
        )
      {
        printf("[pFmcTcpRxDeq] Start processing FMC packet\n");
        cur_word = sFmcTcpDataRx_buffer.read();
        cur_meta = sFmcTcpMetaRx_buffer.read();
        current_bytes_written = extractByteCnt(cur_word);
        soFmc_data.write(cur_word);
        soFmc_meta.write(cur_meta);
        if(cur_word.tlast == 0)
        {
          deqFsmState = DEQ_STREAM_DATA;
        } else {
          deqFsmState = DEQ_SEND_NOTIF;
        }
      }
      break;
    case DEQ_STREAM_DATA:
      if(!sFmcTcpDataRx_buffer.empty()
          && !soFmc_data.full()
        )
      {
        cur_word = sFmcTcpDataRx_buffer.read();
        soFmc_data.write(cur_word);
        current_bytes_written += extractByteCnt(cur_word);
        if(cur_word.tlast == 1)
        {
          deqFsmState = DEQ_SEND_NOTIF;
        }
      }
      break;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

pMrtAgency()

void pMrtAgency	(	stream< NalMrtUpdate > &	sMrtUpdate,
		stream< NodeId > &	sGetIpReq_UdpTx,
		stream< Ip4Addr > &	sGetIpRep_UdpTx,
		stream< NodeId > &	sGetIpReq_TcpTx,
		stream< Ip4Addr > &	sGetIpRep_TcpTx,
		stream< Ip4Addr > &	sGetNidReq_UdpRx,
		stream< NodeId > &	sGetNidRep_UdpRx,
		stream< Ip4Addr > &	sGetNidReq_TcpRx,
		stream< NodeId > &	sGetNidRep_TcpRx
	)

Can access the BRAM that contains the MRT and replies to lookup requests.

Parameters

[in]	sMrtUpdate,Notification	of MRT changes
[in]	sGetIpReq_UdpTx,Request	stream to get the IPv4 to a NodeId (from UdpTx)
[out]	sGetIpRep_UdpTx,Reply	stream containing the IP address (to UdpTx)
[in]	sGetIpReq_TcpTx,Request	stream to get the IPv4 to a NodeId (from TcpTx)
[out]	sGetIpRep_TcpTx,Reply	stream containing the IP address (to TcpTx)
[in]	sGetNidReq_UdpRx,Request	stream to get the NodeId to an IPv4 (from UdRx)
[out]	sGetNidRep_UdpRx,Reply	stream containing the NodeId (to UdpRx)
[in]	sGetNidReq_TcpRx,Request	stream to get the NodeId to an IPv4 (from TcpRx)
[out]	sGetNidRep_TcpRx,Reply	stream containing the NodeId (to TcpRX)

Definition at line 386 of file hss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  //static bool tables_initialized = false;
 
  //#pragma HLS reset variable=tables_initialized
 
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  //static ap_uint<32> localMRT[MAX_MRT_SIZE];
 
  //#define CAM_SIZE 8
  //#define CAM_NUM 16
  //  static Cam8<NodeId,Ip4Addr> mrt_cam_arr[CAM_NUM];
  //#ifndef __SYNTHESIS__
  //  if(MAX_MRT_SIZE != 128)
  //  {
  //    printf("\n\t\tERROR: pMrtAgency is currently configured to support only a MRT size up to 128! Abort.\n(Currently, the use of \'mrt_cam_arr\' must be updated accordingly by hand.)\n");
  //    exit(-1);
  //  }
  //#endif
 
  static ap_uint<32> localMRT[MAX_MRT_SIZE];
  //#pragma HLS ARRAY_PARTITION variable=localMRT cyclic factor=8 dim=1
#pragma HLS ARRAY_PARTITION variable=localMRT complete dim=1
 
 
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
 
  //  if(!tables_initialized)
  //  {
  //    //for(int i = 0; i < CAM_NUM; i++)
  //    //{
  //    //  mrt_cam_arr[i].reset();
  //    //}
  //    tables_initialized = true;
  //  } else
 
  if( !sMrtUpdate.empty() )
  {
    NalMrtUpdate mu = sMrtUpdate.read();
    if(mu.nid < MAX_MRT_SIZE)
    {
      localMRT[mu.nid] = mu.ip4a;
    }
 
  } else if( !sGetIpReq_UdpTx.empty() && !sGetIpRep_UdpTx.full())
  {
    NodeId rank;
    rank = sGetIpReq_UdpTx.read();
    //uint8_t cam_select = rank / CAM_SIZE;
    Ip4Addr rep = 0;  //return zero on failure
    //if(rank < MAX_MRT_SIZE && cam_select < CAM_NUM)
    if(rank < MAX_MRT_SIZE)
    {
      //mrt_cam_arr[cam_select].lookup(rank, rep);
      rep = localMRT[rank];
    }
    sGetIpRep_UdpTx.write(rep);
  }
  else if( !sGetIpReq_TcpTx.empty() && !sGetIpRep_TcpTx.full())
  {
    NodeId rank;
    rank = sGetIpReq_TcpTx.read();
    //uint8_t cam_select = rank / CAM_SIZE;
    Ip4Addr rep = 0;  //return zero on failure
    //if(rank < MAX_MRT_SIZE && cam_select < CAM_NUM)
    if(rank < MAX_MRT_SIZE)
    {
      //mrt_cam_arr[cam_select].lookup(rank, rep);
      rep = localMRT[rank];
    }
    sGetIpRep_TcpTx.write(rep);
  }
  else if( !sGetNidReq_UdpRx.empty() && !sGetNidRep_UdpRx.full())
  {
    ap_uint<32> ipAddr =  sGetNidReq_UdpRx.read();
    printf("[HSS-INFO] Searching for Node ID of IP %d.\n", (int) ipAddr);
    NodeId rep = INVALID_MRT_VALUE;
    for(uint32_t i = 0; i< MAX_MRT_SIZE; i++)
    {
#pragma HLS unroll factor=8
      if(localMRT[i] == ipAddr)
      {
        rep = (NodeId) i;
        break;
      }
    }
    printf("[HSS-INFO] found Node Id %d.\n", (int) rep);
    sGetNidRep_UdpRx.write(rep);
  }
  else if( !sGetNidReq_TcpRx.empty() && !sGetNidRep_TcpRx.full())
  {
    ap_uint<32> ipAddr =  sGetNidReq_TcpRx.read();
    printf("[HSS-INFO] Searching for Node ID of IP %d.\n", (int) ipAddr);
    NodeId rep = INVALID_MRT_VALUE;
    for(uint32_t i = 0; i< MAX_MRT_SIZE; i++)
    {
#pragma HLS unroll factor=8
      if(localMRT[i] == ipAddr)
      {
        rep = (NodeId) i;
        break;
      }
    }
    printf("[HSS-INFO] found Node Id %d.\n", (int) rep);
    sGetNidRep_TcpRx.write(rep);
  }
  //for(int i = 0; i < CAM_NUM; i++)
  //{
  //  if(mrt_cam_arr[i].reverse_lookup(ipAddr, rep))
  //  {
  //    break;
  //  }
  //}
}

Here is the caller graph for this function:

pPortLogic()

void pPortLogic	(	ap_uint< 1 > *	layer_4_enabled,
		ap_uint< 1 > *	layer_7_enabled,
		ap_uint< 1 > *	role_decoupled,
		ap_uint< 1 > *	piNTS_ready,
		ap_uint< 16 > *	piMMIO_FmcLsnPort,
		ap_uint< 32 > *	pi_udp_rx_ports,
		ap_uint< 32 > *	pi_tcp_rx_ports,
		stream< NalConfigUpdate > &	sConfigUpdate,
		stream< UdpPort > &	sUdpPortsToOpen,
		stream< UdpPort > &	sUdpPortsToClose,
		stream< TcpPort > &	sTcpPortsToOpen,
		stream< bool > &	sUdpPortsOpenFeedback,
		stream< bool > &	sTcpPortsOpenFeedback,
		stream< bool > &	sMarkToDel_unpriv,
		stream< NalPortUpdate > &	sPortUpdate,
		stream< bool > &	sStartTclCls
	)

Translates the one-hot encoded open-port vectors from the Role (i.e. piUdpRxPorts and piTcpRxPorts) to absolute port numbers If the input vector changes, or during a reset of the Role, the necessary open or close requests are send to pUdpLsn, pUdpCls, pTcpLsn, and pTcpCls.

Parameters

[in]	layer_4_enabled,external	signal if layer 4 is enabled
[in]	layer_7_enabled,external	signal if layer 7 is enabled
[in]	role_decoupled,external	signal if the role is decoupled
[in]	piNTS_ready,external	signal if NTS is up and running
[in]	piMMIO_FmcLsnPort,the	management listening port (from MMIO)
[in]	pi_udp_rx_ports,one-hot	encoded UDP Role listening ports
[in]	pi_tcp_rx_ports,one-hot	encoded Tcp Role listening ports
[in]	sConfigUpdate,notification	of configuration changes
[out]	sUdpPortsToOpen,stream	containing the next UdpPort to open (to pUdpLsn)
[out]	sUdpPortsToClose,stream	containing the next UdpPort to close (to pUdpCls)
[out]	sTcpPortsToOpen,stream	containing the next TcpPort to open (to pUdpLsn)
[in]	sUdpPortsOpenFeedback,signal	of Udp Port opening results (success/failure)
[in]	sTcpPortsOpenFeedback,signal	of Tcp Port opening results (success/failure)
[out]	sMarkToDel_unpriv,signal	to mark unpivileged Tcp session as to be closed (to TCP agency)
[out]	sPortUpdate,stream	containing updates of currently opened ports (to status processing)
[out]	sStartTclCls	signal to start TCP Connection closing (to pTcpCls)

Definition at line 545 of file hss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static ap_uint<16> processed_FMC_listen_port = 0;
  static ap_uint<32> tcp_rx_ports_processed = 0;
  static ap_uint<32> udp_rx_ports_processed = 0;
  static PortFsmStates port_fsm = PORT_RESET;
 
#ifndef __SYNTHESIS__
  static ap_uint<16>  mmio_stabilize_counter = 1;
#else
  static ap_uint<16>  mmio_stabilize_counter = NAL_MMIO_STABILIZE_TIME;
#endif
 
 
#pragma HLS reset variable=mmio_stabilize_counter
#pragma HLS reset variable=processed_FMC_listen_port
#pragma HLS reset variable=udp_rx_ports_processed
#pragma HLS reset variable=tcp_rx_ports_processed
#pragma HLS reset variable=port_fsm
 
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static ap_uint<16> new_relative_port_to_req_udp;
  static ap_uint<16> new_relative_port_to_req_tcp;
  static ap_uint<16> current_requested_port;
  static NalPortUpdate current_port_update;
 
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
 
  switch(port_fsm)
  {
    default:
    case PORT_RESET:
      if(mmio_stabilize_counter > 0)
      {
        mmio_stabilize_counter--;
      } else {
        port_fsm = PORT_IDLE;
      }
      break;
    case PORT_IDLE:
      if(!sConfigUpdate.empty())
      {
        // restore saved states (after NAL got reset)
        // TODO: apparently, this isn't working in time...for this we have to have a bigger "stabilizing count"
        // at the other side: to request ports twice is apparently not harmful
        NalConfigUpdate ca = sConfigUpdate.read();
        switch(ca.config_addr)
        {
          case NAL_CONFIG_SAVED_FMC_PORTS:
            if(processed_FMC_listen_port == 0)
            {
              processed_FMC_listen_port = (ap_uint<16>) ca.update_value;
            }
            break;
          case NAL_CONFIG_SAVED_UDP_PORTS:
            if(udp_rx_ports_processed == 0)
            {
              udp_rx_ports_processed = ca.update_value;
            }
            break;
          case NAL_CONFIG_SAVED_TCP_PORTS:
            if(tcp_rx_ports_processed == 0)
            {
              tcp_rx_ports_processed = ca.update_value;
            }
            break;
          default:
            printf("[ERROR] invalid config update received!\n");
            break;
        }
 
      } else if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        port_fsm = PORT_L4_RESET;
      } else if(processed_FMC_listen_port != *piMMIO_FmcLsnPort)
      { //process FMC port first!
        port_fsm = PORT_NEW_FMC_REQ;
      } else if (*layer_7_enabled == 0 || *role_decoupled == 1 )
      {
        port_fsm = PORT_L7_RESET;
      } else {
        //  Role port requests
        if(udp_rx_ports_processed != *pi_udp_rx_ports)
        {
          port_fsm = PORT_NEW_UDP_REQ;
        }
        else if(tcp_rx_ports_processed != *pi_tcp_rx_ports)
        {
          port_fsm = PORT_NEW_TCP_REQ;
        }
      }
      break;
    case PORT_L4_RESET:
      if(!sPortUpdate.full()
          && (processed_FMC_listen_port != 0 || udp_rx_ports_processed != 0 || tcp_rx_ports_processed !=0 )
        )
      {//first, notify
        if(processed_FMC_listen_port != 0)
        {
          sPortUpdate.write(NalPortUpdate(FMC, 0));
          processed_FMC_listen_port = 0;
        }
        else if(udp_rx_ports_processed != 0)
        {
          sPortUpdate.write(NalPortUpdate(UDP, 0));
          udp_rx_ports_processed = 0;
        }
        else if(tcp_rx_ports_processed != 0)
        {
          sPortUpdate.write(NalPortUpdate(TCP, 0));
          tcp_rx_ports_processed = 0;
        }
      }
      else if(*layer_4_enabled == 1 && *piNTS_ready == 1)
      {
        //if layer 4 is reset, ports will be closed
        //in all cases
        processed_FMC_listen_port = 0x0;
        udp_rx_ports_processed = 0x0;
        tcp_rx_ports_processed = 0x0;
        port_fsm = PORT_IDLE;
        //no need for PORT_RESET (everything should still be "stable")
      }
      break;
    case PORT_L7_RESET:
      if(*layer_4_enabled == 1 && *piNTS_ready == 1)
      {
        if(udp_rx_ports_processed > 0)
        {
          port_fsm = PORT_START_UDP_CLS;
        } else if(tcp_rx_ports_processed > 0)
        {
          //port_fsm = PORT_START_TCP_CLS_0;
          port_fsm = PORT_START_TCP_CLS_1;
        } else {
          port_fsm = PORT_IDLE;
        }
      } else {
        port_fsm = PORT_L4_RESET;
      }
      break;
    case PORT_START_UDP_CLS:
      if(!sUdpPortsToClose.full())
      {
 
        //mark all UDP ports as to be deleted
        ap_uint<16> newRelativePortToClose = 0;
        ap_uint<16> newAbsolutePortToClose = 0;
        if(udp_rx_ports_processed != 0)
        {
          newRelativePortToClose = getRightmostBitPos(udp_rx_ports_processed);
          newAbsolutePortToClose = NAL_RX_MIN_PORT + newRelativePortToClose;
          sUdpPortsToClose.write(newAbsolutePortToClose);
          ap_uint<32> one_cold_closed_port = ~(((ap_uint<32>) 1) << (newRelativePortToClose));
          udp_rx_ports_processed &= one_cold_closed_port;
          printf("new UDP port ports to close: %#04x\n",(unsigned int) udp_rx_ports_processed);
        }
        if(udp_rx_ports_processed == 0)
        {
          current_port_update = NalPortUpdate(UDP, 0);
          port_fsm = PORT_SEND_UPDATE;
        }
      }
      break;
      //case PORT_START_TCP_CLS_0:
      //to close the open Role ports (not connections)
      //TODO, add if TOE supports it
      //  break;
    case PORT_START_TCP_CLS_1:
      if(!sMarkToDel_unpriv.full())
      {
        sMarkToDel_unpriv.write(true);
        if(*role_decoupled == 1)
        {
          port_fsm = PORT_WAIT_PR;
        } else {
          port_fsm = PORT_START_TCP_CLS_2;
        }
      }
      break;
    case PORT_WAIT_PR:
      if(*role_decoupled == 0)
      {
        port_fsm = PORT_START_TCP_CLS_2;
      }
      break;
    case PORT_START_TCP_CLS_2:
      if(!sStartTclCls.full())
      {
        sStartTclCls.write(true);
        tcp_rx_ports_processed = 0x0;
        current_port_update = NalPortUpdate(TCP, 0);
        port_fsm = PORT_SEND_UPDATE;
      }
      break;
    case PORT_NEW_FMC_REQ:
      //TODO: if processed_FMC_listen_port != 0, we should actually close it?
      if(!sTcpPortsToOpen.full())
      {
        printf("Need FMC port request: %#02x\n",(unsigned int) *piMMIO_FmcLsnPort);
        sTcpPortsToOpen.write(*piMMIO_FmcLsnPort);
        current_requested_port = *piMMIO_FmcLsnPort;
        port_fsm = PORT_NEW_FMC_REP;
      }
      break;
    case PORT_NEW_FMC_REP:
      if(!sTcpPortsOpenFeedback.empty())
      {
        bool fed = sTcpPortsOpenFeedback.read();
        if(fed)
        {
          processed_FMC_listen_port = current_requested_port;
          printf("FMC Port opened: %#03x\n",(int) processed_FMC_listen_port);
        } else {
          printf("[ERROR] FMC TCP port opening failed.\n");
          //TODO: add block list for ports? otherwise we will try it again and again
        }
        current_port_update = NalPortUpdate(FMC, processed_FMC_listen_port);
        port_fsm = PORT_SEND_UPDATE;
      }
      break;
    case PORT_NEW_UDP_REQ:
      if(!sUdpPortsToOpen.full())
      {
        ap_uint<32> tmp = udp_rx_ports_processed | *pi_udp_rx_ports;
        ap_uint<32> diff = udp_rx_ports_processed ^ tmp;
        //printf("rx_ports IN: %#04x\n",(int) *pi_udp_rx_ports);
        //printf("udp_rx_ports_processed: %#04x\n",(int) udp_rx_ports_processed);
        printf("UDP port diff: %#04x\n",(unsigned int) diff);
        if(diff != 0)
        {//we have to open new ports, one after another
          new_relative_port_to_req_udp = getRightmostBitPos(diff);
          UdpPort new_port_to_open = NAL_RX_MIN_PORT + new_relative_port_to_req_udp;
          sUdpPortsToOpen.write(new_port_to_open);
          port_fsm = PORT_NEW_UDP_REP;
        } else {
          udp_rx_ports_processed = *pi_udp_rx_ports;
          port_fsm = PORT_IDLE;
        }
      }
      break;
    case PORT_NEW_UDP_REP:
      if(!sUdpPortsOpenFeedback.empty())
      {
        bool fed = sUdpPortsOpenFeedback.read();
        if(fed)
        {
          udp_rx_ports_processed |= ((ap_uint<32>) 1) << (new_relative_port_to_req_udp);
          printf("new udp_rx_ports_processed: %#03x\n",(int) udp_rx_ports_processed);
        } else {
          printf("[ERROR] UDP port opening failed.\n");
          //TODO: add block list for ports? otherwise we will try it again and again
        }
        //in all cases
        current_port_update = NalPortUpdate(UDP, udp_rx_ports_processed);
        port_fsm = PORT_SEND_UPDATE;
      }
      break;
    case PORT_NEW_TCP_REQ:
      if( !sTcpPortsToOpen.full() )
      {
        ap_uint<32> tmp = tcp_rx_ports_processed | *pi_tcp_rx_ports;
        ap_uint<32> diff = tcp_rx_ports_processed ^ tmp;
        //printf("rx_ports IN: %#04x\n",(int) *pi_tcp_rx_ports);
        //printf("tcp_rx_ports_processed: %#04x\n",(int) tcp_rx_ports_processed);
        printf("TCP port diff: %#04x\n",(unsigned int) diff);
        if(diff != 0)
        {//we have to open new ports, one after another
          new_relative_port_to_req_tcp = getRightmostBitPos(diff);
          TcpPort new_port = NAL_RX_MIN_PORT + new_relative_port_to_req_tcp;
          sTcpPortsToOpen.write(new_port);
          port_fsm = PORT_NEW_TCP_REP;
        } else {
          tcp_rx_ports_processed = *pi_tcp_rx_ports;
          port_fsm = PORT_IDLE;
        }
      }
      break;
    case PORT_NEW_TCP_REP:
      if(!sTcpPortsOpenFeedback.empty())
      {
        bool fed = sTcpPortsOpenFeedback.read();
        if(fed)
        {
          tcp_rx_ports_processed |= ((ap_uint<32>) 1) << (new_relative_port_to_req_tcp);
          printf("new tcp_rx_ports_processed: %#03x\n",(int) tcp_rx_ports_processed);
        } else {
          printf("[ERROR] TCP port opening failed.\n");
          //TODO: add block list for ports? otherwise we will try it again and again
        }
        //in all cases
        current_port_update = NalPortUpdate(TCP, tcp_rx_ports_processed);
        port_fsm = PORT_SEND_UPDATE;
      }
      break;
    case PORT_SEND_UPDATE:
      if(!sPortUpdate.full())
      {
        sPortUpdate.write(current_port_update);
        port_fsm = PORT_IDLE;
      }
      break;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

pROLE()

void pROLE	(	stream< NetworkWord > &	siTRIF_Data,
		stream< NetworkMetaStream > &	siTRIF_meta,
		stream< NetworkWord > &	soTRIF_Data,
		stream< NetworkMetaStream > &	soTRIF_meta
	)

Emulate the behavior of the ROLE.

Parameters

[in]	siTRIF_Data,Data	to TcpRoleInterface (TRIF).
[in]	siTRIF_meta,Network	meta data.
[out]	soROLE_Data,Data	stream to [TRIF].
[out]	soROLE_meta,Network	meta data.

Definition at line 746 of file tb_nal.cpp.

{
    NetworkWord currWord;
    NetworkMetaStream meta_stream_in;
    NetworkMetaStream meta_stream_out;
 
    const char *myRxName  = concat3(THIS_NAME, "/", "ROLE-Rx");
    const char *myTxName  = concat3(THIS_NAME, "/", "ROLE-Tx");
 
    switch (roleFsmState ) {
    case ROLE_WAIT_META:
        if (!siTRIF_meta.empty() && !soTRIF_meta.full()) {
            siTRIF_meta.read(meta_stream_in);
            meta_stream_out = NetworkMetaStream();
            meta_stream_out.tkeep = 0xFFFF;
            meta_stream_out.tlast = 1;
            meta_stream_out.tdata.dst_rank = meta_stream_in.tdata.src_rank;
            meta_stream_out.tdata.dst_port = meta_stream_in.tdata.src_port;
            meta_stream_out.tdata.src_port = NAL_RX_MIN_PORT;
            if(meta_stream_in.tdata.dst_port == 2718)
            {
              meta_stream_out.tdata.len = meta_stream_in.tdata.len;
            } else {
              meta_stream_out.tdata.len = 0; //test streaming mode
            }
            printf("ROLE received stream from Node %d:%d (recv. port %d, length %d)\n", (int) meta_stream_in.tdata.src_rank, (int) meta_stream_in.tdata.src_port, (int) meta_stream_in.tdata.dst_port, (int) meta_stream_in.tdata.len);
            soTRIF_meta.write(meta_stream_out);
            roleFsmState  = ROLE_STREAM;
        }
        break;
    case ROLE_STREAM:
        if (!siTRIF_Data.empty() && !soTRIF_Data.full()) {
            siTRIF_Data.read(currWord);
            if (DEBUG_LEVEL & TRACE_ROLE) {
                 printAxiWord(myRxName, currWord);
            }
            soTRIF_Data.write(currWord);
            if (currWord.tlast)
                roleFsmState  = ROLE_WAIT_META;
        } else {
          printf("[%4.4d] \tERROR: pROLE cant write to NRC.\n", simCnt);
        }
        break;
    }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

pRoleTcpRxDeq()

void pRoleTcpRxDeq	(	ap_uint< 1 > *	layer_7_enabled,
		ap_uint< 1 > *	role_decoupled,
		stream< NetworkWord > &	sRoleTcpDataRx_buffer,
		stream< NetworkMetaStream > &	sRoleTcpMetaRx_buffer,
		stream< NetworkWord > &	soTcp_data,
		stream< NetworkMetaStream > &	soTcp_meta,
		stream< PacketLen > &	role_write_cnt_sig
	)

Terminates the internal TCP RX FIFOs and forwards packets to the Role.

Definition at line 929 of file tss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static DeqFsmStates deqFsmState = DEQ_WAIT_META;
#pragma HLS RESET variable=deqFsmState
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static PacketLen current_bytes_written = 0;
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
  NetworkWord cur_word = NetworkWord();
  NetworkMetaStream cur_meta = NetworkMetaStream();
  bool role_disabled = (*layer_7_enabled == 0 && *role_decoupled == 1);
 
  switch(deqFsmState)
  {
    default:
    case DEQ_SEND_NOTIF:
      if(!role_write_cnt_sig.full())
      {
        role_write_cnt_sig.write(current_bytes_written);
        current_bytes_written = 0;
        deqFsmState = DEQ_WAIT_META;
      }
      break;
    case DEQ_WAIT_META:
      if(!sRoleTcpDataRx_buffer.empty() && !sRoleTcpMetaRx_buffer.empty()
          && ( (!soTcp_data.full() && !soTcp_meta.full()) ||  //user can read
            (role_disabled) //role is disabled -> drain FIFOs
            )
        )
      {
        cur_word = sRoleTcpDataRx_buffer.read();
        cur_meta = sRoleTcpMetaRx_buffer.read();
        current_bytes_written = extractByteCnt(cur_word);
        if(!role_disabled)
        {
          soTcp_data.write(cur_word);
          soTcp_meta.write(cur_meta);
        }
        if(cur_word.tlast == 0)
        {
          deqFsmState = DEQ_STREAM_DATA;
        } else {
          deqFsmState = DEQ_SEND_NOTIF;
        }
      }
      break;
    case DEQ_STREAM_DATA:
      if(!sRoleTcpDataRx_buffer.empty()
          && (!soTcp_data.full() || role_disabled)
        )
      {
        cur_word = sRoleTcpDataRx_buffer.read();
        current_bytes_written += extractByteCnt(cur_word);
        if(!role_disabled)
        {
          soTcp_data.write(cur_word);
        }
        if(cur_word.tlast == 1)
        {
          deqFsmState = DEQ_SEND_NOTIF;
        }
      }
      break;
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

pRoleUdpRxDeq()

void pRoleUdpRxDeq	(	ap_uint< 1 > *	layer_7_enabled,
		ap_uint< 1 > *	role_decoupled,
		stream< NetworkWord > &	sRoleUdpDataRx_buffer,
		stream< NetworkMetaStream > &	sRoleUdpMetaRx_buffer,
		stream< NetworkWord > &	soUdp_data,
		stream< NetworkMetaStream > &	soUdp_meta
	)

Terminates the internal UDP RX FIFOs and forwards packets to the Role.

Definition at line 673 of file uss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static DeqFsmStates deqFsmState = DEQ_WAIT_META;
#pragma HLS RESET variable=deqFsmState
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
  NetworkWord cur_word = NetworkWord();
  NetworkMetaStream cur_meta = NetworkMetaStream();
  bool role_disabled = (*layer_7_enabled == 0 || *role_decoupled == 1);
 
  switch(deqFsmState)
  {
    default:
    case DEQ_WAIT_META:
      if(!sRoleUdpDataRx_buffer.empty() && !sRoleUdpMetaRx_buffer.empty()
          && ( (!soUdp_data.full() && !soUdp_meta.full()) ||  //user can read
            (role_disabled) //role is disabled -> drain FIFOs
            )
        )
      {
        cur_word = sRoleUdpDataRx_buffer.read();
        cur_meta = sRoleUdpMetaRx_buffer.read();
        if(!role_disabled)
        {
          soUdp_data.write(cur_word);
          soUdp_meta.write(cur_meta);
        }
        if(cur_word.tlast == 0)
        {
          deqFsmState = DEQ_STREAM_DATA;
        }
      }
      break;
    case DEQ_STREAM_DATA:
      if(!sRoleUdpDataRx_buffer.empty()
          && (!soUdp_data.full() || role_disabled)
        )
      {
        cur_word = sRoleUdpDataRx_buffer.read();
        if(!role_disabled)
        {
          soUdp_data.write(cur_word);
        }
        if(cur_word.tlast == 1)
        {
          deqFsmState = DEQ_WAIT_META;
        }
      }
      break;
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

pStatusMemory()

void pStatusMemory	(	stream< NalEventNotif > &	internal_event_fifo,
		ap_uint< 1 > *	layer_7_enabled,
		ap_uint< 1 > *	role_decoupled,
		stream< NalConfigUpdate > &	sConfigUpdate,
		stream< uint32_t > &	mrt_version_update,
		stream< NalPortUpdate > &	sNalPortUpdate,
		stream< NalStatusUpdate > &	sStatusUpdate
	)

Maps the individual event notification of the USS/TSS processes to the status array as part of the Axi4Lite address space. Forwards status changes to Axi4Lite processing.

Parameters

[in]	internal_event_fifo,the	merged event fifo
[in]	layer_7_enabled,external	signal if layer 7 is enabled
[in]	role_decoupled,external	signal if the role is decoupled
[in]	sConfigUpdate,notification	of configuration changes
[in]	mrt_version_update,notification	of MRT version change
[in]	sNalPortUpdate,notification	if ports were opened or closed
[out]	sStatusUpdate,the	status update notification for Axi4Lite proc

Definition at line 180 of file nal.cpp.

{  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static ap_uint<32> node_id_missmatch_RX_cnt = 0;
  static NodeId last_rx_node_id = 0;
  static NrcPort last_rx_port = 0;
  static ap_uint<32> node_id_missmatch_TX_cnt = 0;
  static NodeId last_tx_node_id = 0;
  static NrcPort last_tx_port = 0;
  static ap_uint<16> port_corrections_TX_cnt = 0;
  static ap_uint<32> unauthorized_access_cnt = 0;
  static ap_uint<32> authorized_access_cnt = 0;
  static ap_uint<32> fmc_tcp_bytes_cnt = 0;
 
  static ap_uint<32> packet_count_RX = 0;
  static ap_uint<32> packet_count_TX = 0;
  static NodeId own_rank = 0;
 
  static ap_uint<16> tcp_new_connection_failure_cnt = 0;
 
 
  static bool tables_initialized = false;
  static uint8_t status_update_i = 0;
 
#pragma HLS reset variable=node_id_missmatch_RX_cnt
#pragma HLS reset variable=node_id_missmatch_TX_cnt
#pragma HLS reset variable=port_corrections_TX_cnt
#pragma HLS reset variable=packet_count_RX
#pragma HLS reset variable=packet_count_TX
#pragma HLS reset variable=last_rx_node_id
#pragma HLS reset variable=last_rx_port
#pragma HLS reset variable=last_tx_node_id
#pragma HLS reset variable=last_tx_port
#pragma HLS reset variable=unauthorized_access_cnt
#pragma HLS reset variable=authorized_access_cnt
#pragma HLS reset variable=fmc_tcp_bytes_cnt
#pragma HLS reset variable=tcp_new_connection_failure_cnt
#pragma HLS reset variable=tables_initialized
#pragma HLS reset variable=status_update_i
#pragma HLS reset variable=own_rank
 
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
 
  static ap_uint<32> status[NUMBER_STATUS_WORDS];
  static ap_uint<32> old_status[NUMBER_STATUS_WORDS];
 
#pragma HLS ARRAY_PARTITION variable=status complete dim=1
#pragma HLS ARRAY_PARTITION variable=old_status complete dim=1
 
  // ----- tables init -----
  if(!tables_initialized)
  {
    for(int i = 0; i < NUMBER_STATUS_WORDS; i++)
    {
      status[i] = 0x0;
      old_status[i] = 0x0;
    }
    tables_initialized = true;
  } else if( *layer_7_enabled == 0 || *role_decoupled == 1
      && (packet_count_TX > 0 || packet_count_RX > 0 )
      )
  {
    //reset counters
    packet_count_TX = 0x0;
    packet_count_RX = 0x0;
    last_rx_port = 0x0;
    last_rx_node_id = 0x0;
    last_tx_port = 0x0;
    last_tx_node_id = 0x0;
  } else if(!sConfigUpdate.empty())
  {
    NalConfigUpdate ca = sConfigUpdate.read();
    if(ca.config_addr == NAL_CONFIG_OWN_RANK)
    {
      own_rank = ca.update_value;
      status[NAL_STATUS_OWN_RANK] = (ap_uint<32>) own_rank;
    }
  } else if(!mrt_version_update.empty())
  {
    status[NAL_STATUS_MRT_VERSION] = mrt_version_update.read();
    //packet_count_TX = 0x0;
    //packet_count_RX = 0x0;
    //last_rx_port = 0x0;
    //last_rx_node_id = 0x0;
    //last_tx_port = 0x0;
    //last_tx_node_id = 0x0;
  }
  else if(!sNalPortUpdate.empty())
  {
    NalPortUpdate update = sNalPortUpdate.read();
    switch(update.port_type)
    {
      case FMC:
        status[NAL_STATUS_FMC_PORT_PROCESSED] = update.new_value;
        break;
      case UDP:
        status[NAL_STATUS_OPEN_UDP_PORTS] = update.new_value;
        break;
      case TCP:
        status[NAL_STATUS_OPEN_TCP_PORTS] = update.new_value;
        break;
    }
  }
  else if(!internal_event_fifo.empty())
  {
    NalEventNotif nevs = internal_event_fifo.read();
    //printf("[DEBUG] Process event %d with update value %d\n", \
    //    (int) nevs.type, (int) nevs.update_value);
 
    switch(nevs.type)
    {
      case NID_MISS_RX:
        node_id_missmatch_RX_cnt += nevs.update_value;
        break;
      case NID_MISS_TX:
        node_id_missmatch_TX_cnt += nevs.update_value;
        break;
      case PCOR_TX:
        port_corrections_TX_cnt += (ap_uint<16>) nevs.update_value;
        break;
      case TCP_CON_FAIL:
        tcp_new_connection_failure_cnt += (ap_uint<16>) nevs.update_value;
        break;
      case LAST_RX_PORT:
        last_rx_port = (ap_uint<16>) nevs.update_value;
        break;
      case LAST_RX_NID:
        last_rx_node_id = (NodeId) nevs.update_value;
        break;
      case LAST_TX_PORT:
        last_tx_port = (ap_uint<16>) nevs.update_value;
        break;
      case LAST_TX_NID:
        last_tx_node_id = (NodeId)  nevs.update_value;
        break;
      case PACKET_RX:
        packet_count_RX += nevs.update_value;
        break;
      case PACKET_TX:
        packet_count_TX += nevs.update_value;
        break;
      case UNAUTH_ACCESS:
        unauthorized_access_cnt += nevs.update_value;
        break;
      case AUTH_ACCESS:
        authorized_access_cnt += nevs.update_value;
        break;
      case FMC_TCP_BYTES:
        fmc_tcp_bytes_cnt += nevs.update_value;
        break;
      default:
        printf("[ERROR] Internal Event Processing received invalid event %d with update value %d\n", \
            (int) nevs.type, (int) nevs.update_value);
        break;
    }
 
  } else {
 
    //update status entries
    //status[NAL_STATUS_MRT_VERSION] = *mrt_version_processed;
    //status[NAL_STATUS_OPEN_UDP_PORTS] = *udp_rx_ports_processed;
    //status[NAL_STATUS_OPEN_TCP_PORTS] = *tcp_rx_ports_processed;
    //status[NAL_STATUS_FMC_PORT_PROCESSED] = (ap_uint<32>) *processed_FMC_listen_port;
    //status[NAL_STATUS_OWN_RANK] = (ap_uint<32>) *own_rank;
 
    //udp
    //status[NAL_STATUS_SEND_STATE] = (ap_uint<32>) fsmStateRX_Udp;
    //status[NAL_STATUS_RECEIVE_STATE] = (ap_uint<32>) fsmStateTXenq_Udp;
    //status[NAL_STATUS_GLOBAL_STATE] = (ap_uint<32>) fsmStateTXdeq_Udp;
 
    //tcp
    //status[NAL_STATUS_SEND_STATE] = (ap_uint<32>) wrpFsmState;
    //status[NAL_STATUS_RECEIVE_STATE] = (ap_uint<32>) rdpFsmState;
    //status[NAL_STATUS_GLOBAL_STATE] = (ap_uint<32>) opnFsmState;
 
    status[NAL_STATUS_GLOBAL_STATE] = fmc_tcp_bytes_cnt;
 
    //status[NAL_STATUS_RX_NODEID_ERROR] = (ap_uint<32>) node_id_missmatch_RX_cnt;
    status[NAL_STATUS_RX_NODEID_ERROR] = (((ap_uint<32>) port_corrections_TX_cnt) << 16) | ( 0xFFFF & ((ap_uint<16>) node_id_missmatch_RX_cnt));
    status[NAL_STATUS_LAST_RX_NODE_ID] = (ap_uint<32>) (( (ap_uint<32>) last_rx_port) << 16) | ( (ap_uint<32>) last_rx_node_id);
    //status[NAL_STATUS_TX_NODEID_ERROR] = (ap_uint<32>) node_id_missmatch_TX_cnt;
    status[NAL_STATUS_TX_NODEID_ERROR] = (((ap_uint<32>) tcp_new_connection_failure_cnt) << 16) | ( 0xFFFF & ((ap_uint<16>) node_id_missmatch_TX_cnt));
    status[NAL_STATUS_LAST_TX_NODE_ID] = (ap_uint<32>) (((ap_uint<32>) last_tx_port) << 16) | ((ap_uint<32>) last_tx_node_id);
    //status[NAL_STATUS_TX_PORT_CORRECTIONS] = (((ap_uint<32>) tcp_new_connection_failure_cnt) << 16) | ((ap_uint<16>) port_corrections_TX_cnt);
    status[NAL_STATUS_PACKET_CNT_RX] = (ap_uint<32>) packet_count_RX;
    status[NAL_STATUS_PACKET_CNT_TX] = (ap_uint<32>) packet_count_TX;
 
    status[NAL_UNAUTHORIZED_ACCESS] = (ap_uint<32>) unauthorized_access_cnt;
    status[NAL_AUTHORIZED_ACCESS] = (ap_uint<32>) authorized_access_cnt;
 
 
    //check for differences
    if(!sStatusUpdate.full())
    {
      if(old_status[status_update_i] != status[status_update_i])
      {
        ap_uint<32> uv = status[status_update_i];
        NalStatusUpdate su = NalStatusUpdate(status_update_i, uv);
        sStatusUpdate.write(su);
        old_status[status_update_i] = status[status_update_i];
        //printf("[INFO] Internal Event Processing detected status change on address %d with new value %d\n", \
        //       (int) su.status_addr, (int) su.new_value);
      }
      //one at a time is enough
    }
    status_update_i++;
    if(status_update_i >= NUMBER_STATUS_WORDS)
    {
      status_update_i = 0;
    }
  } // else
 
}

Here is the caller graph for this function:

pTcpAgency()

void pTcpAgency	(	stream< SessionId > &	sGetTripleFromSid_Req,
		stream< NalTriple > &	sGetTripleFromSid_Rep,
		stream< NalTriple > &	sGetSidFromTriple_Req,
		stream< SessionId > &	sGetSidFromTriple_Rep,
		stream< NalNewTableEntry > &	sAddNewTriple_TcpRrh,
		stream< NalNewTableEntry > &	sAddNewTriple_TcpCon,
		stream< SessionId > &	sDeleteEntryBySid,
		stream< bool > &	inval_del_sig,
		stream< SessionId > &	sMarkAsPriv,
		stream< bool > &	sMarkToDel_unpriv,
		stream< bool > &	sGetNextDelRow_Req,
		stream< SessionId > &	sGetNextDelRow_Rep
	)

Contains the SessionId-Triple CAM for TCP sessions. It replies to stram requests.

Parameters

[in]	sGetTripleFromSid_Req,Request	stream to get the Tcp Triple to a SessionId
[out]	sGetTripleFromSid_Rep,Reply	stream containing Tcp Triple
[in]	sGetSidFromTriple_Req,Request	stream to get the SessionId to a Tcp Triple
[out]	sGetSidFromTriple_Rep,Reply	stream containing the SessionId
[in]	sAddNewTriple_TcpRrh,Stream	containing new SessionIds with Triples (from TcpRRh)
[out]	sAddNewTriple_TcpCon,Stream	containing new SessionIds with Triples (from TcpCOn)
[in]	sDeleteEntryBySid,Notification	to mark a table entry as closed
[out]	inval_del_sig,Notification	of connection closing to Cache Invalidation Logic
[in]	sMarkAsPriv,Notification	to mark a session as prvileged
[in]	sMarkToDel_unpriv,Signal	to mark all un-privileged sessions as to-be-deleted
[in]	sGetNextDelRow_Req,Request	to get the next sesseion that is marked as to-be-deleted
[out]	sGetNextDelRow_Rep,Reply	containin the SessionId of the next to-be-deleted session

Definition at line 1017 of file hss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  //static  TableFsmStates agencyFsm = TAB_FSM_READ;
  static  bool tables_initialized = false;
 
  //#pragma HLS RESET variable=agencyFsm
#pragma HLS RESET variable=tables_initialized
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static NalTriple  tripleList[MAX_NAL_SESSIONS];
  static SessionId   sessionIdList[MAX_NAL_SESSIONS];
  static ap_uint<1>  usedRows[MAX_NAL_SESSIONS];
  static ap_uint<1>  rowsToDelete[MAX_NAL_SESSIONS];
  static ap_uint<1>  privilegedRows[MAX_NAL_SESSIONS];
 
#pragma HLS ARRAY_PARTITION variable=tripleList complete dim=1
#pragma HLS ARRAY_PARTITION variable=sessionIdList complete dim=1
#pragma HLS ARRAY_PARTITION variable=usedRows complete dim=1
#pragma HLS ARRAY_PARTITION variable=rowsToDelete complete dim=1
#pragma HLS ARRAY_PARTITION variable=privilegedRows complete dim=1
 
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
 
 
  if (!tables_initialized)
  {
    printf("init tables...\n");
    for(int i = 0; i<MAX_NAL_SESSIONS; i++)
    {
      //#pragma HLS unroll
      sessionIdList[i] = 0;
      tripleList[i] = 0;
      usedRows[i]  =  0;
      rowsToDelete[i] = 0;
      privilegedRows[i] = 0;
    }
    tables_initialized = true;
  } else {
 
    //switch(agencyFsm)
    //{
    //case TAB_FSM_READ:
    if(!sGetTripleFromSid_Req.empty() && !sGetTripleFromSid_Rep.full())
    {
      SessionId sessionID = sGetTripleFromSid_Req.read();
      printf("searching for session: %d\n", (int) sessionID);
      uint32_t i = 0;
      NalTriple ret = UNUSED_TABLE_ENTRY_VALUE;
      bool found_smth = false;
      for(i = 0; i < MAX_NAL_SESSIONS; i++)
      {
        //#pragma HLS unroll factor=8
        if(sessionIdList[i] == sessionID && usedRows[i] == 1 && rowsToDelete[i] == 0)
        {
          ret = tripleList[i];
          printf("found triple entry: %d | %d |  %llu\n",(int) i, (int) sessionID, (unsigned long long) ret);
          found_smth = true;
          break;
        }
      }
      if(!found_smth)
      {
        //unkown session TODO
        printf("[TcpAgency:INFO] Unknown session requested\n");
      }
      sGetTripleFromSid_Rep.write(ret);
    } else if(!sGetSidFromTriple_Req.empty() && !sGetSidFromTriple_Rep.full())
    {
      NalTriple triple = sGetSidFromTriple_Req.read();
      printf("Searching for triple: %llu\n", (unsigned long long) triple);
      uint32_t i = 0;
      SessionId ret = UNUSED_SESSION_ENTRY_VALUE;
      bool found_smth = false;
      for(i = 0; i < MAX_NAL_SESSIONS; i++)
      {
        //#pragma HLS unroll factor=8
        if(tripleList[i] == triple && usedRows[i] == 1 && rowsToDelete[i] == 0)
        {
          ret = sessionIdList[i];
          found_smth = true;
          break;
        }
      }
      if(!found_smth)
      {
        //there is (not yet) a connection TODO
        printf("[TcpAgency:INFO] Unknown triple requested\n");
      }
      sGetSidFromTriple_Rep.write(ret);
    } else
      // agencyFsm = TAB_FSM_WRITE;
      // break;
      //case TAB_FSM_WRITE:
      if(!sAddNewTriple_TcpRrh.empty() || !sAddNewTriple_TcpCon.empty())
      {
        NalNewTableEntry ne_struct;
        if(!sAddNewTriple_TcpRrh.empty())
        {
          ne_struct = sAddNewTriple_TcpRrh.read();
        } else {
          ne_struct = sAddNewTriple_TcpCon.read();
        }
        SessionId sessionID = ne_struct.sessId;
        NalTriple new_entry = ne_struct.new_triple;
        printf("new tripple entry: %d |  %llu\n",(int) sessionID, (unsigned long long) new_entry);
        //first check for duplicates!
        //ap_uint<64> test_tripple = getTrippleFromSessionId(sessionID);
        uint32_t i = 0;
        SessionId ret = UNUSED_SESSION_ENTRY_VALUE;
        bool found_smth = false;
        for(i = 0; i < MAX_NAL_SESSIONS; i++)
        {
          //#pragma HLS unroll factor=8
          if(sessionIdList[i] == sessionID && usedRows[i] == 1 && rowsToDelete[i] == 0)
          {
            ret = tripleList[i];
            printf("found triple entry: %d | %d |  %llu\n",(int) i, (int) sessionID, (unsigned long long) ret);
            found_smth = true;
            break;
          }
        }
        if(found_smth)
        {
          printf("session/triple already known, skipping. \n");
          //break; no break, because other may want to run too
        } else {
          bool stored = false;
          uint32_t i = 0;
          for(i = 0; i < MAX_NAL_SESSIONS; i++)
          {
            //#pragma HLS unroll factor=8
            if(usedRows[i] == 0)
            {//next free one, tables stay in sync
              sessionIdList[i] = sessionID;
              tripleList[i] = new_entry;
              usedRows[i] = 1;
              privilegedRows[i] = 0;
              printf("stored triple entry: %d | %d |  %llu\n",(int) i, (int) sessionID, (unsigned long long) new_entry);
              stored = true;
              break;
            }
          }
          if(!stored)
          {
            //we run out of sessions... TODO
            //actually, should not happen, since we have same table size as TOE
            printf("[TcpAgency:ERROR] no free space left in table!\n");
          }
        }
      } else if(!sDeleteEntryBySid.empty() && !inval_del_sig.full())
      {
        SessionId sessionID = sDeleteEntryBySid.read();
        printf("try to delete session: %d\n", (int) sessionID);
        for(uint32_t i = 0; i < MAX_NAL_SESSIONS; i++)
        {
          //#pragma HLS unroll factor=8
          if(sessionIdList[i] == sessionID && usedRows[i] == 1)
          {
            usedRows[i] = 0;
            privilegedRows[i] = 0;
            printf("found and deleting session: %d\n", (int) sessionID);
            //notify cache invalidation
            inval_del_sig.write(true);
            break;
          }
        }
        //nothing to delete, nothing to do...
      } else if(!sMarkAsPriv.empty())
      {
        SessionId sessionID = sMarkAsPriv.read();
        printf("mark session as privileged: %d\n", (int) sessionID);
        for(uint32_t i = 0; i < MAX_NAL_SESSIONS; i++)
        {
          //#pragma HLS unroll factor=8
          if(sessionIdList[i] == sessionID && usedRows[i] == 1)
          {
            privilegedRows[i] = 1;
            rowsToDelete[i] = 0;
            return;
          }
        }
        //nothing found, nothing to do...
      } else if(!sMarkToDel_unpriv.empty())
      {
        if(sMarkToDel_unpriv.read())
        {
          for(uint32_t i = 0; i< MAX_NAL_SESSIONS; i++)
          {
            //#pragma HLS unroll factor=8
            if(privilegedRows[i] == 1)
            {
              continue;
            } else {
              rowsToDelete[i] = usedRows[i];
            }
          }
        }
      } else if(!sGetNextDelRow_Req.empty() && !sGetNextDelRow_Rep.full())
      {
        if(sGetNextDelRow_Req.read())
        {
          SessionId ret = UNUSED_SESSION_ENTRY_VALUE;
          bool found_smth = false;
          for(uint32_t i = 0; i< MAX_NAL_SESSIONS; i++)
          {
            //#pragma HLS unroll factor=8
            if(rowsToDelete[i] == 1)
            {
              ret = sessionIdList[i];
              //sessionIdList[i] = 0x0; //not necessary
              //tripleList[i] = 0x0;
              usedRows[i] = 0;
              rowsToDelete[i] = 0;
              //privilegedRows[i] = 0; //not necessary
              printf("Closing session %d at table row %d.\n",(int) ret, (int) i);
              found_smth = true;
              break;
            }
          }
          if(!found_smth)
          {
            //Tables are empty
            printf("TCP tables are empty\n");
          }
          sGetNextDelRow_Rep.write(ret);
        }
      }
    //agencyFsm = TAB_FSM_READ;
    //break;
    //} //switch
  } // else
}

Here is the caller graph for this function:

pTcpCls()

void pTcpCls	(	stream< TcpAppClsReq > &	soTOE_ClsReq,
		stream< bool > &	sGetNextDelRow_Req,
		stream< SessionId > &	sGetNextDelRow_Rep,
		stream< bool > &	sStartTclCls
	)

Asks the TOE to close Tcp connections, based on the request from pPortLogic.

Parameters

[out]	soTOE_ClsReq,close	connection request to TOE.
[in]	sGetNextDelRow_Req,request	stream to TCP Agency
[in]	sGetNextDelRow_Rep,reply	stream rom TCP Agency
[in]	sStartTclCls,start	signal from pPortLogic

Definition at line 1892 of file tss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
 
  char *myName  = concat3(THIS_NAME, "/", "Tcp_Cls");
 
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static ClsFsmStates clsFsmState_Tcp = CLS_IDLE;
 
#pragma HLS RESET variable=clsFsmState_Tcp
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
 
 
  switch (clsFsmState_Tcp) {
    default:
    case CLS_IDLE:
      //we wait until we are activated;
      if(!sStartTclCls.empty())
      {
        if(sStartTclCls.read())
        {
          clsFsmState_Tcp = CLS_NEXT;
        }
      }
      break;
    case CLS_NEXT:
      if(!sGetNextDelRow_Req.full())
      {
        sGetNextDelRow_Req.write(true);
        clsFsmState_Tcp = CLS_WAIT4RESP;
      }
      break;
    case CLS_WAIT4RESP:
      if(!soTOE_ClsReq.full() && !sGetNextDelRow_Rep.empty())
      {
        SessionId nextToDelete = sGetNextDelRow_Rep.read();
        if(nextToDelete != (SessionId) UNUSED_SESSION_ENTRY_VALUE)
        {
          soTOE_ClsReq.write(nextToDelete);
          clsFsmState_Tcp = CLS_NEXT;
        } else {
          clsFsmState_Tcp = CLS_IDLE;
        }
      }
      break;
  }
}

Here is the caller graph for this function:

pTcpCOn()

void pTcpCOn	(	stream< TcpAppOpnReq > &	soTOE_OpnReq,
		stream< TcpAppOpnRep > &	siTOE_OpnRep,
		stream< NalNewTableEntry > &	sAddNewTriple_TcpCon,
		stream< NalTriple > &	sNewTcpCon_Req,
		stream< NalNewTcpConRep > &	sNewTcpCon_Rep
	)

Client connection to remote HOST or FPGA socket (COn).

Parameters

[out]	soTOE_OpnReq,open	connection request to TOE.
[in]	siTOE_OpnRep,open	connection reply from TOE.
[out]	sAddNewTriple_TcpCon,Notification	for the TCP Agency to add a new Triple/SessionId pair
[in]	sNewTcpCon_Req,Request	stream from pTcpWRp to open a new connection
[out]	sNewTcpCon_Rep,Reply	stream to pTcpWRp

Definition at line 1751 of file tss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
 
  char *myName  = concat3(THIS_NAME, "/", "Tcp_COn");
 
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static OpnFsmStates opnFsmState = OPN_IDLE;
  // Set a startup delay long enough to account for the initialization
  // of TOE's listen port table which takes 32,768 cycles after reset.
  //  [FIXME - StartupDelay must be replaced by a piSHELL_Reday signal]
#ifdef __SYNTHESIS_
  static ap_uint<16>         startupDelay = 0x8000;
#else
  static ap_uint<16>         startupDelay = 30;
#endif
 
#pragma HLS RESET variable=opnFsmState
#pragma HLS RESET variable=startupDelay
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static ap_uint<32>  watchDogTimer_pcon = 0;
  static TcpAppOpnReq     HostSockAddr;  // Socket Address stored in LITTLE-ENDIAN ORDER
  static NalTriple         triple_for_new_connection = 0x0;
 
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
  TcpAppOpnRep     newConn;
 
 
  switch (opnFsmState)
  {
 
    case OPN_IDLE:
      if (startupDelay > 0) 
      {
        startupDelay--;
        //Drain any potential status data
        //TODO?
        //if (!siTOE_OpnRep.empty()) 
        //{
        //  siTOE_OpnRep.read(newConn);
        //  //printInfo(myName, "Requesting to close sessionId=%d.\n", newConn.sessId.to_uint());
        //  //soTOE_ClsReq.write(newConn.sessId);
        //}
      } else {
        opnFsmState = OPN_REQ;
      }
      break;
 
    case OPN_REQ:
      if (!sNewTcpCon_Req.empty() && !soTOE_OpnReq.full())
      {
        triple_for_new_connection = sNewTcpCon_Req.read();
        Ip4Addr remoteIp = getRemoteIpAddrFromTriple(triple_for_new_connection);
        TcpPort remotePort = getRemotePortFromTriple(triple_for_new_connection);
 
        SockAddr    hostSockAddr(remoteIp, remotePort);
        HostSockAddr.addr = hostSockAddr.addr;
        HostSockAddr.port = hostSockAddr.port;
        soTOE_OpnReq.write(HostSockAddr);
        if (DEBUG_LEVEL & TRACE_CON) {
          printInfo(myName, "Client is requesting to connect to remote socket:\n");
          printSockAddr(myName, HostSockAddr);
        }
#ifndef __SYNTHESIS__
        watchDogTimer_pcon = 10;
#else
        watchDogTimer_pcon = NAL_CONNECTION_TIMEOUT;
#endif
        opnFsmState = OPN_REP;
      }
      break;
 
    case OPN_REP:
      if(!sAddNewTriple_TcpCon.full() && !sNewTcpCon_Rep.full())
      {
        watchDogTimer_pcon--;
        if (!siTOE_OpnRep.empty())
        {
          // Read the reply stream
          siTOE_OpnRep.read(newConn);
          if (newConn.tcpState == ESTABLISHED) {
            if (DEBUG_LEVEL & TRACE_CON) {
              printInfo(myName, "Client successfully connected to remote socket:\n");
              printSockAddr(myName, HostSockAddr);
            }
            NalNewTableEntry ne_struct =  NalNewTableEntry(triple_for_new_connection, newConn.sessId);
            sAddNewTriple_TcpCon.write(ne_struct);
            opnFsmState = OPN_DONE;
            NalNewTcpConRep con_rep = NalNewTcpConRep(triple_for_new_connection, newConn.sessId, false);
            sNewTcpCon_Rep.write(con_rep);
          }
          else {
            printError(myName, "Client failed to connect to remote socket:\n");
            printSockAddr(myName, HostSockAddr);
            opnFsmState = OPN_DONE;
            NalNewTcpConRep con_rep = NalNewTcpConRep(triple_for_new_connection, UNUSED_SESSION_ENTRY_VALUE, true);
            sNewTcpCon_Rep.write(con_rep);
          }
        }
        else {
          if (watchDogTimer_pcon == 0) {
            if (DEBUG_LEVEL & TRACE_CON) {
              printError(myName, "Timeout: Failed to connect to the following remote socket:\n");
              printSockAddr(myName, HostSockAddr);
            }
            //the packet will be dropped, so we are done
            opnFsmState = OPN_DONE;
            NalNewTcpConRep con_rep = NalNewTcpConRep(triple_for_new_connection, UNUSED_SESSION_ENTRY_VALUE, true);
            sNewTcpCon_Rep.write(con_rep);
          }
 
        }
      }
      break;
    case OPN_DONE:
      //No need to wait...
      opnFsmState = OPN_REQ;
      break;
  } //switch
}

Here is the call graph for this function:

Here is the caller graph for this function:

pTcpLsn()

void pTcpLsn	(	stream< TcpAppLsnReq > &	soTOE_LsnReq,
		stream< TcpAppLsnRep > &	siTOE_LsnRep,
		stream< TcpPort > &	sTcpPortsToOpen,
		stream< bool > &	sTcpPortsOpenFeedback
	)

Request the TOE to start listening (LSn) for incoming connections on a specific port (.i.e open connection for reception mode).

Parameters

[out]	soTOE_LsnReq,listen	port request to TOE.
[in]	siTOE_LsnRep,listen	port acknowledge from TOE.
[in]	sTcpPortsToOpen,port	open request from pPortLogic
[out]	sTcpPortsOpenFeedback,feedback	to pPortLogic

Warning

The Port Table (PRt) supports two port ranges; one for static ports (0 to 32,767) which are used for listening ports, and one for dynamically assigned or ephemeral ports (32,768 to 65,535) which are used for active connections. Therefore, listening port numbers must be in the range 0 to 32,767.

Definition at line 53 of file tss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
  char* myName  = concat3(THIS_NAME, "/", "Tcp_LSn");
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static LsnFsmStates lsnFsmState = LSN_IDLE;
#ifdef __SYNTHESIS_
  static ap_uint<16>         startupDelay = 0x8000;
#else
  static ap_uint<16>         startupDelay = 5;
#endif
 
#pragma HLS RESET variable=lsnFsmState
#pragma HLS RESET variable=startupDelay
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static ap_uint<8>   watchDogTimer_plisten = 0;
  ap_uint<16> new_absolute_port = 0;
 
 
  switch (lsnFsmState) {
 
    default:
    case LSN_IDLE:
      if (startupDelay > 0)
      {
        startupDelay--;
      } else {
        lsnFsmState = LSN_SEND_REQ;
      }
      break;
 
    case LSN_SEND_REQ: //we arrive here only if need_tcp_port_req == true
      if (!soTOE_LsnReq.full() && !sTcpPortsToOpen.empty()) 
      {
        new_absolute_port = sTcpPortsToOpen.read();
        TcpAppLsnReq    tcpListenPort = new_absolute_port;
        soTOE_LsnReq.write(tcpListenPort);
        if (DEBUG_LEVEL & TRACE_LSN) {
          printInfo(myName, "Server is requested to listen on port #%d (0x%4.4X).\n",
              (int) new_absolute_port, (int) new_absolute_port);
#ifndef __SYNTHESIS__
          watchDogTimer_plisten = 10;
#else
          watchDogTimer_plisten = 100;
#endif
          lsnFsmState = LSN_WAIT_ACK;
        }
      }
      //else {
      //  printWarn(myName, "Cannot send a listen port request to [TOE] because stream is full!\n");
      //}
      break;
 
    case LSN_WAIT_ACK:
      if (!siTOE_LsnRep.empty() && !sTcpPortsOpenFeedback.full())
      {
        bool    listenDone;
        siTOE_LsnRep.read(listenDone);
        if (listenDone) {
          printInfo(myName, "Received listen acknowledgment from [TOE].\n");
          lsnFsmState = LSN_SEND_REQ;
          sTcpPortsOpenFeedback.write(true);
        }
        else {
          printWarn(myName, "TOE denied listening on port %d (0x%4.4X).\n",
              (int) new_absolute_port, (int) new_absolute_port);
          sTcpPortsOpenFeedback.write(false);
          lsnFsmState = LSN_SEND_REQ;
        }
      } else if (watchDogTimer_plisten == 0 && !sTcpPortsOpenFeedback.full() )
      {
        ap_uint<16> new_absolute_port = 0;
        printError(myName, "Timeout: Server failed to listen on port %d %d (0x%4.4X).\n",
            (int)  new_absolute_port, (int) new_absolute_port);
        sTcpPortsOpenFeedback.write(false);
        lsnFsmState = LSN_SEND_REQ;
      } else {
        watchDogTimer_plisten--;
      }
      break;
 
  } //switch
}

Here is the caller graph for this function:

pTcpRDp()

void pTcpRDp	(	ap_uint< 1 > *	layer_4_enabled,
		ap_uint< 1 > *	piNTS_ready,
		stream< TcpAppRdReq > &	sRDp_ReqNotif,
		stream< TcpAppData > &	siTOE_Data,
		stream< TcpAppMeta > &	siTOE_SessId,
		stream< NetworkWord > &	soFMC_data,
		stream< TcpSessId > &	soFMC_SessId,
		stream< NetworkWord > &	soTcp_data,
		stream< NetworkMetaStream > &	soTcp_meta,
		stream< NalConfigUpdate > &	sConfigUpdate,
		stream< Ip4Addr > &	sGetNidReq_TcpRx,
		stream< NodeId > &	sGetNidRep_TcpRx,
		stream< SessionId > &	sGetTripleFromSid_Req,
		stream< NalTriple > &	sGetTripleFromSid_Rep,
		ap_uint< 32 > *	piMMIO_CfrmIp4Addr,
		ap_uint< 16 > *	piMMIO_FmcLsnPort,
		ap_uint< 1 > *	layer_7_enabled,
		ap_uint< 1 > *	role_decoupled,
		stream< bool > &	cache_inval_sig,
		stream< NalEventNotif > &	internal_event_fifo
	)

Read Path (RDp) - From TOE to ROLE or FMC. Process waits for a new data segment to read and forwards it to ROLE or FMC. Invalid packets are dropped.

Parameters

[in]	layer_4_enabled,external	signal if layer 4 is enabled
[in]	piNTS_ready,external	signal if NTS is up and running
[in]	sRDp_ReqNotif,Notifies	pTcpRDp about a n incoming TCP chunk
[in]	siTOE_Data,Data	from [TOE].
[in]	siTOE_SessId,Session	Id from [TOE].
[out]	soFmc_data,Data	for FMC
[out]	soFmc_meta,Metadata	for FMC
[out]	soTcp_data,Data	to [ROLE].
[out]	soTcp_meta,Meta	Data to [ROLE].
[in]	sConfigUpdate,notification	of configuration changes
[out]	sGetNidReq_TcpRx,Request	stream for the the MRT Agency
[in]	sGetNidRep_TcpRx,Reply	stream from the MRT Agency
[out]	&sGetTripleFromSid_Req,Request	stream for the the TCP Agency
[in]	&sGetTripleFromSid_Rep,Reply	stream from the TCO Agency
[in]	piMMIO_CfrmIp4Addr,the	IP address of the CFRM (from MMIO)
[in]	piMMIO_FmcLsnPort,the	management listening port (from MMIO)
[in]	layer_7_enabled,external	signal if layer 7 is enabled
[in]	role_decoupled,external	signal if the role is decoupled
[in]	cache_inval_sig,Signal	from the Cache Invalidation Logic
[out]	internal_event_fifo,Fifo	for event reporting

Definition at line 581 of file tss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
 
  char* myName  = concat3(THIS_NAME, "/", "Tcp_RDp");
 
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static RdpFsmStates rdpFsmState = RDP_RESET;
  static ap_uint<64> cached_tcp_rx_triple = UNUSED_TABLE_ENTRY_VALUE;
  //static bool Tcp_RX_metaWritten = false;
  static SessionId cached_tcp_rx_session_id = UNUSED_SESSION_ENTRY_VALUE;
  static NodeId own_rank = 0;
  static NodeId cached_src_id = INVALID_MRT_VALUE;
  static bool cache_init = false;
  static uint8_t evs_loop_i = 0;
 
 
#pragma HLS RESET variable=rdpFsmState
#pragma HLS RESET variable=cached_tcp_rx_triple
  //#pragma HLS RESET variable=Tcp_RX_metaWritten
#pragma HLS RESET variable=cached_tcp_rx_session_id
#pragma HLS RESET variable=cached_src_id
#pragma HLS RESET variable=cache_init
#pragma HLS RESET variable=own_rank
#pragma HLS RESET variable=evs_loop_i
 
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static SessionId session_toFMC = 0;
  static NetworkMetaStream in_meta_tcp = NetworkMetaStream();
  static bool first_word_written = false;
  static TcpAppData first_word = TcpAppData();
  static NodeId src_id = INVALID_MRT_VALUE;
  static ap_uint<64> triple_in = UNUSED_TABLE_ENTRY_VALUE;
  static Ip4Addr remoteAddr = Ip4Addr();
  static TcpPort dstPort = 0x0;
  static TcpPort srcPort = 0x0;
  static bool found_in_cache = false;
  static  AppMeta     sessId = 0x0;
  static NetworkDataLength current_length = 0;
  static ap_uint<32> fmc_tcp_bytes_cnt = 0;
 
  static stream<NalEventNotif> evsStreams[7];
 
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
  TcpAppData currWord;
  NalEventNotif new_ev_not;
  NetworkMeta tmp_meta;
 
 
  switch (rdpFsmState)
  {
 
    default:
    case RDP_RESET:
      if(*layer_4_enabled == 1 && *piNTS_ready == 1)
      {
        cache_init = false;
        fmc_tcp_bytes_cnt = 0;
        current_length = 0;
        rdpFsmState = RDP_WAIT_META;
      } else {
        if(!sRDp_ReqNotif.empty() )
        {
          sRDp_ReqNotif.read();
        }
        if(!siTOE_SessId.empty())
        {
          siTOE_SessId.read();
        }
        if(!siTOE_Data.empty())
        {
          siTOE_Data.read();
        }
      }
      break;
    case RDP_WAIT_META:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        rdpFsmState = RDP_RESET;
      }
      else if(!cache_inval_sig.empty())
      {
        if(cache_inval_sig.read())
        {
          cached_tcp_rx_session_id = UNUSED_SESSION_ENTRY_VALUE;
          cached_tcp_rx_triple = UNUSED_TABLE_ENTRY_VALUE;
          cached_src_id = INVALID_MRT_VALUE;
          cache_init = false;
        }
        break;
      } else if(!sConfigUpdate.empty())
      {
        NalConfigUpdate ca = sConfigUpdate.read();
        if(ca.config_addr == NAL_CONFIG_OWN_RANK)
        {
          own_rank = (NodeId) ca.update_value;
          cache_init = false;
        }
        break;
      }
      else if (!sRDp_ReqNotif.empty()
          && !sGetTripleFromSid_Req.full()
          )
      {
        TcpAppRdReq new_req = sRDp_ReqNotif.read();
        sessId = new_req.sessionID;
        current_length = new_req.length;
 
        triple_in = UNUSED_TABLE_ENTRY_VALUE;
        found_in_cache = false;
        if(cache_init && sessId == cached_tcp_rx_session_id)
        {
          printf("used TCP RX tripple and NID cache.\n");
          triple_in = cached_tcp_rx_triple;
          src_id = cached_src_id;
          found_in_cache = true;
          rdpFsmState = RDP_FILTER_META;
        } else {
          sGetTripleFromSid_Req.write(sessId);
          rdpFsmState = RDP_W8FORREQS_1;
          cache_init = false;
          printf("[Tcp-RDP:INFO] Need to request session and node id.\n");
        }
      }
      break;
 
    case RDP_W8FORREQS_1:
      if(!sGetTripleFromSid_Rep.empty() && !sGetNidReq_TcpRx.full())
      {
        triple_in = sGetTripleFromSid_Rep.read();
        remoteAddr = getRemoteIpAddrFromTriple(triple_in);
        dstPort = getLocalPortFromTriple(triple_in);
        if(dstPort != *piMMIO_FmcLsnPort)
        {
          sGetNidReq_TcpRx.write(remoteAddr);
          printf("[TCP-RX:INFO] need to ask for Node ID.\n");
          rdpFsmState = RDP_W8FORREQS_2;
        } else {
          printf("[TCP-RX:INFO] found possible FMC connection, write to cache.\n");
          cache_init = true;
          cached_src_id = INVALID_MRT_VALUE;
          cached_tcp_rx_session_id = sessId;
          cached_tcp_rx_triple = triple_in;
          rdpFsmState = RDP_FILTER_META;
        }
      }
      break;
 
    case RDP_W8FORREQS_2:
      if(!sGetNidRep_TcpRx.empty())
      {
 
        src_id = sGetNidRep_TcpRx.read();
        cache_init = true;
        cached_src_id = src_id;
        cached_tcp_rx_session_id = sessId;
        cached_tcp_rx_triple = triple_in;
        rdpFsmState = RDP_FILTER_META;
      }
      break;
 
    case RDP_FILTER_META:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        rdpFsmState = RDP_RESET;
      }
      else if(!siTOE_SessId.empty()
              && !soTcp_meta.full() && !soFMC_SessId.full()
          )
      {
        TcpAppMeta controll_id = siTOE_SessId.read();
        if(controll_id != sessId)
        {//actually, should not happen
          printf("[TCP-RDp:PANIC] We received data that we didn't expect...\n");
          //SINK packet
          //new_ev_not = NalEventNotif(NID_MISS_RX, 1);
          //evsStreams[9].write_nb(new_ev_not);
          rdpFsmState = RDP_DROP_PACKET;
          printf("NRC drops the packet...\n");
          cache_init = false;
          break;
        }
 
        printf("tripple_in: %llu\n",(unsigned long long) triple_in);
        //since we requested the session, we should know it -> no error handling
        dstPort = getLocalPortFromTriple(triple_in);
        srcPort = getRemotePortFromTriple(triple_in);
        remoteAddr = getRemoteIpAddrFromTriple(triple_in);
        printf("remote Addr: %d; dstPort: %d; srcPort %d\n", (int) remoteAddr, (int) dstPort, (int) srcPort);
 
        if(dstPort == *piMMIO_FmcLsnPort)
        {
          if(remoteAddr == *piMMIO_CfrmIp4Addr)
          {//valid connection to FMC
            printf("found valid FMC connection.\n");
            session_toFMC = sessId;
            soFMC_SessId.write(session_toFMC);
            fmc_tcp_bytes_cnt = 0;
            rdpFsmState = RDP_STREAM_FMC;
            new_ev_not = NalEventNotif(AUTH_ACCESS, 1);
            evsStreams[0].write_nb(new_ev_not);
            //done by RRh
            //if(!found_in_cache)
            //{
            //  //markSessionAsPrivileged(sessId);
            //  sMarkAsPriv.write(sessId);
            //}
            break;
          } else {
            new_ev_not = NalEventNotif(UNAUTH_ACCESS, 1);
            evsStreams[1].write_nb(new_ev_not);
            printf("unauthorized access to FMC!\n");
            rdpFsmState = RDP_DROP_PACKET;
            printf("NRC drops the packet...\n");
            cache_init = false;
            break;
          }
        }
 
        printf("TO ROLE: src_rank: %d\n", (int) src_id);
        //Role packet
        if(src_id == INVALID_MRT_VALUE
            || *layer_7_enabled == 0 || *role_decoupled == 1)
        {
          //SINK packet
          new_ev_not = NalEventNotif(NID_MISS_RX, 1);
          evsStreams[2].write_nb(new_ev_not);
          rdpFsmState = RDP_DROP_PACKET;
          printf("NRC drops the packet...\n");
          cache_init = false;
          break;
        }
        new_ev_not = NalEventNotif(LAST_RX_NID, src_id);
        evsStreams[3].write_nb(new_ev_not);
        new_ev_not = NalEventNotif(LAST_RX_PORT, dstPort);
        evsStreams[4].write_nb(new_ev_not);
        tmp_meta = NetworkMeta(own_rank, dstPort, src_id, srcPort, current_length);
        in_meta_tcp = NetworkMetaStream(tmp_meta);
 
        //write meta
        soTcp_meta.write(in_meta_tcp);
        new_ev_not = NalEventNotif(PACKET_RX, 1);
        evsStreams[5].write_nb(new_ev_not);
        rdpFsmState  = RDP_STREAM_ROLE;
      }
      break;
    case RDP_STREAM_ROLE:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        rdpFsmState = RDP_RESET;
      }
      else if (!siTOE_Data.empty() && !soTcp_data.full())
      {
        siTOE_Data.read(currWord);
        NetworkWord tcpWord = NetworkWord(currWord.getLE_TData(), currWord.getLE_TKeep(), currWord.getLE_TLast());
        soTcp_data.write(tcpWord);
        if (currWord.getTLast() == 1)
        {
          rdpFsmState  = RDP_WAIT_META;
        }
      }
      break;
 
    case RDP_STREAM_FMC:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        rdpFsmState = RDP_RESET;
      }
      else if (!siTOE_Data.empty()
          && !soFMC_data.full()
          )
      {
        siTOE_Data.read(currWord);
        NetworkWord tcpWord = NetworkWord(currWord.getLE_TData(), currWord.getLE_TKeep(), currWord.getLE_TLast());
        soFMC_data.write(tcpWord);
        fmc_tcp_bytes_cnt += extractByteCnt(currWord);
        if (currWord.getTLast() == 1)
        {
          new_ev_not = NalEventNotif(FMC_TCP_BYTES, fmc_tcp_bytes_cnt);
          evsStreams[6].write_nb(new_ev_not);
          rdpFsmState  = RDP_WAIT_META;
        }
      }
      break;
 
    case RDP_DROP_PACKET:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        rdpFsmState = RDP_RESET;
      }
      else if( !siTOE_Data.empty() )
      {
        siTOE_Data.read(currWord);
        if (currWord.getTLast() == 1)
        {
          rdpFsmState  = RDP_WAIT_META;
          cache_init = false;
        }
      }
      break;
  } // switch case
 
  //-- ALWAYS -----------------------
  if(!internal_event_fifo.full())
  {
    if(!evsStreams[evs_loop_i].empty())
    {
      internal_event_fifo.write(evsStreams[evs_loop_i].read());
    }
    evs_loop_i++;
    if(evs_loop_i >= 7)
    {
      evs_loop_i = 0;
    }
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

pTcpRRh()

void pTcpRRh	(	ap_uint< 1 > *	layer_4_enabled,
		ap_uint< 1 > *	piNTS_ready,
		ap_uint< 32 > *	piMMIO_CfrmIp4Addr,
		ap_uint< 16 > *	piMMIO_FmcLsnPort,
		stream< TcpAppNotif > &	siTOE_Notif,
		stream< TcpAppRdReq > &	soTOE_DReq,
		stream< NalNewTableEntry > &	sAddNewTriple_TcpRrh,
		stream< SessionId > &	sMarkAsPriv,
		stream< SessionId > &	sDeleteEntryBySid,
		stream< TcpAppRdReq > &	sRDp_ReqNotif,
		stream< PacketLen > &	fmc_write_cnt_sig,
		stream< PacketLen > &	role_write_cnt_sig
	)

ReadRequestHandler (RRh). Waits for a notification indicating the availability of new data for the ROLE or FMC.

Parameters

[in]	layer_4_enabled,external	signal if layer 4 is enabled
[in]	piNTS_ready,external	signal if NTS is up and running
[in]	piMMIO_CfrmIp4Addr,the	IP address of the CFRM (from MMIO)
[in]	piMMIO_FmcLsnPort,the	management listening port (from MMIO)
[in]	siTOE_Notif,a	new Rx data notification from TOE.
[out]	soTOE_DReq,a	Rx data request to TOE.
[out]	sAddNewTriple_TcpRrh,Notification	for the TCP Agency to add a new Triple/SessionId pair
[out]	sMarkAsPriv,Notification	for the TCP Agency to mark a connection as privileged
[out]	sDeleteEntryBySid,Notifies	the TCP Agency of the closing of a connection
[out]	sRDp_ReqNotif,Notifies	pTcpRDp about a n incoming TCP chunk
[in]	fmc_write_cnt_sig,Signal	from pFmcTcpRxDeq about how many bytes are written
[in]	role_write_cnt_sig,Signal	from pRoleTcpRxDeq about how many bytes are written

Definition at line 219 of file tss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
  char* myName  = concat3(THIS_NAME, "/", "Tcp_RRh");
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static RrhFsmStates rrhFsmState = RRH_RESET;
 
#pragma HLS RESET variable=rrhFsmState
 
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static Cam8<SessionId,TcpDatLen> sessionLength = Cam8<SessionId,TcpDatLen>();
#ifndef __SYNTHESIS__
  if(MAX_NAL_SESSIONS != 8)
  {
    printf("\n\t\tERROR: pTcpRRh is currently configured to support only 8 parallel sessions! Abort.\n(Currently, the use of \'Cam8\' must be updated accordingly by hand.)\n");
    exit(-1);
  }
#endif
 
  static stream<NalWaitingData> waitingSessions ("sTcpRRh_WaitingSessions");
  static stream<NalWaitingData> session_reinsert ("sTcpRRh_sessions_to_reinsert");
#pragma HLS STREAM variable=waitingSessions  depth=8
#pragma HLS STREAM variable=session_reinsert  depth=8
 
  static TcpDatLen waiting_length = 0;
  static TcpAppNotif notif_pRrh = TcpAppNotif();
  static bool already_waiting = false;
  static TcpDatLen requested_length = 0;
  static TcpDatLen length_update_value = 0;
  static SessionId found_ID = 0;
  static bool found_fmc_sess = false;
  static bool need_cam_update = false;
  static bool go_back_to_ack_wait_role = false;
  static bool go_back_to_ack_wait_fmc = false;
 
  static PacketLen role_fifo_free_cnt = NAL_MAX_FIFO_DEPTHS_BYTES;
  static PacketLen fmc_fifo_free_cnt = NAL_MAX_FIFO_DEPTHS_BYTES;
 
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
 
  switch(rrhFsmState)
  {
    default:
    case RRH_RESET:
      sessionLength.reset();
      go_back_to_ack_wait_fmc = false;
      go_back_to_ack_wait_role = false;
      role_fifo_free_cnt = NAL_MAX_FIFO_DEPTHS_BYTES;
      fmc_fifo_free_cnt = NAL_MAX_FIFO_DEPTHS_BYTES;
      rrhFsmState = RRH_WAIT_NOTIF;
      break;
    case RRH_WAIT_NOTIF:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        rrhFsmState = RRH_DRAIN;
      }
      else if(!siTOE_Notif.empty()  && !sDeleteEntryBySid.full()
          )
      {
        siTOE_Notif.read(notif_pRrh);
        if (notif_pRrh.tcpDatLen != 0)
        {
          //waiting_length = 0;
          already_waiting = sessionLength.lookup(notif_pRrh.sessionID, waiting_length);
          rrhFsmState = RRH_PROCESS_NOTIF;
 
        } else if(notif_pRrh.tcpState == FIN_WAIT_1 || notif_pRrh.tcpState == FIN_WAIT_2
            || notif_pRrh.tcpState == CLOSING || notif_pRrh.tcpState == TIME_WAIT
            || notif_pRrh.tcpState == LAST_ACK || notif_pRrh.tcpState == CLOSED)
        {
          // we were notified about a closing connection
          sDeleteEntryBySid.write(notif_pRrh.sessionID);
          if(go_back_to_ack_wait_fmc)
          {
            rrhFsmState = RRH_WAIT_FMC;
          }
          else if(go_back_to_ack_wait_role)
          {
            rrhFsmState = RRH_WAIT_ROLE;
          }
          //else, stay here...
        }
      }
      else if(!session_reinsert.empty() && !waitingSessions.full()
          && !go_back_to_ack_wait_fmc && !go_back_to_ack_wait_role
          )
      {
        waitingSessions.write(session_reinsert.read());
        rrhFsmState = RRH_START_REQUEST;
      }
      else if(!waitingSessions.empty()
          && !go_back_to_ack_wait_fmc && !go_back_to_ack_wait_role
          )
      {
        rrhFsmState = RRH_START_REQUEST;
      }
      break;
    case RRH_PROCESS_NOTIF:
      if(!waitingSessions.full() && !sAddNewTriple_TcpRrh.full()
          && !sMarkAsPriv.full()
        )
      {
        if(already_waiting)
        {
          sessionLength.update(notif_pRrh.sessionID, notif_pRrh.tcpDatLen + waiting_length);
          printf("[TCP-RRH] adding %d to waiting sessions for session %d.\n",(int) notif_pRrh.tcpDatLen, (int) notif_pRrh.sessionID);
 
        } else {
          sessionLength.insert(notif_pRrh.sessionID, notif_pRrh.tcpDatLen);
          //bool found_slot = sessionLength.insert(notif_pRrh.sessionID, notif_pRrh.tcpDatLen);
          //if(!found_slot)
          //{
          //  //we have a problem...
          //  //but shouldn't happen actually since we have the same size as the table in TOE...
          //  printf("[TCP-RRH:PANIC] We don't have space left in the waiting table...\n");
          //  break;
          //} else {
          NalNewTableEntry ne_struct = NalNewTableEntry(newTriple(notif_pRrh.ip4SrcAddr, notif_pRrh.tcpSrcPort, notif_pRrh.tcpDstPort),
              notif_pRrh.sessionID);
          sAddNewTriple_TcpRrh.write(ne_struct);
          bool is_fmc = false;
          if(notif_pRrh.ip4SrcAddr == *piMMIO_CfrmIp4Addr && notif_pRrh.tcpDstPort == *piMMIO_FmcLsnPort)
          {
            is_fmc = true;
            sMarkAsPriv.write(notif_pRrh.sessionID);
          }
          NalWaitingData new_sess = NalWaitingData(notif_pRrh.sessionID, is_fmc);
          waitingSessions.write(new_sess);
          printf("[TCP-RRH] adding %d with %d bytes as new waiting session.\n", (int) notif_pRrh.sessionID, (int) notif_pRrh.tcpDatLen);
          //}
        }
        if(go_back_to_ack_wait_fmc)
        {
          rrhFsmState = RRH_WAIT_FMC;
        }
        else if(go_back_to_ack_wait_role)
        {
          rrhFsmState = RRH_WAIT_ROLE;
        } else {
          rrhFsmState = RRH_START_REQUEST;
        }
      }
      break;
    case RRH_START_REQUEST:
      if(!waitingSessions.empty() && !session_reinsert.full()
          //&& role_fifo_free_cnt > 0
          //&& fmc_fifo_free_cnt > 0
          //if we are here, we ensured there is space
        )
      {
        NalWaitingData new_data = waitingSessions.read();
        found_ID = new_data.sessId;
        TcpDatLen found_length = 0;
        found_fmc_sess = new_data.fmc_con;
 
        sessionLength.lookup(found_ID, found_length);
        //bool found_smth = sessionLength.lookup(found_ID, found_length);
        //if(!found_smth)
        //{
        //  //we have a problem...
        //  //but shouldn't happen actually since the stream is filled by ourselve
        //  printf("[TCP-RRH:PANIC] We received a sessionID that is not in the CAM...\n");
        //} else {
        //requested_length = 0;
        if(found_fmc_sess)
        {
          if(found_length >= fmc_fifo_free_cnt)
          {
            need_cam_update = true;
            requested_length = fmc_fifo_free_cnt;
            length_update_value = found_length - fmc_fifo_free_cnt;
          } else {
            need_cam_update = false;
            requested_length = found_length;
          }
        } else {
          if(found_length >= role_fifo_free_cnt)
          {
            need_cam_update = true;
            requested_length = role_fifo_free_cnt;
            length_update_value = found_length - role_fifo_free_cnt;
          } else {
            need_cam_update = false;
            requested_length = found_length;
          }
        }
        rrhFsmState = RRH_PROCESS_REQUEST;
        //}
      }
      //else if(both_fifo_free_cnt == 0)
      //{
      //  rrhFsmState = RRH_WAIT_WRITE_ACK;
      //}
      break;
    case RRH_PROCESS_REQUEST:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        rrhFsmState = RRH_DRAIN;
      }
      else if(!soTOE_DReq.full() && !sRDp_ReqNotif.full()
          && !session_reinsert.full()
          )
      {
        if(need_cam_update)
        {
          sessionLength.update(found_ID, length_update_value);
          session_reinsert.write(NalWaitingData(found_ID, found_fmc_sess));
          if(found_fmc_sess)
          {
            fmc_fifo_free_cnt = 0;
          } else {
            role_fifo_free_cnt = 0;
          }
        } else {
          sessionLength.deleteEntry(found_ID);
          if(found_fmc_sess)
          {
            fmc_fifo_free_cnt -= requested_length;
          } else {
            role_fifo_free_cnt -= requested_length;
          }
        }
        printf("[TCP-RRH] requesting data for #%d with length %d (FMC: %d)\n", (int) found_ID, (int) requested_length, (int) found_fmc_sess);
        TcpAppRdReq new_req = TcpAppRdReq(found_ID, requested_length);
        soTOE_DReq.write(new_req);
        sRDp_ReqNotif.write(new_req);
        go_back_to_ack_wait_fmc  = false;
        go_back_to_ack_wait_role = false;
        if(found_fmc_sess)
        {
          rrhFsmState = RRH_WAIT_FMC;
        } else {
          rrhFsmState = RRH_WAIT_ROLE;
        }
      }
      break;
    case RRH_WAIT_FMC:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        rrhFsmState = RRH_DRAIN;
      }
      else if(!fmc_write_cnt_sig.empty())
      {
        PacketLen fmc_new_free = fmc_write_cnt_sig.read();
        fmc_fifo_free_cnt += fmc_new_free;
        if(fmc_fifo_free_cnt > NAL_MAX_FIFO_DEPTHS_BYTES)
        {
          //to be sure
          fmc_fifo_free_cnt = NAL_MAX_FIFO_DEPTHS_BYTES;
        }
        printf("[TCP-RRH] FMC FIFO completed write of %d bytes; In total %d bytes are free in FMC FIFO.\n", (int) fmc_new_free, (int) fmc_fifo_free_cnt);
        go_back_to_ack_wait_fmc = false;
        rrhFsmState = RRH_WAIT_NOTIF;
      }
      else if(!siTOE_Notif.empty())
      {
        rrhFsmState = RRH_WAIT_NOTIF;
        go_back_to_ack_wait_fmc = true;
      }
      break;
    case RRH_WAIT_ROLE:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        rrhFsmState = RRH_DRAIN;
      }
      else if(!role_write_cnt_sig.empty())
      {
        PacketLen role_new_free = role_write_cnt_sig.read();
        role_fifo_free_cnt += role_new_free;
        if(role_fifo_free_cnt > NAL_MAX_FIFO_DEPTHS_BYTES)
        {
          //to be sure
          role_fifo_free_cnt = NAL_MAX_FIFO_DEPTHS_BYTES;
        }
        printf("[TCP-RRH] ROLE FIFO completed write of %d bytes; In total %d bytes are free in ROLE FIFO.\n", (int) role_new_free, (int) role_fifo_free_cnt);
        go_back_to_ack_wait_role = false;
        rrhFsmState = RRH_WAIT_NOTIF;
      }
      else if(!siTOE_Notif.empty())
      {
        rrhFsmState = RRH_WAIT_NOTIF;
        go_back_to_ack_wait_role = true;
      }
      break;
    case RRH_DRAIN:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        if(!siTOE_Notif.empty())
        {
          siTOE_Notif.read();
        }
        if(!waitingSessions.empty())
        {
          waitingSessions.read();
        }
        if(!session_reinsert.empty())
        {
          session_reinsert.read();
        }
        if(!fmc_write_cnt_sig.empty())
        {
          fmc_write_cnt_sig.read();
        }
        if(!role_write_cnt_sig.empty())
        {
          role_write_cnt_sig.read();
        }
      } else {
        rrhFsmState = RRH_RESET;
      }
      break;
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

pTcpRxNotifEnq()

void pTcpRxNotifEnq	(	ap_uint< 1 > *	layer_4_enabled,
		ap_uint< 1 > *	piNTS_ready,
		stream< TcpAppNotif > &	siTOE_Notif,
		stream< TcpAppNotif > &	sTcpNotif_buffer
	)

Enqueus the incoming notificiations from TOE into the internal buffer.

Definition at line 152 of file tss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static RrhEnqFsmStates rrhEngFsm = RRH_ENQ_RESET;
#pragma HLS RESET variable=rrhEngFsm
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
 
  //This FSM is more or less senseless, but without Vivado HLS removes the 'sTcpNotif_buffer'
 
  switch(rrhEngFsm)
  {
    default:
    case RRH_ENQ_RESET:
      if(*layer_4_enabled == 1 && *piNTS_ready == 1)
      {
        rrhEngFsm = RRH_ENQ_STREAM;
      }
      else if(!siTOE_Notif.empty())
      {
        siTOE_Notif.read();
      }
      break;
    case RRH_ENQ_STREAM:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        rrhEngFsm = RRH_ENQ_RESET;
      }
      else if(!siTOE_Notif.empty() && !sTcpNotif_buffer.full())
      {
        TcpAppNotif new_notif = siTOE_Notif.read();
        sTcpNotif_buffer.write(new_notif);
      }
      break;
  }
 
}

Here is the caller graph for this function:

pTcpWBu()

void pTcpWBu	(	ap_uint< 1 > *	layer_4_enabled,
		ap_uint< 1 > *	piNTS_ready,
		stream< TcpAppData > &	siWrp_Data,
		stream< TcpAppMeta > &	siWrp_SessId,
		stream< TcpDatLen > &	siWrp_len,
		stream< TcpAppData > &	soTOE_Data,
		stream< TcpAppSndReq > &	soTOE_SndReq,
		stream< TcpAppSndRep > &	siTOE_SndRep
	)

Write Buffer (WBu) - From WRp to TOE. Process to synchronize with TOE's TX buffer (and it's available space). In case of streaming mode (i.e. ROLE's length was 0), WRp takes care of splitting the data and writing the right len.

Parameters

[in]	layer_4_enabled,external	signal if layer 4 is enabled
[in]	piNTS_ready,external	signal if NTS is up and running
[in]	siWrp_Data,Tx	data from [Wrp].
[in]	siWrp_SessId,the	session Id from [Wrp].
[in]	siWrp_len,the	length of the current chunk (is never 0) from [Wrp].
[out]	soTOE_Data,Data	for the TOE
[out]	soTOE_SndReq,Send	request (containing the planned length) for the TOE
[in]	siTOE_SndRep,Send	reply from the TOE (containing the allowed length)

Definition at line 1552 of file tss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
  char *myName  = concat3(THIS_NAME, "/", "Tcp_WBu");
 
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static WbuFsmStates wbuState = WBU_WAIT_META;
  static uint16_t dequeue_cnt = 0; //in BYTES!!
  //static TcpDatLen original_requested_length = 0;
 
#pragma HLS RESET variable=wbuState
#pragma HLS RESET variable=dequeue_cnt
  //#pragma HLS RESET variable=original_requested_length
 
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static TcpAppMeta current_sessId;
  static TcpDatLen current_requested_length = 0;
  static TcpDatLen current_approved_length = 0;
  static bool need_to_request_again = false;
 
 
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
  TcpAppSndReq toe_sendReq;
 
 
  switch(wbuState) {
    default:
    case WBU_WAIT_META:
      //wait for meta
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        wbuState = WBU_DRAIN;
      }
      else if(!siWrp_SessId.empty() && !siWrp_len.empty())
      {
        TcpDatLen new_len = siWrp_len.read();
        current_sessId = siWrp_SessId.read();
        //original_requested_length = new_len;
 
        current_requested_length = new_len;
        dequeue_cnt = 0;
        wbuState = WBU_SND_REQ;
      }
      break;
    case WBU_SND_REQ:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        wbuState = WBU_DRAIN;
      }
      else if(!soTOE_SndReq.full())
      {
        toe_sendReq.sessId = current_sessId;
        toe_sendReq.length = current_requested_length;
        soTOE_SndReq.write(toe_sendReq);
        if (DEBUG_LEVEL & TRACE_WRP) 
        {
          printInfo(myName, "Received a data forward request from [NAL/WRP] for sessId=%d and nrBytes=%d (repeating request %d).\n",
              toe_sendReq.sessId.to_uint(), toe_sendReq.length.to_uint(), (int) need_to_request_again);
        }
        wbuState = WBU_WAIT_REP;
      }
      break;
    case WBU_WAIT_REP:
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        wbuState = WBU_DRAIN;
      }
      else if(!siTOE_SndRep.empty())
      {
        //-- Read the request-to-send reply and continue accordingly
        TcpAppSndRep appSndRep = siTOE_SndRep.read();
        switch (appSndRep.error) {
          case NO_ERROR:
            wbuState = WBU_STREAM;
            current_approved_length = current_requested_length; //not spaceLeft(!), because this could be bigger!
            need_to_request_again = false;
            dequeue_cnt = 0;
            break;
          case NO_SPACE:
            printWarn(myName, "Not enough space for writing %d bytes in the Tx buffer of session #%d. Available space is %d bytes.\n",
                appSndRep.length.to_uint(), appSndRep.sessId.to_uint(), appSndRep.spaceLeft.to_uint());
 
            dequeue_cnt = 0;
            current_approved_length = appSndRep.spaceLeft - 7; //with "security margin" (so that the length is correct if tkeep is not 0xff for the last word)
            need_to_request_again = true;
 
            wbuState = WBU_STREAM;
            break;
          case NO_CONNECTION:
            printWarn(myName, "Attempt to write data for a session that is not established.\n");
            //since this is after the WRP, this should never happen
            wbuState = WBU_DROP;
            dequeue_cnt = current_requested_length;
            //TODO: write internal event?
            //TODO: or ignore it, because WRP ensures this should not happen?
            break;
          default:
            printWarn(myName, "Received unknown TCP request to send reply from [TOE].\n");
            wbuState = WBU_DROP;
            dequeue_cnt = current_requested_length;
            //TODO: write internal event?
            //TODO: or ignore it, because WRP ensures this should not happen?
            break;
        }
      }
      break;
    case WBU_STREAM:
      //dequeue data
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        wbuState = WBU_DRAIN;
      }
      else if(!soTOE_Data.full() && !siWrp_Data.empty() )
      {
        TcpAppData tmp = siWrp_Data.read();
        dequeue_cnt += extractByteCnt(tmp);
        if(dequeue_cnt >= current_approved_length)
        {
          tmp.setTLast(1); //to be sure
          if(need_to_request_again)
          {
            current_requested_length -= dequeue_cnt;
            wbuState = WBU_SND_REQ;
          } else {
            //done
            wbuState = WBU_WAIT_META;
            printInfo(myName, "Done with packet (#%d, %d)\n",
                current_sessId.to_uint(), current_requested_length.to_uint());
          }
        } else {
          tmp.setTLast(0); //to be sure
        }
        soTOE_Data.write(tmp);
      }
      break;
    case WBU_DROP:
      //TODO: delete, because WRP ensures this should not happen?
      if(!siWrp_Data.empty())
      {
        TcpAppData tmp = siWrp_Data.read();
        if(tmp.getTLast() == 1)
        {
          //dequeue_cnt = 0;
          wbuState = WBU_WAIT_META;
        } else {
          dequeue_cnt -= extractByteCnt(tmp);
          if(dequeue_cnt == 0)
          {
            wbuState = WBU_WAIT_META;
          }
        }
      }
      break;
    case WBU_DRAIN:
      //drain all streams as long as NTS disabled
      if(*layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        if(!siWrp_Data.empty())
        {
          siWrp_Data.read();
        }
        if(!siWrp_SessId.empty())
        {
          siWrp_SessId.read();
        }
        if(!siWrp_len.empty())
        {
          siWrp_len.read();
        }
      } else {
        wbuState = WBU_WAIT_META;
      }
      break;
  } //switch
}

Here is the call graph for this function:

Here is the caller graph for this function:

pTcpWRp()

void pTcpWRp	(	ap_uint< 1 > *	layer_4_enabled,
		ap_uint< 1 > *	piNTS_ready,
		stream< NetworkWord > &	siFMC_data,
		stream< TcpSessId > &	siFMC_SessId,
		stream< NetworkWord > &	siTcp_data,
		stream< NetworkMetaStream > &	siTcp_meta,
		stream< TcpAppData > &	soTOE_Data,
		stream< TcpAppMeta > &	soTOE_SessId,
		stream< TcpDatLen > &	soTOE_len,
		stream< NodeId > &	sGetIpReq_TcpTx,
		stream< Ip4Addr > &	sGetIpRep_TcpTx,
		stream< NalTriple > &	sGetSidFromTriple_Req,
		stream< SessionId > &	sGetSidFromTriple_Rep,
		stream< NalTriple > &	sNewTcpCon_Req,
		stream< NalNewTcpConRep > &	sNewTcpCon_Rep,
		stream< bool > &	cache_inval_sig,
		stream< NalEventNotif > &	internal_event_fifo
	)

Write Path (WRp) - From ROLE or FMC to TOE. Process waits for a new data segment to write and forwards it to TOE.

Parameters

[in]	layer_4_enabled,external	signal if layer 4 is enabled
[in]	piNTS_ready,external	signal if NTS is up and running
[in]	siFmc_data,Data	from FMC
[in]	siFmc_meta,Metadata	from FMC
[in]	siTcp_data,Data	from [ROLE].
[in]	siTcp_meta,Meta	Data from [ROLE].
[out]	soTOE_Data,Data	for [TOE].
[out]	soTOE_SessId,Session	Id for [TOE].
[out]	soTOE_len,Data	length for [TOE].
[out]	sGetIpReq_TcpTx,Request	stream for the the MRT Agency
[in]	sGetIpRep_TcpTx,Reply	stream from the MRT Agency
[out]	&sGetSidFromTriple_Req,Request	stream for the the TCP Agency
[in]	&sGetSidFromTriple_Rep,Reply	stream from the TCO Agency
[out]	sNewTcpCon_Req,Request	stream for pTcpCOn to open a new connection
[in]	sNewTcpCon_Rep,Reply	stream from pTcpCOn
[in]	cache_inval_sig,Signal	from the Cache Invalidation Logic
[out]	internal_event_fifo,Fifo	for event reporting

Definition at line 1104 of file tss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
 
  char* myName  = concat3(THIS_NAME, "/", "Tcp_WRp");
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static WrpFsmStates wrpFsmState = WRP_RESET;
 
  static SessionId cached_tcp_tx_session_id = UNUSED_SESSION_ENTRY_VALUE;
  static ap_uint<64> cached_tcp_tx_triple = UNUSED_TABLE_ENTRY_VALUE;
  static NodeId cached_dst_rank = INVALID_MRT_VALUE;
  static Ip4Addr cached_dst_ip_addr = 0x0;
  static bool cache_init = false;
 
  static uint8_t evs_loop_i = 0;
 
#pragma HLS RESET variable=wrpFsmState
#pragma HLS RESET variable=cached_tcp_tx_session_id
#pragma HLS RESET variable=cached_tcp_tx_triple
#pragma HLS RESET variable=cached_dst_rank
#pragma HLS RESET variable=cache_init
#pragma HLS RESET variable=cached_dst_ip_addr
#pragma HLS RESET variable=evs_loop_i
 
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static NetworkMetaStream out_meta_tcp = NetworkMetaStream();
  static NetworkDataLength tcpTX_packet_length = 0;
  static NetworkDataLength tcpTX_current_packet_length = 0;
  static TcpAppMeta   tcpSessId = TcpAppMeta();
  static NodeId dst_rank = INVALID_MRT_VALUE;
  static Ip4Addr dst_ip_addr = 0x0;
  static NrcPort src_port = 0x0;
  static NrcPort dst_port = 0x0;
  static ap_uint<64> new_triple = UNUSED_TABLE_ENTRY_VALUE;
  static SessionId sessId = UNUSED_SESSION_ENTRY_VALUE;
  static bool streaming_mode = false;
 
  static stream<NalEventNotif> evsStreams[10];
 
 
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
  //NetworkWord  currWordIn;
  //TcpAppData   currWordOut;
  NalEventNotif new_ev_not;
 
  switch (wrpFsmState)
  {
    default:
    case WRP_RESET:
      if(*layer_4_enabled == 1 && *piNTS_ready == 1)
      {
        cache_init = false;
        wrpFsmState = WRP_WAIT_META;
      } else {
        if(!siFMC_data.empty())
        {
          siFMC_data.read();
        }
        if(!siFMC_SessId.empty())
        {
          siFMC_SessId.read();
        }
        if(!siTcp_data.empty())
        {
          siTcp_data.read();
        }
        if(!siTcp_meta.empty())
        {
          siTcp_meta.read();
        }
      }
      break;
    case WRP_WAIT_META:
      if( *layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        wrpFsmState = WRP_RESET;
      }
      else if(!cache_inval_sig.empty())
      {
        if(cache_inval_sig.read())
        {
          cached_tcp_tx_session_id = UNUSED_SESSION_ENTRY_VALUE;
          cached_tcp_tx_triple = UNUSED_TABLE_ENTRY_VALUE;
          cached_dst_rank = INVALID_MRT_VALUE;
          cached_dst_ip_addr = 0x0;
          cache_init = false;
        }
        break;
      }
      else if (!siFMC_SessId.empty()
          && !soTOE_SessId.full()
          )
      {
        //FMC must come first
        tcpSessId = (AppMeta) siFMC_SessId.read();
        soTOE_SessId.write(tcpSessId);
        streaming_mode = true;
        tcpTX_current_packet_length = 0;
        //delete the session id, we don't need it any longer
        // (this expects an HTTP mode of request-response)
        //UPDATE: is done via the TOE_Notif if the client 
        //closes the connection
 
        if (DEBUG_LEVEL & TRACE_WRP) {
          printInfo(myName, "Received new session ID #%d from [FMC].\n",
              tcpSessId.to_uint());
        }
        wrpFsmState = WRP_STREAM_FMC;
        break;
      }
      else if (!siTcp_meta.empty()
          && !sGetIpReq_TcpTx.full()
          )
      {
        //now ask the ROLE
        out_meta_tcp = siTcp_meta.read();
        tcpTX_packet_length = out_meta_tcp.tdata.len;
        tcpTX_current_packet_length = 0;
 
        dst_rank = out_meta_tcp.tdata.dst_rank;
        if(dst_rank > MAX_CF_NODE_ID)
        {
          new_ev_not = NalEventNotif(NID_MISS_TX, 1);
          evsStreams[0].write_nb(new_ev_not);
          //SINK packet
          wrpFsmState = WRP_DROP_PACKET;
          printf("NRC drops the packet...\n");
          break;
        }
 
        src_port = out_meta_tcp.tdata.src_port;
        if (src_port == 0)
        {
          src_port = DEFAULT_RX_PORT;
        }
        dst_port = out_meta_tcp.tdata.dst_port;
        if (dst_port == 0)
        {
          dst_port = DEFAULT_RX_PORT;
          new_ev_not = NalEventNotif(PCOR_TX, 1);
          evsStreams[2].write_nb(new_ev_not);
        }
 
        if(cache_init && dst_rank == cached_dst_rank)
        {
          dst_ip_addr = cached_dst_ip_addr;
          wrpFsmState = WRP_W8FORREQS_11;
        } else {
          //need request both...
          sGetIpReq_TcpTx.write(dst_rank);
          cache_init = false;
          wrpFsmState = WRP_W8FORREQS_1;
          //break;
        }
      }
      break;
 
    case WRP_W8FORREQS_1:
      if(!sGetIpRep_TcpTx.empty())
      {
        dst_ip_addr = sGetIpRep_TcpTx.read();
        wrpFsmState = WRP_W8FORREQS_11;
      }
      break;
 
    case WRP_W8FORREQS_11:
      //both cases
      if(//cache_init ||
          !sGetSidFromTriple_Req.full())
      {
        //not else, in both cases
        wrpFsmState = WRP_W8FORREQS_2;
        if(dst_ip_addr == 0)
        {
          new_ev_not = NalEventNotif(NID_MISS_TX, 1);
          evsStreams[1].write_nb(new_ev_not);
          //SINK packet
          wrpFsmState = WRP_DROP_PACKET;
          printf("NRC drops the packet...\n");
          break;
        }
 
        //check if session is present
        new_triple = newTriple(dst_ip_addr, dst_port, src_port);
        printf("From ROLE: remote Addr: %d; dstPort: %d; srcPort %d; (rank: %d)\n", (int) dst_ip_addr, (int) dst_port, (int) src_port, (int) dst_rank);
        sessId = UNUSED_SESSION_ENTRY_VALUE;
        if(cache_init && new_triple == cached_tcp_tx_triple)
        {
          printf("used TCP TX tripple chache.\n");
          sessId = cached_tcp_tx_session_id;
          wrpFsmState = WRP_W8FORREQS_22;
        } else {
          //need request
          sGetSidFromTriple_Req.write(new_triple);
          cache_init = false;
          wrpFsmState = WRP_W8FORREQS_2;
          //break;
        }
      }
      break;
 
    case WRP_W8FORREQS_2:
      if(!sGetSidFromTriple_Rep.empty())
      {
        sessId = sGetSidFromTriple_Rep.read();
        cached_tcp_tx_triple = new_triple;
        cached_tcp_tx_session_id = sessId;
        cached_dst_ip_addr = dst_ip_addr;
        cached_dst_rank = dst_rank;
        cache_init = true;
        wrpFsmState = WRP_W8FORREQS_22;
      }
      break;
 
    case WRP_W8FORREQS_22:
      if( *layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        wrpFsmState = WRP_RESET;
      }
      else if(!soTOE_SessId.full() && !sNewTcpCon_Req.full() && !soTOE_len.full() )
      {
        //both cases
        //"final" preprocessing
        printf("session id found: %d\n", (int) sessId);
        if(sessId == (SessionId) UNUSED_SESSION_ENTRY_VALUE)
        {//we need to create one first
          sNewTcpCon_Req.write(new_triple);
          wrpFsmState = WRP_WAIT_CONNECTION;
          cache_init = false;
          printf("requesting new connection.\n");
          break;
        }
        new_ev_not = NalEventNotif(LAST_TX_NID, dst_rank);
        evsStreams[3].write_nb(new_ev_not);
        new_ev_not = NalEventNotif(LAST_TX_PORT, dst_port);
        evsStreams[4].write_nb(new_ev_not);
        new_ev_not = NalEventNotif(PACKET_TX, 1);
        evsStreams[5].write_nb(new_ev_not);
 
        soTOE_SessId.write(sessId);
        tcpTX_current_packet_length = 0;
        if(tcpTX_packet_length == 0)
        {
          streaming_mode = true;
        } else {
          streaming_mode = false;
          soTOE_len.write(tcpTX_packet_length);
        }
        if (DEBUG_LEVEL & TRACE_WRP) {
          printInfo(myName, "Received new session ID #%d from [ROLE] with length %d.\n",
              sessId.to_uint(), tcpTX_packet_length.to_uint());
        }
        wrpFsmState = WRP_STREAM_ROLE;
      }
      break;
 
    case WRP_WAIT_CONNECTION:
      if( *layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        wrpFsmState = WRP_RESET;
      }
      else if( !soTOE_SessId.full() && !sNewTcpCon_Rep.empty() && !soTOE_len.full() )
      {
        NalNewTcpConRep con_rep = sNewTcpCon_Rep.read();
        if(con_rep.failure == true)
        {
          new_ev_not = NalEventNotif(TCP_CON_FAIL, 1);
          evsStreams[6].write_nb(new_ev_not);
          // we sink the packet, because otherwise the design will hang
          // and the user is notified with the flight recorder status
          wrpFsmState = WRP_DROP_PACKET;
          printf("NRC drops the packet...\n");
          break;
        }
        new_triple = con_rep.new_triple;
        sessId = con_rep.newSessionId;
 
        new_ev_not = NalEventNotif(LAST_TX_NID, dst_rank);
        evsStreams[7].write_nb(new_ev_not);
        new_ev_not = NalEventNotif(LAST_TX_PORT, dst_port);
        evsStreams[8].write_nb(new_ev_not);
        new_ev_not = NalEventNotif(PACKET_TX, 1);
        evsStreams[9].write_nb(new_ev_not);
 
        soTOE_SessId.write(sessId);
        tcpTX_current_packet_length = 0;
        if(tcpTX_packet_length == 0)
        {
          streaming_mode = true;
        } else {
          streaming_mode = false;
          soTOE_len.write(tcpTX_packet_length);
        }
        if (DEBUG_LEVEL & TRACE_WRP) {
          printInfo(myName, "Received new session ID #%d from [ROLE].\n",
              sessId.to_uint());
        }
        wrpFsmState = WRP_STREAM_ROLE;
        cached_tcp_tx_triple = new_triple;
        cached_tcp_tx_session_id = sessId;
        cached_dst_ip_addr = dst_ip_addr;
        cached_dst_rank = dst_rank;
        cache_init = true;
 
      }
      break;
 
    case WRP_STREAM_FMC:
      if( *layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        wrpFsmState = WRP_RESET;
      }
      else if (!siFMC_data.empty() && !soTOE_Data.full() && !soTOE_len.full() )
      {
        NetworkWord tmpWord = siFMC_data.read();
        TcpAppData tcpWord = TcpAppData(tmpWord.tdata, tmpWord.tkeep, tmpWord.tlast); //LE stays LE
        tcpTX_current_packet_length += extractByteCnt(tcpWord);
        soTOE_Data.write(tcpWord);
        if(tcpWord.getTLast() == 1) {
          wrpFsmState = WRP_WAIT_META;
          soTOE_len.write(tcpTX_current_packet_length);
        } else {
          //always streaming
          if(tcpTX_current_packet_length >= NAL_STREAMING_SPLIT_TCP)
          {
            soTOE_len.write(tcpTX_current_packet_length);
            tcpTX_current_packet_length = 0;
          }
        }
      }
      break;
 
    case WRP_STREAM_ROLE:
      if( *layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        wrpFsmState = WRP_RESET;
      }
      else if (!siTcp_data.empty() && !soTOE_Data.full()  && !soTOE_len.full() )
      {
        NetworkWord currWordIn = siTcp_data.read();
        tcpTX_current_packet_length += extractByteCnt(currWordIn);
        if(!streaming_mode)
        {
          currWordIn.tlast = 0; // we ignore users tlast if the length is known
        }
        printf("streaming from ROLE to TOE: tcpTX_packet_length: %d, tcpTX_current_packet_length: %d \n", (int) tcpTX_packet_length, (int) tcpTX_current_packet_length);
        if(!streaming_mode && tcpTX_current_packet_length >= tcpTX_packet_length) //&& tcpTX_packet_length > 0
        {
          currWordIn.tlast = 1;
        }
        if(currWordIn.tlast == 1) //either by the user, or by us
        {
          wrpFsmState = WRP_WAIT_META;
          if(streaming_mode)
          {
            soTOE_len.write(tcpTX_current_packet_length);
          }
        }
        else if (streaming_mode)
        {
          if(tcpTX_current_packet_length >= NAL_STREAMING_SPLIT_TCP)
          {
            soTOE_len.write(tcpTX_current_packet_length);
            tcpTX_current_packet_length = 0;
            currWordIn.tlast = 1; //to be sure? (actually, unecessary)
          }
        }
        TcpAppData currWordOutTmp = TcpAppData(currWordIn.tdata, currWordIn.tkeep, currWordIn.tlast);
        soTOE_Data.write(currWordOutTmp);
      }
      break;
 
    case WRP_DROP_PACKET:
      if( *layer_4_enabled == 0 || *piNTS_ready == 0)
      {
        wrpFsmState = WRP_RESET;
      }
      else if( !siTcp_data.empty())
      {
        NetworkWord currWordIn = siTcp_data.read();
        tcpTX_current_packet_length += extractByteCnt(currWordIn);
        //until Tlast or length
        if( (tcpTX_packet_length > 0 && tcpTX_current_packet_length >= tcpTX_packet_length)
            || (currWordIn.tlast == 1)
          )
        {
          wrpFsmState = WRP_WAIT_META;
        }
      }
      break;
  } // switch case
 
  //-- ALWAYS -----------------------
  if(!internal_event_fifo.full()
    )
  {
    if(!evsStreams[evs_loop_i].empty())
    {
      internal_event_fifo.write(evsStreams[evs_loop_i].read());
    }
    evs_loop_i++;
    if(evs_loop_i >= 10)
    {
      evs_loop_i = 0;
    }
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

pTOE()

void pTOE	(	int &	nrErr,
		stream< TcpAppNotif > &	soTRIF_Notif,
		stream< TcpAppRdReq > &	siTRIF_DReq,
		stream< TcpAppData > &	soTRIF_Data,
		stream< TcpAppMeta > &	soTRIF_SessId,
		stream< TcpAppLsnReq > &	siTRIF_LsnReq,
		stream< TcpAppLsnRep > &	soTRIF_LsnAck,
		stream< TcpAppData > &	siTRIF_Data,
		stream< TcpAppSndReq > &	siTRIF_SndReq,
		stream< TcpAppSndRep > &	soTRIF_SndRep,
		stream< TcpAppOpnReq > &	siTRIF_OpnReq,
		stream< TcpAppOpnRep > &	soTRIF_OpnRep
	)

Definition at line 840 of file tb_nal.cpp.

{
 
    //------------------------------------------------------
    //-- FSM #1 - LISTENING
    //------------------------------------------------------
    static TcpAppLsnReq appLsnPortReq;
 
    switch (lsnState) {
    case LSN_WAIT_REQ: // CHECK IF A LISTENING REQUEST IS PENDING
        if (!siTRIF_LsnReq.empty()) {
            siTRIF_LsnReq.read(appLsnPortReq);
            printInfo(myLsnName, "Received a listen port request #%d from [TRIF].\n",
                      appLsnPortReq.to_int());
            lsnState = LSN_SEND_ACK;
        }
        //else {
        //    printWarn(myLsnName, "Waiting for listen port request.\n");
        //}
        break;
    case LSN_SEND_ACK: // SEND ACK BACK TO [TRIF]
        if (!soTRIF_LsnAck.full()) {
            soTRIF_LsnAck.write(true);
            //fpgaLsnPort = appLsnPortReq.to_int();
            lsnState = LSN_WAIT_REQ;
        }
        else {
            printWarn(myLsnName, "Cannot send listen reply back to [TRIF] because stream is full.\n");
        }
        break;
    }  // End-of: switch (lsnState) {
 
    //------------------------------------------------------
    //-- FSM #2 - OPEN CONNECTION
    //------------------------------------------------------
    TcpAppOpnReq   HostSockAddr(DEFAULT_HOST_IP4_ADDR,
                               DEFAULT_HOST_LSN_PORT);
 
    TcpAppOpnRep opnReply(sessionId_reply, ESTABLISHED);
    if (!opnStartupDelay) {
        switch(opnState) {
        case OPN_WAIT_REQ:
            if (!siTRIF_OpnReq.empty()) {
                siTRIF_OpnReq.read(HostSockAddr);
                printInfo(myOpnName, "Received a request to open the following remote socket address:\n");
                printSockAddr(myOpnName, HostSockAddr);
                opnState = OPN_SEND_REP;
            }
            break;
        case OPN_SEND_REP:
            if (!soTRIF_OpnRep.full()) {
                soTRIF_OpnRep.write(opnReply);
                opnState = OPN_WAIT_REQ;
            }
            else {
                printWarn(myOpnName, "Cannot send open connection reply back to [TRIF] because stream is full.\n");
            }
            break;
        default: //Timeout etc.
            break;
        }  // End-of: switch (opnState) {
    }
    else
        opnStartupDelay--;
 
    //------------------------------------------------------
    //-- FSM #3 - RX DATA PATH
    //------------------------------------------------------
    ap_uint< 8>        keep;
    ap_uint< 1>        last;
    if (!rxpStartupDelay) {
        switch (rxpState) {
        case RXP_SEND_NOTIF: // SEND A DATA NOTIFICATION TO [TRIF]
            printf("Send packet from %4.4x to FPGA:%d\n",(int) hostIp4Addr, (int) fpgaLsnPort);
            if (!soTRIF_Notif.full()) {
                soTRIF_Notif.write(TcpAppNotif(sessionId,  tcpSegLen,
                                            hostIp4Addr,hostSrcPort , fpgaLsnPort));
                printInfo(myRxpName, "Sending notification #%d to [TRIF] (sessId=%d, segLen=%d).\n",
                          segCnt, sessionId.to_int(), tcpSegLen.to_int());
                rxpState = RXP_WAIT_DREQ;
            }
            break;
        case RXP_WAIT_DREQ: // WAIT FOR A DATA REQUEST FROM [TRIF]
            if (!siTRIF_DReq.empty()) {
                siTRIF_DReq.read(appRdReq);
                printInfo(myRxpName, "Received a data read request from [TRIF] (sessId=%d, segLen=%d).\n",
                          appRdReq.sessionID.to_int(), appRdReq.length.to_int());
                byteCnt = 0;
                //rxpState = RXP_SEND_DATA;
                //rxpState = RXP_DONE;
                rxpState = RXP_SEND_META;
           }
           break;
        case RXP_SEND_META:
                if (!soTRIF_SessId.full()) {
                    soTRIF_SessId.write(sessionId);
                    rxpState = RXP_SEND_DATA;
                    //rxpState = RXP_DONE;
                }
                break;
        case RXP_SEND_DATA: // FORWARD DATA AND METADATA TO [TRIF]
            // Note: We always assume 'tcpSegLen' is multiple of 8B.
            keep = 0xFF;
            if (byteCnt == 0) {
                //if (!soTRIF_SessId.full() && !soTRIF_Data.full()) {
                if (!soTRIF_Data.full()) {
                    soTRIF_Data.write(TcpAppData(data, keep, last));
                    if (DEBUG_LEVEL & TRACE_TOE)
                        printAxiWord(myRxpName, NetworkWord(data, keep, last));
                    byteCnt += 8;
                    data += 8;
                }
                else {
                  printf("[TB-INFO-2] NRC not ready to receive TCP data.\n");
                  break;
                }
            }
            else if (byteCnt < tcpSegLen) {
                if (!soTRIF_Data.full()) {
                    byteCnt += 8;
                    last = (byteCnt>=(tcpSegLen-1)) ? 1 : 0;
                    soTRIF_Data.write(TcpAppData(data, keep, last));
                    if (DEBUG_LEVEL & TRACE_TOE)
                        printAxiWord(myRxpName, NetworkWord(data, keep, last));
                    data += 8;
                    if(last == 1)
                    {
                      segCnt++;
                      tcp_packets_send++;
                      if (segCnt >= nrSegToSend) {
                          rxpState = RXP_DONE;
                      } else {
                          rxpState = RXP_SEND_NOTIF;
                      }
                    }
                }
            }
            break;
        case RXP_DONE: // END OF THE RX PATH SEQUENCE
            // ALL SEGMENTS HAVE BEEN SENT
            // Reset for next run
            byteCnt = 0;
            segCnt = 0;
            //wait here
            break;
        }  // End-of: switch())
    }
    else
      rxpStartupDelay--;
    
    //printInfo(myRxpName, "POST FSM state %d\n", (int) rxpState); 
 
    //------------------------------------------------------
    //-- FSM #4 - TX DATA PATH
    //--    (Always drain the data coming from [TRIF])
    //------------------------------------------------------
    static TcpSessId curr_sessId;
    if (!txpStartupDelay) {
        switch (txpState) {
        case TXP_WAIT_REQ:
            if (!siTRIF_SndReq.empty() && !soTRIF_SndRep.full()) {
                TcpAppSndReq     app_req;
                siTRIF_SndReq.read(app_req);
                curr_sessId = app_req.sessId;
                TcpDatLen len = app_req.length;
                if (DEBUG_LEVEL & TRACE_TOE) {
                    printInfo(myTxpName, "Receiving TX Request for session #%d with length %d; \t Approve up to length %d\n",
                        curr_sessId.to_int(), len.to_int(), DEFAULT_TCP_LEN_REP);
                }
                TcpAppSndErr err_rep = NO_ERROR;
                if(len > DEFAULT_TCP_LEN_REP)
                {
                  err_rep = NO_SPACE;
                  tcp_recv_frag_cnt++;
                }
                TcpAppSndRep app_rep = TcpAppSndRep(curr_sessId, len, DEFAULT_TCP_LEN_REP, err_rep);
                soTRIF_SndRep.write(app_rep);
                txpState = TXP_WAIT_DATA;
            }
            break;
        case TXP_WAIT_DATA:
          //TODO: acturally, there must not come data after a request, there could also be another request
          //but the current pTcpWBu is not using this flexibility
          if(  !siTRIF_Data.empty())
          {
                TcpAppData appData;
                siTRIF_Data.read(appData);
                if (DEBUG_LEVEL & TRACE_TOE) {
                    printInfo(myTxpName, "Receiving data for session #%d\n", curr_sessId.to_int());
                    printAxiWord(myTxpName, appData);
                }
                if (!appData.getTLast() == 1)
                {
                  txpState = TXP_RECV_DATA;
                } else {
                  txpState = TXP_WAIT_REQ;
                  tcp_packets_recv++;
                }
 
          }
          break;
        case TXP_RECV_DATA:
            if (!siTRIF_Data.empty()) {
                TcpAppData appData;
                siTRIF_Data.read(appData);
                if (DEBUG_LEVEL & TRACE_TOE)
                    printAxiWord(myTxpName, appData);
                if (appData.getTLast() == 1) {
                    txpState = TXP_WAIT_REQ;
                    tcp_packets_recv++;
                }
            }
            break;
        }
    }
    else { 
        txpStartupDelay--;
    }
    
    //printInfo(myTxpName, "POST FSM state %d\n", (int) txpState); 
}

Here is the call graph for this function:

Here is the caller graph for this function:

pUdpCls()

void pUdpCls	(	stream< UdpPort > &	soUOE_ClsReq,
		stream< StsBool > &	siUOE_ClsRep,
		stream< UdpPort > &	sUdpPortsToClose
	)

Asks the UOE to close UDP ports, based on the request from pPortLogic.

Parameters

[out]	soUOE_ClsReq,close	port request for UOE
[in]	siUOE_ClsRep,response	of the UOE
[in]	sUdpPortsToClose,port	close request from pPortLogic

Definition at line 747 of file uss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
  char *myName  = concat3(THIS_NAME, "/", "Udp_Cls");
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static ClsFsmStates clsFsmState_Udp = CLS_IDLE;
 
#pragma HLS RESET variable=clsFsmState_Udp
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  //static ap_uint<16> newRelativePortToClose = 0;
  static ap_uint<16> newAbsolutePortToClose = 0;
 
 
  switch (clsFsmState_Udp) 
  {
    default:
    case CLS_IDLE:
      clsFsmState_Udp = CLS_NEXT;
    case CLS_NEXT:
      if(!sUdpPortsToClose.empty() && !soUOE_ClsReq.full() )
      {
        //we have to close opened ports, one after another
        newAbsolutePortToClose = sUdpPortsToClose.read();
        soUOE_ClsReq.write(newAbsolutePortToClose);
        clsFsmState_Udp = CLS_WAIT4RESP;
      } 
      break;
    case CLS_WAIT4RESP:
      if(!siUOE_ClsRep.empty())
      {
        StsBool isOpened;
        siUOE_ClsRep.read(isOpened);
        if (not isOpened)
        {
          printInfo(myName, "Received close acknowledgment from [UOE].\n");
        }
        else {
          printWarn(myName, "UOE denied closing the port %d (0x%4.4X) which is still opened.\n",
              (int) newAbsolutePortToClose, (int) newAbsolutePortToClose);
        }
        //in all cases
        clsFsmState_Udp = CLS_NEXT;
      }
      break;
  }
}

Here is the caller graph for this function:

pUdpLsn()

void pUdpLsn	(	stream< UdpPort > &	soUOE_LsnReq,
		stream< StsBool > &	siUOE_LsnRep,
		stream< UdpPort > &	sUdpPortsToOpen,
		stream< bool > &	sUdpPortsOpenFeedback
	)

Asks the UOE to open new UDP ports for listening, based on the request from pPortLogic.

Parameters

[out]	soUOE_LsnReq,open	port request for UOE
[in]	siUOE_LsnRep,response	of the UOE
[in]	sUdpPortsToOpen,port	open request from pPortLogic
[out]	sUdpPortsOpenFeedback,feedback	to pPortLogic

Definition at line 358 of file uss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
  char* myName  = concat3(THIS_NAME, "/", "Udp_LSn");
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static LsnFsmStates lsnFsmState = LSN_IDLE;
#ifdef __SYNTHESIS_
  static ap_uint<16>         startupDelay = 0x8000;
#else
  static ap_uint<16>         startupDelay = 10;
#endif
 
#pragma HLS RESET variable=lsnFsmState
#pragma HLS RESET variable=startupDelay
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static ap_uint<8>   watchDogTimer_plisten = 0;
  static UdpPort new_absolute_port = 0;
 
  switch (lsnFsmState) {
 
    default:
    case LSN_IDLE:
      if (startupDelay > 0)
      {
        startupDelay--;
      } else {
        lsnFsmState = LSN_SEND_REQ;
      }
      break;
 
    case LSN_SEND_REQ:
      if ( !soUOE_LsnReq.full() && !sUdpPortsToOpen.empty())
      {
        new_absolute_port = sUdpPortsToOpen.read();
        soUOE_LsnReq.write(new_absolute_port);
        if (DEBUG_LEVEL & TRACE_LSN) {
          printInfo(myName, "Requesting to listen on port #%d (0x%4.4X).\n",
              (int) new_absolute_port, (int) new_absolute_port);
#ifndef __SYNTHESIS__
          watchDogTimer_plisten = 10;
#else
          watchDogTimer_plisten = 100;
#endif
          lsnFsmState = LSN_WAIT_ACK;
        }
      }
      //else {
      //  printWarn(myName, "Cannot send a listen port request to [UOE] because stream is full!\n");
      //}
      break;
 
    case LSN_WAIT_ACK:
      if (!siUOE_LsnRep.empty() && !sUdpPortsOpenFeedback.full())
      {
        bool    listenDone;
        siUOE_LsnRep.read(listenDone);
        if (listenDone) {
          printInfo(myName, "Received listen acknowledgment from [UOE].\n");
          lsnFsmState = LSN_SEND_REQ;
          sUdpPortsOpenFeedback.write(true);
        }
        else {
          printWarn(myName, "UOE denied listening on port %d (0x%4.4X).\n",
              (int) new_absolute_port, (int) new_absolute_port);
          sUdpPortsOpenFeedback.write(false);
          lsnFsmState = LSN_SEND_REQ;
        }
      } else if (watchDogTimer_plisten == 0 && !sUdpPortsOpenFeedback.full() )
      {
        printError(myName, "Timeout: Server failed to listen on port %d %d (0x%4.4X).\n",
            (int)  new_absolute_port, (int) new_absolute_port);
        sUdpPortsOpenFeedback.write(false);
        lsnFsmState = LSN_SEND_REQ;
      } else {
        watchDogTimer_plisten--;
      }
      break;
 
  }
}

Here is the caller graph for this function:

pUdpRx()

void pUdpRx	(	ap_uint< 1 > *	layer_7_enabled,
		ap_uint< 1 > *	role_decoupled,
		stream< NetworkWord > &	soUdp_data,
		stream< NetworkMetaStream > &	soUdp_meta,
		stream< UdpAppData > &	siUOE_Data,
		stream< UdpAppMeta > &	siUOE_Meta,
		stream< UdpAppDLen > &	siUOE_DLen,
		stream< NalConfigUpdate > &	sConfigUpdate,
		stream< Ip4Addr > &	sGetNidReq_UdpRx,
		stream< NodeId > &	sGetNidRep_UdpRx,
		stream< bool > &	cache_inval_sig,
		stream< NalEventNotif > &	internal_event_fifo
	)

Processes the incoming UDP packets (i.e. Network -> ROLE ).

Parameters

[in]	layer_7_enabled,External	signal if layer 7 is enabled
[in]	role_decoupled,External	signal if the role is decoupled
[out]	soUdp_data,UDP	Data for the Role
[out]	soUdp_meta,UDP	Metadata for the Role
[in]	siUOE_Data,UDP	Data from the UOE
[in]	siUOE_Meta,UDP	Metadata from the UOE
[in]	siUOE_DLen,UDP	Packetlength from the UOE (UDP header)
[in]	sConfigUpdate,Updates	from axi4liteProcessing (own rank)
[out]	sGetNidReq_UdpRx,Request	stream for the the MRT Agency
[in]	sGetNidRep_UdpRx,Reply	stream from the MRT Agency
[in]	cache_inval_sig,Signal	from the Cache Invalidation Logic
[out]	internal_event_fifo,Fifo	for event reporting

Definition at line 467 of file uss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
  char   *myName  = concat3(THIS_NAME, "/", "Udp_RX");
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static FsmStateUdp fsmStateRX_Udp = FSM_W8FORMETA;
  static NodeId cached_udp_rx_id = 0;
  static Ip4Addr cached_udp_rx_ipaddr = 0;
  static NodeId own_rank = 0;
  static bool cache_init = false;
  static uint8_t evs_loop_i = 0;
 
#pragma HLS RESET variable=fsmStateRX_Udp
#pragma HLS RESET variable=cached_udp_rx_id
#pragma HLS RESET variable=cached_udp_rx_ipaddr
#pragma HLS RESET variable=own_rank
#pragma HLS RESET variable=cache_init
#pragma HLS RESET variable=evs_loop_i
 
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static UdpAppMeta udpRxMeta;
  static UdpAppDLen udpRxLen;
  static NodeId src_id = INVALID_MRT_VALUE;
  static NetworkMeta in_meta;
 
  static stream<NalEventNotif> evsStreams[4];
 
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
  NalEventNotif new_ev_not;
  NetworkMetaStream in_meta_udp_stream;
  bool role_disabled = (*layer_7_enabled == 0 || *role_decoupled == 1);
 
 
  switch(fsmStateRX_Udp) {
 
    default:
      //case FSM_RESET:
      //fsmStateRX_Udp = FSM_W8FORMETA;
      //NO break;
    case FSM_W8FORMETA:
      if( !cache_inval_sig.empty() )
      {
        if(cache_inval_sig.read())
        {
          cached_udp_rx_id = 0;
          cached_udp_rx_ipaddr = 0;
          cache_init = false;
        }
        break;
      } else if(!sConfigUpdate.empty())
      {
        NalConfigUpdate ca = sConfigUpdate.read();
        if(ca.config_addr == NAL_CONFIG_OWN_RANK)
        {
          own_rank = (NodeId) ca.update_value;
          cache_init = false;
          cached_udp_rx_id = 0;
          cached_udp_rx_ipaddr = 0;
        }
        break;
      } else if ( !siUOE_Meta.empty()
          && !siUOE_DLen.empty()
          && !sGetNidReq_UdpRx.full())
      {
        //extract src ip address
        siUOE_Meta.read(udpRxMeta);
        siUOE_DLen.read(udpRxLen);
        src_id = (NodeId) INVALID_MRT_VALUE;
 
        if(role_disabled)
        {
          fsmStateRX_Udp = FSM_DROP_PACKET;
          //no notifications necessary, UOE counts?
          cache_init = false;
          break;
        }
 
        //to create here due to timing...
        in_meta = NetworkMeta(own_rank, udpRxMeta.udpDstPort, 0, udpRxMeta.udpSrcPort, udpRxLen);
 
        //ask cache
        if(cache_init && cached_udp_rx_ipaddr == udpRxMeta.ip4SrcAddr)
        {
          printf("used UDP RX id cache\n");
          src_id = cached_udp_rx_id;
          fsmStateRX_Udp = FSM_FIRST_ACC;
        } else {
          sGetNidReq_UdpRx.write(udpRxMeta.ip4SrcAddr);
          fsmStateRX_Udp = FSM_W8FORREQS;
          //break;
        }
      }
      break;
 
    case FSM_W8FORREQS:
      if(!sGetNidRep_UdpRx.empty())
      {
        src_id = sGetNidRep_UdpRx.read();
        cached_udp_rx_ipaddr = udpRxMeta.ip4SrcAddr;
        cached_udp_rx_id = src_id;
        cache_init = true;
        fsmStateRX_Udp = FSM_FIRST_ACC;
      }
      break;
 
    case FSM_FIRST_ACC:
      if( !soUdp_meta.full() )
      {
        if(src_id == ((NodeId) INVALID_MRT_VALUE))
        {
          //SINK packet
          new_ev_not = NalEventNotif(NID_MISS_RX, 1);
          evsStreams[0].write_nb(new_ev_not);
          printf("[UDP-RX:ERROR]invalid src_id, packet will be dropped.\n");
          fsmStateRX_Udp = FSM_DROP_PACKET;
          cache_init = false;
          break;
        }
        //status
        new_ev_not = NalEventNotif(LAST_RX_NID, src_id);
        evsStreams[1].write_nb(new_ev_not);
        new_ev_not = NalEventNotif(LAST_RX_PORT, udpRxMeta.udpDstPort);
        evsStreams[2].write_nb(new_ev_not);
        in_meta.src_rank = src_id;
 
        //write metadata
        in_meta_udp_stream = NetworkMetaStream(in_meta);
        soUdp_meta.write(in_meta_udp_stream);
        //soUdp_meta.write(in_meta_udp);
        new_ev_not = NalEventNotif(PACKET_RX, 1);
        evsStreams[3].write_nb(new_ev_not);
        // Forward data chunk to ROLE
        fsmStateRX_Udp = FSM_ACC;
      }
      break;
 
    case FSM_ACC:
      // Default stream handling
      if ( !siUOE_Data.empty() && !soUdp_data.full() )
      {
        // Forward data chunk to ROLE
        //NetworkWord    udpWord = siUOE_Data.read();
        UdpAppData udpWordtmp = siUOE_Data.read();
        NetworkWord udpWord = NetworkWord(udpWordtmp.getLE_TData(), udpWordtmp.getLE_TKeep(), udpWordtmp.getLE_TLast());
        soUdp_data.write(udpWord);
        //TODO: should we verify the length of udpRxLen?
 
        // Until LAST bit is set
        if (udpWord.tlast == 1)
        {
          fsmStateRX_Udp = FSM_W8FORMETA;
        }
      }
      break;
 
    case FSM_DROP_PACKET:
      if( !siUOE_Data.empty() )
      {
        UdpAppData    udpWord = siUOE_Data.read();
        // Until LAST bit is set
        if (udpWord.getTLast() == 1)
        {
          fsmStateRX_Udp = FSM_W8FORMETA;
        }
      }
      break;
  } //switch
 
  //-- ALWAYS -----------------------
  if(!internal_event_fifo.full())
  {
    if(!evsStreams[evs_loop_i].empty())
    {
      internal_event_fifo.write(evsStreams[evs_loop_i].read());
    }
    evs_loop_i++;
    if(evs_loop_i >= 4)
    {
      evs_loop_i = 0;
    }
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

pUdpTX()

void pUdpTX	(	stream< NetworkWord > &	siUdp_data,
		stream< NetworkMetaStream > &	siUdp_meta,
		stream< UdpAppData > &	soUOE_Data,
		stream< UdpAppMeta > &	soUOE_Meta,
		stream< UdpAppDLen > &	soUOE_DLen,
		stream< NodeId > &	sGetIpReq_UdpTx,
		stream< Ip4Addr > &	sGetIpRep_UdpTx,
		const ap_uint< 32 > *	ipAddrBE,
		stream< bool > &	cache_inval_sig,
		stream< NalEventNotif > &	internal_event_fifo
	)

Processes the outgoing UDP packets (i.e. ROLE -> Network).

Parameters

[in]	siUdp_data,UDP	Data from the Role
[in]	siUdp_meta,UDP	Metadata from the Role
[out]	soUOE_Data,UDP	Data for the UOE
[out]	soUOE_Meta,UDP	Metadata (i.e. HostSockAddr) for the UOE
[out]	soUOE_DLen,UDP	Packet length for the UOE
[out]	sGetIpReq_UdpTx,Request	stream for the the MRT Agency
[in]	sGetIpRep_UdpTx,Reply	stream from the MRT Agency
[in]	ipAddrBE,IP	address of the FPGA (from MMIO)
[in]	cache_inval_sig,Signal	from the Cache Invalidation Logic
[out]	internal_event_fifo,Fifo	for event reporting

Definition at line 51 of file uss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
 
  char   *myName  = concat3(THIS_NAME, "/", "Udp_TX");
 
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static FsmStateUdp fsmStateTX_Udp = FSM_RESET;
  static NodeId cached_nodeid_udp_tx = UNUSED_SESSION_ENTRY_VALUE;
  static Ip4Addr cached_ip4addr_udp_tx = 0;
  static bool cache_init = false;
  static uint8_t evs_loop_i = 0;
 
#pragma HLS RESET variable=fsmStateTX_Udp
#pragma HLS RESET variable=cached_nodeid_udp_tx
#pragma HLS RESET variable=cached_ip4addr_udp_tx
#pragma HLS RESET variable=cache_init
#pragma HLS RESET variable=evs_loop_i
 
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  static UdpAppDLen udpTX_packet_length = 0;
  static UdpAppDLen udpTX_current_packet_length = 0;
  static ap_uint<32> dst_ip_addr = 0;
  static NetworkMetaStream udp_meta_in;
  static NodeId dst_rank = 0;
  static UdpAppMeta txMeta;
  static NrcPort src_port;
  static NrcPort dst_port;
 
  static stream<NalEventNotif> evsStreams[6];
 
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
  NalEventNotif new_ev_not;
 
  switch(fsmStateTX_Udp) {
 
    default:
    case FSM_RESET:
      fsmStateTX_Udp = FSM_W8FORMETA;
      udpTX_packet_length = 0;
      udpTX_current_packet_length = 0;
      cache_init = false;
      break;
 
    case FSM_W8FORMETA:
      if( !cache_inval_sig.empty() )
      {
        if(cache_inval_sig.read())
        {
          cache_init = false; 
          cached_nodeid_udp_tx = UNUSED_SESSION_ENTRY_VALUE;
          cached_ip4addr_udp_tx = 0;
        }
        break;
      }
      else if ( !siUdp_meta.empty() &&
          !sGetIpReq_UdpTx.full() )
      {
        udp_meta_in = siUdp_meta.read();
        udpTX_packet_length = udp_meta_in.tdata.len;
        udpTX_current_packet_length = 0;
 
        // Send out the first data together with the metadata and payload length information
 
        dst_rank = udp_meta_in.tdata.dst_rank;
        if(dst_rank > MAX_CF_NODE_ID)
        {
          new_ev_not = NalEventNotif(NID_MISS_TX, 1);
          evsStreams[0].write_nb(new_ev_not);
          //SINK packet
          fsmStateTX_Udp = FSM_DROP_PACKET;
          break;
        }
 
        src_port = udp_meta_in.tdata.src_port;
        if (src_port == 0)
        {
          src_port = DEFAULT_RX_PORT;
        }
        dst_port = udp_meta_in.tdata.dst_port;
        if (dst_port == 0)
        {
          dst_port = DEFAULT_RX_PORT;
          new_ev_not = NalEventNotif(PCOR_TX, 1);
          evsStreams[3].write_nb(new_ev_not);
        }
 
        //to create here due to timing...
        //dst addres as 0 for now
        txMeta = UdpAppMeta(*ipAddrBE, src_port, 0, dst_port);
 
        //request ip if necessary
        if(cache_init && cached_nodeid_udp_tx == dst_rank)
        {
          dst_ip_addr = cached_ip4addr_udp_tx;
          fsmStateTX_Udp = FSM_FIRST_ACC;
          printf("used UDP TX id cache\n");
        } else {
 
          sGetIpReq_UdpTx.write(dst_rank);
          fsmStateTX_Udp = FSM_W8FORREQS;
          //break;
        }
      }
      break;
 
    case FSM_W8FORREQS:
      if(!sGetIpRep_UdpTx.empty())
      {
        dst_ip_addr = sGetIpRep_UdpTx.read();
        //TODO: need new FSM states
        cached_nodeid_udp_tx = dst_rank;
        cached_ip4addr_udp_tx = dst_ip_addr;
        cache_init = true;
        fsmStateTX_Udp = FSM_FIRST_ACC;
      }
      break;
 
    case FSM_FIRST_ACC:
      if ( !soUOE_Meta.full()
          && !soUOE_DLen.full() )
      {
        if(dst_ip_addr == 0)
        {
          new_ev_not = NalEventNotif(NID_MISS_TX, 1);
          evsStreams[1].write_nb(new_ev_not);
          //SINK packet
          fsmStateTX_Udp = FSM_DROP_PACKET;
          break;
        }
        new_ev_not = NalEventNotif(LAST_TX_NID, dst_rank);
        evsStreams[2].write_nb(new_ev_not);
        new_ev_not = NalEventNotif(LAST_TX_PORT, dst_port);
        evsStreams[4].write_nb(new_ev_not);
        //UdpMeta txMeta = {{src_port, ipAddrBE}, {dst_port, dst_ip_addr}};
        //txMeta = SocketPair(SockAddr(*ipAddrBE, src_port), SockAddr(dst_ip_addr, dst_port));
        txMeta.ip4DstAddr = dst_ip_addr;
 
        // Forward data chunk, metadata and payload length
        soUOE_Meta.write(txMeta);
 
        //we can forward the length, even if 0
        //the UOE handles this as streaming mode
        soUOE_DLen.write(udpTX_packet_length);
        new_ev_not = NalEventNotif(PACKET_TX, 1);
        evsStreams[5].write_nb(new_ev_not);
 
        fsmStateTX_Udp = FSM_ACC;
      }
      break;
 
    case FSM_ACC:
      // Default stream handling
      if ( !siUdp_data.empty() && !soUOE_Data.full() )
      {
        // Forward data chunk
        //UdpAppData    aWord = siUdp_data.read();
        NetworkWord tmpWord = siUdp_data.read();
        UdpAppData aWord = UdpAppData(tmpWord.tdata, tmpWord.tkeep, tmpWord.tlast);
        udpTX_current_packet_length += extractByteCnt(aWord);
        if(udpTX_packet_length > 0 && udpTX_current_packet_length >= udpTX_packet_length)
        {//we need to set tlast manually
          aWord.setTLast(1);
        }
 
        soUOE_Data.write(aWord);
        // Until LAST bit is set
        if (aWord.getTLast() == 1)
        {
          fsmStateTX_Udp = FSM_W8FORMETA;
        }
      }
      break;
 
    case FSM_DROP_PACKET:
      if ( !siUdp_data.empty() )
      {
        //UdpAppData    aWord = siUdp_data.read();
        NetworkWord tmpWord = siUdp_data.read();
        UdpAppData aWord = UdpAppData(tmpWord.tdata, tmpWord.tkeep, tmpWord.tlast);
        udpTX_current_packet_length += extractByteCnt(aWord);
 
        if( (udpTX_packet_length > 0 && udpTX_current_packet_length >= udpTX_packet_length)
            || aWord.getTLast() == 1 )
        {
          fsmStateTX_Udp = FSM_W8FORMETA;
        }
      }
      break;
  } //switch
 
  //-- ALWAYS -----------------------
  if(!internal_event_fifo.full())
  {
    if(!evsStreams[evs_loop_i].empty())
    {
      internal_event_fifo.write(evsStreams[evs_loop_i].read());
    }
    evs_loop_i++;
    if(evs_loop_i >= 6)
    {
      evs_loop_i = 0;
    }
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

pUoeUdpTxDeq()

void pUoeUdpTxDeq	(	ap_uint< 1 > *	layer_4_enabled,
		ap_uint< 1 > *	piNTS_ready,
		stream< UdpAppData > &	sUoeTxBuffer_Data,
		stream< UdpAppMeta > &	sUoeTxBuffer_Meta,
		stream< UdpAppDLen > &	sUoeTxBuffer_DLen,
		stream< UdpAppData > &	soUOE_Data,
		stream< UdpAppMeta > &	soUOE_Meta,
		stream< UdpAppDLen > &	soUOE_DLen
	)

Terminates the internal UDP TX FIFOs and forwards packets to the UOE.

Definition at line 277 of file uss.cpp.

{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE off
#pragma HLS pipeline II=1
  //-- STATIC CONTROL VARIABLES (with RESET) --------------------------------
  static DeqFsmStates deqFsmState = DEQ_WAIT_META;
#pragma HLS RESET variable=deqFsmState
  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
  //-- LOCAL DATAFLOW VARIABLES ---------------------------------------------
  UdpAppData cur_word;
  UdpAppMeta cur_meta;
  UdpAppDLen cur_dlen;
  bool uoe_disabled = (*layer_4_enabled == 0 || *piNTS_ready == 0);
 
  switch(deqFsmState)
  {
    default:
    case DEQ_WAIT_META:
      if(!sUoeTxBuffer_Data.empty() && !sUoeTxBuffer_Meta.empty() && !sUoeTxBuffer_DLen.empty()
          && ( (!soUOE_Data.full() && !soUOE_Meta.full() && !soUOE_DLen.full() ) || //UOE can read
            (uoe_disabled) //UOE is disabled -> drain FIFOs
            )
        )
      {
        cur_word = sUoeTxBuffer_Data.read();
        cur_meta = sUoeTxBuffer_Meta.read();
        cur_dlen = sUoeTxBuffer_DLen.read();
        if(!uoe_disabled)
        {
          soUOE_Data.write(cur_word);
          soUOE_Meta.write(cur_meta);
          soUOE_DLen.write(cur_dlen);
        }
        if(cur_word.getTLast() == 0)
        {
          deqFsmState = DEQ_STREAM_DATA;
        }
      }
      break;
    case DEQ_STREAM_DATA:
      if(!sUoeTxBuffer_Data.empty()
          && (!soUOE_Data.full() || uoe_disabled)
        )
      {
        cur_word = sUoeTxBuffer_Data.read();
        if(!uoe_disabled)
        {
          soUOE_Data.write(cur_word);
        }
        if(cur_word.getTLast() == 1)
        {
          deqFsmState = DEQ_WAIT_META;
        }
      }
      break;
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

readDataStream()

bool readDataStream	(	stream< UdpAppData > &	sDataStream,
		UdpAppData *	udpWord
	)

Read data from a stream.

Parameters

[in]	sDataStream,the	output data stream to read.
[in]	dataStreamName,the	name of the data stream.
[out]	udpWord,a	pointer to the storage location of the data to read.

Returns

VALID if a data was read, otherwise UNVALID.

Definition at line 395 of file tb_nal.cpp.

                                                                           {
    // Get the DUT/Data results
    sDataStream.read(*udpWord);
    return(VALID);
}

Here is the caller graph for this function:

readMetaStream()

bool readMetaStream	(	stream< UdpAppMeta > &	sMetaStream,
		const string	metaStreamName,
		UdpAppMeta *	udpMeta
	)

Read an output metadata stream from the DUT.

Parameters

[in]	sMetaStream,the	output metadata stream to read.
[in]	metaStreamName,the	name of the meta stream.
[out]	udpMeta,a	pointer to the storage location of the metadata to read.

Returns

VALID if a data was read, otherwise UNVALID.

Definition at line 410 of file tb_nal.cpp.

                                         {
    // Get the DUT/Metadata results
    sMetaStream.read(*udpMeta);
    // Print DUT/Metadata to console
    printf("[%4.4d] TB is draining output stream [%s] - Metadata = {{SP=0x%4.4X,SA=0x%8.8X} {DP=0x%4.4X,DA=0x%8.8X}} \n",
            simCnt, metaStreamName.c_str(),
            udpMeta->udpSrcPort.to_int(), udpMeta->ip4SrcAddr.to_int(), udpMeta->udpDstPort.to_int(), udpMeta->ip4DstAddr.to_int());
    return(VALID);
}

Here is the caller graph for this function:

readPLenStream()

bool readPLenStream	(	stream< UdpPLen > &	sPLenStream,
		const string	plenStreamName,
		UdpPLen *	udpPLen
	)

Read an output payload length stream from the DUT.

Parameters

[in]	sPLenStream,the	output payload length stream to read.
[in]	plenStreamName,the	name of the payload length stream.
[out]	udpPLen,a	pointer to the storage location of the payload length to read.

Returns

VALID if a data was read, otherwise UNVALID.

Definition at line 431 of file tb_nal.cpp.

                                      {
    // Get the DUT/PayloadLength results
    sPLenStream.read(*udpPLen);
    // Print DUT/PayloadLength to console
    printf("[%4.4d] TB is draining output stream [%s] - Payload length = %d from DUT.\n",
            simCnt, plenStreamName.c_str(), udpPLen->to_int());
    return(VALID);
}

Here is the caller graph for this function:

selectConfigUpdatePropagation()

uint8_t selectConfigUpdatePropagation

(

uint16_t

config_addr

)

This is the process that has to know which config value means what And to where it should be send:

Returns: 0 : no propagation 1 : to TCP tables 2 : to Port logic 3 : to own rank receivers

Definition at line 45 of file hss.cpp.

{
#pragma HLS INLINE
  switch(config_addr) {
    default:
      return 0;
    case NAL_CONFIG_OWN_RANK:
      return 3;
    case NAL_CONFIG_SAVED_FMC_PORTS:
    case NAL_CONFIG_SAVED_TCP_PORTS:
    case NAL_CONFIG_SAVED_UDP_PORTS:
      return 2;
  }
}

Here is the caller graph for this function:

setInputDataStream() [1/2]

bool setInputDataStream	(	stream< NetworkWord > &	sDataStream,
		const string	dataStreamName,
		const string	inpFileName
	)

Definition at line 269 of file tb_nal.cpp.

                                                                                                                 {
    string      strLine;
    ifstream    inpFileStream;
    string      datFile = "../../../../test/" + inpFileName;
 
    //-- STEP-1 : OPEN FILE
    inpFileStream.open(datFile.c_str());
    if ( !inpFileStream ) {
        cout << "### ERROR : Could not open the input data file " << datFile << endl;
        return(KO);
    }
 
    //-- STEP-2 : SET DATA STREAM
    while (inpFileStream) {
 
        if (!inpFileStream.eof()) {
 
            getline(inpFileStream, strLine);
            if (strLine.empty())
            {
              continue;
            }
            uint64_t newd = 0x0;
            uint32_t newk = 0; //sscanf expects 32bit
            uint32_t newl = 0; //sscanf expects 32bit
            //printf(strLine.c_str()); printf("\n");
            //sscanf(strLine.c_str(), "%u" PRIx64 " %x %d", &newd, &newk, &newl);
            sscanf(strLine.c_str(), "%llx %x %d", &newd, &newk, &newl);
            UdpAppData udpWordTmp;
            udpWordTmp.setTData(newd); //BE version
            udpWordTmp.setTKeep(newk); //BE version
            udpWordTmp.setTLast(newl); //BE version
            NetworkWord udpWord = NetworkWord(udpWordTmp.getLE_TData(), udpWordTmp.getLE_TKeep(), udpWordTmp.getLE_TLast());
            //printf("scanff reads %llx, %x %d\n", newd, newk, newl);
 
            // Write to sDataStream
            if (sDataStream.full()) {
                printf("### ERROR : Stream is full. Cannot write stream with data from file \"%s\".\n", inpFileName.c_str());
                return(KO);
            } else {
                sDataStream.write(udpWord);
                // Print Data to console
                printf("[%4.4d] TB is filling input stream [%s] - Data write = {D=0x%16.16llX, K=0x%2.2X, L=%d} \n",
                        simCnt, dataStreamName.c_str(),
                        udpWord.tdata.to_uint64(), udpWord.tkeep.to_int(), udpWord.tlast.to_int());
            }
        }
    }
 
    //-- STEP-3: CLOSE FILE
    inpFileStream.close();
 
    return(OK);
}

Here is the call graph for this function:

setInputDataStream() [2/2]

bool setInputDataStream	(	stream< UdpAppData > &	sDataStream,
		const string	dataStreamName,
		const string	inpFileName
	)

Initialize an input data stream from a file.

Parameters

[in]	sDataStream,the	input data stream to set.
[in]	dataStreamName,the	name of the data stream.
[in]	inpFileName,the	name of the input file to read from.

Returns

OK if successful, otherwise KO.

Definition at line 214 of file tb_nal.cpp.

                                                                                                                {
    string      strLine;
    ifstream    inpFileStream;
    string      datFile = "../../../../test/" + inpFileName;
 
    //-- STEP-1 : OPEN FILE
    inpFileStream.open(datFile.c_str());
    if ( !inpFileStream ) {
        cout << "### ERROR : Could not open the input data file " << datFile << endl;
        return(KO);
    }
 
    //-- STEP-2 : SET DATA STREAM
    while (inpFileStream) {
 
        if (!inpFileStream.eof()) {
 
            getline(inpFileStream, strLine);
            if (strLine.empty())
            {
              continue;
            }
            uint64_t newd = 0x0;
            uint32_t newk = 0; //sscanf expects 32bit
            uint32_t newl = 0; //sscanf expects 32bit
            //printf(strLine.c_str()); printf("\n");
            //sscanf(strLine.c_str(), "%u" PRIx64 " %x %d", &newd, &newk, &newl);
            sscanf(strLine.c_str(), "%llx %x %d", &newd, &newk, &newl);
            UdpAppData     udpWord;
            udpWord.setTData(newd); //BE version
            udpWord.setTKeep(newk); //BE version
            udpWord.setTLast(newl); //BE version
            //printf("scanff reads %llx, %x %d\n", newd, newk, newl);
            //UdpAppData udpWord(newd, newk, newl);
 
            // Write to sDataStream
            if (sDataStream.full()) {
                printf("### ERROR : Stream is full. Cannot write stream with data from file \"%s\".\n", inpFileName.c_str());
                return(KO);
            } else {
                sDataStream.write(udpWord);
                // Print Data to console
                printf("[%4.4d] TB is filling input stream [%s] - Data write = {D=0x%16.16llX, K=0x%2.2X, L=%d} \n",
                        simCnt, dataStreamName.c_str(),
                        udpWord.getTData().to_uint64(), udpWord.getTKeep().to_int(), udpWord.getTLast().to_int());
            }
        }
    }
 
    //-- STEP-3: CLOSE FILE
    inpFileStream.close();
 
    return(OK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setInputMetaStream()

bool setInputMetaStream	(	stream< UdpAppMeta > &	sMetaStream,
		const string	dataStreamName,
		const string	inpFileName
	)

Initialize an input meta stream from a file.

Parameters

[in]	sMetaStream,the	input meta stream to set.
[in]	dataStreamName,the	name of the data stream.
[in]	inpFileName,the	name of the input file to read from.

Returns

OK if successful, otherwise KO.

Definition at line 333 of file tb_nal.cpp.

                                                                                                                {
    string      strLine;
    ifstream    inpFileStream;
    string      datFile = "../../../../test/" + inpFileName;
    UdpWord     udpWord;
    UdpAppMeta  udpMeta;
 
    //-- STEP-1 : OPEN FILE
    inpFileStream.open(datFile.c_str());
    if ( !inpFileStream ) {
        cout << "### ERROR : Could not open the input data file " << datFile << endl;
        return(KO);
    }
 
    //-- STEP-2 : SET DATA STREAM
    while (inpFileStream) {
 
        if (!inpFileStream.eof()) {
 
            getline(inpFileStream, strLine);
            if (strLine.empty()) continue;
            sscanf(strLine.c_str(), "%llx %x %d", &udpWord.tdata, &udpWord.tkeep, &udpWord.tlast);
 
            // Check if the LAST bit is set
            if (udpWord.tlast) {
 
                // Create an connection association {{SrcPort, SrcAdd}, {DstPort, DstAdd}}
                //socketPair = (UdpMeta) {{DEFAULT_RX_PORT, 0x0A0B0C01}, {DEFAULT_RX_PORT, 0x0A0B0C0E}};
                udpMeta = UdpAppMeta(DEFAULT_RX_PORT, 0x0A0B0C01, DEFAULT_RX_PORT, 0x0A0B0C0E);
 
                //  Write to sMetaStream
                if (sMetaStream.full()) {
                    printf("### ERROR : Stream is full. Cannot write stream with data from file \"%s\".\n", inpFileName.c_str());
                    return(KO);
                }
                else {
                    sMetaStream.write(udpMeta);
                    // Print Metadata to console
                    printf("[%4.4d] TB is filling input stream [%s] - Metadata = {{SP=0x%4.4X,SA=0x%8.8X} {DP=0x%4.4X,DA=0x%8.8X}} \n",
                            simCnt, dataStreamName.c_str(),
                            udpMeta.udpSrcPort.to_int(), udpMeta.ip4SrcAddr.to_int(), udpMeta.udpDstPort.to_int(), udpMeta.ip4DstAddr.to_int());
                }
            }
        }
    }
 
    //-- STEP-3: CLOSE FILE
    inpFileStream.close();
 
    return(OK);
}

sFMC_Nrc_Tcp_data()

stream<NetworkWord> sFMC_Nrc_Tcp_data

(

"sFMC_Nrc_Tcp_data"

)

Here is the caller graph for this function:

sFMC_Nrc_Tcp_sessId()

stream<TcpSessId> sFMC_Nrc_Tcp_sessId

(

"sFMC_Nrc_Tcp_sessId"

)

Here is the caller graph for this function:

siUdp_meta()

stream< NetworkMetaStream > siUdp_meta

(

"siUdp_meta"

)

Here is the caller graph for this function:

sNRC_FMC_Tcp_data()

stream<NetworkWord> sNRC_FMC_Tcp_data

(

"sNRC_FMC_Tcp_data"

)

Here is the caller graph for this function:

sNRC_FMC_Tcp_sessId()

stream<TcpSessId> sNRC_FMC_Tcp_sessId

(

"sNRC_FMC_Tcp_sessId"

)

Here is the caller graph for this function:

sNRC_Role_Data()

stream<NetworkWord> sNRC_Role_Data

(

"sNRC_Role_Data"

)

Here is the caller graph for this function:

sNRC_Role_Tcp_data()

stream<NetworkWord> sNRC_Role_Tcp_data

(

"sNRC_Role_Tcp_data"

)

Here is the caller graph for this function:

sNRC_Role_Tcp_meta()

stream<NetworkMetaStream> sNRC_Role_Tcp_meta

(

"sNRC_Role_Tcp_meta"

)

Here is the caller graph for this function:

sNRC_Toe_ClsReq()

stream<TcpAppClsReq> sNRC_Toe_ClsReq

(

"sNRC_TOE_ClsReq"

)

Here is the caller graph for this function:

sNRC_Toe_Data()

stream<TcpAppData> sNRC_Toe_Data

(

"sNRC_TOE_Data"

)

Here is the caller graph for this function:

sNRC_Toe_DReq()

stream<TcpAppRdReq> sNRC_Toe_DReq

(

"sNrc_TOE_DReq"

)

Here is the caller graph for this function:

sNRC_Toe_LsnReq()

stream<TcpAppLsnReq> sNRC_Toe_LsnReq

(

"sNRC_TOE_LsnReq"

)

Here is the caller graph for this function:

sNRC_Toe_OpnReq()

stream<TcpAppOpnReq> sNRC_Toe_OpnReq

(

"sNRC_Toe_OpnReq"

)

Here is the caller graph for this function:

sNRC_Toe_SndReq()

stream<TcpAppSndReq> sNRC_Toe_SndReq

(

"sNRC_TOE_SndReq"

)

Here is the caller graph for this function:

sNRC_UOE_ClsReq()

stream<UdpPort> sNRC_UOE_ClsReq

(

"sNRC_UOE_ClsReq"

)

Here is the caller graph for this function:

sNRC_UOE_Data()

stream<UdpAppData> sNRC_UOE_Data

(

"sNRC_UOE_Data"

)

Here is the caller graph for this function:

sNRC_UOE_DLen()

stream<UdpAppDLen> sNRC_UOE_DLen

(

"sNRC_UOE_DLen"

)

Here is the caller graph for this function:

sNRC_UOE_LsnReq()

stream<UdpPort> sNRC_UOE_LsnReq

(

"sNRC_UOE_LsnReq"

)

Here is the caller graph for this function:

sNRC_UOE_Meta()

stream<UdpAppMeta> sNRC_UOE_Meta

(

"sNRC_UOE_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:

sROLE_NRC_Data()

stream<NetworkWord> sROLE_NRC_Data

(

"sROLE_NRC_Data"

)

Here is the caller graph for this function:

sROLE_Nrc_Tcp_data()

stream<NetworkWord> sROLE_Nrc_Tcp_data

(

"sROLE_Nrc_Tcp_data"

)

Here is the caller graph for this function:

sROLE_Nrc_Tcp_meta()

stream<NetworkMetaStream> sROLE_Nrc_Tcp_meta

(

"sROLE_Nrc_Tcp_meta"

)

Here is the caller graph for this function:

stepDut()

void stepDut

(

)

Run a single iteration of the DUT model.

Returns

Nothing.

Definition at line 171 of file tb_nal.cpp.

               {
    nal_main(
        ctrlLink,
        &layer_4_enabled,
        &layer_7_enabled,
        &role_decoupled,
        &sNTS_Nrc_ready,
        &sMMIO_FmcLsnPort, &sMMIO_CfrmIp4Addr,
        &sIpAddress,
        &s_udp_rx_ports,
        sROLE_NRC_Data,    sNRC_Role_Data,
        siUdp_meta,         soUdp_meta,
        &s_tcp_rx_ports,
        sROLE_Nrc_Tcp_data, sROLE_Nrc_Tcp_meta,
        sNRC_Role_Tcp_data, sNRC_Role_Tcp_meta,
        sFMC_Nrc_Tcp_data, sFMC_Nrc_Tcp_sessId,
        //&piFMC_Tcp_data_FIFO_prog_full,
        sNRC_FMC_Tcp_data,
        //&piFMC_Tcp_sessid_FIFO_prog_full,
        sNRC_FMC_Tcp_sessId,
        sNRC_UOE_LsnReq, sUOE_NRC_LsnRep,
        sNRC_UOE_ClsReq, sUOE_NRC_ClsRep,
        sUOE_NRC_Data, sUOE_NRC_Meta, sUOE_NRC_DLen,
        sNRC_UOE_Data, sNRC_UOE_Meta, sNRC_UOE_DLen,
        sTOE_Nrc_Notif, sNRC_Toe_DReq, sTOE_Nrc_Data, sTOE_Nrc_SessId,
        sNRC_Toe_LsnReq, sTOE_Nrc_LsnAck,
        sNRC_Toe_Data, sNRC_Toe_SndReq, sTOE_Nrc_SndRep,
        sNRC_Toe_OpnReq, sTOE_Nrc_OpnRep,
        sNRC_Toe_ClsReq
        );
    simCnt++;
    printf("[%4.4d] STEP DUT \n", simCnt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sTOE_Nrc_Data()

stream<TcpAppData> sTOE_Nrc_Data

(

"sTOE_Nrc_Data"

)

Here is the caller graph for this function:

sTOE_Nrc_LsnAck()

stream<TcpAppLsnRep> sTOE_Nrc_LsnAck

(

"sTOE_Nrc_LsnAck"

)

Here is the caller graph for this function:

sTOE_Nrc_Notif()

stream<TcpAppNotif> sTOE_Nrc_Notif

(

"sTOE_Nrc_Notif"

)

Here is the caller graph for this function:

sTOE_Nrc_OpnRep()

stream<TcpAppOpnRep> sTOE_Nrc_OpnRep

(

"sTOE_NRC_OpenRep"

)

Here is the caller graph for this function:

sTOE_Nrc_SessId()

stream<TcpAppMeta> sTOE_Nrc_SessId

(

"sTOE_Nrc_SessId"

)

Here is the caller graph for this function:

sTOE_Nrc_SndRep()

stream<TcpAppSndRep> sTOE_Nrc_SndRep

(

"sTOE_NRC_SndRep"

)

Here is the caller graph for this function:

sUOE_NRC_ClsRep()

stream<StsBool> sUOE_NRC_ClsRep

(

"sUOE_NRC_ClsRep"

)

Here is the caller graph for this function:

sUOE_NRC_Data()

stream<UdpAppData> sUOE_NRC_Data

(

"sUOE_NRC_Data"

)

Here is the caller graph for this function:

sUOE_NRC_DLen()

stream<UdpAppDLen> sUOE_NRC_DLen

(

"sUOE_NRC_DLen"

)

Here is the caller graph for this function:

sUOE_NRC_LsnRep()

stream<StsBool> sUOE_NRC_LsnRep

(

"sUOE_NRC_LsnRep"

)

Here is the caller graph for this function:

sUOE_NRC_Meta()

stream<UdpAppMeta> sUOE_NRC_Meta

(

"sUOE_NRC_Meta"

)

Here is the caller graph for this function:

Variable Documentation

appRdReq

TcpAppRdReq appRdReq

Definition at line 826 of file tb_nal.cpp.

byteCnt

int byteCnt = 0

Definition at line 829 of file tb_nal.cpp.

ctrlLink

ap_uint<32> ctrlLink[64+ 16+ 16]

Definition at line 137 of file tb_nal.cpp.

data

ap_uint<64> data =0

Definition at line 832 of file tb_nal.cpp.

fpgaLsnPort

TcpPort fpgaLsnPort = -1

Definition at line 812 of file tb_nal.cpp.

gFatalError

bool gFatalError = false

Definition at line 152 of file tb_nal.cpp.

gSimCycCnt

unsigned int gSimCycCnt = 0

GLOBAL VARIABLES USED BY THE SIMULATION ENVIRONMENT

Definition at line 150 of file tb_nal.cpp.

gTraceEvent [1/2]

bool gTraceEvent

extern

HELPERS FOR THE DEBUGGING TRACES .e.g: DEBUG_LEVEL = (MDL_TRACE | IPS_TRACE)

Definition at line 151 of file tb_nal.cpp.

gTraceEvent [2/2]

bool gTraceEvent = false

HELPERS FOR THE DEBUGGING TRACES .e.g: DEBUG_LEVEL = (MDL_TRACE | IPS_TRACE)

Definition at line 151 of file tb_nal.cpp.

hostIp4Addr

Ip4Addr hostIp4Addr = 0

Emulate the behavior of the TCP Offload Engine (TOE).

Parameters

[in]	nrErr,A	ref to the error counter of main.
[out]	soTRIF_Notif,Notification	to TcpRoleInterface (TRIF).
[in]	siTRIF_DReq,Data	read request from [TRIF}.
[out]	soTRIF_Data,Data	to [TRIF].
[out]	soTRIF_SessId,Session	Id to [TRIF].
[in]	siTRIF_LsnReq,Listen	port request from [TRIF].
[out]	soTRIF_LsnAck,Listen	port acknowledge to [TRIF].

Definition at line 811 of file tb_nal.cpp.

hostSrcPort

TcpPort hostSrcPort = 80

Definition at line 813 of file tb_nal.cpp.

layer_4_enabled

ap_uint<1> layer_4_enabled = 0b1

Definition at line 132 of file tb_nal.cpp.

layer_7_enabled

ap_uint<1> layer_7_enabled = 0b1

Definition at line 133 of file tb_nal.cpp.

loop

int loop = 1

Definition at line 814 of file tb_nal.cpp.

lsnState

enum LsnStates lsnState = LSN_WAIT_REQ

myIpAddress

ap_uint<32> myIpAddress

Definition at line 140 of file tb_nal.cpp.

myLsnName

const char* myLsnName = "NAL" "/" "TOE/Listen"

Definition at line 835 of file tb_nal.cpp.

myOpnName

const char* myOpnName = "NAL" "/" "TOE/OpnCon"

Definition at line 836 of file tb_nal.cpp.

myRxpName

const char* myRxpName = "NAL" "/" "TOE/RxPath"

Definition at line 837 of file tb_nal.cpp.

myTxpName

const char* myTxpName = "NAL" "/" "TOE/TxPath"

Definition at line 838 of file tb_nal.cpp.

nrSegToSend

int nrSegToSend = 3

Definition at line 831 of file tb_nal.cpp.

opnStartupDelay

int opnStartupDelay = 0

Definition at line 821 of file tb_nal.cpp.

opnState

enum OpnStates opnState = OPN_WAIT_REQ

role_decoupled

ap_uint<1> role_decoupled = 0b0

Definition at line 134 of file tb_nal.cpp.

roleFsmState

enum RoleFsmStates roleFsmState = ROLE_WAIT_META

rxFsmState

enum RxFsmStates rxFsmState = RX_WAIT_META

rxpStartupDelay

int rxpStartupDelay = 100

Definition at line 823 of file tb_nal.cpp.

rxpState

enum RxpStates rxpState = RXP_SEND_NOTIF

s_tcp_rx_ports

ap_uint<32> s_tcp_rx_ports = 0x1

Definition at line 139 of file tb_nal.cpp.

s_udp_rx_ports

ap_uint<32> s_udp_rx_ports = 0x1

Definition at line 138 of file tb_nal.cpp.

segCnt

int segCnt = 0

Definition at line 830 of file tb_nal.cpp.

sessionId

AppMeta sessionId = 42

Definition at line 827 of file tb_nal.cpp.

sessionId_reply

AppMeta sessionId_reply = 42

Definition at line 828 of file tb_nal.cpp.

simCnt

unsigned int simCnt

Definition at line 158 of file tb_nal.cpp.

sIpAddress

ap_uint<32> sIpAddress = 0x0a0b0c0d

Definition at line 136 of file tb_nal.cpp.

sMMIO_CfrmIp4Addr

ap_uint<32> sMMIO_CfrmIp4Addr = 0x0A0CC832

Definition at line 143 of file tb_nal.cpp.

sMMIO_FmcLsnPort

ap_uint<16> sMMIO_FmcLsnPort = 8803

Definition at line 141 of file tb_nal.cpp.

sNTS_Nrc_ready

ap_uint<1> sNTS_Nrc_ready = 0b1

Definition at line 135 of file tb_nal.cpp.

tcp_packets_expected_timeout

int tcp_packets_expected_timeout = 0

Definition at line 163 of file tb_nal.cpp.

tcp_packets_recv

int tcp_packets_recv = 0

Definition at line 161 of file tb_nal.cpp.

tcp_packets_send

int tcp_packets_send = 0

Definition at line 160 of file tb_nal.cpp.

tcp_recv_frag_cnt

int tcp_recv_frag_cnt = 0

Definition at line 162 of file tb_nal.cpp.

tcp_timout_packet_drop

int tcp_timout_packet_drop = 0

Definition at line 164 of file tb_nal.cpp.

tcpSegLen

TcpSegLen tcpSegLen = 32

Definition at line 833 of file tb_nal.cpp.

txpStartupDelay

int txpStartupDelay = 0

Definition at line 824 of file tb_nal.cpp.

txpState

enum TxpStates txpState = TXP_WAIT_REQ