flow-monitor.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
//
// Copyright (c) 2009 INESC Porto
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation;
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// Author: Gustavo J. A. M. Carneiro  <gjc@inescporto.pt> <gjcarneiro@gmail.com>
//

#ifndef FLOW_MONITOR_H
#define FLOW_MONITOR_H

#include <vector>
#include <map>

#include "ns3/ptr.h"
#include "ns3/object.h"
#include "ns3/flow-probe.h"
#include "ns3/flow-classifier.h"
#include "ns3/histogram.h"
#include "ns3/nstime.h"
#include "ns3/event-id.h"

namespace ns3 {

class FlowMonitor : public Object
{
public:

  struct FlowStats
  {
    Time     timeFirstTxPacket;

    Time     timeFirstRxPacket;

    Time     timeLastTxPacket;

    Time     timeLastRxPacket;

    Time     delaySum; // delayCount == rxPackets

    Time     jitterSum; // jitterCount == rxPackets - 1

    Time     lastDelay;

    uint64_t txBytes;
    uint64_t rxBytes;
    uint32_t txPackets;
    uint32_t rxPackets;

    uint32_t lostPackets;

    uint32_t timesForwarded;

    Histogram delayHistogram;
    Histogram jitterHistogram;
    Histogram packetSizeHistogram;

    std::vector<uint32_t> packetsDropped; // packetsDropped[reasonCode] => number of dropped packets

    std::vector<uint64_t> bytesDropped; // bytesDropped[reasonCode] => number of dropped bytes
    Histogram flowInterruptionsHistogram; 
  };

  // --- basic methods ---
  static TypeId GetTypeId ();
  virtual TypeId GetInstanceTypeId () const;
  FlowMonitor ();

  void AddFlowClassifier (Ptr<FlowClassifier> classifier);

  void Start (const Time &time);
  void Stop (const Time &time);
  void StartRightNow ();
  void StopRightNow ();

  // --- methods to be used by the FlowMonitorProbe's only ---
  void AddProbe (Ptr<FlowProbe> probe);

  void ReportFirstTx (Ptr<FlowProbe> probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize);
  void ReportForwarding (Ptr<FlowProbe> probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize);
  void ReportLastRx (Ptr<FlowProbe> probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize);
  void ReportDrop (Ptr<FlowProbe> probe, FlowId flowId, FlowPacketId packetId,
                   uint32_t packetSize, uint32_t reasonCode);

  void CheckForLostPackets ();

  void CheckForLostPackets (Time maxDelay);

  // --- methods to get the results ---

  typedef std::map<FlowId, FlowStats> FlowStatsContainer;
  typedef std::map<FlowId, FlowStats>::iterator FlowStatsContainerI;
  typedef std::map<FlowId, FlowStats>::const_iterator FlowStatsContainerCI;
  typedef std::vector< Ptr<FlowProbe> > FlowProbeContainer;
  typedef std::vector< Ptr<FlowProbe> >::iterator FlowProbeContainerI;
  typedef std::vector< Ptr<FlowProbe> >::const_iterator FlowProbeContainerCI;

  const FlowStatsContainer& GetFlowStats () const;

  const FlowProbeContainer& GetAllProbes () const;

  void SerializeToXmlStream (std::ostream &os, uint16_t indent, bool enableHistograms, bool enableProbes);

  std::string SerializeToXmlString (uint16_t indent, bool enableHistograms, bool enableProbes);

  void SerializeToXmlFile (std::string fileName, bool enableHistograms, bool enableProbes);


protected:

  virtual void NotifyConstructionCompleted ();
  virtual void DoDispose (void);

private:

  struct TrackedPacket
  {
    Time firstSeenTime; 
    Time lastSeenTime; 
    uint32_t timesForwarded; 
  };

  FlowStatsContainer m_flowStats;

  typedef std::map< std::pair<FlowId, FlowPacketId>, TrackedPacket> TrackedPacketMap;
  TrackedPacketMap m_trackedPackets; 
  Time m_maxPerHopDelay; 
  FlowProbeContainer m_flowProbes; 

  // note: this is needed only for serialization
  std::list<Ptr<FlowClassifier> > m_classifiers; 

  EventId m_startEvent;     
  EventId m_stopEvent;      
  bool m_enabled;           
  double m_delayBinWidth;   
  double m_jitterBinWidth;  
  double m_packetSizeBinWidth;  
  double m_flowInterruptionsBinWidth; 
  Time m_flowInterruptionsMinTime; 

  FlowStats& GetStatsForFlow (FlowId flowId);

  void PeriodicCheckForLostPackets ();
};


} // namespace ns3

#endif /* FLOW_MONITOR_H */