uwsr.h

Go to the documentation of this file.

//
// Copyright (c) 2017 Regents of the SIGNET lab, University of Padova.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. Neither the name of the University of Padova (SIGNET lab) nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
 
#ifndef UWSR_H
#define UWSR_H
 
#include <mac.h>
#include <mmac.h>
#include <iostream>
#include <string>
#include <map>
#include <set>
#include <utility>
#include <fstream>
 
#include <mphy.h>
 
#define UWSR_DROP_REASON_WRONG_STATE "WST"
#define UWSR_DROP_REASON_WRONG_RECEIVER "WRCV"
#define UWSR_DROP_REASON_UNKNOWN_TYPE "UPT"
#define UWSR_DROP_REASON_BUFFER_FULL "DBF"
#define UWSR_DROP_REASON_ERROR "ERR"
 
extern packet_t PT_MMAC_ACK;
 
typedef int pktSeqNum;
typedef double txStartTime;
typedef int macAddress;
typedef int txRounds;
typedef pair<macAddress, pktSeqNum> usrPair;
typedef pair<double, double> rttPair;
typedef pair<int, int> txStatusPair;
 
class MMacUWSR : public MMac
{
 
public:
    MMacUWSR();
 
    virtual ~MMacUWSR();
 
    virtual int command(int argc, const char *const *argv);
 
protected:
    enum UWSR_STATUS {
        UWSR_STATE_IDLE = 1,
        UWSR_STATE_BACKOFF,
        UWSR_STATE_TX_DATA,
        UWSR_STATE_TX_ACK,
        UWSR_STATE_WAIT_ACK,
        UWSR_STATE_DATA_RX,
        UWSR_STATE_ACK_RX,
        UWSR_STATE_NOT_SET,
        UWSR_STATE_LISTEN,
        UWSR_STATE_CHK_ACK_TIMEOUT,
        UWSR_STATE_CHK_LISTEN_TIMEOUT,
        UWSR_STATE_CHK_BACKOFF_TIMEOUT,
        UWSR_STATE_RX_IDLE,
        UWSR_STATE_RX_LISTEN,
        UWSR_STATE_RX_BACKOFF,
        UWSR_STATE_RX_WAIT_ACK,
        UWSR_STATE_WRONG_PKT_RX,
        UWSR_STATE_WAIT_TX,
        UWSR_STATE_CHK_WAIT_TX_TIMEOUT,
        UWSR_STATE_WAIT_ACK_WAIT_TX,
        UWSR_STATE_RX_DATA_TX_DATA,
        UWSR_STATE_PRE_TX_DATA,
        UWSR_STATE_RX_IN_PRE_TX_DATA
    };
 
    enum UWSR_REASON_STATUS {
        UWSR_REASON_DATA_PENDING,
        UWSR_REASON_DATA_RX,
        UWSR_REASON_DATA_TX,
        UWSR_REASON_ACK_TX,
        UWSR_REASON_ACK_RX,
        UWSR_REASON_BACKOFF_TIMEOUT,
        UWSR_REASON_ACK_TIMEOUT,
        UWSR_REASON_DATA_EMPTY,
        UWSR_REASON_NOT_SET,
        UWSR_REASON_MAX_TX_TRIES,
        UWSR_REASON_BACKOFF_PENDING,
        UWSR_REASON_LISTEN,
        UWSR_REASON_LISTEN_TIMEOUT,
        UWSR_REASON_LISTEN_PENDING,
        UWSR_REASON_START_RX,
        UWSR_REASON_PKT_NOT_FOR_ME,
        UWSR_REASON_WAIT_ACK_PENDING,
        UWSR_REASON_PKT_ERROR,
        UWSR_REASON_WAIT_TX,
        UWSR_REASON_WAIT_TX_PENDING,
        UWSR_REASON_WAIT_TX_TIMEOUT
    };
 
    enum UWSR_PKT_TYPE { UWSR_ACK_PKT = 1, UWSR_DATA_PKT, UWSR_DATAMAX_PKT };
 
    enum UWSR_TIMER_STATUS {
        UWSR_IDLE = 1,
        UWSR_RUNNING,
        UWSR_FROZEN,
        UWSR_EXPIRED
    };
 
    enum CHECK_ACK_TIMER { CHECK_ACTIVE = 1, CHECK_EXPIRED, CHECK_IDLE };
 
