uw-smart-ofdm.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 UWSMARTOFDM_H_
#define UWSMARTOFDM_H_
 
#include "uwofdmmac_hdr.h"
#include "uwofdmphy.h"
#include "uwofdmphy_hdr.h"
#include <array>
#include <atomic>
#include <clmessage.h>
#include <fstream>
#include <iostream>
#include <map>
#include <mmac.h>
#include <mphy.h>
#include <mutex>
#include <queue>
#include <set>
#include <string>
 
#include "msg-display.h"
 
#define UWSMARTOFDM_DROP_REASON_WRONG_STATE "WST"
#define UWSMARTOFDM_DROP_REASON_WRONG_RECEIVER "WRCV"
#define UWSMARTOFDM_DROP_REASON_UNKNOWN_TYPE "UPT"
#define UWSMARTOFDM_DROP_REASON_BUFFER_FULL "DBF"
#define UWSMARTOFDM_DROP_REASON_ERROR "ERR"
 
extern packet_t PT_MMAC_ACK;
extern packet_t PT_MMAC_CTS;
extern packet_t PT_MMAC_DATA;
extern packet_t PT_MMAC_RTS;
 
// Types of MAC frames that can be used
// enum MacFrameType {
//  MF_BEACON   = 0x0008, // beaconing
//  MF_CONTROL  = 0x0010, // used as mask for control frame
//  MF_SLOTS    = 0x001a, // announce slots open for contention
//  MF_RTS      = 0x001b, // request to send
//  MF_CTS      = 0x001c, // clear to send, grant
//  MF_ACK      = 0x001d, // acknowledgement
//  MF_CF_END   = 0x001e, // contention free period end
//  MF_POLL     = 0x001f, // polling
//  MF_DATA     = 0x0020, // also used as mask for data frame
//  MF_DATA_ACK = 0x0021  // ack for data frames
// };
 
typedef int pktSeqNum;
enum criticalLevel { LOW = 0, HIGH = 1 };
 
class UWSmartOFDM : public MMac
{
 
public:
    UWSmartOFDM();
 
    virtual ~UWSmartOFDM();
 
    virtual int command(int argc, const char *const *argv);
 
    // Initialize subCarriers parameters inside a node, default all carriers are
    // used
    void init_macofdm_node(int subCarNum, double carSize, int ctrl_subCar,
            std::string modulation);
 
protected:
    enum UWSMARTOFDM_STATUS {
        UWSMARTOFDM_STATE_IDLE = 1,
        UWSMARTOFDM_STATE_BACKOFF,
        UWSMARTOFDM_STATE_TX_DATA,
        UWSMARTOFDM_STATE_TX_ACK,
        UWSMARTOFDM_STATE_WAIT_ACK,
        UWSMARTOFDM_STATE_DATA_RX,
        UWSMARTOFDM_STATE_ACK_RX,
        UWSMARTOFDM_STATE_NOT_SET,
        UWSMARTOFDM_STATE_CHK_ACK_TIMEOUT,
        UWSMARTOFDM_STATE_RX_IDLE,
        UWSMARTOFDM_STATE_RX_WAIT_ACK,
        UWSMARTOFDM_STATE_CHK_BACKOFF_TIMEOUT,
        UWSMARTOFDM_STATE_RX_BACKOFF,
        UWSMARTOFDM_STATE_WRONG_PKT_RX,
        UWSMARTOFDM_STATE_TX_RTS,
        UWSMARTOFDM_STATE_RX_RTS,
        UWSMARTOFDM_STATE_WAIT_CTS,
        UWSMARTOFDM_STATE_CTRL_BACKOFF,
        UWSMARTOFDM_STATE_CHK_CTS_BACKOFF_TIMEOUT,
        UWSMARTOFDM_STATE_TX_CTS,
        UWSMARTOFDM_STATE_RX_CTS,
        UWSMARTOFDM_STATE_RX_ACTIVE,
        UWSMARTOFDM_STATE_TX_ACTIVE,
        UWSMARTOFDM_STATE_WAIT_DATA
    };
 
