Changeset 1cb7fab2

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

Files:

• Common/Stats.h (modified) (2 diffs)
• Common/Stats/Base.h (modified) (3 diffs)
• Common/Stats/Counter.cc (modified) (3 diffs)
• Common/Stats/Counter.h (modified) (1 diff)
• Common/Stats/Heap.cc (modified) (7 diffs)
• Common/Stats/Stats.cc (added)
• Common/Stats/Time.h (added)
• Common/module.mk (modified) (1 diff)
• Makefile.in (modified) (4 diffs)
• SymTab/Indexer.cc (modified) (7 diffs)
• main.cc (modified) (3 diffs)

src/Common/Stats.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Heap.h --
+// Stats.h --
 //
 // Author           : Thierry Delisle
@@ -18 +18 @@
 #include "Common/Stats/Counter.h"
 #include "Common/Stats/Heap.h"
+#include "Common/Stats/Time.h"
+
+namespace Stats {
+        void parse_params(const char * const params);
+        void print();
+}

src/Common/Stats/Base.h

@@ -16 +16 @@
 #pragma once
 
-#include <string>
-
 namespace Stats {
         namespace Base {
+                class TreeImpl;
+
+                struct TreeTop {
+                        TreeImpl * head = nullptr;
+                        TreeImpl * tail = nullptr;
+
+                        inline void append(TreeImpl * node);
+                };
+
+                template<typename func_t>
+                void ForAll(TreeTop & range, size_t level, func_t func, bool destroy = false);
+
                 class TreeImpl {
                 public:
-                        struct Top {
-                                TreeImpl * head = nullptr;
-                                TreeImpl * tail = nullptr;
-
-                                void append(TreeImpl * node) {
-                                        if(!head) { head = node; }
-                                        else      { tail->next = node;}
-                                        tail = node;
-                                }
-                        };
-
                         virtual void print(std::ostream &) = 0;
 
-                        const std::string name;
-                        TreeImpl(const std::string & name) : name(name) {}
+                        const char * const name;
+                        TreeImpl(const char * const name) : name(name) {}
 
                 protected:
@@ -42 +41 @@
 
                         TreeImpl * next = nullptr;
-                        Top children;
+                        TreeTop children;
+
+                        friend struct TreeTop;
 
                         template<typename func_t>
-                        friend void ForAll(TreeImpl::Top & range, size_t level, func_t func, bool destroy = false);
+                        friend void ForAll(TreeTop & range, size_t level, func_t func, bool destroy);
                 };
 
+                void TreeTop::append(TreeImpl * node) {
+                        if(!head) { head = node; }
+                        else      { tail->next = node;}
+                        tail = node;
+                }
+
                 template<typename func_t>
-                inline void ForAll(TreeImpl::Top & range, size_t level, func_t func, bool destroy) {
+                inline void ForAll(TreeTop & range, size_t level, func_t func, bool destroy) {
                         auto it = range.head;
                         while(it) {
@@ -60 +67 @@
                 }
 
-                template<TreeImpl::Top & top>
+                template<TreeTop & top>
                 class Tree : public TreeImpl {
                 public:
-                        Tree(const std::string & name) : TreeImpl{name} {
+                        Tree(const char * const name) : TreeImpl{name} {
                                 top.append(this);
                         }
 
-                        Tree(const std::string & name, Tree * parent) : TreeImpl{name} {
+                        Tree(const char * const name, Tree * parent) : TreeImpl{name} {
                                 parent->children.append(this);
                         }

src/Common/Stats/Counter.cc

@@ -27 +27 @@
                         size_t nc = 0;
                         Base::ForAll(top, 0, [&](Base::TreeImpl * node, size_t level) {
-                                nc = std::max(nc, (4 * level) + node->name.size());
+                                nc = std::max(nc, (4 * level) + std::strlen(node->name));
                         });
 
-                        const std::string & title = "Counter Statistic";
+                        const char * const title = "Counter Statistic";
                         size_t nct = nc + 14;
                         std::cerr << std::string(nct, '=') << std::endl;
-                        std::cerr << std::string((nct - title.size()) / 2, ' ');
+                        std::cerr << std::string((nct - std::strlen(title)) / 2, ' ');
                         std::cerr << title << std::endl;
                         std::cerr << std::string(nct, '-') << std::endl;
@@ -41 +41 @@
                                 std::cerr << std::string(level * 4, ' ');
                                 std::cerr << node->name;
-                                std::cerr << std::string(nc - ((level * 4) + node->name.size()), ' ');
+                                std::cerr << std::string(nc - ((level * 4) + std::strlen(node->name)), ' ');
                                 std::cerr << " | ";
                                 std::cerr << std::setw(9);
@@ -52 +52 @@
                 }
 
-                Base::TreeImpl::Top top;
+                Base::TreeTop top;
+
+                extern bool enabled;
         }
 }

src/Common/Stats/Counter.h

@@ -18 +18 @@
 #include <cstdint>
 #include <iostream>
-#include <string>
 
 #include "Common/Stats/Base.h"
 
+#if defined( NO_STATISTICS )
+        #define NO_COUNTER_STATISTICS
+#endif
+
 namespace Stats {
         namespace Counters {
-                void print();
+#               if defined(NO_COUNTERS_STATISTICS)
 
-                extern Base::TreeImpl::Top top;
+                        static inline void print() {}
 
-                class CounterGroup : public Base::Tree<top> {
-                public:
-                        CounterGroup(const std::string & name ) : Base::Tree<top>(name) {}
-                        CounterGroup(const std::string & name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent) {}
+                        class CounterGroup {
+                        public:
+                        };
 
-                        virtual void print(std::ostream & os) override { os << ""; }
-                protected:
-                        virtual ~CounterGroup() = default;
-                };
+                        class SimpleCounter {
+                        public:
+                                inline void operator++(int) {}
+                                inline void operator+=(size_t) {}
+                        };
 
-                class SimpleCounter : public Base::Tree<top> {
-                public:
-                        SimpleCounter(const std::string & name ) : Base::Tree<top>(name) {}
-                        SimpleCounter(const std::string & name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent) {}
+                        template<typename T>
+                        class AverageCounter {
+                        public:
+                                inline void push(T value) {}
+                        };
 
-                        virtual void print(std::ostream & os) override { os << count; }
+                        template<typename T>
+                        class MaxCounter {
+                        public:
+                                inline void push(T value) {}
+                        };
 
-                        inline void operator++(int)          { count++;        }
-                        inline void operator+=(size_t value) { count += value; }
-                protected:
-                        virtual ~SimpleCounter() = default;
-
-                private:
-                        size_t count = 0;
-                };
-
-                template<typename T>
-                class AverageCounter : public Base::Tree<top> {
-                public:
-                        AverageCounter(const std::string & name ) : Base::Tree<top>(name), sum{} {}
-                        AverageCounter(const std::string & name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent), sum{} {}
-
-                        virtual void print(std::ostream & os) { os << sum / count; }
-
-                        inline void push(T value) {
-                                sum += value;
-                                count++;
+                        template<typename counter_t>
+                        counter_t * build(const char * const name) {
+                                return nullptr;
                         }
 
-                protected:
-                        virtual ~AverageCounter() = default;
+                        template<typename counter_t>
+                        counter_t * build(const char * const name, Base::Tree<top> * parent) {
+                                        return nullptr;
+                        }
+#               else
+                        extern bool enabled;
 
-                private:
-                        T sum;
-                        size_t count = 1;
-                };
+                        extern Base::TreeTop top;
 
-                template<typename T>
-                class MaxCounter : public Base::Tree<top> {
-                public:
-                        MaxCounter(const std::string & name ) : Base::Tree<top>(name), max{} {}
-                        MaxCounter(const std::string & name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent), max{} {}
+                        class CounterGroup : public Base::Tree<top> {
+                        public:
+                                CounterGroup(const char * const name ) : Base::Tree<top>(name) {}
+                                CounterGroup(const char * const name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent) {}
 
-                        virtual void print(std::ostream & os) { os << max; }
+                                virtual void print(std::ostream & os) override { os << ""; }
+                        protected:
+                                virtual ~CounterGroup() = default;
+                        };
 
-                        inline void push(T value) { max = std::max(max, value); }
-                protected:
-                        virtual ~MaxCounter() = default;
+                        class SimpleCounter : public Base::Tree<top> {
+                        public:
+                                SimpleCounter(const char * const name ) : Base::Tree<top>(name) {}
+                                SimpleCounter(const char * const name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent) {}
 
-                private:
-                        T max;
-                };
+                                virtual void print(std::ostream & os) override { os << count; }
+
+                                inline void operator++(int)          { if(!enabled) return; count++;        }
+                                inline void operator+=(size_t value) { if(!enabled) return; count += value; }
+
+                        protected:
+                                virtual ~SimpleCounter() = default;
+
+                        private:
+                                size_t count = 0;
+                        };
+
+                        template<typename T>
+                        class AverageCounter : public Base::Tree<top> {
+                        public:
+                                AverageCounter(const char * const name ) : Base::Tree<top>(name), sum{} {}
+                                AverageCounter(const char * const name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent), sum{} {}
+
+                                virtual void print(std::ostream & os) { os << sum / count; }
+
+                                inline void push(T value) { if(!enabled) return; sum += value; count++; }
+
+                        protected:
+                                virtual ~AverageCounter() = default;
+
+                        private:
+                                T sum;
+                                size_t count = 1;
+                        };
+
+                        template<typename T>
+                        class MaxCounter : public Base::Tree<top> {
+                        public:
+                                MaxCounter(const char * const name ) : Base::Tree<top>(name), max{} {}
+                                MaxCounter(const char * const name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent), max{} {}
+
+                                virtual void print(std::ostream & os) { os << max; }
+
+                                inline void push(T value) { if(!enabled) return; max = std::max(max, value); }
+
+                        protected:
+                                virtual ~MaxCounter() = default;
+
+                        private:
+                                T max;
+                        };
+
+                        template<typename counter_t>
+                        counter_t * build(const char * const name) {
+                                if(!enabled) return nullptr;
+                                return new counter_t(name);
+                        }
+
+                        template<typename counter_t>
+                        counter_t * build(const char * const name, Base::Tree<top> * parent) {
+                                if(!enabled) return nullptr;
+                                return new counter_t(name, parent);
+                        }
+#               endif
         }
 }

src/Common/Stats/Heap.cc

@@ -21 +21 @@
 #include <iostream>
 
+#if defined( NO_STATISTICS )
+        #define NO_HEAP_STATISTICS
+#endif
+
 namespace Stats {
         namespace Heap {
@@ -28 +32 @@
                 void print() {}
 #else
+                extern bool enabled;
+
                 struct StatBlock {
                         const char * name  = nullptr;   ///< Name of this pass
@@ -77 +83 @@
 
                 void print() {
+                        if(!enabled) return;
+
                         size_t nc = 0;
                         size_t total_mallocs = 0;
@@ -166 +174 @@
                         void * malloc( size_t size ) {
                                 static auto __malloc = reinterpret_cast<void * (*)(size_t)>(interpose_symbol( "malloc", nullptr ));
-                                if( passes_cnt > 0 ) {
+                                if( enabled && passes_cnt > 0 ) {
                                         passes[passes_cnt - 1].mallocs++;
                                         passes[passes_cnt - 1].n_allocs++;
@@ -177 +185 @@
                         void free( void * ptr ) {
                                 static auto __free = reinterpret_cast<void   (*)(void *)>(interpose_symbol( "free", nullptr ));
-                                if( passes_cnt > 0 ) {
+                                if( enabled && passes_cnt > 0 ) {
                                         passes[passes_cnt - 1].frees++;
                                         passes[passes_cnt - 1].n_allocs--;
@@ -186 +194 @@
                         void * calloc( size_t nelem, size_t size ) {
                                 static auto __calloc = reinterpret_cast<void * (*)(size_t, size_t)>(interpose_symbol( "calloc", nullptr ));
-                                if( passes_cnt > 0 ) {
+                                if( enabled && passes_cnt > 0 ) {
                                         passes[passes_cnt - 1].mallocs++;
                                         passes[passes_cnt - 1].n_allocs++;
@@ -198 +206 @@
                                 static auto __realloc = reinterpret_cast<void * (*)(void *, size_t)>(interpose_symbol( "realloc", nullptr ));
                                 void * s = __realloc( ptr, size );
-                                if ( s != ptr && passes_cnt > 0 ) {                     // did realloc get new storage ?
+                                if ( enabled && s != ptr && passes_cnt > 0 ) {                  // did realloc get new storage ?
                                         passes[passes_cnt - 1].mallocs++;
                                         passes[passes_cnt - 1].frees++;

src/Common/module.mk

@@ -20 +20 @@
       Common/PassVisitor.cc \
       Common/SemanticError.cc \
+      Common/Stats/Counter.cc \
       Common/Stats/Heap.cc \
-      Common/Stats/Counter.cc \
+      Common/Stats/Stats.cc \
       Common/UniqueName.cc
 

src/Makefile.in

@@ -167 +167 @@
 am__objects_2 = Common/Assert.$(OBJEXT) Common/Eval.$(OBJEXT) \
         Common/PassVisitor.$(OBJEXT) Common/SemanticError.$(OBJEXT) \
-        Common/Stats/Heap.$(OBJEXT) Common/Stats/Counter.$(OBJEXT) \
-        Common/UniqueName.$(OBJEXT)
+        Common/Stats/Counter.$(OBJEXT) Common/Stats/Heap.$(OBJEXT) \
+        Common/Stats/Stats.$(OBJEXT) Common/UniqueName.$(OBJEXT)
 am__objects_3 = ControlStruct/ForExprMutator.$(OBJEXT) \
         ControlStruct/LabelFixer.$(OBJEXT) \
@@ -564 +564 @@
       Common/PassVisitor.cc \
       Common/SemanticError.cc \
+      Common/Stats/Counter.cc \
       Common/Stats/Heap.cc \
-      Common/Stats/Counter.cc \
+      Common/Stats/Stats.cc \
       Common/UniqueName.cc
 
@@ -735 +736 @@
         @$(MKDIR_P) Common/Stats/$(DEPDIR)
         @: > Common/Stats/$(DEPDIR)/$(am__dirstamp)
+Common/Stats/Counter.$(OBJEXT): Common/Stats/$(am__dirstamp) \
+        Common/Stats/$(DEPDIR)/$(am__dirstamp)
 Common/Stats/Heap.$(OBJEXT): Common/Stats/$(am__dirstamp) \
         Common/Stats/$(DEPDIR)/$(am__dirstamp)
-Common/Stats/Counter.$(OBJEXT): Common/Stats/$(am__dirstamp) \
+Common/Stats/Stats.$(OBJEXT): Common/Stats/$(am__dirstamp) \
         Common/Stats/$(DEPDIR)/$(am__dirstamp)
 Common/UniqueName.$(OBJEXT): Common/$(am__dirstamp) \
@@ -1124 +1127 @@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Counter.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Heap.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Stats.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/Keywords.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/Waitfor.Po@am__quote@

src/SymTab/Indexer.cc

@@ -45 +45 @@
         // Statistics block
         namespace {
-                auto idtable_group = new Stats::Counters::CounterGroup("IdTable");
-                auto idtable_find  = new Stats::Counters::SimpleCounter("Find calls", idtable_group);
-                auto idtable_size  = new Stats::Counters::AverageCounter<double>("Average Size", idtable_group);
-                auto idtable_key   = new Stats::Counters::AverageCounter<double>("Average Key Size", idtable_group);
-
-                auto indexers_group = new Stats::Counters::CounterGroup("Indexers");
-                auto indexers_count = new Stats::Counters::SimpleCounter("Count", indexers_group);
-                auto indexers_size  = new Stats::Counters::AverageCounter<double>("Average Size", indexers_group);
-                auto indexers_depth_a  = new Stats::Counters::AverageCounter<double>("Average Depth", indexers_group);
-                auto indexers_depth_m  = new Stats::Counters::MaxCounter<size_t>("Max Depth", indexers_group);
+
+                static inline auto stats_idtable() {
+                        using namespace Stats::Counters;
+                        static auto group = build<CounterGroup>("IdTable");
+                        static struct {
+                                SimpleCounter * find;
+                                AverageCounter<double> * size;
+                                AverageCounter<double> * key;
+                        } ret = {
+                                .find = build<SimpleCounter>("Find calls", group),
+                                .size = build<AverageCounter<double>>("Average Size", group),
+                                .key  = build<AverageCounter<double>>("Average Key Size", group),
+                        };
+                        return ret;
+                }
+
+                static inline auto stats_indexers() {
+                        using namespace Stats::Counters;
+                        static auto group   = build<CounterGroup>("Indexers");
+                        static struct {
+                                SimpleCounter * count;
+                                AverageCounter<double> * size;
+                                AverageCounter<double> * depth_a;
+                                MaxCounter<size_t> * depth_m;
+                        } ret = {
+                                .count   = build<SimpleCounter>("Count", group),
+                                .size    = build<AverageCounter<double>>("Average Size", group),
+                                .depth_a = build<AverageCounter<double>>("Average Depth", group),
+                                .depth_m = build<MaxCounter<size_t>>("Max Depth", group),
+                        };
+                        return ret;
+                }
         }
 
@@ -214 +236 @@
 
         Indexer::Indexer() : tables( 0 ), scope( 0 ) {
-                (*indexers_count)++;
+                (*stats_indexers().count)++;
         }
 
         Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {
-                (*indexers_count)++;
+                (*stats_indexers().count)++;
         }
 
@@ -227 +249 @@
         Indexer::~Indexer() {
                 if(tables) {
-                        indexers_size->push( tables->idTable.size() );
+                        stats_indexers().size->push( tables->idTable.size() );
                         size_t depth = 1;
                         for( auto crnt = tables->base.tables; crnt; crnt = crnt->base.tables ) {
                                 ++depth;
                         }
-                        indexers_depth_a->push( depth );
-                        indexers_depth_m->push( depth );
+                        stats_indexers().depth_a->push( depth );
+                        stats_indexers().depth_m->push( depth );
                 }
                 deleteRef( tables );
@@ -266 +288 @@
                 while ( searchTables ) {
 
-                        (*idtable_find)++;
-                        idtable_key->push( id.size() );
-                        idtable_size->push( searchTables->idTable.size() );
+                        (*stats_idtable().find)++;
+                        stats_idtable().key->push( id.size() );
+                        stats_idtable().size->push( searchTables->idTable.size() );
                         IdTable::const_iterator decls = searchTables->idTable.find( id );
                         if ( decls != searchTables->idTable.end() ) {
@@ -345 +367 @@
                 if ( tables->scope < scope ) return nullptr;
 
-                (*idtable_find)++;
-                idtable_key->push( id.size() );
-                idtable_size->push( tables->idTable.size() );
+                (*stats_idtable().find)++;
+                stats_idtable().key->push( id.size() );
+                stats_idtable().size->push( tables->idTable.size() );
                 IdTable::const_iterator decls = tables->idTable.find( id );
                 if ( decls != tables->idTable.end() ) {
@@ -366 +388 @@
                 if ( tables->scope < scope ) return false;
 
-                (*idtable_find)++;
-                idtable_key->push( id.size() );
-                idtable_size->push( tables->idTable.size() );
+                (*stats_idtable().find)++;
+                stats_idtable().key->push( id.size() );
+                stats_idtable().size->push( tables->idTable.size() );
                 IdTable::const_iterator decls = tables->idTable.find( id );
                 if ( decls != tables->idTable.end() ) {
@@ -385 +407 @@
                 if ( tables->scope < scope ) return false;
 
-                (*idtable_find)++;
-                idtable_key->push( id.size() );
-                idtable_size->push( tables->idTable.size() );
+                (*stats_idtable().find)++;
+                stats_idtable().key->push( id.size() );
+                stats_idtable().size->push( tables->idTable.size() );
                 IdTable::const_iterator decls = tables->idTable.find( id );
                 if ( decls != tables->idTable.end() ) {

src/main.cc

@@ -65 +65 @@
 using namespace std;
 
-auto pass_visitor_group = new Stats::Counters::CounterGroup("Pass Visitor");
 
 void NewPass(const char * const name) {
         Stats::Heap::newPass(name);
-        auto pass = new Stats::Counters::CounterGroup(name, pass_visitor_group);
+        using namespace Stats::Counters;
+        static auto pass_visitor_group = build<CounterGroup>("Pass Visitor");
+        auto pass = build<CounterGroup>(name, pass_visitor_group);
         pass_visitor_stats.depth = 0;
-        pass_visitor_stats.avg = new Stats::Counters::AverageCounter<double>("Average Depth", pass);
-        pass_visitor_stats.max = new Stats::Counters::MaxCounter<double>("Max Depth", pass);
+        pass_visitor_stats.avg = build<AverageCounter<double>>("Average Depth", pass);
+        pass_visitor_stats.max = build<MaxCounter<double>>("Max Depth", pass);
 }
 
@@ -389 +390 @@
 
         deleteAll( translationUnit );
-        if(!libcfap && !treep) {
-                if(stats_counters) Stats::Counters::print();
-                if(stats_heap) Stats::Heap::print();
-        }
+        Stats::print();
 
         return 0;
@@ -508 +506 @@
                         break;
                         case Stats:
-                        {
-                                std::stringstream ss(optarg);
-                                while(ss.good()) {
-                                        std::string substr;
-                                        getline( ss, substr, ',' );
-                                        if(substr == "counters") {
-                                                stats_counters = true;
-                                        } else if(substr == "heap") {
-                                                stats_heap = true;
-                                        } else if(substr == "none") {
-                                                stats_counters = false;
-                                                stats_heap = false;
-                                        } else {
-                                                std::cerr << "Ignoring unknown statistic " << substr << std::endl;
-                                        }
-                                }
-
-                        }
+                                Stats::parse_params(optarg);
                         break;
                         case Symbol: