I68TO2: 8232069: enable shutdown UseCompressedClassPointers && UseCompressedOops when CDS

Author: eapen

common/bin/compare.sh

@@ -290,7 +290,7 @@ compare_general_files() {
         ! -name "ct.sym" ! -name "*.diz" ! -name "*.dll" \
         ! -name "*.pdb" ! -name "*.exp" ! -name "*.ilk" \
         ! -name "*.lib" ! -name "*.war" ! -name "JavaControlPanel" \
-        ! -name "classes.jsa" \
+        ! -name "classes.jsa" | -name "classes_nocoops.jsa" \
         | $GREP -v "./bin/"  | $SORT | $FILTER)
 
     echo General files...

hotspot/src/share/vm/memory/filemap.cpp

@@ -241,6 +241,8 @@ void FileMapInfo::FileMapHeader::populate(FileMapInfo* mapinfo, size_t alignment
   _alignment = alignment;
   _obj_alignment = ObjectAlignmentInBytes;
 
+  _compressed_oops = UseCompressedOops;
+  _compressed_class_ptrs = UseCompressedClassPointers;
   if (!DynamicDumpSharedSpaces) {
     _classpath_entry_table_size = mapinfo->_classpath_entry_table_size;
     _classpath_entry_table = mapinfo->_classpath_entry_table;
@@ -987,6 +989,16 @@ bool FileMapInfo::FileMapHeader::validate() {
                   _obj_alignment, ObjectAlignmentInBytes);
     return false;
   }
+  if (PrintSharedSpaces) {
+    tty->print_cr("Archive was created with UseCompressedOops = %d, UseCompressedClassPointers = %d",
+                          compressed_oops(), compressed_class_pointers());
+  }
+
+  if (compressed_oops() != UseCompressedOops || compressed_class_pointers() != UseCompressedClassPointers) {
+    FileMapInfo::fail_continue("Unable to use shared archive.\nThe saved state of UseCompressedOops and UseCompressedClassPointers is "
+                               "different from runtime, CDS will be disabled.");
+    return false;
+  }
 
   return true;
 }

hotspot/src/share/vm/memory/filemap.hpp

