collection.h

Go to the documentation of this file.

// Copyright (c) 2021, Aalto University, developed by Erik Schultheis
// All rights reserved.
//
// SPDX-License-Identifier: MIT
 
#ifndef DISMEC_COLLECTION_H
#define DISMEC_COLLECTION_H
 
#include "stats_base.h"
#include <vector>
#include <type_traits>
#include <memory>
#include "matrix_types.h"
#include "stat_id.h"
 
namespace dismec::stats
{
    class StatisticsCollection {
    public:
        // declaration and registration of stats
        void declare_stat(stat_id_t index, StatisticMetaData meta);
 
        void declare_tag(tag_id_t index, std::string name);
 
        void register_stat(const std::string& name, std::unique_ptr<Statistics> stat);
 
        // access stats
        [[nodiscard]] const std::vector<StatisticMetaData>& get_statistics_meta() const { return m_MetaData; }
 
        [[nodiscard]] const Statistics& get_stat(const std::string& name) const;
 
        [[nodiscard]] TagContainer get_tag_by_name(const std::string& name) const;
 
        [[nodiscard]] const std::vector<TagContainer>& get_all_tags() const { return m_TagValues; }
 
         void provide_tags(const StatisticsCollection& other);
 
        // enable / disable
        void enable(stat_id_t stat);
 
        void disable(stat_id_t stat);
 
        [[nodiscard]] bool is_enabled(stat_id_t stat) const {
#ifdef NDEBUG
            return m_Enabled[stat.to_index()];
#else
            // additional checking for debug builds.
            return m_Enabled.at(stat.to_index());
#endif
        }
 
        void enable(const std::string& stat);
 
        void disable(const std::string& stat);
 
        [[nodiscard]] bool has_stat(const std::string& name) const;
 
        [[nodiscard]] bool is_enabled_by_name(const std::string& name) const;
 
        // recording
        template<class T, std::enable_if_t<!std::is_invocable_v<T>, bool> = true>
        void record(stat_id_t stat, T&& value) {
            if(is_enabled(stat)) {
                do_record(stat.to_index(), std::forward<T>(value));
            }
        }
 
        template<class F, std::enable_if_t<std::is_invocable_v<F>, bool> = true>
        void record(stat_id_t stat, F&& callable) {
            if(is_enabled(stat)) {
                // we wrap callable into an immediately invoked lambda, which is annotated as cold, so that
                // the code-path with stat disabled is optimized.
                do_record(stat.to_index(), [&]() __attribute__((cold)) { return callable(); }());
            }
        }
 
         void set_tag(tag_id_t tag, int value) {
#ifdef NDEBUG
            m_TagValues[tag.to_index()].set_value(value);
#else
            m_TagValues.at(tag.to_index()).set_value(value);
#endif
         }
 
 
    private:
        template<class T>
        void do_record(int index, T&& value) {
            m_Statistics[index]->record(std::forward<T>(value));
        }
 
        std::vector<bool> m_Enabled;
        std::vector<StatisticMetaData> m_MetaData;
        std::vector<std::unique_ptr<Statistics>> m_Statistics;
 
        std::vector<TagContainer> m_TagValues;
        std::unordered_map<std::string, TagContainer> m_TagLookup;
    };
}
 
#endif //DISMEC_COLLECTION_H