Commits

Anonymous committed a446ef9

first import

Comments (0)

Files changed (10)

+2007-04-04  Sebastien Binet  <binet@lblbox>
+
+	* tagging PerfMonEvent-00-00-00
+	* first import (API is way far from being stable !!)
+

PerfMonEvent/PerfMonCpuData.h

+///////////////////////// -*- C++ -*- /////////////////////////////
+// PerfMonCpuData.h 
+// Header file for class PerfMon::CpuData
+// Author: S.Binet<binet@cern.ch>
+/////////////////////////////////////////////////////////////////// 
+#ifndef PERFMONEVENT_PERFMONCPUDATA_H 
+#define PERFMONEVENT_PERFMONCPUDATA_H 
+
+// STL includes
+#include <iosfwd>
+
+// HepMC / CLHEP includes
+
+// Gaudi includes
+
+// Forward declaration
+
+namespace PerfMon {
+
+class CpuData
+{ 
+
+  /////////////////////////////////////////////////////////////////// 
+  // Public methods: 
+  /////////////////////////////////////////////////////////////////// 
+ public: 
+
+  /// Default constructor: 
+  CpuData();
+
+  /// Copy constructor: 
+  CpuData( const CpuData& rhs );
+
+  /// Assignment operator: 
+  CpuData& operator=( const CpuData& rhs ); 
+
+  /// Constructor with parameters: 
+
+  /// Destructor: 
+  virtual ~CpuData(); 
+
+  /////////////////////////////////////////////////////////////////// 
+  // Const methods: 
+  ///////////////////////////////////////////////////////////////////
+
+  /// retrieve the total (user) time spent for this event
+  const float utime() const;
+
+  /////////////////////////////////////////////////////////////////// 
+  // Non-const methods: 
+  /////////////////////////////////////////////////////////////////// 
+
+  /// set the total (user) time spent for this event
+  void setUtime( const float utime );
+
+  /// reset internal state
+  void clear();
+
+  /////////////////////////////////////////////////////////////////// 
+  // Private CpuData: 
+  /////////////////////////////////////////////////////////////////// 
+ private: 
+
+  /// Total (user) time for this event (microseconds)
+  float m_utime;
+}; 
+
+/////////////////////////////////////////////////////////////////// 
+// Inline methods: 
+/////////////////////////////////////////////////////////////////// 
+inline const float CpuData::utime() const
+{ return m_utime; }
+
+inline void CpuData::setUtime( const float utime )
+{ m_utime = utime; }
+
+inline void CpuData::clear()
+{ 
+  setUtime( -1. );
+}
+
+} //> end namespace PerfMon
+
+/////////////////////////////////////////////////////////////////// 
+// I/O methods: 
+/////////////////////////////////////////////////////////////////// 
+std::ostream& operator<<( std::ostream& out, const PerfMon::CpuData& o );
+
+#endif //> PERFMONEVENT_PERFMONCPUDATA_H

PerfMonEvent/PerfMonData.h

