Add internal Perf interface

Author: cstlee

src/Perf.cc

@@ -43,12 +43,13 @@ std::unordered_set<const Counters*> perThreadCounters;
 }  // namespace Internal
 
 // Init thread local thread counters
-thread_local ThreadCounters threadCounters;
+thread_local ThreadCounters counters;
 
 /**
  * Construct and register a new per thread set of counters.
  */
 ThreadCounters::ThreadCounters()
+    : Counters()
 {
     std::lock_guard<std::mutex> lock(Internal::mutex);
     Internal::perThreadCounters.insert(this);
@@ -60,7 +61,7 @@ ThreadCounters::ThreadCounters()
 ThreadCounters::~ThreadCounters()
 {
     std::lock_guard<std::mutex> lock(Internal::mutex);
-    Internal::globalCounters.active_cycles += this->active_cycles;
+    Internal::globalCounters.add(this);
     Internal::perThreadCounters.erase(this);
 }
 
@@ -73,11 +74,14 @@ getStats(Stats* stats)
     stats->timestamp = PerfUtils::Cycles::rdtsc();
     stats->cycles_per_second = PerfUtils::Cycles::perSecond();
 
-    stats->active_cycles = Internal::globalCounters.active_cycles;
+    Counters output;
+    output.add(&Internal::globalCounters);
 
     for (const Counters* counters : Internal::perThreadCounters) {
-        stats->active_cycles += counters->active_cycles;
+        output.add(counters);
     }
+
+    output.dumpStats(stats);
 }
 
 }  // namespace Perf

src/Perf.h

@@ -27,8 +27,75 @@ namespace Perf {
  * Collection of collected performance counters.
  */
 struct Counters {
+    /**
+     * Wrapper class for individual counter entires to
+     */
+    template <typename T>
+    struct Stat : private std::atomic<T> {
+        /**
+         * Passthrough constructor.
+         */
+        template <typename... Args>
+        Stat(Args&&... args)
+            : std::atomic<T>(static_cast<Args&&>(args)...)
+        {}
+
+        /**
+         * Add the value of another Stat to this Stat.
+         */
+        void add(const Stat<T>& other)
+        {
+            this->fetch_add(other.load(std::memory_order_relaxed),
+                            std::memory_order_relaxed);
+        }
+
+        /**
+         * Add the given value to this Stat.
+         */
+        void add(T val)
+        {
+            this->fetch_add(val, std::memory_order_relaxed);
+        }
+
+        /**
+         * Return the stat value.
+         */
+        T get() const
+        {
+            return this->load(std::memory_order_relaxed);
+        }
+    };
+
+    /**
+     * Default constructor.
+     */
+    Counters()
+        : active_cycles(0)
+    {}
+
+    /**
+     * Default destructor.
+     */
+    ~Counters() = default;
+
+    /**
+     * Add the values in other to the corresponding counters in this object.
+     */
+    void add(const Counters* other)
+    {
+        active_cycles.add(other->active_cycles);
+    }
+
+    /**
+     * Export this object's counter values to a Stats structure.
+     */
+    void dumpStats(Stats* stats)
+    {
+        stats->active_cycles = active_cycles.get();
+    }
+
     /// CPU time spent actively processing Homa messages in cycles.
-    std::atomic<uint64_t> active_cycles;
+    Stat<uint64_t> active_cycles;
 };
 
 /**
@@ -42,7 +109,7 @@ struct ThreadCounters : public Counters {
 /**
  * Per thread counters.
  */
-extern thread_local ThreadCounters threadCounters;
+extern thread_local ThreadCounters counters;
 
 }  // namespace Perf
 }  // namespace Homa

src/Receiver.cc

@@ -778,8 +778,7 @@ Receiver::trySendGrants()
 
     uint64_t elapsed_cycles = PerfUtils::Cycles::rdtsc() - start_tsc;
     if (!idle) {
-        Perf::threadCounters.active_cycles.fetch_add(elapsed_cycles,
-                                                     std::memory_order_relaxed);
+        Perf::counters.active_cycles.add(elapsed_cycles);
     }
 }
 

src/Sender.cc

@@ -1015,8 +1015,7 @@ Sender::trySend()
     sending.clear();
     uint64_t elapsed_cycles = PerfUtils::Cycles::rdtsc() - start_tsc;
     if (!idle) {
-        Perf::threadCounters.active_cycles.fetch_add(elapsed_cycles,
-                                                     std::memory_order_relaxed);
+        Perf::counters.active_cycles.add(elapsed_cycles);
     }
 }
 

src/TransportImpl.cc

@@ -134,8 +134,7 @@ TransportImpl::processPackets()
     }
     uint64_t elapsed_cycles = PerfUtils::Cycles::rdtsc() - start_tsc;
     if (!idle) {
-        Perf::threadCounters.active_cycles.fetch_add(elapsed_cycles,
-                                                     std::memory_order_relaxed);
+        Perf::counters.active_cycles.add(elapsed_cycles);
     }
 }