User Manual, Developers Guide and API Documentation

BlockACK.hpp

Go to the documentation of this file.

/******************************************************************************
 * WiFiMac                                                                    *
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2007
 * Chair of Communication Networks (ComNets)
 * Kopernikusstr. 16, 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 WIFIMAC_DRAFTN_BLOCKACK_HPP
#define WIFIMAC_DRAFTN_BLOCKACK_HPP

#include <WIFIMAC/lowerMAC/Manager.hpp>
#include <WIFIMAC/management/PERInformationBase.hpp>
#include <WIFIMAC/lowerMAC/ITransmissionCounter.hpp>
#include <WIFIMAC/draftn/BlockACKCommand.hpp>
#include <WIFIMAC/draftn/TransmissionQueue.hpp>
#include <WIFIMAC/draftn/ReceptionQueue.hpp>
#include <WIFIMAC/convergence/IRxStartEnd.hpp>
#include <WIFIMAC/convergence/ITxStartEnd.hpp>

#include <WNS/ldk/fu/Plain.hpp>
#include <WNS/ldk/Delayed.hpp>
#include <WNS/ldk/arq/ARQ.hpp>
#include <WNS/ldk/probe/Probe.hpp>
#include <WNS/ldk/buffer/Buffer.hpp>

#include <WNS/probe/bus/ContextCollector.hpp>
#include <WNS/events/CanTimeout.hpp>
#include <WNS/Observer.hpp>
#include <WNS/RoundRobin.hpp>

#include <WIFIMAC/draftn/IBlockACKObserver.hpp>

namespace wifimac {
    namespace draftn {

        class BlockACK:
            public wns::ldk::arq::ARQ,
            public wns::ldk::fu::Plain<BlockACK, BlockACKCommand>,
            public wns::ldk::Delayed<BlockACK>,
            public wns::events::CanTimeout,
            public wns::Observer<wifimac::convergence::IRxStartEnd>,
            public wns::Observer<wifimac::convergence::ITxStartEnd>,
            public wifimac::lowerMAC::ITransmissionCounter,
            public wns::ldk::probe::Probe
        {
            friend class TransmissionQueue;
            friend class ReceptionQueue;

            typedef wns::container::Registry<wns::service::dll::UnicastAddress, BlockACKCommand::SequenceNumber> AddrSNMap;

        public:

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

            BlockACK(const BlockACK& other);

            virtual ~BlockACK();

            virtual void
            onFUNCreated();

            virtual void
            registerObserver(IBlockACKObserver *o) 
                {
                    observers.push_back(o);
                }

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

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

            virtual bool
            hasCapacity() const;

            virtual const wns::ldk::CompoundPtr
            hasACK() const;

            virtual const wns::ldk::CompoundPtr
            hasData() const;

            virtual wns::ldk::CompoundPtr
            getACK();

            virtual wns::ldk::CompoundPtr
            getData();

            virtual void
            onTimeout();

            virtual void
            onRxStart(wns::simulator::Time expRxTime);

            virtual void
            onRxEnd();

            virtual void
            onRxError();

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

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

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

            virtual unsigned int
            getTransmissionCounter(const wns::ldk::CompoundPtr& compound) const;

            virtual void
            copyTransmissionCounter(const wns::ldk::CompoundPtr& src, const wns::ldk::CompoundPtr& dst);

            virtual void
            calculateSizes(const wns::ldk::CommandPool* commandPool, Bit& commandPoolSize, Bit& dataSize) const;

            wifimac::lowerMAC::Manager*
            getManager() const
                {
                    return friends.manager;
                }

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

            const size_t
            getMaxOnAir()
                {
                    return maxOnAir;
                }

            wifimac::management::PERInformationBase*
            getPERMIB()
                {
                    return this->perMIB;
                }

    protected:
            wns::logger::Logger logger;

            TransmissionQueue *currentTxQueue;

            virtual unsigned int
            storageSize() const;

            const Bit capacity;

            std::auto_ptr<wns::ldk::buffer::SizeCalculator> sizeCalculator;

            const size_t maxOnAir;

            enum BAState {
                idle,
                waitForACK,
                receiving,
                receptionFinished
            } baState;

            virtual void
            processIncomingACKSNs(std::set<BlockACKCommand::SequenceNumber> ackSNs);

    private:

            bool
            isAccepting(const wns::ldk::CompoundPtr& compound) const;

            void printTxQueueStatus() const;

            const std::string managerName;
            const std::string rxStartEndName;
            const std::string txStartEndName;
            const std::string sendBufferName;
            const std::string perMIBServiceName;

            const wifimac::convergence::PhyMode blockACKPhyMode;

            const wns::simulator::Time sifsDuration;
            const wns::simulator::Time maximumACKDuration;
            const wns::simulator::Time ackTimeout;

            const Bit baBits;
            const Bit baReqBits;

            const size_t maximumTransmissions;

            const bool impatientBAreqTransmission;

            wns::container::Registry<wns::service::dll::UnicastAddress, ReceptionQueue*> rxQueues;

            wns::service::dll::UnicastAddress hasACKfor;

            AddrSNMap nextTransmissionSN;

            struct Friends
            {
                wns::ldk::DelayedInterface* sendBuffer;

                wifimac::lowerMAC::Manager* manager;
            } friends;

            wifimac::management::PERInformationBase* perMIB;

            wns::probe::bus::ContextCollectorPtr numTxAttemptsProbe;

            std::vector<IBlockACKObserver *> observers;
        };

} // mac
} // wifimac

#endif // WIFIMAC_LOWERMAC_BLOCKACK_HPP

---