uw-mac-TLohi.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_TLOHI_H
#define MMAC_UW_TLOHI_H
 
//#include<module.h>
#include <mmac.h>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <utility>
#include <fstream>
 
#include <mphy.h>
 
#define HDR_TLOHI(P) (hdr_tlohi::access(P))
 
#define TLOHI_DROP_REASON_WRONG_STATE "WST"
#define TLOHI_DROP_REASON_WRONG_RECEIVER "WRCV"
#define TLOHI_DROP_REASON_UNKNOWN_TYPE "UPT"
#define TLOHI_DROP_REASON_BUFFER_FULL "DBF"
 
extern packet_t PT_TLOHI;
 
static const int prop_speed =
        1500; 
enum TLOHI_STATUS {
    STATE_IDLE = 1,
    STATE_BACKOFF,
    STATE_START_CONTENTION,
    STATE_WAIT_END_CONTENTION,
    STATE_TX_DATA,
    STATE_SLEEP,
    STATE_TX_ACK,
    STATE_WAIT_ACK,
    STATE_DATA_RECEIVED,
    STATE_ACK_RECEIVED,
    STATE_WAIT_END_CR,
    STATE_COUNT_CONTENDERS,
    STATE_RECONTEND_WINDOW,
    STATE_WAIT_XACK,
    STATE_NOT_SET
};
 
enum TLOHI_REASON_STATUS {
    REASON_TONE_TX = 1,
    REASON_DATA_PENDING,
    REASON_TONE_RX,
    REASON_WAIT_CR_END,
    REASON_NO_CONTENDERS,
    REASON_CONTENDERS,
    REASON_DATA_RX,
    REASON_XDATA_RX,
    REASON_XACK_RX,
    REASON_DATA_TX,
    REASON_ACK_TX,
    REASON_ACK_RX,
    REASON_BACKOFF_TIMEOUT,
    REASON_ACK_TIMEOUT,
    REASON_SLEEP_TIMEOUT,
    REASON_RECONTEND_END,
    REASON_CR_END,
    REASON_DATA_EMPTY,
    REASON_XACK_TIMEOUT,
    REASON_NOT_SET,
    REASON_MAX_TX_TRIES
};
 
enum TLOHI_PKT_TYPE { TONE_PKT = 1, ACK_PKT, DATA_PKT, DATAMAX_PKT };
 
enum TLOHI_ACK_MODE { ACK_MODE = 1, NO_ACK_MODE };
 
enum TLOHI_MODE {
    CONSERVATIVE_UNSYNC_MODE = 1,
    AGGRESSIVE_UNSYNC_MODE,
    SYNC_MODE
};
 
enum TIMER_STATUS { RUNNING = 1, STOPPED, FREEZED };
 
typedef struct hdr_tlohi {
 
    double ts; 
    int sn; 
    TLOHI_PKT_TYPE pkt_type; 
    packet_t
            orig_type; 
    int data_sn; 
    static int offset_; 
    inline static int &
    offset()
    {
        return offset_;
    }
    inline static struct hdr_tlohi *
    access(const Packet *p)
    {
        return (struct hdr_tlohi *) p->access(offset_);
    }
 
} hdr_tlohi;
 
class MMacTLOHI;
 
class Timer : public TimerHandler
{
public:
    Timer(MMacTLOHI *m)
        : TimerHandler()
    {
        module = m;
    }
 
protected:
    virtual void expire(Event *e);
    MMacTLOHI *module; 
};
 
class DataTimer : public TimerHandler
{
public:
    DataTimer(MMacTLOHI *m)
        : TimerHandler()
    {
        module = m;
    }
 
protected:
    virtual void expire(Event *e);
    MMacTLOHI *module;
};
 
class MMacTLOHI : public MMac
{
    friend class Timer;
    friend class DataTimer;
 
public:
    MMacTLOHI();
    virtual ~MMacTLOHI();
    virtual int command(int argc, const char *const *argv);
    virtual int crLayCommand(ClMessage *m);
 
protected:
    virtual void recvFromUpperLayers(Packet *p);
 
