uwpolling_NODE.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 Uwpolling_HDR_NODE_H
#define Uwpolling_HDR_NODE_H
 
#include "mmac.h"
#include "uwpolling_cmn_hdr.h"
 
#include <chrono>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
 
#define UWPOLLING_NODE_DROP_REASON_BUFFER_FULL \
    "DBF" 
#define UWPOLLING_NODE_DROP_REASON_ERROR "DERR" 
#define UWPOLLING_NODE_DROP_REASON_UNKNOWN_TYPE \
    "DUT" 
#define UWPOLLING_NODE_DROP_REASON_WRONG_RECEIVER \
    "DWR" 
#define UWPOLLING_NODE_DROP_REASON_WRONG_STATE \
    "DWS" 
#define UWPOLLING_NODE_DROP_REASON_PACKET_NOT_FOR_ME \
    "DPNFM" 
#define UWPOLLING_NODE_DROP_REASON_IMINLIST_NOT_POLLED                    \
    "DPLNP" 
#define UWPOLLING_NODE_DROP_REASON_NOT_POLLED \
    "DNP" 
class Uwpolling_NODE : public MMac
{
public:
    Uwpolling_NODE();
    virtual ~Uwpolling_NODE();
    virtual int command(int argc, const char *const *argv);
    virtual int crLayCommand(ClMessage *m);
 
protected:
    enum UWPOLLING_NODE_STATUS {
        UWPOLLING_NODE_STATUS_IDLE = 1,
        UWPOLLING_NODE_STATUS_RX_TRIGGER,
        UWPOLLING_NODE_STATUS_TX_PROBE,
        UWPOLLING_NODE_STATUS_RX_POLL,
        UWPOLLING_NODE_STATUS_TX_DATA,
        UWPOLLING_NODE_STATUS_WAIT_POLL
    };
 
    enum UWPOLLING_PKT_TYPE {
        UWPOLLING_DATA_PKT = 1,
        UWPOLLING_POLL_PKT,
        UWPOLLING_TRIGGER_PKT,
        UWPOLLING_PROBE_PKT
    };
 
    enum UWPOLLING_NODE_REASON {
        UWPOLLING_NODE_REASON_TX_DATA,
        UWPOLLING_NODE_REASON_RX_TRIGGER,
        UWPOLLING_NODE_REASON_PKT_ERROR,
        UWPOLLING_NODE_REASON_TX_PROBE,
        UWPOLLING_NODE_REASON_RX_POLL,
        UWPOLLING_NODE_REASON_BACKOFF_TIMER_EXPIRED,
        UWPOLLING_NODE_REASON_RX_POLL_TIMER_EXPIRED,
        UWPOLLING_NODE_REASON_NOT_SET,
        UWPOLLING_NODE_REASON_EMPTY_DATA_QUEUE,
        UWPOLLING_NODE_REASON_WRONG_TYPE,
        UWPOLLING_NODE_REASON_WRONG_RECEIVER,
        UWPOLLING_NODE_REASON_WRONG_STATE,
        UWPOLLING_NODE_REASON_NOT_IN_LIST,
        UWPOLLING_NODE_REASON_LIST_NOT_POLLED
    };
 
    enum UWPOLLING_TIMER_STATUS {
        UWPOLLING_IDLE = 1,
        UWPOLLING_RUNNING,
        UWPOLLING_FROZEN,
        UWPOLLING_EXPIRED
    };
 
    class Uwpolling_NODE_Timer : public TimerHandler
    {
    public:
        Uwpolling_NODE_Timer(Uwpolling_NODE *m)
            : TimerHandler()
            , start_time(0.0)
            , left_duration(0.0)
            , counter(0)
            , module(m)
            , timer_status(UWPOLLING_IDLE)
        {
            assert(m != NULL);
        }
 
        virtual ~Uwpolling_NODE_Timer()
        {
        }
 
        virtual void
        freeze()
        {
            assert(timer_status == UWPOLLING_RUNNING);
            left_duration -= (NOW - start_time);
            if (left_duration <= 0.0) {
                left_duration = module->mac2phy_delay_;
            }
            force_cancel();
            timer_status = UWPOLLING_FROZEN;
        }
 
        virtual void
        unFreeze()
        {
            assert(timer_status == UWPOLLING_FROZEN);
            start_time = NOW;
            assert(left_duration > 0);
            sched(left_duration);
            timer_status = UWPOLLING_RUNNING;
        }
 
        virtual void
        stop()
        {
            timer_status = UWPOLLING_IDLE;
            force_cancel();
        }
 
        virtual void
        schedule(double val)
        {
            start_time = NOW;
            left_duration = val;
            timer_status = UWPOLLING_RUNNING;
            resched(val);
        }
 
        bool
        isIdle()
        {
            return (timer_status == UWPOLLING_IDLE);
        }
 
        bool
        isRunning()
        {
            return (timer_status == UWPOLLING_RUNNING);
        }
 
        bool
        isExpired()
        {
            return (timer_status == UWPOLLING_EXPIRED);
        }
 
        bool
        isFrozen()
        {
            return (timer_status == UWPOLLING_FROZEN);
        }
 
        bool
        isActive()
        {
            return (timer_status == UWPOLLING_FROZEN ||
                    timer_status == UWPOLLING_RUNNING);
        }
 
        void
        resetCounter()
        {
            counter = 0;
        }
 
