storage.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2021 Daniel R. Carvalho
 * Copyright (c) 2003-2005 The Regents of The University of Michigan
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef __BASE_STATS_STORAGE_HH__
#define __BASE_STATS_STORAGE_HH__
 
#include <cassert>
#include <cmath>
 
#include "base/cast.hh"
#include "base/compiler.hh"
#include "base/logging.hh"
#include "base/stats/types.hh"
#include "sim/cur_tick.hh"
 
namespace gem5
{
 
namespace statistics
{
 
struct StorageParams
{
    virtual ~StorageParams() = default;
};
 
class StatStor
{
  private:
    Counter data;
 
  public:
    struct Params : public StorageParams {};
 
    StatStor(const StorageParams* const storage_params)
        : data(Counter())
    { }
 
    void set(Counter val) { data = val; }
 
    void inc(Counter val) { data += val; }
 
    void dec(Counter val) { data -= val; }
 
    Counter value() const { return data; }
 
    Result result() const { return (Result)data; }
 
    void prepare(const StorageParams* const storage_params) { }
 
    void reset(const StorageParams* const storage_params) { data = Counter(); }
 
    bool zero() const { return data == Counter(); }
};
 
class AvgStor
{
  private:
    Counter current;
    Tick lastReset;
    mutable Result total;
    mutable Tick last;
 
  public:
    struct Params : public StorageParams {};
 
    AvgStor(const StorageParams* const storage_params)
        : current(0), lastReset(0), total(0), last(0)
    { }
 
    void
    set(Counter val)
    {
        total += current * (curTick() - last);
        last = curTick();
        current = val;
    }
 
    void inc(Counter val) { set(current + val); }
 
    void dec(Counter val) { set(current - val); }
 
    Counter value() const { return current; }
 
    Result
    result() const
    {
        assert(last == curTick());
        return (Result)(total + current) / (Result)(curTick() - lastReset + 1);
    }
 
    bool zero() const { return total == 0.0; }
 
    void
    prepare(const StorageParams* const storage_params)
    {
        total += current * (curTick() - last);
        last = curTick();
    }
 
    void
    reset(const StorageParams* const storage_params)
    {
        total = 0.0;
        last = curTick();
        lastReset = curTick();
    }
 
};
 
struct DistParams : public StorageParams
{
    const DistType type;
    DistParams(DistType t) : type(t) {}
};
 
class DistStor
{
  private:
    Counter min_track;
    Counter max_track;
    Counter bucket_size;
 
    Counter min_val;
    Counter max_val;
    Counter underflow;
    Counter overflow;
    Counter sum;
    Counter squares;
    Counter samples;
    VCounter cvec;
 
  public:
    struct Params : public DistParams
    {
        Counter min;
        Counter max;
        Counter bucket_size;
        size_type buckets;
 
        Params(Counter _min, Counter _max, Counter _bucket_size)
          : DistParams(Dist), min(_min), max(_max), bucket_size(_bucket_size),
            buckets(0)
        {
            fatal_if(bucket_size <= 0,
                "Bucket size (%f) must be greater than zero", bucket_size);
            warn_if(std::floor((max - min + 1.0) / bucket_size) !=
                std::ceil((max - min + 1.0) / bucket_size),
                "Bucket size (%f) does not divide range [%f:%f] into equal-" \
                "sized buckets. Rounding up.", bucket_size, min + 1.0, max);
 
            buckets = std::ceil((max - min + 1.0) / bucket_size);
        }
    };
 
    DistStor(const StorageParams* const storage_params)
        : cvec(safe_cast<const Params *>(storage_params)->buckets)
    {
        reset(storage_params);
    }
 
    void sample(Counter val, int number);
 
    size_type size() const { return cvec.size(); }
 
    bool
    zero() const
    {
        return samples == Counter();
    }
 
    void
    prepare(const StorageParams* const storage_params, DistData &data)
    {
        const Params *params = safe_cast<const Params *>(storage_params);
 
        assert(params->type == Dist);
        data.type = params->type;
        data.min = params->min;
        data.max = params->max;
        data.bucket_size = params->bucket_size;
 
        data.min_val = (min_val == CounterLimits::max()) ? 0 : min_val;
        data.max_val = (max_val == CounterLimits::min()) ? 0 : max_val;
        data.underflow = underflow;
        data.overflow = overflow;
 
        data.cvec.resize(params->buckets);
        for (off_type i = 0; i < params->buckets; ++i)
            data.cvec[i] = cvec[i];
 
        data.sum = sum;
        data.squares = squares;
        data.samples = samples;
    }
 
    void
    reset(const StorageParams* const storage_params)
    {
        const Params *params = safe_cast<const Params *>(storage_params);
        min_track = params->min;
        max_track = params->max;
        bucket_size = params->bucket_size;
 
        min_val = CounterLimits::max();
        max_val = CounterLimits::min();
        underflow = Counter();
        overflow = Counter();
 
        size_type size = cvec.size();
        for (off_type i = 0; i < size; ++i)
            cvec[i] = Counter();
 
        sum = Counter();
        squares = Counter();
        samples = Counter();
    }
};
 
class HistStor
{
  private:
    Counter min_bucket;
    Counter max_bucket;
    Counter bucket_size;
 
