User Manual, Developers Guide and API Documentation

SchedulerState.hpp

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2009
 * Chair of Communication Networks (ComNets)
 * Kopernikusstr. 5, D-52074 Aachen, Germany
 * phone: ++49-241-80-27910,
 * fax: ++49-241-80-22242
 * email: info@openwns.org
 * www: http://www.openwns.org
 * _____________________________________________________________________________
 *
 * openWNS is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 2 as published by the
 * Free Software Foundation;
 *
 * openWNS is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/

#ifndef WNS_SCHEDULER_STRATEGY_SCHEDULERSTATE_HPP
#define WNS_SCHEDULER_STRATEGY_SCHEDULERSTATE_HPP

#include <WNS/scheduler/SchedulerTypes.hpp>
#include <WNS/scheduler/MapInfoEntry.hpp>
#include <WNS/scheduler/SchedulingMap.hpp>
#include <WNS/service/dll/StationTypes.hpp>
#include <WNS/service/phy/ofdma/Pattern.hpp>
#include <WNS/service/phy/phymode/PhyModeInterface.hpp>
#include <WNS/ldk/Command.hpp>
#include <WNS/ldk/Compound.hpp>
#include <WNS/ldk/FunctionalUnit.hpp>
#include <WNS/ldk/Classifier.hpp>
#include <WNS/node/Node.hpp>
#include <WNS/PowerRatio.hpp>
#include <WNS/CandI.hpp>
#include <WNS/Enum.hpp>

#include <map>
#include <vector>
#include <set>
#include <list>
#include <string>
#include <sstream>

namespace wns { namespace scheduler {
        class MapInfoEntry; // forward declaration
        namespace strategy {
            class StrategyInput;
            class StrategyInterface;

            class RequestForResource
                    : virtual public wns::RefCountable
            {
            public:
                RequestForResource(ConnectionID _cid, UserID _user, Bits _bits, Bits _queuedBits, bool useHARQ);
                ~RequestForResource();
                std::string toString() const;
            public:
                simTimeType getDuration() const;

                ConnectionID cid;
                UserID user;
                Bits bits;
                Bits queuedBits;

                wns::service::phy::phymode::PhyModeInterfacePtr phyModePtr;
                int subChannel;
                int timeSlot;
                int spatialLayer; // also called "stream" or better "spacialIndex"
                ChannelQualityOnOneSubChannel cqiOnSubChannel; // memory here
                bool useHARQ;
            };

            class RevolvingState
                    : virtual public wns::RefCountable
            {
            public:
                RevolvingState(const strategy::StrategyInput* _strategyInput);
                virtual ~RevolvingState();
                virtual std::string toString() const;
                virtual GroupingPtr getNewGrouping();
                virtual bool groupingIsValid() const;
                virtual bool sdmaGroupingIsValid() const;
                virtual GroupingPtr getGrouping() const;
                virtual void setGrouping(GroupingPtr groupingPtr);
                virtual void setCurrentPriority(int priority);
                virtual int  getCurrentPriority() const;
                virtual void clearMap();
            public:
                const strategy::StrategyInput* strategyInput;
                MapInfoCollectionPtr bursts;
                wns::scheduler::SchedulingMapPtr schedulingMap;
                //ConnectionSet allActiveConnections;
                ConnectionSet activeConnections;
                ChannelQualitiesOfAllUsersPtr channelQualitiesOfAllUsers;
            protected:
                GroupingPtr grouping;

                int currentPriority;
            }; // class RevolvingState
            typedef SmartPtr<RevolvingState> RevolvingStatePtr;
            //typedef std::vector< RevolvingStatePtr > RevolvingStateVector;


            class SchedulerState
                    : virtual public wns::RefCountable
            {
            public:
                SchedulerState(strategy::StrategyInterface* _strategy):
                    strategy(_strategy),
                    defaultPhyModePtr(),
                    defaultTxPower(),
                    powerCapabilities(),
                    isTx(true),
                    isDL(true),
                    useCQI(false),
                    powerControlType(PowerControlDLMaster),
                    //schedulerSpot(wns::scheduler::SchedulerSpot::DLMaster()),
                    schedulerSpot(-1), // initialized to good value in setFriends
                    myUserID(NULL),
                    excludeTooLowSINR(true),
                    keepResultHistory(false),
                    symbolDuration(0.0),
                    eirpLimited(false),
                    currentState() // empty RevolvingState(), not persistent
                {
                    assure(strategy!=NULL,"strategy==NULL");
                }
                ~SchedulerState() { strategy=NULL; };

                virtual void setDefaultPhyMode(wns::service::phy::phymode::PhyModeInterfacePtr _phyModePtr)
                { defaultPhyModePtr = _phyModePtr; /*_phyModePtr->clone();*/}
                virtual wns::service::phy::phymode::PhyModeInterfacePtr
                getDefaultPhyMode()
                { assure(defaultPhyModePtr!=wns::service::phy::phymode::PhyModeInterfacePtr(),"defaultPhyModePtr=NULL"); return defaultPhyModePtr; }
                virtual void setDefaultTxPower(wns::Power _txPower) {
                    defaultTxPower = _txPower; }
                virtual void clearMap() {
                    assure(currentState!=RevolvingStatePtr(),"uninitialized currentState");
                    if (currentState!=RevolvingStatePtr()) currentState->clearMap(); }
                virtual RevolvingStatePtr
                getCurrentState() {
                    assure (currentState!=RevolvingStatePtr(),"uninitialized currentState");
                    return currentState; }
            public:
                strategy::StrategyInterface* strategy; // allow strategy to be asked
                wns::service::phy::phymode::PhyModeInterfacePtr defaultPhyModePtr;
                wns::Power defaultTxPower;
                PowerCapabilities powerCapabilities;
                bool isTx;
                bool isDL;
                bool useCQI;
                PowerControlType powerControlType;
                SchedulerSpotType schedulerSpot;
                UserID myUserID;
                bool excludeTooLowSINR;
                bool keepResultHistory;
                simTimeType symbolDuration;
                bool eirpLimited;

                RevolvingStatePtr currentState;

            }; // class SchedulerState

            typedef SmartPtr<SchedulerState> SchedulerStatePtr;

            class betterChannelQuality
            {
            public:
                bool operator()(wns::scheduler::ChannelQualityOnOneSubChannel a, wns::scheduler::ChannelQualityOnOneSubChannel b)
                {
                    return a.pathloss.get_factor() * a.interference.get_mW()
                        < b.pathloss.get_factor() * b.interference.get_mW();
                }
            };

        }}} // namespace wns::scheduler::strategy
#endif // WNS_SCHEDULER_STRATEGY_SCHEDULERSTATE_HPP

---