User Manual, Developers Guide and API Documentation

ProportionalFair.hpp

Go to the documentation of this file.

/******************************************************************************
 * WNS (Wireless Network Simulator)                                           *
 * __________________________________________________________________________ *
 *                                                                            *
 * Copyright (C) 2004-2006                                                    *
 * Chair of Communication Networks (ComNets)                                  *
 * Kopernikusstr. 16, D-52074 Aachen, Germany                                 *
 * phone: ++49-241-80-27910 (phone), fax: ++49-241-80-22242                   *
 * email: wns@comnets.rwth-aachen.de                                          *
 * www: http://wns.comnets.rwth-aachen.de                                     *
 ******************************************************************************/

#ifndef WNS_SCHEDULER_STRATEGY_STATICPRIORITY_PROPORTIONALFAIR_HPP
#define WNS_SCHEDULER_STRATEGY_STATICPRIORITY_PROPORTIONALFAIR_HPP

#include <WNS/scheduler/strategy/Strategy.hpp>
#include <WNS/scheduler/strategy/staticpriority/SubStrategy.hpp>
#include <WNS/scheduler/SchedulingMap.hpp>
#include <WNS/scheduler/queue/QueueInterface.hpp>
#include <WNS/scheduler/RegistryProxyInterface.hpp>

#include <WNS/distribution/Uniform.hpp>
#include <WNS/StaticFactory.hpp>

#include <queue>

namespace wns { namespace scheduler { namespace strategy { namespace staticpriority {

                class ProportionalFair
                    : public SubStrategy
                {
                public:
                    ProportionalFair(const wns::pyconfig::View& config);

                    ~ProportionalFair();

                    typedef std::pair<float, UserID> UserPreference;

                    virtual void
                    initialize();

                    std::priority_queue<UserPreference>
                    calculateUserPreferences(UserSet activeUsers, bool txStrategy) const;

                    std::map<UserID, float>
                    calculateBitsForConnections(const ConnectionSet& currentConnections);

                    virtual wns::scheduler::ConnectionID
                    getNextConnection(SchedulerStatePtr schedulerState, std::priority_queue<UserPreference> preferences);

                    void
                    updatePastDataRates(std::map<UserID, float> bitsBeforeThisFrame,
                                        std::map<UserID, float> bitsAfterThisFrame,
                                        simTimeType phaseLength);

                    virtual wns::scheduler::MapInfoCollectionPtr
                    doStartSubScheduling(SchedulerStatePtr schedulerState,
                                         wns::scheduler::SchedulingMapPtr schedulingMap);

                protected:
                    ConnectionVector
                    getConnectionsForPrio(int currentPrio, const UserID user);
                    wns::scheduler::ConnectionID
                    getRandomConnection(ConnectionVector currentPrioConns);
                    int blockSize;
                    float historyWeight;
                    float scalingBetweenMaxTPandPFair;
                    bool rateFairness;
                    float maxRateOfSubchannel;
                    UserSet allUsers;
                    std::map<UserID, float> bitsForUsers;
                    std::map<UserID, float> bitsThisFrame;
                    std::map<UserID, float> pastDataRates;
                    std::map<UserID, wns::CandI> sinrs;
                    wns::distribution::Uniform* preferenceVariationDistribution;
                };
            }}}}
namespace std {
    template <>
    struct less<wns::scheduler::strategy::staticpriority::ProportionalFair::UserPreference>:
        public binary_function<wns::scheduler::strategy::staticpriority::ProportionalFair::UserPreference,
                               wns::scheduler::strategy::staticpriority::ProportionalFair::UserPreference,
                               bool>{
        bool operator()(const wns::scheduler::strategy::staticpriority::ProportionalFair::UserPreference & lhs,
                        const wns::scheduler::strategy::staticpriority::ProportionalFair::UserPreference & rhs) const
        {
            if(lhs.first == rhs.first) {
                return lhs.second.getName() < rhs.second.getName();
            }
            return lhs.first < rhs.first;
        }
    };
}
#endif

---