#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

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

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