InstrumentationNode.hpp

Go to the documentation of this file.

// <InstrumentationNode> -*- C++ -*-
 
#pragma once
 
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/Utils.hpp"
 
namespace sparta {
 
class StatisticInstance;
 
class InstrumentationNode : public TreeNode
{
public:
 
 
    typedef uint32_t visibility_t;
 
    enum Visibility {
        VIS_HIDDEN  = 0,
 
        VIS_SUPPORT = 1000000, // 1M
 
        VIS_DETAIL  = 10000000, // 10M
 
        VIS_NORMAL  = 100000000, // 100M
 
        VIS_SUMMARY = VIS_NORMAL  * 2, // 100M * 2
 
        /*
         * If needed, more levels of visibility can be inserted here: VIS_SUMMARY_L2 - VIS_SUMMARY_L9
         */
 
        VIS_CRITICAL = 1000000000, // 1B
 
        VIS_MAX     = ~(visibility_t)0
 
    };
 
    static constexpr visibility_t AUTO_VISIBILITY = VIS_MAX;
 
    static constexpr visibility_t CONTAINER_DEFAULT_VISIBILITY = VIS_HIDDEN;
 
    static constexpr visibility_t DEFAULT_VISIBILITY = (visibility_t)VIS_NORMAL;
 
    typedef uint32_t class_t;
 
    enum Class {
        CLASS_OTHER  = 0,
 
        CLASS_IMPORTANT  = 50,
 
        CLASS_CRITICAL  = 100,
 
        CLASS_MAX     = ~(class_t)0
 
    };
 
    static constexpr class_t AUTO_CLASS = CLASS_IMPORTANT;
 
    static constexpr class_t CONTAINER_DEFAULT_CLASS = CLASS_IMPORTANT;
 
    static constexpr class_t DEFAULT_CLASS = (class_t)CLASS_IMPORTANT;
 
    enum Type {
        TYPE_STATISTICDEF = 0,
 
        TYPE_COUNTER,
 
        TYPE_PARAMETER,
 
        TYPE_HISTOGRAM,
 
        NUM_TYPES
 
    };
 
 
 
    InstrumentationNode() = delete;
 
    InstrumentationNode(const InstrumentationNode&) = delete;
 
    InstrumentationNode(InstrumentationNode&& rhp) :
        TreeNode::TreeNode(std::move(rhp)),
        visibility_(rhp.visibility_),
        class_(rhp.class_),
        instrument_type_(rhp.instrument_type_)
    {
    }
 
    InstrumentationNode& operator=(const InstrumentationNode&) = delete;
 
    InstrumentationNode(TreeNode* parent,
                        const std::string& name,
                        const std::string& group,
                        group_idx_type group_idx,
                        const std::string& desc,
                        Type type,
                        visibility_t visibility,
                        class_t n_class) :
        TreeNode::TreeNode(parent, name, group, group_idx, desc),
        visibility_(visibility),
        class_(n_class),
        instrument_type_(type)
    { }
 
    InstrumentationNode(TreeNode* parent,
                        const std::string& name,
                        const std::string& group,
                        group_idx_type group_idx,
                        const std::string& desc,
                        Type type,
                        visibility_t visibility) :
        TreeNode::TreeNode(parent, name, group, group_idx, desc),
        visibility_(visibility),
        class_(DEFAULT_CLASS),
        instrument_type_(type)
    { }
 
    InstrumentationNode(TreeNode* parent,
                        const std::string& name,
                        const std::string& group,
                        group_idx_type group_idx,
                        const std::string& desc,
                        Type type) :
        InstrumentationNode(parent,
                            name,
                            group,
                            group_idx,
                            desc,
                            type,
                            DEFAULT_VISIBILITY,
                            DEFAULT_CLASS)
    {
        // Delegated constructor
    }
 
    InstrumentationNode(const std::string& name,
                        const std::string& group,
                        group_idx_type group_idx,
                        const std::string& desc,
                        Type type) :
        InstrumentationNode(nullptr,
                            name,
                            group,
                            group_idx,
                            desc,
                            type,
                            DEFAULT_VISIBILITY,
                            DEFAULT_CLASS)
    {
        // Delegated constructor
    }
 
    InstrumentationNode(const std::string& name,
                        const std::string& group,
                        group_idx_type group_idx,
                        const std::string& desc,
                        Type type,
                        visibility_t visibility,
                        class_t n_class) :
        InstrumentationNode(nullptr,
                            name,
                            group,
                            group_idx,
                            desc,
                            type,
                            visibility,
                            n_class)
    {
        // Delegated constructor
    }
 