+///////////////////////// -*- C++ -*- /////////////////////////////
+// PerfMonData.h 
+// Header file for class PerfMon::Data
+// Author: S.Binet<binet@cern.ch>
+/////////////////////////////////////////////////////////////////// 
+#ifndef PERFMONEVENT_PERFMONDATA_H 
+#define PERFMONEVENT_PERFMONDATA_H 
+
+// STL includes
+#include <iosfwd>
+
+// HepMC / CLHEP includes
+
+// Gaudi includes
+
+// PerfMonEvent includes
+#include "PerfMonEvent/PerfMonMemData.h"
+#include "PerfMonEvent/PerfMonCpuData.h"
+#include "PerfMonEvent/PerfMonIoData.h"
+
+// Forward declaration
+class PerfMonSvc;
+
+namespace PerfMon {
+
+class Data
+{ 
+  /// make the PerfMonSvc our friend for efficiency
+  friend class PerfMonSvc;
+
+  /////////////////////////////////////////////////////////////////// 
+  // Public methods: 
+  /////////////////////////////////////////////////////////////////// 
+ public: 
+
+  /// Default constructor: 
+  Data();
+
+  /// Copy constructor: 
+  Data( const Data& rhs );
+
+  /// Assignment operator: 
+  Data& operator=( const Data& rhs ); 
+
+  /// Constructor with parameters: 
+
+  /// Destructor: 
+  virtual ~Data(); 
+
+  /////////////////////////////////////////////////////////////////// 
+  // Const methods: 
+  ///////////////////////////////////////////////////////////////////
+
+  /// retrieve the memory-related informations for this event
+  const MemData& mem() const;
+
+  /// retrieve the cpu-related informations for this event
+  const CpuData& cpu() const;
+
+  /// retrieve the io-related informations for this event
+  const IoData&  io()  const;
+
+  /////////////////////////////////////////////////////////////////// 
+  // Non-const methods: 
+  /////////////////////////////////////////////////////////////////// 
+
+  /// set the memory-related informations for this event
+  void setMemData( const MemData& mem );
+
+  /// set the CPU-related informations for this event
+  void setCpuData( const CpuData& cpu );
+
+  /// set the I/O-related informations for this event
+  void setIoData( const IoData& io );
+
+  /// reset internal state
+  void clear();
+
+  /////////////////////////////////////////////////////////////////// 
+  // Private data: 
+  /////////////////////////////////////////////////////////////////// 
+ private: 
+
+  /// Memory-related informations for this event
+  MemData m_mem;
+
+  /// Cpu-related informations for this event
+  CpuData m_cpu;
+
+  /// I/O-related informations for this event
+  IoData m_io;
+
+}; 
+
+/////////////////////////////////////////////////////////////////// 
+// Inline methods: 
+/////////////////////////////////////////////////////////////////// 
+inline const MemData& Data::mem() const
+{ return m_mem; }
+
+inline const CpuData& Data::cpu() const
+{ return m_cpu; }
+
+inline const IoData& Data::io() const
+{ return m_io; }
+
+inline void Data::setMemData( const MemData& mem )
+{ m_mem = mem; }
+
+inline void Data::setCpuData( const CpuData& cpu )
+{ m_cpu = cpu; }
+
+inline void Data::setIoData( const IoData& io )
+{ m_io = io; }
+
+inline void Data::clear()
+{ 
+  m_mem.clear();
+  m_cpu.clear();
+  m_io. clear();
+}
+
+} //> end namespace PerfMon
+
+/////////////////////////////////////////////////////////////////// 
+// I/O methods: 
+/////////////////////////////////////////////////////////////////// 
+std::ostream& operator<<( std::ostream& out, const PerfMon::Data& o );
+
+#endif //> PERFMONEVENT_PERFMONDATA_H

PerfMonEvent/PerfMonIoData.h

