GStatDump.cc

// Copyright 2008 Michael Marsh, University of Maryland.
//
// This file is part of pydtn.
//
// pydtn is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// pydtn 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 pydtn.  If not, see <http://www.gnu.org/licenses/>.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the University
// of Maryland.
//
// pydtn extends and embeds the Python interpreter, which is
// Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
// and is released under the PSF License Agreement.
//
// RANLUX random number generation uses the Boost library,
// Copyright 1994-2006 by various authors (details in individual files),
// which is released under the Boost Software License, Version 1.0.

#include "simlpy/interpreter_defs.h"

#include "GStatDump.h"
#include "GStatCollect.h"
#include "Measurement.h"
#include "simlpy/Clock.h"
#include <iostream>

GStatDump::GStatDump( std::ostream& s, unsigned long int t ) :
   m_stream( s ),
   m_period( 0, t )
{
}

GStatDump::~GStatDump()
{
}

Entity*
GStatDump::create() const
{
   return 0;
}

void
GStatDump::configure( const ArgList& args )
{
}

void
GStatDump::emit( const ArgList& args )
{
}

bool
GStatDump::handler( GStatTrigger& event )
{
   if ( Time(0,0) == m_period ) return false;
   Time t = Clock::time() + m_period;
   Clock::schedule( new GStatCollect( this, this, t ) );
   return true;
}

bool
GStatDump::handler( GStatCollect& event )
{
   dump();

   if ( Time(0,0) == m_period ) return false;
   Time t = Clock::time() + m_period;
   if ( 0 != Clock::numEvents() )
   {
      Clock::schedule( new GStatCollect( this, this, t ) );
   }
   else
   {
      Clock::tentative( new GStatCollect( this, this, t ) );
   }
   return true;
}

void
GStatDump::dump()
{
   GlobalStatistics* gs = GlobalStatistics::instance();
   if ( 0 == gs )
   {
      return;
   }
   Time t = Clock::time();

   m_stream << t
            << " originated unique ";
   dumpStat(gs->since().originated().unique());
   m_stream << " ";
   dumpStat(gs->total().originated().unique());
   m_stream << "\n";

   m_stream << t
            << " originated duplicate ";
   dumpStat(gs->since().originated().duplicate());
   m_stream << " ";
   dumpStat(gs->total().originated().duplicate());
   m_stream << "\n";

   m_stream << t
            << " delivered unique ";
   dumpStat(gs->since().delivered().unique());
   m_stream << " ";
   dumpStat(gs->total().delivered().unique());
   m_stream << "\n";

   m_stream << t
            << " delivered duplicate ";
   dumpStat(gs->since().delivered().duplicate());
   m_stream << " ";
   dumpStat(gs->total().delivered().duplicate());
   m_stream << "\n";

   m_stream << t
            << " delivered hops ";
   dumpStat(gs->since().deliverHops());
   m_stream << " ";
   dumpStat(gs->total().deliverHops());
   m_stream << "\n";

   m_stream << t
            << " sent ";
   dumpStat(gs->since().sent());
   m_stream << " ";
   dumpStat(gs->total().sent());
   m_stream << "\n";

   m_stream << t
            << " received ";
   dumpStat(gs->since().received());
   m_stream << " ";
   dumpStat(gs->total().received());
   m_stream << "\n";

   m_stream << t
            << " dropped bytes ";
   dumpStat(gs->since().dropped());
   m_stream << " ";
   dumpStat(gs->total().dropped());
   m_stream << "\n";

   m_stream << t
            << " dropped hops ";
   dumpStat(gs->since().dropHops());
   m_stream << " ";
   dumpStat(gs->total().dropHops());
   m_stream << "\n";

   double ndelv = gs->total().delivered().unique().n();
   double norig = gs->total().originated().unique().n();
   double ndrop = gs->total().dropped().n();
   double nsent = norig + gs->total().delivered().duplicate().n();
   Measurement fdelivered( ndelv/norig ,
                            (ndelv/(norig*norig))*(1-ndelv/norig) );
   Measurement fdropped( ndrop/nsent ,
                         (ndrop/(nsent*nsent))*(1-ndrop/nsent) );
   m_stream << t
            << " fdelivered "
            << fdelivered
            << "\n";
   m_stream << t
            << " fdropped "
            << fdropped
            << "\n";

   m_stream << t
            << " storage "
            << gs->used()
            << " "
            << gs->capacity()
            << " "
            << gs->maxUsed()
            << "\n";

   m_stream << t
            << " exhausted "
            << gs->since().exhausted()
            << " "
            << gs->total().exhausted()
            << "\n";

   m_stream.flush();
   gs->reset();
}

void
GStatDump::dumpStat( const Stat& s )
{
   m_stream << s.n() << " " << s.s() << " " << Measurement(s.mean(),s.var());
}

---