Attachment #538 for bug #645

View | Details | Raw Unified | Return to bug 645
Collapse All | Expand All

(-)5d448b8564e5 (+11 lines)

Added	Link Here

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>stats</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

	</buildSpec>

	<natures>

	</natures>

</projectDescription>




available online on the ns-3 wiki at:

http://www.nsnam.org/wiki/index.php/Statistical_Framework_for_Network_Simulation

*** Using ns-3 with the OMNeT++ analysis tool ***

The stat framework can write out the result in a format that is compatible with the
output format of OMNeT++ 4 Discrete Event Simulator Framework.
Use the wifi-example-omnet.sh script to generate the results in OMNeT++ format.

If you want to analyse the results with OMNeT++'s result analyser tool:
a) Download OMNeT++ 4 and install it. Start the IDE. (www.omnetpp.org)
b) If you do not want to install the whole simulator framework, there is a seperate 
   package which contains only the analysis tool from the OMNeT++ package.
   You can download it from http://omnetpp.org/download/release/omnetpp-scave.tgz

Once you are running the OMNeT++ IDE or the separate analysis tool (SCAVE)
- Choose File|Import...|Existing Projects into Workspace, then click [Next]
- Select root directory. (choose the examples/stats directory) and click [Finish]

Double click the wifi-example-omnet.anf in the opened project and select 
the Chart page to see the created chart. Experiment with the analysis tool and read its
documentation: http://omnetpp.org/doc/omnetpp40/userguide/ch09.html

(-)a/examples/stats/wifi-example-db.sh (-2 / +2 lines)

Lines 64-71	Link Here

    from Singletons rx, Singletons tx, Experiments exp \

    from Singletons rx, Singletons tx, Experiments exp \

    where rx.run = tx.run AND \

    where rx.run = tx.run AND \

          rx.run = exp.run AND \

          rx.run = exp.run AND \

          rx.name='receiver-rx-packets' AND \

          rx.variable='receiver-rx-packets' AND \

          tx.name='sender-tx-packets' \

          tx.variable='sender-tx-packets' \

    group by exp.input \

    group by exp.input \

    order by abs(exp.input) ASC;"

    order by abs(exp.input) ASC;"




<?xml version="1.0" encoding="UTF-8"?>
<scave:Analysis xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:scave="http://www.omnetpp.org/omnetpp/scave">
  <inputs>
    <inputs name="/stats/*.sca"/>
  </inputs>
  <datasets>
    <datasets name="Tx vs Rx">
      <items xsi:type="scave:Add" filterPattern="name(sender-tx-packets) or name(receiver-rx-packets) or name(measurement) "/>
      <items xsi:type="scave:ScatterChart" name="Scatter distance vs Rx/Tx" xDataPattern="module(.) AND name(measurement)">
        <properties name="X.Axis.Title" value="Distance"/>
        <properties name="Y.Axis.Title" value="Rx/Tx packets"/>
      </items>
    </datasets>
  </datasets>
  <chartSheets>
    <chartSheets name="default" charts="//@datasets/@datasets.0/@items.1"/>
  </chartSheets>
</scave:Analysis>




#!/bin/sh

DISTANCES="25 50 75 100 125 145 147 150 152 155 157 160 162 165 167 170 172 175 177 180"
TRIALS="1 2 3 4 5"

echo WiFi Experiment Example - OMNeT++ output

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:bin/

for trial in $TRIALS
do
  for distance in $DISTANCES
  do
    echo Trial $trial, distance $distance
    ../../waf --run "wifi-example-sim --format=omnet --distance=$distance --run=run-$distance-$trial"
  done
done

