1/*
| 1/*
|
| 2 * Copyright (c) 2012 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder. You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
|
2 * Copyright (c) 2004-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Nathan Binkert
| 14 * Copyright (c) 2004-2005 The Regents of The University of Michigan
15 * All rights reserved.
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions are
19 * met: redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer;
21 * redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution;
24 * neither the name of the copyright holders nor the names of its
25 * contributors may be used to endorse or promote products derived from
26 * this software without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 *
40 * Authors: Nathan Binkert
|
| 41 * Sascha Bischoff
|
29 */
30
31// This file will contain default statistics for the simulator that
32// don't really belong to a specific simulator object
33
34#include <fstream>
35#include <iostream>
36#include <list>
37
38#include "base/callback.hh"
39#include "base/hostinfo.hh"
40#include "base/statistics.hh"
41#include "base/time.hh"
42#include "config/the_isa.hh"
43#if THE_ISA == NO_ISA
44#include "arch/noisa/cpu_dummy.hh"
45#else
46#include "cpu/base.hh"
47#endif
48
49#include "sim/eventq.hh"
50#include "sim/stat_control.hh"
51
52using namespace std;
53
54Stats::Formula simSeconds;
55Stats::Value simTicks;
56Stats::Value finalTick;
57Stats::Value simFreq;
58
59namespace Stats {
60
61Time statTime(true);
62Tick startTick;
63
| 42 */
43
44// This file will contain default statistics for the simulator that
45// don't really belong to a specific simulator object
46
47#include <fstream>
48#include <iostream>
49#include <list>
50
51#include "base/callback.hh"
52#include "base/hostinfo.hh"
53#include "base/statistics.hh"
54#include "base/time.hh"
55#include "config/the_isa.hh"
56#if THE_ISA == NO_ISA
57#include "arch/noisa/cpu_dummy.hh"
58#else
59#include "cpu/base.hh"
60#endif
61
62#include "sim/eventq.hh"
63#include "sim/stat_control.hh"
64
65using namespace std;
66
67Stats::Formula simSeconds;
68Stats::Value simTicks;
69Stats::Value finalTick;
70Stats::Value simFreq;
71
72namespace Stats {
73
74Time statTime(true);
75Tick startTick;
76
|
| 77Event *dumpEvent;
78
|
64struct SimTicksReset : public Callback
65{
66 void process()
67 {
68 statTime.setTimer();
69 startTick = curTick();
70 }
71};
72
73double
74statElapsedTime()
75{
76 Time now;
77 now.setTimer();
78
79 Time elapsed = now - statTime;
80 return elapsed;
81}
82
83Tick
84statElapsedTicks()
85{
86 return curTick() - startTick;
87}
88
89Tick
90statFinalTick()
91{
92 return curTick();
93}
94
95SimTicksReset simTicksReset;
96
97struct Global
98{
99 Stats::Formula hostInstRate;
100 Stats::Formula hostOpRate;
101 Stats::Formula hostTickRate;
102 Stats::Value hostMemory;
103 Stats::Value hostSeconds;
104
105 Stats::Value simInsts;
106 Stats::Value simOps;
107
108 Global();
109};
110
111Global::Global()
112{
113 simInsts
114 .functor(BaseCPU::numSimulatedInsts)
115 .name("sim_insts")
116 .desc("Number of instructions simulated")
117 .precision(0)
118 .prereq(simInsts)
119 ;
120
121 simOps
122 .functor(BaseCPU::numSimulatedOps)
123 .name("sim_ops")
124 .desc("Number of ops (including micro ops) simulated")
125 .precision(0)
126 .prereq(simOps)
127 ;
128
129 simSeconds
130 .name("sim_seconds")
131 .desc("Number of seconds simulated")
132 ;
133
134 simFreq
135 .scalar(SimClock::Frequency)
136 .name("sim_freq")
137 .desc("Frequency of simulated ticks")
138 ;
139
140 simTicks
141 .functor(statElapsedTicks)
142 .name("sim_ticks")
143 .desc("Number of ticks simulated")
144 ;
145
146 finalTick
147 .functor(statFinalTick)
148 .name("final_tick")
149 .desc("Number of ticks from beginning of simulation \
150(restored from checkpoints and never reset)")
151 ;
152
153 hostInstRate
154 .name("host_inst_rate")
155 .desc("Simulator instruction rate (inst/s)")
156 .precision(0)
157 .prereq(simInsts)
158 ;
159
160 hostOpRate
161 .name("host_op_rate")
162 .desc("Simulator op (including micro ops) rate (op/s)")
163 .precision(0)
164 .prereq(simOps)
165 ;
166
167 hostMemory
168 .functor(memUsage)
169 .name("host_mem_usage")
170 .desc("Number of bytes of host memory used")
171 .prereq(hostMemory)
172 ;
173
174 hostSeconds
175 .functor(statElapsedTime)
176 .name("host_seconds")
177 .desc("Real time elapsed on the host")
178 .precision(2)
179 ;
180
181 hostTickRate
182 .name("host_tick_rate")
183 .desc("Simulator tick rate (ticks/s)")
184 .precision(0)
185 ;
186
187 simSeconds = simTicks / simFreq;
188 hostInstRate = simInsts / hostSeconds;
189 hostOpRate = simOps / hostSeconds;
190 hostTickRate = simTicks / hostSeconds;
191
192 registerResetCallback(&simTicksReset);
193}
194
195void
196initSimStats()
197{
198 static Global global;
199}
200
| 79struct SimTicksReset : public Callback
80{
81 void process()
82 {
83 statTime.setTimer();
84 startTick = curTick();
85 }
86};
87
88double
89statElapsedTime()
90{
91 Time now;
92 now.setTimer();
93
94 Time elapsed = now - statTime;
95 return elapsed;
96}
97
98Tick
99statElapsedTicks()
100{
101 return curTick() - startTick;
102}
103
104Tick
105statFinalTick()
106{
107 return curTick();
108}
109
110SimTicksReset simTicksReset;
111
112struct Global
113{
114 Stats::Formula hostInstRate;
115 Stats::Formula hostOpRate;
116 Stats::Formula hostTickRate;
117 Stats::Value hostMemory;
118 Stats::Value hostSeconds;
119
120 Stats::Value simInsts;
121 Stats::Value simOps;
122
123 Global();
124};
125
126Global::Global()
127{
128 simInsts
129 .functor(BaseCPU::numSimulatedInsts)
130 .name("sim_insts")
131 .desc("Number of instructions simulated")
132 .precision(0)
133 .prereq(simInsts)
134 ;
135
136 simOps
137 .functor(BaseCPU::numSimulatedOps)
138 .name("sim_ops")
139 .desc("Number of ops (including micro ops) simulated")
140 .precision(0)
141 .prereq(simOps)
142 ;
143
144 simSeconds
145 .name("sim_seconds")
146 .desc("Number of seconds simulated")
147 ;
148
149 simFreq
150 .scalar(SimClock::Frequency)
151 .name("sim_freq")
152 .desc("Frequency of simulated ticks")
153 ;
154
155 simTicks
156 .functor(statElapsedTicks)
157 .name("sim_ticks")
158 .desc("Number of ticks simulated")
159 ;
160
161 finalTick
162 .functor(statFinalTick)
163 .name("final_tick")
164 .desc("Number of ticks from beginning of simulation \
165(restored from checkpoints and never reset)")
166 ;
167
168 hostInstRate
169 .name("host_inst_rate")
170 .desc("Simulator instruction rate (inst/s)")
171 .precision(0)
172 .prereq(simInsts)
173 ;
174
175 hostOpRate
176 .name("host_op_rate")
177 .desc("Simulator op (including micro ops) rate (op/s)")
178 .precision(0)
179 .prereq(simOps)
180 ;
181
182 hostMemory
183 .functor(memUsage)
184 .name("host_mem_usage")
185 .desc("Number of bytes of host memory used")
186 .prereq(hostMemory)
187 ;
188
189 hostSeconds
190 .functor(statElapsedTime)
191 .name("host_seconds")
192 .desc("Real time elapsed on the host")
193 .precision(2)
194 ;
195
196 hostTickRate
197 .name("host_tick_rate")
198 .desc("Simulator tick rate (ticks/s)")
199 .precision(0)
200 ;
201
202 simSeconds = simTicks / simFreq;
203 hostInstRate = simInsts / hostSeconds;
204 hostOpRate = simOps / hostSeconds;
205 hostTickRate = simTicks / hostSeconds;
206
207 registerResetCallback(&simTicksReset);
208}
209
210void
211initSimStats()
212{
213 static Global global;
214}
215
|
| 216/**
217 * Event to dump and/or reset the statistics.
218 */
|
201class StatEvent : public Event
202{
203 private:
204 bool dump;
205 bool reset;
206 Tick repeat;
207
208 public:
209 StatEvent(bool _dump, bool _reset, Tick _repeat)
210 : Event(Stat_Event_Pri, AutoDelete),
211 dump(_dump), reset(_reset), repeat(_repeat)
212 {
213 }
214
215 virtual void
216 process()
217 {
218 if (dump)
219 Stats::dump();
220
221 if (reset)
222 Stats::reset();
223
224 if (repeat) {
225 Stats::schedStatEvent(dump, reset, curTick() + repeat, repeat);
226 }
227 }
228};
229
230void
231schedStatEvent(bool dump, bool reset, Tick when, Tick repeat)
232{
| 219class StatEvent : public Event
220{
221 private:
222 bool dump;
223 bool reset;
224 Tick repeat;
225
226 public:
227 StatEvent(bool _dump, bool _reset, Tick _repeat)
228 : Event(Stat_Event_Pri, AutoDelete),
229 dump(_dump), reset(_reset), repeat(_repeat)
230 {
231 }
232
233 virtual void
234 process()
235 {
236 if (dump)
237 Stats::dump();
238
239 if (reset)
240 Stats::reset();
241
242 if (repeat) {
243 Stats::schedStatEvent(dump, reset, curTick() + repeat, repeat);
244 }
245 }
246};
247
248void
249schedStatEvent(bool dump, bool reset, Tick when, Tick repeat)
250{
|
233 Event *event = new StatEvent(dump, reset, repeat);
234 mainEventQueue.schedule(event, when);
| 251 dumpEvent = new StatEvent(dump, reset, repeat);
252 mainEventQueue.schedule(dumpEvent, when);
|
235}
236
| 253}
254
|
| 255void
256periodicStatDump(uint64_t period)
257{
258 /*
259 * If the period is set to 0, then we do not want to dump periodically,
260 * thus we deschedule the event. Else, if the period is not 0, but the event
261 * has already been scheduled, we need to get rid of the old event before we
262 * create a new one, as the old event will no longer be moved forward in the
263 * event that we resume from a checkpoint.
264 */
265 if (dumpEvent != NULL && (period == 0 || dumpEvent->scheduled())) {
266 // Event should AutoDelete, so we do not need to free it.
267 mainEventQueue.deschedule(dumpEvent);
268 }
269
270 /*
271 * If the period is not 0, we schedule the event. If this is called with a
272 * period that is less than the current tick, then we shift the first dump
273 * by curTick. This ensures that we do not schedule the event is the past.
274 */
275 if (period != 0) {
276 // Schedule the event
277 if (period >= curTick()) {
278 schedStatEvent(true, true, (Tick)period, (Tick)period);
279 } else {
280 schedStatEvent(true, true, (Tick)period + curTick(), (Tick)period);
281 }
282 }
283}
284
285void
286updateEvents()
287{
288 /*
289 * If the dumpEvent has been scheduled, but is scheduled in the past, then
290 * we need to shift the event to be at a valid point in time. Therefore, we
291 * shift the event by curTick.
292 */
293 if (dumpEvent != NULL &&
294 (dumpEvent->scheduled() && dumpEvent->when() < curTick())) {
295 // shift by curTick() and reschedule
296 Tick _when = dumpEvent->when();
297 mainEventQueue.reschedule(dumpEvent, _when + curTick());
298 }
299}
300
|
237} // namespace Stats
| 301} // namespace Stats
|