8385359: [CRaC] aarch64: c7g.medium <-> c8g.medium FAIL: vector length

src/hotspot/cpu/aarch64/vm_version_aarch64.cpp

@@ -63,6 +63,7 @@
   GLIBC_UNSUPPORTED(A53MAC    ); \
   GLIBC_UNSUPPORTED(ECV       ); \
   GLIBC_UNSUPPORTED(WFXT      ); \
+  GLIBC_UNSUPPORTED(SVE256    ); \
   GLIBC_UNSUPPORTED(NOTPACA   ); \
   /**/
 #include "runtime/abstract_vm_version.inline.hpp"
@@ -930,3 +931,32 @@ void VM_Version::CPUFeatures_apply_arch(VM_Features &parsed, VM_Features &missin
   missing.clear_feature(CPU_PACA);
   missing.clear_feature(CPU_NOTPACA);
 }
+
+bool VM_Version::restore_pre(VM_Features image_features, const char *image_location) {
+  bool boolvalue = image_features.supports_feature(CPU_SVE256);
+  if (boolvalue == _cpu_features.supports_feature(CPU_SVE256)) {
+    return true;
+  }
+  if (boolvalue && !_cpu_features.supports_feature(CPU_SVE256)) {
+    ResourceMark rm;
+    stringStream ss;
+    VM_Features sve256;
+    sve256.set_feature(CPU_SVE256);
+    VM_Features use = image_features & _cpu_features;
+    log_error(crac)("Image %s has -XX:CPUFeatures=%s with CPU_SVE256=%s, this CPU has CPUFeatures=%s not supporting CPU_SVE256, use -XX:CPUFeatures=%s during snapshot",
+                    image_location, image_features.print_numbers(), sve256.print_numbers(), _cpu_features.print_numbers(), use.print_numbers());
+    return false;
+  }
+  errno = 0;
+  int got = set_and_get_current_sve_vector_length(16);
+  if (got != 16) {
+    ResourceMark rm;
+    stringStream ss;
+    VM_Features sve256;
+    sve256.set_feature(CPU_SVE256);
+    log_error(crac)("Image %s has -XX:CPUFeatures=%s with CPU_SVE256=%s unset, this CPU has CPUFeatures=%s but PR_SVE_SET_VL reports %d: %m",
+                    image_location, image_features.print_numbers(), sve256.print_numbers(), _cpu_features.print_numbers(), got);
+    return false;
+  }
+  return true;
+}

src/hotspot/cpu/aarch64/vm_version_aarch64.hpp

@@ -59,6 +59,7 @@ class VM_Feature_Flag {
     decl(ECV,           ecv,        21) \
     decl(WFXT,          wfxt,       22) \
     /* These features are added for CRaC. */ \
+    decl(SVE256,        sve256,     62) \
     decl(NOTPACA,       notpaca,    63) \
     /**/
 
@@ -68,7 +69,7 @@ class VM_Feature_Flag {
   #undef DECLARE_CPU_FEATURE_FLAG
     MAX_CPU_FEATURES,
     LAST_CPU_FEATURE = CPU_WFXT,
-    FIRST_GLIBC_FEATURE = CPU_NOTPACA
+    FIRST_GLIBC_FEATURE = CPU_SVE256
   };
 };
 
