Collectable.hpp

Go to the documentation of this file.

// <Collectable.hpp>  -*- C++ -*-
 
#pragma once
 
#include <algorithm>
#include <sstream>
#include <functional>
#include <type_traits>
#include <iomanip>
 
#include "sparta/app/Simulation.hpp"
#include "sparta/collection/PipelineCollector.hpp"
#include "sparta/collection/BitBucket.hpp"
#include "sparta/pipeViewer/transaction_structures.hpp"
#include "sparta/events/PayloadEvent.hpp"
#include "sparta/events/EventSet.hpp"
#include "sparta/events/SchedulingPhases.hpp"
#include "sparta/pairs/SpartaKeyPairs.hpp"
#include "sparta/utils/Utils.hpp"
#include "sparta/utils/MetaStructs.hpp"
 
#include "boost/numeric/conversion/converter.hpp"
 
namespace sparta{
    namespace collection
    {
 
        template <typename U>
        std::true_type  derives_from_pair_definition_(const sparta::PairDefinition<U>*);
        std::false_type derives_from_pair_definition_(...);
 
        template <typename T>
        concept use_pair_definition = requires {
            typename T::SpartaPairDefinitionType;
            requires decltype(derives_from_pair_definition_(
                std::declval<typename T::SpartaPairDefinitionType*>()))::value;
        };
 
        template <typename T>
        concept use_raw_type =
            std::is_trivial_v<T> &&
            std::is_standard_layout_v<T> &&
            !use_pair_definition<T>;
 
        template <typename T>
        concept use_tiny_strings = std::is_same_v<T, std::string> ||
                                   std::is_same_v<std::decay_t<T>, const char*>;
 
        template <typename T>
        concept use_cast_operator =
            simdb::type_traits::is_pod_convertible_v<T> &&
            !use_raw_type<T> &&
            !use_pair_definition<T> &&
            !utils::has_ostream_operator<T>::value;
 
        template <typename T>
        concept use_dynamic_fields =
            !use_raw_type<T> &&
            !use_tiny_strings<T> &&
            !use_pair_definition<T> &&
            !use_cast_operator<T> &&
            utils::has_ostream_operator<T>::value;
 
        template <typename DataT, SchedulingPhase collection_phase = SchedulingPhase::Collection>
        class CollectableCommon : public CollectableTreeNode
        {
        public:
            using ValueType = MetaStruct::remove_any_pointer_t<DataT>;
 
            CollectableCommon(sparta::TreeNode* parent,
                              const std::string& name,
                              const std::string& group,
                              uint32_t index,
                              uint64_t parentid = 0,
                              const std::string & desc = "Collectable <manual, no desc>") :
                CollectableTreeNode(sparta::notNull(parent), name, group, index, desc),
                event_set_(this),
                ev_close_record_(&event_set_, name + "_pipeline_collectable_close_event",
                                CREATE_SPARTA_HANDLER_WITH_DATA(CollectableCommon, closeRecord, bool))
            {
            }
 
            CollectableCommon(sparta::TreeNode* parent,
                              const std::string& name,
                              const DataT * collected_object,
                              uint64_t parentid = 0,
                              const std::string & desc = "Collectable <no desc>") :
                CollectableCommon(parent, name,
                                  TreeNode::GROUP_NAME_NONE,
                                  TreeNode::GROUP_IDX_NONE,
                                  parentid,
                                  desc)
            {
                collected_object_ = collected_object;
 
                // Get an initial value, if available
                if(collected_object) {
                    initialize(*collected_object);
                }
            }
 
            CollectableCommon(sparta::TreeNode* parent,
                              const std::string& name,
                              uint64_t parentid = 0,
                              const std::string & desc = "Collectable <manual, no desc>") :
                CollectableCommon(parent, name, nullptr, parentid, desc)
            {
                // Can't auto collect without setting collected_object_
                setManualCollection();
            }
 
            virtual ~CollectableCommon() {}
 
            void initialize(const ValueType & val) {
                //TODO cnyce: handle initial value
                (void)val;
            }
 
            template <typename T>
            requires MetaStruct::is_any_pointer_v<T>
            void initialize(const T & val) {
                if (val) {
                    initialize(*val);
                }
            }
 
            void collect(const ValueType & val) {
                if(SPARTA_EXPECT_FALSE(isCollected() && (bit_bucket_ || entry_point_)))
                {
                    performCollection_(val);
                }
            }
 
