8301106: Allow archived Java strings to be moved by GC

Reviewed-by: dholmes

Author: iklam

src/hotspot/share/cds/archiveHeapLoader.cpp

@@ -91,7 +91,7 @@ void ArchiveHeapLoader::fixup_regions() {
   } else if (_loading_failed) {
     fill_failed_loaded_heap();
   }
-  if (is_fully_available()) {
+  if (is_in_use()) {
     if (!MetaspaceShared::use_full_module_graph()) {
       // Need to remove all the archived java.lang.Module objects from HeapShared::roots().
       ClassLoaderDataShared::clear_archived_oops();
@@ -472,7 +472,7 @@ void ArchiveHeapLoader::finish_initialization() {
       verify_loaded_heap();
     }
   }
-  if (is_fully_available()) {
+  if (is_in_use()) {
     patch_native_pointers();
   }
 }

src/hotspot/share/cds/archiveHeapLoader.hpp

@@ -65,13 +65,7 @@ class ArchiveHeapLoader : AllStatic {
     NOT_CDS_JAVA_HEAP(return false;)
   }
 
-  static bool are_archived_strings_available() {
-    return is_loaded() || closed_regions_mapped();
-  }
-  static bool are_archived_mirrors_available() {
-    return is_fully_available();
-  }
-  static bool is_fully_available() {
+  static bool is_in_use() {
     return is_loaded() || is_mapped();
   }
 

src/hotspot/share/cds/archiveUtils.cpp

@@ -316,16 +316,16 @@ void ReadClosure::do_tag(int tag) {
 void ReadClosure::do_oop(oop *p) {
   if (UseCompressedOops) {
     narrowOop o = CompressedOops::narrow_oop_cast(nextPtr());
-    if (CompressedOops::is_null(o) || !ArchiveHeapLoader::is_fully_available()) {
+    if (CompressedOops::is_null(o) || !ArchiveHeapLoader::is_in_use()) {
       *p = nullptr;
     } else {
       assert(ArchiveHeapLoader::can_use(), "sanity");
-      assert(ArchiveHeapLoader::is_fully_available(), "must be");
+      assert(ArchiveHeapLoader::is_in_use(), "must be");
       *p = ArchiveHeapLoader::decode_from_archive(o);
     }
   } else {
     intptr_t dumptime_oop = nextPtr();
-    if (dumptime_oop == 0 || !ArchiveHeapLoader::is_fully_available()) {
+    if (dumptime_oop == 0 || !ArchiveHeapLoader::is_in_use()) {
       *p = nullptr;
     } else {
       assert(!ArchiveHeapLoader::is_loaded(), "ArchiveHeapLoader::can_load() is not supported for uncompessed oops");

src/hotspot/share/cds/heapShared.cpp

@@ -261,7 +261,7 @@ oop HeapShared::get_root(int index, bool clear) {
 void HeapShared::clear_root(int index) {
   assert(index >= 0, "sanity");
   assert(UseSharedSpaces, "must be");
-  if (ArchiveHeapLoader::is_fully_available()) {
+  if (ArchiveHeapLoader::is_in_use()) {
     if (log_is_enabled(Debug, cds, heap)) {
       oop old = roots()->obj_at(index);
       log_debug(cds, heap)("Clearing root %d: was " PTR_FORMAT, index, p2i(old));
@@ -378,8 +378,6 @@ void HeapShared::remove_scratch_objects(Klass* k) {
 }
 
 void HeapShared::archive_java_mirrors() {
-  init_seen_objects_table();
-
   for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
     BasicType bt = (BasicType)i;
     if (!is_reference_type(bt)) {
@@ -404,7 +402,7 @@ void HeapShared::archive_java_mirrors() {
     if (m != nullptr) {
       Klass* buffered_k = ArchiveBuilder::get_buffered_klass(orig_k);
       bool success = archive_reachable_objects_from(1, _default_subgraph_info, m, /*is_closed_archive=*/ false);
-      guarantee(success, "scratch mirrors should not point to any unachivable objects");
+      guarantee(success, "scratch mirrors must point to only archivable objects");
       buffered_k->set_archived_java_mirror(append_root(m));
       ResourceMark rm;
       log_trace(cds, heap, mirror)(
@@ -425,8 +423,16 @@ void HeapShared::archive_java_mirrors() {
       }
     }
   }
+}
 
-  delete_seen_objects_table();
+void HeapShared::archive_strings() {
+  oop shared_strings_array = StringTable::init_shared_table(_dumped_interned_strings);
+  bool success = archive_reachable_objects_from(1, _default_subgraph_info, shared_strings_array, /*is_closed_archive=*/ false);
+  // We must succeed because:
+  // - _dumped_interned_strings do not contain any large strings.
+  // - StringTable::init_shared_table() doesn't create any large arrays.
+  assert(success, "shared strings array must not point to arrays or strings that are too large to archive");
+  StringTable::set_shared_strings_array_index(append_root(shared_strings_array));
 }
 
 void HeapShared::mark_native_pointers(oop orig_obj) {
@@ -501,7 +507,7 @@ void HeapShared::check_enum_obj(int level,
 
 // See comments in HeapShared::check_enum_obj()
 bool HeapShared::initialize_enum_klass(InstanceKlass* k, TRAPS) {
-  if (!ArchiveHeapLoader::is_fully_available()) {
+  if (!ArchiveHeapLoader::is_in_use()) {
     return false;
   }
 
@@ -556,22 +562,20 @@ void HeapShared::archive_objects(GrowableArray<MemRegion>* closed_regions,
   }
 
   ArchiveHeapWriter::write(_pending_roots, closed_regions, open_regions, closed_bitmaps, open_bitmaps);
-  StringTable::write_shared_table(_dumped_interned_strings);
 }
 
 void HeapShared::copy_interned_strings() {
   init_seen_objects_table();
 
   auto copier = [&] (oop s, bool value_ignored) {
     assert(s != nullptr, "sanity");
-    if (!ArchiveHeapWriter::is_string_too_large_to_archive(s)) {
-      bool success = archive_reachable_objects_from(1, _default_subgraph_info,
-                                                    s, /*is_closed_archive=*/true);
-      assert(success, "must be");
-      // Prevent string deduplication from changing the value field to
-      // something not in the archive.
-      java_lang_String::set_deduplication_forbidden(s);
-    }
+    assert(!ArchiveHeapWriter::is_string_too_large_to_archive(s), "large strings must have been filtered");
+    bool success = archive_reachable_objects_from(1, _default_subgraph_info,
+                                                  s, /*is_closed_archive=*/true);
+    assert(success, "string must be short enough to be archived");
+    // Prevent string deduplication from changing the value field to
+    // something not in the archive.
+    java_lang_String::set_deduplication_forbidden(s);
   };
   _dumped_interned_strings->iterate_all(copier);
 
@@ -589,10 +593,18 @@ void HeapShared::copy_closed_objects() {
                            false /* is_full_module_graph */);
 }
 
+void HeapShared::copy_special_open_objects() {
+  // Archive special objects that do not belong to any subgraphs
+  init_seen_objects_table();
+  archive_java_mirrors();
+  archive_strings();
+  delete_seen_objects_table();
+}
+
 void HeapShared::copy_open_objects() {
   assert(HeapShared::can_write(), "must be");
 
-  archive_java_mirrors();
+  copy_special_open_objects();
 
   archive_object_subgraphs(open_archive_subgraph_entry_fields,
                            false /* is_closed_archive */,
@@ -861,7 +873,7 @@ void HeapShared::serialize_root(SerializeClosure* soc) {
     assert(oopDesc::is_oop_or_null(roots_oop), "is oop");
     // Create an OopHandle only if we have actually mapped or loaded the roots
     if (roots_oop != nullptr) {
-      assert(ArchiveHeapLoader::is_fully_available(), "must be");
+      assert(ArchiveHeapLoader::is_in_use(), "must be");
       _roots = OopHandle(Universe::vm_global(), roots_oop);
     }
   } else {
@@ -921,7 +933,7 @@ static void verify_the_heap(Klass* k, const char* which) {
 // this case, we will not load the ArchivedKlassSubGraphInfoRecord and will clear its roots.
 void HeapShared::resolve_classes(JavaThread* current) {
   assert(UseSharedSpaces, "runtime only!");
-  if (!ArchiveHeapLoader::is_fully_available()) {
+  if (!ArchiveHeapLoader::is_in_use()) {
     return; // nothing to do
   }
   resolve_classes_for_subgraphs(current, closed_archive_subgraph_entry_fields);
@@ -954,7 +966,7 @@ void HeapShared::resolve_classes_for_subgraph_of(JavaThread* current, Klass* k)
 
 void HeapShared::initialize_from_archived_subgraph(JavaThread* current, Klass* k) {
   JavaThread* THREAD = current;
-  if (!ArchiveHeapLoader::is_fully_available()) {
+  if (!ArchiveHeapLoader::is_in_use()) {
     return; // nothing to do
   }
 

src/hotspot/share/cds/heapShared.hpp

@@ -344,6 +344,7 @@ class HeapShared: AllStatic {
   static void mark_native_pointers(oop orig_obj);
   static bool has_been_archived(oop orig_obj);
   static void archive_java_mirrors();
+  static void archive_strings();
  public:
   static void reset_archived_object_states(TRAPS);
   static void create_archived_object_cache() {
@@ -364,6 +365,7 @@ class HeapShared: AllStatic {
                               GrowableArray<ArchiveHeapBitmapInfo>* open_bitmaps);
   static void copy_closed_objects();
   static void copy_open_objects();
+  static void copy_special_open_objects();
 
   static bool archive_reachable_objects_from(int level,
                                              KlassSubGraphInfo* subgraph_info,

src/hotspot/share/cds/metaspaceShared.cpp

@@ -801,6 +801,7 @@ void MetaspaceShared::preload_and_dump_impl(TRAPS) {
   log_info(cds)("Rewriting and linking classes: done");
 
 #if INCLUDE_CDS_JAVA_HEAP
+  StringTable::allocate_shared_strings_array(CHECK);
   ArchiveHeapWriter::init();
   if (use_full_module_graph()) {
     HeapShared::reset_archived_object_states(CHECK);
@@ -1437,9 +1438,6 @@ void MetaspaceShared::initialize_shared_spaces() {
   ReadClosure rc(&array);
   serialize(&rc);
 
-  // Initialize the run-time symbol table.
-  SymbolTable::create_table();
-
   // Finish up archived heap initialization. These must be
   // done after ReadClosure.
   static_mapinfo->patch_heap_embedded_pointers();

src/hotspot/share/classfile/javaClasses.cpp

@@ -889,7 +889,7 @@ void java_lang_Class::fixup_mirror(Klass* k, TRAPS) {
   }
 
   if (k->is_shared() && k->has_archived_mirror_index()) {
-    if (ArchiveHeapLoader::are_archived_mirrors_available()) {
+    if (ArchiveHeapLoader::is_in_use()) {
       bool present = restore_archived_mirror(k, Handle(), Handle(), Handle(), CHECK);
       assert(present, "Missing archived mirror for %s", k->external_name());
       return;