sun-ipr-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 SUN_NODE_H
#define SUN_NODE_H
 
#include "sun-ipr-common-structures.h"
#include "sun-hdr-ack.h"
#include "sun-hdr-data.h"
#include "sun-hdr-pathestablishment.h"
 
#include <uwip-module.h>
#include <uwip-clmsg.h>
#include <uwcbr-module.h>
 
#include "mphy.h"
#include "packet.h"
#include <module.h>
#include <tclcl.h>
 
#include <cmath>
#include <limits>
#include <sstream>
#include <string>
#include <iostream>
#include <rng.h>
#include <ctime>
#include <vector>
#include <fstream>
#include <map>
 
 
 
class SunIPRoutingNode;
 
class SinkProbeTimer : public TimerHandler
{
public:
    SinkProbeTimer(SunIPRoutingNode *m)
        : TimerHandler()
    {
        module = m;
    }
 
protected:
    virtual void expire(Event *e);
 
    SunIPRoutingNode
            *module; 
};
 
class RemoveHopTableTimer : public TimerHandler
{
 
public:
    RemoveHopTableTimer(SunIPRoutingNode *m)
        : TimerHandler()
    {
        module = m;
    }
 
protected:
    SunIPRoutingNode
            *module; 
    virtual void expire(Event *e);
};
 
// * AckWaiting class is used to handle the timer of acks.
// * When a node sends a packet it waits for and ack
// * for a period managed by an AckWaiting object.
// */
// class AckWaiting : public TimerHandler {
//
// public:
//    AckWaiting(SunIPRoutingNode* m) : TimerHandler() {
//        module = m;
//    }
//
// protected:
//    SunIPRoutingNode* module; /**< Pointer to an objet of type
//    SunIPRoutingNode. */
//
//    /**
//     * Method invoked when the AckWaiting timer expires.
//     */
//    virtual void expire(Event *e);
//};
 
class BufferTimer : public TimerHandler
{
 
public:
    BufferTimer(SunIPRoutingNode *m)
        : TimerHandler()
    {
        module = m;
    }
 
protected:
    SunIPRoutingNode
            *module; 
    virtual void expire(Event *e);
};
 
class SearchPathTimer : public TimerHandler
{
 
public:
    SearchPathTimer(SunIPRoutingNode *m)
        : TimerHandler()
    {
        module = m;
    }
 
protected:
    SunIPRoutingNode
            *module; 
    virtual void expire(Event *e);
};
 
class SunIPRoutingNode : public Module
{
 
    friend class RemoveHopTableTimer;
 
    friend class AckWaiting;
 
    friend class SinkProbeTimer;
 
    friend class BufferTimer;
 
    friend class SearchPathTimer;
 
public:
    SunIPRoutingNode();
 
    virtual ~SunIPRoutingNode();
 
    static const int LISTLENGTH = 30; 
    static const int MINUTE =
            60; 
protected:
    /*****************************
     |     Internal Functions    |
     *****************************/
    virtual int command(int, const char *const *);
 
    virtual void recv(Packet *);
 
    virtual int recvSyncClMsg(ClMessage *);
 
    virtual int recvAsyncClMsg(ClMessage *);
 
    virtual void clearHops();
 
    virtual void initialize();
 
    virtual void printHopTable() const;
 
    virtual void printSelectedRoutes() const;
 
    inline const long &
    getNPathsEstablished()
    {
      return n_paths_established;
    }
 
    static string printIP(const nsaddr_t &);
 
    static string printIP(const ns_addr_t &);
 
    static nsaddr_t str2addr(const char *);
 
    inline const double
    getDelay(const double &period_) const
    {
        if (PoissonTraffic_)
            return (-log(RNG::defaultrng()->uniform_double()) /
                    (1.0 / period_));
        else
            return 0;
    }
 
    inline const bool
    isZero(const double &value) const
    {
        return std::fabs(value) < std::numeric_limits<double>::epsilon();
    }
 
    virtual const int &setNumberOfHopToSink(const int &);
 
    virtual const int &getNumberOfHopToSink() const;
 
    virtual void receiveProbe(const Packet *);
 
    /*****************************
     | Path Establishment Search |
     *****************************/
    virtual void searchPath();
 
    virtual void initPktPathEstSearch(Packet *) const;
 
    virtual void replyPathEstSearch(Packet *);
 
    virtual const bool addMyIpInList(Packet *);
 
    virtual const bool isMyIpInList(const Packet *) const;
 
    virtual void updateQuality(Packet *);
 
    /*****************************
     | Path Establishment Answer |
     *****************************/
    virtual void answerPath(
            const Packet *); // invoked only by a node with ho count = 1
 
    virtual void initPktPathEstAnswer(Packet *,
            const Packet *); // invoked only by a node with ho count = 1
 
    virtual void sendRouteBack(Packet *);
 
    virtual const int &evaluatePath(const Packet *);
 
