gem5  v20.1.0.0
statistics.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2019-2020 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  *
14  * Copyright (c) 2003-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 
41 #include "base/statistics.hh"
42 
43 #include <fstream>
44 #include <iomanip>
45 #include <list>
46 #include <map>
47 #include <string>
48 
49 #include "base/callback.hh"
50 #include "base/cprintf.hh"
51 #include "base/debug.hh"
52 #include "base/hostinfo.hh"
53 #include "base/logging.hh"
54 #include "base/str.hh"
55 #include "base/time.hh"
56 #include "base/trace.hh"
57 #include "sim/root.hh"
58 
59 using namespace std;
60 
61 namespace Stats {
62 
63 std::string Info::separatorString = "::";
64 
65 // We wrap these in a function to make sure they're built in time.
68 {
69  static list<Info *> the_list;
70  return the_list;
71 }
72 
73 MapType &
75 {
76  static MapType the_map;
77  return the_map;
78 }
79 
80 void
81 InfoAccess::setInfo(Group *parent, Info *info)
82 {
83  panic_if(statsMap().find(this) != statsMap().end() ||
84  _info != nullptr,
85  "shouldn't register stat twice!");
86 
87  // New-style stats are reachable through the hierarchy and
88  // shouldn't be added to the global lists.
89  if (parent) {
90  _info = info;
91  return;
92  }
93 
94  statsList().push_back(info);
95 
96 #ifndef NDEBUG
98 #endif
99  statsMap().insert(make_pair(this, info));
100  assert(result.second && "this should never fail");
101  assert(statsMap().find(this) != statsMap().end());
102 }
103 
104 void
105 InfoAccess::setParams(const StorageParams *params)
106 {
107  info()->storageParams = params;
108 }
109 
110 void
111 InfoAccess::setInit()
112 {
113  info()->flags.set(init);
114 }
115 
116 Info *
117 InfoAccess::info()
118 {
119  if (_info) {
120  // New-style stats
121  return _info;
122  } else {
123  // Legacy stats
124  MapType::const_iterator i = statsMap().find(this);
125  assert(i != statsMap().end());
126  return (*i).second;
127  }
128 }
129 
130 const Info *
131 InfoAccess::info() const
132 {
133  if (_info) {
134  // New-style stats
135  return _info;
136  } else {
137  // Legacy stats
138  MapType::const_iterator i = statsMap().find(this);
139  assert(i != statsMap().end());
140  return (*i).second;
141  }
142 }
143 
144 StorageParams::~StorageParams()
145 {
146 }
147 
148 NameMapType &
150 {
151  static NameMapType the_map;
152  return the_map;
153 }
154 
155 int Info::id_count = 0;
156 
157 int debug_break_id = -1;
158 
159 Info::Info()
160  : flags(none), precision(-1), prereq(0), storageParams(NULL)
161 {
162  id = id_count++;
163  if (debug_break_id >= 0 and debug_break_id == id)
165 }
166 
168 {
169 }
170 
171 bool
172 validateStatName(const string &name)
173 {
174  if (name.empty())
175  return false;
176 
177  vector<string> vec;
178  tokenize(vec, name, '.');
179  vector<string>::const_iterator item = vec.begin();
180  while (item != vec.end()) {
181  if (item->empty())
182  return false;
183 
184  string::const_iterator c = item->begin();
185 
186  // The first character is different
187  if (!isalpha(*c) && *c != '_')
188  return false;
189 
190  // The rest of the characters have different rules.
191  while (++c != item->end()) {
192  if (!isalnum(*c) && *c != '_')
193  return false;
194  }
195 
196  ++item;
197  }
198 
199  return true;
200 }
201 
202 void
203 Info::setName(const string &name)
204 {
205  setName(nullptr, name);
206 }
207 
208 void
209 Info::setName(const Group *parent, const string &name)
210 {
211  if (!validateStatName(name))
212  panic("invalid stat name '%s'", name);
213 
214  // We only register the stat with the nameMap() if we are using
215  // old-style stats without a parent group. New-style stats should
216  // be unique since their names should correspond to a member
217  // variable.
218  if (!parent) {
219  auto p = nameMap().insert(make_pair(name, this));
220 
221  if (!p.second)
222  panic("same statistic name used twice! name=%s\n",
223  name);
224  }
225 
226  this->name = name;
227 }
228 
229 bool
230 Info::less(Info *stat1, Info *stat2)
231 {
232  const string &name1 = stat1->name;
233  const string &name2 = stat2->name;
234 
235  vector<string> v1;
236  vector<string> v2;
237 
238  tokenize(v1, name1, '.');
239  tokenize(v2, name2, '.');
240 
241  size_type last = min(v1.size(), v2.size()) - 1;
242  for (off_type i = 0; i < last; ++i)
243  if (v1[i] != v2[i])
244  return v1[i] < v2[i];
245 
246  // Special compare for last element.
247  if (v1[last] == v2[last])
248  return v1.size() < v2.size();
249  else
250  return v1[last] < v2[last];
251 
252  return false;
253 }
254 
255 bool
257 {
258  if (!(flags & Stats::init)) {
259 #ifdef DEBUG
260  cprintf("this is stat number %d\n", id);
261 #endif
262  panic("Not all stats have been initialized.\n"
263  "You may need to add <ParentClass>::regStats() to a"
264  " new SimObject's regStats() function. Name: %s",
265  name);
266  return false;
267  }
268 
269  if ((flags & display) && name.empty()) {
270  panic("all printable stats must be named");
271  return false;
272  }
273 
274  return true;
275 }
276 
277 void
279 {
280 }
281 
282 void
284 {
285  size_type s = size();
286  if (subnames.size() < s)
287  subnames.resize(s);
288  if (subdescs.size() < s)
289  subdescs.resize(s);
290 }
291 
292 void
294 {
295  size_type s = size();
296  if (subnames.size() < s)
297  subnames.resize(s);
298  if (subdescs.size() < s)
299  subdescs.resize(s);
300 }
301 
302 void
304 {
305  if (subnames.size() < x)
306  subnames.resize(x);
307  if (subdescs.size() < x)
308  subdescs.resize(x);
309  if (y_subnames.size() < y)
310  y_subnames.resize(y);
311 }
312 
313 void
315 {
316  int size = cvec.size();
317  int zero = size / 2; // round down!
318  int top_half = zero + (size - zero + 1) / 2; // round up!
319  int bottom_half = (size - zero) / 2; // round down!
320 
321  // grow down
322  int low_pair = zero - 1;
323  for (int i = zero - 1; i >= bottom_half; i--) {
324  cvec[i] = cvec[low_pair];
325  if (low_pair - 1 >= 0)
326  cvec[i] += cvec[low_pair - 1];
327  low_pair -= 2;
328  }
329  assert(low_pair == 0 || low_pair == -1 || low_pair == -2);
330 
331  for (int i = bottom_half - 1; i >= 0; i--)
332  cvec[i] = Counter();
333 
334  // grow up
335  int high_pair = zero;
336  for (int i = zero; i < top_half; i++) {
337  cvec[i] = cvec[high_pair];
338  if (high_pair + 1 < size)
339  cvec[i] += cvec[high_pair + 1];
340  high_pair += 2;
341  }
342  assert(high_pair == size || high_pair == size + 1);
343 
344  for (int i = top_half; i < size; i++)
345  cvec[i] = Counter();
346 
347  max_bucket *= 2;
348  min_bucket *= 2;
349  bucket_size *= 2;
350 }
351 
352 void
354 {
355  int size = cvec.size();
356  int half = (size + 1) / 2; // round up!
357  //bool even = (size & 1) == 0;
358 
359  int pair = size - 1;
360  for (int i = size - 1; i >= half; --i) {
361  cvec[i] = cvec[pair];
362  if (pair - 1 >= 0)
363  cvec[i] += cvec[pair - 1];
364  pair -= 2;
365  }
366 
367  for (int i = half - 1; i >= 0; i--)
368  cvec[i] = Counter();
369 
370  min_bucket = -max_bucket;// - (even ? bucket_size : 0);
371  bucket_size *= 2;
372 }
373 
374 void
376 {
377  int size = cvec.size();
378  int half = (size + 1) / 2; // round up!
379 
380  int pair = 0;
381  for (int i = 0; i < half; i++) {
382  cvec[i] = cvec[pair];
383  if (pair + 1 < size)
384  cvec[i] += cvec[pair + 1];
385  pair += 2;
386  }
387  assert(pair == size || pair == size + 1);
388 
389  for (int i = half; i < size; i++)
390  cvec[i] = Counter();
391 
392  max_bucket *= 2;
393  bucket_size *= 2;
394 }
395 
396 void
398 {
399  int b_size = hs->size();
400  assert(size() == b_size);
401  assert(min_bucket == hs->min_bucket);
402 
403  sum += hs->sum;
404  logs += hs->logs;
405  squares += hs->squares;
406  samples += hs->samples;
407 
408  while (bucket_size > hs->bucket_size)
409  hs->grow_up();
410  while (bucket_size < hs->bucket_size)
411  grow_up();
412 
413  for (uint32_t i = 0; i < b_size; i++)
414  cvec[i] += hs->cvec[i];
415 }
416 
417 Formula::Formula(Group *parent, const char *name, const char *desc)
418  : DataWrapVec<Formula, FormulaInfoProxy>(parent, name, desc)
419 
420 {
421 }
422 
423 
424 
425 Formula::Formula(Group *parent, const char *name, const char *desc,
426  const Temp &r)
427  : DataWrapVec<Formula, FormulaInfoProxy>(parent, name, desc)
428 {
429  *this = r;
430 }
431 
432 const Formula &
434 {
435  assert(!root && "Can't change formulas");
436  root = r.getNodePtr();
437  setInit();
438  assert(size());
439  return *this;
440 }
441 
442 const Formula &
444 {
445  if (root)
446  root = NodePtr(new BinaryNode<std::plus<Result> >(root, r));
447  else {
448  root = r.getNodePtr();
449  setInit();
450  }
451 
452  assert(size());
453  return *this;
454 }
455 
456 const Formula &
458 {
459  assert (root);
460  root = NodePtr(new BinaryNode<std::divides<Result> >(root, r));
461 
462  assert(size());
463  return *this;
464 }
465 
466 
467 void
469 {
470  if (root)
471  vec = root->result();
472 }
473 
474 Result
476 {
477  return root ? root->total() : 0.0;
478 }
479 
480 size_type
482 {
483  if (!root)
484  return 0;
485  else
486  return root->size();
487 }
488 
489 void
491 {
492 }
493 
494 bool
496 {
497  VResult vec;
498  result(vec);
499  for (VResult::size_type i = 0; i < vec.size(); ++i)
500  if (vec[i] != 0.0)
501  return false;
502  return true;
503 }
504 
505 string
507 {
508  return root ? root->str() : "";
509 }
510 
513 
514 void
515 registerHandlers(Handler reset_handler, Handler dump_handler)
516 {
517  resetHandler = reset_handler;
518  dumpHandler = dump_handler;
519 }
520 
523 
524 void
526 {
528 }
529 
530 void
532 {
533  dumpQueue.process();
534 }
535 
536 void
537 registerResetCallback(const std::function<void()> &callback)
538 {
539  resetQueue.push_back(callback);
540 }
541 
542 bool _enabled = false;
543 
544 bool
546 {
547  return _enabled;
548 }
549 
550 void
552 {
553  if (_enabled)
554  fatal("Stats are already enabled");
555 
556  _enabled = true;
557 }
558 
559 void
561 {
562  if (dumpHandler)
563  dumpHandler();
564  else
565  fatal("No registered Stats::dump handler");
566 }
567 
568 void
570 {
571  if (resetHandler)
572  resetHandler();
573  else
574  fatal("No registered Stats::reset handler");
575 }
576 
577 const Info *
578 resolve(const std::string &name)
579 {
580  const auto &it = nameMap().find(name);
581  if (it != nameMap().cend()) {
582  return it->second;
583  } else {
584  return Root::root()->resolveStat(name);
585  }
586 }
587 
588 void
589 registerDumpCallback(const std::function<void()> &callback)
590 {
591  dumpQueue.push_back(callback);
592 }
593 
594 } // namespace Stats
595 
596 void
598 {
599  Stats::dump();
600 }
Stats::_enabled
bool _enabled
Definition: statistics.cc:542
Stats::VectorDistInfo::subnames
std::vector< std::string > subnames
Names and descriptions of subfields.
Definition: info.hh:206
Stats::Vector2dInfo::subdescs
std::vector< std::string > subdescs
Definition: info.hh:223
Stats::Info::~Info
virtual ~Info()
Definition: statistics.cc:167
tokenize
void tokenize(vector< string > &v, const string &s, char token, bool ignore)
Definition: str.cc:67
fatal
#define fatal(...)
This implements a cprintf based fatal() function.
Definition: logging.hh:183
Stats::init
const FlagsType init
This Stat is Initialized.
Definition: info.hh:45
Root::root
static Root * root()
Use this function to get a pointer to the single Root object in the simulation.
Definition: root.hh:73
Stats::Formula::operator+=
const Formula & operator+=(Temp r)
Add the given tree to the existing one.
Definition: statistics.cc:443
Stats::Info::baseCheck
bool baseCheck() const
Definition: statistics.cc:256
Stats::processResetQueue
void processResetQueue()
Process all the callbacks in the reset callbacks queue.
Definition: statistics.cc:525
Debug::breakpoint
void breakpoint()
Definition: debug.cc:62
Stats::HistStor::cvec
VCounter cvec
Counter for each bucket.
Definition: statistics.hh:1600
Stats::off_type
unsigned int off_type
Definition: types.hh:55
ArmISA::i
Bitfield< 7 > i
Definition: miscregs_types.hh:63
Stats::HistStor
Templatized storage and interface for a histogram stat.
Definition: statistics.hh:1571
Stats::enable
void enable()
Definition: statistics.cc:551
Stats::HistStor::add
void add(HistStor *)
Definition: statistics.cc:397
Stats::Formula::str
std::string str() const
Definition: statistics.cc:506
Stats::NameMapType
std::map< std::string, Info * > NameMapType
Definition: statistics.hh:3418
time.hh
Stats::registerDumpCallback
void registerDumpCallback(const std::function< void()> &callback)
Register a callback that should be called whenever statistics are about to be dumped.
Definition: statistics.cc:589
debugDumpStats
void debugDumpStats()
Definition: statistics.cc:597
Stats::HistStor::max_bucket
Counter max_bucket
The maximum value to track.
Definition: statistics.hh:1587
Stats::Formula::reset
void reset()
Formulas don't need to be reset.
Definition: statistics.cc:490
Stats::VectorDistInfo::subdescs
std::vector< std::string > subdescs
Definition: info.hh:207
Stats::Vector2dInfo::subnames
std::vector< std::string > subnames
Names and descriptions of subfields.
Definition: info.hh:222
Stats::Vector2dInfo::y_subnames
std::vector< std::string > y_subnames
Definition: info.hh:224
std::vector< string >
Stats::statsMap
MapType & statsMap()
Definition: statistics.cc:74
Stats::reset
void reset()
Definition: statistics.cc:569
Stats::display
const FlagsType display
Print this stat.
Definition: info.hh:47
CallbackQueue
Definition: callback.hh:35
Stats::none
const FlagsType none
Nothing extra to print.
Definition: info.hh:43
Stats::HistStor::logs
Counter logs
The sum of logarithm of each sample, used to compute geometric mean.
Definition: statistics.hh:1594
Stats::Info::id_count
static int id_count
A unique stat ID for each stat in the simulator.
Definition: info.hh:88
root.hh
Stats::Formula::operator=
const Formula & operator=(const Temp &r)
Set an unitialized Formula to the given root.
Definition: statistics.cc:433
Stats::Formula::zero
bool zero() const
Definition: statistics.cc:495
Stats::BinaryNode
Definition: statistics.hh:2370
Stats::HistStor::min_bucket
Counter min_bucket
The minimum value to track.
Definition: statistics.hh:1585
Stats::StorageParams
Definition: statistics.hh:176
Stats::HistStor::squares
Counter squares
The sum of squares.
Definition: statistics.hh:1596
str.hh
Stats::Formula::total
Result total() const
Return the total Formula result.
Definition: statistics.cc:475
Stats::VectorDistInfo::size
virtual size_type size() const =0
Stats::Info::enable
virtual void enable()
Enable the stat for use.
Definition: statistics.cc:278
Stats::Temp
Helper class to construct formula node trees.
Definition: statistics.hh:3142
Stats::enabled
bool enabled()
Definition: statistics.cc:545
Stats::VectorDistInfo::enable
void enable()
Enable the stat for use.
Definition: statistics.cc:293
Stats::validateStatName
bool validateStatName(const string &name)
Definition: statistics.cc:172
Stats::nameMap
NameMapType & nameMap()
Definition: statistics.cc:149
Stats::resetHandler
Handler resetHandler
Definition: statistics.cc:511
Stats::DataWrapVec
Definition: statistics.hh:353
Stats::Group::resolveStat
const Info * resolveStat(std::string name) const
Resolve a stat by its name within this group.
Definition: group.cc:121
cprintf
void cprintf(const char *format, const Args &...args)
Definition: cprintf.hh:152
Stats::Handler
void(* Handler)()
Register reset and dump handlers.
Definition: statistics.hh:3387
Stats::resolve
const Info * resolve(const std::string &name)
Definition: statistics.cc:578
Stats::HistStor::zero
bool zero() const
Returns true if any calls to sample have been made.
Definition: statistics.hh:1662
Stats::registerResetCallback
void registerResetCallback(const std::function< void()> &callback)
Register a callback that should be called whenever statistics are reset.
Definition: statistics.cc:537
statistics.hh
Stats::Formula::root
NodePtr root
The root of the tree which represents the Formula.
Definition: statistics.hh:3041
MipsISA::r
r
Definition: pra_constants.hh:95
hostinfo.hh
Stats::HistStor::sum
Counter sum
The current sum.
Definition: statistics.hh:1592
debug.hh
Stats::Formula::Formula
Formula(Group *parent=nullptr, const char *name=nullptr, const char *desc=nullptr)
Create and initialize thie formula, and register it with the database.
Definition: statistics.cc:417
Stats::VectorInfo::subdescs
std::vector< std::string > subdescs
Definition: info.hh:161
cprintf.hh
Stats::Vector2dInfo::x
size_type x
Definition: info.hh:226
Stats::statsList
list< Info * > & statsList()
Definition: statistics.cc:67
std::pair
STL pair class.
Definition: stl.hh:58
Stats::HistStor::grow_up
void grow_up()
Definition: statistics.cc:375
Stats::VectorInfo::size
virtual size_type size() const =0
name
const std::string & name()
Definition: trace.cc:50
Stats::HistStor::grow_convert
void grow_convert()
Definition: statistics.cc:353
Stats::Info
Definition: info.hh:69
Stats::HistStor::bucket_size
Counter bucket_size
The number of entries in each bucket.
Definition: statistics.hh:1589
Stats::Result
double Result
All results are doubles.
Definition: types.hh:50
Stats::Counter
double Counter
All counters are of 64-bit values.
Definition: types.hh:41
Stats::VectorInfo::subnames
std::vector< std::string > subnames
Names and descriptions of subfields.
Definition: info.hh:160
panic_if
#define panic_if(cond,...)
Conditional panic macro that checks the supplied condition and only panics if the condition is true a...
Definition: logging.hh:197
Stats::InfoAccess::setInit
void setInit()
Save Storage class parameters if any.
Definition: statistics.cc:111
Stats::FormulaInfoProxy
Definition: statistics.hh:2815
Stats::processDumpQueue
void processDumpQueue()
Process all the callbacks in the dump callbacks queue.
Definition: statistics.cc:531
Stats::Info::setName
void setName(const std::string &name)
Set the name of this statistic.
std
Overload hash function for BasicBlockRange type.
Definition: vec_reg.hh:587
Stats::Vector2dInfo::y
size_type y
Definition: info.hh:227
Stats::dump
void dump()
Dump all statistics data to the registered outputs.
Definition: statistics.cc:560
Stats::Info::flags
Flags flags
The formatting flags.
Definition: info.hh:79
CallbackQueue::process
void process()
Definition: callback.hh:46
Stats::Formula
A formula for statistics that is calculated when printed.
Definition: statistics.hh:3037
Stats::Group
Statistics container.
Definition: group.hh:83
Stats::resetQueue
CallbackQueue resetQueue
Definition: statistics.cc:522
Stats::Info::name
std::string name
The name of the stat.
Definition: info.hh:73
logging.hh
Stats::Formula::result
void result(VResult &vec) const
Return the result of the Fomula in a vector.
Definition: statistics.cc:468
Stats::Info::less
static bool less(Info *stat1, Info *stat2)
Checks if the first stat's name is alphabetically less than the second.
Definition: statistics.cc:230
ArmISA::c
Bitfield< 29 > c
Definition: miscregs_types.hh:50
Stats
Definition: statistics.cc:61
Stats::Vector2dInfo::enable
void enable()
Enable the stat for use.
Definition: statistics.cc:303
Stats::Formula::operator/=
const Formula & operator/=(Temp r)
Divide the existing tree by the given one.
Definition: statistics.cc:457
trace.hh
Stats::size_type
unsigned int size_type
Definition: types.hh:54
Stats::HistStor::size
size_type size() const
Return the number of buckets in this distribution.
Definition: statistics.hh:1655
Stats::debug_break_id
int debug_break_id
Definition: statistics.cc:157
MipsISA::p
Bitfield< 0 > p
Definition: pra_constants.hh:323
Stats::MapType
std::map< const void *, Info * > MapType
Definition: statistics.hh:3415
std::list
STL list class.
Definition: stl.hh:51
Stats::HistStor::grow_out
void grow_out()
Definition: statistics.cc:314
ArmISA::s
Bitfield< 4 > s
Definition: miscregs_types.hh:556
Stats::Formula::size
size_type size() const
Return the number of elements in the tree.
Definition: statistics.cc:481
Stats::registerHandlers
void registerHandlers(Handler reset_handler, Handler dump_handler)
Definition: statistics.cc:515
Stats::dumpHandler
Handler dumpHandler
Definition: statistics.cc:512
Stats::VectorInfo::enable
void enable()
Enable the stat for use.
Definition: statistics.cc:283
Stats::dumpQueue
CallbackQueue dumpQueue
Definition: statistics.cc:521
callback.hh
Stats::NodePtr
std::shared_ptr< Node > NodePtr
Shared pointer to a function Node.
Definition: statistics.hh:2154
panic
#define panic(...)
This implements a cprintf based panic() function.
Definition: logging.hh:171
Stats::HistStor::samples
Counter samples
The number of samples.
Definition: statistics.hh:1598

Generated on Wed Sep 30 2020 14:02:08 for gem5 by doxygen 1.8.17