@@ -105,6 +105,8 @@ class FileMapInfo : public CHeapObj<mtInternal> {
     size_t       _alignment;                // how shared archive should be aligned
     int          _obj_alignment;            // value of ObjectAlignmentInBytes
     bool         _is_default_jsa;           // indicates whether is the default jsa file
+    bool         _compressed_oops;          // save the flag UseCompressedOops
+    bool         _compressed_class_ptrs;    // save the flag UseCompressedClassPointers
 
     struct space_info {
       int    _crc;           // crc checksum of the current space
@@ -156,6 +158,8 @@ class FileMapInfo : public CHeapObj<mtInternal> {
     int compute_crc();
     unsigned int magic()                    const { return _magic; }
     const char* jvm_ident()                 const { return _jvm_ident; }
+    bool  compressed_oops()                 const { return _compressed_oops; }
+    bool  compressed_class_pointers()       const { return _compressed_class_ptrs; }
   };
 
   // Fixme

hotspot/src/share/vm/memory/metaspace.cpp

@@ -3634,25 +3634,33 @@ void Metaspace::global_initialize() {
     }
 
 #ifdef _LP64
-    if (cds_total + compressed_class_space_size() > UnscaledClassSpaceMax) {
-      vm_exit_during_initialization("Unable to dump shared archive.",
-          err_msg("Size of archive (" SIZE_FORMAT ") + compressed class space ("
-                  SIZE_FORMAT ") == total (" SIZE_FORMAT ") is larger than compressed "
-                  "klass limit: " SIZE_FORMAT, cds_total, compressed_class_space_size(),
-                  cds_total + compressed_class_space_size(), UnscaledClassSpaceMax));
-    }
+    if (UseCompressedClassPointers) {
+      if (cds_total + compressed_class_space_size() > UnscaledClassSpaceMax) {
+        vm_exit_during_initialization("Unable to dump shared archive.",
+            err_msg("Size of archive (" SIZE_FORMAT ") + compressed class space ("
+                    SIZE_FORMAT ") == total (" SIZE_FORMAT ") is larger than compressed "
+                    "klass limit: " SIZE_FORMAT, cds_total, compressed_class_space_size(),
+                    cds_total + compressed_class_space_size(), UnscaledClassSpaceMax));
+      }
 
-    // Set the compressed klass pointer base so that decoding of these pointers works
-    // properly when creating the shared archive.
-    assert(UseCompressedOops && UseCompressedClassPointers,
-      "UseCompressedOops and UseCompressedClassPointers must be set");
-    Universe::set_narrow_klass_base((address)_space_list->current_virtual_space()->bottom());
-    if (TraceMetavirtualspaceAllocation && Verbose) {
-      gclog_or_tty->print_cr("Setting_narrow_klass_base to Address: " PTR_FORMAT,
-                             _space_list->current_virtual_space()->bottom());
-    }
+      // Set the compressed klass pointer base so that decoding of these pointers works
+      // properly when creating the shared archive.
+      assert(UseCompressedOops && UseCompressedClassPointers,
+        "UseCompressedOops and UseCompressedClassPointers must be set");
+      Universe::set_narrow_klass_base((address)_space_list->current_virtual_space()->bottom());
+      if (TraceMetavirtualspaceAllocation && Verbose) {
+        gclog_or_tty->print_cr("Setting_narrow_klass_base to Address: " PTR_FORMAT,
+                               _space_list->current_virtual_space()->bottom());
+      }
 
-    Universe::set_narrow_klass_shift(0);
+      Universe::set_narrow_klass_shift(0);
+    } else {
+      if (cds_total > UnscaledClassSpaceMax) {
+        vm_exit_during_initialization("Unable to dump shared archive.",
+            err_msg("Size of archive (" SIZE_FORMAT ") is larger than compressed "
+                    "klass limit: " SIZE_FORMAT, cds_total, UnscaledClassSpaceMax));
+      }
+    }
 #endif // _LP64
 #endif // INCLUDE_CDS
   } else {

hotspot/src/share/vm/runtime/arguments.cpp

@@ -242,7 +242,9 @@ bool Arguments::init_shared_archive_paths() {
     }
   }
 
-  if (SharedArchiveFile != NULL) {
+  if (SharedArchiveFile == NULL) {
+    SharedArchivePath = get_default_shared_archive_path();
+  } else {
     int archives = num_archives(SharedArchiveFile);
     if (is_dumping_archive()) {
       if (archives > 1) {
@@ -4008,7 +4010,7 @@ jint Arguments::parse_options_environment_variable(const char* name, SysClassPat
   return JNI_OK;
 }
 
-void Arguments::set_shared_spaces_flags() {
+jint Arguments::set_shared_spaces_flags() {
   if (DumpSharedSpaces) {
     if (FailOverToOldVerifier) {
       // Don't fall back to the old verifier on verification failure. If a
@@ -4022,22 +4024,16 @@ void Arguments::set_shared_spaces_flags() {
       warning("cannot dump shared archive while using shared archive");
     }
     UseSharedSpaces = false;
-#ifdef _LP64
-    if (!UseCompressedOops || !UseCompressedClassPointers) {
-      vm_exit_during_initialization(
-        "Cannot dump shared archive when UseCompressedOops or UseCompressedClassPointers is off.", NULL);
-    }
-  } else {
-    if (!UseCompressedOops || !UseCompressedClassPointers) {
-      no_shared_spaces("UseCompressedOops and UseCompressedClassPointers must be on for UseSharedSpaces.");
-    }
-#endif
   }
 
 #if INCLUDE_CDS
   // Initialize shared archive paths which could include both base and dynamic archive paths
-  init_shared_archive_paths();
+  // This must be after set_ergonomics_flags() called so flag UseCompressedOops is set properly.
+  if(!init_shared_archive_paths()) {
+    return   JNI_ENOMEM;
+  }
 #endif  // INCLUDE_CDS
+  return JNI_OK;
 }
 
 #if !INCLUDE_ALL_GCS
@@ -4065,25 +4061,14 @@ char* Arguments::get_default_shared_archive_path() {
   const size_t len = jvm_path_len + file_sep_len + 20;
   default_archive_path = NEW_C_HEAP_ARRAY(char, len, mtInternal);
   if (default_archive_path != NULL) {
-    jio_snprintf(default_archive_path, len, "%s%sclasses.jsa",
+    jio_snprintf(default_archive_path, len,
+      UseCompressedClassPointers ? "%s%sclasses.jsa" : "%s%sclasses_nocoops.jsa",
       jvm_path, os::file_separator());
   }
   Arguments::set_is_default_jsa(true);
   return default_archive_path;
 }
 
-// Sharing support
-// Construct the path to the archive
-static char* get_shared_archive_path() {
-  char *shared_archive_path;
-  if (SharedArchiveFile == NULL) {
-    shared_archive_path = Arguments::get_default_shared_archive_path();
-  } else {
-    shared_archive_path = os::strdup(SharedArchiveFile, mtInternal);
-  }
-  return shared_archive_path;
-}
-
 
 #ifndef PRODUCT
 // Determine whether LogVMOutput should be implicitly turned on.
@@ -4221,13 +4206,6 @@ jint Arguments::parse(const JavaVMInitArgs* args) {
     return result;
   }
 
-  // Call get_shared_archive_path() here, after possible SharedArchiveFile option got parsed.
-  SharedArchivePath = get_shared_archive_path();
-  if (SharedArchivePath == NULL) {
-    return JNI_ENOMEM;
-  }
-
-
   // Set up VerifySharedSpaces
   if (FLAG_IS_DEFAULT(VerifySharedSpaces) && SharedArchiveFile != NULL) {
     VerifySharedSpaces = true;
@@ -4321,7 +4299,8 @@ jint Arguments::apply_ergo() {
   // Set flags based on ergonomics.
   set_ergonomics_flags();
 
-  set_shared_spaces_flags();
+  jint result = set_shared_spaces_flags();
+  if (result != JNI_OK) return result;
 
 #if defined(SPARC)
   // BIS instructions require 'membar' instruction regardless of the number

hotspot/src/share/vm/runtime/arguments.hpp

@@ -343,7 +343,7 @@ class Arguments : AllStatic {
   static void set_use_compressed_klass_ptrs();
   static void select_gc();
   static void set_ergonomics_flags();
-  static void set_shared_spaces_flags();
+  static jint set_shared_spaces_flags();
   // limits the given memory size by the maximum amount of memory this process is
   // currently allowed to allocate or reserve.
   static julong limit_by_allocatable_memory(julong size);

hotspot/test/runtime/CDSCompressedKPtrs/CDSCompressedKPtrsError.java

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, Huawei Technologies Co., Ltd. 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
@@ -64,9 +65,9 @@ private void initTestTable() {
             testTable.add( new TestVector("-XX:ObjectAlignmentInBytes=64", "-XX:ObjectAlignmentInBytes=32",
                     "An error has occurred while processing the shared archive file", 1) );
             testTable.add( new TestVector("-XX:+UseCompressedOops", "-XX:-UseCompressedOops",
-                    "Class data sharing is inconsistent with other specified options", 1) );
+                    "The saved state of UseCompressedOops and UseCompressedClassPointers is different from runtime, CDS will be disabled", 1) );
             testTable.add( new TestVector("-XX:+UseCompressedClassPointers", "-XX:-UseCompressedClassPointers",
-                    "Class data sharing is inconsistent with other specified options", 1) );
+                    "The saved state of UseCompressedOops and UseCompressedClassPointers is different from runtime, CDS will be disabled", 1) );
         }
     }
 

hotspot/test/runtime/appcds/CommandLineFlagComboNegative.java

@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, Huawei Technologies Co., Ltd. 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.
+ */
+
+/**
+ * @test
+ * @bug 8232069
+ * @summary Testing different combination of CompressedOops and CompressedClassPointers
+ * @requires (vm.gc=="null")
+ * @library /testlibrary
+ * @compile test-classes/Hello.java
+ * @run main/othervm  TestCombinedCompressedFlags
+ */
+
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.OutputAnalyzer;
+import java.util.List;
+import java.util.ArrayList;
+
+public class TestCombinedCompressedFlags {
+    public static String HELLO_STRING = "Hello World";
+    public static String EXEC_ABNORMAL_MSG = "Unable to use shared archive.";
+    public static final int PASS = 0;
+    public static final int FAIL = 1;
+
+    static class ConfArg {
+        public boolean useCompressedOops;            // UseCompressedOops
+        public boolean useCompressedClassPointers;   // UseCompressedClassPointers
+        public String  msg;
+        public int code;
+        public ConfArg(boolean useCompressedOops, boolean useCompressedClassPointers, String msg, int code) {
+            this.useCompressedOops = useCompressedOops;
+            this.useCompressedClassPointers = useCompressedClassPointers;
+            this.msg  = msg;
+            this.code = code;
+        }
+    }
+
+    static class RunArg {
+        public ConfArg dumpArg;
+        public List<ConfArg> execArgs;
+        public RunArg(ConfArg arg) {
+            dumpArg = arg;
+            initExecArgs();
+        }
+        private void initExecArgs() {
+           /* The combinations have four cases. Note COOP off, CCPTR must be off
+            *          UseCompressedOops   UseCompressedClassPointers  Result
+            *    1.
+            *    dump: on                  on
+            *    test: on                  on                          Pass
+            *          on                  off                         Fail
+            *          off                 on                          Fail
+            *          off                 off                         Fail
+            *    2.
+            *    dump: on                  off
+            *    test: on                  off                         Pass
+            *          on                  on                          Fail
+            *          off                 on                          Pass
+            *          off                 off                         Fail
+            *    3.
+            *    dump: off                 on
+            *    test: off                 on                          Pass
+            *          off                 off                         Pass
+            *          on                  on                          Fail
+            *          on                  off                         Fail
+            *    4.
+            *    dump: off                 off
+            *    test: off                 off                         Pass
+            *          off                 on                          Pass
+            *          on                  on                          Fail
+            *          on                  off                         Fail
+            **/
+            execArgs = new ArrayList<ConfArg>();
+            if (dumpArg.useCompressedOops && dumpArg.useCompressedClassPointers) {
+                execArgs
+                    .add(new ConfArg(true, true, HELLO_STRING, PASS));
+                execArgs
+                    .add(new ConfArg(true, false, EXEC_ABNORMAL_MSG, FAIL));
+                execArgs
+                    .add(new ConfArg(false, true, EXEC_ABNORMAL_MSG, FAIL));
+                execArgs
+                    .add(new ConfArg(false, false, EXEC_ABNORMAL_MSG, FAIL));
+
+            }  else if(dumpArg.useCompressedOops && !dumpArg.useCompressedClassPointers) {
+                execArgs
+                    .add(new ConfArg(true, false, HELLO_STRING, PASS));
+                execArgs
+                    .add(new ConfArg(true, true, EXEC_ABNORMAL_MSG, FAIL));
+                execArgs
+                    .add(new ConfArg(false, true, EXEC_ABNORMAL_MSG, FAIL));
+                execArgs
+                    .add(new ConfArg(false, false, EXEC_ABNORMAL_MSG, FAIL));
+
+            } else if (!dumpArg.useCompressedOops && dumpArg.useCompressedClassPointers) {
+                execArgs
+                    .add(new ConfArg(false, false, HELLO_STRING, PASS));
+                execArgs
+                    .add(new ConfArg(false, true, HELLO_STRING, PASS));
+                execArgs
+                    .add(new ConfArg(true, true, EXEC_ABNORMAL_MSG, FAIL));
+                execArgs
+                    .add(new ConfArg(true, false, EXEC_ABNORMAL_MSG, FAIL));
+            } else if (!dumpArg.useCompressedOops && !dumpArg.useCompressedClassPointers) {
+                execArgs
+                    .add(new ConfArg(false, false, HELLO_STRING, PASS));
+                execArgs
+                    .add(new ConfArg(false, true, HELLO_STRING, PASS));
+                execArgs
+                    .add(new ConfArg(true, true, EXEC_ABNORMAL_MSG, FAIL));
+                execArgs
+                    .add(new ConfArg(true, false, EXEC_ABNORMAL_MSG, FAIL));
+            }
+        }
+    }
+
+    public static String getCompressedOopsArg(boolean on) {
+        if (on) return "-XX:+UseCompressedOops";
+        else    return "-XX:-UseCompressedOops";
+    }
+
+    public static String getCompressedClassPointersArg(boolean on) {
+        if (on) return "-XX:+UseCompressedClassPointers";
+        else    return "-XX:-UseCompressedClassPointers";
+    }
+
+    public static List<RunArg> runList;
+
+    public static void configureRunArgs() {
+        runList = new ArrayList<RunArg>();
+        runList
+            .add(new RunArg(new ConfArg(true, true, null, PASS)));
+        runList
+            .add(new RunArg(new ConfArg(true, false, null, PASS)));
+        runList
+            .add(new RunArg(new ConfArg(false, true, null, PASS)));
+        runList
+            .add(new RunArg(new ConfArg(false, false, null, PASS)));
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (!Platform.is64bit()) {
+            System.out.println("Test case not applicable on 32-bit platforms");
+            return;
+
+        }
+
+        String helloJar = JarBuilder.build("hello", "Hello");
+        configureRunArgs();
+        OutputAnalyzer out;
+        for (RunArg t: runList) {
+            out = TestCommon
+                .dump(helloJar,
+                      new String[] {"Hello"},
+                      getCompressedOopsArg(t.dumpArg.useCompressedOops),
+                      getCompressedClassPointersArg(t.dumpArg.useCompressedClassPointers));
+            out.shouldContain("total   :  ");
+            out.shouldHaveExitValue(0);
+
+            for (ConfArg c : t.execArgs) {
+                out = TestCommon.exec(helloJar,
+                                      "-cp",
+                                      helloJar,
+                                      getCompressedOopsArg(c.useCompressedOops),
+                                      getCompressedClassPointersArg(c.useCompressedClassPointers),
+                                      "Hello");
+                out.shouldContain(c.msg);
+                out.shouldHaveExitValue(c.code);
+            }
+        }
+    }
+}

hotspot/test/runtime/appcds/TestCombinedCompressedFlags.java

@@ -106,8 +106,10 @@ images:
         ifeq ($(BUILD_CDS_ARCHIVE), true)
 	  echo Creating CDS archive for jdk image
 	  $(JDK_IMAGE_DIR)/bin/java -Xshare:dump -Xmx128M -Xms128M -XX:ParallelGCThreads=1 -Xint $(LOG_INFO)
+	  $(JDK_IMAGE_DIR)/bin/java -Xshare:dump -Xmx128M -Xms128M -XX:ParallelGCThreads=1 -Xint -XX:-UseCompressedOops $(LOG_INFO)
 	  echo Creating CDS archive for jre image
 	  $(JRE_IMAGE_DIR)/bin/java -Xshare:dump -Xmx128M -Xms128M -XX:ParallelGCThreads=1 -Xint $(LOG_INFO)
+	  $(JDK_IMAGE_DIR)/bin/java -Xshare:dump -Xmx128M -Xms128M -XX:ParallelGCThreads=1 -Xint -XX:-UseCompressedOops $(LOG_INFO)
         endif