Changeset 8e70823


Ignore:
Timestamp:
Mar 1, 2019, 2:10:34 PM (3 years ago)
Author:
tdelisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, persistent-indexer
Children:
675716e
Parents:
79de2210
Message:

Extracted out BaseCounter? as a generic key-value tree

Location:
src/Common/Stats
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • src/Common/Stats/Counter.cc

    r79de2210 r8e70823  
    1818#include <algorithm>
    1919#include <cstring>
     20#include <functional>
    2021#include <iomanip>
    2122
    2223namespace Stats {
    2324        namespace Counters {
    24 
    25                 template<typename T>
    26                 void ForAllCounters(BaseCounter::list_t & range, size_t level, T func) {
    27                         auto it = range.head;
    28                         while(it) {
    29                                 auto next = it->next;
    30                                 func(it, level);
    31                                 ForAllCounters(it->children, level + 1, func);
    32                                 it = next;
    33                         }
    34                 }
    35 
    3625                void print() {
    37                         if(!BaseCounter::top.head) return;
     26                        if(!top.head) return;
    3827                        size_t nc = 0;
    39                         ForAllCounters(BaseCounter::top, 0, [&](BaseCounter * node, size_t level) {
    40                                 nc = std::max(nc, (4 * level) + std::strlen(node->name));
     28                        Base::ForAll(top, 0, [&](Base::TreeImpl * node, size_t level) {
     29                                nc = std::max(nc, (4 * level) + node->name.size());
    4130                        });
    4231
    43                         const char * const title = "Counter Statistic";
     32                        const std::string & title = "Counter Statistic";
    4433                        size_t nct = nc + 14;
    4534                        std::cerr << std::string(nct, '=') << std::endl;
    46                         std::cerr << std::string((nct - std::strlen(title)) / 2, ' ');
     35                        std::cerr << std::string((nct - title.size()) / 2, ' ');
    4736                        std::cerr << title << std::endl;
    4837                        std::cerr << std::string(nct, '-') << std::endl;
    4938
    5039
    51                         ForAllCounters(BaseCounter::top, 0, [&](BaseCounter * node, size_t level) {
     40                        Base::ForAll(top, 0, [&](Base::TreeImpl * node, size_t level) {
    5241                                std::cerr << std::string(level * 4, ' ');
    5342                                std::cerr << node->name;
    54                                 std::cerr << std::string(nc - ((level * 4) + std::strlen(node->name)), ' ');
     43                                std::cerr << std::string(nc - ((level * 4) + node->name.size()), ' ');
    5544                                std::cerr << " | ";
    5645                                std::cerr << std::setw(9);
     
    5847                                std::cerr << " |";
    5948                                std::cerr << '\n';
    60                                 delete node;
    61                         });
     49                        }, true);
    6250
    6351                        std::cerr << std::string(nct, '-') << std::endl;
    6452                }
    6553
    66                 BaseCounter::list_t BaseCounter::top;
     54                Base::TreeImpl::Top top;
    6755        }
    6856}
  • src/Common/Stats/Counter.h

    r79de2210 r8e70823  
    1818#include <cstdint>
    1919#include <iostream>
     20#include <string>
     21
     22#include "Common/Stats/Base.h"
    2023
    2124namespace Stats {
     
    2326                void print();
    2427
    25                 class BaseCounter {
     28                extern Base::TreeImpl::Top top;
     29
     30                class CounterGroup : public Base::Tree<top> {
    2631                public:
    27                         BaseCounter(const char * const name) : name(name) {
    28                                 top.append(this);
    29                         }
     32                        CounterGroup(const std::string & name ) : Base::Tree<top>(name) {}
     33                        CounterGroup(const std::string & name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent) {}
    3034
    31                         BaseCounter(const char * const name, BaseCounter * parent) : name(name) {
    32                                 parent->children.append(this);
    33                         }
     35                        virtual void print(std::ostream & os) override { os << ""; }
    3436                protected:
    35                         virtual ~BaseCounter() = default;
    36 
    37                         struct list_t {
    38                                 BaseCounter * head = nullptr;
    39                                 BaseCounter * tail = nullptr;
    40 
    41                                 void append(BaseCounter * node) {
    42                                         if(!head) { head = node; }
    43                                         else      { tail->next = node;}
    44                                         tail = node;
    45                                 }
    46                         };
    47 
    48                 private:
    49                         virtual void print(std::ostream &) = 0;
    50                         template<typename T>
    51                         friend void ForAllCounters(BaseCounter::list_t &, size_t, T );
    52                         friend void print();
    53 
    54                 private:
    55                         const char * const name;
    56 
    57                         BaseCounter * next = nullptr;
    58                         list_t children;
    59 
    60                         static list_t top;
     37                        virtual ~CounterGroup() = default;
    6138                };
    6239
    63                 class CounterGroup : public BaseCounter {
     40                class SimpleCounter : public Base::Tree<top> {
    6441                public:
    65                         CounterGroup(const char * const name ) : BaseCounter(name) {}
    66                         CounterGroup(const char * const name, BaseCounter * parent) : BaseCounter(name, parent) {}
     42                        SimpleCounter(const std::string & name ) : Base::Tree<top>(name) {}
     43                        SimpleCounter(const std::string & name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent) {}
    6744
    68                 protected:
    69                         virtual ~CounterGroup() = default;
    70 
    71                 private:
    72                         virtual void print(std::ostream & os) {
    73                                 os << "";
    74                         }
    75                         template<typename T>
    76                         friend void ForAllCounters(BaseCounter::list_t &, size_t, T );
    77                         friend void print();
    78                 };
    79 
    80                 class SimpleCounter : public BaseCounter {
    81                 public:
    82                         SimpleCounter(const char * const name ) : BaseCounter(name) {}
    83                         SimpleCounter(const char * const name, BaseCounter * parent) : BaseCounter(name, parent) {}
     45                        virtual void print(std::ostream & os) override { os << count; }
    8446
    8547                        inline void operator++(int)          { count++;        }
     
    8951
    9052                private:
    91                         virtual void print(std::ostream & os) {
    92                                 os << count;
    93                         }
    94                         template<typename T>
    95                         friend void ForAllCounters(BaseCounter::list_t &, size_t, T );
    96                         friend void print();
    97 
    9853                        size_t count = 0;
    99 
    10054                };
    10155
    10256                template<typename T>
    103                 class AverageCounter : public BaseCounter {
     57                class AverageCounter : public Base::Tree<top> {
    10458                public:
    105                         AverageCounter(const char * const name ) : BaseCounter(name), sum{} {}
    106                         AverageCounter(const char * const name, BaseCounter * parent) : BaseCounter(name, parent), sum{} {}
     59                        AverageCounter(const std::string & name ) : Base::Tree<top>(name), sum{} {}
     60                        AverageCounter(const std::string & name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent), sum{} {}
     61
     62                        virtual void print(std::ostream & os) { os << sum / count; }
    10763
    10864                        inline void push(T value) {
     
    11571
    11672                private:
    117                         virtual void print(std::ostream & os) {
    118                                 os << sum / count;
    119                         }
    120                         template<typename F>
    121                         friend void ForAllCounters(BaseCounter::list_t &, size_t, F );
    122                         friend void print();
    123 
    12473                        T sum;
    12574                        size_t count = 1;
     
    12776
    12877                template<typename T>
    129                 class MaxCounter : public BaseCounter {
     78                class MaxCounter : public Base::Tree<top> {
    13079                public:
    131                         MaxCounter(const char * const name ) : BaseCounter(name), max{} {}
    132                         MaxCounter(const char * const name, BaseCounter * parent) : BaseCounter(name, parent), max{} {}
     80                        MaxCounter(const std::string & name ) : Base::Tree<top>(name), max{} {}
     81                        MaxCounter(const std::string & name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent), max{} {}
    13382
    134                         inline void push(T value) {
    135                                 max = std::max(max, value);
    136                         }
     83                        virtual void print(std::ostream & os) { os << max; }
    13784
     85                        inline void push(T value) { max = std::max(max, value); }
    13886                protected:
    13987                        virtual ~MaxCounter() = default;
    14088
    14189                private:
    142                         virtual void print(std::ostream & os) {
    143                                 os << max;
    144                         }
    145                         template<typename F>
    146                         friend void ForAllCounters(BaseCounter::list_t &, size_t, F );
    147                         friend void print();
    148 
    14990                        T max;
    15091                };
Note: See TracChangeset for help on using the changeset viewer.