            template <typename T>
            requires MetaStruct::is_any_pointer_v<T>
            void collect(const T & val) {
                if (val) {
                    collect(*val);
                } else {
                    closeRecord();
                }
            }
 
            void collectWithDuration(const ValueType & val, sparta::Clock::Cycle duration) {
                if(SPARTA_EXPECT_FALSE(isCollected()))
                {
                    if(duration != 0) {
                        ev_close_record_.preparePayload(false)->schedule(duration);
                    }
                    collect(val);
                }
            }
 
            template <typename T>
            requires MetaStruct::is_any_pointer_v<T>
            void collectWithDuration(const T & val, sparta::Clock::Cycle duration) {
                if (val) {
                    collectWithDuration(*val, duration);
                } else {
                    closeRecord();
                }
            }
 
            void collectWithDuration(sparta::Clock::Cycle duration) {
                // If pointer has become nullified, close the record
                if(nullptr == collected_object_) {
                    closeRecord();
                    return;
                }
                collectWithDuration(*collected_object_, duration);
            }
 
            void collect() override final {
                // If pointer has become nullified, close the record
                if(nullptr == collected_object_) {
                    closeRecord();
                    return;
                }
                collect(*collected_object_);
            }
 
            void closeRecord(const bool & = false) override final {
                if (SPARTA_EXPECT_FALSE(isCollected() && entry_point_)) {
                    entry_point_->closeRecord();
                }
            }
 
            void setManualCollection() {
                auto_collect_ = false;
            }
 
            void createSimDbEntryPoint(simdb::argos::ArgosCollector* argos_collector) override {
                auto loc = getLocation();
                auto clk_name = notNull(getClock())->getName();
                auto type = encodeCollectedType();
                entry_point_ = argos_collector->createScalarCollector(loc, clk_name, type);
 
                auto tiny_strings = argos_collector->getTinyStrings();
                auto enum_inspector = argos_collector->getEnumInspector();
                auto bit_bucket = std::make_shared<CollectableBitBucket>(tiny_strings, enum_inspector);
                setBitBucket(bit_bucket);
            }
 
            virtual void setBitBucket(const std::shared_ptr<BitBucket>& bit_bucket) {
                bit_bucket_ = bit_bucket;
            }
 
        protected:
 
            EventSet & getEventSet_() {
                return event_set_;
            }
 
            void setCollecting_(bool collect, Collector * collector) override {
                if(collect && !initial_bytes_.empty()) {
                    //TODO cnyce: handle initial value
                    initial_bytes_.clear();
                }
 
                // If the collected object is null, this Collectable
                // object is to be explicitly collected
                if(collected_object_ && auto_collect_) {
                    pipeline_col_ = dynamic_cast<PipelineCollector *>(collector);
                    sparta_assert(pipeline_col_ != nullptr,
                                  "Collectables can only added to PipelineCollectors... for now");
 
                    if(collect) {
                        // Add this Collectable to the PipelineCollector's
                        // list of objects requiring collection
                        pipeline_col_->addToAutoCollection(this, collection_phase);
                    }
                    else {
                        // Remove this Collectable from the
                        // PipelineCollector's list of objects requiring
                        // collection
                        pipeline_col_->removeFromAutoCollection(this);
                    }
                }
 
                if(!collect) {
                    closeRecord();
                }
            }
 
            virtual void performCollection_(const ValueType & val) = 0;
 
            const DataT * collected_object_ = nullptr;
 
            PipelineCollector * pipeline_col_ = nullptr;
 
            sparta::EventSet event_set_;
            sparta::PayloadEvent<bool, sparta::SchedulingPhase::Trigger> ev_close_record_;
 
            bool auto_collect_ = true;
 
            std::vector<char> initial_bytes_;
 
            std::shared_ptr<BitBucket> bit_bucket_;
        };
 
        #define INHERIT_COMMON_INTERFACE                                                      \
            using ValueType = typename CollectableCommon<DataT, collection_phase>::ValueType; \
            using CollectableCommon<DataT, collection_phase>::CollectableCommon;              \
            using CollectableCommon<DataT, collection_phase>::initialize;                     \
            using CollectableCommon<DataT, collection_phase>::collect;                        \
            using CollectableCommon<DataT, collection_phase>::collectWithDuration;            \
            using CollectableCommon<DataT, collection_phase>::closeRecord;                    \
            using CollectableCommon<DataT, collection_phase>::setManualCollection;            \
            using CollectableCommon<DataT, collection_phase>::getEventSet_;                   \
            using CollectableCommon<DataT, collection_phase>::bit_bucket_;                    \
            using CollectableCommon<DataT, collection_phase>::entry_point_;
 
