/usr/include/sc/util/misc/regtime.h is in libsc-dev 2.3.1-16.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 | //
// regtime.h
//
// Copyright (C) 1996 Limit Point Systems, Inc.
//
// Author: Curtis Janssen <cljanss@limitpt.com>
// Maintainer: LPS
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// The SC Toolkit 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 Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with the SC Toolkit; see the file COPYING.LIB. If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//
#ifdef __GNUC__
#pragma interface
#endif
#ifndef _util_misc_regtime_h
#define _util_misc_regtime_h
#include <iostream>
#include <string>
#include <util/class/class.h>
namespace sc {
class TimedRegion {
private:
char *name_;
TimedRegion *up_;
TimedRegion *subregions_;
TimedRegion *next_;
TimedRegion *prev_;
double cpu_time_;
double wall_time_;
double cpu_enter_;
double wall_enter_;
double flops_;
double flops_enter_;
TimedRegion *insert_after(const char *name);
TimedRegion *insert_before(const char *name);
public:
TimedRegion(const char *name);
~TimedRegion();
const char *name() const { return name_; }
TimedRegion *findinsubregion(const char *);
void cpu_enter(double);
void wall_enter(double);
void flops_enter(double);
void cpu_exit(double);
void wall_exit(double);
void flops_exit(double);
void cpu_add(double t) { cpu_time_ += t; }
void wall_add(double t) { wall_time_ += t; }
void flops_add(double t) { flops_ += t; }
TimedRegion *up() const { return up_; }
TimedRegion *subregions() const { return subregions_; }
TimedRegion *next() const { return next_; }
TimedRegion *prev() const { return prev_; }
int nregion();
void get_region_names(const char *names[]);
void get_wall_times(double *);
void get_cpu_times(double *);
void get_flops(double *);
void get_depth(int *, int depth = 0);
};
/** The RegionTimer class is used to record the time spent in a section of
code. During the run of a code, enter and exit members are called to begin
and end timed sections. The print member is used to display the obtained
times. Multiple enter calls for a region with the same name aggregate the
timings. Nested regions are supported. */
class RegionTimer: public DescribedClass {
protected:
int wall_time_;
int cpu_time_;
int flops_;
TimedRegion *top_;
TimedRegion *current_;
TimedRegion *default_;
public:
RegionTimer(const char *topname = "total",
int cpu_time = 0, int wall_time = 1);
RegionTimer(const Ref<KeyVal> &);
~RegionTimer();
void enter(const char * = 0);
void change(const char *newname, const char * oldname = 0);
void exit(const char * = 0, bool do_not_throw = false);
void set_default(const char *);
void unset_default();
void enter_default();
void exit_default();
virtual void print(std::ostream& = ExEnv::out0()) const;
void update_top() const;
int nregion() const;
void get_region_names(const char *names[]) const;
void get_wall_times(double *) const;
void get_cpu_times(double *) const;
void get_flops(double *) const;
void get_depth(int *) const;
double get_wall_time() const;
double get_cpu_time() const;
double get_flops() const;
void add_wall_time(const char *, double);
void add_cpu_time(const char *, double);
void add_flops(const char *, double);
static RegionTimer *default_regiontimer();
static void set_default_regiontimer(const Ref<RegionTimer> &);
};
/** The Timer class uses RegionTimer to time intervals in an exception safe
manner. It will automatically call RegionTimer::enter when its constructor
is called and RegionTimer::exit when its destructor is called. The reset
member can also result in RegionTimer's enter and exit routines being
called. The programmer is responsible for making sure that timers are
exited in the reverse of the order that they are entered. */
class Timer {
Ref<RegionTimer> timer_;
std::string name_;
bool active_;
public:
/** Start timing a region using the default RegionTimer and activate
the timer. If a null name pointer is given, then the
timer will not be activated. */
Timer(const char *name);
/** Start timing a region using the given RegionTimer. If a null name
pointer is given, then the timer will not be activated. */
Timer(const Ref<RegionTimer> &, const char *name);
/** Stop timing a region, if active. */
~Timer();
/** Stop timing the current region, if active. If a new region name is
passed in, start timing with that name. If no region name is
given, the Timer will be deactivated. */
void reset(const char * = 0);
};
}
#endif
// Local Variables:
// mode: c++
// c-file-style: "CLJ"
// End:
|