cloudFPGA (cF) API  1.0
The documentation of the source code of cloudFPGA (cF)
tcp_app_flash.cpp
Go to the documentation of this file.
1 /*
2  * Copyright 2016 -- 2021 IBM Corporation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 
47 #include "tcp_app_flash.hpp"
48 
49 using namespace hls;
50 using namespace std;
51 
52 
56 #ifndef __SYNTHESIS__
57  extern bool gTraceEvent;
58 #endif
59 
60 #define THIS_NAME "TAF" // TcpApplicationFlash
61 
62 #define TRACE_OFF 0x0000
63 #define TRACE_ESF 1 << 1 // EchoStoreForward
64 #define TRACE_RXP 1 << 2 // RxPath
65 #define TRACE_TXP 1 << 3 // TxPath
66 #define TRACE_ALL 0xFFFF
67 #define DEBUG_LEVEL (TRACE_OFF)
68 
69 
70 
89 void pTcpEchoStoreAndForward(
90  stream<TcpAppData> &siRXp_Data,
91  stream<TcpSessId> &siRXp_SessId,
92  stream<TcpDatLen> &siRXp_DatLen,
93  stream<TcpAppData> &soTXp_Data,
94  stream<TcpSessId> &soTXp_SessId,
95  stream<TcpDatLen> &soTXp_DatLen)
96 {
97  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
98  #pragma HLS INLINE off
99  #pragma HLS PIPELINE II=1 enable_flush
100 
101  const char *myName = concat3(THIS_NAME, "/", "ESf");
102 
103  //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
104  static enum FsmStates { ESF_META=0, ESF_STREAM } \
105  esf_fsmState = ESF_META;
106  #pragma HLS reset variable=esf_fsmState
107  static Ly4Len esf_byteCnt;
108  #pragma HLS reset variable=esf_byteCnt
109 
110  //-- DYNAMIC VARIABLES -----------------------------------------------------
111  AxisApp currChunk;
112  TcpAppMeta tcpSessId;
113 
114  //=====================================================
115  //== PROCESS DATA FORWARDING
116  //=====================================================
117  if ( !siRXp_Data.empty() and !soTXp_Data.full() ) {
118  TcpAppData appData = siRXp_Data.read();
119  soTXp_Data.write(appData);
120  esf_byteCnt += appData.getLen();
121  if (appData.getTLast()) {
122  esf_byteCnt = 0;
123  }
124  }
125 
126  //=====================================================
127  //== PROCESS META FORWARDING
128  //=====================================================
129  if ( !siRXp_SessId.empty() and !soTXp_SessId.full() and
130  !siRXp_DatLen.empty() and !soTXp_DatLen.full() ) {
131  TcpSessId sessId = siRXp_SessId.read();
132  TcpDatLen datLen = siRXp_DatLen.read();
133  soTXp_SessId.write(sessId);
134  soTXp_DatLen.write(datLen);
135  }
136 
137 } // End of: pTcpEchoStoreAndForward()
138 
139 
153 void pTcpTxPath(
154  #if defined TAF_USE_NON_FIFO_IO
155  ap_uint<2> piSHL_MmioEchoCtrl,
156  #endif
157  stream<TcpAppData> &siEPt_Data,
158  stream<TcpSessId> &siEPt_SessId,
159  stream<TcpDatLen> &siEPt_DatLen,
160  stream<TcpAppData> &siESf_Data,
161  stream<TcpSessId> &siESf_SessId,
162  stream<TcpDatLen> &siESf_DatLen,
163  stream<TcpAppData> &soTSIF_Data,
164  stream<TcpSessId> &soTSIF_SessId,
165  stream<TcpDatLen> &soTSIF_DatLen)
166 {
167  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
168  #pragma HLS INLINE off
169  #pragma HLS PIPELINE II=1 enable_flush
170 
171  const char *myName = concat3(THIS_NAME, "/", "TXp");
172 
173  //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
174  static enum FsmStates { TXP_START_OF_STREAM=0, TXP_CONTINUATION_OF_STREAM } \
175  txp_fsmState=TXP_START_OF_STREAM;
176  #pragma HLS RESET variable=txp_fsmState
177  static EchoCtrl txp_EchoCtrl=ECHO_PATH_THRU;
178  #pragma HLS RESET variable=txp_EchoCtrl
179 
180  //-- STATIC DATAFLOW VARIABLES ---------------------------------------------
181  static ap_uint<16> txp_msgGapSize;
182 
183  //-- DYNAMIC VARIABLES -----------------------------------------------------
184  TcpAppData appData;
185  TcpAppMeta tcpSessId;
186 
187  #if defined TAF_USE_NON_FIFO_IO
188  switch (txp_fsmState ) {
189  case TXP_START_OF_STREAM:
190  switch(piSHL_MmioEchoCtrl) {
191  case ECHO_PATH_THRU:
192  // Read session Id from pEchoPassThrough and forward to [SHL]
193  if ( !siEPt_SessId.empty() and !soTSIF_SessId.full() and
194  !siEPt_DatLen.empty() and !soTSIF_DatLen.full() ) {
195  TcpSessId sessId;
196  TcpDatLen datLen;
197  siEPt_SessId.read(sessId);
198  siEPt_DatLen.read(datLen);
199  soTSIF_SessId.write(sessId);
200  soTSIF_DatLen.write(datLen);
201  txp_fsmState = TXP_CONTINUATION_OF_STREAM;
202  }
203  break;
204  case ECHO_STORE_FWD:
205  //-- Read session Id from pTcpEchoStoreAndForward and forward to [SHL]
206  if ( !siESf_SessId.empty() and !soTSIF_SessId.full() and
207  !siESf_DatLen.empty() and !soTSIF_DatLen.full() ) {
208  TcpSessId sessId;
209  TcpDatLen datLen;
210  siESf_SessId.read(sessId);
211  siESf_DatLen.read(datLen);
212  soTSIF_SessId.write(sessId);
213  soTSIF_DatLen.write(datLen);
214  txp_fsmState = TXP_CONTINUATION_OF_STREAM;
215  }
216  break;
217  case ECHO_OFF:
218  default:
219  // Always drain and drop the session Id (if any)
220  if ( !siEPt_SessId.empty() ) {
221  siEPt_SessId.read();
222  }
223  else if ( !siESf_SessId.empty() ) {
224  siESf_SessId.read();
225  }
226  // Always drain and drop the data-length (if any)
227  if ( !siEPt_DatLen.empty() ) {
228  siEPt_DatLen.read();
229  }
230  else if ( !siESf_DatLen.empty() ) {
231  siESf_DatLen.read();
232  }
233  txp_fsmState = TXP_CONTINUATION_OF_STREAM;
234  break;
235  } // End-of: switch(piSHL_MmioEchoCtrl) {
236  break;
237  case TXP_CONTINUATION_OF_STREAM:
238  switch(piSHL_MmioEchoCtrl) {
239  case ECHO_PATH_THRU:
240  //-- Read incoming data from pEchoPathThrough and forward to [SHL]
241  if (!siEPt_Data.empty() and !soTSIF_Data.full()) {
242  siEPt_Data.read(appData);
243  soTSIF_Data.write(appData);
244  // Update FSM state
245  if (appData.getTLast()) {
246  txp_fsmState = TXP_START_OF_STREAM;
247  }
248  }
249  break;
250  case ECHO_STORE_FWD:
251  //-- Read incoming data from pTcpEchoStoreAndForward and forward to [SHL]
252  if ( !siESf_Data.empty() and !soTSIF_Data.full()) {
253  siESf_Data.read(appData);
254  soTSIF_Data.write(appData);
255  // Update FSM state
256  if (appData.getTLast()) {
257  txp_fsmState = TXP_START_OF_STREAM;
258  }
259  }
260  break;
261  case ECHO_OFF:
262  default:
263  // Always drain and drop the data streams (if any)
264  if ( !siEPt_Data.empty() ) {
265  siEPt_Data.read(appData);
266  }
267  else if ( !siESf_Data.empty() ) {
268  siESf_Data.read(appData);
269  }
270  // Always alternate between START and CONTINUATION to drain all streams
271  txp_fsmState = TXP_START_OF_STREAM;
272  break;
273  } // End-of: switch(piSHL_MmioEchoCtrl) {
274  break;
275  } // End-of: switch (txp_fsmState ) {
276  #else
277  switch (txp_fsmState ) {
278  case TXP_START_OF_STREAM:
279  if (!siEPt_SessId.empty() and !siEPt_DatLen.empty() and
280  !soTSIF_SessId.full() and !soTSIF_DatLen.full()) {
281  soTSIF_SessId.write(siEPt_SessId.read());
282  soTSIF_DatLen.write(siEPt_DatLen.read());
283  txp_EchoCtrl = ECHO_PATH_THRU;
284  txp_fsmState = TXP_CONTINUATION_OF_STREAM;
285  }
286  else if (!siESf_SessId.empty() and !siESf_DatLen.empty() and
287  !soTSIF_SessId.full() and !soTSIF_DatLen.full()) {
288  soTSIF_SessId.write(siESf_SessId.read());
289  soTSIF_DatLen.write(siESf_DatLen.read());
290  txp_EchoCtrl = ECHO_STORE_FWD;
291  txp_fsmState = TXP_CONTINUATION_OF_STREAM;
292  }
293  break;
294  case TXP_CONTINUATION_OF_STREAM:
295  if (txp_EchoCtrl == ECHO_PATH_THRU) {
296  if(!siEPt_Data.empty() and !soTSIF_Data.full()) {
297  siEPt_Data.read(appData);
298  soTSIF_Data.write(appData);
299  if (appData.getTLast()) {
300  txp_fsmState = TXP_START_OF_STREAM;
301  txp_EchoCtrl = ECHO_STORE_FWD; // Toggle
302  }
303  }
304  }
305  else {
306  if(!siESf_Data.empty() and !soTSIF_Data.full()) {
307  siESf_Data.read(appData);
308  soTSIF_Data.write(appData);
309  if (appData.getTLast()) {
310  txp_fsmState = TXP_START_OF_STREAM;
311  txp_EchoCtrl = ECHO_PATH_THRU; // Toggle
312  }
313  }
314  }
315  break;
316  } // End-of: switch (txp_fsmState ) {
317  #endif
318 
319 } // End of: pTcpTxPath()
320 
321 
340 void pTcpRxPath(
341  #if defined TAF_USE_NON_FIFO_IO
342  ap_uint<2> piSHL_MmioEchoCtrl,
343  #endif
344  stream<TcpAppData> &siTSIF_Data,
345  stream<TcpSessId> &siTSIF_SessId,
346  stream<TcpDatLen> &siTSIF_DatLen,
347  stream<TcpAppData> &soEPt_Data,
348  stream<TcpSessId> &soEPt_SessId,
349  stream<TcpDatLen> &soEPt_DatLen,
350  stream<TcpAppData> &soESf_Data,
351  stream<TcpSessId> &soESf_SessId,
352  stream<TcpDatLen> &soESf_DatLen)
353 {
354  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
355  #pragma HLS INLINE off
356  #pragma HLS PIPELINE II=1 enable_flush
357 
358  const char *myName = concat3(THIS_NAME, "/", "RXp");
359 
360  //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
361  static enum FsmStates { RXP_START_OF_STREAM=0, RXP_CONTINUATION_OF_STREAM } \
362  rxp_fsmState=RXP_START_OF_STREAM;
363  #pragma HLS reset variable=rxp_fsmState
364  static EchoCtrl rxp_EchoCtrl=ECHO_PATH_THRU;
365  #pragma HLS RESET variable=rxp_EchoCtrl
366 
367  //-- LOCAL VARIABLES -------------------------------------------------------
368  TcpAppData appData;
369  TcpSessId sessId;
370  TcpDatLen datLen;
371 
372  #if defined TAF_USE_NON_FIFO_IO
373  switch(piSHL_MmioEchoCtrl) {
374  case ECHO_PATH_THRU:
375  switch (rxp_fsmState ) {
376  case RXP_START_OF_STREAM:
377  //-- Read incoming metadata and forward to pEchoPathThrough
378  if ( !siTSIF_SessId.empty() and !soEPt_SessId.full() and
379  !siTSIF_DatLen.empty() and !soEPt_DatLen.full() ) {
380  siTSIF_SessId.read(sessId);
381  siTSIF_DatLen.read(datLen);
382  soEPt_SessId.write(sessId);
383  soEPt_DatLen.write(datLen);
384  rxp_fsmState = RXP_CONTINUATION_OF_STREAM;
385  }
386  break;
387  case RXP_CONTINUATION_OF_STREAM:
388  //-- Read incoming data and forward to pEchoPathThrough
389  if (!siTSIF_Data.empty() and !soEPt_Data.full()) {
390  siTSIF_Data.read(appData);
391  soEPt_Data.write(appData);
392  // Update FSM state
393  if (appData.getTLast()) {
394  rxp_fsmState = RXP_START_OF_STREAM;
395  }
396  }
397  break;
398  }
399  break;
400  case ECHO_STORE_FWD:
401  switch (rxp_fsmState ) {
402  case RXP_START_OF_STREAM:
403  //-- Read incoming metadata and forward to pTcpEchoStoreAndForward
404  if ( !siTSIF_SessId.empty() and !soESf_SessId.full() and
405  !siTSIF_DatLen.empty() and !soEPt_DatLen.full()) {
406  soESf_SessId.write(siTSIF_SessId.read());
407  soESf_DatLen.write(siTSIF_DatLen.read());
408  rxp_fsmState = RXP_CONTINUATION_OF_STREAM;
409  }
410  break;
411  case RXP_CONTINUATION_OF_STREAM:
412  //-- Read incoming data and forward to pTcpEchoStoreAndForward
413  if ( !siTSIF_Data.empty() and !soESf_Data.full()) {
414  siTSIF_Data.read(appData);
415  soESf_Data.write(appData);
416  // Update FSM state
417  if (appData.getTLast()) {
418  rxp_fsmState = RXP_START_OF_STREAM;
419  }
420  }
421  break;
422  }
423  break;
424  case ECHO_OFF:
425  default:
426  switch (rxp_fsmState ) {
427  case RXP_START_OF_STREAM:
428  // Drain and drop the TCP metadata
429  if ( !siTSIF_SessId.empty() and !siTSIF_DatLen.empty()) {
430  siTSIF_SessId.read();
431  siTSIF_DatLen.read();
432  rxp_fsmState = RXP_CONTINUATION_OF_STREAM;
433  }
434  break;
435  case RXP_CONTINUATION_OF_STREAM:
436  // Drain and drop the TCP data
437  if ( !siTSIF_Data.empty() ) {
438  siTSIF_Data.read();
439  }
440  // Always alternate between START and CONTINUATION to drain all streams
441  rxp_fsmState = RXP_START_OF_STREAM;
442  break;
443  }
444  break;
445  }
446 
518  #else
519  switch (rxp_fsmState ) {
520  case RXP_START_OF_STREAM:
521  if (!siTSIF_SessId.empty() and !siTSIF_DatLen.empty() and
522  !soEPt_SessId.full() and !soEPt_DatLen.full() and
523  !soESf_SessId.full() and !soESf_DatLen.full()) {
524  siTSIF_SessId.read(sessId);
525  siTSIF_DatLen.read(datLen);
526  if (sessId.get_bit(0)) {
527  soEPt_SessId.write(sessId);
528  soEPt_DatLen.write(datLen);
529  rxp_EchoCtrl = ECHO_PATH_THRU;
530  if (DEBUG_LEVEL & TRACE_RXP) {
531  printInfo(myName, "SessId=%d --> Forwarding segment in ECHO_PATH_THRU mode.\n", sessId.to_ushort());
532  }
533  }
534  else {
535  // Forward to pEchoStoreAndForward
536  soESf_SessId.write(sessId);
537  soESf_DatLen.write(datLen);
538  rxp_EchoCtrl = ECHO_STORE_FWD;
539  if (DEBUG_LEVEL & TRACE_RXP) {
540  printInfo(myName, "SessId=%d --> Forwarding segment in ECHO_STORE_FWD mode.\n", sessId.to_ushort());
541  }
542  }
543  rxp_fsmState = RXP_CONTINUATION_OF_STREAM;
544  }
545  break;
546  case RXP_CONTINUATION_OF_STREAM:
547  if (!siTSIF_Data.empty()) {
548  if ((rxp_EchoCtrl == ECHO_PATH_THRU) and !soEPt_Data.full()) {
549  siTSIF_Data.read(appData);
550  soEPt_Data.write(appData);
551  if (appData.getTLast()) {
552  rxp_fsmState = RXP_START_OF_STREAM;
553  }
554  }
555  else if ((rxp_EchoCtrl == ECHO_STORE_FWD) and !soESf_Data.full()) {
556  siTSIF_Data.read(appData);
557  soESf_Data.write(appData);
558  if (appData.getTLast()) {
559  rxp_fsmState = RXP_START_OF_STREAM;
560  }
561  }
562  }
563  break;
564  }
565  #endif
566 
567 } // End of: pTcpRxPath()
568 
569 
581 void tcp_app_flash (
582 
583  //------------------------------------------------------
584  //-- SHELL / MMIO / Configuration Interfaces
585  //------------------------------------------------------
586  #if defined TAF_USE_NON_FIFO_IO
587  ap_uint<2> piSHL_MmioEchoCtrl,
588  #endif
589  //------------------------------------------------------
590  //-- SHELL / TCP Rx Data Interface
591  //------------------------------------------------------
592  stream<TcpAppData> &siTSIF_Data,
593  stream<TcpSessId> &siTSIF_SessId,
594  stream<TcpDatLen> &siTSIF_DataLen,
595  //------------------------------------------------------
596  //-- SHELL / TCP Tx Data Interface
597  //------------------------------------------------------
598  stream<TcpAppData> &soTSIF_Data,
599  stream<TcpSessId> &soTSIF_SessId,
600  stream<TcpDatLen> &soTSIF_DatLen)
601 {
602 
603  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
604  #pragma HLS DATAFLOW
605  #pragma HLS INLINE
606  #pragma HLS INTERFACE ap_ctrl_none port=return
607 
608  #if defined TAF_USE_NON_FIFO_IO
609  #pragma HLS STABLE variable=piSHL_MmioEchoCtrl
610  #endif
611 
612  //--------------------------------------------------------------------------
613  //-- LOCAL STREAMS (Sorted by the name of the modules which generate them)
614  //--------------------------------------------------------------------------
615 
616  //-- Rx Path (RXp) ---------------------------------------------------------
617  static stream<TcpAppData> ssRXpToTXp_Data ("ssRXpToTXp_Data");
618  #pragma HLS STREAM variable=ssRXpToTXp_Data depth=1024
619  static stream<TcpSessId> ssRXpToTXp_SessId ("ssRXpToTXp_SessId");
620  #pragma HLS STREAM variable=ssRXpToTXp_SessId depth=64
621  static stream<TcpDatLen> ssRXpToTXp_DatLen ("ssRXpToTXp_DatLen");
622  #pragma HLS STREAM variable=ssRXpToTXp_DatLen depth=64
623 
624  static stream<TcpAppData> ssRXpToESf_Data ("ssRXpToESf_Data");
625  #pragma HLS STREAM variable=ssRXpToESf_Data depth=2048
626  static stream<TcpSessId> ssRXpToESf_SessId ("ssRXpToESf_SessId");
627  #pragma HLS STREAM variable=ssRXpToESf_SessId depth=32
628  static stream<TcpDatLen> ssRXpToESf_DatLen ("ssRXpToESf_DatLen");
629  #pragma HLS STREAM variable=ssRXpToESf_DatLen depth=32
630 
631  //-- Echo Store and Forward (ESf) ------------------------------------------
632  static stream<TcpAppData> ssESfToTXp_Data ("ssESfToTXp_Data");
633  #pragma HLS STREAM variable=ssESfToTXp_Data depth=1024
634  static stream<TcpSessId> ssESfToTXp_SessId ("ssESfToTXp_SessId");
635  #pragma HLS STREAM variable=ssESfToTXp_SessId depth=32
636  static stream<TcpDatLen> ssESfToTXp_DatLen ("ssESfToTXp_DatLen");
637  #pragma HLS STREAM variable=ssESfToTXp_DatLen depth=32
638 
639  //-- PROCESS FUNCTIONS -----------------------------------------------------
640  //
641  // +----------+
642  // +-------->| pESf |----------+
643  // | +----------+ |
644  // | --------+ |
645  // | +--------> sEPt |---------+ |
646  // | | --------+ | |
647  // +--+--+--+--+ +--+--+--+--+
648  // | pRXp | | pTXp |
649  // +------+----+ +-----+-----+
650  // /|\ |
651  // | |
652  // | |
653  // | \|/
654  //
655  //--------------------------------------------------------------------------
656  pTcpRxPath(
657  #if defined TAF_USE_NON_FIFO_IO
658  piSHL_MmioEchoCtrl,
659  #endif
660  siTSIF_Data,
661  siTSIF_SessId,
662  siTSIF_DataLen,
663  ssRXpToTXp_Data,
664  ssRXpToTXp_SessId,
665  ssRXpToTXp_DatLen,
666  ssRXpToESf_Data,
667  ssRXpToESf_SessId,
668  ssRXpToESf_DatLen);
669 
670  pTcpEchoStoreAndForward(
671  ssRXpToESf_Data,
672  ssRXpToESf_SessId,
673  ssRXpToESf_DatLen,
674  ssESfToTXp_Data,
675  ssESfToTXp_SessId,
676  ssESfToTXp_DatLen);
677 
678  pTcpTxPath(
679  #if defined TAF_USE_NON_FIFO_IO
680  piSHL_MmioEchoCtrl,
681  #endif
682  ssRXpToTXp_Data,
683  ssRXpToTXp_SessId,
684  ssRXpToTXp_DatLen,
685  ssESfToTXp_Data,
686  ssESfToTXp_SessId,
687  ssESfToTXp_DatLen,
688  soTSIF_Data,
689  soTSIF_SessId,
690  soTSIF_DatLen);
691 
692 }
693 
AxisRaw::getTLast
tLast getTLast() const
Definition: AxisRaw.hpp:219
AxisRaw::getLen
int getLen() const
Definition: AxisRaw.hpp:411
EchoCtrl
EchoCtrl
Definition: memtest.hpp:49
Ly4Len
ap_uint< 16 > Ly4Len
Definition: nts_types.hpp:202
TcpDatLen
ap_uint< 16 > TcpDatLen
Definition: AxisTcp.hpp:123
printInfo
#define printInfo(callerName, format,...)
A macro to print an information message.
Definition: nts_utils.hpp:169
concat3
#define concat3(firstCharConst, secondCharConst, thirdCharConst)
Definition: nts_utils.hpp:161
TcpAppMeta
TcpSessId TcpAppMeta
Definition: nts.hpp:74
TcpSessId
ap_uint< 16 > TcpSessId
Definition: nts_types.hpp:137
pTcpTxPath
void pTcpTxPath(stream< TcpAppData > &siEPt_Data, stream< TcpSessId > &siEPt_SessId, stream< TcpDatLen > &siEPt_DatLen, stream< TcpAppData > &siESf_Data, stream< TcpSessId > &siESf_SessId, stream< TcpDatLen > &siESf_DatLen, stream< TcpAppData > &soTSIF_Data, stream< TcpSessId > &soTSIF_SessId, stream< TcpDatLen > &soTSIF_DatLen)
Transmit Path - From THIS to TSIF.
Definition: tcp_app_flash.cpp:153
TRACE_RXP
#define TRACE_RXP
Definition: tcp_app_flash.cpp:64
pTcpRxPath
void pTcpRxPath(stream< TcpAppData > &siTSIF_Data, stream< TcpSessId > &siTSIF_SessId, stream< TcpDatLen > &siTSIF_DatLen, stream< TcpAppData > &soEPt_Data, stream< TcpSessId > &soEPt_SessId, stream< TcpDatLen > &soEPt_DatLen, stream< TcpAppData > &soESf_Data, stream< TcpSessId > &soESf_SessId, stream< TcpDatLen > &soESf_DatLen)
TCP Receive Path (RXp) - From SHELL->ROLE/TSIF to THIS.
Definition: tcp_app_flash.cpp:340
gTraceEvent
bool gTraceEvent
Definition: tb_nal.cpp:151
THIS_NAME
#define THIS_NAME
Definition: tcp_app_flash.cpp:60
tcp_app_flash
void tcp_app_flash(stream< TcpAppData > &siTSIF_Data, stream< TcpSessId > &siTSIF_SessId, stream< TcpDatLen > &siTSIF_DataLen, stream< TcpAppData > &soTSIF_Data, stream< TcpSessId > &soTSIF_SessId, stream< TcpDatLen > &soTSIF_DatLen)
Main process of the TCP Application Flash (TAF)
Definition: tcp_app_flash.cpp:581
DEBUG_LEVEL
#define DEBUG_LEVEL
Definition: tcp_app_flash.cpp:67
pTcpEchoStoreAndForward
void pTcpEchoStoreAndForward(stream< TcpAppData > &siRXp_Data, stream< TcpSessId > &siRXp_SessId, stream< TcpDatLen > &siRXp_DatLen, stream< TcpAppData > &soTXp_Data, stream< TcpSessId > &soTXp_SessId, stream< TcpDatLen > &soTXp_DatLen)
Echo Store and Forward (ESf)
Definition: tcp_app_flash.cpp:89
ECHO_STORE_FWD
@ ECHO_STORE_FWD
Definition: memtest.hpp:51
ECHO_OFF
@ ECHO_OFF
Definition: memtest.hpp:52
ECHO_PATH_THRU
@ ECHO_PATH_THRU
Definition: memtest.hpp:50
tcp_app_flash.hpp
: TCP Application Flash (TAF)