@@ -142,6 +143,8 @@ class VM_Version : public Abstract_VM_Version, public VM_Feature_Flag {
   static void insert_features_names(VM_Version::VM_Features features, outputStream& os);
   // The returned string needs a ResourceMark.
   static const char *restore_failed_check(const VM_Features *image_features, const VM_Features *current_features);
+  static bool restore_pre(VM_Features image_features, const char *image_location);
+  static constexpr bool restore_pre_needed = true;
 
   static void print_platform_virtualization_info(outputStream*);
 

src/hotspot/cpu/x86/vm_version_x86.hpp

@@ -732,6 +732,10 @@ class VM_Version : public Abstract_VM_Version, protected VM_Feature_Flag {
   static const char *restore_failed_check(const VM_Features *image_features, const VM_Features *current_features) {
     return nullptr;
   }
+  static bool restore_pre(VM_Features image_features, const char *image_location) {
+    return false;
+  }
+  static constexpr bool restore_pre_needed = false;
 
   static bool os_supports_avx_vectors();
   static bool os_supports_apx_egprs();

src/hotspot/cpu/zero/vm_version_zero.hpp

@@ -38,6 +38,10 @@ class VM_Version : public Abstract_VM_Version {
   static const char *restore_failed_check(const VM_Features *image_features, const VM_Features *current_features) {
     return nullptr;
   }
+  static bool restore_pre(VM_Features image_features, const char *image_location) {
+    return false;
+  }
+  static constexpr bool restore_pre_needed = false;
 
   constexpr static bool supports_stack_watermark_barrier() { return true; }
 

src/hotspot/os_cpu/linux_aarch64/vm_version_linux_aarch64.cpp

@@ -24,6 +24,7 @@
  */
 
 #include "memory/resourceArea.hpp"
+#include "runtime/globals_extension.hpp"
 #include "runtime/java.hpp"
 #include "runtime/os.hpp"
 #include "runtime/os.inline.hpp"
@@ -120,9 +121,12 @@ int VM_Version::get_current_sve_vector_length() {
   return prctl(PR_SVE_GET_VL);
 }
 
+// Limit what set_and_get_current_sve_vector_length is willing to set.
+static int maximum_sve_vector_length = INT_MAX;
+
 int VM_Version::set_and_get_current_sve_vector_length(int length) {
   assert(VM_Version::supports_sve(), "should not call this");
-  int new_length = prctl(PR_SVE_SET_VL, length);
+  int new_length = prctl(PR_SVE_SET_VL, MIN2(length, maximum_sve_vector_length));
   return new_length;
 }
 
@@ -163,6 +167,10 @@ void VM_Version::get_os_cpu_info() {
   update_feature(auxv2, CPU_WFXT,       HWCAP2_WFXT      );
   update_feature(~auxv, CPU_NOTPACA,    HWCAP_PACA       );
 
+  if (supports_sve() && get_current_sve_vector_length() == 32) {
+    set_feature(CPU_SVE256);
+  }
+
   uint64_t ctr_el0;
   uint64_t dczid_el0;
   __asm__ (
@@ -226,6 +234,26 @@ void VM_Version::check_os_cpu_info() {
     // GLIBC_TUNABLES=glibc.cpu.hwcaps is unsupported on aarch64
     vm_exit_during_initialization(err_msg("LSE (%s) cannot be disabled via -XX:CPUFeatures on aarch64.", lse.print_numbers()));
   }
+  if (FLAG_IS_DEFAULT(CPUFeatures)) {
+    assert(_cpu_features.supports_feature(CPU_SVE256) == _features.supports_feature(CPU_SVE256), "CPU_SVE256 is not changed");
+  } else if (!_cpu_features.supports_feature(CPU_SVE256) && _features.supports_feature(CPU_SVE256)) {
+    stringStream ss;
+    VM_Features sve256;
+    sve256.set_feature(VM_Feature_Flag::CPU_SVE256);
+    ss.print("Specified -XX:CPUFeatures=%s have CPU_SVE256=%s set but this CPU does not support it", _features.print_numbers(), sve256.print_numbers());
+    vm_exit_during_initialization(ss.base());
+  } else if (_cpu_features.supports_feature(CPU_SVE256) && !_features.supports_feature(CPU_SVE256)) {
+    maximum_sve_vector_length = 16;
+    int got = set_and_get_current_sve_vector_length(maximum_sve_vector_length);
+    if (got != maximum_sve_vector_length) {
+      stringStream ss;
+      VM_Features sve256;
+      sve256.set_feature(VM_Feature_Flag::CPU_SVE256);
+      ss.print("Specified -XX:CPUFeatures=%s have unset CPU_SVE256=%s, this CPU has CPUFeatures=%s but it cannot be disabled as PR_SVE_SET_VL reports %d: %m",
+               _features.print_numbers(), sve256.print_numbers(), _cpu_features.print_numbers(), got);
+      vm_exit_during_initialization(ss.base());
+    }
+  }
 }
 
 static bool read_fully(const char *fname, char *buf, size_t buflen) {

src/hotspot/share/runtime/crac_engine.cpp

@@ -378,11 +378,96 @@
   return _api->checkpoint(_conf);
 }
 
+static inline unsigned char from_hex(char c, bool* err) {
+  if (c >= '0' && c <= '9') {
+    return c - '0';
+  } else if (c >= 'a' && c <= 'f') {
+    return c - 'a' + 10;
+  } else {
+    *err = true;
+    return 0;
+  }
+}
+
+static constexpr char cpufeatures_prefix[] = "bitmap:cpu.features";
+
+// FIXME: Replace "tags" parsing by a new constraint reader method call.
+bool CracEngine::restore_pre_core(FILE *f) const {
+  static constexpr const size_t _MAX_VALUE_SIZE = 256;
+  char line[sizeof(cpufeatures_prefix) + 1 + _MAX_VALUE_SIZE + 2];
+  while (fgets(line, (int) sizeof(line), f)) {
+    char* eq = strchr((char *) line, '=');
+    char* nl = strchr((char *) (eq + 1), '\n');
+    if (eq == nullptr || nl == nullptr) {
+      log_error(crac)("Invalid format of tags file of image %s: %s", _image_location, line);
+      return false;
+    }
+    *eq = 0;
+    *nl = 0;
+    if (eq < nl && !strncmp(line, cpufeatures_prefix, strlen(cpufeatures_prefix)) && eq - line == strlen(cpufeatures_prefix)) {
+      size_t length = (size_t)(nl - eq - 1)/2;
+      if (2 * length != (size_t)(nl - eq - 1)) {
+        log_error(crac)("Invalid format of tags file (bad bitmap) of image %s: %s", _image_location, line);
+        return false;
+      }
+      union {
+	VM_Version::VM_Features features;
+	uint8_t bytes[sizeof(VM_Version::VM_Features)] = { 0 };
+      } u;
+      bool err = false;
+      for (size_t i = 0; i < length; ++i) {
+        u.bytes[i] = (from_hex(eq[1 + 2 * i], &err) << 4) + from_hex(eq[2 + 2 * i], &err);
+      }
+      if (err) {
+        log_error(crac)("Invalid format of tags file (bad character in bitmap): %s", line);
+        return false;
+      }
+      return VM_Version::restore_pre(u.features, _image_location);
+    }
+  }
+  log_error(crac)("%s not found in image %s", cpufeatures_prefix, _image_location);
+  return false;
+}
+
+static FILE* open_tags(const char* image_location, const char* mode) {
+  char fname[PATH_MAX];
+  if (os::snprintf(fname, sizeof(fname), "%s/tags", image_location) >= (int) sizeof(fname) - 1) {
+    log_error(crac)("filename too long: %s/tags", image_location);
+    return nullptr;
+  }
+  FILE* f = fopen(fname, mode);
+  if (f == nullptr) {
+    log_error(crac)("cannot open %s in mode %s: %s", fname, mode, os::strerror(errno));
+    return nullptr;
+  }
+  return f;
+}
+
+bool CracEngine::restore_pre() const {
+  if (!VM_Version::restore_pre_needed) {
+    return true;
+  }
+  FILE* f = open_tags(_image_location, "r");
+  if (f == nullptr) {
+    log_error(crac)("Cannot open tags for image %s", _image_location);
+    return false;
+  }
+  bool retval = restore_pre_core(f);
+  if (fclose(f)) {
+    log_error(crac)("cannot close %s/tags: %s", _image_location, os::strerror(errno));
+    return false;
+  }
+  return retval;
+}
+
 int CracEngine::restore() const {
   precond(is_initialized());
   if (!check_engine(_name, _image_location)) {
     return -1;
   }
+  if (!restore_pre()) {
+    return -1;
+  }
   return _api->restore(_conf);
 }
 

src/hotspot/share/runtime/crac_engine.hpp

@@ -92,6 +92,9 @@ class CracEngine : public CHeapObj<mtInternal> {
   crlib_image_score_t *_image_score_api = nullptr;
 
   crlib_conf_option_t *_options = nullptr;
+
+  bool restore_pre() const;
+  bool restore_pre_core(FILE *f) const;
 };
 
 #endif // SHARE_RUNTIME_CRAC_ENGINE_HPP

test/jdk/jdk/crac/CPUFeatures/CPUFeaturesAWS.sh

@@ -345,11 +345,12 @@ checkpoint_restore "$LINENO" a1.medium t4g.micro
 checkpoint_restore "$LINENO" t4g.micro a1.medium "1:Restore failed due to incompatible or missing CPU features, try using -XX:CPUFeatures=0x80000000000000ff on checkpoint."
 checkpoint_restore "$LINENO" t4g.micro a1.medium "-1:LSE (0x100) cannot be disabled via -XX:CPUFeatures on aarch64." "-XX:CPUFeatures=0x80000000000000ff" ""
 
-# JDK-8385359: checkpoint_restore "$LINENO" c7g.medium c7g.medium
-# JDK-8385359: checkpoint_restore "$LINENO" c8g.medium c8g.medium
-# JDK-8385359: checkpoint_restore "$LINENO" c7g.medium c8g.medium
+checkpoint_restore "$LINENO" c7g.medium c7g.medium
+checkpoint_restore "$LINENO" c8g.medium c8g.medium
+checkpoint_restore "$LINENO" c7g.medium c8g.medium "1:Image cr has -XX:CPUFeatures=0x4000000000017fff with CPU_SVE256=0x4000000000000000, this CPU has CPUFeatures=0x77fff not supporting CPU_SVE256, use -XX:CPUFeatures=0x17fff during snapshot"
+checkpoint_restore "$LINENO" c7g.medium c8g.medium "" "-XX:CPUFeatures=0x17fff" ""
 checkpoint_restore "$LINENO" c8g.medium c7g.medium "1:Restore failed due to incompatible or missing CPU features, try using -XX:CPUFeatures=0x17fff on checkpoint."
-# JDK-8385359: checkpoint_restore "$LINENO" c8g.medium c7g.medium "" "-XX:CPUFeatures=0x17fff" ""
+checkpoint_restore "$LINENO" c8g.medium c7g.medium "" "-XX:CPUFeatures=0x17fff" ""
 
 checkpoint_restore "$LINENO" t4g.micro c8g.medium "1:Restore failed due to incompatible aarch64 CPU feature PACA (0x10000); these CPUs each require a separate image."
 checkpoint_restore "$LINENO" c8g.medium t4g.micro "1:Restore failed due to incompatible aarch64 CPU feature PACA (0x10000); these CPUs each require a separate image."