PipelineCollector.hpp

Go to the documentation of this file.

// <PipelineCollector.hpp> -*- C++ -*-
 
#pragma once
 
#include <set>
#include <map>
 
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/simulation/Clock.hpp"
#include "sparta/simulation/TreeNodePrivateAttorney.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/collection/CollectableTreeNode.hpp"
#include "sparta/collection/Collector.hpp"
#include "sparta/events/EventSet.hpp"
#include "sparta/events/UniqueEvent.hpp"
#include "sparta/events/GlobalOrderingPoint.hpp"
#include "sparta/kernel/Scheduler.hpp"
 
namespace sparta::app{
    class Simulation;
    extern void onPipelineCollectionShutdown(Simulation* sim);
}
 
namespace sparta{
namespace collection
{
    class PipelineCollector : public Collector
    {
        class CollectablesByClock
        {
        public:
            CollectablesByClock(const Clock * clk,
                                SchedulingPhase collection_phase) :
                ev_set_(nullptr)
            {
                switch(collection_phase)
                {
                case SchedulingPhase::Trigger:
                    ev_collect_.reset(new sparta::UniqueEvent<SchedulingPhase::Trigger>
                                      (&ev_set_, sparta::notNull(clk)->getName() + "_auto_collection_event_trigger",
                                       CREATE_SPARTA_HANDLER(CollectablesByClock, performCollection), 1));
                    break;
                case SchedulingPhase::Update:
                    ev_collect_.reset(new sparta::UniqueEvent<SchedulingPhase::Update>
                                      (&ev_set_, sparta::notNull(clk)->getName() + "_auto_collection_event_update",
                                       CREATE_SPARTA_HANDLER(CollectablesByClock, performCollection), 1));
                    break;
                case SchedulingPhase::PortUpdate:
                    ev_collect_.reset(new sparta::UniqueEvent<SchedulingPhase::PortUpdate>
                                      (&ev_set_, sparta::notNull(clk)->getName() + "_auto_collection_event_portupdate",
                                       CREATE_SPARTA_HANDLER(CollectablesByClock, performCollection), 1));
                    break;
                case SchedulingPhase::Flush:
                    ev_collect_.reset(new sparta::UniqueEvent<SchedulingPhase::Flush>
                                      (&ev_set_, sparta::notNull(clk)->getName() + "_auto_collection_event_flush",
                                       CREATE_SPARTA_HANDLER(CollectablesByClock, performCollection), 1));
                    break;
                case SchedulingPhase::Collection:
                    ev_collect_.reset(new sparta::UniqueEvent<SchedulingPhase::Collection>
                                      (&ev_set_, sparta::notNull(clk)->getName() + "_auto_collection_event_collection",
                                       CREATE_SPARTA_HANDLER(CollectablesByClock, performCollection), 1));
                    break;
                case SchedulingPhase::Tick:
                    ev_collect_.reset(new sparta::UniqueEvent<SchedulingPhase::Tick>
                                      (&ev_set_, sparta::notNull(clk)->getName() + "_auto_collection_event_tick",
                                       CREATE_SPARTA_HANDLER(CollectablesByClock, performCollection), 1));
                    break;
                case SchedulingPhase::PostTick:
                    ev_collect_.reset(new sparta::UniqueEvent<SchedulingPhase::PostTick>
                                      (&ev_set_, sparta::notNull(clk)->getName() + "_auto_collection_event_posttick",
                                       CREATE_SPARTA_HANDLER(CollectablesByClock, performCollection), 1));
                    break;
                case SchedulingPhase::__last_scheduling_phase:
                    sparta_assert(!"Should not have gotten here");
                    break;
                    // NO DEFAULT!  Allows for compiler errors if the enum
                    // class is updated.
                }
                ev_collect_->setScheduleableClock(clk);
                ev_collect_->setScheduler(clk->getScheduler());
                ev_collect_->setContinuing(false);
            }
 
            void enable(CollectableTreeNode * ctn) {
                enabled_ctns_.insert(ctn);
                // Schedule collect event in the next cycle in case
                // this is called in an unavailable pphase.
                ev_collect_->schedule(sparta::Clock::Cycle(1));
            }
 
            void disable(CollectableTreeNode * ctn) {
                enabled_ctns_.erase(ctn);
            }
 
            bool anyCollected() const {
                return !enabled_ctns_.empty();
            }
 