    enum UWSMARTOFDM_REASON_STATUS {
        UWSMARTOFDM_REASON_DATA_PENDING,
        UWSMARTOFDM_REASON_DATA_NOCAR,
        UWSMARTOFDM_REASON_DATA_CARASSIGNED,
        UWSMARTOFDM_REASON_DATA_RX,
        UWSMARTOFDM_REASON_DATA_TX,
        UWSMARTOFDM_REASON_ACK_TX,
        UWSMARTOFDM_REASON_ACK_RX,
        UWSMARTOFDM_REASON_ACK_TIMEOUT,
        UWSMARTOFDM_REASON_DATA_EMPTY,
        UWSMARTOFDM_REASON_NOT_SET,
        UWSMARTOFDM_REASON_MAX_TX_TRIES,
        UWSMARTOFDM_REASON_START_RX,
        UWSMARTOFDM_REASON_PKT_NOT_FOR_ME,
        UWSMARTOFDM_REASON_WAIT_ACK_PENDING,
        UWSMARTOFDM_REASON_PKT_ERROR,
        UWSMARTOFDM_REASON_BACKOFF_TIMEOUT,
        UWSMARTOFDM_REASON_BACKOFF_PENDING,
        UWSMARTOFDM_REASON_WAIT_CTS_PENDING,
        UWSMARTOFDM_REASON_CTS_TX,
        UWSMARTOFDM_REASON_RTS_TX,
        UWSMARTOFDM_REASON_CTS_RX,
        UWSMARTOFDM_REASON_RTS_RX,
        UWSMARTOFDM_REASON_CTS_BACKOFF_TIMEOUT,
        UWSMARTOFDM_REASON_PHY_LAYER_RECEIVING,
        UWSMARTOFDM_REASON_PHY_LAYER_SENDING,
        UWSMARTOFDM_REASON_MAX_RTS_TRIES,
        UWSMARTOFDM_REASON_WAIT_DATA,
        UWSMARTOFDM_REASON_DATAT_EXPIRED,
        UWSMARTOFDM_REASON_PREVIOUS_RTS
    };
 
    enum UWSMARTOFDM_PKT_TYPE {
        UWSMARTOFDM_ACK_PKT = 1,
        UWSMARTOFDM_DATA_PKT,
        UWSMARTOFDM_DATAMAX_PKT,
        UWSMARTOFDM_RTS_PKT,
        UWSMARTOFDM_CTS_PKT
 
    };
 
    enum UWSMARTOFDM_ACK_MODES {
        UWSMARTOFDM_ACK_MODE = 1,
        UWSMARTOFDM_NO_ACK_MODE
    };
 
    enum UWSMARTOFDM_TIMER_STATUS {
        UWSMARTOFDM_IDLE = 1,
        UWSMARTOFDM_RUNNING,
        UWSMARTOFDM_FROZEN,
        UWSMARTOFDM_EXPIRED
    };
 
    class UWSmartOFDMTimer : public TimerHandler
    {
 
    public:
        UWSmartOFDMTimer(UWSmartOFDM *m)
            : TimerHandler()
            , start_time(0.0)
            , left_duration(0.0)
            , counter(0)
            , module(m)
            , timer_status(UWSMARTOFDM_IDLE)
        {
            assert(m != NULL);
        }
 
        virtual ~UWSmartOFDMTimer()
        {
        }
 
        virtual double
        startTime()
        {
            return start_time;
        }
 
        virtual void
        freeze()
        {
            assert(timer_status == UWSMARTOFDM_RUNNING);
            left_duration -= (NOW - start_time);
            if (left_duration <= 0.0)
                left_duration = module->mac2phy_delay_;
            force_cancel();
            timer_status = UWSMARTOFDM_FROZEN;
        }
        virtual void
        unFreeze()
        {
            assert(timer_status == UWSMARTOFDM_FROZEN);
            start_time = NOW;
            assert(left_duration > 0);
            sched(left_duration);
            timer_status = UWSMARTOFDM_RUNNING;
        }
 
        virtual void
        stop()
        {
            timer_status = UWSMARTOFDM_IDLE;
            force_cancel();
        }
 
        virtual void
        schedule(double val)
        {
            start_time = NOW;
            left_duration = val;
            timer_status = UWSMARTOFDM_RUNNING;
            resched(val);
        }
 
