test_session_lookup_controller.cpp File Reference

#include "session_lookup_controller.hpp"
#include <map>

Include dependency graph for test_session_lookup_controller.cpp:

Go to the source code of this file.

Functions
void	sessionLookupStub (stream< rtlSessionLookupRequest > &lup_req, stream< rtlSessionLookupReply > &lup_rsp, stream< rtlSessionUpdateRequest > &upd_req, stream< rtlSessionUpdateReply > &upd_rsp)
void	updateRequestMerger (stream< rtlSessionUpdateRequest > &in1, stream< rtlSessionUpdateRequest > &in2, stream< rtlSessionUpdateRequest > &out)
int	main ()

Function Documentation

main()

int main

(

)

Definition at line 120 of file test_session_lookup_controller.cpp.

{
    stream<sessionLookupQuery>          rxEng2sLookup_req;
    stream<sessionLookupReply>          sLookup2rxEng_rsp("sLookup2rxEng_rsp");
    stream<ap_uint<16> >                stateTable2sLookup_releaseSession;
    stream<ap_uint<16> >                sLookup2portTable_releasePort;
    stream<fourTuple>                   txApp2sLookup_req;
    stream<sessionLookupReply>          sLookup2txApp_rsp;
    stream<ap_uint<16> >                txEng2sLookup_rev_req;
    stream<fourTuple>                   sLookup2txEng_rev_rsp;
    stream<rtlSessionLookupRequest>     sessionLookup_req;
    stream<rtlSessionLookupReply>       sessionLookup_rsp("test_sessionLookup_rsp");
    stream<rtlSessionUpdateRequest>     sessionUpdate_req;
    stream<rtlSessionUpdateReply>       sessionUpdate_rsp("test_sessionUpdate_rsp");
 
    stream<rtlSessionUpdateRequest>     sessionInsert_req;
    stream<rtlSessionUpdateRequest>     sessionDelete_req;
 
 
 
    //stream<sessionLookupQueryInternal> lookups("lookups");
 
    ap_uint<16> regSessionCount;
 
    int count = 0;
    fourTuple tuple;
    tuple.dstIp = 0x01010101;
    tuple.dstPort = 7;
    tuple.srcIp = 0x0101010a;
    tuple.srcPort = 3489;
 
    int lastSessionCount = 0;
    while (count < 500)
    {
        if (count == 20)
        {
            rxEng2sLookup_req.write(sessionLookupQuery(tuple, false));
        }
 
        if (count == 70)
        {
            rxEng2sLookup_req.write(sessionLookupQuery(tuple, true));
        }
 
        if (count == 80)
        {
            txEng2sLookup_rev_req.write(0);
        }
 
        if (count == 90)
        {
            txApp2sLookup_req.write(tuple);
        }
        session_lookup_controller(  //lookups,
                                    rxEng2sLookup_req,
                                    sLookup2rxEng_rsp,
                                    stateTable2sLookup_releaseSession,
                                    sLookup2portTable_releasePort,
                                    txApp2sLookup_req,
                                    sLookup2txApp_rsp,
                                    txEng2sLookup_rev_req,
                                    sLookup2txEng_rev_rsp,
                                    sessionLookup_req,
                                    sessionLookup_rsp,
                                    sessionUpdate_req,
                                    //sessionInsert_req,
                                    //sessionDelete_req,
                                    sessionUpdate_rsp,
                                    regSessionCount);
        //lookupRequestMerger(rxEng2sLookup_req, txApp2sLookup_req, sessionLookup_req, lookups);
        //updateRequestMerger(sessionInsert_req, sessionDelete_req, sessionUpdate_req);
        if ( lastSessionCount != regSessionCount)
        {
            std::cout << "SessionCount\t" << regSessionCount << std::endl;
            lastSessionCount = regSessionCount;
        }
        sessionLookupStub(sessionLookup_req, sessionLookup_rsp, sessionUpdate_req, sessionUpdate_rsp);
        count++;
    }
 
    sessionLookupReply reply;
    while (!sLookup2rxEng_rsp.empty())
    {
        sLookup2rxEng_rsp.read(reply);
        std::cout << "rxEng "<< reply.sessionID << "\t" << reply.hit << std::endl;
    }
    while (!sLookup2txApp_rsp.empty())
    {
        sLookup2txApp_rsp.read(reply);
        std::cout << "txApp "<< reply.sessionID << "\t" << reply.hit << std::endl;
    }
    while (!sLookup2txEng_rev_rsp.empty())
    {
        sLookup2txEng_rev_rsp.read(tuple);
        std::cout << "txEng " << tuple.dstIp << ":" << tuple.dstPort << "\t " << tuple.srcIp << ":" << tuple.srcPort << std::endl;
    }
 
    return 0;
}

Here is the call graph for this function:

sessionLookupStub()

void sessionLookupStub	(	stream< rtlSessionLookupRequest > &	lup_req,
		stream< rtlSessionLookupReply > &	lup_rsp,
		stream< rtlSessionUpdateRequest > &	upd_req,
		stream< rtlSessionUpdateReply > &	upd_rsp
	)

Definition at line 32 of file test_session_lookup_controller.cpp.

{
    static std::map<fourTupleInternal, ap_uint<14> > lookupTable;
 
    rtlSessionLookupRequest request;
    rtlSessionUpdateRequest update;
 
    std::map<fourTupleInternal, ap_uint<14> >::const_iterator findPos;
 
    if (!lup_req.empty())
    {
        lup_req.read(request);
        findPos = lookupTable.find(request.key);
        if (findPos != lookupTable.end()) //hit
        {
            lup_rsp.write(rtlSessionLookupReply(true, findPos->second, request.source));
        }
        else
        {
            lup_rsp.write(rtlSessionLookupReply(false, request.source));
        }
    }
 
    if (!upd_req.empty()) //TODO what if element does not exist
    {
        upd_req.read(update);
        if (update.op == INSERT) //Is there a check if it already exists?
        {
            // Read free id
            //new_id.read(update.value);
            lookupTable[update.key] = update.value;
            upd_rsp.write(rtlSessionUpdateReply(update.value, INSERT, update.source));
 
        }
        else // DELETE
        {
            //fin_id.write(update.value);
            lookupTable.erase(update.key);
            upd_rsp.write(rtlSessionUpdateReply(update.value, DELETE, update.source));
        }
    }
}

Here is the caller graph for this function:

updateRequestMerger()

void updateRequestMerger	(	stream< rtlSessionUpdateRequest > &	in1,
		stream< rtlSessionUpdateRequest > &	in2,
		stream< rtlSessionUpdateRequest > &	out
	)

Definition at line 108 of file test_session_lookup_controller.cpp.

{
    if (!in1.empty())
    {
        out.write(in1.read());
    }
    else if (!in2.empty())
    {
        out.write(in2.read());
    }
}