DelayedCollectable.hpp

Go to the documentation of this file.

// <DelayedCollectable.hpp>  -*- C++ -*-
 
#pragma once
 
#include <sstream>
#include <functional>
#include "sparta/collection/Collectable.hpp"
#include "sparta/pipeViewer/transaction_structures.hpp"
#include "sparta/events/EventSet.hpp"
#include "sparta/events/PayloadEvent.hpp"
 
namespace sparta {
 
namespace collection
{
    template<class DataT>
    class DelayedCollectable : public Collectable<DataT>
    {
        using CollectableTreeNode::isCollected;
 
        struct DurationData
        {
            DurationData() {}
 
            DurationData(const DataT & dat,
                         sparta::Clock::Cycle duration) :
                data(dat), duration(duration)
            {}
 
            DataT data;
            sparta::Clock::Cycle duration;
        };
 
    public:
 
        // Promote the collect method from Collectable
        using Collectable<DataT>::collect;
 
        DelayedCollectable(sparta::TreeNode* parent,
                           const std::string& name,
                           const std::string& group,
                           uint32_t index,
                           uint64_t parentid = 0,
                           const std::string & desc = "DelayedCollectable <manual, no desc>") :
            Collectable<DataT>(parent, name, group, index, desc)
        {
            (void) parentid;
        }
 
        DelayedCollectable(sparta::TreeNode* parent,
                           const std::string& name,
                           const DataT * collected_object,
                           uint64_t parentid = 0,
                           const std::string & desc = "DelayedCollectable <no desc>") :
            Collectable<DataT>(parent, name, collected_object, parentid, desc)
        {}
 
        DelayedCollectable(sparta::TreeNode* parent,
                           const std::string& name,
                           uint64_t parentid = 0,
                           const std::string & desc = "DelayedCollectable <manual, no desc>") :
            DelayedCollectable(parent, name, nullptr, parentid, desc)
        {
            // Can't auto collect without setting iterable_object_
            Collectable<DataT>::setManualCollection();
        }
 
        void collect(const DataT & val, sparta::Clock::Cycle delay)
        {
            if(SPARTA_EXPECT_FALSE(isCollected()))
            {
                if(delay != 0) {
                    ev_collect_.schedule(val, delay);
                }
                else {
                    Collectable<DataT>::collect(val);
                }
            }
        }
 
        void collectWithDuration(const DataT & val,
                                 sparta::Clock::Cycle delay,
                                 sparta::Clock::Cycle duration)
        {
            if(SPARTA_EXPECT_FALSE(isCollected()))
            {
                if(delay != 0) {
                    ev_collect_duration_.preparePayload({val, duration})->schedule(delay);
                }
                else {
                    Collectable<DataT>::collectWithDuration(val, duration);
                }
            }
        }
 
    private:
 
        // Called from collectWithDuration where the data needs to be
        // delivered at a given delayed time, but only for a short
        // duration.
        void collectWithDuration_(const DurationData & dur_dat) {
            Collectable<DataT>::collectWithDuration(dur_dat.data, dur_dat.duration);
        }
 
        // For those folks that want collection to appear in the
        // future
        sparta::PayloadEvent<DataT, SchedulingPhase::Collection> ev_collect_{
            &Collectable<DataT>::getEventSet_(), "delayedpipelinecollectable_event",
                CREATE_SPARTA_HANDLER_WITH_DATA(Collectable<DataT>, collect, DataT)};
 
        // For those folks that want collection to appear in the
        // future with a duration
        sparta::PayloadEvent<DurationData, SchedulingPhase::Collection> ev_collect_duration_{
            &Collectable<DataT>::getEventSet_(), "delayedpipelinecollectable_duration_event",
                CREATE_SPARTA_HANDLER_WITH_DATA(DelayedCollectable<DataT>,
                                              collectWithDuration_, DurationData)};
 
 
    };
}//namespace collection
}//namespace sparta