        bool
        isIdle()
        {
            return (timer_status == UWSMARTOFDM_IDLE);
        }
 
        bool
        isRunning()
        {
            return (timer_status == UWSMARTOFDM_RUNNING);
        }
 
        bool
        isExpired()
        {
            return (timer_status == UWSMARTOFDM_EXPIRED);
        }
 
        bool
        isFrozen()
        {
            return (timer_status == UWSMARTOFDM_FROZEN);
        }
 
        bool
        isActive()
        {
            return (timer_status == UWSMARTOFDM_FROZEN ||
                    timer_status == UWSMARTOFDM_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; 
        UWSmartOFDM *module; 
        UWSMARTOFDM_TIMER_STATUS
                timer_status; 
    };
 
    class AckTimer : public UWSmartOFDMTimer
    {
 
    public:
        AckTimer(UWSmartOFDM *m)
            : UWSmartOFDMTimer(m)
        {
        }
 
        virtual ~AckTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    class BackOffTimer : public UWSmartOFDMTimer
    {
 
    public:
        BackOffTimer(UWSmartOFDM *m)
            : UWSmartOFDMTimer(m)
        {
        }
 
        virtual ~BackOffTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    class CTSTimer : public UWSmartOFDMTimer
    {
 
    public:
        CTSTimer(UWSmartOFDM *m)
            : UWSmartOFDMTimer(m)
        {
        }
 
        virtual ~CTSTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
    class RTSTimer : public UWSmartOFDMTimer
    {
 
    public:
        RTSTimer(UWSmartOFDM *m)
            : UWSmartOFDMTimer(m)
        {
        }
 
        virtual ~RTSTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    class AssignmentTimer : public UWSmartOFDMTimer
    {
 
    public:
        AssignmentTimer(UWSmartOFDM *m)
            : UWSmartOFDMTimer(m)
        {
        }
 
        virtual ~AssignmentTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    class AssignmentValidTimer : public UWSmartOFDMTimer
    {
 
    public:
        AssignmentValidTimer(UWSmartOFDM *m)
            : UWSmartOFDMTimer(m)
        {
        }
 
        virtual ~AssignmentValidTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    /* Base class of DATATimer. It is derived class of UWSmartOFDMTimer.
     * waits for DATA after CTS
     */
    class DATATimer : public UWSmartOFDMTimer
    {
 
    public:
        DATATimer(UWSmartOFDM *m)
            : UWSmartOFDMTimer(m)
        {
        }
 
        virtual ~DATATimer()
        {
        }
 
    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(UWSMARTOFDM_PKT_TYPE type);
 
    virtual void initPkt(
            Packet *p, UWSMARTOFDM_PKT_TYPE pkt_type, int dest_addr = 0);
 
    virtual double getBackoffTime();
 
    virtual void txData();
 
    virtual void txAck(int dest_addr);
 
    virtual void txRTS();
 
    virtual void txCTS(int dest_addr, int *rcv_car, int bytesToSend);
 
    virtual void stateIdle();
 
    virtual void stateSendRTS();
 
    virtual void stateSendCTS(Packet *p);
 
    virtual void stateWaitCTS();
 
    virtual void stateBackoffCTS();
 
    virtual void stateRxIdle();
 
    virtual void stateTxData();
 
    virtual void stateTxAck(int dest_addr);
 
    virtual void stateWaitAck();
 
    virtual void stateRxWaitAck();
 
    virtual void stateBackoff(double bt = 0);
 
    virtual void stateRxBackoff();
 
    virtual void stateCheckAckExpired();
 
    virtual void stateCheckBackoffExpired();
 
    virtual void stateCheckCTSBackoffExpired();
 
    virtual void stateRxData(Packet *p);
 
    virtual void stateRxAck(Packet *p);
 
    /* The node comes to this state if it receives an <i>RTS</i> packet */
    virtual void stateRxRTS(Packet *p);
 
    /* The node comes to this state if it receives an <i>CTS</i> packet */
    virtual void stateRxCTS(Packet *p);
 
    /* Node comes here after sending a CTS. Waits for data before doing other
     * stuff */
    virtual void stateWaitData(double t);
 
    virtual void exitBackoff();
 
    virtual void exitCTSBackoff();
 
    virtual void printStateInfo(double delay = 0);
 
    virtual void initInfo();
 
    virtual void
    refreshState(UWSMARTOFDM_STATUS state)
    {
        prev_prev_state = prev_state;
        prev_state = curr_state;
        curr_state = state;
    }
 
    virtual void
    refreshReason(UWSMARTOFDM_REASON_STATUS reason)
    {
        last_reason = reason;
    }
 
    virtual void
    incrCurrTxRounds()
    {
        curr_tx_rounds++;
    }
 
    virtual void
    resetCurrTxRounds()
    {
        curr_tx_rounds = 0;
    }
 
    virtual void updateRTT(double rtt);
 
    virtual double
    getRTT()
    {
        return (rttsamples > 0) ? sumrtt / rttsamples : 0;
    }
 
    virtual double
    getRTSsent()
    {
        return RTSsent;
    }
 
    virtual double
    getCTSsent()
    {
        return CTSsent;
    }
 
    virtual void updateAckTimeout(double rtt);
 
    virtual void
    updateLastDataIdRx(int id)
    {
        last_data_id_rx = id;
    }
    virtual void waitForUser();
 
    inline int
    getPktSeqNum(Packet *p)
    {
        int seq_num;
        hdr_cmn *ch = hdr_cmn::access(p);
        seq_num = ch->uid();
        return seq_num;
    }
 
    inline void
    putPktInQueue(Packet *p)
    {
        mapPacket.insert(pair<pktSeqNum, Packet *>(getPktSeqNum(p), p));
    }
 
    inline void
    eraseItemFromPktQueue(int seq_num)
    {
        map<pktSeqNum, Packet *>::iterator it_p;
        it_p = mapPacket.find(seq_num);
        if (it_p != mapPacket.end()) {
            Packet::free((*it_p).second);
            mapPacket.erase((*it_p).first);
 
        } else
            std::cout << "ATTENTION PACKET NOT FOUND IN PKTQUEUE" << std::endl;
    }
 
    inline void
    putAckTimerInMap(int seq_num)
    {
        mapAckTimer.insert(pair<pktSeqNum, AckTimer>(seq_num, ack_timer));
    }
 
    inline void
    eraseItemFrommapAckTimer(int seq_num)
    {
        map<pktSeqNum, AckTimer>::iterator it_a;
        it_a = mapAckTimer.find(seq_num);
        mapAckTimer.erase((*it_a).first);
    }
 
    virtual int
    getRemainingPkts()
    {
        return (up_data_pkts_rx - mapPacket.size());
    }
 
    virtual void
    incrUpperDataRx()
    {
        up_data_pkts_rx++;
    }
 
    inline int
    getUpLayersDataPktsRx()
    {
        return up_data_pkts_rx;
    }
 
    // returns the number of high priority packets sent
    inline int
    getHighPrioPktsSent()
    {
        return high_prio_pkt_sent;
    }
 
    // returns the number of high priority packets received
    inline int
    getHighPrioPktsRecv()
    {
        return high_prio_pkt_recv;
    }
 
    // returns the current free carriers that can be given to a node
    void carToBeUsed(criticalLevel c, int &top, int &bottom, int &avoid_top,
            int &avoid_bottom);
 
    int pickFreeCarriers(int *freeC);
 
    int matchCarriers(int *myFree, int *otherFree, int *matching);
 
    void updateOccupancy(int *busyCar, int ntslots);
 
    void clearOccTable();
 
    void resetAssignment();
 
    void printOccTable();
 
    // Sends a msg to Mac to tell if tx is happening
    void Mac2PhySetTxBusy(int, int get = 0);
 
    // True if the conditions for a batch sending are verified, false otherwise
    bool batchSending();
 
    // add to the list of carriers that shouldn't be used
    inline void
    addInvalidCarriers(int c)
    {
        nouse_carriers.push_back(c);
    }
 
    // Remove Invalid Carrier c from nouse_carriers - if it's back to valid
    void removeInvalidCarrier(int c);
 
    // update InterfTable with new unrecognized packet
    // also cleans the old samples
    void updateInterfTable(Packet *p);
 
    int max_tx_tries; 
    double wait_constant; 
    double backoff_tuner; 
    int max_payload; 
    int HDR_size; 
    int ACK_size; 
    int RTS_size; 
    int CTS_size; 
    int DATA_size; 
    double ACK_timeout; 
    double bitrateCar; // Bitrate per carrier
    int buffer_pkts; 
    double alpha_; 
    double max_backoff_counter; 
    int uwsmartofdm_debug; 
 
    std::vector<string> mac_carMod; // Vector with carriers modulations
    std::vector<int> mac_carVec; // Vector with carriers used/not used
    std::vector<char> mac_prioVec; // Vector with node's priorities H/L
    int mac_ncarriers; // number of subcarriers
    double mac_carrierSize;
    int ctrl_car; // number of control subcarriers
    int data_car; // number of carriers used for data
    bool coordinator; // if this node is a coordinator
    criticalLevel cLevel = LOW;
    bool car_assigned = 0;
    int nodeNum; // number of nodes in the network
    std::atomic<int> current_rcvs; // Number of current Receptions
    int current_macDA;
 
    int oTableIndex; // index in the occupancy table of the current point
    int max_aval_car; // number of free carriers that tx can tell rx
 
    static bool initialized; 
    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 RTSsent = 0;
    int CTSsent = 0;
 
    int curr_tx_rounds; 
    int last_data_id_rx; 
    int recv_data_id; 
    int high_prio_pkt_sent = 0;
    int high_prio_pkt_recv = 0;
 
    double nextAssignment;
 
    Packet *curr_data_pkt; 
    int txsn; 
    static const double prop_speed; 
    AckTimer ack_timer; 
    BackOffTimer backoff_timer; 
    CTSTimer CTS_timer; 
    RTSTimer RTS_timer; 
    DATATimer DATA_timer; 
    AssignmentTimer
            assignment_timer; 
    AssignmentValidTimer
            assignment_valid_timer; 
    UWSMARTOFDM_REASON_STATUS
    last_reason; 
    UWSMARTOFDM_STATUS curr_state; 
    UWSMARTOFDM_STATUS
    prev_state; 
    UWSMARTOFDM_STATUS prev_prev_state; 
    UWSMARTOFDM_ACK_MODES
    ack_mode; 
    static map<UWSMARTOFDM_STATUS, string> status_info; 
    static map<UWSMARTOFDM_REASON_STATUS, string>
            reason_info; 
    static map<UWSMARTOFDM_PKT_TYPE, string>
            pkt_type_info; 
    static map<criticalLevel, string>
            clevel_info; 
    map<pktSeqNum, Packet *>
            mapPacket; 
    map<pktSeqNum, AckTimer> mapAckTimer; 
    ofstream fout; 
    MsgDisplayer msgDisp;
 
    std::vector<std::vector<int>>
            occupancy_table; // table with future usage of subcarriers
    std::mutex otabmtx; // mutex for occupancy table
    int timeslots; // how many timeslots will be kept
    double timeslot_length; // length in seconds of each timeslot
    int max_car_reserved; // max num of carriers reserved for each exchange
    int req_tslots; // how many tslots reserved for an interaction
 
    int current_timeslot; // index in the occupancy table of the current
                          // timeslot
 
    int max_rts_tries; // max num of times that rts will be sent for a specific
                       // packet
    int curr_rts_tries; // current num of rts sent for a specific packet
    int max_burst_size; // number of packets that will be sent consecutively
    int curr_pkt_batch;
    bool batch_sending; // true if sending a batch, false otherwise
 
    bool RTSvalid; // true if allowed to send an RTS
 
    double nextFreeTime; // When in time the bw will become free
    bool ackToSend; // Packets have been received, need to send ack
    Packet *pkt_to_ack;
    int waitPkt;
    // variables to save heard RTS
    Packet *nextRTS;
    double nextRTSts;
    bool fullBand;
    std::vector<int> nouse_carriers;
    std::vector<std::vector<double>>
            interf_table; // table with future usage of subcarriers
};
 
#endif /* UWUWSMARTOFDM_H_ */