uw-mac-DACAP-alter.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 MMAC_UW_DACAP_H
#define MMAC_UW_DACAP_H
 
#include <fstream>
#include <iostream>
#include <map>
#include <mmac.h>
#include <mphy.h>
#include <queue>
#include <string>
 
#define HDR_DACAP(P) (hdr_dacap::access(P))
 
#define DACAP_DROP_REASON_WRONG_STATE                                        \
    "WST" 
#define DACAP_DROP_REASON_WRONG_RECEIVER \
    "WRCV" 
#define DACAP_DROP_REASON_UNKNOWN_TYPE \
    "UPT" 
#define DACAP_DROP_REASON_BUFFER_FULL \
    "DBF" 
extern packet_t PT_DACAP;
 
typedef struct hdr_dacap {
 
    double ts; 
    int sn; 
    int dacap_type; 
    packet_t orig_type; 
    int data_sn; 
    int tx_tries; 
    static int offset_; 
    inline static int &
    offset()
    {
        return offset_;
    }
    inline static struct hdr_dacap *
    access(const Packet *p)
    {
        return (struct hdr_dacap *) p->access(offset_);
    }
 
} hdr_dacap;
 
class MMacDACAP;
 
class DACAPTimer : public TimerHandler
{
 
public:
    DACAPTimer(MMacDACAP *m)
        : TimerHandler()
    {
        module = m;
    }
 
protected:
    virtual void expire(Event *e);
    MMacDACAP *module; 
    int wait_reason; 
};
class DACAPBTimer : public TimerHandler
{
public:
    DACAPBTimer(MMacDACAP *m)
        : TimerHandler()
    {
        module = m;
    }
 
protected:
    virtual void expire(Event *e);
    MMacDACAP *module; 
    int wait_reason; 
};
 
class MMacDACAP : public MMac
{
    friend class DACAPTimer; 
    friend class DACAPBTimer; 
public:
    MMacDACAP();
    virtual ~MMacDACAP();
    virtual int command(int argc, const char *const *argv);
    virtual int crLayCommand(ClMessage *m);
 
protected:
    /***********************************
     | Internal variable and functions |
     ***********************************/
    virtual void recvFromUpperLayers(Packet *p);
 
    virtual void Phy2MacEndTx(const Packet *p);
    virtual void Phy2MacStartRx(const Packet *p);
    virtual void Phy2MacEndRx(Packet *p);
    virtual double computeWaitTime(int mode, double distance);
    virtual double computeTxTime(int type);
    virtual void initPkt(Packet *p, int pkt_type);
    virtual double getBackoffTime();
    virtual double getRecontendTime();
    virtual void txAck();
    virtual void txData();
    virtual void txRts();
    virtual void txCts();
    virtual void txWrn();
    virtual void rxStateIdle(Packet *p);
    virtual void rxStateBackoff(Packet *p);
    virtual void rxStateWaitCTS(Packet *p);
    virtual void rxStateWaitACK(Packet *p);
    virtual void rxStateWaitData(Packet *p);
    virtual void rxStateWaitXCts(Packet *p);
    virtual void rxStateWaitXData(Packet *p);
    virtual void rxStateWaitXAck(Packet *p);
    virtual void rxStateWaitXWarning(Packet *p);
    virtual void rxStateWaitWarning(Packet *p);
    virtual void rxStateSendWarning(Packet *p);
    virtual void rxStateRecontendWindow(Packet *p);
    virtual void stateIdle();
    virtual void stateSendRTS();
    virtual void stateBackoff();
    virtual void stateWaitCTS();
    virtual void stateDeferData();
    virtual void stateSendData();
    virtual void stateWaitACK();
    virtual void stateCTSReceived();
    virtual void stateWaitData();
    virtual void stateDataReceived(Packet *data_pkt);
    virtual void stateWaitXCts();
    virtual void stateWaitXData();
    virtual void stateWaitXAck();
    virtual void stateWaitXWarning();
    virtual void stateSendAck();
    virtual void stateSendCTS();
    virtual void stateWaitWarning();
    virtual void stateSendWarning();
    virtual void stateRecontendWindow();
    virtual void printStateInfo(double delay = 0);
    virtual void initInfo();
    virtual void
    refreshState(int state)
    {
        prev_state = curr_state;
        curr_state = state;
    }
    virtual void setBackoffNodes(double node, double node_b);
    virtual void exitBackoff();
    virtual void exitSleep();
    virtual void freezeBackoff();
    virtual int
    getQueueSize()
    {
        return Q.size();
    }
    virtual void
    queuePop(bool flag = true)
    {
        Packet::free(Q.front());
        Q.pop();
        waitEndTime(flag);
    }
    virtual void waitForUser();
 
