Changeset 1cb7fab2


Ignore:
Timestamp:
Mar 4, 2019, 2:53:55 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:
874ffa4
Parents:
675716e
Message:

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

Location:
src
Files:
2 added
9 edited

Legend:

Unmodified
Added
Removed
  • src/Common/Stats.h

    r675716e r1cb7fab2  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Heap.h --
     7// Stats.h --
    88//
    99// Author           : Thierry Delisle
     
    1818#include "Common/Stats/Counter.h"
    1919#include "Common/Stats/Heap.h"
     20#include "Common/Stats/Time.h"
     21
     22namespace Stats {
     23        void parse_params(const char * const params);
     24        void print();
     25}
  • 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++;
  • src/Common/module.mk

    r675716e r1cb7fab2  
    2020      Common/PassVisitor.cc \
    2121      Common/SemanticError.cc \
     22      Common/Stats/Counter.cc \
    2223      Common/Stats/Heap.cc \
    23       Common/Stats/Counter.cc \
     24      Common/Stats/Stats.cc \
    2425      Common/UniqueName.cc
    2526
  • src/Makefile.in

    r675716e r1cb7fab2  
    167167am__objects_2 = Common/Assert.$(OBJEXT) Common/Eval.$(OBJEXT) \
    168168        Common/PassVisitor.$(OBJEXT) Common/SemanticError.$(OBJEXT) \
    169         Common/Stats/Heap.$(OBJEXT) Common/Stats/Counter.$(OBJEXT) \
    170         Common/UniqueName.$(OBJEXT)
     169        Common/Stats/Counter.$(OBJEXT) Common/Stats/Heap.$(OBJEXT) \
     170        Common/Stats/Stats.$(OBJEXT) Common/UniqueName.$(OBJEXT)
    171171am__objects_3 = ControlStruct/ForExprMutator.$(OBJEXT) \
    172172        ControlStruct/LabelFixer.$(OBJEXT) \
     
    564564      Common/PassVisitor.cc \
    565565      Common/SemanticError.cc \
     566      Common/Stats/Counter.cc \
    566567      Common/Stats/Heap.cc \
    567       Common/Stats/Counter.cc \
     568      Common/Stats/Stats.cc \
    568569      Common/UniqueName.cc
    569570
     
    735736        @$(MKDIR_P) Common/Stats/$(DEPDIR)
    736737        @: > Common/Stats/$(DEPDIR)/$(am__dirstamp)
     738Common/Stats/Counter.$(OBJEXT): Common/Stats/$(am__dirstamp) \
     739        Common/Stats/$(DEPDIR)/$(am__dirstamp)
    737740Common/Stats/Heap.$(OBJEXT): Common/Stats/$(am__dirstamp) \
    738741        Common/Stats/$(DEPDIR)/$(am__dirstamp)
    739 Common/Stats/Counter.$(OBJEXT): Common/Stats/$(am__dirstamp) \
     742Common/Stats/Stats.$(OBJEXT): Common/Stats/$(am__dirstamp) \
    740743        Common/Stats/$(DEPDIR)/$(am__dirstamp)
    741744Common/UniqueName.$(OBJEXT): Common/$(am__dirstamp) \
     
    11241127@AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Counter.Po@am__quote@
    11251128@AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Heap.Po@am__quote@
     1129@AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Stats.Po@am__quote@
    11261130@AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/Keywords.Po@am__quote@
    11271131@AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/Waitfor.Po@am__quote@
  • src/SymTab/Indexer.cc

    r675716e r1cb7fab2  
    4545        // Statistics block
    4646        namespace {
    47                 auto idtable_group = new Stats::Counters::CounterGroup("IdTable");
    48                 auto idtable_find  = new Stats::Counters::SimpleCounter("Find calls", idtable_group);
    49                 auto idtable_size  = new Stats::Counters::AverageCounter<double>("Average Size", idtable_group);
    50                 auto idtable_key   = new Stats::Counters::AverageCounter<double>("Average Key Size", idtable_group);
    51 
    52                 auto indexers_group = new Stats::Counters::CounterGroup("Indexers");
    53                 auto indexers_count = new Stats::Counters::SimpleCounter("Count", indexers_group);
    54                 auto indexers_size  = new Stats::Counters::AverageCounter<double>("Average Size", indexers_group);
    55                 auto indexers_depth_a  = new Stats::Counters::AverageCounter<double>("Average Depth", indexers_group);
    56                 auto indexers_depth_m  = new Stats::Counters::MaxCounter<size_t>("Max Depth", indexers_group);
     47
     48                static inline auto stats_idtable() {
     49                        using namespace Stats::Counters;
     50                        static auto group = build<CounterGroup>("IdTable");
     51                        static struct {
     52                                SimpleCounter * find;
     53                                AverageCounter<double> * size;
     54                                AverageCounter<double> * key;
     55                        } ret = {
     56                                .find = build<SimpleCounter>("Find calls", group),
     57                                .size = build<AverageCounter<double>>("Average Size", group),
     58                                .key  = build<AverageCounter<double>>("Average Key Size", group),
     59                        };
     60                        return ret;
     61                }
     62
     63                static inline auto stats_indexers() {
     64                        using namespace Stats::Counters;
     65                        static auto group   = build<CounterGroup>("Indexers");
     66                        static struct {
     67                                SimpleCounter * count;
     68                                AverageCounter<double> * size;
     69                                AverageCounter<double> * depth_a;
     70                                MaxCounter<size_t> * depth_m;
     71                        } ret = {
     72                                .count   = build<SimpleCounter>("Count", group),
     73                                .size    = build<AverageCounter<double>>("Average Size", group),
     74                                .depth_a = build<AverageCounter<double>>("Average Depth", group),
     75                                .depth_m = build<MaxCounter<size_t>>("Max Depth", group),
     76                        };
     77                        return ret;
     78                }
    5779        }
    5880
     
    214236
    215237        Indexer::Indexer() : tables( 0 ), scope( 0 ) {
    216                 (*indexers_count)++;
     238                (*stats_indexers().count)++;
    217239        }
    218240
    219241        Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {
    220                 (*indexers_count)++;
     242                (*stats_indexers().count)++;
    221243        }
    222244
     
    227249        Indexer::~Indexer() {
    228250                if(tables) {
    229                         indexers_size->push( tables->idTable.size() );
     251                        stats_indexers().size->push( tables->idTable.size() );
    230252                        size_t depth = 1;
    231253                        for( auto crnt = tables->base.tables; crnt; crnt = crnt->base.tables ) {
    232254                                ++depth;
    233255                        }
    234                         indexers_depth_a->push( depth );
    235                         indexers_depth_m->push( depth );
     256                        stats_indexers().depth_a->push( depth );
     257                        stats_indexers().depth_m->push( depth );
    236258                }
    237259                deleteRef( tables );
     
    266288                while ( searchTables ) {
    267289
    268                         (*idtable_find)++;
    269                         idtable_key->push( id.size() );
    270                         idtable_size->push( searchTables->idTable.size() );
     290                        (*stats_idtable().find)++;
     291                        stats_idtable().key->push( id.size() );
     292                        stats_idtable().size->push( searchTables->idTable.size() );
    271293                        IdTable::const_iterator decls = searchTables->idTable.find( id );
    272294                        if ( decls != searchTables->idTable.end() ) {
     
    345367                if ( tables->scope < scope ) return nullptr;
    346368
    347                 (*idtable_find)++;
    348                 idtable_key->push( id.size() );
    349                 idtable_size->push( tables->idTable.size() );
     369                (*stats_idtable().find)++;
     370                stats_idtable().key->push( id.size() );
     371                stats_idtable().size->push( tables->idTable.size() );
    350372                IdTable::const_iterator decls = tables->idTable.find( id );
    351373                if ( decls != tables->idTable.end() ) {
     
    366388                if ( tables->scope < scope ) return false;
    367389
    368                 (*idtable_find)++;
    369                 idtable_key->push( id.size() );
    370                 idtable_size->push( tables->idTable.size() );
     390                (*stats_idtable().find)++;
     391                stats_idtable().key->push( id.size() );
     392                stats_idtable().size->push( tables->idTable.size() );
    371393                IdTable::const_iterator decls = tables->idTable.find( id );
    372394                if ( decls != tables->idTable.end() ) {
     
    385407                if ( tables->scope < scope ) return false;
    386408
    387                 (*idtable_find)++;
    388                 idtable_key->push( id.size() );
    389                 idtable_size->push( tables->idTable.size() );
     409                (*stats_idtable().find)++;
     410                stats_idtable().key->push( id.size() );
     411                stats_idtable().size->push( tables->idTable.size() );
    390412                IdTable::const_iterator decls = tables->idTable.find( id );
    391413                if ( decls != tables->idTable.end() ) {
  • src/main.cc

    r675716e r1cb7fab2  
    6565using namespace std;
    6666
    67 auto pass_visitor_group = new Stats::Counters::CounterGroup("Pass Visitor");
    6867
    6968void NewPass(const char * const name) {
    7069        Stats::Heap::newPass(name);
    71         auto pass = new Stats::Counters::CounterGroup(name, pass_visitor_group);
     70        using namespace Stats::Counters;
     71        static auto pass_visitor_group = build<CounterGroup>("Pass Visitor");
     72        auto pass = build<CounterGroup>(name, pass_visitor_group);
    7273        pass_visitor_stats.depth = 0;
    73         pass_visitor_stats.avg = new Stats::Counters::AverageCounter<double>("Average Depth", pass);
    74         pass_visitor_stats.max = new Stats::Counters::MaxCounter<double>("Max Depth", pass);
     74        pass_visitor_stats.avg = build<AverageCounter<double>>("Average Depth", pass);
     75        pass_visitor_stats.max = build<MaxCounter<double>>("Max Depth", pass);
    7576}
    7677
     
    389390
    390391        deleteAll( translationUnit );
    391         if(!libcfap && !treep) {
    392                 if(stats_counters) Stats::Counters::print();
    393                 if(stats_heap) Stats::Heap::print();
    394         }
     392        Stats::print();
    395393
    396394        return 0;
     
    508506                        break;
    509507                        case Stats:
    510                         {
    511                                 std::stringstream ss(optarg);
    512                                 while(ss.good()) {
    513                                         std::string substr;
    514                                         getline( ss, substr, ',' );
    515                                         if(substr == "counters") {
    516                                                 stats_counters = true;
    517                                         } else if(substr == "heap") {
    518                                                 stats_heap = true;
    519                                         } else if(substr == "none") {
    520                                                 stats_counters = false;
    521                                                 stats_heap = false;
    522                                         } else {
    523                                                 std::cerr << "Ignoring unknown statistic " << substr << std::endl;
    524                                         }
    525                                 }
    526 
    527                         }
     508                                Stats::parse_params(optarg);
    528509                        break;
    529510                        case Symbol:
Note: See TracChangeset for help on using the changeset viewer.