Attachment #635 for bug #691

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

(-)a/src/core/system-wall-clock-ms.h (-3 / +24 lines)

Lines 25-30	Link Here

/**

/**

 * \brief measure wall-clock time in milliseconds

 * \brief measure wall-clock time in milliseconds

 * \todo This class exists also in non-unix systems but is not

 * implemented and always return zero as measurd time.

*/

*/

class SystemWallClockMs {

class SystemWallClockMs {

public:

public:

Lines 36-48	Link Here

*/

*/

  void Start (void);

  void Start (void);

/**

/**

   * \returns the measured elapsed wall clock time since

   * \brief Stop measuring the time since Start() was called.

   *          ns3::SystemWallClockMs::start was invoked.

   * \returns the measured elapsed wall clock time (in milliseconds) since

   *          ns3::SystemWallClockMs::Start was invoked.

   * It is possible to start a new measurement with ns3::SystemWallClockMs::start

   * It is possible to start a new measurement with ns3::SystemWallClockMs::Start

   * after this method returns.

   * after this method returns.

*/

*/

  unsigned long long End (void);

  unsigned long long End (void);

/**

   * \returns the measured elapsed wall clock time (in milliseconds) since

   *          ns3::SystemWallClockMs::Start was invoked.

*/

  double GetElapsedReal (void) const;

/**

   * \returns the measured elapsed 'user' wall clock time (in milliseconds) since

   *          ns3::SystemWallClockMs::Start was invoked.

*/

  double GetElapsedUser (void) const;

/**

   * \returns the measured elapsed 'system' wall clock time (in milliseconds) since

   *          ns3::SystemWallClockMs::Start was invoked.

*/

  double GetElapsedSystem (void) const;

private:

private:

  class SystemWallClockMsPrivate *m_priv;

  class SystemWallClockMsPrivate *m_priv;

};

};




