8354954: Typed static memory for late initialization of static class members in Hotspot

Reviewed-by: qamai, kbarrett, jvernee

Author: johan-sjolen

src/hotspot/share/nmt/memTracker.cpp

@@ -41,6 +41,7 @@
 #include "runtime/vmThread.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/defaultStream.hpp"
+#include "utilities/deferred.hpp"
 #include "utilities/vmError.hpp"
 
 #ifdef _WINDOWS
@@ -49,7 +50,7 @@
 
 NMT_TrackingLevel MemTracker::_tracking_level = NMT_unknown;
 
-MemBaseline MemTracker::_baseline;
+Deferred<MemBaseline> MemTracker::_baseline;
 
 bool MemTracker::NmtVirtualMemoryLocker::_safe_to_use;
 
@@ -67,6 +68,7 @@ void MemTracker::initialize() {
   STATIC_ASSERT(mt_number_of_tags <= max_jubyte);
 
   if (level > NMT_off) {
+    _baseline.initialize();
     if (!MallocTracker::initialize(level) ||
         !MemoryFileTracker::Instance::initialize(level) ||
         !VirtualMemoryTracker::initialize(level)) {

src/hotspot/share/nmt/memTracker.hpp

@@ -27,21 +27,21 @@
 
 #include "memory/reservedSpace.hpp"
 #include "nmt/mallocTracker.hpp"
+#include "nmt/memBaseline.hpp"
 #include "nmt/nmtCommon.hpp"
 #include "nmt/memoryFileTracker.hpp"
 #include "nmt/threadStackTracker.hpp"
 #include "nmt/virtualMemoryTracker.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/nativeCallStack.hpp"
+#include "utilities/deferred.hpp"
 
 #define CURRENT_PC ((MemTracker::tracking_level() == NMT_detail) ? \
                     NativeCallStack(0) : FAKE_CALLSTACK)
 #define CALLER_PC  ((MemTracker::tracking_level() == NMT_detail) ?  \
                     NativeCallStack(1) : FAKE_CALLSTACK)
 
-class MemBaseline;
-
 class MemTracker : AllStatic {
   friend class VirtualMemoryTrackerTest;
 
@@ -266,7 +266,7 @@ class MemTracker : AllStatic {
 
   // Stored baseline
   static inline MemBaseline& get_baseline() {
-    return _baseline;
+    return *_baseline;
   }
 
   static void tuning_statistics(outputStream* out);
@@ -319,7 +319,7 @@ class MemTracker : AllStatic {
   // Tracking level
   static NMT_TrackingLevel   _tracking_level;
   // Stored baseline
-  static MemBaseline      _baseline;
+  static Deferred<MemBaseline>      _baseline;
 };
 
 #endif // SHARE_NMT_MEMTRACKER_HPP

src/hotspot/share/nmt/memoryFileTracker.cpp

@@ -32,7 +32,7 @@
 #include "utilities/nativeCallStack.hpp"
 #include "utilities/ostream.hpp"
 
-MemoryFileTracker* MemoryFileTracker::Instance::_tracker = nullptr;
+Deferred<MemoryFileTracker> MemoryFileTracker::Instance::_tracker;
 
 MemoryFileTracker::MemoryFileTracker(bool is_detailed_mode)
   : _stack_storage(is_detailed_mode), _files() {}
@@ -126,9 +126,8 @@ const GrowableArrayCHeap<MemoryFileTracker::MemoryFile*, mtNMT>& MemoryFileTrack
 
 bool MemoryFileTracker::Instance::initialize(NMT_TrackingLevel tracking_level) {
   if (tracking_level == NMT_TrackingLevel::NMT_off) return true;
-  _tracker = static_cast<MemoryFileTracker*>(os::malloc(sizeof(MemoryFileTracker), mtNMT));
-  if (_tracker == nullptr) return false;
-  new (_tracker) MemoryFileTracker(tracking_level == NMT_TrackingLevel::NMT_detail);
+  bool is_detailed_mode = tracking_level == NMT_TrackingLevel::NMT_detail;
+  _tracker.initialize(is_detailed_mode);
   return true;
 }
 

src/hotspot/share/nmt/memoryFileTracker.hpp

@@ -34,6 +34,7 @@
 #include "utilities/growableArray.hpp"
 #include "utilities/nativeCallStack.hpp"
 #include "utilities/ostream.hpp"
+#include "utilities/deferred.hpp"
 
 // The MemoryFileTracker tracks memory of 'memory files',
 // storage with its own memory space separate from the process.
@@ -91,7 +92,7 @@ class MemoryFileTracker {
   const GrowableArrayCHeap<MemoryFile*, mtNMT>& files();
 
   class Instance : public AllStatic {
-    static MemoryFileTracker* _tracker;
+    static Deferred<MemoryFileTracker> _tracker;
 
   public:
 

src/hotspot/share/utilities/deferred.hpp

@@ -0,0 +1,76 @@
+/*
+* Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+* or visit www.oracle.com if you need additional information or have any
+* questions.
+*
+*/
+
+#ifndef SHARE_UTILITIES_STABLEVALUE_HPP
+#define SHARE_UTILITIES_STABLEVALUE_HPP
+
+#include "globalDefinitions.hpp"
+#include <type_traits>
+
+// The purpose of this class is to defer initialization of a T to a later point in time,
+// and then to never deallocate it. This is mainly useful for deferring the initialization of
+// static fields in classes, in order to avoid "Static Initialization Order Fiasco".
+template<typename T>
+class Deferred {
+  union {
+    T _t;
+  };
+
+  DEBUG_ONLY(bool _initialized);
+
+public:
+  NONCOPYABLE(Deferred);
+
+  Deferred()
+  DEBUG_ONLY(: _initialized(false)) {
+    // Do not construct value, on purpose.
+  }
+
+  ~Deferred() {
+    // Do not destruct value, on purpose.
+  }
+
+  T* get() {
+    assert(_initialized, "must be initialized before access");
+    return &_t;
+  }
+
+  T& operator*() {
+    return *get();
+  }
+
+  T* operator->() {
+    return get();
+  }
+
+  template<typename... Ts>
+  void initialize(Ts&... args) {
+    assert(!_initialized, "Double initialization forbidden");
+    DEBUG_ONLY(_initialized = true);
+    using NCVP = std::add_pointer_t<std::remove_cv_t<T>>;
+    ::new (const_cast<NCVP>(get())) T(args...);
+  }
+};
+
+#endif // SHARE_UTILITIES_STABLEVALUE_HPP