            void performCollection() {
                // std::for_each(enabled_ctns_.begin(),
                //               enabled_ctns_.end(), [&](CollectableTreeNode * it) {
                //                   std::cout << it->getName() << " " << ev_collect_.getClock()->currentCycle() << std::endl;
                //               });
 
                for(auto & ctn : enabled_ctns_) {
                    if(ctn->isCollected()) {
                        ctn->collect();
                    }
                }
                if(!enabled_ctns_.empty()) {
                    ev_collect_->schedule();
                }
            }
 
            void print() {
                for(auto ctn : enabled_ctns_) {
                    std::cout << '\t' << ctn->getName() << std::endl;
                }
            }
        private:
            EventSet ev_set_;
 
            std::unique_ptr<sparta::Scheduleable> ev_collect_;
            std::set<CollectableTreeNode*> enabled_ctns_;
        };
 
        // A map of the clock pointer and the structures that
        // represent collectables on that clock.
        std::map<const sparta::Clock *,
                 std::array<std::unique_ptr<CollectablesByClock>,
                            sparta::NUM_SCHEDULING_PHASES>> clock_ctn_map_;
 
        // Registered collectables
        std::set<CollectableTreeNode*> registered_collectables_;
 
        // Simulation from the root node. This is used to ensure the SimDB
        // pipeline is flushed on simulator exceptions, any newly-seen enum
        // values get stringified into the DB, ensure newly-seen std::string
        // IDs in the TinyStrings table get written to the DB, etc.
        //
        // Without proper teardown, the database blobs could be unparseable
        // for the collected data that just occurred prior to the exception.
        // Either that or there is just missing data that should be there.
        app::Simulation* simulation_ = nullptr;
 
    public:
 
        PipelineCollector(const std::string& filepath, Scheduler::Tick heartbeat_interval,
                          const sparta::Clock* root_clk, const sparta::TreeNode* root,
                          Scheduler* scheduler=nullptr) :
            Collector("PipelineCollector"),
            scheduler_(scheduler != nullptr ? scheduler : root_clk->getScheduler())
        {
            // Sanity check - pipeline collection cannot occur without a scheduler
            sparta_assert(scheduler_);
 
            sparta_assert(root != nullptr, "Pipeline Collection will not be able to create location file because it was passed a nullptr root treenode.");
            sparta_assert(root->isFinalized(), "Pipeline collection cannot be constructed until the sparta tree has been finalized.");
            // Assert that we got valid pointers necessary for pipeline collection.
            sparta_assert(root_clk != nullptr, "Cannot construct PipelineCollector because root clock is a nullptr");
            sparta_assert(scheduler_->isFinalized() == false, "Pipeline Collection cannot be instantiated after scheduler finalization -- it creates events");
 
            // Initialize the clock/collectable map and find the fastest clock
            const sparta::Clock* fastest_clk = nullptr;
            std::function<void (const sparta::Clock*)> addClks;
            addClks = [&addClks, this, &fastest_clk] (const sparta::Clock* clk)
                {
                    if(clk != nullptr){
                        auto & u_p = clock_ctn_map_[clk];
                        for(uint32_t i = 0; i < NUM_SCHEDULING_PHASES; ++i) {
                            u_p[i].reset(new CollectablesByClock(clk, static_cast<SchedulingPhase>(i)));
                        }
                        for(const sparta::TreeNode* child : sparta::TreeNodePrivateAttorney::getAllChildren(clk)) {
                            const sparta::Clock* child_clk = dynamic_cast<const sparta::Clock*>(child);
                            if(child_clk){
                                auto clk_period = child_clk->getPeriod();
                                // If this clock has a non-1 period (i.e. not the root clock)
                                // AND there is either
                                //   (A) no fastest clock yet
                                //    or
                                //   (B) this clock is a higher frequency than the fastest clock.
                                // then choose this as the fastest
                                if(clk_period != 1 && (!fastest_clk || (clk_period < fastest_clk->getPeriod()))) {
                                    fastest_clk = child_clk;
                                }
                                addClks(child_clk);
                            }
                        }
                    }
                };
            addClks(root_clk);
            if(fastest_clk == nullptr){
                fastest_clk = root_clk;
            }
 
            // A multiple to multiply against the fastest clock when no heartbeat was set.
            static const uint32_t heartbeat_multiplier = 200;
            // round heartbeat using a multiple of the fastest clock if one was not set.
            if (heartbeat_interval == 0)
            {
                sparta_assert(fastest_clk->getPeriod() != 0);
                heartbeat_interval = fastest_clk->getPeriod() * heartbeat_multiplier;                //round up to the nearest multiple of 100
                heartbeat_interval = heartbeat_interval + (100 - (heartbeat_interval % 100));
                // pipeViewer requires that intervals be a multiple of 100.
                sparta_assert(heartbeat_interval % 100 == 0)
            }
 
            // Initialize some values.
            filepath_           = filepath;
            root_clk_           = root_clk;
        }
 
