SST  9.1.0
StructuralSimulationToolkit
statbase.h
1 // Copyright 2009-2019 NTESS. Under the terms
2 // of Contract DE-NA0003525 with NTESS, the U.S.
3 // Government retains certain rights in this software.
4 //
5 // Copyright (c) 2009-2019, NTESS
6 // All rights reserved.
7 //
8 // This file is part of the SST software package. For license
9 // information, see the LICENSE file in the top level directory of the
10 // distribution.
11 
12 #ifndef _H_SST_CORE_STATISTICS_BASE
13 #define _H_SST_CORE_STATISTICS_BASE
14 
15 #include <string>
16 
17 #include <sst/core/sst_types.h>
18 #include <sst/core/warnmacros.h>
19 #include <sst/core/params.h>
20 #include <sst/core/oneshot.h>
21 #include <sst/core/statapi/statfieldinfo.h>
22 #include <sst/core/eli/elementinfo.h>
23 #include <sst/core/serialization/serializable.h>
24 
25 namespace SST {
26 class BaseComponent;
27 class Factory;
28 
29 namespace Statistics {
30 class StatisticOutput;
31 class StatisticProcessingEngine;
32 class StatisticGroup;
33 
34 
36 public:
37  std::string name;
38  Params params;
39 
40  StatisticInfo(const std::string &name) : name(name) { }
41  StatisticInfo(const std::string &name, const Params &params) : name(name), params(params) { }
42  StatisticInfo() { } /* DO NOT USE: For serialization */
43 
44  void serialize_order(SST::Core::Serialization::serializer &ser) override {
45  ser & name;
46  ser & params;
47  }
48 
49  ImplementSerializable(SST::Statistics::StatisticInfo)
50 };
51 
52 
53 
54 /**
55  \class StatisticBase
56 
57  Forms the base class for statistics gathering within SST. Statistics are
58  gathered and processed into various (extensible) output forms. Statistics
59  are expected to be named so that they can be located in the simulation
60  output files.
61 */
62 
64 {
65 public:
66  /** Statistic collection mode */
67  typedef enum {STAT_MODE_UNDEFINED, STAT_MODE_COUNT, STAT_MODE_PERIODIC} StatMode_t;
68 
69  // Enable/Disable of Statistic
70  /** Enable Statistic for collections */
71  void enable() {m_statEnabled = true;}
72 
73  /** Disable Statistic for collections */
74  void disable() {m_statEnabled = false;}
75 
76  // Handling of Collection Counts and Data
77  /** Inform the Statistic to clear its data */
78  virtual void clearStatisticData() {}
79 
80  /** Set the current collection count to 0 */
81  virtual void resetCollectionCount();
82 
83  /** Increment current collection count */
84  virtual void incrementCollectionCount();
85 
86  /** Set the current collection count to a defined value */
87  virtual void setCollectionCount(uint64_t newCount);
88 
89  /** Set the collection count limit to a defined value */
90  virtual void setCollectionCountLimit(uint64_t newLimit);
91 
92  // Control Statistic Operation Flags
93  /** Set the Reset Count On Output flag.
94  * If Set, the collection count will be reset when statistic is output.
95  */
96  void setFlagResetCountOnOutput(bool flag) {m_resetCountOnOutput = flag;}
97 
98  static const std::vector<ElementInfoParam>& ELI_getParams();
99 
100  /** Set the Clear Data On Output flag.
101  * If Set, the data in the statistic will be cleared by calling
102  * clearStatisticData().
103  */
104  void setFlagClearDataOnOutput(bool flag) {m_clearDataOnOutput = flag;}
105 
106  /** Set the Output At End Of Sim flag.
107  * If Set, the statistic will perform an output at the end of simulation.
108  */
109  void setFlagOutputAtEndOfSim(bool flag) {m_outputAtEndOfSim = flag;}
110 
111  // Get Data & Information on Statistic
112  /** Return the Component Name */
113  const std::string& getCompName() const;
114 
115  /** Return the Statistic Name */
116  inline const std::string& getStatName() const {return m_statName;}
117 
118  /** Return the Statistic SubId */
119  inline const std::string& getStatSubId() const {return m_statSubId;}
120 
121  /** Return the full Statistic name of Component.StatName.SubId */
122  inline const std::string& getFullStatName() const {return m_statFullName;} // Return compName.statName.subId
123 
124  /** Return the Statistic type name */
125  inline const std::string& getStatTypeName() const {return m_statTypeName;}
126 
127  /** Return the Statistic data type */
128  inline const StatisticFieldInfo::fieldType_t& getStatDataType() const {return m_statDataType;}
129 
130  /** Return the Statistic data type */
131  inline const char* getStatDataTypeShortName() const {return StatisticFieldInfo::getFieldTypeShortName(m_statDataType);}
132 
133  /** Return the Statistic data type */
134  inline const char* getStatDataTypeFullName() const {return StatisticFieldInfo::getFieldTypeFullName(m_statDataType);}
135 
136  /** Return a pointer to the parent Component */
137  BaseComponent* getComponent() const {return m_component;}
138 
139  /** Return the enable status of the Statistic */
140  bool isEnabled() const {return m_statEnabled;}
141 
142  /** Return the enable status of the Statistic's ability to output data */
143  bool isOutputEnabled() const {return m_outputEnabled;}
144 
145  /** Return the collection count limit */
146  uint64_t getCollectionCountLimit() const {return m_collectionCountLimit;}
147 
148  /** Return the current collection count */
149  uint64_t getCollectionCount() const {return m_currentCollectionCount;}
150 
151  /** Return the ResetCountOnOutput flag value */
152  bool getFlagResetCountOnOutput() const {return m_resetCountOnOutput;}
153 
154  /** Return the ClearDataOnOutput flag value */
155  bool getFlagClearDataOnOutput() const {return m_clearDataOnOutput;}
156 
157  /** Return the OutputAtEndOfSim flag value */
158  bool getFlagOutputAtEndOfSim() const {return m_outputAtEndOfSim;}
159 
160  /** Return the collection mode that is registered */
161  StatMode_t getRegisteredCollectionMode() const {return m_registeredCollectionMode;}
162 
163  // Delay Methods (Uses OneShot to disable Statistic or Collection)
164  /** Delay the statistic from outputting data for a specified delay time
165  * @param delayTime - Value in UnitAlgebra format for delay (i.e. 10ns).
166  */
167  void delayOutput(const char* delayTime);
168 
169  /** Delay the statistic from collecting data for a specified delay time.
170  * @param delayTime - Value in UnitAlgebra format for delay (i.e. 10ns).
171  */
172  void delayCollection(const char* delayTime);
173 
174  // Status of Statistic
175  /** Indicate that the Statistic is Ready to be used */
176  virtual bool isReady() const {return true;}
177 
178  /** Indicate if the Statistic is a NullStatistic */
179  virtual bool isNullStatistic() const {return false;}
180 
181 protected:
184  friend class SST::Statistics::StatisticGroup;
185 
186  /** Construct a StatisticBase
187  * @param comp - Pointer to the parent constructor.
188  * @param statName - Name of the statistic to be registered. This name must
189  * match the name in the ElementInfoStatistic.
190  * @param statSubId - Additional name of the statistic
191  * @param statParams - The parameters for this statistic
192  */
193  // Constructors:
194  StatisticBase(BaseComponent* comp, const std::string& statName,
195  const std::string& statSubId, Params& statParams);
196 
197  // Destructor
198  virtual ~StatisticBase() {}
199 
200  /** Return the Statistic Parameters */
201  Params& getParams() {return m_statParams;}
202 
203  /** Set the Statistic Data Type */
204  void setStatisticDataType(const StatisticFieldInfo::fieldType_t dataType) {m_statDataType = dataType;}
205 
206  /** Set an optional Statistic Type Name */
207  void setStatisticTypeName(const char* typeName) {m_statTypeName = typeName;}
208 
209 private:
210  friend class SST::BaseComponent;
211 
212  /** Set the Registered Collection Mode */
213  void setRegisteredCollectionMode(StatMode_t mode) {m_registeredCollectionMode = mode;}
214 
215  /** Construct a full name of the statistic */
216  static std::string buildStatisticFullName(const char* compName, const char* statName, const char* statSubId);
217  static std::string buildStatisticFullName(const std::string& compName, const std::string& statName, const std::string& statSubId);
218 
219  // Required Virtual Methods:
220  /** Called by the system to tell the Statistic to register its output fields.
221  * by calling statOutput->registerField(...)
222  * @param statOutput - Pointer to the statistic output
223  */
224  virtual void registerOutputFields(StatisticOutput* statOutput) = 0;
225 
226  /** Called by the system to tell the Statistic to send its data to the
227  * StatisticOutput to be output.
228  * @param statOutput - Pointer to the statistic output
229  * @param EndOfSimFlag - Indicates that the output is occurring at the end of simulation.
230  */
231  virtual void outputStatisticData(StatisticOutput* statOutput, bool EndOfSimFlag) = 0;
232 
233  /** Indicate if the Statistic Mode is supported.
234  * This allows Statistics to support STAT_MODE_COUNT and STAT_MODE_PERIODIC modes.
235  * by default, both modes are supported.
236  * @param mode - Mode to test
237  */
238  virtual bool isStatModeSupported(StatMode_t UNUSED(mode)) const {return true;} // Default is to accept all modes
239 
240  /** Verify that the statistic names match */
241  bool operator==(StatisticBase& checkStat);
242 
243  // Support Routines
244  void initializeStatName(const char* compName, const char* statName, const char* statSubId);
245  void initializeStatName(const std::string& compName, const std::string& statName, const std::string& statSubId);
246 
247  void initializeProperties();
248  void checkEventForOutput();
249 
250  // OneShot Callbacks:
251  void delayOutputExpiredHandler(); // Enable Output in handler
252  void delayCollectionExpiredHandler(); // Enable Collection in Handler
253 
254  const StatisticGroup* getGroup() const { return m_group; }
255  void setGroup(const StatisticGroup *group ) { m_group = group; }
256 
257 private:
258  StatisticBase(); // For serialization only
259 
260 private:
261  BaseComponent* m_component;
262  std::string m_statName;
263  std::string m_statSubId;
264  std::string m_statFullName;
265  std::string m_statTypeName;
266  Params m_statParams;
267  StatMode_t m_registeredCollectionMode;
268  uint64_t m_currentCollectionCount;
269  uint64_t m_collectionCountLimit;
270  StatisticFieldInfo::fieldType_t m_statDataType;
271 
272  bool m_statEnabled;
273  bool m_outputEnabled;
274  bool m_resetCountOnOutput;
275  bool m_clearDataOnOutput;
276  bool m_outputAtEndOfSim;
277 
278  bool m_outputDelayed;
279  bool m_collectionDelayed;
280  bool m_savedStatEnabled;
281  bool m_savedOutputEnabled;
282  OneShot::HandlerBase* m_outputDelayedHandler;
283  OneShot::HandlerBase* m_collectionDelayedHandler;
284  const StatisticGroup* m_group;
285 
286 };
287 
288 /**
289  \class StatisticCollector
290  * Base type that creates the virtual addData(...) interface
291  * Used for distinguishing fundamental types (collected by value)
292  * and composite struct types (collected by reference)
293  */
294 template <class T, bool F=std::is_fundamental<T>::value>
296 
297 template <class T>
298 struct StatisticCollector<T,true> {
299  virtual void addData_impl(T data) = 0;
300 };
301 
302 template <class... Args>
303 struct StatisticCollector<std::tuple<Args...>,false> {
304  virtual void addData_impl(Args... args) = 0;
305 
306  template <class... InArgs>
307  void addData(InArgs&&... args){
308  addData_impl(std::make_tuple(std::forward<InArgs>(args)...));
309  }
310 };
311 
312 ////////////////////////////////////////////////////////////////////////////////
313 
314 /**
315  \class Statistic
316 
317  Forms the template defined base class for statistics gathering within SST.
318 
319  @tparam T A template for the basic numerical data stored by this Statistic
320 */
321 
322 template <typename T>
323 class Statistic : public StatisticBase, public StatisticCollector<T>
324 {
325  public:
326  SST_ELI_DECLARE_BASE(Statistic)
327  SST_ELI_DECLARE_INFO(
328  ELI::ProvidesInterface,
329  ELI::ProvidesParams)
330  SST_ELI_DECLARE_CTOR(BaseComponent*,const std::string&, const std::string&, SST::Params&)
331 
332  using Datum = T;
333  using StatisticCollector<T>::addData_impl;
334  // The main method to add data to the statistic
335  /** Add data to the Statistic
336  * This will call the addData_impl() routine in the derived Statistic.
337  */
338  template <class... InArgs> //use a universal reference here
339  void addData(InArgs&&... args)
340  {
341  // Call the Derived Statistic's implementation
342  // of addData and increment the count
343  if (isEnabled()) {
344  addData_impl(std::forward<InArgs>(args)...);
346  }
347  }
348 
349 
350 
351  static fieldType_t fieldId() {
352  return StatisticFieldType<T>::id();
353  }
354 
355 protected:
356  friend class SST::Factory;
357  friend class SST::BaseComponent;
358  /** Construct a Statistic
359  * @param comp - Pointer to the parent constructor.
360  * @param statName - Name of the statistic to be registered. This name must
361  * match the name in the ElementInfoStatistic.
362  * @param statSubId - Additional name of the statistic
363  * @param statParams - The parameters for this statistic
364  */
365 
366  Statistic(BaseComponent* comp, const std::string& statName,
367  const std::string& statSubId, Params& statParams) :
368  StatisticBase(comp, statName, statSubId, statParams)
369  {
370  setStatisticDataType(StatisticFieldInfo::getFieldTypeFromTemplate<T>());
371  }
372 
373  virtual ~Statistic(){}
374 
375 private:
376  Statistic(){} // For serialization only
377 
378 
379 };
380 
381 template <class... Args>
382 using MultiStatistic = Statistic<std::tuple<Args...>>;
383 
384 
386  public:
387  std::string toString() const;
388 
389  Statistics::fieldType_t fieldId() const {
390  return field_;
391  }
392 
393  const char* fieldName() const {
394  return field_name_;
395  }
396 
397  const char* fieldShortName() const {
398  return short_name_;
399  }
400 
401  protected:
402  template <class T> ImplementsStatFields(T* UNUSED(t)) :
403  field_name_(T::ELI_fieldName()),
404  short_name_(T::ELI_fieldShortName()),
405  field_(T::ELI_registerField(T::ELI_fieldName(), T::ELI_fieldShortName()))
406  {
407  }
408 
409  private:
410  const char* field_name_;
411  const char* short_name_;
412  Statistics::fieldType_t field_;
413 
414 };
415 
416 #define SST_ELI_DECLARE_STATISTIC_TEMPLATE(cls,lib,name,version,desc,interface) \
417  SST_ELI_DEFAULT_INFO(lib,name,ELI_FORWARD_AS_ONE(version),desc) \
418  SST_ELI_INTERFACE_INFO(interface)
419 
420 #define SST_ELI_REGISTER_CUSTOM_STATISTIC(parent,cls,lib,name,version,desc) \
421  bool ELI_isLoaded() const { \
422  return SST::ELI::InstantiateBuilderInfo<parent,cls>::isLoaded() \
423  && SST::ELI::InstantiateBuilder<parent,cls>::isLoaded(); \
424  } \
425  SST_ELI_DEFAULT_INFO(lib,name,ELI_FORWARD_AS_ONE(version),desc) \
426  SST_ELI_INTERFACE_INFO(#parent) \
427  static const char* ELI_fieldName(){ return #parent "Data"; } \
428  static const char* ELI_fieldShortName(){ return #parent "Data"; }
429 
430 #define SST_ELI_DECLARE_STATISTIC(cls,field,lib,name,version,desc,interface) \
431  static bool ELI_isLoaded() { \
432  return SST::Statistics::Statistic<field>::template addDerivedInfo<cls>(lib,name) \
433  && SST::Statistics::Statistic<field>::template addDerivedBuilder<cls>(lib,name) \
434  && SST::Statistics::Statistic<field>::template addDerivedInfo<SST::Statistics::NullStatistic<field>>(lib,name) \
435  && SST::Statistics::Statistic<field>::template addDerivedBuilder<SST::Statistics::NullStatistic<field>>(lib,name); \
436  } \
437  SST_ELI_DEFAULT_INFO(lib,name,ELI_FORWARD_AS_ONE(version),desc) \
438  SST_ELI_INTERFACE_INFO(interface) \
439  static const char* ELI_fieldName(){ return #field; } \
440  static const char* ELI_fieldShortName(){ return #field; }
441 
442 
443 #define SST_ELI_INSTANTIATE_STATISTIC(cls,field) \
444  struct cls##_##field##_##shortName : public cls<field> { \
445  cls##_##field##_##shortName(SST::BaseComponent* bc, const std::string& sn, \
446  const std::string& si, SST::Params& p) : \
447  cls<field>(bc,sn,si,p) {} \
448  static bool ELI_isLoaded() { \
449  return SST::ELI::InstantiateBuilderInfo< \
450  SST::Statistics::Statistic<field>,cls##_##field##_##shortName>::isLoaded() \
451  && SST::ELI::InstantiateBuilder< \
452  SST::Statistics::Statistic<field>,cls##_##field##_##shortName>::isLoaded() \
453  && SST::ELI::InstantiateBuilderInfo< \
454  SST::Statistics::Statistic<field>, \
455  SST::Statistics::NullStatistic<field>>::isLoaded() \
456  && SST::ELI::InstantiateBuilder< \
457  SST::Statistics::Statistic<field>, \
458  SST::Statistics::NullStatistic<field>>::isLoaded(); \
459  } \
460  };
461 
462 
463 #define PP_NARG(...) PP_NARG_(__VA_ARGS__, PP_NSEQ())
464 #define PP_NARG_(...) PP_ARG_N(__VA_ARGS__)
465 #define PP_ARG_N(_1,_2,_3,_4,_5,N,...) N
466 #define PP_NSEQ() 5,4,3,2,1,0
467 
468 #define PP_GLUE(X,Y) PP_GLUE_I(X,Y)
469 #define PP_GLUE_I(X,Y) X##Y
470 
471 #define STAT_NAME1(base,a) base##a
472 #define STAT_NAME2(base,a,b) base##a##b
473 #define STAT_NAME3(base,a,b,c) base##a##b##c
474 #define STAT_NAME4(base,a,b,c,d) base##a##b##c##d
475 
476 #define STAT_GLUE_NAME(base,...) PP_GLUE(STAT_NAME,PP_NARG(__VA_ARGS__))(base,__VA_ARGS__)
477 #define STAT_TUPLE(...) std::tuple<__VA_ARGS__>
478 
479 #define MAKE_MULTI_STATISTIC(cls,name,tuple,...) \
480  struct name : public cls<__VA_ARGS__> { \
481  name(SST::BaseComponent* bc, const std::string& sn, \
482  const std::string& si, SST::Params& p) : \
483  cls<__VA_ARGS__>(bc,sn,si,p) {} \
484  bool ELI_isLoaded() const { \
485  return SST::ELI::InstantiateBuilderInfo< \
486  SST::Statistics::Statistic<tuple>,name>::isLoaded() \
487  && SST::ELI::InstantiateBuilder< \
488  SST::Statistics::Statistic<tuple>,name>::isLoaded() \
489  && SST::ELI::InstantiateBuilderInfo< \
490  SST::Statistics::Statistic<tuple>, \
491  SST::Statistics::NullStatistic<tuple>>::isLoaded() \
492  && SST::ELI::InstantiateBuilder< \
493  SST::Statistics::Statistic<tuple>, \
494  SST::Statistics::NullStatistic<tuple>>::isLoaded(); \
495  } \
496  };
497 
498 #define SST_ELI_INSTANTIATE_MULTI_STATISTIC(cls,...) \
499  MAKE_MULTI_STATISTIC(cls,STAT_GLUE_NAME(cls,__VA_ARGS__),STAT_TUPLE(__VA_ARGS__),__VA_ARGS__)
500 
501 
502 
503 } //namespace Statistics
504 } //namespace SST
505 
506 //we need to make sure null stats are instantiated for whatever types we use
507 #include <sst/core/statapi/statnull.h>
508 
509 #endif
This class is basically a wrapper for objects to declare the order in which their members should be s...
Definition: serializer.h:35
void setFlagOutputAtEndOfSim(bool flag)
Set the Output At End Of Sim flag.
Definition: statbase.h:109
virtual void setCollectionCountLimit(uint64_t newLimit)
Set the collection count limit to a defined value.
Definition: statbase.cc:72
void delayCollection(const char *delayTime)
Delay the statistic from collecting data for a specified delay time.
Definition: statbase.cc:144
void setFlagClearDataOnOutput(bool flag)
Set the Clear Data On Output flag.
Definition: statbase.h:104
Forms the base class for statistics output generation within the SST core.
Definition: statoutput.h:48
Forms the base class for statistics gathering within SST.
Definition: statbase.h:63
void setStatisticTypeName(const char *typeName)
Set an optional Statistic Type Name.
Definition: statbase.h:207
uint64_t getCollectionCount() const
Return the current collection count.
Definition: statbase.h:149
void enable()
Enable Statistic for collections.
Definition: statbase.h:71
void delayOutput(const char *delayTime)
Delay the statistic from outputting data for a specified delay time.
Definition: statbase.cc:130
StatMode_t getRegisteredCollectionMode() const
Return the collection mode that is registered.
Definition: statbase.h:161
Forms the template defined base class for statistics gathering within SST.
Definition: elementinfo.h:43
Definition: serializable.h:110
virtual bool isNullStatistic() const
Indicate if the Statistic is a NullStatistic.
Definition: statbase.h:179
const std::string & getCompName() const
Return the Component Name.
Definition: statbase.cc:50
virtual void incrementCollectionCount()
Increment current collection count.
Definition: statbase.cc:55
virtual void resetCollectionCount()
Set the current collection count to 0.
Definition: statbase.cc:67
const StatisticFieldInfo::fieldType_t & getStatDataType() const
Return the Statistic data type.
Definition: statbase.h:128
Base type that creates the virtual addData(...) interface Used for distinguishing fundamental types (...
Definition: statbase.h:295
Statistic(BaseComponent *comp, const std::string &statName, const std::string &statSubId, Params &statParams)
Construct a Statistic.
Definition: statbase.h:366
void addData(InArgs &&...args)
Add data to the Statistic This will call the addData_impl() routine in the derived Statistic...
Definition: statbase.h:339
bool getFlagOutputAtEndOfSim() const
Return the OutputAtEndOfSim flag value.
Definition: statbase.h:158
bool getFlagClearDataOnOutput() const
Return the ClearDataOnOutput flag value.
Definition: statbase.h:155
bool isEnabled() const
Return the enable status of the Statistic.
Definition: statbase.h:140
virtual bool isReady() const
Indicate that the Statistic is Ready to be used.
Definition: statbase.h:176
Main component object for the simulation.
Definition: baseComponent.h:52
void disable()
Disable Statistic for collections.
Definition: statbase.h:74
bool isOutputEnabled() const
Return the enable status of the Statistic&#39;s ability to output data.
Definition: statbase.h:143
Definition: statbase.h:385
StatMode_t
Statistic collection mode.
Definition: statbase.h:67
virtual void clearStatisticData()
Inform the Statistic to clear its data.
Definition: statbase.h:78
void setFlagResetCountOnOutput(bool flag)
Set the Reset Count On Output flag.
Definition: statbase.h:96
Parameter store.
Definition: params.h:45
bool getFlagResetCountOnOutput() const
Return the ResetCountOnOutput flag value.
Definition: statbase.h:152
const std::string & getStatSubId() const
Return the Statistic SubId.
Definition: statbase.h:119
Definition: statbase.h:35
const char * getStatDataTypeFullName() const
Return the Statistic data type.
Definition: statbase.h:134
Class for instantiating Components, Links and the like out of element libraries.
Definition: factory.h:43
const std::string & getFullStatName() const
Return the full Statistic name of Component.StatName.SubId.
Definition: statbase.h:122
virtual void setCollectionCount(uint64_t newCount)
Set the current collection count to a defined value.
Definition: statbase.cc:61
const char * getStatDataTypeShortName() const
Return the Statistic data type.
Definition: statbase.h:131
Definition: statfieldinfo.h:51
void setStatisticDataType(const StatisticFieldInfo::fieldType_t dataType)
Set the Statistic Data Type.
Definition: statbase.h:204
An SST core component that handles timing and event processing informing all registered Statistics to...
Definition: statengine.h:52
Definition: statgroup.h:29
Params & getParams()
Return the Statistic Parameters.
Definition: statbase.h:201
uint64_t getCollectionCountLimit() const
Return the collection count limit.
Definition: statbase.h:146
BaseComponent * getComponent() const
Return a pointer to the parent Component.
Definition: statbase.h:137
const std::string & getStatTypeName() const
Return the Statistic type name.
Definition: statbase.h:125
const std::string & getStatName() const
Return the Statistic Name.
Definition: statbase.h:116
StatisticBase(BaseComponent *comp, const std::string &statName, const std::string &statSubId, Params &statParams)
Construct a StatisticBase.
Definition: statbase.cc:28