quic: use backing store for StatsBase

Author: jasnell

src/aliased_buffer.h

@@ -32,31 +32,6 @@ template <class NativeT,
           typename = std::enable_if_t<std::is_scalar<NativeT>::value>>
 class AliasedBufferBase {
  public:
-  /**
-   * Create an AliasedBufferBase over an existing buffer
-   */
-  AliasedBufferBase(
-      v8::Isolate* isolate,
-      const size_t count,
-      NativeT* buffer) :
-      isolate_(isolate),
-      count_(count),
-      byte_offset_(0),
-      buffer_(buffer) {
-    CHECK_GT(count, 0);
-    const v8::HandleScope handle_scope(isolate_);
-    const size_t size_in_bytes =
-        MultiplyWithOverflowCheck(sizeof(NativeT), count);
-    v8::Local<v8::ArrayBuffer> ab =
-        v8::ArrayBuffer::New(
-            isolate_,
-            buffer,
-            size_in_bytes);
-
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count);
-    js_array_ = v8::Global<V8T>(isolate, js_array);
-  }
-
   AliasedBufferBase(v8::Isolate* isolate, const size_t count)
       : isolate_(isolate), count_(count), byte_offset_(0) {
     CHECK_GT(count, 0);
@@ -199,6 +174,14 @@ class AliasedBufferBase {
     return buffer_;
   }
 
+  /**
+   *  Get the underlying native buffer as a cast to T.
+   **/
+  template <typename T>
+  inline T* GetNativeBuffer() {
+    return reinterpret_cast<T*>(&buffer_);
+  }
+
   /**
    *  Synonym for GetBuffer()
    */

src/quic/node_quic_util-inl.h

@@ -324,23 +324,29 @@ template <typename T>
 StatsBase<T>::StatsBase(
     Environment* env,
     v8::Local<v8::Object> wrap,
-    int options)
-    : stats_buffer_(
-          env->isolate(),
-          sizeof(typename T::Stats) / sizeof(uint64_t),
-          reinterpret_cast<uint64_t*>(&stats_)) {
+    int options) {
   static constexpr uint64_t kMax = std::numeric_limits<int64_t>::max();
-  stats_.created_at = uv_hrtime();
 
-  // TODO(@jasnell): The follow are checks instead of handling
-  // the error. Before this code moves out of experimental,
-  // these should be change to properly handle the error.
-
-  wrap->DefineOwnProperty(
+  // Create the backing store for the statistics
+  size_t size = sizeof(Stats);
+  size_t count = size / sizeof(uint64_t);
+  stats_store_ = v8::ArrayBuffer::NewBackingStore(env->isolate(), size);
+  stats_ = new (stats_store_->Data()) Stats;
+
+  DCHECK_NOT_NULL(stats_);
+  stats_->created_at = uv_hrtime();
+
+  // The stats buffer is exposed as a BigUint64Array on
+  // the JavaScript side to allow statistics to be monitored.
+  v8::Local<v8::ArrayBuffer> stats_buffer =
+      v8::ArrayBuffer::New(env->isolate(), stats_store_);
+  v8::Local<v8::BigUint64Array> stats_array =
+      v8::BigUint64Array::New(stats_buffer, 0, count);
+  USE(wrap->DefineOwnProperty(
       env->context(),
       env->stats_string(),
-      stats_buffer_.GetJSArray(),
-      v8::PropertyAttribute::ReadOnly).Check();
+      stats_array,
+      v8::PropertyAttribute::ReadOnly));
 
   if (options & HistogramOptions::ACK) {
     ack_ = HistogramBase::New(env, 1, kMax);
@@ -371,28 +377,28 @@ StatsBase<T>::StatsBase(
 }
 
 template <typename T>
-void StatsBase<T>::IncrementStat(uint64_t T::Stats::*member, uint64_t amount) {
+void StatsBase<T>::IncrementStat(uint64_t Stats::*member, uint64_t amount) {
   static constexpr uint64_t kMax = std::numeric_limits<uint64_t>::max();
-  stats_.*member += std::min(amount, kMax - stats_.*member);
+  stats_->*member += std::min(amount, kMax - stats_->*member);
 }
 
 template <typename T>
-void StatsBase<T>::SetStat(uint64_t T::Stats::*member, uint64_t value) {
-  stats_.*member = value;
+void StatsBase<T>::SetStat(uint64_t Stats::*member, uint64_t value) {
+  stats_->*member = value;
 }
 
 template <typename T>
-void StatsBase<T>::RecordTimestamp(uint64_t T::Stats::*member) {
-  stats_.*member = uv_hrtime();
+void StatsBase<T>::RecordTimestamp(uint64_t Stats::*member) {
+  stats_->*member = uv_hrtime();
 }
 
 template <typename T>
-uint64_t StatsBase<T>::GetStat(uint64_t T::Stats::*member) const {
-  return stats_.*member;
+uint64_t StatsBase<T>::GetStat(uint64_t Stats::*member) const {
+  return stats_->*member;
 }
 
 template <typename T>
-inline void StatsBase<T>::RecordRate(uint64_t T::Stats::*member) {
+inline void StatsBase<T>::RecordRate(uint64_t Stats::*member) {
   CHECK(rate_);
   uint64_t received_at = GetStat(member);
   uint64_t now = uv_hrtime();
@@ -408,7 +414,7 @@ inline void StatsBase<T>::RecordSize(uint64_t val) {
 }
 
 template <typename T>
-inline void StatsBase<T>::RecordAck(uint64_t T::Stats::*member) {
+inline void StatsBase<T>::RecordAck(uint64_t Stats::*member) {
   CHECK(ack_);
   uint64_t acked_at = GetStat(member);
   uint64_t now = uv_hrtime();
@@ -419,7 +425,7 @@ inline void StatsBase<T>::RecordAck(uint64_t T::Stats::*member) {
 
 template <typename T>
 void StatsBase<T>::StatsMemoryInfo(MemoryTracker* tracker) const {
-  tracker->TrackField("stats_buffer", stats_buffer_);
+  tracker->TrackField("stats_store", stats_store_);
   tracker->TrackField("rate_histogram", rate_);
   tracker->TrackField("size_histogram", size_);
   tracker->TrackField("ack_histogram", ack_);
@@ -441,7 +447,7 @@ std::string StatsBase<T>::StatsDebug::ToString() const {
     out += std::to_string(val);
     out += "\n";
   };
-  add_field("Duration", uv_hrtime() - ptr->GetStat(&T::Stats::created_at));
+  add_field("Duration", uv_hrtime() - ptr->GetStat(&Stats::created_at));
   T::ToString(*ptr, add_field);
   return out;
 }

src/quic/node_quic_util.h

@@ -109,6 +109,8 @@ struct StatsTraits {
 template <typename T>
 class StatsBase {
  public:
+   typedef typename T::Stats Stats;
+
   // A StatsBase instance may have one of three histogram
   // instances. One that records rate of data flow, one
   // that records size of data chunk, and one that records
@@ -127,7 +129,7 @@ class StatsBase {
       v8::Local<v8::Object> wrap,
       int options = HistogramOptions::NONE);
 
-  inline ~StatsBase() = default;
+  inline ~StatsBase() { if (stats_ != nullptr) stats_->~Stats(); }
 
   // The StatsDebug utility is used when StatsBase is destroyed
   // to output statistical information to Debug. It is designed
@@ -141,40 +143,40 @@ class StatsBase {
 
   // Increments the given stat field by the given amount or 1 if
   // no amount is specified.
-  inline void IncrementStat(uint64_t T::Stats::*member, uint64_t amount = 1);
+  inline void IncrementStat(uint64_t Stats::*member, uint64_t amount = 1);
 
   // Sets an entirely new value for the given stat field
-  inline void SetStat(uint64_t T::Stats::*member, uint64_t value);
+  inline void SetStat(uint64_t Stats::*member, uint64_t value);
 
   // Sets the given stat field to the current uv_hrtime()
-  inline void RecordTimestamp(uint64_t T::Stats::*member);
+  inline void RecordTimestamp(uint64_t Stats::*member);
 
   // Gets the current value of the given stat field
-  inline uint64_t GetStat(uint64_t T::Stats::*member) const;
+  inline uint64_t GetStat(uint64_t Stats::*member) const;
 
   // If the rate histogram is used, records the time elapsed
   // between now and the timestamp specified by the member
   // field.
-  inline void RecordRate(uint64_t T::Stats::*member);
+  inline void RecordRate(uint64_t Stats::*member);
 
   // If the size histogram is used, records the given size.
   inline void RecordSize(uint64_t val);
 
   // If the ack rate histogram is used, records the time
   // elapsed between now and the timestamp specified by
   // the member field.
-  inline void RecordAck(uint64_t T::Stats::*member);
+  inline void RecordAck(uint64_t Stats::*member);
 
   inline void StatsMemoryInfo(MemoryTracker* tracker) const;
 
   inline void DebugStats();
 
  private:
-  typename T::Stats stats_{};
   BaseObjectPtr<HistogramBase> rate_;
   BaseObjectPtr<HistogramBase> size_;
   BaseObjectPtr<HistogramBase> ack_;
-  AliasedBigUint64Array stats_buffer_;
+  std::shared_ptr<v8::BackingStore> stats_store_;
+  Stats* stats_ = nullptr;
 };
 
 // PreferredAddress is a helper class used only when a client QuicSession