        ~PipelineCollector() {
            // XXX This is a little goofy looking.  Should we make sparta_abort that takes conditional
            //    be sparta_abort_unless()?
            sparta_abort(collection_active_ != true,
                         "The PipelineCollector was not torn down properly. Before "
                         "tearing down the simulation tree, you must call "
                         "destroy() on the collector");
        }
 
        void destroy()
        {
            if(collection_active_) {
                for(auto & ctn : registered_collectables_) {
                    if(ctn->isCollected()) {
                        ctn->closeRecord(true); // set true for simulation termination
                    }
                }
            }
            registered_collectables_.clear();
            collection_active_ = false;
            onPipelineCollectionShutdown(simulation_);
        }
 
        void reactivate(const std::string& filepath)
        {
            sparta_assert(!collection_active_,
                          "You can only reactivate the PipelineCollector after you destroy it");
            filepath_ = filepath;
        }
 
        void startCollection(sparta::TreeNode* starting_node)
        {
            // Recursively collect the start node and children
            std::function<void (sparta::TreeNode* starting_node)> recursiveCollect;
            recursiveCollect = [&recursiveCollect, this] (sparta::TreeNode* starting_node)
                {
                    // First turn on this node if it's actually a CollectableTreeNode
                    CollectableTreeNode* c_node = dynamic_cast<CollectableTreeNode*>(starting_node);
                    if(c_node != nullptr) {
                        c_node->startCollecting(this);
                        if(!c_node->isIterableCollectorBin()) {
                            registered_collectables_.insert(c_node);
                        }
                    }
 
                    // Recursive step. Go through the children and turn them on as well.
                    for(sparta::TreeNode* node : sparta::TreeNodePrivateAttorney::getAllChildren(starting_node))
                    {
                        recursiveCollect(node);
                    }
                };
 
            recursiveCollect(starting_node);
        }
 
        void stopCollection(sparta::TreeNode* starting_node)
        {
            std::function<void (sparta::TreeNode* starting_node)> recursiveStopCollect;
            recursiveStopCollect = [&recursiveStopCollect, this] (sparta::TreeNode* starting_node) {
                // First turn off this node if it's actually a CollectableTreeNode
                CollectableTreeNode* c_node = dynamic_cast<CollectableTreeNode*>(starting_node);
                if(c_node != nullptr)
                {
                    c_node->stopCollecting(this);
                    registered_collectables_.erase(c_node);
                }
 
                // Recursive step. Go through the children and turn them on as well.
                for(sparta::TreeNode* node : sparta::TreeNodePrivateAttorney::getAllChildren(starting_node))
                {
                    recursiveStopCollect(node);
                }
            };
            recursiveStopCollect(starting_node);
 
            collection_active_ = !registered_collectables_.empty();
        }
 
        void stopCollection() {
            for(auto & col : registered_collectables_) {
                col->stopCollecting(this);
            }
            registered_collectables_.clear();
            onPipelineCollectionShutdown(simulation_);
        }
 
        void addToAutoCollection(CollectableTreeNode * ctn,
                                 SchedulingPhase collection_phase = SchedulingPhase::Tick)
        {
            auto ccm_pair = clock_ctn_map_.find(ctn->getClock());
            sparta_assert(ccm_pair != clock_ctn_map_.end());
            ccm_pair->second[static_cast<uint32_t>(collection_phase)]->enable(ctn);
        }
 
        void removeFromAutoCollection(CollectableTreeNode * ctn)
        {
            auto ccm_pair = clock_ctn_map_.find(ctn->getClock());
            sparta_assert(ccm_pair != clock_ctn_map_.end());
            for(auto & u_p : ccm_pair->second) {
                u_p->disable(ctn);
            }
        }
 
        bool isCollectionActive() const {
            return collection_active_;
        }
 
        const std::string & getFilePath() const {
            return filepath_;
        }
 
        Scheduler* getScheduler() const {
            return scheduler_;
        }
 
    private:
 
        const sparta::Clock * root_clk_ = nullptr;
 
        std::string filepath_;
 
        Scheduler * scheduler_;
 
        bool collection_active_ = false;
    };
 
}// namespace collection
}// namespace sparta