void
TestCase::DoReportStart  (void)
{
  m_clock.Start ();

  if (m_ofs == 0)
    {

void
TestCase::DoReportEnd  (void)
{
  m_clock.End ();

  if (m_ofs == 0)
    {
      return;
    }

  struct tms endTimes;
  clock_t endTime = times (&endTimes);

  clock_t elapsed = endTime - m_startTime;
  clock_t elapsedUsr = endTimes.tms_utime - m_startTimes.tms_utime;
  clock_t elapsedSys = endTimes.tms_stime - m_startTimes.tms_stime;

  (*m_ofs).precision (2);
  *m_ofs << std::fixed;

  *m_ofs << "    <CaseTime>" << "real " << m_clock.GetElapsedReal () * 1e-3
                             << " user " << m_clock.GetElapsedUser () * 1e-3
                             << " system " << m_clock.GetElapsedSystem () * 1e-3
         << "</CaseTime>" << std::endl;

  *m_ofs << "  </TestCase>" << std::endl;

void
TestSuite::DoReportStart (void)
{
  m_clock.Start ();
  
  if (m_ofs == 0)
    {
      return;

void
TestSuite::DoReportEnd (void)
{
  m_clock.End ();
  
  if (m_ofs == 0)
    {
      return;
    }
  struct tms endTimes;
  clock_t endTime = times (&endTimes);

  clock_t elapsed = endTime - m_startTime;
  clock_t elapsedUsr = endTimes.tms_utime - m_startTimes.tms_utime;
  clock_t elapsedSys = endTimes.tms_stime - m_startTimes.tms_stime;

  (*m_ofs).precision (2);
  *m_ofs << std::fixed;

  *m_ofs << "  <SuiteTime>" << "real " << m_clock.GetElapsedReal () * 1e-3
                            << " user " << m_clock.GetElapsedUser () * 1e-3
                            << " system " << m_clock.GetElapsedSystem () * 1e-3
         << "</SuiteTime>" << std::endl;

  *m_ofs << "</TestSuite>" << std::endl;

(-)a/src/core/test.h (-7 / +7 lines)

Lines 27-33	Link Here

#include <list>

#include <list>

#include <limits>

#include <limits>

#include <stdint.h>

#include <stdint.h>

#include <sys/times.h>

#include "ns3/system-wall-clock-ms.h"

//

//

// Note on below macros:

// Note on below macros:

//

//

Lines 821-826	Link Here

821

  TestCase (TestCase& tc);

824

  TestCase (TestCase& tc);

822

  TestCase& operator= (TestCase& tc);

825

  TestCase& operator= (TestCase& tc);

823

826

827

  SystemWallClockMs m_clock;

824

  std::string m_name;

828

  std::string m_name;

825

  bool m_verbose;

829

  bool m_verbose;

826

  bool m_continueOnFailure;

830

  bool m_continueOnFailure;

Lines 828-835	Link Here

828

  std::string m_basedir;

832

  std::string m_basedir;

829

  std::ofstream *m_ofs;

833

  std::ofstream *m_ofs;

830

  bool m_error;

834

  bool m_error;

831

  clock_t m_startTime;

832

  struct tms m_startTimes;

833

};

835

};

834

836

835

/**

837

/**

Lines 1057-1062	Link Here

1057

  TestSuite (TestSuite& ts);

1059

  TestSuite (TestSuite& ts);

1058

  TestSuite& operator= (TestSuite& ts);

1060

  TestSuite& operator= (TestSuite& ts);

1059

1061

1062

  SystemWallClockMs m_clock;

1060

  std::string m_name;

1063

  std::string m_name;

1061

  bool m_verbose;

1064

  bool m_verbose;

1062

  bool m_continueOnFailure;

1065

  bool m_continueOnFailure;

Lines 1064-1073	Link Here

1064

  std::ofstream *m_ofs;

1067

  std::ofstream *m_ofs;

1065

  bool m_error;

1068

  bool m_error;

1066

  TestType m_type;

1069

  TestType m_type;

1067

1070

1068

  clock_t m_startTime;

1069

  struct tms m_startTimes;

1070

1071

  typedef std::vector<TestCase *> TestCaseVector_t;

1071

  typedef std::vector<TestCase *> TestCaseVector_t;

1072

  TestCaseVector_t m_tests;

1072

  TestCaseVector_t m_tests;

1073

};

1073

};

(-)a/src/core/unix-system-wall-clock-ms.cc (-10 / +59 lines)

Lines 19-25	Link Here

*/

*/

#include "system-wall-clock-ms.h"

#include "system-wall-clock-ms.h"

#include <sys/time.h>

#include <sys/times.h>

#include <unistd.h>

#include <limits.h>

namespace ns3 {

namespace ns3 {

Lines 27-54	Link Here

public:

public:

  void Start (void);

  void Start (void);

  unsigned long long End (void);

  unsigned long long End (void);

  double GetElapsedReal (void) const;

  double GetElapsedUser (void) const;

  double GetElapsedSystem (void) const;

private:

private:

  struct timeval m_startTv;

  struct tms m_startTimes;

  struct timeval m_endTv;

  clock_t m_startTime;

  double m_elapsedReal;

  double m_elapsedUser;

  double m_elapsedSystem;

};

};

void

void

SystemWallClockMsPrivate::Start (void)

SystemWallClockMsPrivate::Start (void)

  struct timezone tz;

  m_startTime = times (&m_startTimes);

  gettimeofday (&m_startTv, &tz);

unsigned long long

unsigned long long

SystemWallClockMsPrivate::End (void)

SystemWallClockMsPrivate::End (void)

  struct timezone tz;

  static long ticksPerSecond = sysconf (_SC_CLK_TCK);

  gettimeofday (&m_endTv, &tz);

  unsigned long long end = m_endTv.tv_sec *1000 + m_endTv.tv_usec / 1000;

  struct tms endTimes;

  unsigned long long start = m_startTv.tv_sec *1000 + m_startTv.tv_usec / 1000;

  clock_t endTime = times (&endTimes);

  return end - start;

  m_elapsedReal = 1e3 * static_cast<double> (endTime - m_startTime) / ticksPerSecond;

  m_elapsedUser = 1e3 * static_cast<double> (endTimes.tms_utime - m_startTimes.tms_utime) / ticksPerSecond;

  m_elapsedSystem = 1e3 * static_cast<double> (endTimes.tms_stime - m_startTimes.tms_stime) / ticksPerSecond;

  return m_elapsedReal;

double

SystemWallClockMsPrivate::GetElapsedReal (void) const

  return m_elapsedReal;

double

SystemWallClockMsPrivate::GetElapsedUser (void) const

  return m_elapsedUser;

double

SystemWallClockMsPrivate::GetElapsedSystem (void) const

  return m_elapsedSystem;

SystemWallClockMs::SystemWallClockMs ()

SystemWallClockMs::SystemWallClockMs ()

  : m_priv (new SystemWallClockMsPrivate ())

  : m_priv (new SystemWallClockMsPrivate ())

{}

{}

Lines 70-73	Link Here

  return m_priv->End ();

101

  return m_priv->End ();

102

103

104

double

105

SystemWallClockMs::GetElapsedReal (void) const

106

107

  return m_priv->GetElapsedReal ();

108

109

110

double

111

SystemWallClockMs::GetElapsedUser (void) const

112

113

  return m_priv->GetElapsedUser ();

114

115

116

double

117

SystemWallClockMs::GetElapsedSystem (void) const

118

119

  return m_priv->GetElapsedSystem ();

120

121

}; // namespace ns3

122

}; // namespace ns3




  return m_priv->End ();
}

double
SystemWallClockMs::GetElapsedReal (void) const
{
  return 0;
}

double
SystemWallClockMs::GetElapsedUser (void) const
{
  return 0;
}

double
SystemWallClockMs::GetElapsedSystem (void) const
{
  return 0;
}

}; // namespace ns3

Return to bug 691