SIValuesBuffer.hpp

// <SIValuesBuffer> -*- C++ -*-
 
#pragma once
 
#include "sparta/statistics/StatisticInstance.hpp"
#include "simdb/schema/Schema.hpp"
#include "sparta/report/db/Schema.hpp"
 
namespace sparta {
namespace statistics {
 
inline void refillWithNaNs(std::vector<double> & vec)
{
    vec = std::vector<double>(vec.size(), NAN);
}
 
class SIValuesBuffer
{
public:
    SIValuesBuffer(const std::vector<const StatisticInstance*> & stats,
                   const Clock & root_clk) :
        stats_(stats),
        scheduler_(*root_clk.getScheduler()),
        root_clk_(root_clk)
    {
        //We are going to be asking the SI's for their values
        //ourselves. Don't take the performance hit of having
        //them writing their values into SnapshotLogger's that
        //nobody is listening to.
        for (const auto si : stats_) {
            si->disableSnapshotLogging();
        }
    }
 
    void useRowMajorOrdering() {
        if (!buffersAreEmpty()) {
            throw SpartaException(
                "Cannot change row/column-major ordering when "
                "SIValuesBuffer contains buffered data");
        }
        is_row_major_ = true;
    }
 
    void useColumnMajorOrdering() {
        if (!buffersAreEmpty()) {
            throw SpartaException(
                "Cannot change row/column-major ordering when "
                "SIValuesBuffer contains buffered data");
        }
        is_row_major_ = false;
    }
 
    db::MajorOrdering getMajorOrdering() const {
        return is_row_major_ ?
            db::MajorOrdering::ROW_MAJOR :
            db::MajorOrdering::COLUMN_MAJOR;
    }
 
    void initializeNumSIBuffers(const size_t num_si_buffers) {
        si_values_buffer_.resize(num_si_buffers * stats_.size());
        max_num_si_buffers_ = num_si_buffers;
    }
 
    void updateNumSIBuffers(const size_t num_si_buffers) {
        sparta_assert(num_si_buffers > 0, "You cannot have an "
                    "SIValuesBuffer with zero SI capacity");
        updated_num_si_buffers_ = num_si_buffers;
    }
 
    bool buffersAreFilled() const {
        return (current_buffer_write_idx_ == max_num_si_buffers_);
    }
 
    bool buffersAreEmpty() const {
        return (current_buffer_write_idx_ == 0);
    }
 
    size_t getNumBufferedSIBlocks() const {
        return current_buffer_write_idx_;
    }
 
    void resetSIBuffers(const bool fill_with_nans = true) {
        current_buffer_write_idx_ = 0;
        if (updated_num_si_buffers_.isValid()) {
            initializeNumSIBuffers(updated_num_si_buffers_);
            updated_num_si_buffers_.clearValid();
        }
 
        if (fill_with_nans) {
            refillWithNaNs(si_values_buffer_);
        }
 
        si_buffer_beginning_picoseconds_.clearValid();
        si_buffer_ending_picoseconds_.clearValid();
        si_buffer_beginning_clock_cycles_.clearValid();
        si_buffer_ending_clock_cycles_.clearValid();
    }
 
    void bufferCurrentSIValues() {
        //Ensure that we have the space in our buffer to append the
        //current SI values
        sparta_assert(current_buffer_write_idx_ < max_num_si_buffers_);
 
        //Capture the current simulated picoseconds & root clock cycle
        //if this is the first write into a fresh buffer
        if (buffersAreEmpty()) {
            si_buffer_beginning_picoseconds_ = scheduler_.getSimulatedPicoSeconds();
            si_buffer_beginning_clock_cycles_ = root_clk_.currentCycle();
        }
 
        //For row-major ordering, we start the write index at the Nth SI
        //position, where N equals the current buffer index. For column-
        //major ordering, we start the write index at the 0th position
        //of the Mth buffer, where M equals the current buffer index.
        size_t buffer_idx =
            is_row_major_ ?
            current_buffer_write_idx_ * stats_.size() :
            current_buffer_write_idx_;
        for (const auto si : stats_) {
            si_values_buffer_[buffer_idx] = si->getValue();
            //Row-major ordering jumps the write index ahead by 1.
            //Column-major ordering jumps this index to the next
            //available buffer.
            buffer_idx += is_row_major_ ? 1 : max_num_si_buffers_;
        }
        ++current_buffer_write_idx_;
 
        //Capture the ending simulated picoseconds & root clock cycle
        //in this buffer
        si_buffer_ending_picoseconds_ = scheduler_.getSimulatedPicoSeconds();
        si_buffer_ending_clock_cycles_ = root_clk_.currentCycle();
    }
 
    const std::vector<double> & getBufferedSIValues() {
        if (buffersAreFilled()) {
            return si_values_buffer_;
        }
 
        if (buffersAreEmpty()) {
            refillWithNaNs(si_values_buffer_);
            return si_values_buffer_;
        }
 
        const size_t num_filled_buffers = current_buffer_write_idx_;
        squeezed_si_values_.resize(num_filled_buffers * stats_.size());
        auto read_iter = si_values_buffer_.begin();
 
        //When using row-major ordering, simply copy the SI values
        //buffer as-is into the squeezed SI values vector.
        if (is_row_major_) {
            memcpy(&squeezed_si_values_[0],
                   &si_values_buffer_[0],
                   squeezed_si_values_.size() * sizeof(double));
        } else {
            //Column-major ordering is a little bit different.
            //For each "block" of buffers, whether filled or unfilled...
            for (size_t si_idx = 0; si_idx < stats_.size(); ++si_idx) {
                //...copy over the SI values from the filled buffer slots...
                std::copy(read_iter,
                          read_iter + num_filled_buffers,
                          squeezed_si_values_.begin() + (si_idx * num_filled_buffers));
 
                //...and jump over the unfilled buffer slots to the start
                //of the next filled buffer.
                std::advance(read_iter, max_num_si_buffers_);
            }
        }
 
        return squeezed_si_values_;
    }
 
    void getBeginningAndEndingTimestampsForBufferedSIs(
        uint64_t & starting_picoseconds,
        uint64_t & ending_picoseconds,
        uint64_t & starting_cycles,
        uint64_t & ending_cycles) const
    {
        starting_picoseconds = si_buffer_beginning_picoseconds_;
        ending_picoseconds = si_buffer_ending_picoseconds_;
        starting_cycles = si_buffer_beginning_clock_cycles_;
        ending_cycles = si_buffer_ending_clock_cycles_;
    }
 
private:
    const std::vector<const StatisticInstance*> stats_;
    std::vector<double> si_values_buffer_;
    std::vector<double> squeezed_si_values_;
    size_t current_buffer_write_idx_ = 0;
    size_t max_num_si_buffers_ = 0;
    utils::ValidValue<size_t> updated_num_si_buffers_;
    bool is_row_major_ = true;
 
    utils::ValidValue<uint64_t> si_buffer_beginning_picoseconds_;
    utils::ValidValue<uint64_t> si_buffer_ending_picoseconds_;
    utils::ValidValue<uint64_t> si_buffer_beginning_clock_cycles_;
    utils::ValidValue<uint64_t> si_buffer_ending_clock_cycles_;
 
    const Scheduler & scheduler_;
    const Clock & root_clk_;
 
};
 
} // namespace statistics
} // namespace sparta