Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/global/management/include/G4Timer.hh

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /global/management/include/G4Timer.hh (Version 11.3.0) and /global/management/include/G4Timer.hh (Version 3.2)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 // G4Timer                                     <<  23 //
                                                   >>  24 // $Id: G4Timer.hh,v 1.10.4.1 2001/06/28 19:10:03 gunter Exp $
                                                   >>  25 // GEANT4 tag $Name:  $
                                                   >>  26 //
                                                   >>  27 // 
                                                   >>  28 // ----------------------------------------------------------------------
                                                   >>  29 // Class G4Timer
 27 //                                                 30 //
 28 // Class description:                              31 // Class description:
 29 //                                                 32 //
 30 // Class for timer objects, able to measure el     33 // Class for timer objects, able to measure elasped user/system process time.
 31 //                                                 34 //
 32 // Note: Uses <sys/times.h> & <unistd.h> - POS     35 // Note: Uses <sys/times.h> & <unistd.h> - POSIX.1 defined
 33 //       If used, this header must be included     36 //       If used, this header must be included in the source (.cc) file and it
 34 //       must be the first header file to be i     37 //       must be the first header file to be included!
 35 //                                                 38 //
 36 // Member functions:                               39 // Member functions:
 37 //                                                 40 //
 38 // G4Timer()                                       41 // G4Timer()
 39 //   Construct a timer object                      42 //   Construct a timer object
 40 // Start()                                         43 // Start()
 41 //   Start timing                                  44 //   Start timing
 42 // Stop()                                          45 // Stop()
 43 //   Stop timing                                   46 //   Stop timing
 44 // G4bool IsValid()                                47 // G4bool IsValid()
 45 //   Return true if have a valid time (ie star     48 //   Return true if have a valid time (ie start() and stop() called)
 46 // G4double GetRealElapsed()                       49 // G4double GetRealElapsed()
 47 //   Return the elapsed real time between last     50 //   Return the elapsed real time between last calling start() and stop()
 48 // G4double GetSystemElapsed()                     51 // G4double GetSystemElapsed()
 49 //   Return the elapsed system time between la     52 //   Return the elapsed system time between last calling start() and stop()
 50 // G4double GetUserElapsed()                       53 // G4double GetUserElapsed()
 51 //   Return the elapsed user time between last     54 //   Return the elapsed user time between last calling start() and stop()
 52 //                                                 55 //
 53 // Operators:                                      56 // Operators:
 54 //                                                 57 //
 55 // std::ostream& operator << (std::ostream& os <<  58 // G4std::ostream& operator << (G4std::ostream& os, const G4Timer& t);
 56 //   Print the elapsed real,system and usertim     59 //   Print the elapsed real,system and usertimes on os. Prints **s for times
 57 //   if !IsValid                                   60 //   if !IsValid
 58 //                                                 61 //
 59 // Member data:                                    62 // Member data:
 60 //                                                 63 //
 61 // G4bool fValidTimes                              64 // G4bool fValidTimes
 62 //   True after start and stop have both been      65 //   True after start and stop have both been called more than once and
 63 //   an equal number of times                      66 //   an equal number of times
 64 // clock_t fStartRealTime,fEndRealTime             67 // clock_t fStartRealTime,fEndRealTime
 65 //   Real times (arbitrary time 0)                 68 //   Real times (arbitrary time 0)
 66 // tms fStartTimes,fEndTimes                       69 // tms fStartTimes,fEndTimes
 67 //   Timing structures (see times(2)) for star     70 //   Timing structures (see times(2)) for start and end times
 68                                                    71 
 69 // Author: P.Kent, 21.08.95 - First implementa <<  72 // History:
 70 // Revision: G.Cosmo, 29.04.97 - Added timings <<  73 // 23.08.96 P.Kent Updated to also computed real elapsed time
 71 // ------------------------------------------- <<  74 // 21.08.95 P.Kent
                                                   >>  75 // 29.04.97 G.Cosmo Added timings for Windows/NT
                                                   >>  76 
 72 #ifndef G4TIMER_HH                                 77 #ifndef G4TIMER_HH
 73 #define G4TIMER_HH 1                           <<  78 #define G4TIMER_HH
 74                                                    79 
 75 #if !(defined(WIN32) || defined(__MINGW32__))  <<  80 #ifndef WIN32
 76 #  include <sys/times.h>                       << 
 77 #  include <unistd.h>                              81 #  include <unistd.h>
                                                   >>  82 #  include <sys/times.h>
 78 #else                                              83 #else
 79 #  include <time.h>                                84 #  include <time.h>
 80 #  define _SC_CLK_TCK 1                        <<  85 #  define _SC_CLK_TCK    1
 81                                                    86 
 82 extern "C"                                     <<  87    extern "C" {
 83 {                                              <<  88           int sysconf(int);
 84   int sysconf(int);                            <<  89    };
 85 };                                             <<  90 
                                                   >>  91    // Structure returned by times()
                                                   >>  92   
                                                   >>  93    struct tms {
                                                   >>  94       clock_t tms_utime;           /* user time */
                                                   >>  95       clock_t tms_stime;           /* system time */
                                                   >>  96       clock_t tms_cutime;          /* user time, children */
                                                   >>  97       clock_t tms_cstime;          /* system time, children */
                                                   >>  98    };
                                                   >>  99 
                                                   >> 100    extern "C" {
                                                   >> 101       extern clock_t times(struct tms *);
                                                   >> 102    };
                                                   >> 103 #endif  /* WIN32 */
 86                                                   104 
 87 // Structure returned by times()               << 105 #include "G4Types.hh"
                                                   >> 106 #include "G4ios.hh"
 88                                                   107 
 89 struct tms                                     << 108 class G4Timer
 90 {                                                 109 {
 91   clock_t tms_utime;  /* user time */          << 110 public:
 92   clock_t tms_stime;  /* system time */        << 111     G4Timer() : fValidTimes(false) {;}
 93   clock_t tms_cutime; /* user time, children * << 
 94   clock_t tms_cstime; /* system time, children << 
 95 };                                             << 
 96                                                   112 
 97 extern "C"                                     << 113     inline void Start();
 98 {                                              << 114     inline void Stop();
 99   extern clock_t times(struct tms*);           << 115     inline G4bool IsValid() const;
                                                   >> 116     G4double GetRealElapsed() const;
                                                   >> 117     G4double GetSystemElapsed() const;
                                                   >> 118     G4double GetUserElapsed() const;
                                                   >> 119 private:
                                                   >> 120     G4bool fValidTimes;
                                                   >> 121     clock_t fStartRealTime,fEndRealTime;
                                                   >> 122     tms fStartTimes,fEndTimes;
100 };                                                123 };
101 #endif /* WIN32 */                             << 
102                                                   124 
103 #include "G4Types.hh"                          << 125 G4std::ostream& operator << (G4std::ostream& os, const G4Timer& t);
104 #include "G4ios.hh"                            << 
105                                                   126 
106 #include <chrono>                              << 127 // Inline functions:
107                                                   128 
108 class G4Timer                                  << 129 inline void G4Timer::Start()
109 {                                                 130 {
110  public:                                       << 131     fValidTimes=false;
111   inline void Start();                         << 132     fStartRealTime=times(&fStartTimes);
112   inline void Stop();                          << 133 }
113   inline G4bool IsValid() const;               << 
114   inline const char* GetClockTime() const;     << 
115   G4double GetRealElapsed() const;             << 
116   G4double GetSystemElapsed() const;           << 
117   G4double GetUserElapsed() const;             << 
118                                                << 
119  private:                                      << 
120   G4bool fValidTimes{false};                   << 
121   using clock_type = std::chrono::high_resolut << 
122   std::chrono::time_point<clock_type> fStartRe << 
123   tms fStartTimes, fEndTimes;                  << 
124 };                                             << 
125                                                   134 
126 std::ostream& operator<<(std::ostream& os, con << 135 inline void G4Timer::Stop()
                                                   >> 136 {
                                                   >> 137     fEndRealTime=times(&fEndTimes);
                                                   >> 138     fValidTimes=true;
                                                   >> 139 }
127                                                   140 
128 #include "G4Timer.icc"                         << 141 inline G4bool G4Timer::IsValid() const
                                                   >> 142 {
                                                   >> 143     return fValidTimes;
                                                   >> 144 }
                                                   >> 145 
                                                   >> 146 #define times ostimes
129                                                   147 
130 #endif                                            148 #endif
                                                   >> 149 
131                                                   150