python_init.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 "simlpy/interpreter_hooks.h"

#include "Globals.h"
#include "WrapNode.h"
#include "WrapLink.h"
#include "ExplicitRoutingEntity.h"
#include "PrefixRoutingEntity.h"
#include "SpaceAvailEntity.h"
#include "TrafficGenerator.h"
#include "Tracer.h"
#include "GlobalStatistics.h"
#include "GStatDump.h"
#include "GStatTrigger.h"
#include "PydtnBundle.h"
#include "PydtnApplication.h"
#include "simlpy/Clock.h"

#include <iostream>
#include <fstream>

#ifndef PyMODINIT_FUNC
#define PyMODINIT_FUNC extern "C" void
#endif

static GStatDump* gsd = 0;

static char dtn_config_doc[] = "Global DTN parameter configuration.\n\
   \n\
   Valid configurations are:\n\
   \n\
   pydtn.config('capacity',<size>)\n\
      Set the default volatile storage capacity to <size>.\n\
      (real-valued, in kibibytes)\n\
   \n\
   pydtn.config('stable_store',<size>)\n\
      Set the default persistent storage capacity to <size>.\n\
      (real-valued, in kibibytes)\n\
   \n\
   pydtn.config('bandwidth',<bw>)\n\
      Set the default link bandwidth to <bw>.\n\
      (real-valued, in Mbps).\n\
   \n\
   pydtn.config('latency',<t>)\n\
      Set the default link latency to <t>, given as [s,us]\n\
      (seconds, microseconds).\n\
   \n\
   pydtn.config('bundle_lifetime',<t>)\n\
      Set the default bundle lifetime to <t>, given as [s,us]\n\
      (seconds, microseconds).\n\
   \n\
   pydtn.config('resend_period',<t>)\n\
      Set the default bundle resending period to <t>, given as [s,us]\n\
      (seconds, microseconds).\n";

static PyObject*
dtn_config( PyObject* self, PyObject* args )
{
   Entity::ArgList argList;
   if ( ! PyTuple_Check( args ) )
   {
      PyErr_SetString(PyExc_TypeError,"config expects a list of arguments");
      return 0;
   }
   build_arglist( argList, args );
   unsigned int nargs = argList.size();

   if ( nargs < 2 )
   {
      std::cerr << "config() takes at least 2 arguments ("
                << nargs << " given)"
                << std::endl;
      return 0;
   }

   try
   {
      std::string command = parse_string(argList[0]);
      if ( "capacity" == command )
      {
         double dcap = parse_double( argList[1] );
         // convert from KB to B
         size_t cap = (size_t)(1024 * dcap);
         Globals::setVolatileCap(cap);
      }
      else if ( "stable_store" == command )
      {
         double dcap = parse_double( argList[1] );
         // convert from KB to B
         size_t cap = (size_t)(1024 * dcap);
         Globals::setPersistentCap(cap);
      }
      else if ( "bandwidth" == command )
      {
         double dbw = parse_double( argList[1] );
         // convert from Mbps to bps
         unsigned long int bw = (unsigned long int)(1000000 * dbw);
         Globals::setBandwidth( bw );
      }
      else if ( "latency" == command )
      {
         Globals::setLatency( parse_time(argList[1]) );
      }
      else if ( "bundle_lifetime" == command )
      {
         Globals::setBundleLifetime( parse_time(argList[1]) );
      }
      else if ( "resend_period" == command )
      {
         Globals::setResendPeriod( parse_time(argList[1]) );
      }
      else
      {
         std::cerr << "Unrecognized configuration option: " << command
                   << std::endl;
         clean_arglist( argList );
         return 0;
      }
   }
   catch ( ... )
   {
      clean_arglist( argList );
      return 0;
   }

   clean_arglist( argList );
   Py_INCREF(Py_None);
   return Py_None;
}

static char dtn_trace_doc[] = "Enable global tracing.\n\
   \n\
   This function takes no arguments.\n\
   \n\
   In general, this shouldn't be needed, as an individual tracing\n\
   module should be able to initialize global tracing.\n";

static PyObject*
dtn_trace( PyObject* self, PyObject* args )
{
   GlobalTracer::enable();
   Py_INCREF(Py_None);
   return Py_None;
}

static char dtn_stats_doc[] = "Enable global statistics aggregation.\n\
   \n\
   Statistics aggregation is done as bundles move through the system.\n\
   Information is periodically displayed summarizing data collected\n\
   since the last dump and data collected since the beginning of the\n\
   simulation.\n\
   \n\
   In addition, at the end of the simulation a final summary will be\n\
   displayed.\n\
   \n\
   Syntax:\n\
   \n\
   pydtn.stats(<fname>,<period>)\n\
      The parameter <fname> is the name of the file into which the\n\
      data should be dumped, or 'stdout' or 'stderr'.\n\
   \n\
      The parameter <period> is the delay (in microseconds) between\n\
      collections, and is optional.  The default value is 10000 (10ms).\n\
      Alternately, a period of 0 will inhibit periodic statistical\n\
      dumps, and only the end-of-simulation display will occur.\n";

static PyObject*
dtn_stats( PyObject* self, PyObject* args )
{
   const char* fname;
   long int t = 10000; // 10ms default
   if ( ! PyArg_ParseTuple(args, "s|l", &fname, &t) )
   {
      std::cerr << "Incorrect argument list" << std::endl;
      return 0;
   }
   std::string fnstr( fname ); // This lets us use operator==.
   GlobalStatistics* gs = GlobalStatistics::instance();
   if ( 0 == gs )
   {
      GlobalStatistics::enable();
      if ( 0 != gsd ) delete gsd;
      gsd = 0;
      if ( "stdout" == fnstr )
      {
         gsd = new GStatDump( std::cout, t );
      }
      else if ( "stderr" == fnstr )
      {
         gsd = new GStatDump( std::cerr, t );
      }
      else
      {
         gsd = new GStatDump( *(new std::ofstream(fname)), t );
      }
      if ( 0 != gsd )
      {
         if ( 0 != t )
         {
            Clock::schedule( new GStatTrigger( gsd, gsd, Clock::time() ) );
         }
      }
   }

   Py_INCREF(Py_None);
   return Py_None;
}

void
pydtn_statdump()
{
   if ( 0 == gsd ) return;
   GlobalStatistics* gs = GlobalStatistics::instance();
   if ( 0 == gs ) return;
   gsd->dump();
}

static PyMethodDef ExampleMethods[] =
{
   {"config",dtn_config,METH_VARARGS,dtn_config_doc},
   {"trace",dtn_trace,METH_VARARGS,dtn_trace_doc},
   {"stats",dtn_stats,METH_VARARGS,dtn_stats_doc},
   {0,0,0,0} // sentinel
};

PyMODINIT_FUNC
init_pydtn(void)
{
   add_entity( new WrapNode );
   add_entity( new WrapLink );
   add_entity( new ExplicitRoutingEntity );
   add_entity( new PrefixRoutingEntity );
   add_entity( new SpaceAvailEntity );
   add_entity( new TrafficGenerator );
   Py_AtExit(pydtn_statdump);
   PyObject* m = Py_InitModule("_pydtn",ExampleMethods);
   addType_PydtnBundle(m);
   addType_PydtnAppObject(m);
}

---