Changeset 1cb7fab2 for src/Common/Stats/Counter.h

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

File:

• src/Common/Stats/Counter.h (modified) (1 diff)

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
         }
 }