8304301: Remove the global option SuperWordMaxVectorSize

Reviewed-by: sviswanathan, kvn

Author: Fei Gao

src/hotspot/cpu/aarch64/aarch64.ad

@@ -2375,6 +2375,10 @@ const int Matcher::min_vector_size(const BasicType bt) {
   return MIN2(size, max_size);
 }
 
+const int Matcher::superword_max_vector_size(const BasicType bt) {
+  return Matcher::max_vector_size(bt);
+}
+
 // Actual max scalable vector register length.
 const int Matcher::scalable_vector_reg_size(const BasicType bt) {
   return Matcher::max_vector_size(bt);

src/hotspot/cpu/arm/arm.ad

@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2008, 2022, Oracle and/or its affiliates. All rights reserved.
+// Copyright (c) 2008, 2023, 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
@@ -1074,6 +1074,10 @@ const int Matcher::min_vector_size(const BasicType bt) {
   return 8/type2aelembytes(bt);
 }
 
+const int Matcher::superword_max_vector_size(const BasicType bt) {
+  return Matcher::max_vector_size(bt);
+}
+
 // Is this branch offset short enough that a short branch can be used?
 //
 // NOTE: If the platform does not provide any short branch variants, then

src/hotspot/cpu/ppc/ppc.ad

@@ -2239,6 +2239,10 @@ const int Matcher::min_vector_size(const BasicType bt) {
   return max_vector_size(bt); // Same as max.
 }
 
+const int Matcher::superword_max_vector_size(const BasicType bt) {
+  return Matcher::max_vector_size(bt);
+}
+
 const int Matcher::scalable_vector_reg_size(const BasicType bt) {
   return -1;
 }

src/hotspot/cpu/riscv/riscv.ad

@@ -1945,6 +1945,10 @@ const int Matcher::min_vector_size(const BasicType bt) {
   return MIN2(size, max_size);
 }
 
+const int Matcher::superword_max_vector_size(const BasicType bt) {
+  return Matcher::max_vector_size(bt);
+}
+
 // Vector ideal reg.
 const uint Matcher::vector_ideal_reg(int len) {
   assert(MaxVectorSize >= len, "");

src/hotspot/cpu/s390/s390.ad

@@ -1571,6 +1571,10 @@ const int Matcher::min_vector_size(const BasicType bt) {
   return max_vector_size(bt); // Same as max.
 }
 
+const int Matcher::superword_max_vector_size(const BasicType bt) {
+  return Matcher::max_vector_size(bt);
+}
+
 const int Matcher::scalable_vector_reg_size(const BasicType bt) {
   return -1;
 }

src/hotspot/cpu/x86/vm_version_x86.cpp

@@ -1312,27 +1312,6 @@ void VM_Version::get_processor_features() {
     FLAG_SET_DEFAULT(MaxVectorSize, max_vector_size);
   }
 
-#if defined(COMPILER2)
-  if (FLAG_IS_DEFAULT(SuperWordMaxVectorSize)) {
-    if (FLAG_IS_DEFAULT(UseAVX) && UseAVX > 2 &&
-        is_intel_skylake() && _stepping >= 5) {
-      // Limit auto vectorization to 256 bit (32 byte) by default on Cascade Lake
-      FLAG_SET_DEFAULT(SuperWordMaxVectorSize, MIN2(MaxVectorSize, (intx)32));
-    } else {
-      FLAG_SET_DEFAULT(SuperWordMaxVectorSize, MaxVectorSize);
-    }
-  } else {
-    if (SuperWordMaxVectorSize > MaxVectorSize) {
-      warning("SuperWordMaxVectorSize cannot be greater than MaxVectorSize %i", (int) MaxVectorSize);
-      FLAG_SET_DEFAULT(SuperWordMaxVectorSize, MaxVectorSize);
-    }
-    if (!is_power_of_2(SuperWordMaxVectorSize)) {
-      warning("SuperWordMaxVectorSize must be a power of 2, setting to MaxVectorSize: %i", (int) MaxVectorSize);
-      FLAG_SET_DEFAULT(SuperWordMaxVectorSize, MaxVectorSize);
-    }
-  }
-#endif
-
 #if defined(COMPILER2) && defined(ASSERT)
   if (MaxVectorSize > 0) {
     if (supports_avx() && PrintMiscellaneous && Verbose && TraceNewVectors) {
@@ -2094,6 +2073,17 @@ void VM_Version::check_virtualizations() {
   }
 }
 
+#ifdef COMPILER2
+// Determine if it's running on Cascade Lake using default options.
+bool VM_Version::is_default_intel_cascade_lake() {
+  return FLAG_IS_DEFAULT(UseAVX) &&
+         FLAG_IS_DEFAULT(MaxVectorSize) &&
+         UseAVX > 2 &&
+         is_intel_skylake() &&
+         _stepping >= 5;
+}
+#endif
+
 // avx3_threshold() sets the threshold at which 64-byte instructions are used
 // for implementing the array copy and clear operations.
 // The Intel platforms that supports the serialize instruction

src/hotspot/cpu/x86/vm_version_x86.hpp

@@ -711,6 +711,11 @@ class VM_Version : public Abstract_VM_Version {
   static bool is_intel_skylake() { return is_intel_family_core() &&
                                           extended_cpu_model() == CPU_MODEL_SKYLAKE; }
 
+#ifdef COMPILER2
+  // Determine if it's running on Cascade Lake using default options.
+  static bool is_default_intel_cascade_lake();
+#endif
+
   static int avx3_threshold();
 
   static bool is_intel_tsc_synched_at_init();

src/hotspot/cpu/x86/x86.ad

@@ -2296,6 +2296,15 @@ const int Matcher::min_vector_size(const BasicType bt) {
   return MIN2(size,max_size);
 }
 
+const int Matcher::superword_max_vector_size(const BasicType bt) {
+  // Limit the max vector size for auto vectorization to 256 bits (32 bytes)
+  // by default on Cascade Lake
+  if (VM_Version::is_default_intel_cascade_lake()) {
+    return MIN2(Matcher::max_vector_size(bt), 32 / type2aelembytes(bt));
+  }
+  return Matcher::max_vector_size(bt);
+}
+
 const int Matcher::scalable_vector_reg_size(const BasicType bt) {
   return -1;
 }

src/hotspot/share/opto/c2_globals.hpp

@@ -82,11 +82,6 @@
           "actual size could be less depending on elements type")           \
           range(0, max_jint)                                                \
                                                                             \
-  product(intx, SuperWordMaxVectorSize, 64, DIAGNOSTIC,                     \
-          "Vector size limit in bytes for superword, "                      \
-          "superword vector size limit in bytes")                           \
-          range(0, max_jint)                                                \
-                                                                            \
   product(intx, ArrayOperationPartialInlineSize, 0, DIAGNOSTIC,             \
           "Partial inline size used for small array operations"             \
           "(e.g. copy,cmp) acceleration.")                                  \

src/hotspot/share/opto/matcher.hpp

@@ -351,6 +351,8 @@ class Matcher : public PhaseTransform {
     return (Matcher::max_vector_size(bt) >= size &&
             Matcher::min_vector_size(bt) <= size);
   }
+  // Limits on max vector size (number of elements) for auto-vectorization.
+  static const int superword_max_vector_size(const BasicType bt);
 
   // Actual max scalable vector register length.
   static const int scalable_vector_reg_size(const BasicType bt);

src/hotspot/share/opto/superword.cpp

@@ -198,16 +198,6 @@ bool SuperWord::transform_loop(IdealLoopTree* lpt, bool do_optimization) {
   return success;
 }
 
-//------------------------------max vector size------------------------------
-int SuperWord::max_vector_size(BasicType bt) {
-  int max_vector = Matcher::max_vector_size(bt);
-  int sw_max_vector_limit = SuperWordMaxVectorSize / type2aelembytes(bt);
-  if (max_vector > sw_max_vector_limit) {
-    max_vector = sw_max_vector_limit;
-  }
-  return max_vector;
-}
-
 //------------------------------early unrolling analysis------------------------------
 void SuperWord::unrolling_analysis(int &local_loop_unroll_factor) {
   bool is_slp = true;
@@ -226,7 +216,7 @@ void SuperWord::unrolling_analysis(int &local_loop_unroll_factor) {
     ignored_loop_nodes[i] = -1;
   }
 
-  int max_vector = max_vector_size(T_BYTE);
+  int max_vector = Matcher::superword_max_vector_size(T_BYTE);
 
   // Process the loop, some/all of the stack entries will not be in order, ergo
   // need to preprocess the ignored initial state before we process the loop
@@ -361,7 +351,7 @@ void SuperWord::unrolling_analysis(int &local_loop_unroll_factor) {
 
       if (is_java_primitive(bt) == false) continue;
 
-      int cur_max_vector = max_vector_size(bt);
+      int cur_max_vector = Matcher::superword_max_vector_size(bt);
 
       // If a max vector exists which is not larger than _local_loop_unroll_factor
       // stop looking, we already have the max vector to map to.
@@ -1054,13 +1044,13 @@ int SuperWord::get_vw_bytes_special(MemNode* s) {
       }
     }
     if (should_combine_adjacent) {
-      vw = MIN2(max_vector_size(btype)*type2aelembytes(btype), vw * 2);
+      vw = MIN2(Matcher::superword_max_vector_size(btype)*type2aelembytes(btype), vw * 2);
     }
   }
 
   // Check for special case where there is a type conversion between different data size.
   int vectsize = max_vector_size_in_def_use_chain(s);
-  if (vectsize < max_vector_size(btype)) {
+  if (vectsize < Matcher::superword_max_vector_size(btype)) {
     vw = MIN2(vectsize * type2aelembytes(btype), vw);
   }
 
@@ -1254,8 +1244,8 @@ bool SuperWord::stmts_can_pack(Node* s1, Node* s2, int align) {
   if(!is_java_primitive(bt1) || !is_java_primitive(bt2))
     return false;
   BasicType longer_bt = longer_type_for_conversion(s1);
-  if (max_vector_size(bt1) < 2 ||
-      (longer_bt != T_ILLEGAL && max_vector_size(longer_bt) < 2)) {
+  if (Matcher::superword_max_vector_size(bt1) < 2 ||
+      (longer_bt != T_ILLEGAL && Matcher::superword_max_vector_size(longer_bt) < 2)) {
     return false; // No vectors for this type
   }
 
@@ -3669,10 +3659,10 @@ int SuperWord::max_vector_size_in_def_use_chain(Node* n) {
     vt = (newt == T_ILLEGAL) ? vt : newt;
   }
 
-  int max = max_vector_size(vt);
+  int max = Matcher::superword_max_vector_size(vt);
   // If now there is no vectors for the longest type, the nodes with the longest
   // type in the def-use chain are not packed in SuperWord::stmts_can_pack.
-  return max < 2 ? max_vector_size(bt) : max;
+  return max < 2 ? Matcher::superword_max_vector_size(bt) : max;
 }
 
 //-------------------------compute_vector_element_type-----------------------

src/hotspot/share/opto/superword.hpp

@@ -329,8 +329,6 @@ class SuperWord : public ResourceObj {
 
   bool transform_loop(IdealLoopTree* lpt, bool do_optimization);
 
-  int max_vector_size(BasicType bt);
-
   void unrolling_analysis(int &local_loop_unroll_factor);
 
   // Accessors for SWPointer

src/hotspot/share/opto/vectornode.cpp

@@ -298,17 +298,18 @@ int VectorNode::replicate_opcode(BasicType bt) {
   }
 }
 
-bool VectorNode::vector_size_supported(BasicType bt, uint vlen) {
-  return (Matcher::vector_size_supported(bt, vlen) &&
-          (vlen * type2aelembytes(bt) <= (uint)SuperWordMaxVectorSize));
+// Limits on vector size (number of elements) for auto-vectorization.
+bool VectorNode::vector_size_supported_superword(const BasicType bt, int size) {
+  return Matcher::superword_max_vector_size(bt) >= size &&
+         Matcher::min_vector_size(bt) <= size;
 }
 
 // Also used to check if the code generator
 // supports the vector operation.
 bool VectorNode::implemented(int opc, uint vlen, BasicType bt) {
   if (is_java_primitive(bt) &&
       (vlen > 1) && is_power_of_2(vlen) &&
-      vector_size_supported(bt, vlen)) {
+      vector_size_supported_superword(bt, vlen)) {
     int vopc = VectorNode::opcode(opc, bt);
     // For rotate operation we will do a lazy de-generation into
     // OrV/LShiftV/URShiftV pattern if the target does not support
@@ -1379,7 +1380,7 @@ bool VectorCastNode::implemented(int opc, uint vlen, BasicType src_type, BasicTy
   if (is_java_primitive(dst_type) &&
       is_java_primitive(src_type) &&
       (vlen > 1) && is_power_of_2(vlen) &&
-      VectorNode::vector_size_supported(dst_type, vlen)) {
+      VectorNode::vector_size_supported_superword(dst_type, vlen)) {
     int vopc = VectorCastNode::opcode(opc, src_type);
     return vopc > 0 && Matcher::match_rule_supported_superword(vopc, vlen, dst_type);
   }
@@ -1473,7 +1474,7 @@ Node* ReductionNode::make_reduction_input(PhaseGVN& gvn, int opc, BasicType bt)
 bool ReductionNode::implemented(int opc, uint vlen, BasicType bt) {
   if (is_java_primitive(bt) &&
       (vlen > 1) && is_power_of_2(vlen) &&
-      VectorNode::vector_size_supported(bt, vlen)) {
+      VectorNode::vector_size_supported_superword(bt, vlen)) {
     int vopc = ReductionNode::opcode(opc, bt);
     return vopc != opc && Matcher::match_rule_supported_superword(vopc, vlen, bt);
   }

src/hotspot/share/opto/vectornode.hpp

@@ -92,7 +92,9 @@ class VectorNode : public TypeNode {
 
   static int  opcode(int opc, BasicType bt);
   static int replicate_opcode(BasicType bt);
-  static bool vector_size_supported(BasicType bt, uint vlen);
+
+  // Limits on vector size (number of elements) for auto-vectorization.
+  static bool vector_size_supported_superword(const BasicType bt, int size);
   static bool implemented(int opc, uint vlen, BasicType bt);
   static bool is_shift(Node* n);
   static bool is_vshift_cnt(Node* n);