BasicHistogram.hpp

Go to the documentation of this file.

// <BasicHistogram.h> -*- C++ -*-
 
#pragma once
 
#include <string>
#include <vector>
#include <sstream>
#include "sparta/statistics/Counter.hpp"
 
namespace sparta
{
template<typename BucketT, bool ASSERT_ON_UNDERFLOW=false>
class BasicHistogram
{
public:
    BasicHistogram(sparta::StatisticSet &sset,
                   const std::string &name,
                   const std::string &desc,
                   const std::vector<BucketT> &buckets) :
        bucket_vals_(buckets)
    {
        sparta_assert(std::is_sorted(buckets.begin(), buckets.end()), "Buckets must be sorted");
 
        const auto bucket_size = bucket_vals_.size();
        ctrs_.reserve(bucket_size);
 
        // create one counter per bucket
        for (unsigned i = 0; i < bucket_size; ++i)
        {
            auto &v = bucket_vals_[i];
            std::ostringstream os_name;
            if (v < 0)
            {
                os_name << name << "_n" << -v; // negative
            }
            else
            {
                os_name << name << '_' << v;
            }
 
            std::ostringstream os_desc;
            if (i == 0)
            {
                os_desc << desc << " with values less than or equal to " << v;
            }
            else
            {
                os_desc << desc << " with values greater than " << bucket_vals_[i-1] << " and less than or equal to " << v;
            }
 
            ctrs_.emplace_back(&sset, os_name.str(), os_desc.str(), sparta::Counter::COUNT_NORMAL);
        }
    }
 
    ~BasicHistogram() {}
 
    void addValue(const BucketT &val)
    {
        // upper_bound will yield the bucket beyond the one we want
        auto bucket = std::upper_bound(bucket_vals_.begin(), bucket_vals_.end(), val);
 
        // check for underflow (value below first bucket)
        if (bucket == bucket_vals_.begin())
        {
            sparta_assert(!ASSERT_ON_UNDERFLOW, "Value below first bucket");
            ++ctrs_[0]; // put underflow in first bucket
            return;
        }
        //else calculate offset into counter array
        auto off = bucket - bucket_vals_.begin() - 1;
        ++ctrs_[off];
    }
 
    BasicHistogram(const BasicHistogram &) = delete;
    BasicHistogram(      BasicHistogram &&) = delete;
    const BasicHistogram & operator=(const BasicHistogram &) = delete;
    BasicHistogram       & operator=(      BasicHistogram &&) = delete;
 
private: // data
    std::vector<BucketT> bucket_vals_; 
    std::vector<sparta::Counter> ctrs_; 
};
} // namespace sparta