test/jdk/jdk/incubator/vector/Long64VectorTests.java

@@ -1,7 +1,7 @@
  /*
-  * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
+  * Copyright (c) 2018, 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
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.

@@ -61,10 +61,12 @@
      static final VectorSpecies<Long> SPECIES =
                  LongVector.SPECIES_64;
  
      static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
  
+     static LongVector bcast_vec = LongVector.broadcast(SPECIES, (long)10);
+ 
  
      private static final long CONST_SHIFT = Long.SIZE / 2;
  
      static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 64);
  

@@ -3096,110 +3098,98 @@
  
          assertShiftConstEquals(r, a, mask, Long64VectorTests::ROL_binary_const);
      }
  
  
-     static LongVector bv_MIN = LongVector.broadcast(SPECIES, (long)10);
- 
      @Test(dataProvider = "longUnaryOpProvider")
      static void MINLong64VectorTestsWithMemOp(IntFunction<long[]> fa) {
          long[] a = fa.apply(SPECIES.length());
          long[] r = fr.apply(SPECIES.length());
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  LongVector av = LongVector.fromArray(SPECIES, a, i);
-                 av.lanewise(VectorOperators.MIN, bv_MIN).intoArray(r, i);
+                 av.lanewise(VectorOperators.MIN, bcast_vec).intoArray(r, i);
              }
          }
  
          assertArraysEquals(r, a, (long)10, Long64VectorTests::MIN);
      }
  
-     static LongVector bv_min = LongVector.broadcast(SPECIES, (long)10);
- 
      @Test(dataProvider = "longUnaryOpProvider")
      static void minLong64VectorTestsWithMemOp(IntFunction<long[]> fa) {
          long[] a = fa.apply(SPECIES.length());
          long[] r = fr.apply(SPECIES.length());
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  LongVector av = LongVector.fromArray(SPECIES, a, i);
-                 av.min(bv_min).intoArray(r, i);
+                 av.min(bcast_vec).intoArray(r, i);
              }
          }
  
          assertArraysEquals(r, a, (long)10, Long64VectorTests::min);
      }
  
-     static LongVector bv_MIN_M = LongVector.broadcast(SPECIES, (long)10);
- 
      @Test(dataProvider = "longUnaryOpMaskProvider")
      static void MINLong64VectorTestsMaskedWithMemOp(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
          long[] a = fa.apply(SPECIES.length());
          long[] r = fr.apply(SPECIES.length());
          boolean[] mask = fm.apply(SPECIES.length());
          VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  LongVector av = LongVector.fromArray(SPECIES, a, i);
-                 av.lanewise(VectorOperators.MIN, bv_MIN_M, vmask).intoArray(r, i);
+                 av.lanewise(VectorOperators.MIN, bcast_vec, vmask).intoArray(r, i);
              }
          }
  
          assertArraysEquals(r, a, (long)10, mask, Long64VectorTests::MIN);
      }
  
-     static LongVector bv_MAX = LongVector.broadcast(SPECIES, (long)10);
- 
      @Test(dataProvider = "longUnaryOpProvider")
      static void MAXLong64VectorTestsWithMemOp(IntFunction<long[]> fa) {
          long[] a = fa.apply(SPECIES.length());
          long[] r = fr.apply(SPECIES.length());
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  LongVector av = LongVector.fromArray(SPECIES, a, i);
-                 av.lanewise(VectorOperators.MAX, bv_MAX).intoArray(r, i);
+                 av.lanewise(VectorOperators.MAX, bcast_vec).intoArray(r, i);
              }
          }
  
          assertArraysEquals(r, a, (long)10, Long64VectorTests::MAX);
      }
  
-     static LongVector bv_max = LongVector.broadcast(SPECIES, (long)10);
- 
      @Test(dataProvider = "longUnaryOpProvider")
      static void maxLong64VectorTestsWithMemOp(IntFunction<long[]> fa) {
          long[] a = fa.apply(SPECIES.length());
          long[] r = fr.apply(SPECIES.length());
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  LongVector av = LongVector.fromArray(SPECIES, a, i);
-                 av.max(bv_max).intoArray(r, i);
+                 av.max(bcast_vec).intoArray(r, i);
              }
          }
  
          assertArraysEquals(r, a, (long)10, Long64VectorTests::max);
      }
  
-     static LongVector bv_MAX_M = LongVector.broadcast(SPECIES, (long)10);
- 
      @Test(dataProvider = "longUnaryOpMaskProvider")
      static void MAXLong64VectorTestsMaskedWithMemOp(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
          long[] a = fa.apply(SPECIES.length());
          long[] r = fr.apply(SPECIES.length());
          boolean[] mask = fm.apply(SPECIES.length());
          VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  LongVector av = LongVector.fromArray(SPECIES, a, i);
-                 av.lanewise(VectorOperators.MAX, bv_MAX_M, vmask).intoArray(r, i);
+                 av.lanewise(VectorOperators.MAX, bcast_vec, vmask).intoArray(r, i);
              }
          }
  
          assertArraysEquals(r, a, (long)10, mask, Long64VectorTests::MAX);
      }