    Counter sum;
    Counter logs;
    Counter squares;
    Counter samples;
    VCounter cvec;
 
    void growUp();
 
    void growOut();
 
    void growDown();
 
  public:
    struct Params : public DistParams
    {
        size_type buckets;
 
        Params(size_type _buckets)
          : DistParams(Hist)
        {
            fatal_if(_buckets < 2,
                "There must be at least two buckets in a histogram");
            buckets = _buckets;
        }
    };
 
    HistStor(const StorageParams* const storage_params)
        : cvec(safe_cast<const Params *>(storage_params)->buckets)
    {
        reset(storage_params);
    }
 
    void add(HistStor *other);
 
    void sample(Counter val, int number);
 
    size_type size() const { return cvec.size(); }
 
    bool
    zero() const
    {
        return samples == Counter();
    }
 
    void
    prepare(const StorageParams* const storage_params, DistData &data)
    {
        const Params *params = safe_cast<const Params *>(storage_params);
 
        assert(params->type == Hist);
        data.type = params->type;
        data.min = min_bucket;
        data.max = max_bucket + bucket_size - 1;
        data.bucket_size = bucket_size;
 
        data.min_val = min_bucket;
        data.max_val = max_bucket;
 
        int buckets = params->buckets;
        data.cvec.resize(buckets);
        for (off_type i = 0; i < buckets; ++i)
            data.cvec[i] = cvec[i];
 
        data.sum = sum;
        data.logs = logs;
        data.squares = squares;
        data.samples = samples;
    }
 
    void
    reset(const StorageParams* const storage_params)
    {
        const Params *params = safe_cast<const Params *>(storage_params);
        min_bucket = 0;
        max_bucket = params->buckets - 1;
        bucket_size = 1;
 
        size_type size = cvec.size();
        for (off_type i = 0; i < size; ++i)
            cvec[i] = Counter();
 
        sum = Counter();
        squares = Counter();
        samples = Counter();
        logs = Counter();
    }
};
 
class SampleStor
{
  private:
    Counter sum;
    Counter squares;
    Counter samples;
 
  public:
    struct Params : public DistParams
    {
        Params() : DistParams(Deviation) {}
    };
 
    SampleStor(const StorageParams* const storage_params)
        : sum(Counter()), squares(Counter()), samples(Counter())
    { }
 
    void
    sample(Counter val, int number)
    {
        sum += val * number;
        squares += val * val * number;
        samples += number;
    }
 
    size_type size() const { return 1; }
 
    bool zero() const { return samples == Counter(); }
 
    void
    prepare(const StorageParams* const storage_params, DistData &data)
    {
        const Params *params = safe_cast<const Params *>(storage_params);
 
        assert(params->type == Deviation);
        data.type = params->type;
        data.sum = sum;
        data.squares = squares;
        data.samples = samples;
    }
 
    void
    reset(const StorageParams* const storage_params)
    {
        sum = Counter();
        squares = Counter();
        samples = Counter();
    }
};
 
class AvgSampleStor
{
  private:
    Counter sum;
    Counter squares;
 
  public:
    struct Params : public DistParams
    {
        Params() : DistParams(Deviation) {}
    };
 
    AvgSampleStor(const StorageParams* const storage_params)
        : sum(Counter()), squares(Counter())
    {}
 
    void
    sample(Counter val, int number)
    {
        sum += val * number;
        squares += val * val * number;
    }
 
    size_type size() const { return 1; }
 
    bool zero() const { return sum == Counter(); }
 
    void
    prepare(const StorageParams* const storage_params, DistData &data)
    {
        const Params *params = safe_cast<const Params *>(storage_params);
 
        assert(params->type == Deviation);
        data.type = params->type;
        data.sum = sum;
        data.squares = squares;
        data.samples = curTick();
    }
 
    void
    reset(const StorageParams* const storage_params)
    {
        sum = Counter();
        squares = Counter();
    }
};
 
class SparseHistStor
{
  private:
    Counter samples;
    MCounter cmap;
 
  public:
    struct Params : public DistParams
    {
        Params() : DistParams(Hist) {}
    };
 
    SparseHistStor(const StorageParams* const storage_params)
    {
        reset(storage_params);
    }
 
    void
    sample(Counter val, int number)
    {
        cmap[val] += number;
        samples += number;
    }
 
    size_type size() const { return cmap.size(); }
 
    bool
    zero() const
    {
        return samples == Counter();
    }
 
    void
    prepare(const StorageParams* const storage_params, SparseHistData &data)
    {
        MCounter::iterator it;
        data.cmap.clear();
        for (it = cmap.begin(); it != cmap.end(); it++) {
            data.cmap[(*it).first] = (*it).second;
        }
 
        data.samples = samples;
    }
 
    void
    reset(const StorageParams* const storage_params)
    {
        cmap.clear();
        samples = 0;
    }
};
 
} // namespace statistics
} // namespace gem5
 
#endif // __BASE_STATS_STORAGE_HH__