    InstrumentationNode(const std::string& name,
                        const std::string& group,
                        group_idx_type group_idx,
                        const std::string& desc,
                        Type type,
                        visibility_t visibility):
        InstrumentationNode(nullptr,
                            name,
                            group,
                            group_idx,
                            desc,
                            type,
                            visibility,
                            DEFAULT_CLASS)
    {
        // Delegated constructor
    }
 
    InstrumentationNode(TreeNode* parent,
                        const std::string& name,
                        const std::string& desc,
                        Type type) :
        InstrumentationNode::InstrumentationNode(parent,
                                                 name,
                                                 GROUP_NAME_NONE,
                                                 GROUP_IDX_NONE,
                                                 desc,
                                                 type,
                                                 DEFAULT_VISIBILITY,
                                                 DEFAULT_CLASS)
    {
        // Delegated constructor
    }
 
    InstrumentationNode(TreeNode* parent,
                        const std::string& name,
                        const std::string& desc,
                        Type type,
                        visibility_t visibility,
                        class_t n_class) :
        InstrumentationNode::InstrumentationNode(parent,
                                                 name,
                                                 GROUP_NAME_NONE,
                                                 GROUP_IDX_NONE,
                                                 desc,
                                                 type,
                                                 visibility,
                                                 n_class)
    {
        // Delegated constructor
    }
 
    InstrumentationNode(TreeNode* parent,
                        const std::string& name,
                        const std::string& desc,
                        Type type,
                        visibility_t visibility):
        InstrumentationNode::InstrumentationNode(parent,
                                                 name,
                                                 GROUP_NAME_NONE,
                                                 GROUP_IDX_NONE,
                                                 desc,
                                                 type,
                                                 visibility,
                                                 DEFAULT_CLASS)
    {
        // Delegated constructor
    }
 
 
    InstrumentationNode(const std::string& name,
                        const std::string& desc,
                        Type type) :
        InstrumentationNode::InstrumentationNode(nullptr,
                                                 name,
                                                 GROUP_NAME_NONE,
                                                 GROUP_IDX_NONE,
                                                 desc,
                                                 type,
                                                 DEFAULT_VISIBILITY,
                                                 DEFAULT_CLASS)
    {
        // Delegated constructor
    }
 
    InstrumentationNode(const std::string& name,
                        const std::string& desc,
                        Type type,
                        visibility_t visibility,
                        class_t n_class) :
        InstrumentationNode::InstrumentationNode(nullptr,
                                                 name,
                                                 GROUP_NAME_NONE,
                                                 GROUP_IDX_NONE,
                                                 desc,
                                                 type,
                                                 visibility,
                                                 n_class)
    {
        // Delegated constructor
    }
 
    InstrumentationNode(const std::string& name,
                        const std::string& desc,
                        Type type,
                        visibility_t visibility):
        InstrumentationNode::InstrumentationNode(nullptr,
                                                 name,
                                                 GROUP_NAME_NONE,
                                                 GROUP_IDX_NONE,
                                                 desc,
                                                 type,
                                                 visibility,
                                                 DEFAULT_CLASS)
    {
        // Delegated constructor
    }
 
    virtual ~InstrumentationNode()
    {
    }
 
 
 
    visibility_t getVisibility() const {
        return visibility_;
    }
 
    class_t getClass() const {
        return class_;
    }
 
    Type getInstrumentationType() const {
        return instrument_type_;
    }
 
 
 
    virtual bool groupedPrinting(const std::vector<const StatisticInstance*> & sub_stats,
                                 std::set<const void*> & dont_print_these,
                                 void * grouped_json,
                                 void * doc) const {
        (void) sub_stats;
        (void) dont_print_these;
        (void) grouped_json;
        (void) doc;
        return false;
    }
 
    virtual bool groupedPrintingReduced(const std::vector<const StatisticInstance*> & sub_stats,
                                        std::set<const void*> & dont_print_these,
                                        void * grouped_json,
                                        void * doc) const {
        (void) sub_stats;
        (void) dont_print_these;
        (void) grouped_json;
        (void) doc;
        return false;
    }
 
    virtual bool groupedPrintingDetail(const std::vector<const StatisticInstance*> & sub_stats,
                                       std::set<const void*> & dont_print_these,
                                       void * grouped_json,
                                       void * doc) const {
        (void) sub_stats;
        (void) dont_print_these;
        (void) grouped_json;
        (void) doc;
        return false;
    }
 
    using StringPair = std::pair<std::string, std::string>;
    const std::vector<StringPair> & getMetadata() const {
        return metadata_;
    }
 
 
protected:
 
    void addMetadata_(const std::string & key, const std::string & value){
        metadata_.emplace_back(std::make_pair(key, value));
    }
 
private:
 
    visibility_t visibility_;
 
    class_t class_;
 
    Type instrument_type_;
 
    std::vector<StringPair> metadata_;
};
 
} // namespace sparta
 
// __INSTRUMENTATION_NODE__