+///////////////////////// -*- C++ -*- /////////////////////////////
+// PerfMonIoData.h 
+// Header file for class PerfMon::IoData
+// Author: S.Binet<binet@cern.ch>
+/////////////////////////////////////////////////////////////////// 
+#ifndef PERFMONEVENT_PERFMONIODATA_H 
+#define PERFMONEVENT_PERFMONIODATA_H 
+
+// STL includes
+#include <iosfwd>
+
+// HepMC / CLHEP includes
+
+// Gaudi includes
+
+// Forward declaration
+
+namespace PerfMon {
+
+class IoData
+{ 
+
+  /////////////////////////////////////////////////////////////////// 
+  // Public methods: 
+  /////////////////////////////////////////////////////////////////// 
+ public: 
+
+  /// Default constructor: 
+  IoData();
+
+  /// Copy constructor: 
+  IoData( const IoData& rhs );
+
+  /// Assignment operator: 
+  IoData& operator=( const IoData& rhs ); 
+
+  /// Constructor with parameters: 
+
+  /// Destructor: 
+  virtual ~IoData(); 
+
+  /////////////////////////////////////////////////////////////////// 
+  // Const methods: 
+  ///////////////////////////////////////////////////////////////////
+
+  /// retrieve the commit output time for this event
+  const float commitTime() const;
+
+  /////////////////////////////////////////////////////////////////// 
+  // Non-const methods: 
+  /////////////////////////////////////////////////////////////////// 
+
+  /// set the commit output time for this event
+  void setCommitTime( const float time );
+
+  /// reset internal state
+  void clear();
+
+  /////////////////////////////////////////////////////////////////// 
+  // Private IoData: 
+  /////////////////////////////////////////////////////////////////// 
+ private: 
+
+  /// Commit Output time
+  float m_commitOutput;
+}; 
+
+/////////////////////////////////////////////////////////////////// 
+// Inline methods: 
+/////////////////////////////////////////////////////////////////// 
+inline const float IoData::commitTime() const
+{ return m_commitOutput; }
+
+inline void IoData::setCommitTime( const float time )
+{ m_commitOutput = time; }
+
+inline void IoData::clear()
+{ 
+  m_commitOutput = -1.;
+}
+
+} //> end namespace PerfMon
+
+/////////////////////////////////////////////////////////////////// 
+// I/O methods: 
+/////////////////////////////////////////////////////////////////// 
+std::ostream& operator<<( std::ostream& out, const PerfMon::IoData& o );
+
+#endif //> PERFMONEVENT_PERFMONIODATA_H

PerfMonEvent/PerfMonMemData.h

+///////////////////////// -*- C++ -*- /////////////////////////////
+// PerfMonMemData.h 
+// Header file for class PerfMon::MemData
+// Author: S.Binet<binet@cern.ch>
+/////////////////////////////////////////////////////////////////// 
+#ifndef PERFMONEVENT_PERFMONMEMDATA_H 
+#define PERFMONEVENT_PERFMONMEMDATA_H 
+
+// STL includes
+#include <iosfwd>
+
+// HepMC / CLHEP includes
+
+// Gaudi includes
+
+// Forward declaration
+
+namespace PerfMon {
+
+class MemData
+{ 
+
+  /////////////////////////////////////////////////////////////////// 
+  // Public methods: 
+  /////////////////////////////////////////////////////////////////// 
+ public: 
+
+  /// Default constructor: 
+  MemData();
+
+  /// Copy constructor: 
+  MemData( const MemData& rhs );
+
+  /// Assignment operator: 
+  MemData& operator=( const MemData& rhs ); 
+
+  /// Constructor with parameters: 
+
+  /// Destructor: 
+  virtual ~MemData(); 
+
+  /////////////////////////////////////////////////////////////////// 
+  // Const methods: 
+  ///////////////////////////////////////////////////////////////////
+
+  /// retrieve the virtual memory size for this event
+  const float vsize() const;
+
+  /// retrieve the resident set size for this event
+  const float rss() const;
+
+  /////////////////////////////////////////////////////////////////// 
+  // Non-const methods: 
+  /////////////////////////////////////////////////////////////////// 
+
+  /// set the virtual memory size for this event
+  void setVSize( const float vsize );
+
+  /// set the RSS for this event
+  void setRSS( const float rss );
+
+  /// reset internal state
+  void clear();
+
+  /////////////////////////////////////////////////////////////////// 
+  // Private MemData: 
+  /////////////////////////////////////////////////////////////////// 
+ private: 
+
+  /// Instantaneous virtual memory size (in pages)
+  float m_vSize;
+
+  /// Instantaneous resident set size (in pages)
+  float m_rss;
+}; 
+
+/////////////////////////////////////////////////////////////////// 
+// Inline methods: 
+/////////////////////////////////////////////////////////////////// 
+inline const float MemData::vsize() const
+{ return m_vSize; }
+
+inline const float MemData::rss() const
+{ return m_rss; }
+
+inline void MemData::setVSize( const float vsize )
+{ m_vSize = vsize; }
+
+inline void MemData::setRSS( const float rss )
+{ m_rss = rss; }
+
+inline void MemData::clear()
+{ 
+  setVSize( -1. );
+  setRSS  ( -1. );
+}
+
+} //> end namespace PerfMon
+
+/////////////////////////////////////////////////////////////////// 
+// I/O methods: 
+/////////////////////////////////////////////////////////////////// 
+std::ostream& operator<<( std::ostream& out, const PerfMon::MemData& o );
+
+#endif //> PERFMONEVENT_PERFMONMEMDATA_H
+## Automatically generated CMT requirements file
+package PerfMonEvent
+author  Sebastien Binet <binet@cern.ch>
+
+## For Athena policies: it has to be the first use statement
+use AtlasPolicy 	AtlasPolicy-*
+
+## Put here your package dependencies...
+
+##
+
+branches PerfMonEvent src
+
+library PerfMonEvent *.cxx
+apply_pattern installed_library

