Pipe.hpp

Go to the documentation of this file.

// <Pipe.hpp> -*- C++ -*-
 
 
#pragma once
 
#include <cinttypes>
#include <memory>
#include <functional>
#include "sparta/simulation/Clock.hpp"
#include "sparta/ports/Port.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/MathUtils.hpp"
#include "sparta/collection/IterableCollector.hpp"
#include "sparta/utils/ValidValue.hpp"
#include "sparta/utils/IteratorTraits.hpp"
 
namespace sparta
{
 
template <typename DataT>
class Pipe
{
 
private:
 
    struct PipeEntry
    {
        sparta::utils::ValidValue<DataT> data;
    };
 
    uint32_t getPhysicalStage_ (int32_t stage) const
    {
        sparta_assert (stage < static_cast<int32_t>(num_entries_));
        return (tail_ + stage) & stage_mask_;
    }
 
    void initPipe_(uint32_t num_entries)
    {
        sparta_assert(num_entries > 0, "ERROR: sparta::Pipe '" << name_
                    << "' Cannot be created with 0 stages");
        num_entries_ = num_entries;
        physical_size_ = sparta::utils::pow2 (sparta::utils::ceil_log2 (num_entries + 1));
        stage_mask_ = physical_size_ - 1;
        pipe_.reset(new PipeEntry[physical_size_]);
    }
 
public:
 
    typedef DataT value_type;
 
    typedef uint32_t size_type;
 
    template <bool is_const_iterator = true>
    class PipeIterator : public utils::IteratorTraits<std::forward_iterator_tag, value_type>
    {
        typedef typename std::conditional<is_const_iterator,
                                          const value_type &,
                                          value_type &>::type DataReferenceType;
 
        typedef typename std::conditional<is_const_iterator,
                                          const Pipe<DataT> *,
                                          Pipe<DataT> *>::type PipePointerType;
        DataReferenceType getAccess_(std::false_type) {
            return pipe_->access(index_);
        }
 
        DataReferenceType getAccess_(std::true_type) {
            return pipe_->read(index_);
        }
 
    public:
 
        PipeIterator(PipePointerType pipe) : pipe_(pipe) {}
 
        PipeIterator(PipePointerType pipe, uint32_t index) : pipe_(pipe), index_(index) {}
 
        PipeIterator(const PipeIterator &) = default;
 
        PipeIterator(PipeIterator &&)      = default;
 
        DataReferenceType operator*() {
            sparta_assert(index_ != uint32_t(-1));
            sparta_assert(pipe_->isValid(index_));
            return getAccess_(std::integral_constant<bool, is_const_iterator>());
        }
 
 
        DataReferenceType operator->()
        {
            return operator*();
        }
 
        PipeIterator & operator++() {
            if(++index_ > pipe_->capacity()) {
                index_ = pipe_->capacity();
            }
            return *this;
        }
 
        PipeIterator operator++(int) {
            PipeIterator it(*this);
            this->operator++();
            return it;
        }
 
        bool operator==(const PipeIterator & it) const {
            return ((pipe_ == it.pipe_) && (index_ == it.index_));
        }
 
        bool operator!=(const PipeIterator & it) const {
            return !operator==(it);
        }
 
        bool isValid() const {
            return pipe_->isValid(index_);
        }
 
    private:
        PipePointerType pipe_;
        uint32_t index_{0};
    };
 
    typedef PipeIterator<false> iterator;
 
    typedef PipeIterator<true> const_iterator;
 
    iterator begin(){ return iterator(this);}
 
    iterator end()  { return iterator(this, num_entries_);}
 
    const_iterator begin() const { return const_iterator(this);}
 
    const_iterator end()   const { return const_iterator(this, num_entries_);}
 
    Pipe (const Pipe <DataT> &) = delete;
 
    Pipe & operator= (const Pipe <DataT> &) = delete;
 
    Pipe (const std::string & name,
          uint32_t num_entries,
          const Clock * clk) :
        name_(name),
        ev_update_(&es_, name+"_pipe_update_event",
                   CREATE_SPARTA_HANDLER(Pipe, internalUpdate_), 1)
    {
        initPipe_(num_entries);
        ev_update_.setScheduleableClock(clk);
        ev_update_.setScheduler(clk->getScheduler());
        ev_update_.setContinuing(false);
    }
 