    class UWSRTimer : public TimerHandler
    {
 
    public:
        UWSRTimer(MMacUWSR *m)
            : TimerHandler()
            , start_time(0.0)
            , left_duration(0.0)
            , counter(0)
            , module(m)
            , timer_status(UWSR_IDLE)
        {
            assert(m != NULL);
        }
 
        virtual ~UWSRTimer()
        {
        }
 
        virtual void
        freeze()
        {
            assert(timer_status == UWSR_RUNNING);
            left_duration -= (NOW - start_time);
            if (left_duration <= 0.0)
                left_duration = module->mac2phy_delay_;
            force_cancel();
            timer_status = UWSR_FROZEN;
        }
 
        virtual void
        unFreeze()
        {
            assert(timer_status == UWSR_FROZEN);
            start_time = NOW;
            assert(left_duration > 0);
            sched(left_duration);
            timer_status = UWSR_RUNNING;
        }
 
        virtual void
        stop()
        {
            timer_status = UWSR_IDLE;
            force_cancel();
        }
 
        virtual void
        schedule(double val)
        {
            start_time = NOW;
            left_duration = val;
            timer_status = UWSR_RUNNING;
            resched(val);
        }
 
        bool
        isIdle()
        {
            return (timer_status == UWSR_IDLE);
        }
 
        bool
        isRunning()
        {
            return (timer_status == UWSR_RUNNING);
        }
 
        bool
        isExpired()
        {
            return (timer_status == UWSR_EXPIRED);
        }
 
        bool
        isFrozen()
        {
            return (timer_status == UWSR_FROZEN);
        }
 
        bool
        isActive()
        {
            return (timer_status == UWSR_FROZEN ||
                    timer_status == UWSR_RUNNING);
        }
 
        void
        resetCounter()
        {
            counter = 0;
        }
 
        void
        incrCounter()
        {
            ++counter;
        }
 
        int
        getCounter()
        {
            return counter;
        }
 
        double
        getDuration()
        {
            return left_duration;
        }
 
        double
        leftDuration()
        {
            return NOW - start_time;
        }
 
    protected:
        double start_time; 
        double left_duration; 
        int counter; 
        MMacUWSR *module; 
        UWSR_TIMER_STATUS timer_status; 
    };
 
    class BackOffTimer : public UWSRTimer
    {
 
    public:
        BackOffTimer(MMacUWSR *m)
            : UWSRTimer(m)
        {
        }
 