src/PerfMonCpuData.cxx

+///////////////////////// -*- C++ -*- /////////////////////////////
+// PerfMonCpuData.cxx 
+// Implementation file for class PerfMon::CpuData
+// Author: S.Binet<binet@cern.ch>
+/////////////////////////////////////////////////////////////////// 
+
+
+// STL includes
+#include <ostream>
+
+// PerfMonEvent includes
+#include "PerfMonEvent/PerfMonCpuData.h"
+
+namespace PerfMon {
+
+/////////////////////////////////////////////////////////////////// 
+// Public methods: 
+/////////////////////////////////////////////////////////////////// 
+
+CpuData::CpuData() :
+  m_utime( -1. )
+{}
+
+CpuData::CpuData( const CpuData& rhs ) :
+  m_utime( rhs.m_utime )
+{}
+
+CpuData& CpuData::operator=( const CpuData& rhs )
+{
+  if ( this != &rhs ) {
+    m_utime = rhs.m_utime;
+  }
+  return *this;
+}
+
+CpuData::~CpuData()
+{}
+
+/////////////////////////////////////////////////////////////////// 
+// Const methods: 
+///////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////// 
+// Non-const methods: 
+/////////////////////////////////////////////////////////////////// 
+
+/////////////////////////////////////////////////////////////////// 
+// Protected methods: 
+/////////////////////////////////////////////////////////////////// 
+
+} //> end namespace PerfMon
+
+std::ostream& operator<<( std::ostream& out, const PerfMon::CpuData& o )
+{
+  out << o.utime() << "\n";
+
+  return out;
+}

src/PerfMonData.cxx

+///////////////////////// -*- C++ -*- /////////////////////////////
+// PerfMonData.cxx 
+// Implementation file for class PerfMon::Data
+// Author: S.Binet<binet@cern.ch>
+/////////////////////////////////////////////////////////////////// 
+
+
+// STL includes
+#include <ostream>
+
+// PerfMonEvent includes
+#include "PerfMonEvent/PerfMonData.h"
+
+namespace PerfMon {
+
+/////////////////////////////////////////////////////////////////// 
+// Public methods: 
+/////////////////////////////////////////////////////////////////// 
+
+Data::Data() :
+  m_mem( ),
+  m_cpu( ),
+  m_io ( )
+{}
+
+Data::Data( const Data& rhs ) :
+  m_mem( rhs.m_mem ),
+  m_cpu( rhs.m_cpu ),
+  m_io ( rhs.m_io  )
+{}
+
+Data& Data::operator=( const Data& rhs )
+{
+  if ( this != &rhs ) {
+    m_mem = rhs.m_mem;
+    m_cpu = rhs.m_cpu;
+    m_io  = rhs.m_io;
+  }
+  return *this;
+}
+
+Data::~Data()
+{}
+
+/////////////////////////////////////////////////////////////////// 
+// Const methods: 
+///////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////// 
+// Non-const methods: 
+/////////////////////////////////////////////////////////////////// 
+
+/////////////////////////////////////////////////////////////////// 
+// Protected methods: 
+/////////////////////////////////////////////////////////////////// 
+
+} //> end namespace PerfMon
+
+std::ostream& operator<<( std::ostream& out, const PerfMon::Data& o )
+{
+  out << "evt ===========\n" 
+      << "    " << o.mem()
+      << "    " << o.cpu()
+      << "    " << o.io ()
+    ;
+  return out;
+}

