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