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 "Python.h"
#include "structmember.h"

#include "BundleCollector.h"
#include "pydtn/WrapNode.h"
#include "pydtn/parsers.h"
#include "simlpy/interpreter_hooks.h"
#include "simlpy/Clock.h"

#include <iostream>
#include <fstream>

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

static std::ostream* _stream = &(std::cout);

static char storeprofile_setup_doc[] = "Storage profiling configuration.\n\
   \n\
   This method should be called if stable storage profiling is desired.\n\
   \n\
   Calling syntax:\n\
   \n\
   pydtn.storeprofile.setup(<fname>)\n\
   \n\
      <fname> is either a filename or one of 'stdout' or 'stderr'.\n\
      In the former case, the profiling information is written\n\
      to the file named.  In the latter cases, the information is\n\
      written to the appropriate stream.\n";

static PyObject*
storeprofile_setup( PyObject* self, PyObject* args )
{
   const char* fname;
   if ( ! PyArg_ParseTuple(args, "s", &fname) )
   {
      std::cerr << "Incorrect argument list" << std::endl;
      return 0;
   }
   std::string fnstr( fname ); // This lets us use operator==.

   if ( "stdout" == fnstr )
   {
      _stream = &(std::cout);
   }
   else if ( "stderr" == fnstr )
   {
      _stream = &(std::cerr);
   }
   else
   {
      _stream = new std::ofstream(fname);
   }

   Py_INCREF(Py_None);
   return Py_None;
}

static char storeprofile_collect_doc[] = "Add profiling to a node.\n\
   \n\
   Calling syntax:\n\
   \n\
   pydtn.storeprofile.collect(<n>)\n\
   \n\
      <n> is a node for which we want to collect a profile.\n";

static PyObject*
storeprofile_collect( PyObject* self, PyObject* args )
{
   if ( ! PyTuple_Check( args ) )
   {
      PyErr_SetString(PyExc_TypeError,"collect expects a list of arguments");
      return 0;
   }
   if ( 0 == PyTuple_Size( args ) )
   {
      PyErr_SetString(PyExc_TypeError,
                      "collect expects a non-empty argument list");
      return 0;
   }
   PyObject* p = PyTuple_GetItem( args, 0 );
   WrapNode* wn = parse_node(p);
   if ( 0 == wn )
   {
      PyErr_SetString(PyExc_TypeError,
                      "collect expects a node");
      return 0;
   }
   wn->addCollector( new StoreProfile::BundleCollector( *_stream ) );
   Py_INCREF(Py_None);
   return Py_None;
}

static PyMethodDef ExampleMethods[] =
{
   {"setup",storeprofile_setup,METH_VARARGS,storeprofile_setup_doc},
   {"collect",storeprofile_collect,METH_VARARGS,storeprofile_collect_doc},
   {0,0,0,0} // sentinel
};

PyMODINIT_FUNC
init_storeprofile(void)
{
   (void) Py_InitModule("_storeprofile",ExampleMethods);
}

---