From 0e8f927a2b455f845885160060e17a5188f03374 Mon Sep 17 00:00:00 2001
From: Paul Nathan Stickney <pstickne@gmail.com>
Date: Fri, 22 Nov 2019 20:56:23 -0800
Subject: [PATCH] #575 use unique_ptr to make valgrind happy

- While there is no actual memory leak for a static lifetime
  object required for the duration of the program, failure to
  delete the object can result in tooling reporting false positives..

  Anyway, also fixed the slight 'not quite in spec' usage of the
  MEMBER STATIC variables (which are not strictly qualified under
  constant initialization..), reduced the exposed definition,
  and improved comments.
---
 src/vt/trace/trace_containers.cc | 24 ++++++++++++++++++++++--
 src/vt/trace/trace_containers.h  | 24 ++++++------------------
 2 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/src/vt/trace/trace_containers.cc b/src/vt/trace/trace_containers.cc
index e2905791cf..b86053c448 100644
--- a/src/vt/trace/trace_containers.cc
+++ b/src/vt/trace/trace_containers.cc
@@ -1,12 +1,32 @@
 #include "vt/trace/trace_common.h"
 #include "vt/trace/trace_containers.h"
 
+#include <memory>
+
 namespace vt { namespace trace {
 
+// These MUST have static-lifetime and be initialized during constant
+// initialization as they are modified during dynamic initialization as
+// that is when auto-handler events are registered.
+// Using a constexpr constructor / initializer list is also relevant.
+// - https://en.cppreference.com/w/cpp/language/constant_initialization
+static std::unique_ptr<TraceContainerEventClassType> event_type_container_{};
+static std::unique_ptr<TraceContainerEventType> event_container_{};
+
 /*static*/ TraceContainerEventClassType*
-TraceContainers::event_type_container_;
+TraceContainers::getEventTypeContainer(){
+  if (event_type_container_ == nullptr) {
+    event_type_container_ = std::make_unique<TraceContainerEventClassType>();
+  }
+  return event_type_container_.get();
+}
 
 /*static*/ TraceContainerEventType*
-TraceContainers::event_container_;
+TraceContainers::getEventContainer(){
+  if (event_container_ == nullptr) {
+    event_container_ = std::make_unique<TraceContainerEventType>();
+  }
+  return event_container_.get();
+}
 
 }} //end namespace vt::trace
diff --git a/src/vt/trace/trace_containers.h b/src/vt/trace/trace_containers.h
index 9eb8f9ffad..5ba5233fe5 100644
--- a/src/vt/trace/trace_containers.h
+++ b/src/vt/trace/trace_containers.h
@@ -49,7 +49,6 @@
 #include "vt/trace/trace_common.h"
 #include "vt/trace/trace_event.h"
 
-#include <cstdint>
 #include <unordered_map>
 
 namespace vt { namespace trace {
@@ -59,25 +58,14 @@ using EventClassType = EventClass;
 using TraceContainerEventType = std::unordered_map<TraceEntryIDType, TraceEventType>;
 using TraceContainerEventClassType = std::unordered_map<TraceEntryIDType, EventClassType>;
 
-// Container types are created-as-needed, which occurs during
-// intialization to avoid intiailization ordering issues.
 class TraceContainers {
  public:
-  static TraceContainerEventClassType* getEventTypeContainer(){
-    if (not event_type_container_)
-      event_type_container_ = new TraceContainerEventClassType();
-    return event_type_container_;
-  }
-
-  static TraceContainerEventType* getEventContainer(){
-    if (not event_container_)
-      event_container_ = new TraceContainerEventType();
-    return event_container_;
-  }
-
- private:
-  static TraceContainerEventClassType* event_type_container_;
-  static TraceContainerEventType* event_container_;
+  /// Returns container of all registered event types (aka parents).
+  /// The returned pointer is only valid for the current scope.
+  static TraceContainerEventClassType* getEventTypeContainer();
+  /// Returns container of all registered event.
+  /// The returned pointer is only valid for the current scope.
+  static TraceContainerEventType* getEventContainer();
 };
 
 }} //end namespace vt::trace