state_table.cpp

Go to the documentation of this file.

 
 
 
#include "state_table.hpp"
 
using namespace hls;
 
 
#ifndef __SYNTHESIS__
  extern bool gTraceEvent;
#endif
 
#define THIS_NAME "TOE/STt"
 
#define TRACE_OFF  0x0000
#define TRACE_STT 1 <<  1
#define TRACE_ALL  0xFFFF
 
#define DEBUG_LEVEL (TRACE_OFF)
 
 
 
void state_table(
        stream<StateQuery>         &siRXe_SessStateQry,
        stream<TcpState>           &soRXe_SessStateRep,
        stream<StateQuery>         &siTAi_ConnectStateQry,
        stream<TcpState>           &soTAi_ConnectStateRep,
        stream<SessionId>          &siTAi_StreamStateReq,
        stream<TcpState>           &soTAi_StreamStateRep,
        stream<SessionId>          &siTIm_SessCloseCmd,
        stream<SessionId>          &soSLc_SessReleaseCmd)
{
    //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
    #pragma HLS PIPELINE II=1 enable_flush
    #pragma HLS INLINE off
 
    //-- STATIC ARRAYS ---------------------------------------------------------
    static TcpState                 SESS_STATE_TABLE[TOE_MAX_SESSIONS];
    #pragma HLS RESOURCE   variable=SESS_STATE_TABLE core=RAM_2P_BRAM
    #pragma HLS DEPENDENCE variable=SESS_STATE_TABLE inter false
 
    //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
    static bool                stt_rxWait=false;
    #pragma HLS RESET variable=stt_rxWait
    static bool                stt_txWait=false;
    #pragma HLS RESET variable=stt_txWait
    static bool                stt_rxSessionLocked=false;
    #pragma HLS RESET variable=stt_rxSessionLocked
    static bool                stt_txSessionLocked=false;
    #pragma HLS RESET variable=stt_txSessionLocked
    static bool                stt_closeWait=false;
    #pragma HLS RESET variable=stt_closeWait
 
    //-- STATIC DATAFLOW VARIABLES ---------------------------------------------
    static StateQuery   stt_txAccess;
    static StateQuery   stt_rxAccess;
    static SessionId    stt_txSessionID;
    static SessionId    stt_rxSessionID;
    static SessionId    stt_closeSessionID;
 
    if(!siTAi_ConnectStateQry.empty() && !stt_txWait) {
        //-------------------------------------------------
        //-- Request from TAi/Connect
        //-------------------------------------------------
        siTAi_ConnectStateQry.read(stt_txAccess);
        if ((stt_txAccess.sessionID == stt_rxSessionID) && stt_rxSessionLocked) {
            stt_txWait = true;
        }
        else {
            if (stt_txAccess.write) {
                SESS_STATE_TABLE[stt_txAccess.sessionID] = stt_txAccess.state;
                stt_txSessionLocked = false;
                if (DEBUG_LEVEL & TRACE_STT) {
                    printInfo(THIS_NAME, "TAi is requesting to set SESS_STATE_TABLE[%d] = %s.\n", \
                              stt_txAccess.sessionID.to_uint(), \
                              getTcpStateName(stt_txAccess.state));
                }
            }
            else {
                soTAi_ConnectStateRep.write(SESS_STATE_TABLE[stt_txAccess.sessionID]);
                // Lock on every read
                stt_txSessionID = stt_txAccess.sessionID;
                stt_txSessionLocked = true;
            }
        }
    }
    else if (!siTAi_StreamStateReq.empty()) {
        //-------------------------------------------------
        //-- Request from TAi/Stream
        //-------------------------------------------------
        SessionId sessionID;
        siTAi_StreamStateReq.read(sessionID);
        soTAi_StreamStateRep.write(SESS_STATE_TABLE[sessionID]);
    }
    else if(!siRXe_SessStateQry.empty() && !stt_rxWait) {
        //-------------------------------------------------
        //-- Request from RxEngine
        //-------------------------------------------------
        siRXe_SessStateQry.read(stt_rxAccess);
        if ((stt_rxAccess.sessionID == stt_txSessionID) && stt_txSessionLocked) {
            stt_rxWait = true;
        }
        else {
            if (stt_rxAccess.write) {
                if (stt_rxAccess.state == CLOSED) {
                    // [TODO] Do we need to check if already closed?
                    // [TODO] && state_table[stt_rxAccess.sessionID] != CLOSED)
                    soSLc_SessReleaseCmd.write(stt_rxAccess.sessionID);
                }
                SESS_STATE_TABLE[stt_rxAccess.sessionID] = stt_rxAccess.state;
                stt_rxSessionLocked = false;
                if (DEBUG_LEVEL & TRACE_STT) {
                    printInfo(THIS_NAME, "RXe is requesting to set SESS_STATE_TABLE[%d] = %s.\n", \
                              stt_rxAccess.sessionID.to_uint(), \
                              getTcpStateName(stt_rxAccess.state));
                }
            }
            else {
                soRXe_SessStateRep.write(SESS_STATE_TABLE[stt_rxAccess.sessionID]);
                stt_rxSessionID = stt_rxAccess.sessionID;
                stt_rxSessionLocked = true;
            }
        }
    }
    else if (!siTIm_SessCloseCmd.empty() && !stt_closeWait) {
        //-------------------------------------------------
        //-- Request to close connection from Timers
        //-------------------------------------------------
        siTIm_SessCloseCmd.read(stt_closeSessionID);
        if (((stt_closeSessionID == stt_rxSessionID) && stt_rxSessionLocked) || \
            ((stt_closeSessionID == stt_txSessionID) && stt_txSessionLocked)) {
            // The session is currently locked
            stt_closeWait = true;
        }
        else {
            SESS_STATE_TABLE[stt_closeSessionID] = CLOSED;
            soSLc_SessReleaseCmd.write(stt_closeSessionID);
            if (DEBUG_LEVEL & TRACE_STT) {
                printWarn(THIS_NAME, "TIm is requesting to close connection with SessId=%d.\n",
                        stt_closeSessionID.to_uint());
            }
        }
    }
    else if (stt_txWait) {
        //-------------------------------------------------
        //-- Tx Wait
        //-------------------------------------------------
        if ((stt_txAccess.sessionID != stt_rxSessionID) || !stt_rxSessionLocked) {
            if (stt_txAccess.write) {
                SESS_STATE_TABLE[stt_txAccess.sessionID] = stt_txAccess.state;
                stt_txSessionLocked = false;
            }
            else {
                soTAi_ConnectStateRep.write(SESS_STATE_TABLE[stt_txAccess.sessionID]);
                stt_txSessionID = stt_txAccess.sessionID;
                stt_txSessionLocked = true;
            }
            stt_txWait = false;
        }
    }
    else if (stt_rxWait) {
        //-------------------------------------------------
        //-- Rx Wait
        //-------------------------------------------------
        if ((stt_rxAccess.sessionID != stt_txSessionID) || !stt_txSessionLocked) {
            if (stt_rxAccess.write) {
                if (stt_rxAccess.state == CLOSED) {
                    soSLc_SessReleaseCmd.write(stt_rxAccess.sessionID);
                }
                SESS_STATE_TABLE[stt_rxAccess.sessionID] = stt_rxAccess.state;
                stt_rxSessionLocked = false;
            }
            else {
                soRXe_SessStateRep.write(SESS_STATE_TABLE[stt_rxAccess.sessionID]);
                stt_rxSessionID = stt_rxAccess.sessionID;
                stt_rxSessionLocked = true;
            }
            stt_rxWait = false;
        }
    }
    else if (stt_closeWait) {
        //-------------------------------------------------
        //-- Close Wait
        //-------------------------------------------------
        if (((stt_closeSessionID != stt_rxSessionID) || !stt_rxSessionLocked) && \
            ((stt_closeSessionID != stt_txSessionID) || !stt_txSessionLocked)) {
            SESS_STATE_TABLE[stt_closeSessionID] = CLOSED;
            soSLc_SessReleaseCmd.write(stt_closeSessionID);
            stt_closeWait = false;
        }
    }
}