NestedPeventCollector.hpp

// <NestedPeventCollector> -*- C++ -*-
 
 
#pragma once
 
#include "sparta/simulation/Clock.hpp"
#include "sparta/pairs/SpartaKeyPairs.hpp"
#include "sparta/pevents/PeventTreeNode.hpp"
#include "sparta/log/MessageSource.hpp"
#include "sparta/utils/MetaStructs.hpp"
 
#include <boost/algorithm/string.hpp>
 
#define PEVENT_COLLECTOR_NOTE "_pevent"
namespace sparta {
namespace pevents {
 
    template<typename DataT>
    class NestedPeventCollector :
        public sparta::PairCollector<
            typename MetaStruct::remove_any_pointer<
                DataT>::type::SpartaPairDefinitionType>, public PeventCollectorTreeNode {
 
        // Aliasing the actual Datatype of the collectable being collected as Data_t
        typedef typename MetaStruct::remove_any_pointer<DataT>::type Data_t;
 
        // Aliasing the Datatype of the Pair Definition of the collectable being collected as PairDef_t
        typedef typename Data_t::SpartaPairDefinitionType PairDef_t;
 
        using PairCollector<PairDef_t>::getPEventLogVector;
        using PairCollector<PairDef_t>::turnOn_;
        using PairCollector<PairDef_t>::turnOff_;
        using PairCollector<PairDef_t>::collect_;
 
    public:
        using PairCollector<PairDef_t>::isCollecting;
        NestedPeventCollector(const std::string& event_name,
            sparta::TreeNode* parent,
                const Clock* clk,
                    const bool verbosity=false) :
            sparta::PairCollector<PairDef_t>(),
            PeventCollectorTreeNode(parent,
                event_name+PEVENT_COLLECTOR_NOTE+(verbosity ? "_verbose" : "")),
            event_name_(event_name),
            message_src_(this,
                event_name+PEVENT_COLLECTOR_NOTE,
                    "A collector used to collect pevent data."),
            clk_(clk),
            f_skew_(std::plus<uint64_t>()),
            skew_(0u),
            verbosity_(verbosity) {
 
            // There should never be a null clock
            sparta_assert (clk_ != nullptr);
        }
 
        virtual ~NestedPeventCollector() {}
 
        template<typename... Targs>
        void collect(const Data_t & obj,
            const Targs &... pos_args) {
            if(isCollecting()) {
                collect_(obj, pos_args...);
                generateCollectionString_();
            }
        }
 
        virtual const std::string& eventName() override {
            return event_name_;
        }
 
        void adjustSkew(const int32_t & skew_amount) {
            skew_ = std::abs(skew_amount);
            if(skew_amount >= 0) {
                f_skew_ = std::plus<uint64_t>();
            }
            else {
                f_skew_ = std::minus<uint64_t>();
            }
        }
 
        virtual bool addTap(const std::string& type, const std::string& file, const bool verbose) override final {
 
            // notice we only checkout on the lower case.
            std::string lowertype = type;
            boost::algorithm::to_lower(lowertype);
            std::string lower_ev_name = event_name_;
            boost::algorithm::to_lower(lower_ev_name);
            if(( lowertype == lower_ev_name || lowertype == "all") && verbosity_ == verbose) {
                // Make sure they cannot add taps after the trigger has fired.
                sparta_assert(running_ == false, "Cannot turnOn a pevent collector for which go() has already been called.");
 
                // only create a custom tap if we don't already have this one.
                // we could potentially end up with duplicates since the user can turn collection
                // on at treenodes that overlap
                bool is_unique = true;
                for(const auto& existing_tap : taps_) {
                    if(existing_tap->getDestination()->compareStrings(file) &&
                        (existing_tap->getCategoryName() == lowertype
                            || lowertype == "all")) {
                        is_unique = false;
                        break;
                    }
                }
 
                if(is_unique) {
                    // Setup a tap to capture the output.
                    taps_.emplace_back(new log::Tap(this, event_name_+PEVENT_COLLECTOR_NOTE, file));
                    // We detatch the tap since we need to wait till the trigger
                    // fires or is manually started to start pevent collection.
                    taps_[taps_.size() - 1]->detach();
                    // We did create a tap.
                    return true;
                }
            }
 
            // We never added a tap because it was not appropriate for our
            // event type.
            return false;
        }
 
        // Coming in a bit.
        virtual void turnOff(const std::string& type) override final {
            sparta_assert(false, "peventTurnOff not yet supported");
            if(type == event_name_) {
 
                //remove the taps, this is coming in the future.
                if(taps_.empty()) {
                    turnOff_();
                }
            }
        }
 
        virtual void go() override final {
            if(taps_.size() > 0) {
                running_ = true;
                // Mark the pair collector running
                turnOn_();
            }
 
            // replace the taps here so that we are officially collecting the data to file.
            for(auto& tap : taps_) {
                tap->reset(this);
            }
        }
 
    protected:
 
        virtual void generateCollectionString_() override final {
 
            // Write the pevent to the log.
            std::stringstream ss;
 
            // Write the event name.
            ss << "ev=" << "\"" << event_name_ << "\" ";
 
            // Now write the cached key values.
            for(const auto & pair : getPEventLogVector())
            {
                ss << pair.first << "=" << "\"" << pair.second << "\" ";
            }
 
            // Write the time
            ss << "cyc=" << f_skew_(clk_->currentCycle(), skew_);
 
            // Finish the line
            ss << ";";
            message_src_ << ss.str();
        }
 
    private:
 
        const std::string event_name_;
 
        // We are going to use sparta's logger to output our pevents for ease.
        log::MessageSource message_src_;
 
        // Log taps that this pevent is being outputted too.
        std::vector<std::unique_ptr<log::Tap > > taps_;
 
        // We do need a clock b/c each pevent records it's time.
        const Clock* clk_;
        std::function<uint64_t(const uint64_t &, const uint32_t &)> f_skew_;
        uint32_t skew_;
        bool verbosity_;
        bool running_ = false;
    };
} // namespace pevents
} // namespace sparta