source: src/Common/Stats/Counter.h@ a1099278

//
// Cforall Version 1.0.0 Copyright (C) 2019 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// Heap.h --
//
// Author           : Thierry Delisle
// Created On       : Thu Feb 28 12::05:10 2019
// Last Modified By :
// Last Modified On :
// Update Count     :
//

#pragma once

#include <cstdint>
#include <iostream>

namespace Stats {
        namespace Counters {
                void print();

                class BaseCounter {
                public:
                        BaseCounter(const char * const name) : name(name) {
                                top.append(this);
                        }

                        BaseCounter(const char * const name, BaseCounter * parent) : name(name) {
                                parent->children.append(this);
                        }
                protected:
                        virtual ~BaseCounter() = default;

                        struct list_t {
                                BaseCounter * head = nullptr;
                                BaseCounter * tail = nullptr;

                                void append(BaseCounter * node) {
                                        if(!head) { head = node; }
                                        else      { tail->next = node;}
                                        tail = node;
                                }
                        };

                private:
                        virtual void print(std::ostream &) = 0;
                        template<typename T>
                        friend void ForAllCounters(BaseCounter::list_t &, size_t, T );
                        friend void print();

                private:
                        const char * const name;

                        BaseCounter * next = nullptr;
                        list_t children;

                        static list_t top;
                };

                class CounterGroup : public BaseCounter {
                public:
                        CounterGroup(const char * const name ) : BaseCounter(name) {}
                        CounterGroup(const char * const name, BaseCounter * parent) : BaseCounter(name, parent) {}

                protected:
                        virtual ~CounterGroup() = default;

                private:
                        virtual void print(std::ostream & os) {
                                os << "";
                        }
                        template<typename T>
                        friend void ForAllCounters(BaseCounter::list_t &, size_t, T );
                        friend void print();
                };

                class SimpleCounter : public BaseCounter {
                public:
                        SimpleCounter(const char * const name ) : BaseCounter(name) {}
                        SimpleCounter(const char * const name, BaseCounter * parent) : BaseCounter(name, parent) {}

                        inline void operator++(int)          { count++;        }
                        inline void operator+=(size_t value) { count += value; }
                protected:
                        virtual ~SimpleCounter() = default;

                private:
                        virtual void print(std::ostream & os) {
                                os << count;
                        }
                        template<typename T>
                        friend void ForAllCounters(BaseCounter::list_t &, size_t, T );
                        friend void print();

                        size_t count = 0;

                };

                template<typename T>
                class AverageCounter : public BaseCounter {
                public:
                        AverageCounter(const char * const name ) : BaseCounter(name), sum{} {}
                        AverageCounter(const char * const name, BaseCounter * parent) : BaseCounter(name, parent), sum{} {}

                        inline void push(T value) {
                                sum += value;
                                count++;
                        }

                protected:
                        virtual ~AverageCounter() = default;

                private:
                        virtual void print(std::ostream & os) {
                                os << sum / count;
                        }
                        template<typename F>
                        friend void ForAllCounters(BaseCounter::list_t &, size_t, F );
                        friend void print();

                        T sum;
                        size_t count = 1;
                };
        }
}