blob: 52740f6456f2376110e4c6cb2f67c5b19faa52ab (
plain)
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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
/* -*- C++ -*- */
//=============================================================================
/**
* @file Timeprobe_T.h
*
* $Id$
*
* @author Irfan Pyarali
*/
//=============================================================================
#ifndef ACE_TIMEPROBE_T_H
#define ACE_TIMEPROBE_T_H
#include "ace/pre.h"
#include "ace/OS.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#if defined (ACE_COMPILE_TIMEPROBES)
#include "ace/Unbounded_Set.h"
/**
* @class ACE_Timeprobe
*
* @brief This class is used to instrument code. This is accomplished
* by inserting time probes at different location in the code.
* ACE_Timeprobe then measures the time difference between two
* time probes.
*
* This class provides a lightweight implementation for
* measuring the time required to execute code between two time
* probes. When a time probe executes, it records the time, the
* id of the calling thread, and an event description. The
* event description can either be an unsigned long or a string
* (char *). If string are used, care must be taken cause only
* pointer copies are done and the string data is *not* copied.
* The recorded time probes can then be printed by calling
* <print_times>. If you have used unsigned longs as event
* descriptions in any of your time probes, you must have
* provided an event description table that maps the unsigned
* longs to readable strings. This map is a simple array of
* strings, and the event number is used as the index into the
* array when looking for the event description. If you have
* only used strings for the event description, this map is not
* necessary.
* Multiple maps can also be used to chunk up the time probes.
* Each one can be added by calling <event_descriptions>.
* Different tables are used internally by consulting the
* minimum_id for each table. It is up to the user to make sure
* that multiple tables do not share the same event id range.
*/
template <class ACE_LOCK>
class ACE_Timeprobe
{
public:
/// Self
typedef ACE_Timeprobe<ACE_LOCK>
SELF;
/// We can hold multiple event description tables.
typedef ACE_Unbounded_Set<ACE_Event_Descriptions>
EVENT_DESCRIPTIONS;
/// Create Timeprobes with <size> slots
ACE_Timeprobe (u_long size = ACE_DEFAULT_TIMEPROBE_TABLE_SIZE);
/// Destructor.
~ACE_Timeprobe (void);
/// Record a time. <event> is used to describe this time probe.
void timeprobe (u_long event);
/// Record a time. <id> is used to describe this time probe.
void timeprobe (const char *id);
/// Record event descriptions.
int event_descriptions (const char **descriptions,
u_long minimum_id);
/// Print the time probes.
void print_times (void);
/// Print the time probes.
void print_absolute_times (void);
/// Reset the slots. All old time probes will be lost.
void reset (void);
ACE_Timeprobe (const ACE_Timeprobe<ACE_LOCK> &);
// Not implemented (stupid MSVC won't let it be protected).
// = (Somewhat private) Accessors
/// Event Descriptions
ACE_Unbounded_Set<ACE_Event_Descriptions> &event_descriptions (void);
/// Sorted Event Descriptions.
ACE_Unbounded_Set<ACE_Event_Descriptions> &sorted_event_descriptions (void);
/// VME slot address.
u_int *current_slot_vme_address (void);
/// Find description of event <i>
const char *find_description_i (u_long i);
/// Sort event descriptions
void sort_event_descriptions_i (void);
/// Time probe slots
ACE_timeprobe_t *timeprobes (void);
/// Synchronization variable.
ACE_LOCK &lock (void);
/// Max size of timestamp table
u_long max_size (void);
/// Current size of timestamp table
u_long current_size (void);
protected:
/// Event Descriptions
EVENT_DESCRIPTIONS event_descriptions_;
/// Sorted Event Descriptions.
EVENT_DESCRIPTIONS sorted_event_descriptions_;
/// Added sections below here to make compatible with the VMETRO
/// board test.
u_int *current_slot_vme_address_;
/// Time probe slots
ACE_timeprobe_t *timeprobes_;
/// Synchronization variable.
ACE_LOCK lock_;
/// Max size of timestamp table
u_long max_size_;
/// Current size of timestamp table
u_long current_size_;
};
/**
* @class ACE_Function_Timeprobe
*
* @brief Auto pointer like time probes. It will record <event> on
* construction and <event + 1> on destruction.
*/
template <class Timeprobe>
class ACE_Function_Timeprobe
{
public:
/// Constructor.
ACE_Function_Timeprobe (Timeprobe &timeprobe,
u_long event);
/// Destructor.
~ACE_Function_Timeprobe (void);
protected:
/// Reference to timeprobe.
Timeprobe &timeprobe_;
/// Event.
u_long event_;
};
#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
#include "ace/Timeprobe_T.cpp"
#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
#pragma implementation ("Timeprobe_T.cpp")
#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
#endif /* ACE_COMPILE_TIMEPROBES */
#include "ace/post.h"
#endif /* ACE_TIMEPROBE_T_H */
|
