User Manual, Developers Guide and API Documentation

ResourceScheduler.hpp

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2007
 * 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 LTE_TIMING_RESOURCESCHEDULERTX_HPP
#define LTE_TIMING_RESOURCESCHEDULERTX_HPP

#include <LTE/timing/ResourceSchedulerInterface.hpp>
#include <LTE/macr/Scorer.hpp>
#include <LTE/helper/HasModeName.hpp>

#include <DLL/services/control/Association.hpp>

// Forward declarations would be sufficient here
// For convenience we include here.
#include <WNS/scheduler/MapInfoProviderInterface.hpp>
#include <WNS/scheduler/RegistryProxyInterface.hpp>
#include <WNS/scheduler/queue/QueueInterface.hpp>
#include <WNS/scheduler/harq/HARQInterface.hpp>
#include <WNS/scheduler/strategy/StrategyInterface.hpp>
#include <WNS/scheduler/grouper/SpatialGrouper.hpp>
#include <WNS/ldk/FunctionalUnit.hpp>
#include <WNS/service/dll/FlowID.hpp>
#include <WNS/probe/bus/ContextCollector.hpp>

#include <map>
#include <list>

namespace lte {

// Forward declarations
namespace rlc { class RLC; }
namespace macg { class MACg; }
namespace macr { class PhyUser; }
namespace controlplane { class IMapHandlerRS; }
namespace controlplane { class RRHandler; }
namespace controlplane { namespace flowmanagement { class FlowManager; } }
namespace controlplane { namespace associationHandler { class AssociationHandlerBS; } }
namespace timing { class TimingScheduler; class RegistryProxy;}
namespace timing { namespace partitioning { class PartitioningInfo;}}
namespace helper { class QueueProxy; }

namespace timing {

class ResourceScheduler :
        virtual public SchedulerFUInterface,
        virtual public SchedulerOutgoing,
        virtual public SchedulerIncoming,
        virtual public wns::ldk::FunctionalUnit,
        public wns::ldk::CommandTypeSpecifier<SchedulerCommand>,
        virtual public wns::scheduler::SchedulingMapProviderInterface,
        virtual public macr::ScorerInterface,
        public lte::helper::HasModeName,
        public dll::services::control::AssociationObserver
{
    friend class controlplane::associationHandler::AssociationHandlerBS;

    typedef std::map<wns::service::dll::UnicastAddress,
                     wns::service::dll::UnicastAddress> SeenTable;

    typedef std::list<wns::ldk::CompoundPtr> CompoundList;

public:
    ResourceScheduler(wns::ldk::fun::FUN* fun, const wns::pyconfig::View& config);

    virtual ~ResourceScheduler();


    virtual bool
    doIsAccepting(const wns::ldk::CompoundPtr& compound) const;

    virtual void
    doSendData(const wns::ldk::CompoundPtr& compound);

    virtual void
    doOnData(const wns::ldk::CompoundPtr& compound);

    void
    postDecoding(const wns::ldk::CompoundPtr compound);

    virtual void
    doWakeup();



    wns::scheduler::SchedulingMapPtr
    getSchedulingMap(int frameNr) const;


    void
    finishCollection(int frameNr, simTimeType _startTime);

    virtual void
    resetHARQScheduledPeerRetransmissions();

    virtual void
    sendPendingHARQFeedback();

    virtual void
    onNodeCreated();

    virtual void
    onFUNCreated();

    virtual void
    onAssociated(wns::service::dll::UnicastAddress userAdr,
                 wns::service::dll::UnicastAddress dstAdr) = 0;

    virtual void
    onDisassociated(wns::service::dll::UnicastAddress userAdr,
                    wns::service::dll::UnicastAddress dstAdr) = 0;

    virtual void
    onFlowReleased(wns::service::dll::FlowID flowId,
                   wns::scheduler::UserID user /*nextHop!*/);

    virtual lte::helper::Route
    score(const wns::ldk::CompoundPtr& compound);

    int
    getPartitionGroup();

    void
    prepareMapOutput();

    void
    evaluateMap(wns::scheduler::SchedulingMapPtr schedulingMap, int frameNr);

    void
    closeMapOutput();

protected:
    void
    startCollection(int frameNr, simTimeType duration);

    void
    deliverSchedulingTimeSlot(bool canBeDecoded,
                              const wns::scheduler::SchedulingTimeSlotPtr& schedulingTimeSlot,
                              wns::service::phy::power::PowerMeasurementPtr&,
                              int subband);

    virtual void
    deliverReceived();

    virtual void
    applyPowerLimitation(wns::scheduler::SchedulingMapPtr);

    void 
    probeResourceUsage(wns::scheduler::SchedulingMapPtr schedulingMap);

    wns::pyconfig::View pyConfig;

    wns::logger::Logger logger;

    dll::ILayer2* layer2;

    dll::services::control::Association* associationService;

    struct Friends {
        Friends()
            {
                rlcReader=NULL; macg=NULL; phyUser=NULL; timer=NULL;
                flowManager=NULL; mapHandler=NULL; rrHandler=NULL; partitioningInfo=NULL;
            };

        wns::ldk::CommandReaderInterface* rlcReader;
        lte::macg::MACg* macg;
        lte::macr::PhyUser* phyUser;
        lte::timing::TimingScheduler* timer;
        lte::controlplane::flowmanagement::FlowManager* flowManager;
        lte::controlplane::IMapHandlerRS* mapHandler;
        lte::controlplane::RRHandler* rrHandler;
        lte::timing::partitioning::PartitioningInfo* partitioningInfo;
    } friends;

    struct Colleagues {
        Colleagues()
            {
                registry=NULL; strategy=NULL; queue=NULL; queueProxy=NULL;
                grouper=NULL; harq=NULL;
            };
        wns::scheduler::strategy::StrategyInterface* strategy;
        lte::timing::RegistryProxy* registry;
        //wns::scheduler::RegistryProxyInterface* registry;
        wns::scheduler::queue::QueueInterface* queue;
        lte::helper::QueueProxy* queueProxy;
        wns::scheduler::grouper::GroupingProviderInterface* grouper;
        wns::scheduler::harq::HARQInterface* harq;
    } colleagues;

    int framesPerSuperFrame;

    simTimeType slotDuration;

    unsigned int freqChannels;

    unsigned int numberOfTimeSlots;

    unsigned int maxBeams;

    bool beamforming;

    int partitionGroup;

    wns::scheduler::strategy::StrategyResultHistory schedulingResultOfFrame;

    lte::macr::Scorer scorer;

    wns::probe::bus::ContextCollectorPtr resUsageProbe_;

    wns::scheduler::SchedulerSpotType schedulerSpot;

    bool IamUplinkMaster;

    bool writeMapOutput;

    std::string mapOutputFileName;

    std::ofstream *mapFile;

    long int transportBlockCounter;

    wns::scheduler::harq::HARQInterface::DecodeStatusContainer receivedNonHARQTimeslots_;

    wns::Power maxTxPower;
};
}
} // lte::timing

#endif // NOT defined ...

---