8348349: Refactor CDSConfig::is_dumping_heap()

Reviewed-by: ccheung, matsaave

Author: iklam

src/hotspot/share/cds/archiveHeapWriter.cpp

@@ -78,7 +78,7 @@ static FillersTable* _fillers;
 static int _num_native_ptrs = 0;
 
 void ArchiveHeapWriter::init() {
-  if (HeapShared::can_write()) {
+  if (CDSConfig::is_dumping_heap()) {
     Universe::heap()->collect(GCCause::_java_lang_system_gc);
 
     _buffer_offset_to_source_obj_table = new BufferOffsetToSourceObjectTable(/*size (prime)*/36137, /*max size*/1 * M);
@@ -99,7 +99,7 @@ void ArchiveHeapWriter::add_source_obj(oop src_obj) {
 
 void ArchiveHeapWriter::write(GrowableArrayCHeap<oop, mtClassShared>* roots,
                               ArchiveHeapInfo* heap_info) {
-  assert(HeapShared::can_write(), "sanity");
+  assert(CDSConfig::is_dumping_heap(), "sanity");
   allocate_buffer();
   copy_source_objs_to_buffer(roots);
   set_requested_address(heap_info);

src/hotspot/share/cds/cdsConfig.cpp

@@ -46,6 +46,7 @@ bool CDSConfig::_is_using_full_module_graph = true;
 bool CDSConfig::_has_aot_linked_classes = false;
 bool CDSConfig::_has_archived_invokedynamic = false;
 bool CDSConfig::_old_cds_flags_used = false;
+bool CDSConfig::_disable_heap_dumping = false;
 
 char* CDSConfig::_default_archive_path = nullptr;
 char* CDSConfig::_static_archive_path = nullptr;
@@ -532,10 +533,53 @@ bool CDSConfig::current_thread_is_vm_or_dumper() {
   return t != nullptr && (t->is_VM_thread() || t == _dumper_thread);
 }
 
+// If an incompatible VM options is found, return a text message that explains why
+static const char* check_options_incompatible_with_dumping_heap() {
 #if INCLUDE_CDS_JAVA_HEAP
+  if (!UseCompressedClassPointers) {
+    return "UseCompressedClassPointers must be true";
+  }
+
+  // Almost all GCs support heap region dump, except ZGC (so far).
+  if (UseZGC) {
+    return "ZGC is not supported";
+  }
+
+  return nullptr;
+#else
+  return "JVM not configured for writing Java heap objects";
+#endif
+}
+
+void CDSConfig::log_reasons_for_not_dumping_heap() {
+  const char* reason;
+
+  assert(!is_dumping_heap(), "sanity");
+
+  if (_disable_heap_dumping) {
+    reason = "Programmatically disabled";
+  } else {
+    reason = check_options_incompatible_with_dumping_heap();
+  }
+
+  assert(reason != nullptr, "sanity");
+  log_info(cds)("Archived java heap is not supported: %s", reason);
+}
+
+#if INCLUDE_CDS_JAVA_HEAP
+bool CDSConfig::are_vm_options_incompatible_with_dumping_heap() {
+  return check_options_incompatible_with_dumping_heap() != nullptr;
+}
+
+
 bool CDSConfig::is_dumping_heap() {
-  // heap dump is not supported in dynamic dump
-  return is_dumping_static_archive() && HeapShared::can_write();
+  if (!is_dumping_static_archive() // heap dump is not supported in dynamic dump
+      || are_vm_options_incompatible_with_dumping_heap()
+      || _disable_heap_dumping) {
+    return false;
+  }
+
+  return true;
 }
 
 bool CDSConfig::is_loading_heap() {

src/hotspot/share/cds/cdsConfig.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 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
@@ -46,6 +46,7 @@ class CDSConfig : public AllStatic {
   static char* _dynamic_archive_path;
 
   static bool  _old_cds_flags_used;
+  static bool  _disable_heap_dumping;
 
   static JavaThread* _dumper_thread;
 #endif
@@ -116,6 +117,10 @@ class CDSConfig : public AllStatic {
 
   // --- Archived java objects
 
+  static bool are_vm_options_incompatible_with_dumping_heap() NOT_CDS_JAVA_HEAP_RETURN_(true);
+  static void log_reasons_for_not_dumping_heap();
+
+  static void disable_heap_dumping()                         { CDS_ONLY(_disable_heap_dumping = true); }
   static bool is_dumping_heap()                              NOT_CDS_JAVA_HEAP_RETURN_(false);
   static bool is_loading_heap()                              NOT_CDS_JAVA_HEAP_RETURN_(false);
   static bool is_initing_classes_at_dump_time()              NOT_CDS_JAVA_HEAP_RETURN_(false);

src/hotspot/share/cds/filemap.cpp

@@ -1601,7 +1601,7 @@ void FileMapInfo::write_region(int region, char* base, size_t size,
     // This is an unused region (e.g., a heap region when !INCLUDE_CDS_JAVA_HEAP)
     requested_base = nullptr;
   } else if (HeapShared::is_heap_region(region)) {
-    assert(HeapShared::can_write(), "sanity");
+    assert(CDSConfig::is_dumping_heap(), "sanity");
 #if INCLUDE_CDS_JAVA_HEAP
     assert(!CDSConfig::is_dumping_dynamic_archive(), "must be");
     requested_base = (char*)ArchiveHeapWriter::requested_address();

src/hotspot/share/cds/heapShared.cpp

@@ -86,7 +86,6 @@ struct ArchivableStaticFieldInfo {
   }
 };
 
-bool HeapShared::_disable_writing = false;
 DumpedInternedStrings *HeapShared::_dumped_interned_strings = nullptr;
 
 size_t HeapShared::_alloc_count[HeapShared::ALLOC_STAT_SLOTS];
@@ -236,9 +235,6 @@ int HeapShared::append_root(oop obj) {
 objArrayOop HeapShared::root_segment(int segment_idx) {
   if (CDSConfig::is_dumping_heap()) {
     assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread");
-    if (!HeapShared::can_write()) {
-      return nullptr;
-    }
   } else {
     assert(CDSConfig::is_using_archive(), "must be");
   }
@@ -714,7 +710,7 @@ void HeapShared::scan_java_class(Klass* orig_k) {
 }
 
 void HeapShared::archive_subgraphs() {
-  assert(HeapShared::can_write(), "must be");
+  assert(CDSConfig::is_dumping_heap(), "must be");
 
   archive_object_subgraphs(archive_subgraph_entry_fields,
                            false /* is_full_module_graph */);
@@ -1874,7 +1870,7 @@ void HeapShared::init_subgraph_entry_fields(ArchivableStaticFieldInfo fields[],
 }
 
 void HeapShared::init_subgraph_entry_fields(TRAPS) {
-  assert(HeapShared::can_write(), "must be");
+  assert(CDSConfig::is_dumping_heap(), "must be");
   _dump_time_subgraph_info_table = new (mtClass)DumpTimeKlassSubGraphInfoTable();
   init_subgraph_entry_fields(archive_subgraph_entry_fields, CHECK);
   if (CDSConfig::is_dumping_full_module_graph()) {
@@ -1963,7 +1959,7 @@ void HeapShared::initialize_test_class_from_archive(JavaThread* current) {
 #endif
 
 void HeapShared::init_for_dumping(TRAPS) {
-  if (HeapShared::can_write()) {
+  if (CDSConfig::is_dumping_heap()) {
     setup_test_class(ArchiveHeapTestClass);
     _dumped_interned_strings = new (mtClass)DumpedInternedStrings(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE);
     init_subgraph_entry_fields(CHECK);

src/hotspot/share/cds/heapShared.hpp

@@ -143,26 +143,6 @@ class HeapShared: AllStatic {
   friend class VerifySharedOopClosure;
 
 public:
-  // Can this VM write a heap region into the CDS archive?
-  static bool can_write() {
-    CDS_JAVA_HEAP_ONLY(
-      if (_disable_writing) {
-        return false;
-      }
-      // Need compressed class pointers for heap region dump.
-      if (!UseCompressedClassPointers) {
-        return false;
-      }
-      // Almost all GCs support heap region dump, except ZGC (so far).
-      return !UseZGC;
-    )
-    NOT_CDS_JAVA_HEAP(return false;)
-  }
-
-  static void disable_writing() {
-    CDS_JAVA_HEAP_ONLY(_disable_writing = true;)
-  }
-
   static bool is_subgraph_root_class(InstanceKlass* ik);
 
   // Scratch objects for archiving Klass::java_mirror()
@@ -173,7 +153,6 @@ class HeapShared: AllStatic {
 
 private:
 #if INCLUDE_CDS_JAVA_HEAP
-  static bool _disable_writing;
   static DumpedInternedStrings *_dumped_interned_strings;
 
   // statistics
@@ -377,7 +356,6 @@ class HeapShared: AllStatic {
   }
 
   static int archive_exception_instance(oop exception);
-  static void write_heap(ArchiveHeapInfo* heap_info);
 
   static bool archive_reachable_objects_from(int level,
                                              KlassSubGraphInfo* subgraph_info,
@@ -424,6 +402,7 @@ class HeapShared: AllStatic {
 #endif // INCLUDE_CDS_JAVA_HEAP
 
  public:
+  static void write_heap(ArchiveHeapInfo* heap_info) NOT_CDS_JAVA_HEAP_RETURN;
   static objArrayOop scratch_resolved_references(ConstantPool* src);
   static void add_scratch_resolved_references(ConstantPool* src, objArrayOop dest) NOT_CDS_JAVA_HEAP_RETURN;
   static void init_scratch_objects(TRAPS) NOT_CDS_JAVA_HEAP_RETURN;

src/hotspot/share/cds/metaspaceShared.cpp

@@ -552,7 +552,7 @@ class VM_PopulateDumpSharedSpace : public VM_Operation {
   FileMapInfo* _map_info;
   StaticArchiveBuilder& _builder;
 
-  void dump_java_heap_objects(GrowableArray<Klass*>* klasses) NOT_CDS_JAVA_HEAP_RETURN;
+  void dump_java_heap_objects();
   void dump_shared_symbol_table(GrowableArray<Symbol*>* symbols) {
     log_info(cds)("Dumping symbol table ...");
     SymbolTable::write_to_archive(symbols);
@@ -653,7 +653,7 @@ void VM_PopulateDumpSharedSpace::doit() {
   MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag);
 
 #if INCLUDE_CDS_JAVA_HEAP
-  if (HeapShared::can_write() && _extra_interned_strings != nullptr) {
+  if (CDSConfig::is_dumping_heap() && _extra_interned_strings != nullptr) {
     for (int i = 0; i < _extra_interned_strings->length(); i ++) {
       OopHandle string = _extra_interned_strings->at(i);
       HeapShared::add_to_dumped_interned_strings(string.resolve());
@@ -675,7 +675,7 @@ void VM_PopulateDumpSharedSpace::doit() {
   _builder.make_klasses_shareable();
   MetaspaceShared::make_method_handle_intrinsics_shareable();
 
-  dump_java_heap_objects(_builder.klasses());
+  dump_java_heap_objects();
   dump_shared_symbol_table(_builder.symbols());
 
   char* early_serialized_data = dump_early_read_only_tables();
@@ -1043,19 +1043,13 @@ bool MetaspaceShared::try_link_class(JavaThread* current, InstanceKlass* ik) {
   }
 }
 
-#if INCLUDE_CDS_JAVA_HEAP
-void VM_PopulateDumpSharedSpace::dump_java_heap_objects(GrowableArray<Klass*>* klasses) {
-  if (!HeapShared::can_write()) {
-    log_info(cds)(
-      "Archived java heap is not supported as UseG1GC "
-      "and UseCompressedClassPointers are required."
-      "Current settings: UseG1GC=%s, UseCompressedClassPointers=%s.",
-      BOOL_TO_STR(UseG1GC), BOOL_TO_STR(UseCompressedClassPointers));
-    return;
+void VM_PopulateDumpSharedSpace::dump_java_heap_objects() {
+  if (CDSConfig::is_dumping_heap()) {
+    HeapShared::write_heap(&_heap_info);
+  } else {
+    CDSConfig::log_reasons_for_not_dumping_heap();
   }
-  HeapShared::write_heap(&_heap_info);
 }
-#endif // INCLUDE_CDS_JAVA_HEAP
 
 void MetaspaceShared::set_shared_metaspace_range(void* base, void *static_top, void* top) {
   assert(base <= static_top && static_top <= top, "must be");

src/hotspot/share/classfile/classLoaderExt.cpp

@@ -341,7 +341,7 @@ void ClassLoaderExt::record_result(const s2 classpath_index, InstanceKlass* resu
     ResourceMark rm;
     log_warning(cds)("CDS heap objects cannot be written because class %s maybe modified by ClassFileLoadHook.",
                      result->external_name());
-    HeapShared::disable_writing();
+    CDSConfig::disable_heap_dumping();
   }
 #endif // INCLUDE_CDS_JAVA_HEAP
 }

src/hotspot/share/classfile/stringTable.cpp

@@ -1012,7 +1012,7 @@ void StringTable::verify_secondary_array_index_bits() {
 // [1] Store it into _shared_strings_array. Encode its position as a 32-bit index.
 // [2] Store the index and hashcode into _shared_table.
 oop StringTable::init_shared_strings_array(const DumpedInternedStrings* dumped_interned_strings) {
-  assert(HeapShared::can_write(), "must be");
+  assert(CDSConfig::is_dumping_heap(), "must be");
   objArrayOop array = (objArrayOop)(_shared_strings_array.resolve());
 
   verify_secondary_array_index_bits();

src/hotspot/share/prims/whitebox.cpp

@@ -2188,7 +2188,7 @@ WB_ENTRY(jboolean, WB_IsJVMCISupportedByGC(JNIEnv* env))
 WB_END
 
 WB_ENTRY(jboolean, WB_CanWriteJavaHeapArchive(JNIEnv* env))
-  return HeapShared::can_write();
+  return !CDSConfig::are_vm_options_incompatible_with_dumping_heap();
 WB_END