daemon/src/routing/prophet/ProphetRoutingExtension.h

Go to the documentation of this file.

#ifndef PROPHETROUTINGEXTENSION_H_
#define PROPHETROUTINGEXTENSION_H_

#include "routing/BaseRouter.h"
#include <ibrcommon/thread/Mutex.h>
#include <ibrcommon/thread/Queue.h>
#include <ibrcommon/thread/ThreadsafeReference.h>

#include <map>
#include <list>

#define DISABLE_MAP_STORE 1

namespace dtn
{
        namespace routing
        {
                class ProphetRoutingExtension : public BaseRouter::ThreadedExtension
                {
                public:

                        class DeliveryPredictabilityMap : public std::map<dtn::data::EID, float>, public NodeHandshakeItem, public ibrcommon::Mutex
                        {
                        public:
                                /* virtual methods from NodeHandshakeItem */

                                virtual size_t getIdentifier() const; 
                                virtual size_t getLength() const; 
                                virtual std::ostream& serialize(std::ostream& stream) const; 
                                virtual std::istream& deserialize(std::istream& stream); 
                                static const size_t identifier;

                                /* TODO: move this to a deserializer or toString? */
                                friend std::ostream& operator<<(ostream&, const DeliveryPredictabilityMap&);
                        };

                        class ForwardingStrategy
                        {
                        public:
                                ForwardingStrategy();
                                virtual ~ForwardingStrategy() = 0;
                                virtual bool shallForward(const dtn::data::EID& neighbor, const dtn::data::MetaBundle& bundle) const = 0;
                                bool neighborDPIsGreater(const dtn::data::EID& neighbor, const dtn::data::EID& destination) const;

                                void setProphetRouter(ProphetRoutingExtension *router);

                        protected:
                                ProphetRoutingExtension *_prophet_router;
                        };

                        class Acknowledgement
                        {
                        public:
                                Acknowledgement();
                                Acknowledgement(const dtn::data::BundleID&, size_t expire_time);
                                virtual ~Acknowledgement();
                                std::ostream& serialize(std::ostream& stream) const;
                                std::istream& deserialize(std::istream& stream);

                                bool operator<(const Acknowledgement &other) const;

                                dtn::data::BundleID bundleID; 
                                size_t expire_time; 
                        };

                        class AcknowledgementSet : public NodeHandshakeItem, public ibrcommon::Mutex
                        {
                        public:
                                AcknowledgementSet();
                                AcknowledgementSet(const AcknowledgementSet&);

                                void insert(const Acknowledgement&); 
                                void purge(); 
                                void merge(const AcknowledgementSet&); 
                                bool has(const dtn::data::BundleID &bundle) const; 

                                /* virtual methods from NodeHandshakeItem */
                                virtual size_t getIdentifier() const; 
                                virtual size_t getLength() const; 
                                virtual std::ostream& serialize(std::ostream& stream) const; 
                                virtual std::istream& deserialize(std::istream& stream); 
                                static const size_t identifier;

                                /* TODO: move this to a deserializer or toString? */
                                friend std::ostream& operator<<(ostream&, const AcknowledgementSet&);
                        private:
                                std::set<Acknowledgement> _ackSet;
                        };

                        ProphetRoutingExtension(ForwardingStrategy *strategy, float p_encounter_max, float p_encounter_first,
                                                float p_first_threshold, float beta, float gamma, float delta,
                                                size_t time_unit, size_t i_typ,
                                                size_t next_exchange_timeout);
                        virtual ~ProphetRoutingExtension();

                        /* virtual methods from BaseRouter::Extension */
                        virtual void requestHandshake(const dtn::data::EID&, NodeHandshake&) const; 
                        virtual void responseHandshake(const dtn::data::EID&, const NodeHandshake&, NodeHandshake&); 
                        virtual void processHandshake(const dtn::data::EID&, NodeHandshake&); 
                        virtual void notify(const dtn::core::Event *evt);

                        ibrcommon::ThreadsafeReference<DeliveryPredictabilityMap> getDeliveryPredictabilityMap();
                        ibrcommon::ThreadsafeReference<const DeliveryPredictabilityMap> getDeliveryPredictabilityMap() const;

                        ibrcommon::ThreadsafeReference<const AcknowledgementSet> getAcknowledgementSet() const;
                protected:
                        virtual void run();
                        void __cancellation();
                private:
                        void update(const DeliveryPredictabilityMap& neighbor_dp_map, const dtn::data::EID& neighbor);

                        void updateNeighbor(const dtn::data::EID& neighbor);

                        void age();

                        DeliveryPredictabilityMap _deliveryPredictabilityMap;
                        ForwardingStrategy *_forwardingStrategy;
                        AcknowledgementSet _acknowledgementSet;

#ifndef DISABLE_MAP_STORE
                        typedef std::map<dtn::data::EID, DeliveryPredictabilityMap> map_store;
                        map_store _mapStore;
#endif

                        ibrcommon::Mutex _next_exchange_mutex; 
                        size_t _next_exchange_timeout; 
                        size_t _next_exchange_timestamp; 

                        float p_encounter(const dtn::data::EID &neighbor) const;

                        float _p_encounter_max; 
                        float _p_encounter_first; 
                        float _p_first_threshold; 
                        float _beta; 
                        float _gamma; 
                        float _delta; 
                        size_t _lastAgingTime; 
                        size_t _time_unit; 
                        size_t _i_typ; 

                        typedef std::map<dtn::data::EID, size_t> age_map;
                        age_map _ageMap; 

                        class Task
                        {
                        public:
                                virtual ~Task() {};
                                virtual std::string toString() const = 0;
                        };

                        class SearchNextBundleTask : public Task
                        {
                        public:
                                SearchNextBundleTask(const dtn::data::EID &eid);
                                virtual ~SearchNextBundleTask();

                                virtual std::string toString() const;

                                const dtn::data::EID eid;
                        };

                        class NextExchangeTask : public Task
                        {
                        public:
                                NextExchangeTask();
                                virtual ~NextExchangeTask();

                                virtual std::string toString() const;
                        };

                        ibrcommon::Queue<Task* > _taskqueue;

                public:
                        class GRTR_Strategy : public ForwardingStrategy
                        {
                        public:
                                explicit GRTR_Strategy();
                                virtual ~GRTR_Strategy();
                                virtual bool shallForward(const dtn::data::EID& neighbor, const dtn::data::MetaBundle& bundle) const;
                        };

                        class GTMX_Strategy : public ForwardingStrategy
                        {
                        public:
                                explicit GTMX_Strategy(unsigned int NF_max);
                                virtual ~GTMX_Strategy();
                                virtual bool shallForward(const dtn::data::EID& neighbor, const dtn::data::MetaBundle& bundle) const;

                                void addForward(const dtn::data::BundleID &id);

                        private:
                                unsigned int _NF_max; 

                                typedef std::map<dtn::data::BundleID, unsigned int> nf_map;
                                nf_map _NF_map; 
                        };
                };

                std::ostream& operator<<(std::ostream&, const ProphetRoutingExtension::AcknowledgementSet&);

        } // namespace routing
} // namespace dtn

#endif // PROPHETROUTINGEXTENSION_H_