SST  11.1.0
StructuralSimulationToolkit
statbase.h
1 // Copyright 2009-2021 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-2021, 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 SST_CORE_STATAPI_STATBASE_H
13 #define SST_CORE_STATAPI_STATBASE_H
14 
15 #include "sst/core/eli/elementinfo.h"
16 #include "sst/core/oneshot.h"
17 #include "sst/core/params.h"
18 #include "sst/core/serialization/serializable.h"
19 #include "sst/core/sst_types.h"
20 #include "sst/core/statapi/statfieldinfo.h"
21 #include "sst/core/warnmacros.h"
22 
23 #include <string>
24 
25 namespace SST {
26 class BaseComponent;
27 class Factory;
28 
29 namespace Statistics {
30 class StatisticOutput;
31 class StatisticFieldsOutput;
32 class StatisticProcessingEngine;
33 class StatisticGroup;
34 
36 {
37 public:
38  std::string name;
39  Params params;
40 
41  StatisticInfo(const std::string& name) : name(name) {}
42  StatisticInfo(const std::string& name, const Params& params) : name(name), params(params) {}
43  StatisticInfo() {} /* DO NOT USE: For serialization */
44 
45  void serialize_order(SST::Core::Serialization::serializer& ser) override
46  {
47  ser& name;
48  ser& params;
49  }
50 
51  ImplementSerializable(SST::Statistics::StatisticInfo)
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, STAT_MODE_DUMP_AT_END } 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(uint64_t increment);
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
132  {
133  return StatisticFieldInfo::getFieldTypeShortName(m_statDataType);
134  }
135 
136  /** Return the Statistic data type */
137  inline const char* getStatDataTypeFullName() const
138  {
139  return StatisticFieldInfo::getFieldTypeFullName(m_statDataType);
140  }
141 
142  /** Return a pointer to the parent Component */
143  BaseComponent* getComponent() const { return m_component; }
144 
145  /** Return the enable status of the Statistic */
146  bool isEnabled() const { return m_statEnabled; }
147 
148  /** Return the enable status of the Statistic's ability to output data */
149  bool isOutputEnabled() const { return m_outputEnabled; }
150 
151  /** Return the collection count limit */
152  uint64_t getCollectionCountLimit() const { return m_collectionCountLimit; }
153 
154  /** Return the current collection count */
155  uint64_t getCollectionCount() const { return m_currentCollectionCount; }
156 
157  /** Return the ResetCountOnOutput flag value */
158  bool getFlagResetCountOnOutput() const { return m_resetCountOnOutput; }
159 
160  /** Return the ClearDataOnOutput flag value */
161  bool getFlagClearDataOnOutput() const { return m_clearDataOnOutput; }
162 
163  /** Return the OutputAtEndOfSim flag value */
164  bool getFlagOutputAtEndOfSim() const { return m_outputAtEndOfSim; }
165 
166  /** Return the collection mode that is registered */
167  StatMode_t getRegisteredCollectionMode() const { return m_registeredCollectionMode; }
168 
169  // Delay Methods (Uses OneShot to disable Statistic or Collection)
170  /** Delay the statistic from outputting data for a specified delay time
171  * @param delayTime - Value in UnitAlgebra format for delay (i.e. 10ns).
172  */
173  void delayOutput(const char* delayTime);
174 
175  /** Delay the statistic from collecting data for a specified delay time.
176  * @param delayTime - Value in UnitAlgebra format for delay (i.e. 10ns).
177  */
178  void delayCollection(const char* delayTime);
179 
180  // Status of Statistic
181  /** Indicate that the Statistic is Ready to be used */
182  virtual bool isReady() const { return true; }
183 
184  /** Indicate if the Statistic is a NullStatistic */
185  virtual bool isNullStatistic() const { return false; }
186 
187 protected:
190  friend class SST::Statistics::StatisticGroup;
192 
193  /** Construct a StatisticBase
194  * @param comp - Pointer to the parent constructor.
195  * @param statName - Name of the statistic to be registered. This name must
196  * match the name in the ElementInfoStatistic.
197  * @param statSubId - Additional name of the statistic
198  * @param statParams - The parameters for this statistic
199  */
200  // Constructors:
201  StatisticBase(BaseComponent* comp, const std::string& statName, const std::string& statSubId, Params& statParams);
202 
203  // Destructor
204  virtual ~StatisticBase() {}
205 
206  /** Return the Statistic Parameters */
207  Params& getParams() { return m_statParams; }
208 
209  /** Set the Statistic Data Type */
210  void setStatisticDataType(const StatisticFieldInfo::fieldType_t dataType) { m_statDataType = dataType; }
211 
212  /** Set an optional Statistic Type Name */
213  void setStatisticTypeName(const char* typeName) { m_statTypeName = typeName; }
214 
215 private:
216  friend class SST::BaseComponent;
217 
218  /** Set the Registered Collection Mode */
219  void setRegisteredCollectionMode(StatMode_t mode) { m_registeredCollectionMode = mode; }
220 
221  /** Construct a full name of the statistic */
222  static std::string buildStatisticFullName(const char* compName, const char* statName, const char* statSubId);
223  static std::string
224  buildStatisticFullName(const std::string& compName, const std::string& statName, const std::string& statSubId);
225 
226  // Required Virtual Methods:
227  /** Called by the system to tell the Statistic to register its output fields.
228  * by calling statOutput->registerField(...)
229  * @param statOutput - Pointer to the statistic output
230  */
231  virtual void registerOutputFields(StatisticFieldsOutput* statOutput) = 0;
232 
233  /** Called by the system to tell the Statistic to send its data to the
234  * StatisticOutput to be output.
235  * @param statOutput - Pointer to the statistic output
236  * @param EndOfSimFlag - Indicates that the output is occurring at the end of simulation.
237  */
238  virtual void outputStatisticFields(StatisticFieldsOutput* statOutput, bool EndOfSimFlag) = 0;
239 
240  /** Indicate if the Statistic Mode is supported.
241  * This allows Statistics to support STAT_MODE_COUNT and STAT_MODE_PERIODIC modes.
242  * by default, both modes are supported.
243  * @param mode - Mode to test
244  */
245  virtual bool isStatModeSupported(StatMode_t UNUSED(mode)) const { return true; } // Default is to accept all modes
246 
247  /** Verify that the statistic names match */
248  bool operator==(StatisticBase& checkStat);
249 
250  // Support Routines
251  void initializeStatName(const char* compName, const char* statName, const char* statSubId);
252  void initializeStatName(const std::string& compName, const std::string& statName, const std::string& statSubId);
253 
254  void initializeProperties();
255  void checkEventForOutput();
256 
257  // OneShot Callbacks:
258  void delayOutputExpiredHandler(); // Enable Output in handler
259  void delayCollectionExpiredHandler(); // Enable Collection in Handler
260 
261  const StatisticGroup* getGroup() const { return m_group; }
262  void setGroup(const StatisticGroup* group) { m_group = group; }
263 
264 protected:
265  StatisticBase(); // For serialization only
266 
267 private:
268  BaseComponent* m_component;
269  std::string m_statName;
270  std::string m_statSubId;
271  std::string m_statFullName;
272  std::string m_statTypeName;
273  Params m_statParams;
274  StatMode_t m_registeredCollectionMode;
275  uint64_t m_currentCollectionCount;
276  uint64_t m_collectionCountLimit;
277  StatisticFieldInfo::fieldType_t m_statDataType;
278 
279  bool m_statEnabled;
280  bool m_outputEnabled;
281  bool m_resetCountOnOutput;
282  bool m_clearDataOnOutput;
283  bool m_outputAtEndOfSim;
284 
285  bool m_outputDelayed;
286  bool m_collectionDelayed;
287  bool m_savedStatEnabled;
288  bool m_savedOutputEnabled;
289  OneShot::HandlerBase* m_outputDelayedHandler;
290  OneShot::HandlerBase* m_collectionDelayedHandler;
291  const StatisticGroup* m_group;
292 };
293 
294 /**
295  \class StatisticCollector
296  * Base type that creates the virtual addData(...) interface
297  * Used for distinguishing fundamental types (collected by value)
298  * and composite struct types (collected by reference)
299  */
300 template <class T, bool F = std::is_fundamental<T>::value>
302 {};
303 
304 template <class T>
305 struct StatisticCollector<T, true>
306 {
307  virtual void addData_impl(T data) = 0;
308 
309  /**
310  * @brief addData_impl_Ntimes Add the same data N times in a row
311  * By default, this just calls the addData function N times
312  * @param N The number of consecutive times
313  * @param args The arguments to pass in
314  */
315  virtual void addData_impl_Ntimes(uint64_t N, T data)
316  {
317  for ( uint64_t i = 0; i < N; ++i ) {
318  addData_impl(data);
319  }
320  }
321 };
322 
323 template <class... Args>
324 struct StatisticCollector<std::tuple<Args...>, false>
325 {
326  virtual void addData_impl(Args... args) = 0;
327 
328  /**
329  * @brief addData_impl_Ntimes Add the same data N times in a row
330  * By default, this just calls the addData function N times
331  * @param N The number of consecutive times
332  * @param args The arguments to pass in
333  */
334  virtual void addData_impl_Ntimes(uint64_t N, Args... args)
335  {
336  for ( uint64_t i = 0; i < N; ++i ) {
337  addData_impl(args...);
338  }
339  }
340 
341  template <class... InArgs>
342  void addData(InArgs&&... args)
343  {
344  addData_impl(std::make_tuple(std::forward<InArgs>(args)...));
345  }
346 };
347 
348 ////////////////////////////////////////////////////////////////////////////////
349 
350 /**
351  \class Statistic
352 
353  Forms the template defined base class for statistics gathering within SST.
354 
355  @tparam T A template for the basic numerical data stored by this Statistic
356 */
357 
358 template <typename T>
359 class Statistic : public StatisticBase, public StatisticCollector<T>
360 {
361 public:
362  SST_ELI_DECLARE_BASE(Statistic)
363  SST_ELI_DECLARE_INFO(
364  ELI::ProvidesInterface,
365  ELI::ProvidesParams)
366  SST_ELI_DECLARE_CTOR(BaseComponent*, const std::string&, const std::string&, SST::Params&)
367 
368  using Datum = T;
369  using StatisticCollector<T>::addData_impl;
370  // The main method to add data to the statistic
371  /** Add data to the Statistic
372  * This will call the addData_impl() routine in the derived Statistic.
373  */
374  template <class... InArgs> // use a universal reference here
375  void addData(InArgs&&... args)
376  {
377  // Call the Derived Statistic's implementation
378  // of addData and increment the count
379  if ( isEnabled() ) {
380  addData_impl(std::forward<InArgs>(args)...);
382  }
383  }
384 
385  template <class... InArgs> // use a universal reference here
386  void addDataNTimes(uint64_t N, InArgs&&... args)
387  {
388  // Call the Derived Statistic's implementation
389  // of addData and increment the count
390  if ( isEnabled() ) {
391  addData_impl_Ntimes(N, std::forward<InArgs>(args)...);
393  }
394  }
395 
396  static fieldType_t fieldId() { return StatisticFieldType<T>::id(); }
397 
398 protected:
399  friend class SST::Factory;
400  friend class SST::BaseComponent;
401  /** Construct a Statistic
402  * @param comp - Pointer to the parent constructor.
403  * @param statName - Name of the statistic to be registered. This name must
404  * match the name in the ElementInfoStatistic.
405  * @param statSubId - Additional name of the statistic
406  * @param statParams - The parameters for this statistic
407  */
408 
409  Statistic(BaseComponent* comp, const std::string& statName, const std::string& statSubId, Params& statParams) :
410  StatisticBase(comp, statName, statSubId, statParams)
411  {
412  setStatisticDataType(StatisticFieldInfo::getFieldTypeFromTemplate<T>());
413  }
414 
415  virtual ~Statistic() {}
416 
417 private:
418  Statistic() {} // For serialization only
419 };
420 
421 /**
422  * void Statistic has special meaning in that it does not collect fields
423  * in the usual way through the addData function. It has to use custom functions.
424  */
425 template <>
426 class Statistic<void> : public StatisticBase
427 {
428 public:
429  SST_ELI_DECLARE_BASE(Statistic)
430  SST_ELI_DECLARE_INFO(
433  SST_ELI_DECLARE_CTOR(BaseComponent*, const std::string&, const std::string&, SST::Params&)
434 
435  void registerOutputFields(StatisticFieldsOutput* statOutput) override;
436 
437  void outputStatisticFields(StatisticFieldsOutput* statOutput, bool EndOfSimFlag) override;
438 
439 protected:
440  friend class SST::Factory;
441  friend class SST::BaseComponent;
442  /** Construct a Statistic
443  * @param comp - Pointer to the parent constructor.
444  * @param statName - Name of the statistic to be registered. This name must
445  * match the name in the ElementInfoStatistic.
446  * @param statSubId - Additional name of the statistic
447  * @param statParams - The parameters for this statistic
448  */
449 
450  Statistic(BaseComponent* comp, const std::string& statName, const std::string& statSubId, Params& statParams) :
451  StatisticBase(comp, statName, statSubId, statParams)
452  {}
453 
454  virtual ~Statistic() {}
455 
456 private:
457  Statistic() {} // For serialization only
458 };
459 
460 using CustomStatistic = Statistic<void>;
461 
462 template <class... Args>
463 using MultiStatistic = Statistic<std::tuple<Args...>>;
464 
466 {
467 public:
468  std::string toString() const;
469 
470  Statistics::fieldType_t fieldId() const { return field_; }
471 
472  const char* fieldName() const { return field_name_; }
473 
474  const char* fieldShortName() const { return short_name_; }
475 
476 protected:
477  template <class T>
478  ImplementsStatFields(T* UNUSED(t)) :
479  field_name_(T::ELI_fieldName()),
480  short_name_(T::ELI_fieldShortName()),
481  field_(T::ELI_registerField(T::ELI_fieldName(), T::ELI_fieldShortName()))
482  {}
483 
484 private:
485  const char* field_name_;
486  const char* short_name_;
487  Statistics::fieldType_t field_;
488 };
489 
490 #define SST_ELI_DECLARE_STATISTIC_TEMPLATE(cls, lib, name, version, desc, interface) \
491  SST_ELI_DEFAULT_INFO(lib, name, ELI_FORWARD_AS_ONE(version), desc) \
492  SST_ELI_INTERFACE_INFO(interface)
493 
494 #define SST_ELI_REGISTER_CUSTOM_STATISTIC(cls, lib, name, version, desc) \
495  SST_ELI_REGISTER_DERIVED(SST::Statistics::CustomStatistic,cls,lib,name,ELI_FORWARD_AS_ONE(version),desc) \
496  SST_ELI_INTERFACE_INFO("CustomStatistic")
497 
498 #define SST_ELI_DECLARE_STATISTIC(cls, field, lib, name, version, desc, interface) \
499  static bool ELI_isLoaded() \
500  { \
501  return SST::Statistics::Statistic<field>::template addDerivedInfo<cls>(lib, name) && \
502  SST::Statistics::Statistic<field>::template addDerivedBuilder<cls>(lib, name) && \
503  SST::Statistics::Statistic<field>::template addDerivedInfo<SST::Statistics::NullStatistic<field>>( \
504  lib, name) && \
505  SST::Statistics::Statistic<field>::template addDerivedBuilder<SST::Statistics::NullStatistic<field>>( \
506  lib, name); \
507  } \
508  SST_ELI_DEFAULT_INFO(lib, name, ELI_FORWARD_AS_ONE(version), desc) \
509  SST_ELI_INTERFACE_INFO(interface) \
510  static const char* ELI_fieldName() { return #field; } \
511  static const char* ELI_fieldShortName() { return #field; }
512 
513 #ifdef __INTEL_COMPILER
514 #define SST_ELI_INSTANTIATE_STATISTIC(cls, field) \
515  bool force_instantiate_##cls##_##field = \
516  SST::ELI::InstantiateBuilderInfo<SST::Statistics::Statistic<field>, cls<field>>::isLoaded() && \
517  SST::ELI::InstantiateBuilder<SST::Statistics::Statistic<field>, cls<field>>::isLoaded() && \
518  SST::ELI::InstantiateBuilderInfo< \
519  SST::Statistics::Statistic<field>, SST::Statistics::NullStatistic<field>>::isLoaded() && \
520  SST::ELI::InstantiateBuilder< \
521  SST::Statistics::Statistic<field>, SST::Statistics::NullStatistic<field>>::isLoaded();
522 #else
523 #define SST_ELI_INSTANTIATE_STATISTIC(cls, field) \
524  struct cls##_##field##_##shortName : public cls<field> \
525  { \
526  cls##_##field##_##shortName( \
527  SST::BaseComponent* bc, const std::string& sn, const std::string& si, SST::Params& p) : \
528  cls<field>(bc, sn, si, p) \
529  {} \
530  static bool ELI_isLoaded() \
531  { \
532  return SST::ELI::InstantiateBuilderInfo< \
533  SST::Statistics::Statistic<field>, cls##_##field##_##shortName>::isLoaded() && \
534  SST::ELI::InstantiateBuilder< \
535  SST::Statistics::Statistic<field>, cls##_##field##_##shortName>::isLoaded() && \
536  SST::ELI::InstantiateBuilderInfo< \
537  SST::Statistics::Statistic<field>, SST::Statistics::NullStatistic<field>>::isLoaded() && \
538  SST::ELI::InstantiateBuilder< \
539  SST::Statistics::Statistic<field>, SST::Statistics::NullStatistic<field>>::isLoaded(); \
540  } \
541  };
542 #endif
543 
544 #define PP_NARG(...) PP_NARG_(__VA_ARGS__, PP_NSEQ())
545 #define PP_NARG_(...) PP_ARG_N(__VA_ARGS__)
546 #define PP_ARG_N(_1, _2, _3, _4, _5, N, ...) N
547 #define PP_NSEQ() 5, 4, 3, 2, 1, 0
548 
549 #define PP_GLUE(X, Y) PP_GLUE_I(X, Y)
550 #define PP_GLUE_I(X, Y) X##Y
551 
552 #define STAT_NAME1(base, a) base##a
553 #define STAT_NAME2(base, a, b) base##a##b
554 #define STAT_NAME3(base, a, b, c) base##a##b##c
555 #define STAT_NAME4(base, a, b, c, d) base##a##b##c##d
556 
557 #define STAT_GLUE_NAME(base, ...) PP_GLUE(STAT_NAME, PP_NARG(__VA_ARGS__))(base, __VA_ARGS__)
558 #define STAT_TUPLE(...) std::tuple<__VA_ARGS__>
559 
560 #ifdef __INTEL_COMPILER
561 #define MAKE_MULTI_STATISTIC(cls, name, tuple, ...) \
562  bool force_instantiate_stat_name = \
563  SST::ELI::InstantiateBuilderInfo<SST::Statistics::Statistic<tuple>, cls<__VA_ARGS__>>::isLoaded() && \
564  SST::ELI::InstantiateBuilder<SST::Statistics::Statistic<tuple>, cls<__VA_ARGS__>>::isLoaded() && \
565  SST::ELI::InstantiateBuilderInfo< \
566  SST::Statistics::Statistic<tuple>, SST::Statistics::NullStatistic<tuple>>::isLoaded() && \
567  SST::ELI::InstantiateBuilder< \
568  SST::Statistics::Statistic<tuple>, SST::Statistics::NullStatistic<tuple>>::isLoaded(); \
569  } \
570  } \
571  ;
572 #else
573 #define MAKE_MULTI_STATISTIC(cls, name, tuple, ...) \
574  struct name : public cls<__VA_ARGS__> \
575  { \
576  name(SST::BaseComponent* bc, const std::string& sn, const std::string& si, SST::Params& p) : \
577  cls<__VA_ARGS__>(bc, sn, si, p) \
578  {} \
579  bool ELI_isLoaded() const \
580  { \
581  return SST::ELI::InstantiateBuilderInfo<SST::Statistics::Statistic<tuple>, name>::isLoaded() && \
582  SST::ELI::InstantiateBuilder<SST::Statistics::Statistic<tuple>, name>::isLoaded() && \
583  SST::ELI::InstantiateBuilderInfo< \
584  SST::Statistics::Statistic<tuple>, SST::Statistics::NullStatistic<tuple>>::isLoaded() && \
585  SST::ELI::InstantiateBuilder< \
586  SST::Statistics::Statistic<tuple>, SST::Statistics::NullStatistic<tuple>>::isLoaded(); \
587  } \
588  };
589 #endif
590 
591 #define SST_ELI_INSTANTIATE_MULTI_STATISTIC(cls, ...) \
592  MAKE_MULTI_STATISTIC(cls, STAT_GLUE_NAME(cls, __VA_ARGS__), STAT_TUPLE(__VA_ARGS__), __VA_ARGS__)
593 
594 } // namespace Statistics
595 } // namespace SST
596 
597 // we need to make sure null stats are instantiated for whatever types we use
598 #include "sst/core/statapi/statnull.h"
599 
600 #endif // SST_CORE_STATAPI_STATBASE_H
This class is basically a wrapper for objects to declare the order in which their members should be s...
Definition: serializer.h:34
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:94
void delayCollection(const char *delayTime)
Delay the statistic from collecting data for a specified delay time.
Definition: statbase.cc:174
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:49
Forms the base class for statistics gathering within SST.
Definition: statbase.h:63
virtual void addData_impl_Ntimes(uint64_t N, T data)
addData_impl_Ntimes Add the same data N times in a row By default, this just calls the addData functi...
Definition: statbase.h:315
void setStatisticTypeName(const char *typeName)
Set an optional Statistic Type Name.
Definition: statbase.h:213
uint64_t getCollectionCount() const
Return the current collection count.
Definition: statbase.h:155
void enable()
Enable Statistic for collections.
Definition: statbase.h:71
SSTHandlerBaseNoArgs< void, false > HandlerBase
Base handler for OneShot callbacks.
Definition: oneshot.h:38
void delayOutput(const char *delayTime)
Delay the statistic from outputting data for a specified delay time.
Definition: statbase.cc:159
StatMode_t getRegisteredCollectionMode() const
Return the collection mode that is registered.
Definition: statbase.h:167
Forms the template defined base class for statistics gathering within SST.
Definition: elementinfo.h:42
Statistic(BaseComponent *comp, const std::string &statName, const std::string &statSubId, Params &statParams)
Construct a Statistic.
Definition: statbase.h:450
Definition: serializable.h:118
virtual bool isNullStatistic() const
Indicate if the Statistic is a NullStatistic.
Definition: statbase.h:185
const std::string & getCompName() const
Return the Component Name.
Definition: statbase.cc:52
virtual void resetCollectionCount()
Set the current collection count to 0.
Definition: statbase.cc:88
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:301
Statistic(BaseComponent *comp, const std::string &statName, const std::string &statSubId, Params &statParams)
Construct a Statistic.
Definition: statbase.h:409
void addData(InArgs &&...args)
Add data to the Statistic This will call the addData_impl() routine in the derived Statistic...
Definition: statbase.h:375
Definition: paramsInfo.h:40
bool getFlagOutputAtEndOfSim() const
Return the OutputAtEndOfSim flag value.
Definition: statbase.h:164
bool getFlagClearDataOnOutput() const
Return the ClearDataOnOutput flag value.
Definition: statbase.h:161
virtual void incrementCollectionCount(uint64_t increment)
Increment current collection count.
Definition: statbase.cc:74
bool isEnabled() const
Return the enable status of the Statistic.
Definition: statbase.h:146
Definition: statoutput.h:142
virtual bool isReady() const
Indicate that the Statistic is Ready to be used.
Definition: statbase.h:182
Main component object for the simulation.
Definition: baseComponent.h:51
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:149
Definition: statbase.h:465
StatMode_t
Statistic collection mode.
Definition: statbase.h:67
virtual void clearStatisticData()
Inform the Statistic to clear its data.
Definition: statbase.h:78
virtual void addData_impl_Ntimes(uint64_t N, Args...args)
addData_impl_Ntimes Add the same data N times in a row By default, this just calls the addData functi...
Definition: statbase.h:334
void setFlagResetCountOnOutput(bool flag)
Set the Reset Count On Output flag.
Definition: statbase.h:96
Parameter store.
Definition: params.h:43
bool getFlagResetCountOnOutput() const
Return the ResetCountOnOutput flag value.
Definition: statbase.h:158
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:137
Class for instantiating Components, Links and the like out of element libraries.
Definition: factory.h:42
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:81
const char * getStatDataTypeShortName() const
Return the Statistic data type.
Definition: statbase.h:131
void setStatisticDataType(const StatisticFieldInfo::fieldType_t dataType)
Set the Statistic Data Type.
Definition: statbase.h:210
An SST core component that handles timing and event processing informing all registered Statistics to...
Definition: statengine.h:51
Definition: statgroup.h:27
Params & getParams()
Return the Statistic Parameters.
Definition: statbase.h:207
uint64_t getCollectionCountLimit() const
Return the collection count limit.
Definition: statbase.h:152
BaseComponent * getComponent() const
Return a pointer to the parent Component.
Definition: statbase.h:143
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
Definition: interfaceInfo.h:18
StatisticBase(BaseComponent *comp, const std::string &statName, const std::string &statSubId, Params &statParams)
Construct a StatisticBase.
Definition: statbase.cc:30