    void resize(uint32_t new_size) {
        sparta_assert(collector_ == nullptr);
        //sparta_assert(!getClock()->isFinalized());
        initPipe_(new_size);
    }
 
    void performOwnUpdates() {
        if(!perform_own_updates_ && isAnyValid()) {
            ev_update_.schedule();
        }
        perform_own_updates_ = true;
    }
 
    size_type capacity () const {
        return num_entries_;
    }
 
    size_type numValid () const {
        return num_valid_;
    }
 
    size_type size() const {
        return numValid();
    }
 
    bool empty() const {
        return numValid() == 0;
    }
 
    void append (const DataT & data)
    {
        appendImpl_(data);
    }
 
    void append (DataT && data)
    {
        return appendImpl_(std::move(data));
    }
 
    bool isAppended() const
    {
        const PipeEntry & pe = pipe_[getPhysicalStage_(-1)];
        return pe.data.isValid();
    }
 
    void push_front (const DataT & data)
    {
        append(data);
    }
 
    void push_front (DataT && data)
    {
        append(std::move(data));
    }
 
    void writePS (uint32_t stage, const DataT & data)
    {
        writePSImpl_(stage, data);
    }
 
    void writePS (uint32_t stage, DataT && data)
    {
        writePSImpl_(stage, std::move(data));
    }
 
    void invalidatePS (uint32_t stage)
    {
        PipeEntry & pe = pipe_[getPhysicalStage_(stage)];
        sparta_assert(pe.data.isValid(), "ERROR: In sparta::Pipe '" << name_
                    << "' invalidatePS at stage " << stage << " is not valid");
        sparta_assert(stage != uint32_t(-1), "Do not refer to stage -1 directly, use flushAppend()");
        if(pe.data.isValid()) {
            --num_valid_;
        }
        pe.data.clearValid();
        if(perform_own_updates_) {
            ev_update_.schedule();
        }
    }
 
    void clear() {
        pipe_.reset (new PipeEntry[physical_size_]);
        num_valid_ = 0;
    }
 
    void invalidateLastPS () {
        invalidatePS(num_entries_ - 1);
    }
 
    void flushPS (uint32_t stage)
    {
        PipeEntry & pe = pipe_[getPhysicalStage_(stage)];
        sparta_assert(stage != uint32_t(-1), "Do not refer to stage -1 directly, use flushAppend()");
        if(pe.data.isValid()) {
            --num_valid_;
        }
        pe.data.clearValid();
    }
 
    void flushAppend()
    {
        PipeEntry & pe = pipe_[getPhysicalStage_(-1)];
        pe.data.clearValid();
    }
 
    void flushAll ()
    {
        for (int32_t i = -1; i < static_cast<int32_t>(num_entries_); ++i) {
            PipeEntry & pe = pipe_[getPhysicalStage_(i)];
            pe.data.clearValid();
        }
        num_valid_ = 0;
    }
 
    void flushIf(const DataT& criteria){
        for(int32_t i = -1; i < static_cast<int32_t>(num_entries_); ++i){
            PipeEntry & pe = pipe_[getPhysicalStage_(i)];
            if(pe.data.isValid()) {
                if(pe.data.getValue() == criteria){
                    if(pe.data.isValid()) {
                        --num_valid_;
                    }
                    pe.data.clearValid();
                }
            }
        }
    }
 
    void flushIf(std::function<bool(const DataT&)> compare){
        for(int32_t i = -1; i < static_cast<int32_t>(num_entries_); ++i){
            PipeEntry & pe = pipe_[getPhysicalStage_(i)];
            if(pe.data.isValid()) {
                if(compare(pe.data.getValue())){
                    if(pe.data.isValid()) {
                        --num_valid_;
                    }
                    pe.data.clearValid();
                }
            }
        }
    }
 
    const std::string & getName() const {
        return name_;
    }
 
    bool isValid (uint32_t stage) const
    {
        const PipeEntry & pe = pipe_[getPhysicalStage_(stage)];
        return pe.data.isValid();
    }
 
    bool isAnyValid () const
    {
        return (num_valid_ > 0) || isValid(uint32_t(-1));
    }
 