rm *.sca
mv ../../*.sca .

echo "Done; data in data-run-*.sca files. Open SCAVE, create a new workspace and import this directory."




  Ptr<CounterCalculator<uint32_t> > totalTx =
    CreateObject<CounterCalculator<uint32_t> >();
  totalTx->SetKey("wifi-tx-frames");
  totalTx->SetContext("node[0]");
  Config::Connect("/NodeList/0/DeviceList/*/$ns3::WifiNetDevice/Mac/MacTx",
                  MakeBoundCallback(&TxCallback, totalTx));
  data.AddDataCalculator(totalTx);

  Ptr<PacketCounterCalculator> totalRx =
    CreateObject<PacketCounterCalculator>();
  totalRx->SetKey("wifi-rx-frames");
  totalRx->SetContext("node[1]");
  Config::Connect("/NodeList/1/DeviceList/*/$ns3::WifiNetDevice/Mac/MacRx",
                  MakeCallback(&PacketCounterCalculator::PacketUpdate,
                               totalRx));

  Ptr<PacketCounterCalculator> appTx =
    CreateObject<PacketCounterCalculator>();
  appTx->SetKey("sender-tx-packets");
  appTx->SetContext("node[0]");
  Config::Connect("/NodeList/0/ApplicationList/*/$Sender/Tx",
                  MakeCallback(&PacketCounterCalculator::PacketUpdate,
                                    appTx));

  Ptr<CounterCalculator<> > appRx =
    CreateObject<CounterCalculator<> >();
  appRx->SetKey("receiver-rx-packets");
  appRx->SetContext("node[1]");
  receiver->SetCounter(appRx);
  data.AddDataCalculator(appRx);


  Ptr<PacketSizeMinMaxAvgTotalCalculator> appTxPkts =
    CreateObject<PacketSizeMinMaxAvgTotalCalculator>();
  appTxPkts->SetKey("tx-pkt-size");
  appTxPkts->SetContext("node[0]");
  Config::Connect("/NodeList/0/ApplicationList/*/$Sender/Tx",
                  MakeCallback
                    (&PacketSizeMinMaxAvgTotalCalculator::PacketUpdate,

  Ptr<TimeMinMaxAvgTotalCalculator> delayStat =
    CreateObject<TimeMinMaxAvgTotalCalculator>();
  delayStat->SetKey("delay");
  delayStat->SetContext(".");
  receiver->SetDelayTracker(delayStat);
  data.AddDataCalculator(delayStat);


(-)a/src/contrib/stats/basic-data-calculators.h (-12 / +14 lines)

Lines 29-35	Link Here

  //------------------------------------------------------------

  //------------------------------------------------------------

  //--------------------------------------------

  //--------------------------------------------

  template <typename T  = uint32_t>

  template <typename T  = uint32_t>

  class MinMaxAvgTotalCalculator : public DataCalculator {

  class MinMaxAvgTotalCalculator : public DataCalculator,

                                   public StatisticalSummary {

  public:

  public:

    MinMaxAvgTotalCalculator();

    MinMaxAvgTotalCalculator();

    virtual ~MinMaxAvgTotalCalculator();

    virtual ~MinMaxAvgTotalCalculator();

Lines 38-43	Link Here

    virtual void Output(DataOutputCallback &callback) const;

    virtual void Output(DataOutputCallback &callback) const;

    long getCount() const { return m_count; }

    double getSum() const { return m_total; }

    double getMin() const { return m_min; }

    double getMax() const { return m_max; }

    double getMean() const { return m_total / (double)m_count; }

    double getStddev() const { return NaN; } // unsupported

    double getVariance() const { return NaN; } // unsupported

    double getSqrSum() const { return NaN; } // unsupported

  protected:

  protected:

    virtual void DoDispose(void);

    virtual void DoDispose(void);

Lines 86-108	Link Here

    // end MinMaxAvgTotalCalculator::Update

    // end MinMaxAvgTotalCalculator::Update

  template <typename T>

100

  template <typename T>

  void

101

  void

  MinMaxAvgTotalCalculator<T>::Output(DataOutputCallback &callback) const

102

  MinMaxAvgTotalCalculator<T>::Output(DataOutputCallback &callback) const

103

    callback.OutputSingleton(m_key, "count", m_count);

104

      callback.OutputStatistic(m_context, m_key, this);

    if (m_count > 0) {

      callback.OutputSingleton(m_key, "total", m_total);

      callback.OutputSingleton(m_key, "average", m_total/m_count);

      callback.OutputSingleton(m_key, "max", m_max);

      callback.OutputSingleton(m_key, "min", m_min);

100

    // end MinMaxAvgTotalCalculator::Output

101

105

102

106

103

107

104

105

106

  //------------------------------------------------------------

108

  //------------------------------------------------------------

107

  //--------------------------------------------

109

  //--------------------------------------------

108

  template <typename T  = uint32_t>

110

  template <typename T  = uint32_t>

Lines 178-184	Link Here

178

  void

180

  void

179

  CounterCalculator<T>::Output(DataOutputCallback &callback) const

181

  CounterCalculator<T>::Output(DataOutputCallback &callback) const

180

182

181

    callback.OutputSingleton(m_key, "count", m_count);

183

    callback.OutputSingleton(m_context, m_key, m_count);

182

    // end CounterCalculator::Output

184

    // end CounterCalculator::Output

183

185

184

186

(-)a/src/contrib/stats/data-calculator.cc (+16 lines)

Lines 27-32	Link Here

NS_LOG_COMPONENT_DEFINE("DataCalculator");

NS_LOG_COMPONENT_DEFINE("DataCalculator");

static double zero = 0;

const double ns3::NaN = zero / zero;

//--------------------------------------------------------------

//--------------------------------------------------------------

//----------------------------------------------

//----------------------------------------------

Lines 70-75	Link Here

//----------------------------------------------

//----------------------------------------------

void

void

DataCalculator::SetContext(const std::string context)

  m_context = context;

  // end DataCalculator::SetContext

std::string

DataCalculator::GetContext() const

  return m_context;

  // end DataCalculator::GetContext

//----------------------------------------------

void

DataCalculator::Enable()

DataCalculator::Enable()

  m_enabled = true;

  m_enabled = true;




#include "ns3/simulator.h"

namespace ns3 {
  extern const double NaN;
  inline bool isNaN(double x) { return x != x; }

  class DataOutputCallback;

  class StatisticalSummary {
	  public:
	    /**
	     * Returns the number of the observations.
	     */
	    virtual long getCount() const = 0;

	    /**
	     * Returns the sum of the values.
	     * @see getWeightedSum()
	     */
	    virtual double getSum() const = 0;

	    /**
	     * Returns the sum of the squared values.
	     * @see getWeightedSqrSum()
	     */
	    virtual double getSqrSum() const = 0;

	    /**
	     * Returns the minimum of the values.
	     */
	    virtual double getMin() const = 0;

	    /**
	     * Returns the maximum of the values.
	     */
	    virtual double getMax() const = 0;

	    /**
	     * Returns the mean of the (weighted) observations.
	     */
	    virtual double getMean() const = 0;

	    /**
	     * Returns the standard deviation of the (weighted) observations.
	     */
	    virtual double getStddev() const = 0;

	    /**
	     * Returns the variance of the (weighted) observations.
	     */
	    virtual double getVariance() const = 0;
  };

  //------------------------------------------------------------
  //--------------------------------------------
  class DataCalculator : public Object {

    void SetKey(const std::string key);
    std::string GetKey() const;

    void SetContext(const std::string context);
    std::string GetContext() const;

    virtual void Start(const Time& startTime);
    virtual void Stop(const Time& stopTime);


    bool m_enabled;  // Descendant classes *must* check & respect m_enabled!

    std::string m_key;
    std::string m_context;

    virtual void DoDispose(void);


(-)a/src/contrib/stats/data-output-interface.h (+5 lines)

Lines 23-28	Link Here

#include "ns3/object.h"

#include "ns3/object.h"

#include "ns3/nstime.h"

#include "ns3/nstime.h"

#include "ns3/data-calculator.h"

namespace ns3 {

namespace ns3 {

Lines 52-57	Link Here

  public:

  public:

    virtual ~DataOutputCallback() {}

    virtual ~DataOutputCallback() {}

    virtual void OutputStatistic(std::string key,

                                 std::string variable,

                                 const StatisticalSummary *statSum) = 0;

    virtual void OutputSingleton(std::string key,

    virtual void OutputSingleton(std::string key,

                                 std::string variable,

                                 std::string variable,

                                 int val) = 0;

                                 int val) = 0;




 */

#include <fstream>
#include <cstdlib>

#include "ns3/log.h"
#include "ns3/nstime.h"

}

//----------------------------------------------

inline bool isNumeric(const std::string& s) {
  char *endp;
  strtod(s.c_str(), &endp);
  return endp == s.c_str() + s.size();
}

void
OmnetDataOutput::Output(DataCollector &dc)
{

  std::ofstream scalarFile;
  std::string fn = m_filePrefix +"-"+dc.GetRunLabel()+ ".sca";
  scalarFile.open(fn.c_str(), std::ios_base::out);

  // TODO add timestamp to the runlevel
  scalarFile << "run " << dc.GetRunLabel() << std::endl;
  scalarFile << std::endl;
  scalarFile << "attr experiment \"" << dc.GetExperimentLabel()
            << "\"" << std::endl;
  scalarFile << "attr strategy \"" << dc.GetStrategyLabel()
            << "\"" << std::endl;
  scalarFile << "attr measurement \"" << dc.GetInputLabel()
            << "\"" << std::endl;
  scalarFile << "attr description \"" << dc.GetDescription()
            << "\"" << std::endl;
  scalarFile << std::endl;

  for (MetadataList::iterator i = dc.MetadataBegin();
       i != dc.MetadataEnd(); i++) {

  }

  scalarFile << std::endl;
  if (isNumeric(dc.GetInputLabel())) {
     scalarFile << "scalar . measurement \"" << dc.GetInputLabel()
            << "\"" << std::endl;
  }
  for (MetadataList::iterator i = dc.MetadataBegin();
       i != dc.MetadataEnd(); i++) {
    std::pair<std::string, std::string> blob = (*i);
    if (isNumeric(blob.second)) {
       scalarFile << "scalar . \"" << blob.first << "\" \"" << blob.second << "\""
               << std::endl;
    }
  }
  OmnetOutputCallback callback(&scalarFile);

  for (DataCalculatorList::iterator i = dc.DataCalculatorBegin();

  // end OmnetDataOutput::Output
}


OmnetDataOutput::OmnetOutputCallback::OmnetOutputCallback
  (std::ostream *scalar) :
  m_scalar(scalar)

}

void
OmnetDataOutput::OmnetOutputCallback::OutputStatistic(std::string context,
                                                      std::string name,
                                                      const StatisticalSummary *statSum)
{
	if (context == "")
		context = ".";
	if (name == "")
		name = "\"\"";
	(*m_scalar) << "statistic " << context << " " << name << std::endl;
	if (!isNaN(statSum->getCount()))
		(*m_scalar) << "field count " << statSum->getCount() << std::endl;
	if (!isNaN(statSum->getSum()))
		(*m_scalar) << "field sum " << statSum->getSum() << std::endl;
	if (!isNaN(statSum->getMean()))
		(*m_scalar) << "field mean " << statSum->getMean() << std::endl;
	if (!isNaN(statSum->getMin()))
		(*m_scalar) << "field min " << statSum->getMin() << std::endl;
	if (!isNaN(statSum->getMax()))
		(*m_scalar) << "field max " << statSum->getMax() << std::endl;
	if (!isNaN(statSum->getSqrSum()))
		(*m_scalar) << "field sqrsum " << statSum->getSqrSum() << std::endl;
	if (!isNaN(statSum->getStddev()))
		(*m_scalar) << "field stddev " << statSum->getStddev() << std::endl;
}

void
OmnetDataOutput::OmnetOutputCallback::OutputSingleton(std::string context,
                                                      std::string name,
                                                      int val)
{
	if (context == "")
		context = ".";
	if (name == "")
		name = "\"\"";
  (*m_scalar) << "scalar " << context << " " << name << " " << val << std::endl;
  // end OmnetDataOutput::OmnetOutputCallback::OutputSingleton
}

void
OmnetDataOutput::OmnetOutputCallback::OutputSingleton(std::string context,
                                                      std::string name,
                                                      uint32_t val)
{
	if (context == "")
		context = ".";
	if (name == "")
		name = "\"\"";
  (*m_scalar) << "scalar " << context << " " << name << " " << val << std::endl;
  // end OmnetDataOutput::OmnetOutputCallback::OutputSingleton
}

void
OmnetDataOutput::OmnetOutputCallback::OutputSingleton(std::string context,
                                                      std::string name,
                                                      double val)
{
	if (context == "")
		context = ".";
	if (name == "")
		name = "\"\"";
    (*m_scalar) << "scalar " << context << " " << name << " " << val << std::endl;
  // end OmnetDataOutput::OmnetOutputCallback::OutputSingleton
}

void
OmnetDataOutput::OmnetOutputCallback::OutputSingleton(std::string context,
                                                      std::string name,
                                                      std::string val)
{
	if (context == "")
		context = ".";
	if (name == "")
		name = "\"\"";
    (*m_scalar) << "scalar " << context << " " << name << " " << val << std::endl;
  // end OmnetDataOutput::OmnetOutputCallback::OutputSingleton
}

void
OmnetDataOutput::OmnetOutputCallback::OutputSingleton(std::string context,
                                                      std::string name,
                                                      Time val)
{
	if (context == "")
		context = ".";
	if (name == "")
		name = "\"\"";
    (*m_scalar) << "scalar " << context << " " << name << " " << val.GetTimeStep() << std::endl;
  // end OmnetDataOutput::OmnetOutputCallback::OutputSingleton
}




    public:
      OmnetOutputCallback(std::ostream *scalar);

      void OutputStatistic(std::string context,
                           std::string name,
                           const StatisticalSummary *statSum);

      void OutputSingleton(std::string context,
                           std::string name,
                           int val);

      void OutputSingleton(std::string context,
                           std::string name,
                           uint32_t val);

      void OutputSingleton(std::string context,
                           std::string name,
                           double val);

      void OutputSingleton(std::string context,
                           std::string name,
                           std::string val);

      void OutputSingleton(std::string context,
                           std::string name,
                           Time val);

    private:




}

void
SqliteDataOutput::SqliteOutputCallback::OutputStatistic(std::string key,
                       std::string variable,
                       const StatisticalSummary *statSum)
{
	OutputSingleton(key,variable+"-count", (double)statSum->getCount());
	if (!isNaN(statSum->getSum()))
		OutputSingleton(key,variable+"-total", statSum->getSum());
	if (!isNaN(statSum->getMax()))
		OutputSingleton(key,variable+"-max", statSum->getMax());
	if (!isNaN(statSum->getMin()))
		OutputSingleton(key,variable+"-min", statSum->getMin());
	if (!isNaN(statSum->getSqrSum()))
		OutputSingleton(key,variable+"-sqrsum", statSum->getSqrSum());
	if (!isNaN(statSum->getStddev()))
		OutputSingleton(key,variable+"-stddev", statSum->getStddev());
}


void
SqliteDataOutput::SqliteOutputCallback::OutputSingleton(std::string key,
                                                        std::string variable,
                                                        int val)

(-)a/src/contrib/stats/sqlite-data-output.h (+4 lines)

Lines 48-53	Link Here

    public:

    public:

      SqliteOutputCallback(Ptr<SqliteDataOutput> owner, std::string run);

      SqliteOutputCallback(Ptr<SqliteDataOutput> owner, std::string run);

      void OutputStatistic(std::string key,

                           std::string variable,

                           const StatisticalSummary *statSum);

      void OutputSingleton(std::string key,

      void OutputSingleton(std::string key,

                           std::string variable,

                           std::string variable,

                           int val);

                           int val);




void
TimeMinMaxAvgTotalCalculator::Output(DataOutputCallback &callback) const
{
  callback.OutputSingleton(m_context, m_key + "-count", m_count);
  if (m_count > 0) {
    callback.OutputSingleton(m_context, m_key + "-total", m_total);
    callback.OutputSingleton(m_context, m_key + "-average", m_total/Scalar(m_count));
    callback.OutputSingleton(m_context, m_key + "-max", m_max);
    callback.OutputSingleton(m_context, m_key + "-min", m_min);
  }
  // end TimeMinMaxAvgTotalCalculator::Output
}

Return to bug 645