        void
        incrCounter()
        {
            ++counter;
        }
 
        int
        getCounter()
        {
            return counter;
        }
 
        double
        getDuration()
        {
            return left_duration;
        }
 
    protected:
        double start_time; 
        double left_duration; 
        int counter; 
        Uwpolling_NODE
                *module; 
        UWPOLLING_TIMER_STATUS timer_status; 
    };
 
    class BackOffTimer : public Uwpolling_NODE_Timer
    {
    public:
        BackOffTimer(Uwpolling_NODE *m)
            : Uwpolling_NODE_Timer(m)
        {
        }
 
        virtual ~BackOffTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    class Rx_Poll_Timer : public Uwpolling_NODE_Timer
    {
    public:
        Rx_Poll_Timer(Uwpolling_NODE *m)
            : Uwpolling_NODE_Timer(m)
        {
        }
 
        virtual ~Rx_Poll_Timer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    class Tx_Data_Timer : public Uwpolling_NODE_Timer
    {
    public:
        Tx_Data_Timer(Uwpolling_NODE *m)
            : Uwpolling_NODE_Timer(m)
        {
        }
 
        virtual ~Tx_Data_Timer()
        {
        }
 
    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 void initPkt(UWPOLLING_PKT_TYPE pkt_type);
    virtual void initInfo();
 
    virtual void
    refreshReason(UWPOLLING_NODE_REASON reason)
    {
        last_reason = reason;
    }
 
    virtual void
    refreshState(UWPOLLING_NODE_STATUS state)
    {
        prev_state = curr_state;
        curr_state = state;
    }
 
    virtual void
    incrProbeSent()
    {
        n_probe_sent++;
    }
 
    virtual void
    incrTimesPolled()
    {
        n_times_polled++;
    }
 
    inline void
    incrTriggerReceived()
    {
        n_trigger_received++;
    }
 
    inline void
    incrTriggerDropped()
    {
        n_trigger_dropped++;
    }
 
    inline void
    incrPollDropped()
    {
        n_poll_dropped++;
    }
 
    inline void
    getDataQueueLog()
    {
        std::cout << getEpoch() << "::" << NOW << "::Uwpolling_NODE(" << addr
                  << ")::DATA_QUEUE_SIZE--> " << Q_data.size() << std::endl;
    }
 
    inline int
    getProbeSent()
    {
        return n_probe_sent;
    }
 
    inline int
    getTimesPolled()
    {
        return n_times_polled;
    }
 
    inline int
    getTriggerReceived()
    {
        return n_trigger_received;
    }
 
    inline int
    getTriggerDropped()
    {
        return n_trigger_dropped;
    }
 
    inline int
    getPollDropped()
    {
        return n_poll_dropped;
    }
    virtual void waitForUser();
    virtual void stateIdle();
    virtual void stateTxData();
    virtual void stateRxTrigger();
    virtual void stateTxProbe();
    virtual void stateRxPoll();
    virtual void BackOffTimerExpired();
    virtual void RxPollTimerExpired();
    virtual double getBackOffTime();
    virtual void TxData();
    virtual void TxPRobe();
    virtual void stateWaitPoll();
 
    inline unsigned long int
    getEpoch()
    {
        unsigned long int timestamp =
                (unsigned long int) (std::chrono::duration_cast<
                        std::chrono::milliseconds>(
                        std::chrono::system_clock::now().time_since_epoch())
                                .count());
        return timestamp;
    }
 
    /*************************
     * input values from TCL *
     *************************/
    double T_poll; 
    double T_poll_guard; 
    double backoff_tuner; 
    int max_payload; 
    int buffer_data_pkts; 
    int max_data_pkt_tx; 
    uint node_id; 
    int sea_trial; 
    int print_stats; 
    int n_run; /*< ID of the experiments (used during sea trial) */
    double Intra_data_Guard_Time; 
    std::queue<Packet *> Q_data; 
    static bool initialized; 
    bool polled; 
    bool RxPollEnabled; 
    bool Triggered; 
    bool LastPacket; 
    double MaxTimeStamp; 
    double T_in; 
    double T_fin; 
    double BOffTime; 
    int AUV_mac_addr; 
    int N_data_pkt_2_TX; 
    int packet_index; 
    uint n_probe_sent; 
    int n_times_polled; 
    int n_trigger_received; 
    uint N_polled_node; 
    uint PROBE_uid; 
    Packet *curr_data_pkt; 
    Packet *curr_probe_pkt; 
    Packet *curr_poll_pkt; 
    Packet *curr_trigger_pkt; 
    UWPOLLING_NODE_REASON
    last_reason; 
    UWPOLLING_NODE_STATUS curr_state; 
    UWPOLLING_NODE_STATUS prev_state; 
    static map<Uwpolling_NODE::UWPOLLING_NODE_STATUS, string>
            status_info; 
    static map<Uwpolling_NODE::UWPOLLING_NODE_REASON, string>
            reason_info; 
    static map<Uwpolling_NODE::UWPOLLING_PKT_TYPE, string>
            pkt_type_info; 
    BackOffTimer backoff_timer; 
    Rx_Poll_Timer rx_poll_timer; 
    Tx_Data_Timer tx_data_timer; 
    std::ofstream fout; 
    std::ofstream out_file_stats;
 
    int n_trigger_dropped; 
    int n_poll_dropped; 
    int useAdaptiveTpoll; 
};
#endif