    bool isLastValid () const
    {
        const PipeEntry & pe = pipe_[getPhysicalStage_(num_entries_ - 1)];
        return pe.data.isValid();
    }
 
    const DataT & read (uint32_t stage) const
    {
        const PipeEntry & pe = pipe_[getPhysicalStage_(stage)];
        sparta_assert(pe.data.isValid(), "ERROR: In sparta::Pipe '" << name_
                      << "' read at stage " << stage << " is not valid");
        return pe.data.getValue();
    }
 
    DataT & access(uint32_t stage)
    {
        PipeEntry & pe = pipe_[getPhysicalStage_(stage)];
        sparta_assert(pe.data.isValid(), "ERROR: In sparta::Pipe '" << name_
                      << "' read at stage " << stage << " is not valid");
        return pe.data.getValue();
    }
 
    const DataT & readLast() const
    {
        return read(num_entries_ - 1);
    }
 
    const DataT & readAppendedData() const
    {
        const PipeEntry & pe = pipe_[getPhysicalStage_(-1)];
        sparta_assert(pe.data.isValid(), "ERROR: In sparta::Pipe '" << name_
                      << "' reading appended data is not valid");
        return pe.data.getValue();
    }
 
    void update () {
        sparta_assert(perform_own_updates_ == false,
                      "HEY! You said you wanted the pipe to do it's own updates.  Liar.");
        internalUpdate_();
    }
 
    bool shiftAppend()
    {
        PipeEntry & pe_neg1 = pipe_[getPhysicalStage_(-1)];
        if(!pe_neg1.data.isValid()) {
            return false; // nothing to move
        }
        const PipeEntry & pe_zero = pipe_[getPhysicalStage_(0)];
        if(pe_zero.data.isValid()) {
            return false;// can't move
        }
        writePS(0, pe_neg1.data.getValue());
        pe_neg1.data.clearValid();
        return true;
    }
 
    template<sparta::SchedulingPhase phase = SchedulingPhase::Collection>
    void enableCollection(TreeNode * parent) {
        collector_.reset (new collection::IterableCollector<Pipe<DataT>, phase, true>
                          (parent, name_, this, capacity()));
    }
 
    bool isCollected() const {
        return collector_ && collector_->isCollected();
    }
 
private:
 
    size_type num_entries_   = 0; 
    size_type physical_size_ = 0; 
    size_type stage_mask_    = 0; 
    size_type num_valid_     = 0; 
    size_type tail_          = 0; 
 
    std::unique_ptr<PipeEntry[]> pipe_;
 
    const std::string name_;
 
    // Internal use only
 
    // Process appends, invalidates, etc, timed only
    sparta::EventSet es_{nullptr};
    UniqueEvent<SchedulingPhase::Update>   ev_update_;
    bool perform_own_updates_ = false;
 
    void internalUpdate_() {
        // Remove the head object
        PipeEntry & pe_head = pipe_[getPhysicalStage_(num_entries_ - 1)];
        if(pe_head.data.isValid()) {
            --num_valid_;
        }
        pe_head.data.clearValid();
 
        // Shift the pipe
        tail_ = getPhysicalStage_(-1);
 
        // Add the tail object
        const PipeEntry & pe_tail = pipe_[tail_];
        if(pe_tail.data.isValid()) {
            ++num_valid_;
        }
        if((num_valid_ > 0) && perform_own_updates_) {
            ev_update_.schedule();
        }
    }
 
    template<typename U>
    void appendImpl_ (U && data)
    {
        PipeEntry & pe = pipe_[getPhysicalStage_(-1)];
        sparta_assert(pe.data.isValid() == false, "ERROR: sparta::Pipe '" << name_
                    << "' Double append of data before update");
        pe.data = std::forward<U>(data);
        if(perform_own_updates_) {
            ev_update_.schedule();
        }
    }
 
    template<typename U>
    void writePSImpl_ (uint32_t stage, U && data)
    {
        PipeEntry & pe = pipe_[getPhysicalStage_(stage)];
        if(pe.data.isValid()) {
            --num_valid_;
        }
        pe.data = std::forward<U>(data);
        ++num_valid_;
        if(perform_own_updates_) {
            ev_update_.schedule();
        }
    }
 
    // Collectors
    std::unique_ptr<collection::CollectableTreeNode> collector_;
 
};
 
}