    virtual void Phy2MacEndTx(const Packet *p);
    virtual void Phy2MacStartRx(const Packet *p);
    virtual void Phy2MacEndRx(Packet *p);
    virtual double computeTxTime(TLOHI_PKT_TYPE type);
    virtual void initPkt(Packet *p, TLOHI_PKT_TYPE pkt_type);
    virtual void getBackoffTime();
    virtual double
    getCRduration()
    {
        return CR_duration;
    }
    virtual void checkDataPhy();
    virtual int countContenders(double time);
    virtual void txTone();
    virtual void txData();
    virtual void txAck();
    virtual void rxTone(Packet *p);
    virtual void rxAck(Packet *p);
    virtual void rxElse(Packet *p);
    virtual void stateIdle();
    virtual void stateBackoff();
    virtual void stateStartContention();
    virtual void stateWaitEndContention();
    virtual void stateCountContenders();
    virtual void stateTxData();
    virtual void stateSleep();
    virtual void stateWaitAck();
    virtual void stateWaitXAck();
    virtual void stateDataReceived(Packet *data_pkt);
    virtual void stateTxAck();
    virtual void stateRecontendWindow();
    virtual void stateWaitCR();
    virtual void printStateInfo(double delay = 0);
    virtual void initInfo();
    virtual void initData();
    virtual void initMphyIds();
    virtual void
    refreshState(TLOHI_STATUS state)
    {
        prev_state = curr_state;
        curr_state = state;
    }
    virtual void
    refreshReason(TLOHI_REASON_STATUS reason)
    {
        last_reason = reason;
    }
    virtual void exitBackoff();
    virtual void
    setDestAddr(int mac_addr)
    {
        curr_dest_addr = mac_addr;
    }
    virtual void
    setSessionDistance(double distance)
    {
        session_distance = distance;
    }
    virtual void checkPhyInit();
    virtual void
    incrCurrTxRounds()
    {
        curr_tx_rounds++;
    }
    virtual void resetSession();
    virtual void
    queuePop(bool flag)
    {
        Packet::free(Q.front());
        Q.pop();
        waitEndTime(flag);
    }
    virtual void waitForUser();
 
    /*****************
     * stats methods *
     ****************/
    virtual void
    incrTonePktsTx()
    {
        tone_pkts_tx++;
    }
    virtual void
    incrTonePktsRx()
    {
        tone_pkts_rx++;
    }
    virtual void
    incrCurrTxTries()
    {
        curr_tx_tries++;
    }
    virtual void
    resetStats()
    {
        tone_pkts_tx = 0;
        tone_pkts_rx = 0;
        return MMac::resetStats();
    }
    virtual int
    getRemainingPkts()
    {
        return (up_data_pkts_rx - Q.size());
    }
    virtual int
    getTonePktsTx()
    {
        return tone_pkts_tx;
    }
    virtual int
    getTonePktsRx()
    {
        return tone_pkts_rx;
    }
 
    virtual int
    getUpLayersDataPktsRx()
    {
        return up_data_pkts_rx;
    }
 
    // stats //
    int tone_pkts_tx; 
    int tone_pkts_rx; 
 
    /***************
    * input values *
    ****************/
    double max_prop_delay; 
    int max_tx_rounds; 
    double max_tx_tries; 
    double backoff_tuner; 
    double wait_costant; 
    int max_payload; 
    int HDR_size; 
    int ACK_size; 
    double sleep_timeout; 
    double DATA_listen_timeout; 
    double ACK_timeout; 
    double recontend_time; 
    double tone_data_delay; 
    int buffer_pkts; 
    queue<Packet *> Q; 
    bool TxActive; 
    bool session_active; 
    bool
            backoff_pending; 
    bool tone_transmitted; 
    bool print_transitions; 
    static bool initialized; 
    bool mphy_ids_initialized; 
    bool has_buffer_queue; 
    TLOHI_ACK_MODE ack_mode; 
    TLOHI_MODE op_mode; 
    int tone_phy_id; 
    int data_phy_id; 
    double CR_duration; 
    int curr_dest_addr; 
    int last_data_id_tx; 
    int last_data_id_rx; 
    Packet *curr_data_pkt; 
    int curr_contenders; 
    int curr_tx_rounds; 
    int curr_tx_tries; 
    TLOHI_REASON_STATUS last_reason; 
    TLOHI_STATUS curr_state; 
    TLOHI_STATUS prev_state; 
    double session_distance; 
    double backoff_start_time; 
    double backoff_duration; 
    double backoff_remaining; 
    static int u_pkt_id; 
    int u_data_id; 
    int txsn; 
    string tcl_modulation; 
    Timer timer; 
    DataTimer
            data_phy_timer; 
    static map<TLOHI_STATUS, string>
            status_info; 
    static map<TLOHI_REASON_STATUS, string>
            reason_info; 
    static map<TLOHI_PKT_TYPE, string> pkt_type_info; 
    ofstream fout; 
};
 
#endif /* MMAC_UW_TLOHI_H */