        virtual ~BackOffTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    class AckTimer : public UWSRTimer
    {
 
    public:
        AckTimer(MMacUWSR *m)
            : UWSRTimer(m)
        {
        }
 
        virtual ~AckTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    class ListenTimer : public UWSRTimer
    {
 
    public:
        ListenTimer(MMacUWSR *m)
            : UWSRTimer(m)
        {
        }
 
        virtual ~ListenTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    class WaitTxTimer : public UWSRTimer
    {
 
    public:
        WaitTxTimer(MMacUWSR *m)
            : UWSRTimer(m)
        {
        }
 
        virtual ~WaitTxTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    virtual void recvFromUpperLayers(Packet *p);
 
    virtual void Mac2PhyStartTx(Packet *p);
 
    virtual void Phy2MacEndTx(const Packet *p);
 
    virtual void Phy2MacStartRx(const Packet *p);
 
    virtual void Phy2MacEndRx(Packet *p);
 
    virtual double computeTxTime(UWSR_PKT_TYPE type);
 
    virtual void initPkt(Packet *p, UWSR_PKT_TYPE pkt_type, int dest_addr = 0);
 
    virtual double getBackoffTime();
 
    inline void
    setBackoffCount()
    {
        backoff_count++;
    }
 
    inline int
    getBackoffCount()
    {
        return backoff_count;
    }
 
    virtual void statePreTxData();
 
    virtual void txAck(int dest_addr);
 
    virtual void stateIdle();
 
    virtual void stateRxIdle();
 
    virtual void stateTxData();
 
    virtual void stateTxAck(int dest_addr);
 
    virtual void stateBackoff();
 
    virtual void stateRxBackoff();
 
    virtual void stateWaitAck();
 
    virtual void stateRxinPreTxData();
 
    virtual void stateRxWaitAck();
 
    virtual void stateListen();
 
    virtual void stateRxListen();
 
    virtual void stateCheckListenExpired();
 
    virtual void stateCheckAckExpired();
 
    virtual void stateCheckBackoffExpired();
 
    virtual void stateCheckWaitTxExpired();
 
    virtual void stateRxData(Packet *p);
 
    virtual void stateRxAck(Packet *p);
 
    virtual void stateRxPacketNotForMe(Packet *p);
 
    virtual void printStateInfo(double delay = 0);
 
    virtual void initInfo();
 
    virtual void
    refreshState(UWSR_STATUS state)
    {
        prev_prev_state = prev_state;
        prev_state = curr_state;
        curr_state = state;
    }
 
    virtual void
    refreshReason(UWSR_REASON_STATUS reason)
    {
        last_reason = reason;
    }
 
    virtual void exitBackoff();
 
    virtual double
    getRTT()
    {
        return (rttsamples > 0) ? sumrtt / rttsamples : 0;
    }
 
    virtual void
    updateLastDataIdRx(int id)
    {
        last_data_id_rx = id;
    }
    virtual void waitForUser();
 
    // stats functions
    virtual int
    getRemainingPkts()
    {
        return (up_data_pkts_rx - mapPacket.size());
    }
 
    virtual void
    incrUpperDataRx()
    {
        up_data_pkts_rx++;
    }
 
    virtual int
    getPktSeqNum(Packet *p)
    {
        hdr_cmn *ch = hdr_cmn::access(p);
        return ch->uid();
    }
 
    virtual int
    getMacAddress(Packet *p)
    {
        hdr_mac *mach = HDR_MAC(p);
        return mach->macDA();
    }
 
 
    inline bool chkItemInmapTxRounds(int mac_addr, int seq_num);
 
    inline void
    setCurrTxRounds(int mac_addr, int seq_num)
    {
        curr_tx_rounds = 1;
        mapTxRounds.insert(
                make_pair(make_pair(mac_addr, seq_num), curr_tx_rounds));
    }
 
    inline void
    incrCurrTxRounds(int mac_addr, int seq_num)
    {
        map<usrPair, txRounds>::iterator it_t;
        it_t = mapTxRounds.find(make_pair(mac_addr, seq_num));
        (*it_t).second += 1;
    }
 
    inline int
    getCurrTxRounds(int mac_addr, int seq_num)
    {
        map<usrPair, txRounds>::iterator it_t;
        it_t = mapTxRounds.find(make_pair(mac_addr, seq_num));
        return ((*it_t).second);
    }
 
    inline void
    eraseItemFromTxRounds(int mac_addr, int seq_num)
    {
        map<usrPair, txRounds>::iterator it_t;
        it_t = mapTxRounds.find(make_pair(mac_addr, seq_num));
        mapTxRounds.erase((*it_t).first);
    }
 
 
    inline void
    putPktInQueue(Packet *p)
    {
        mapPacket.insert(
                make_pair(make_pair(getMacAddress(p), getPktSeqNum(p)), p));
    }
 
    inline void
    eraseItemFromPktQueue(int mac_addr, int seq_num)
    {
        map<usrPair, Packet *>::iterator it_p;
        it_p = mapPacket.find(make_pair(mac_addr, seq_num));
        Packet::free((*it_p).second);
        mapPacket.erase((*it_p).first);
    }
 
 
    inline void
    putAckTimerInMap(int mac_addr, int seq_num)
    {
        mapAckTimer.insert(make_pair(make_pair(mac_addr, seq_num), ack_timer));
    }
 
    inline void
    eraseItemFrommapAckTimer(int mac_addr, int seq_num)
    {
        map<usrPair, AckTimer>::iterator it_a;
        it_a = mapAckTimer.find(make_pair(mac_addr, seq_num));
        mapAckTimer.erase((*it_a).first);
    }
 
    inline void
    putStartTxTimeInMap(int mac_addr, int seq_num, double start_tx_time)
    {
        mapCalcAck.insert(
                make_pair(make_pair(mac_addr, seq_num), start_tx_time));
    }
 
    inline void
    eraseItemFrommapCalcAck(int mac_addr, int seq_num)
    {
        map<usrPair, txStartTime>::iterator it_ca;
        it_ca = mapCalcAck.find(make_pair(mac_addr, seq_num));
        mapCalcAck.erase((*it_ca).first);
    }
 
    virtual int checkAckTimer(CHECK_ACK_TIMER type);
 
    virtual void eraseExpiredItemsFrommapAckandCalc();
 
    virtual bool checkMultipleTx(int rcv_mac_addr);
 
    virtual int getPktsCanSendIn1RTT(int mac_addr);
 
    virtual void putRTTInMap(int mac_addr, double rtt);
 
    inline double
    getRTTInMap(int mac_addr)
    {
        map<macAddress, rttPair>::iterator it_d;
        it_d = mapRTT.find(mac_addr);
        return (it_d->second).first;
    }
 
    inline void
    incrPktsSentIn1RTT()
    {
        pkts_sent_1RTT++;
    }
 
    inline void
    rstPktsSentIn1RTT()
    {
        pkts_sent_1RTT = 0;
    }
 
    inline int
    getPktsSentIn1RTT()
    {
        return pkts_sent_1RTT;
    }
 
    inline void
    incrAcksRcvIn1RTT()
    {
        acks_rcv_1RTT++;
    }
 
    inline void
    rstAcksRcvIn1RTT()
    {
        acks_rcv_1RTT = 0;
    }
 
    inline int
    getAcksRcvIn1RTT()
    {
        return acks_rcv_1RTT;
    }
 
    inline void
    incrPktsLostCount()
    {
        pkts_lost_counter++;
    }
 
    inline void
    rstPktsLostCount()
    {
        pkts_lost_counter = 0;
    }
 
    inline int
    getPktsLostCount()
    {
        return pkts_lost_counter;
    }
 
    virtual bool prepBeforeTx(int mac_addr, int seq_num);
 
    virtual double calcWaitTxTime(int mac_addr);
 
    inline void updateTxStatus(macAddress mac_addr, int rcv_acks);
 
    virtual int calWindowSize(macAddress mac_addr);
 
    inline void
    calTotalPktsTx()
    {
        hit_count++;
        total_pkts_tx = total_pkts_tx + getPktsSentIn1RTT();
    }
 
    inline double
    getAvgPktsTxIn1RTT()
    {
        double x = (double) total_pkts_tx / (double) hit_count;
        return x;
    }
 
    int max_tx_tries; 
    double backoff_tuner; 
    double wait_constant; 
    int max_payload; 
    int HDR_size; 
    int ACK_size; 
    double ACK_timeout; 
    int buffer_pkts; 
    double alpha_; 
    double max_backoff_counter; 
    double listen_time; 
    double guard_time; 
    double node_speed; 
    double var_k; 
    int uwsr_debug; 
 
    static bool initialized; 
    static const double prop_speed; 
    int last_sent_data_id; 
    bool print_transitions; 
    bool
            has_buffer_queue; 
    double start_tx_time; 
    double srtt; 
    double sumrtt; 
    double sumrtt2; 
    int rttsamples; 
    int curr_tx_rounds; 
    int last_data_id_rx; 
    int recv_data_id; 
    int backoff_count; 
    int pkt_tx_count; 
    Packet *curr_data_pkt; 
    double round_trip_time; 
    double wait_tx_time; 
    double sumwtt; 
    int wttsamples; 
    int pkts_sent_1RTT; 
    int
            acks_rcv_1RTT; 
    int pkts_lost_counter; 
    int window_size; 
    int txsn; 
    double
            latest_ack_timeout; 
    int prv_mac_addr; 
    int
            hit_count; 
    int total_pkts_tx; 
    AckTimer ack_timer; 
    BackOffTimer backoff_timer; 
    ListenTimer listen_timer; 
    WaitTxTimer wait_tx_timer; 
    UWSR_REASON_STATUS last_reason; 
    UWSR_STATUS
            curr_state; 
    UWSR_STATUS
            prev_state; 
    UWSR_STATUS prev_prev_state; 
    static map<UWSR_STATUS, string>
            status_info; 
    static map<UWSR_REASON_STATUS, string>
            reason_info; 
    static map<UWSR_PKT_TYPE, string>
            pkt_type_info; 
    map<usrPair, Packet *>
            mapPacket; 
    map<usrPair, txRounds> mapTxRounds; 
    map<usrPair, AckTimer> mapAckTimer; 
    map<usrPair, txStartTime> mapCalcAck; 
    map<macAddress, rttPair> mapRTT; 
    map<macAddress, txStatusPair> mapTxStatus; 
    ofstream fout; 
};
 
#endif /* UWSR_H */