    /*******************
     * stats functions *
     ******************/
 
    inline int
    getUpLayersDataPktsRx()
    {
        return up_data_pkts_rx;
    }
 
    virtual void
    incrWrnPktsTx()
    {
        wrn_pkts_tx++;
    }
    virtual void
    incrWrnPktsRx()
    {
        wrn_pkts_rx++;
    }
    virtual void
    incrRtsPktsTx()
    {
        rts_pkts_tx++;
    }
    virtual void
    incrRtsPktsRx()
    {
        rts_pkts_rx++;
    }
    virtual void
    incrCtsPktsTx()
    {
        cts_pkts_tx++;
    }
    virtual void
    incrCtsPktsRx()
    {
        cts_pkts_rx++;
    }
    virtual void
    incrTotalDeferTimes()
    {
        defer_times_no++;
    }
    virtual void
    resetStats()
    {
        wrn_pkts_tx = 0;
        wrn_pkts_rx = 0;
        defer_times_no = 0;
        return MMac::resetStats();
    }
    virtual int
    getRemainingPkts()
    {
        return (up_data_pkts_rx - Q.size());
    }
    virtual int
    getWrnPktsTx()
    {
        return wrn_pkts_tx;
    }
    virtual int
    getWrnPktsRx()
    {
        return wrn_pkts_rx;
    }
    virtual int
    getRtsPktsTx()
    {
        return rts_pkts_tx;
    }
    virtual int
    getRtsPktsRx()
    {
        return rts_pkts_rx;
    }
    virtual int
    getCtsPktsTx()
    {
        return cts_pkts_tx;
    }
    virtual int
    getCtsPktsRx()
    {
        return cts_pkts_rx;
    }
    virtual int
    getTotalDeferTimes()
    {
        return defer_times_no;
    }
    virtual void
    backoffStartTime()
    {
        backoff_first_start = NOW;
    }
    virtual void
    deferEndTime(double duration)
    {
        sum_defer_time += duration;
    }
    virtual void
    backoffEndTime()
    {
        double duration = NOW - backoff_first_start;
        backoffSumDuration(duration);
    }
    virtual double
    getMeanDeferTime()
    {
        if (defer_times_no > 0)
            return (sum_defer_time / defer_times_no);
        else
            return (0.0);
    }
 
    int wrn_pkts_tx; 
    int wrn_pkts_rx; 
    int rts_pkts_tx; 
    int rts_pkts_rx; 
    int cts_pkts_tx; 
    int cts_pkts_rx; 
    double defer_times_no; 
    double sum_defer_time; 
    double start_tx_time; 
    double srtt; 
    double sumrtt; 
    double sumrtt2; 
    int rttsamples; 
    std::queue<Packet *> Q; 
    bool TxActive; 
    bool RxActive; 
    bool defer_data; 
    bool session_active; 
    bool backoff_pending; 
    bool warning_sent; 
    bool backoff_freeze_mode; 
    bool print_transitions; 
    bool has_buffer_queue; 
    bool multihop_mode; 
    int sleep_node_1; 
    int sleep_node_2; 
    int last_reason; 
    double t_min; 
    double T_W_min; 
    double delta_D; 
    double delta_data; 
    double max_prop_delay; 
    int op_mode; 
    double max_tx_tries; 
    int buffer_pkts; 
    double backoff_tuner; 
    double wait_costant; 
    int max_payload; 
    double max_backoff_counter; 
    double alpha_; 
    int curr_dest_addr; 
    int CTS_size; 
    int RTS_size; 
    int WRN_size; 
    int HDR_size; 
    int ACK_size; 
    int curr_state; 
    int prev_state; 
    double RTS_sent_time; 
    double session_distance; 
    double backoff_start_time; 
    double backoff_duration; 
    double backoff_remaining; 
    double backoff_first_start; 
    Packet *curr_data_pkt; 
    int last_data_id_tx; 
    int last_data_id_rx; 
    static int u_pkt_id; 
    int u_data_id; 
    DACAPTimer timer; 
    DACAPBTimer backoff_timer; 
    int txsn; 
    int backoff_counter; 
    static map<int, string> info; 
    ofstream fout; 
};
 
#endif /* MMAC_UW_DACAP_H */