SST  7.2.0
StructuralSimulationToolkit
sstinfo.h
1 // Copyright 2009-2017 Sandia Corporation. Under the terms
2 // of Contract DE-NA0003525 with Sandia Corporation, the U.S.
3 // Government retains certain rights in this software.
4 //
5 // Copyright (c) 2009-2017, Sandia Corporation
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 
13 #ifndef SST_INFO_H
14 #define SST_INFO_H
15 
16 #include <map>
17 #include <vector>
18 #include <set>
19 
20 #include <sst/core/element.h>
21 #include <sst/core/elementinfo.h>
22 
23 class TiXmlNode;
24 
25 namespace SST {
26 
27 // CONFIGURATION BITS
28 #define CFG_OUTPUTHUMAN 0x00000001
29 #define CFG_OUTPUTXML 0x00000002
30 #define CFG_VERBOSE 0x00000004
31 
32 /**
33  * The SSTInfo Configuration class.
34  *
35  * This class will parse the command line, and setup internal
36  * lists of elements and components to be processed.
37  */
39 public:
40  typedef std::multimap<std::string, std::string> FilterMap_t;
41  /** Create a new SSTInfo configuration and parse the Command Line. */
42  SSTInfoConfig();
43  ~SSTInfoConfig();
44 
45  /** Parse the Command Line.
46  * @param argc The number of arguments passed to the application
47  * @param argv The array of arguments
48  */
49  int parseCmdLine(int argc, char* argv[]);
50 
51  /** Return the list of elements to be processed. */
52  std::set<std::string> getElementsToProcessArray()
53  {
54  std::set<std::string> res;
55  for ( auto &i : m_filters )
56  res.insert(i.first);
57  return res;
58  }
59 
60  /** Return the filter map */
61  FilterMap_t& getFilterMap() { return m_filters; }
62 
63  /** Return the bit field of various command line options enabled. */
64  unsigned int getOptionBits() {return m_optionBits;}
65 
66  /** Return the user defined path the XML File. */
67  std::string& getXMLFilePath() {return m_XMLFilePath;}
68 
69  /** Is debugging output enabled? */
70  bool debugEnabled() const { return m_debugEnabled; }
71  bool processAllElements() const { return m_filters.empty(); }
72  bool doVerbose() const { return m_optionBits & CFG_VERBOSE; }
73 
74 private:
75  void outputUsage();
76  void outputVersion();
77  void addFilter(std::string name);
78 
79 private:
80  char* m_AppName;
81  std::vector<std::string> m_elementsToProcess;
82  unsigned int m_optionBits;
83  std::string m_XMLFilePath;
84  bool m_debugEnabled;
85  FilterMap_t m_filters;
86 };
87 
88 
90 public:
91  /** Output the Parameter Information.
92  * @param Index The Index of the Parameter.
93  */
94  virtual void outputHumanReadable(int index) = 0;
95 
96  /** Create the formatted XML data of the Parameter.
97  * @param Index The Index of the Parameter.
98  * @param XMLParentElement The parent element to receive the XML data.
99  */
100  virtual void outputXML(int Index, TiXmlNode* XMLParentElement) = 0;
101 
102 protected:
103  void xmlComment(TiXmlNode* owner, const char* fmt...);
104 };
105 
107 public:
108 
109  template <typename T>
110  SSTInfoElement_BaseInfo( const T *eli ) :
111  m_name(eli->name), m_desc(fs(eli->description))
112  { }
113 
115  m_name(eli.getName()), m_desc(eli.getDescription())
116  { }
117 
118  /* Because PartitionerElementInfo doesn't subclass from BaseElmentInfo... */
120  m_name(eli.getName()), m_desc(eli.getDescription())
121  { }
122 
123 
124  /** Return the Name of the Element. */
125  const std::string& getName() {return m_name;}
126 
127  /** Return the Description of the Parameter. */
128  const std::string& getDesc() {return m_desc;}
129 
130 protected:
131  template<typename TO, typename FROM>
132  std::vector<TO> convertFromELI(const FROM *ptr) {
133  std::vector<TO> res;
134  if ( ptr != NULL ) {
135  while ( ptr->name ) {
136  res.emplace_back(ptr);
137  ptr++;
138  }
139  }
140  return res;
141  }
142 
143  template<typename TO, typename FROM>
144  std::vector<TO> convertFromDB(const std::vector<FROM> &input) {
145  std::vector<TO> res;
146  for ( auto &i : input ) {
147  res.emplace_back(&i);
148  }
149  return res;
150  }
151 
152  std::string fs(const char* x) {
153  if ( x == NULL ) return "";
154  return std::string(x);
155  }
156 
157  std::string m_name;
158  std::string m_desc;
159 };
160 
161 
162 /**
163  * The SSTInfo representation of ElementInfoParam object.
164  *
165  * This class is used internally by SSTInfo to load and process
166  * ElementInfoParam objects.
167  */
169 public:
170  /** Create a new SSTInfoElement_ParamInfo object.
171  * @param elparam Pointer to an ElementInfoParam object.
172  */
174  SSTInfoElement_BaseInfo(elparam)
175  {
176  m_defaultValue = (elparam->defaultValue) ? elparam->defaultValue : "REQUIRED";
177  }
178 
179 
180  /** Return the Default value of the Parameter. */
181  const std::string& getDefault() {return m_defaultValue;}
182 
183  /** Output the Parameter Information.
184  * @param Index The Index of the Parameter.
185  */
186  void outputHumanReadable(int index) override;
187 
188  /** Create the formatted XML data of the Parameter.
189  * @param Index The Index of the Parameter.
190  * @param XMLParentElement The parent element to receive the XML data.
191  */
192  void outputXML(int Index, TiXmlNode* XMLParentElement) override;
193 
194 private:
195  std::string m_defaultValue;
196 };
197 
198 
199 /**
200  * The SSTInfo representation of ElementInfoPort object.
201  *
202  * This class is used internally by SSTInfo to load and process
203  * ElementInfoPort objects.
204  */
206 public:
207  /** Create a new SSTInfoElement_PortInfo object.
208  * @param elport Pointer to an ElementInfoPort object.
209  */
212  {
213  const char **arrayPtr = elport->validEvents;
214  while ( arrayPtr && *arrayPtr ) {
215  m_validEvents.emplace_back(*arrayPtr);
216  arrayPtr++;
217  }
218  }
221  {
222  m_validEvents = elport->validEvents;
223  }
224 
225  /** Return the array of Valid Events related to the Port. */
226  const std::vector<std::string>& getValidEvents() {return m_validEvents;}
227 
228  /** Return the number of Valid Events related to the Port. */
229  int getNumberOfValidEvents() {return m_validEvents.size();}
230 
231  /** Return the a specific Valid Events.
232  * @param index The index of the Valid Event.
233  */
234  const std::string& getValidEvent(unsigned int index) { return m_validEvents.at(index);}
235 
236  /** Output the Port Information.
237  * @param Index The Index of the Port.
238  */
239  void outputHumanReadable(int index) override;
240 
241  /** Create the formatted XML data of the Port.
242  * @param Index The Index of the Port.
243  * @param XMLParentElement The parent element to receive the XML data.
244  */
245  void outputXML(int Index, TiXmlNode* XMLParentElement) override;
246 
247 private:
248  void analyzeValidEventsArray();
249 
250  std::vector<std::string> m_validEvents;
251 
252 };
253 
254 
255 /**
256  * The SSTInfo representation of StatisticInfo object.
257  *
258  * This class is used internally by SSTInfo to load and process
259  * ElementInfoPort objects.
260  */
262 public:
263  /** Create a new SSTInfoElement_StatisticInfo object.
264  * @param elstat Pointer to an ElementInfoStatistic object.
265  */
268  m_units(els->units), m_enableLevel(els->enableLevel)
269  { }
270 
271  /** Return the Units of the Statistic. */
272  const std::string& getUnits() {return m_units;}
273 
274  /** Return the enable level of the Statistic. */
275  uint8_t getEnableLevel() {return m_enableLevel;}
276 
277  /** Output the Statistic Information.
278  * @param Index The Index of the Statistic.
279  */
280  void outputHumanReadable(int Index) override;
281 
282  /** Create the formatted XML data of the Statistic.
283  * @param Index The Index of the Statistic.
284  * @param XMLParentElement The parent element to receive the XML data.
285  */
286  void outputXML(int Index, TiXmlNode* XMLParentElement) override;
287 
288 private:
289  std::string m_units;
290  uint8_t m_enableLevel;
291 };
292 
293 
294 /**
295  * The SSTInfo representation of SubComponentSlotINfo object.
296  */
298 public:
299  /** Create a new SSTInfoElement_StatisticInfo object.
300  * @param elstat Pointer to an ElementInfoStatistic object.
301  */
304  m_interface(els->superclass)
305  { }
306 
307  /** Return the Interface which is requires */
308  const std::string& getInterface() {return m_interface;}
309 
310  /** Output the Statistic Information.
311  * @param Index The Index of the Statistic.
312  */
313  void outputHumanReadable(int Index) override;
314 
315  /** Create the formatted XML data of the Statistic.
316  * @param Index The Index of the Statistic.
317  * @param XMLParentElement The parent element to receive the XML data.
318  */
319  void outputXML(int Index, TiXmlNode* XMLParentElement) override;
320 
321 private:
322  std::string m_interface;
323 };
324 
325 
326 
327 /**
328  * The SSTInfo representation of ElementInfoComponent object.
329  *
330  * This class is used internally by SSTInfo to load and process
331  * ElementInfoComponent objects.
332  */
334 public:
335  /** Create a new SSTInfoElement_ComponentInfo object.
336  * @param elc Pointer to an ElementInfoComponent object.
337  */
339  SSTInfoElement_BaseInfo(elc), m_category(elc->category)
340  {
341  m_ParamArray = convertFromELI<SSTInfoElement_ParamInfo>(elc->params);
342  m_PortArray = convertFromELI<SSTInfoElement_PortInfo>(elc->ports);
343  m_StatisticArray = convertFromELI<SSTInfoElement_StatisticInfo>(elc->stats);
344  m_SubCompSlotArray = convertFromELI<SSTInfoElement_SubCompSlotInfo>(elc->subComponents);
345  }
346 
348  SSTInfoElement_BaseInfo(*elc), m_category(elc->getCategory())
349  {
350  m_ParamArray = convertFromDB<SSTInfoElement_ParamInfo>(elc->getValidParams());
351  m_PortArray = convertFromDB<SSTInfoElement_PortInfo>(elc->getValidPorts());
352  m_StatisticArray = convertFromDB<SSTInfoElement_StatisticInfo>(elc->getValidStats());
353  m_SubCompSlotArray = convertFromDB<SSTInfoElement_SubCompSlotInfo>(elc->getSubComponentSlots());
354  }
355 
356  /** Return a Parameter Info Object.
357  * @param index The index of the Parameter.
358  */
359  SSTInfoElement_ParamInfo* getParamInfo(int index) {return &m_ParamArray[index];}
360 
361  /** Return a Port Info Object.
362  * @param index The index of the Port.
363  */
364  SSTInfoElement_PortInfo* getPortInfo(int index) {return &m_PortArray[index];}
365 
366  /** Return a Statistic Enable Info Object.
367  * @param index The index of the Statistic Enable.
368  */
369  SSTInfoElement_StatisticInfo* getStatisticInfo(int index) {return &m_StatisticArray[index];}
370 
371  /** Return the Category value of the Component. */
372  uint32_t getCategoryValue() {return m_category;}
373 
374  /** Return the name of the Category of the Component. */
375  std::string getCategoryString() const;
376 
377  /** Output the Component Information.
378  * @param Index The Index of the Component.
379  */
380  void outputHumanReadable(int index) override;
381 
382  /** Create the formatted XML data of the Component.
383  * @param Index The Index of the Component.
384  * @param XMLParentElement The parent element to receive the XML data.
385  */
386  void outputXML(int Index, TiXmlNode* XMLParentElement) override;
387 
388 private:
389  uint32_t m_category;
390  std::vector<SSTInfoElement_ParamInfo> m_ParamArray;
391  std::vector<SSTInfoElement_PortInfo> m_PortArray;
392  std::vector<SSTInfoElement_StatisticInfo> m_StatisticArray;
393  std::vector<SSTInfoElement_SubCompSlotInfo> m_SubCompSlotArray;
394 };
395 
396 
397 /**
398  * The SSTInfo representation of ElementInfoEvent object.
399  *
400  * This class is used internally by SSTInfo to load and process
401  * ElementInfoEvent objects.
402  */
404 public:
405  /** Create a new SSTInfoElement_EventInfo object.
406  * @param ele Pointer to an ElementInfoEvent object.
407  */
410  { }
411 
412 
413  /** Output the Event Information.
414  * @param Index The Index of the Event.
415  */
416  void outputHumanReadable(int index) override;
417 
418  /** Create the formatted XML data of the Event.
419  * @param Index The Index of the Event.
420  * @param XMLParentElement The parent element to receive the XML data.
421  */
422  void outputXML(int Index, TiXmlNode* XMLParentElement) override;
423 
424 private:
425 };
426 
427 /**
428  * The SSTInfo representation of ElementInfoModule object.
429  *
430  * This class is used internally by SSTInfo to load and process
431  * ElementInfoModule objects.
432  */
434 public:
435  /** Create a new SSTInfoElement_ModuleInfo object.
436  * @param elm Pointer to an ElementInfoModule object.
437  */
439  SSTInfoElement_BaseInfo(elm), m_provides(fs(elm->provides))
440  {
441  m_ParamArray = convertFromELI<SSTInfoElement_ParamInfo>(elm->params);
442  }
444  SSTInfoElement_BaseInfo(*elm), m_provides(elm->getInterface())
445  {
446  m_ParamArray = convertFromDB<SSTInfoElement_ParamInfo>(elm->getValidParams());
447  }
448 
449  /** Return what class the Module provides. */
450  const std::string& getProvides() { return m_provides;}
451 
452  /** Return a Parameter Info Object.
453  * @param index The index of the Parameter.
454  */
455  SSTInfoElement_ParamInfo* getParamInfo(int index) {return &m_ParamArray[index];}
456 
457  /** Output the Module Information.
458  * @param Index The Index of the Module.
459  */
460  void outputHumanReadable(int index) override;
461 
462  /** Create the formatted XML data of the Module.
463  * @param Index The Index of the Module.
464  * @param XMLParentElement The parent element to receive the XML data.
465  */
466  void outputXML(int Index, TiXmlNode* XMLParentElement) override;
467 
468 private:
469  std::string m_provides;
470  std::vector<SSTInfoElement_ParamInfo> m_ParamArray;
471 };
472 
473 /**
474  * The SSTInfo representation of ElementInfoSubComponent object.
475  *
476  * This class is used internally by SSTInfo to load and process
477  * ElementInfoSubComponent objects.
478  */
480 public:
481  /** Create a new SSTInfoElement_SubComponentInfo object.
482  * @param elsc Pointer to an ElementInfoComponent object.
483  */
485  SSTInfoElement_BaseInfo(elsc), m_Provides(elsc->provides)
486  {
487  m_ParamArray = convertFromELI<SSTInfoElement_ParamInfo>(elsc->params);
488  m_PortArray = convertFromELI<SSTInfoElement_PortInfo>(elsc->ports);
489  m_StatisticArray = convertFromELI<SSTInfoElement_StatisticInfo>(elsc->stats);
490  m_SubCompSlotArray = convertFromELI<SSTInfoElement_SubCompSlotInfo>(elsc->subComponents);
491  }
492 
494  SSTInfoElement_BaseInfo(*elc), m_Provides(elc->getInterface())
495  {
496  m_ParamArray = convertFromDB<SSTInfoElement_ParamInfo>(elc->getValidParams());
497  m_PortArray = convertFromDB<SSTInfoElement_PortInfo>(elc->getValidPorts());
498  m_StatisticArray = convertFromDB<SSTInfoElement_StatisticInfo>(elc->getValidStats());
499  m_SubCompSlotArray = convertFromDB<SSTInfoElement_SubCompSlotInfo>(elc->getSubComponentSlots());
500  }
501 
502  /** Return a Parameter Info Object.
503  * @param index The index of the Parameter.
504  */
505  SSTInfoElement_ParamInfo* getParamInfo(int index) {return &m_ParamArray[index];}
506 
507  /** Return a Statistic Enable Info Object.
508  * @param index The index of the Statistic Enable.
509  */
510  SSTInfoElement_StatisticInfo* getStatisticInfo(int index) {return &m_StatisticArray[index];}
511 
512  /** Return a Port Info Object.
513  * @param index The index of the Port.
514  */
515  SSTInfoElement_PortInfo* getPortInfo(int index) {return &m_PortArray[index];}
516 
517  /** Output the SubComponent Information.
518  * @param Index The Index of the SubComponent.
519  */
520  void outputHumanReadable(int index) override;
521 
522  /** Create the formatted XML data of the Component.
523  * @param Index The Index of the Component.
524  * @param XMLParentElement The parent element to receive the XML data.
525  */
526  void outputXML(int Index, TiXmlNode* XMLParentElement) override;
527 
528  const std::string& getProvides() const { return m_Provides; }
529 
530 private:
531  std::vector<SSTInfoElement_ParamInfo> m_ParamArray;
532  std::vector<SSTInfoElement_PortInfo> m_PortArray;
533  std::vector<SSTInfoElement_StatisticInfo> m_StatisticArray;
534  std::vector<SSTInfoElement_SubCompSlotInfo> m_SubCompSlotArray;
535  std::string m_Provides;
536 };
537 
538 /**
539  * The SSTInfo representation of ElementInfoPartitioner object.
540  *
541  * This class is used internally by SSTInfo to load and process
542  * ElementInfoPartitioner objects.
543  */
545 public:
546  /** Create a new SSTInfoElement_PartitionerInfo object.
547  * @param elp Pointer to an ElementInfoPartitioner object.
548  */
551  { }
552 
555  { }
556 
557  /** Output the Partitioner Information.
558  * @param Index The Index of the Partitioner.
559  */
560  void outputHumanReadable(int index) override;
561 
562  /** Create the formatted XML data of the Partitioner.
563  * @param Index The Index of the Partitioner.
564  * @param XMLParentElement The parent element to receive the XML data.
565  */
566  void outputXML(int Index, TiXmlNode* XMLParentElement) override;
567 
568 private:
569 };
570 
571 /**
572  * The SSTInfo representation of ElementInfoGenerator object.
573  *
574  * This class is used internally by SSTInfo to load and process
575  * ElementInfoGenerator objects.
576  */
578 public:
579  /** Create a new SSTInfoElement_GeneratorInfo object.
580  * @param elg Pointer to an ElementInfoGenerator object.
581  */
584  { }
585 
586  /** Output the Generator Information.
587  * @param Index The Index of the Generator.
588  */
589  void outputHumanReadable(int index) override;
590 
591  /** Create the formatted XML data of the Generator.
592  * @param Index The Index of the Generator.
593  * @param XMLParentElement The parent element to receive the XML data.
594  */
595  void outputXML(int Index, TiXmlNode* XMLParentElement) override;
596 
597 private:
598 };
599 
600 
601 /**
602  * The SSTInfo representation of ElementLibraryInfo object.
603  *
604  * This class is used internally by SSTInfo to load and process
605  * ElementLibraryInfo objects.
606  */
608 
609 public:
610  /** Create a new SSTInfoElement_LibraryInfo object.
611  * @param eli Pointer to an ElementLibraryInfo object.
612  */
613  SSTInfoElement_LibraryInfo(const std::string& name, const ElementLibraryInfo* eli) :
614  m_name(name)
615  {
616  m_eli = eli;
617  populateLibraryInfo();
618  }
619 
620  /** Return the Name of the Library. */
621  // std::string getLibraryName() {if (m_eli && m_eli->name) return m_eli->name; else return ""; }
622  std::string getLibraryName() {return m_name; }
623 
624  /** Return the Description of the Library. */
625  std::string getLibraryDescription() {if (m_eli && m_eli->description) return m_eli->description; else return ""; }
626 
627  /** Return the number of Components within the Library. */
628  int getNumberOfLibraryComponents() {return m_ComponentArray.size();}
629 
630  /** Return the number of Events within the Library. */
631  int getNumberOfLibraryEvents() {return m_EventArray.size();}
632 
633  /** Return the number of Modules within the Library. */
634  int getNumberOfLibraryModules() {return m_ModuleArray.size();}
635 
636  /** Return the number of SubComponents within the Library. */
637  int getNumberOfLibrarySubComponents() {return m_SubComponentArray.size();}
638 
639  /** Return the number of Partitioners within the Library. */
640  int getNumberOfLibraryPartitioners() {return m_PartitionerArray.size();}
641 
642  /** Return the number of Generators within the Library. */
643  int getNumberOfLibraryGenerators() {return m_GeneratorArray.size();}
644 
645  /** Return the ElementLibraryInfo object. */
646  const ElementLibraryInfo* getLibraryInfo() {return m_eli;}
647 
648  /** Return a specific SSTInfoElement_ComponentInfo object.
649  * @param Index The index of the object.
650  */
651  SSTInfoElement_ComponentInfo* getInfoComponent(int Index) {return &m_ComponentArray[Index];}
652 
653  /** Return a specific SSTInfoElement_EventInfo object.
654  * @param Index The index of the object.
655  */
656  SSTInfoElement_EventInfo* getInfoEvent(int Index) {return &m_EventArray[Index];}
657 
658  /** Return a specific SSTInfoElement_ModuleInfo object.
659  * @param Index The index of the object.
660  */
661  SSTInfoElement_ModuleInfo* getInfoModule(int Index) {return &m_ModuleArray[Index];}
662 
663  /** Return a specific SSTInfoElement_SubComponentInfo object.
664  * @param Index The index of the object.
665  */
666  SSTInfoElement_SubComponentInfo* getInfoSubComponent(int Index) {return &m_SubComponentArray[Index];}
667 
668  /** Return a specific SSTInfoElement_PartitionerInfo object.
669  * @param Index The index of the object.
670  */
671  SSTInfoElement_PartitionerInfo* getInfoPartitioner(int Index) {return &m_PartitionerArray[Index];}
672 
673  /** Return a specific SSTInfoElement_GeneratorInfo object.
674  * @param Index The index of the object.
675  */
676  SSTInfoElement_GeneratorInfo* getInfoGenerator(int Index) {return &m_GeneratorArray[Index];}
677 
678  /** Output the Library Information.
679  * @param LibIndex The Index of the Library.
680  */
681  void outputHumanReadable(int LibIndex) override;
682 
683  /** Create the formatted XML data of the Library.
684  * @param LibIndex The Index of the Library.
685  * @param XMLParentElement The parent element to receive the XML data.
686  */
687  void outputXML(int LibIndex, TiXmlNode* XMLParentElement) override;
688 
689 private:
690  void populateLibraryInfo();
691  template<typename T> void addInfoComponent(const T* eic) {m_ComponentArray.emplace_back(const_cast<T*>(eic));}
692  template<typename T> void addInfoEvent(const T* eie) {m_EventArray.emplace_back(const_cast<T*>(eie));}
693  template<typename T> void addInfoModule(const T* eim) {m_ModuleArray.emplace_back(const_cast<T*>(eim));}
694  template<typename T> void addInfoSubComponent(const T* eisc) {m_SubComponentArray.emplace_back(const_cast<T*>(eisc));}
695  template<typename T> void addInfoPartitioner(const T* eip) {m_PartitionerArray.emplace_back(const_cast<T*>(eip));}
696  template<typename T> void addInfoGenerator(const T* eig) {m_GeneratorArray.emplace_back(const_cast<T*>(eig));}
697 
698  const ElementLibraryInfo* m_eli;
699  const std::string m_name;
700  std::vector<SSTInfoElement_ComponentInfo> m_ComponentArray;
701  std::vector<SSTInfoElement_EventInfo> m_EventArray;
702  std::vector<SSTInfoElement_ModuleInfo> m_ModuleArray;
703  std::vector<SSTInfoElement_SubComponentInfo> m_SubComponentArray;
704  std::vector<SSTInfoElement_PartitionerInfo> m_PartitionerArray;
705  std::vector<SSTInfoElement_GeneratorInfo> m_GeneratorArray;
706 
707 };
708 
709 } // namespace SST
710 
711 #endif // SST_INFO_H
SSTInfoElement_GeneratorInfo * getInfoGenerator(int Index)
Return a specific SSTInfoElement_GeneratorInfo object.
Definition: sstinfo.h:676
SSTInfoElement_PartitionerInfo(const ElementInfoPartitioner *elp)
Create a new SSTInfoElement_PartitionerInfo object.
Definition: sstinfo.h:549
const ElementInfoStatistic * stats
Definition: element.h:98
SSTInfoElement_ModuleInfo * getInfoModule(int Index)
Return a specific SSTInfoElement_ModuleInfo object.
Definition: sstinfo.h:661
Describes an Event.
Definition: element.h:73
int getNumberOfLibraryComponents()
Return the number of Components within the Library.
Definition: sstinfo.h:628
SSTInfoElement_PartitionerInfo * getInfoPartitioner(int Index)
Return a specific SSTInfoElement_PartitionerInfo object.
Definition: sstinfo.h:671
Describes a Component and its associated information.
Definition: element.h:49
The SSTInfo representation of ElementLibraryInfo object.
Definition: sstinfo.h:607
Describes a Partitioner.
Definition: element.h:106
SSTInfoElement_EventInfo * getInfoEvent(int Index)
Return a specific SSTInfoElement_EventInfo object.
Definition: sstinfo.h:656
const std::string & getInterface()
Return the Interface which is requires.
Definition: sstinfo.h:308
Definition: elibase.h:89
const char * defaultValue
Definition: elibase.h:43
std::string getLibraryDescription()
Return the Description of the Library.
Definition: sstinfo.h:625
The SSTInfo representation of ElementInfoGenerator object.
Definition: sstinfo.h:577
const char ** validEvents
Definition: elibase.h:51
Definition: elementinfo.h:40
The SSTInfo representation of ElementInfoModule object.
Definition: sstinfo.h:433
Describes all the parts of the Element Library.
Definition: element.h:130
int getNumberOfLibrarySubComponents()
Return the number of SubComponents within the Library.
Definition: sstinfo.h:637
Definition: elementinfo.h:120
The SSTInfo representation of ElementInfoEvent object.
Definition: sstinfo.h:403
const std::string & getProvides()
Return what class the Module provides.
Definition: sstinfo.h:450
SSTInfoElement_PortInfo * getPortInfo(int index)
Return a Port Info Object.
Definition: sstinfo.h:364
SSTInfoElement_SubComponentInfo * getInfoSubComponent(int Index)
Return a specific SSTInfoElement_SubComponentInfo object.
Definition: sstinfo.h:666
SSTInfoElement_ParamInfo(const ElementInfoParam *elparam)
Create a new SSTInfoElement_ParamInfo object.
Definition: sstinfo.h:173
Definition: sstinfo.h:106
The SSTInfo representation of ElementInfoComponent object.
Definition: sstinfo.h:333
SSTInfoElement_ModuleInfo(const ElementInfoModule *elm)
Create a new SSTInfoElement_ModuleInfo object.
Definition: sstinfo.h:438
Definition: action.cc:17
bool debugEnabled() const
Is debugging output enabled?
Definition: sstinfo.h:70
Describes Ports that the Component can use.
Definition: elibase.h:56
const std::string & getDesc()
Return the Description of the Parameter.
Definition: sstinfo.h:128
SSTInfoElement_ComponentInfo * getInfoComponent(int Index)
Return a specific SSTInfoElement_ComponentInfo object.
Definition: sstinfo.h:651
SSTInfoElement_PortInfo * getPortInfo(int index)
Return a Port Info Object.
Definition: sstinfo.h:515
The SSTInfo representation of SubComponentSlotINfo object.
Definition: sstinfo.h:297
const ElementInfoStatistic * stats
Definition: element.h:57
SSTInfoElement_GeneratorInfo(const ElementInfoGenerator *elg)
Create a new SSTInfoElement_GeneratorInfo object.
Definition: sstinfo.h:582
Definition: elementinfo.h:97
SSTInfoElement_SubComponentInfo(const ElementInfoSubComponent *elsc)
Create a new SSTInfoElement_SubComponentInfo object.
Definition: sstinfo.h:484
SSTInfoElement_StatisticInfo * getStatisticInfo(int index)
Return a Statistic Enable Info Object.
Definition: sstinfo.h:369
The SSTInfo Configuration class.
Definition: sstinfo.h:38
SSTInfoElement_StatisticInfo(const ElementInfoStatistic *els)
Create a new SSTInfoElement_StatisticInfo object.
Definition: sstinfo.h:266
Describes Statistics used by a Component.
Definition: elibase.h:31
int getNumberOfLibraryGenerators()
Return the number of Generators within the Library.
Definition: sstinfo.h:643
Describes a Generator.
Definition: element.h:115
Definition: sstinfo.h:89
The SSTInfo representation of ElementInfoParam object.
Definition: sstinfo.h:168
Definition: elementinfo.h:133
SSTInfoElement_StatisticInfo * getStatisticInfo(int index)
Return a Statistic Enable Info Object.
Definition: sstinfo.h:510
The SSTInfo representation of ElementInfoPort object.
Definition: sstinfo.h:205
std::string & getXMLFilePath()
Return the user defined path the XML File.
Definition: sstinfo.h:67
const ElementLibraryInfo * getLibraryInfo()
Return the ElementLibraryInfo object.
Definition: sstinfo.h:646
SSTInfoConfig()
Create a new SSTInfo configuration and parse the Command Line.
Definition: sstinfo.cc:279
const std::string & getDefault()
Return the Default value of the Parameter.
Definition: sstinfo.h:181
SSTInfoElement_EventInfo(const ElementInfoEvent *ele)
Create a new SSTInfoElement_EventInfo object.
Definition: sstinfo.h:408
const ElementInfoParam * params
Definition: element.h:97
const std::string & getUnits()
Return the Units of the Statistic.
Definition: sstinfo.h:272
Describes Parameters to a Component.
Definition: elibase.h:40
int getNumberOfLibraryEvents()
Return the number of Events within the Library.
Definition: sstinfo.h:631
Definition: elementinfo.h:109
int getNumberOfValidEvents()
Return the number of Valid Events related to the Port.
Definition: sstinfo.h:229
int getNumberOfLibraryModules()
Return the number of Modules within the Library.
Definition: sstinfo.h:634
int parseCmdLine(int argc, char *argv[])
Parse the Command Line.
Definition: sstinfo.cc:308
const std::string & getName()
Return the Name of the Element.
Definition: sstinfo.h:125
unsigned int getOptionBits()
Return the bit field of various command line options enabled.
Definition: sstinfo.h:64
SSTInfoElement_LibraryInfo(const std::string &name, const ElementLibraryInfo *eli)
Create a new SSTInfoElement_LibraryInfo object.
Definition: sstinfo.h:613
SSTInfoElement_ParamInfo * getParamInfo(int index)
Return a Parameter Info Object.
Definition: sstinfo.h:455
Describes a Module.
Definition: element.h:82
SSTInfoElement_ParamInfo * getParamInfo(int index)
Return a Parameter Info Object.
Definition: sstinfo.h:505
const std::string & getValidEvent(unsigned int index)
Return the a specific Valid Events.
Definition: sstinfo.h:234
const ElementInfoPort * ports
Definition: element.h:55
const ElementInfoPort * ports
Definition: element.h:100
SSTInfoElement_ParamInfo * getParamInfo(int index)
Return a Parameter Info Object.
Definition: sstinfo.h:359
const std::vector< std::string > & getValidEvents()
Return the array of Valid Events related to the Port.
Definition: sstinfo.h:226
int getNumberOfLibraryPartitioners()
Return the number of Partitioners within the Library.
Definition: sstinfo.h:640
std::set< std::string > getElementsToProcessArray()
Return the list of elements to be processed.
Definition: sstinfo.h:52
uint32_t getCategoryValue()
Return the Category value of the Component.
Definition: sstinfo.h:372
const ElementInfoParam * params
Definition: element.h:88
const ElementInfoParam * params
Definition: element.h:54
Describes Ports that the Component can use.
Definition: elibase.h:48
The SSTInfo representation of ElementInfoPartitioner object.
Definition: sstinfo.h:544
SSTInfoElement_PortInfo(const ElementInfoPort *elport)
Create a new SSTInfoElement_PortInfo object.
Definition: sstinfo.h:210
Definition: element.h:92
const std::vector< std::string > validEvents
Definition: elibase.h:59
uint8_t getEnableLevel()
Return the enable level of the Statistic.
Definition: sstinfo.h:275
The SSTInfo representation of StatisticInfo object.
Definition: sstinfo.h:261
SSTInfoElement_ComponentInfo(const ElementInfoComponent *elc)
Create a new SSTInfoElement_ComponentInfo object.
Definition: sstinfo.h:338
std::string getLibraryName()
Return the Name of the Library.
Definition: sstinfo.h:622
SSTInfoElement_SubCompSlotInfo(const ElementInfoSubComponentSlot *els)
Create a new SSTInfoElement_StatisticInfo object.
Definition: sstinfo.h:302
The SSTInfo representation of ElementInfoSubComponent object.
Definition: sstinfo.h:479
FilterMap_t & getFilterMap()
Return the filter map.
Definition: sstinfo.h:61