    /*****************************
     |           Data            |
     *****************************/
    virtual void initPktDataPacket(Packet *);
 
    virtual void forwardDataPacket(Packet *);
 
    /*****************************
     |           Acks            |
     *****************************/
    virtual void sendBackAck(const Packet *);
 
    virtual void initPktAck(Packet *);
 
    virtual void createRouteError(const Packet *, Packet *);
 
    virtual void sendRouteErrorBack(Packet *);
 
    /*****************************
     |           Load            |
     *****************************/
    virtual void updatePacketsCount();
 
    virtual void updateAcksCount();
 
    virtual const int getPacketsLastMinute() const;
    virtual const int getAcksLastMinute() const;
 
    virtual const double getLoad() const;
 
    /*****************************
     |         Buffering         |
     *****************************/
    virtual void bufferManager();
 
    /*****************************
     |        Statistics         |
     *****************************/
    static inline const int
    getAckHeaderSize()
    {
        return sizeof(hdr_sun_ack);
    }
 
    static inline const int
    getDataPktHeaderSize()
    {
        return sizeof(hdr_sun_data);
    }
 
    static inline const int
    getPathEstHeaderSize()
    {
        return sizeof(hdr_sun_path_est);
    }
 
    inline const long &
    getAckCount() const
    {
        return number_of_ackpkt_;
    }
 
    inline const long &
    getDataCount() const
    {
        return number_of_datapkt_;
    }
 
    inline const long &
    getForwardedCount() const
    {
        return number_of_pkt_forwarded_;
    }
 
    inline const long &
    getDataDropsCountBuffer() const
    {
        return number_of_drops_buffer_full_;
    }
 
    inline const long &
    getDataDropsCountMaxRetx() const
    {
        return number_of_drops_maxretx_;
    }
 
    inline const long &
    getPathEstablishmentCount() const
    {
        return number_of_pathestablishment_;
    }
 
    /*****************************
     |          Timers           |
     *****************************/
    virtual void expTimerHopTable();
 
    virtual void lostSink();
 
    virtual void searchPathExpire();
 
    /*****************************
     |         Trace file         |
     *****************************/
    virtual void tracePacket(
            const Packet *const, const string &position = "UNDEF___");
 
    virtual string createTraceString(const string &, const double &,
            const int &, const int &, const int &, const int &, const int &,
            const int &, const int &, const double &, const int &, const int &);
 
    virtual void writeInTrace(const string &);
 
    enum {
        HOPCOUNT = 1,
        SNR,
        LESSCONGESTED
    }; 
    // Variables
    nsaddr_t ipAddr_; 
    int metrics_; 
    int PoissonTraffic_; 
    double
            period_status_; 
    double period_data_; 
    int
            num_hop_to_sink; 
    double quality_link; 
    nsaddr_t *hop_table; 
    int hop_table_length; 
    nsaddr_t sink_associated; 
    int printDebug_; 
    double probe_min_snr_; 
    double snr_to_sink_; 
    bool search_path_enable_; 
    int disable_path_error_; 
    int
            reset_buffer_if_error_; 
    // Load
    double
            list_packets
                    [LISTLENGTH]; 
    double list_acks[LISTLENGTH]; 
    int pointer_packets_; 
    int pointer_acks_; 
    long list_packets_max_time_; 
    long list_acks_max_time_; 
    bool packets_array_full; 
    bool
            acks_array_full; 
    double alpha_; 
    // Acks
    int max_ack_error_; 
    int ack_warnings_counter_; 
    bool ack_error_state; 
    // Buffer
    vector<buffer_element>
            buffer_data; 
    uint32_t buffer_max_size_; 
    long
            pkt_stored_; 
    long pkt_tx_; 
    int
            safe_timer_buffer_; 
    // Timers
    double timer_route_validity_; 
    double timer_sink_probe_validity_; 
    double timer_buffer_; 
    double timer_search_path_; 
    RemoveHopTableTimer rmhopTableTmr_; 
    SinkProbeTimer sinkProbeTimer_; 
    BufferTimer bufferTmr_; 
    SearchPathTimer searchPathTmr_; 
    // Trace file
    bool trace_; 
    char
            *trace_file_name_; 
    ostringstream osstream_; 
    ofstream trace_file_; 
    char trace_separator_; 
    // Statistics
    int data_and_hops[MAX_HOP_NUMBER]; 
    std::map<uint8_t, uint> paths_selected; 
    long n_paths_established; 
    static long
            number_of_pathestablishment_; 
    static long number_of_datapkt_; 
    static long number_of_ackpkt_; 
    static long
            number_of_drops_buffer_full_; 
    static long number_of_drops_maxretx_; 
    static long
            number_of_pkt_forwarded_; 
    uint max_retx_; 
private:
    SunIPRoutingNode(const SunIPRoutingNode &);
};
 
#endif // SUN_NODE_H