        template<typename DataT, SchedulingPhase collection_phase = SchedulingPhase::Collection, typename = void>
        class Collectable : public CollectableCommon<DataT, collection_phase>
        {
        public:
            INHERIT_COMMON_INTERFACE
 
            std::string encodeCollectedType(bool = false) const override final {
                throw SpartaException("Uncollectable type encountered at ") << this->getLocation();
            }
 
        private:
            void performCollection_(const ValueType &) override final {
            }
        };
 
        template<typename DataT, SchedulingPhase collection_phase>
        requires use_raw_type<MetaStruct::remove_any_pointer_t<DataT>>
        class Collectable<DataT, collection_phase, void>
            : public CollectableCommon<DataT, collection_phase>
        {
        public:
            INHERIT_COMMON_INTERFACE
 
            std::string encodeCollectedType(bool human_readable = false) const override final {
                auto type = simdb::demangle_type<ValueType>();
                if constexpr (std::is_enum_v<ValueType>) {
                    if (human_readable) {
                        using underlying_t = std::underlying_type_t<ValueType>;
                        type += " (enum: " + simdb::demangle_type<underlying_t>() + ")";
                    }
                }
                return type;
            }
 
        private:
            void performCollection_(const ValueType & val) override final {
                constexpr auto dummy_field_id = 0u;
                bit_bucket_->writeField(val, dummy_field_id);
 
                if (entry_point_) {
                    static_cast<CollectableBitBucket*>(bit_bucket_.get())->writeTo(entry_point_);
                }
            }
        };
 
        template<typename DataT, SchedulingPhase collection_phase>
        requires use_tiny_strings<MetaStruct::remove_any_pointer_t<DataT>>
        class Collectable<DataT, collection_phase, void>
            : public CollectableCommon<DataT, collection_phase>
        {
        public:
            INHERIT_COMMON_INTERFACE
 
            std::string encodeCollectedType(bool = false) const override final {
                return "string";
            }
 
        private:
            void performCollection_(const ValueType & val) override final {
                constexpr auto dummy_field_id = 0u;
                bit_bucket_->writeField(val, dummy_field_id);
 
                if (entry_point_) {
                    static_cast<CollectableBitBucket*>(bit_bucket_.get())->writeTo(entry_point_);
                }
            }
        };
 
        template<typename DataT, SchedulingPhase collection_phase>
        requires use_cast_operator<MetaStruct::remove_any_pointer_t<DataT>>
        class Collectable<DataT, collection_phase, void>
            : public CollectableCommon<DataT, collection_phase>
        {
        public:
            INHERIT_COMMON_INTERFACE
 
            std::string encodeCollectedType(bool human_readable = false) const override final {
                using converted_t = simdb::type_traits::pod_convertible_t<ValueType>;
                auto type = simdb::demangle_type<converted_t>();
                if (human_readable) {
                    type += " (built-in type using cast operator)";
                }
                return type;
            }
 
        private:
            void performCollection_(const ValueType & val) override final {
                constexpr auto dummy_field_id = 0u;
                using converted_t = simdb::type_traits::pod_convertible_t<ValueType>;
                auto converted_val = static_cast<converted_t>(val);
                bit_bucket_->writeField(converted_val, dummy_field_id);
 
                if (entry_point_) {
                    static_cast<CollectableBitBucket*>(bit_bucket_.get())->writeTo(entry_point_);
                }
            }
        };
    
        template<typename DataT, SchedulingPhase collection_phase>
        requires use_dynamic_fields<MetaStruct::remove_any_pointer_t<DataT>>
        class Collectable<DataT, collection_phase, void>
            : public CollectableCommon<DataT, collection_phase>
        {
        public:
            INHERIT_COMMON_INTERFACE
 
            std::string encodeCollectedType(bool human_readable = false) const override final {
                auto type = std::string("dynamic");
                if (human_readable) {
                    type += " (" + simdb::demangle_type<ValueType>() + ")";
                }
                return type;
            }
 
            void createSimDbEntryPoint(simdb::argos::ArgosCollector* argos_collector) override final {
                std::ostringstream oss;
                oss << "Collecting non-trivial classes using operator<< only is not supported for now. Use PairDefinition.\n";
                oss << "  - path: " << this->getLocation() << "\n";
                oss << "  - type: " << simdb::demangle_type<MetaStruct::remove_any_pointer_t<DataT>>() << " (scalar)";
                argos_collector->postNotif(oss.str(), simdb::argos::NotifType::WARNING);
            }
 
        private:
            void setCollecting_(bool, Collector *) override final {
            }
 
            void performCollection_(const ValueType &) override final {
            }
        };
 
