Changeset 8e70823 for src/Common/Stats

Timestamp:

Mar 1, 2019, 2:10:34 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:

675716e

Parents:

79de2210

Message:

Extracted out BaseCounter? as a generic key-value tree

Location:

src/Common/Stats

Files:

• Base.h (added)
• Counter.cc (modified) (2 diffs)
• Counter.h (modified) (5 diffs)

src/Common/Stats/Counter.cc ¶

@@ -18 +18 @@
 #include <algorithm>
 #include <cstring>
+#include <functional>
 #include <iomanip>
 
 namespace Stats {
         namespace Counters {
-
-                template<typename T>
-                void ForAllCounters(BaseCounter::list_t & range, size_t level, T func) {
-                        auto it = range.head;
-                        while(it) {
-                                auto next = it->next;
-                                func(it, level);
-                                ForAllCounters(it->children, level + 1, func);
-                                it = next;
-                        }
-                }
-
                 void print() {
-                        if(!BaseCounter::top.head) return;
+                        if(!top.head) return;
                         size_t nc = 0;
-                        ForAllCounters(BaseCounter::top, 0, [&](BaseCounter * node, size_t level) {
-                                nc = std::max(nc, (4 * level) + std::strlen(node->name));
+                        Base::ForAll(top, 0, [&](Base::TreeImpl * node, size_t level) {
+                                nc = std::max(nc, (4 * level) + node->name.size());
                         });
 
-                        const char * const title = "Counter Statistic";
+                        const std::string & title = "Counter Statistic";
                         size_t nct = nc + 14;
                         std::cerr << std::string(nct, '=') << std::endl;
-                        std::cerr << std::string((nct - std::strlen(title)) / 2, ' ');
+                        std::cerr << std::string((nct - title.size()) / 2, ' ');
                         std::cerr << title << std::endl;
                         std::cerr << std::string(nct, '-') << std::endl;
 
 
-                        ForAllCounters(BaseCounter::top, 0, [&](BaseCounter * node, size_t level) {
+                        Base::ForAll(top, 0, [&](Base::TreeImpl * node, size_t level) {
                                 std::cerr << std::string(level * 4, ' ');
                                 std::cerr << node->name;
-                                std::cerr << std::string(nc - ((level * 4) + std::strlen(node->name)), ' ');
+                                std::cerr << std::string(nc - ((level * 4) + node->name.size()), ' ');
                                 std::cerr << " | ";
                                 std::cerr << std::setw(9);
@@ -58 +47 @@
                                 std::cerr << " |";
                                 std::cerr << '\n';
-                                delete node;
-                        });
+                        }, true);
 
                         std::cerr << std::string(nct, '-') << std::endl;
                 }
 
-                BaseCounter::list_t BaseCounter::top;
+                Base::TreeImpl::Top top;
         }
 }

src/Common/Stats/Counter.h ¶

@@ -18 +18 @@
 #include <cstdint>
 #include <iostream>
+#include <string>
+
+#include "Common/Stats/Base.h"
 
 namespace Stats {
@@ -23 +26 @@
                 void print();
 
-                class BaseCounter {
+                extern Base::TreeImpl::Top top;
+
+                class CounterGroup : public Base::Tree<top> {
                 public:
-                        BaseCounter(const char * const name) : name(name) {
-                                top.append(this);
-                        }
+                        CounterGroup(const std::string & name ) : Base::Tree<top>(name) {}
+                        CounterGroup(const std::string & name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent) {}
 
-                        BaseCounter(const char * const name, BaseCounter * parent) : name(name) {
-                                parent->children.append(this);
-                        }
+                        virtual void print(std::ostream & os) override { os << ""; }
                 protected:
-                        virtual ~BaseCounter() = default;
-
-                        struct list_t {
-                                BaseCounter * head = nullptr;
-                                BaseCounter * tail = nullptr;
-
-                                void append(BaseCounter * node) {
-                                        if(!head) { head = node; }
-                                        else      { tail->next = node;}
-                                        tail = node;
-                                }
-                        };
-
-                private:
-                        virtual void print(std::ostream &) = 0;
-                        template<typename T>
-                        friend void ForAllCounters(BaseCounter::list_t &, size_t, T );
-                        friend void print();
-
-                private:
-                        const char * const name;
-
-                        BaseCounter * next = nullptr;
-                        list_t children;
-
-                        static list_t top;
+                        virtual ~CounterGroup() = default;
                 };
 
-                class CounterGroup : public BaseCounter {
+                class SimpleCounter : public Base::Tree<top> {
                 public:
-                        CounterGroup(const char * const name ) : BaseCounter(name) {}
-                        CounterGroup(const char * const name, BaseCounter * parent) : BaseCounter(name, parent) {}
+                        SimpleCounter(const std::string & name ) : Base::Tree<top>(name) {}
+                        SimpleCounter(const std::string & name, Base::Tree<top> * parent) : Base::Tree<top>(name, parent) {}
 
-                protected:
-                        virtual ~CounterGroup() = default;
-
-                private:
-                        virtual void print(std::ostream & os) {
-                                os << "";
-                        }
-                        template<typename T>
-                        friend void ForAllCounters(BaseCounter::list_t &, size_t, T );
-                        friend void print();
-                };
-
-                class SimpleCounter : public BaseCounter {
-                public:
-                        SimpleCounter(const char * const name ) : BaseCounter(name) {}
-                        SimpleCounter(const char * const name, BaseCounter * parent) : BaseCounter(name, parent) {}
+                        virtual void print(std::ostream & os) override { os << count; }
 
                         inline void operator++(int)          { count++;        }
@@ -89 +51 @@
 
                 private:
-                        virtual void print(std::ostream & os) {
-                                os << count;
-                        }
-                        template<typename T>
-                        friend void ForAllCounters(BaseCounter::list_t &, size_t, T );
-                        friend void print();
-
                         size_t count = 0;
-
                 };
 
                 template<typename T>
-                class AverageCounter : public BaseCounter {
+                class AverageCounter : public Base::Tree<top> {
                 public:
-                        AverageCounter(const char * const name ) : BaseCounter(name), sum{} {}
-                        AverageCounter(const char * const name, BaseCounter * parent) : BaseCounter(name, parent), sum{} {}
+                        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) {
@@ -115 +71 @@
 
                 private:
-                        virtual void print(std::ostream & os) {
-                                os << sum / count;
-                        }
-                        template<typename F>
-                        friend void ForAllCounters(BaseCounter::list_t &, size_t, F );
-                        friend void print();
-
                         T sum;
                         size_t count = 1;
@@ -127 +76 @@
 
                 template<typename T>
-                class MaxCounter : public BaseCounter {
+                class MaxCounter : public Base::Tree<top> {
                 public:
-                        MaxCounter(const char * const name ) : BaseCounter(name), max{} {}
-                        MaxCounter(const char * const name, BaseCounter * parent) : BaseCounter(name, parent), max{} {}
+                        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{} {}
 
-                        inline void push(T value) {
-                                max = std::max(max, value);
-                        }
+                        virtual void print(std::ostream & os) { os << max; }
 
+                        inline void push(T value) { max = std::max(max, value); }
                 protected:
                         virtual ~MaxCounter() = default;
 
                 private:
-                        virtual void print(std::ostream & os) {
-                                os << max;
-                        }
-                        template<typename F>
-                        friend void ForAllCounters(BaseCounter::list_t &, size_t, F );
-                        friend void print();
-
                         T max;
                 };