src/PerfMonIoData.cxx

+///////////////////////// -*- C++ -*- /////////////////////////////
+// PerfMonIoData.cxx 
+// Implementation file for class PerfMon::IoData
+// Author: S.Binet<binet@cern.ch>
+/////////////////////////////////////////////////////////////////// 
+
+
+// STL includes
+#include <ostream>
+
+// PerfMonEvent includes
+#include "PerfMonEvent/PerfMonIoData.h"
+
+namespace PerfMon {
+
+/////////////////////////////////////////////////////////////////// 
+// Public methods: 
+/////////////////////////////////////////////////////////////////// 
+
+IoData::IoData() :
+  m_commitOutput ( -1. )
+{}
+
+IoData::IoData( const IoData& rhs ) :
+  m_commitOutput ( rhs.m_commitOutput )
+{}
+
+IoData& IoData::operator=( const IoData& rhs )
+{
+  if ( this != &rhs ) {
+    m_commitOutput = rhs.m_commitOutput;
+  }
+  return *this;
+}
+
+IoData::~IoData()
+{}
+
+/////////////////////////////////////////////////////////////////// 
+// Const methods: 
+///////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////// 
+// Non-const methods: 
+/////////////////////////////////////////////////////////////////// 
+
+/////////////////////////////////////////////////////////////////// 
+// Protected methods: 
+/////////////////////////////////////////////////////////////////// 
+
+} //> end namespace PerfMon
+
+std::ostream& operator<<( std::ostream& out, const PerfMon::IoData& o )
+{
+  out << o.commitTime() << "\n";
+
+  return out;
+}

src/PerfMonMemData.cxx

+///////////////////////// -*- C++ -*- /////////////////////////////
+// PerfMonMemData.cxx 
+// Implementation file for class PerfMon::MemData
+// Author: S.Binet<binet@cern.ch>
+/////////////////////////////////////////////////////////////////// 
+
+
+// STL includes
+#include <ostream>
+
+// PerfMonEvent includes
+#include "PerfMonEvent/PerfMonMemData.h"
+
+namespace PerfMon {
+
+/////////////////////////////////////////////////////////////////// 
+// Public methods: 
+/////////////////////////////////////////////////////////////////// 
+
+MemData::MemData() :
+  m_vSize( -1. ),
+  m_rss  ( -1. )
+{}
+
+MemData::MemData( const MemData& rhs ) :
+  m_vSize( rhs.m_vSize ),
+  m_rss  ( rhs.m_rss   )
+{}
+
+MemData& MemData::operator=( const MemData& rhs )
+{
+  if ( this != &rhs ) {
+    m_vSize = rhs.m_vSize;
+    m_rss   = rhs.m_rss;
+  }
+  return *this;
+}
+
+MemData::~MemData()
+{}
+
+/////////////////////////////////////////////////////////////////// 
+// Const methods: 
+///////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////// 
+// Non-const methods: 
+/////////////////////////////////////////////////////////////////// 
+
+/////////////////////////////////////////////////////////////////// 
+// Protected methods: 
+/////////////////////////////////////////////////////////////////// 
+
+} //> end namespace PerfMon
+
+std::ostream& operator<<( std::ostream& out, const PerfMon::MemData& o )
+{
+  out << o.vsize() << "\t" 
+      << o.rss()   << "\n";
+
+  return out;
+}