        template<typename DataT, SchedulingPhase collection_phase>
        requires use_pair_definition<MetaStruct::remove_any_pointer_t<DataT>>
        class Collectable<DataT, collection_phase, void>
            : public CollectableCommon<DataT, collection_phase>
            , public PairCollector<typename MetaStruct::remove_any_pointer_t<DataT>::SpartaPairDefinitionType>
        {
        public:
            INHERIT_COMMON_INTERFACE
 
            std::string encodeCollectedType(bool human_readable = false) const override final {
                auto type = simdb::demangle_type<ValueType>();
                if (human_readable) {
                    type += " (using PairDefinition)";
                }
                return type;
            }
 
            void serializeStructSchema(
                simdb::DatabaseManager* db_mgr,
                std::set<std::string>& serialized_types) override final
            {
                auto root_dtype = encodeCollectedType();
                if(serialized_types.count(root_dtype)) {
                    return;
                }
 
                const int32_t schema_id =
                    db_mgr->INSERT(SQL_TABLE("DataTypeSchemas"), SQL_VALUES(root_dtype))->getId();
 
                using PairDef = typename ValueType::SpartaPairDefinitionType;
                PairDef pair_def;
                sparta::PairCache pair_cache;
                pair_def.finalizeKeys(&pair_cache);
 
                const auto & names = pair_cache.getNameStrings();
                const auto & dtypes = pair_def.getLeafArgosDtypeStrings();
                const auto & formatters = pair_cache.getFormatVector();
                sparta_assert(names.size() == dtypes.size());
                sparta_assert(formatters.size() == names.size());
 
                std::vector<std::string> format_strings;
                for(size_t i = 0; i < formatters.size(); ++i) {
                    std::string fmt_str;
                    switch(formatters[i]) {
                        case PairFormatter::HEX:
                            fmt_str = "HEX"; break;
                        case PairFormatter::OCTAL:
                            fmt_str = "OCT"; break;
                        default: break;
                    }
                    format_strings.push_back(fmt_str);
                }
 
                bool verbose = false;
                if (auto sim = this->getSimulation()) {
                    verbose = sim->getSimulationConfiguration()->simdb_config.verboseMode();
                }
 
                if (verbose) {
                    std::cout << "\nSerializing PairDefinition to database for '" << root_dtype << "'...\n";
                }
                for(size_t i = 0; i < names.size(); ++i) {
                    if (verbose) {
                        std::cout << "\t" << names[i] << ", " << dtypes[i];
                        if (!format_strings[i].empty()) {
                            std::cout << " (" << format_strings[i] << ")";
                        }
                        std::cout << "\n";
                    }
 
                    db_mgr->INSERT(SQL_TABLE("DataTypeNodes"),
                                   SQL_VALUES(schema_id,
                                              names[i],
                                              dtypes[i],
                                              format_strings[i]));
                }
                serialized_types.insert(root_dtype);
            }
 
            void setBitBucket(const std::shared_ptr<BitBucket>& bit_bucket) override final {
                // Share the BitBucket with the Pairs
                setBitBucket_(bit_bucket);
 
                // Let the base class own the bit bucket
                CollectableCommon<DataT, collection_phase>::setBitBucket(bit_bucket);
            }
 
            std::string dumpNameValuePairs(const DataT & val) {
                collect_(val);
                std::ostringstream ss;
                for(const auto & pairs : this->getPEventLogVector()){
                    ss << pairs.first << "(" << pairs.second << ") ";
                }
                return ss.str();
            }
 
        private:
            typedef typename ValueType::SpartaPairDefinitionType PairDef_t;
            using PairCollector<PairDef_t>::collect_;
            using PairCollector<PairDef_t>::setBitBucket_;
 
            void performCollection_(const ValueType & val) override final {
                if (!this->isIterableCollectorBin()) {
                    bit_bucket_->clear();
                }
                collect_(val);
 
                if (entry_point_) {
                    static_cast<CollectableBitBucket*>(bit_bucket_.get())->writeTo(entry_point_);
                }
            }
 
            void generateCollectionString_() override {}
        };
 
    }//namespace collection
}//namespace sparta