Changeset 1cb7fab2 for src/Common/Stats


Ignore:
Timestamp:
Mar 4, 2019, 2:53:55 PM (6 years ago)
Author:
tdelisle <tdelisle@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, persistent-indexer, pthread-emulation, qualifiedEnum
Children:
874ffa4
Parents:
675716e
Message:

Added better support for enabling/disabling/compiling-out statistics

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

Legend:

Unmodified
Added
Removed

  • src/Common/Stats/Base.h

    r675716e r1cb7fab2  
    1616#pragma once
    1717
    18 #include <string>
    19 
    2018namespace Stats {
    2119        namespace Base {
     20                class TreeImpl;
     21
     22                struct TreeTop {
     23                        TreeImpl * head = nullptr;
     24                        TreeImpl * tail = nullptr;
     25
     26                        inline void append(TreeImpl * node);
     27                };
     28
     29                template<typename func_t>
     30                void ForAll(TreeTop & range, size_t level, func_t func, bool destroy = false);
     31
    2232                class TreeImpl {
    2333                public:
    24                         struct Top {
    25                                 TreeImpl * head = nullptr;
    26                                 TreeImpl * tail = nullptr;
    27 
    28                                 void append(TreeImpl * node) {
    29                                         if(!head) { head = node; }
    30                                         else      { tail->next = node;}
    31                                         tail = node;
    32                                 }
    33                         };
    34 
    3534                        virtual void print(std::ostream &) = 0;
    3635
    37                         const std::string name;
    38                         TreeImpl(const std::string & name) : name(name) {}
     36                        const char * const name;
     37                        TreeImpl(const char * const name) : name(name) {}
    3938
    4039                protected:
    … …  
    4241
    4342                        TreeImpl * next = nullptr;
    44                         Top children;
     43                        TreeTop children;
     44
     45                        friend struct TreeTop;
    4546
    4647                        template<typename func_t>
    47                         friend void ForAll(TreeImpl::Top & range, size_t level, func_t func, bool destroy = false);
     48                        friend void ForAll(TreeTop & range, size_t level, func_t func, bool destroy);
    4849                };
    4950
     51                void TreeTop::append(TreeImpl * node) {
     52                        if(!head) { head = node; }
     53                        else      { tail->next = node;}
     54                        tail = node;
     55                }
     56
    5057                template<typename func_t>
    51                 inline void ForAll(TreeImpl::Top & range, size_t level, func_t func, bool destroy) {
     58                inline void ForAll(TreeTop & range, size_t level, func_t func, bool destroy) {
    5259                        auto it = range.head;
    5360                        while(it) {
    … …  
    6067                }
    6168
    62                 template<TreeImpl::Top & top>
     69                template<TreeTop & top>
    6370                class Tree : public TreeImpl {
    6471                public:
    65                         Tree(const std::string & name) : TreeImpl{name} {
     72                        Tree(const char * const name) : TreeImpl{name} {
    6673                                top.append(this);
    6774                        }
    6875
    69                         Tree(const std::string & name, Tree * parent) : TreeImpl{name} {
     76                        Tree(const char * const name, Tree * parent) : TreeImpl{name} {
    7077                                parent->children.append(this);
    7178                        }

  • src/Common/Stats/Counter.cc

    r675716e r1cb7fab2  
    2727                        size_t nc = 0;
    2828                        Base::ForAll(top, 0, [&](Base::TreeImpl * node, size_t level) {
    29                                 nc = std::max(nc, (4 * level) + node->name.size());
     29                                nc = std::max(nc, (4 * level) + std::strlen(node->name));
    3030                        });
    3131
    32                         const std::string & title = "Counter Statistic";
     32                        const char * const title = "Counter Statistic";
    3333                        size_t nct = nc + 14;
    3434                        std::cerr << std::string(nct, '=') << std::endl;
    35                         std::cerr << std::string((nct - title.size()) / 2, ' ');
     35                        std::cerr << std::string((nct - std::strlen(title)) / 2, ' ');
    3636                        std::cerr << title << std::endl;
    3737                        std::cerr << std::string(nct, '-') << std::endl;
    … …  
    4141                                std::cerr << std::string(level * 4, ' ');
    4242                                std::cerr << node->name;
    43                                 std::cerr << std::string(nc - ((level * 4) + node->name.size()), ' ');
     43                                std::cerr << std::string(nc - ((level * 4) + std::strlen(node->name)), ' ');
    4444                                std::cerr << " | ";
    4545                                std::cerr << std::setw(9);
    … …  
    5252                }
    5353
    54                 Base::TreeImpl::Top top;
     54                Base::TreeTop top;
     55
     56                extern bool enabled;
    5557        }
    5658}

  • src/Common/Stats/Counter.h

    r675716e r1cb7fab2  
    1818#include <cstdint>
    1919#include <iostream>
    20 #include <string>
    2120
    2221#include "Common/Stats/Base.h"
    2322
     23#if defined( NO_STATISTICS )
     24        #define NO_COUNTER_STATISTICS
     25#endif
     26
    2427namespace Stats {
    2528        namespace Counters {
    26                 void print();
     29#               if defined(NO_COUNTERS_STATISTICS)
    2730
    28                 extern Base::TreeImpl::Top top;
     31                        static inline void print() {}
    2932
    30                 class CounterGroup : public Base::Tree<top> {
    31                 public:
    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) {}
     33                        class CounterGroup {
     34                        public:
     35                        };
    3436
    35                         virtual void print(std::ostream & os) override { os << ""; }
    36                 protected:
    37                         virtual ~CounterGroup() = default;
    38                 };
     37                        class SimpleCounter {
     38                        public:
     39                                inline void operator++(int) {}
     40                                inline void operator+=(size_t) {}
     41                        };
    3942
    40                 class SimpleCounter : public Base::Tree<top> {
    41                 public:
    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) {}
     43                        template<typename T>
     44                        class AverageCounter {
     45                        public:
     46                                inline void push(T value) {}
     47                        };
    4448
    45                         virtual void print(std::ostream & os) override { os << count; }
     49                        template<typename T>
     50                        class MaxCounter {
     51                        public:
     52                                inline void push(T value) {}
     53                        };
    4654
    47                         inline void operator++(int)          { count++;        }
    48                         inline void operator+=(size_t value) { count += value; }
    49                 protected:
    50                         virtual ~SimpleCounter() = default;
    51 
    52                 private:
    53                         size_t count = 0;
    54                 };
    55 
    56                 template<typename T>
    57                 class AverageCounter : public Base::Tree<top> {
    58                 public:
    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; }
    63 
    64                         inline void push(T value) {
    65                                 sum += value;
    66                                 count++;
     55                        template<typename counter_t>
     56                        counter_t * build(const char * const name) {
     57                                return nullptr;
    6758                        }
    6859
    69                 protected:
    70                         virtual ~AverageCounter() = default;
     60                        template<typename counter_t>
     61                        counter_t * build(const char * const name, Base::Tree<top> * parent) {
     62                                        return nullptr;
     63                        }
     64#               else
     65                        extern bool enabled;
    7166
    72                 private:
    73                         T sum;
    74                         size_t count = 1;
    75                 };
     67                        extern Base::TreeTop top;
    7668
    77                 template<typename T>
    78                 class MaxCounter : public Base::Tree<top> {
    79                 public:
    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{} {}
     69                        class CounterGroup : public Base::Tree<top> {
     70                        public:
     71                                CounterGroup(const char * const name ) : Base::Tree<top>(name) {}
     72                                CounterGroup(const char * const name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent) {}
    8273
    83                         virtual void print(std::ostream & os) { os << max; }
     74                                virtual void print(std::ostream & os) override { os << ""; }
     75                        protected:
     76                                virtual ~CounterGroup() = default;
     77                        };
    8478
    85                         inline void push(T value) { max = std::max(max, value); }
    86                 protected:
    87                         virtual ~MaxCounter() = default;
     79                        class SimpleCounter : public Base::Tree<top> {
     80                        public:
     81                                SimpleCounter(const char * const name ) : Base::Tree<top>(name) {}
     82                                SimpleCounter(const char * const name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent) {}
    8883
    89                 private:
    90                         T max;
    91                 };
     84                                virtual void print(std::ostream & os) override { os << count; }
     85
     86                                inline void operator++(int)          { if(!enabled) return; count++;        }
     87                                inline void operator+=(size_t value) { if(!enabled) return; count += value; }
     88
     89                        protected:
     90                                virtual ~SimpleCounter() = default;
     91
     92                        private:
     93                                size_t count = 0;
     94                        };
     95
     96                        template<typename T>
     97                        class AverageCounter : public Base::Tree<top> {
     98                        public:
     99                                AverageCounter(const char * const name ) : Base::Tree<top>(name), sum{} {}
     100                                AverageCounter(const char * const name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent), sum{} {}
     101
     102                                virtual void print(std::ostream & os) { os << sum / count; }
     103
     104                                inline void push(T value) { if(!enabled) return; sum += value; count++; }
     105
     106                        protected:
     107                                virtual ~AverageCounter() = default;
     108
     109                        private:
     110                                T sum;
     111                                size_t count = 1;
     112                        };
     113
     114                        template<typename T>
     115                        class MaxCounter : public Base::Tree<top> {
     116                        public:
     117                                MaxCounter(const char * const name ) : Base::Tree<top>(name), max{} {}
     118                                MaxCounter(const char * const name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent), max{} {}
     119
     120                                virtual void print(std::ostream & os) { os << max; }
     121
     122                                inline void push(T value) { if(!enabled) return; max = std::max(max, value); }
     123
     124                        protected:
     125                                virtual ~MaxCounter() = default;
     126
     127                        private:
     128                                T max;
     129                        };
     130
     131                        template<typename counter_t>
     132                        counter_t * build(const char * const name) {
     133                                if(!enabled) return nullptr;
     134                                return new counter_t(name);
     135                        }
     136
     137                        template<typename counter_t>
     138                        counter_t * build(const char * const name, Base::Tree<top> * parent) {
     139                                if(!enabled) return nullptr;
     140                                return new counter_t(name, parent);
     141                        }
     142#               endif
    92143        }
    93144}

  • src/Common/Stats/Heap.cc

    r675716e r1cb7fab2  
    2121#include <iostream>
    2222
     23#if defined( NO_STATISTICS )
     24        #define NO_HEAP_STATISTICS
     25#endif
     26
    2327namespace Stats {
    2428        namespace Heap {
    … …  
    2832                void print() {}
    2933#else
     34                extern bool enabled;
     35
    3036                struct StatBlock {
    3137                        const char * name  = nullptr;   ///< Name of this pass
    … …  
    7783
    7884                void print() {
     85                        if(!enabled) return;
     86
    7987                        size_t nc = 0;
    8088                        size_t total_mallocs = 0;
    … …  
    166174                        void * malloc( size_t size ) {
    167175                                static auto __malloc = reinterpret_cast<void * (*)(size_t)>(interpose_symbol( "malloc", nullptr ));
    168                                 if( passes_cnt > 0 ) {
     176                                if( enabled && passes_cnt > 0 ) {
    169177                                        passes[passes_cnt - 1].mallocs++;
    170178                                        passes[passes_cnt - 1].n_allocs++;
    … …  
    177185                        void free( void * ptr ) {
    178186                                static auto __free = reinterpret_cast<void   (*)(void *)>(interpose_symbol( "free", nullptr ));
    179                                 if( passes_cnt > 0 ) {
     187                                if( enabled && passes_cnt > 0 ) {
    180188                                        passes[passes_cnt - 1].frees++;
    181189                                        passes[passes_cnt - 1].n_allocs--;
    … …  
    186194                        void * calloc( size_t nelem, size_t size ) {
    187195                                static auto __calloc = reinterpret_cast<void * (*)(size_t, size_t)>(interpose_symbol( "calloc", nullptr ));
    188                                 if( passes_cnt > 0 ) {
     196                                if( enabled && passes_cnt > 0 ) {
    189197                                        passes[passes_cnt - 1].mallocs++;
    190198                                        passes[passes_cnt - 1].n_allocs++;
    … …  
    198206                                static auto __realloc = reinterpret_cast<void * (*)(void *, size_t)>(interpose_symbol( "realloc", nullptr ));
    199207                                void * s = __realloc( ptr, size );
    200                                 if ( s != ptr && passes_cnt > 0 ) {                     // did realloc get new storage ?
     208                                if ( enabled && s != ptr && passes_cnt > 0 ) {                  // did realloc get new storage ?
    201209                                        passes[passes_cnt - 1].mallocs++;
    202210                                        passes[passes_cnt - 1].frees++;
Note: See TracChangeset for help on using the changeset viewer.