8370922: Template Framework Library: Float16 type and operations

Reviewed-by: galder, thartmann, bmaillard

Author: eme64

test/hotspot/jtreg/compiler/igvn/ExpressionFuzzer.java

@@ -23,10 +23,11 @@
 
 /*
  * @test
- * @bug 8359412
+ * @bug 8359412 8370922
  * @key randomness
  * @summary Use the template framework library to generate random expressions.
  * @modules java.base/jdk.internal.misc
+ * @modules jdk.incubator.vector
  * @library /test/lib /
  * @compile ../lib/verify/Verify.java
  * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:CompileTaskTimeout=10000 compiler.igvn.ExpressionFuzzer
@@ -55,6 +56,7 @@
 import compiler.lib.template_framework.library.PrimitiveType;
 import compiler.lib.template_framework.library.TestFrameworkClass;
 import static compiler.lib.template_framework.library.CodeGenerationDataNameType.PRIMITIVE_TYPES;
+import static compiler.lib.template_framework.library.CodeGenerationDataNameType.SCALAR_NUMERIC_TYPES;
 
 // We generate random Expressions from primitive type operators.
 //
@@ -84,10 +86,14 @@ public static void main(String[] args) {
         comp.addJavaSourceCode("compiler.igvn.templated.ExpressionFuzzerInnerTest", generate(comp));
 
         // Compile the source file.
-        comp.compile();
+        comp.compile("--add-modules=jdk.incubator.vector");
 
         // compiler.igvn.templated.InnterTest.main(new String[] {});
-        comp.invoke("compiler.igvn.templated.ExpressionFuzzerInnerTest", "main", new Object[] {new String[] {}});
+        comp.invoke("compiler.igvn.templated.ExpressionFuzzerInnerTest", "main", new Object[] {new String[] {
+            "--add-modules=jdk.incubator.vector",
+            "--add-opens", "jdk.incubator.vector/jdk.incubator.vector=ALL-UNNAMED",
+            "--add-opens", "java.base/java.lang=ALL-UNNAMED"
+        }});
     }
 
     // Generate a Java source file as String
@@ -189,10 +195,10 @@ public static String generate(CompileFramework comp) {
                 case "byte", "short", "char", "int", "long" ->
                     List.of("val", Collections.nCopies(20, integralCmpTemplate.asToken(expression.returnType)));
                 // Float/Double have no range, just return the value:
-                case "float", "double" -> "val";
+                case "float", "double", "Float16" -> "val";
                 // Check if the boolean constant folded:
                 case "boolean" -> "val, val == true, val == false";
-                default -> throw new RuntimeException("should only be primitive types");
+                default -> throw new RuntimeException("type not supported yet: " + expression.returnType.name());
             }
             , "};\n",
             """
@@ -224,7 +230,7 @@ public static String generate(CompileFramework comp) {
                 // Booleans do have an int-range, but restricting it would just make it constant, which
                 // is not very useful: we would like to keep it variable here. We already mix in variable
                 // arguments and constants in the testTemplate.
-                case "boolean", "float", "double" -> "return v;\n";
+                case "boolean", "float", "double", "Float16" -> "return v;\n";
                 case "byte", "short", "char", "int", "long" -> List.of(
                     // Sometimes constrain the signed range
                     //   v = min(max(v, CON1), CON2)
@@ -241,7 +247,7 @@ public static String generate(CompileFramework comp) {
                     : List.of(),
                     // FUTURE: we could also constrain the unsigned bounds.
                     "return v;\n");
-                default -> throw new RuntimeException("should only be primitive types");
+                default -> throw new RuntimeException("type not supported yet: " + type.name());
             },
             """
             }
@@ -325,6 +331,7 @@ public static String generate(CompileFramework comp) {
 
         // Generate expressions with the primitive types.
         for (PrimitiveType type : PRIMITIVE_TYPES) {
+            // Prmitive expressions are most important, so let's create many expressions per output type.
             for (int i = 0; i < 10; i++) {
                 // The depth determines roughly how many operations are going to be used in the expression.
                 int depth = RANDOM.nextInt(1, 20);
@@ -333,6 +340,21 @@ public static String generate(CompileFramework comp) {
             }
         }
 
+        // Generate expressions with any scalar numeric types.
+        for (CodeGenerationDataNameType type : SCALAR_NUMERIC_TYPES) {
+            // The extended set of scalar numeric expressions (incl. special types such as Float16) are relevant
+            // but don't currently warrant the same number amount of testing time, so we only create 2 cases
+            // per type. Note: this still produces a lot of expressions, given that we have a lot of output
+            // types, and even if the output type is "float", we can still use other types in the expression,
+            // such as "float -> Float16 -> float". We can consider adjusting this arbitrary count in the future.
+            for (int i = 0; i < 2; i++) {
+                // The depth determines roughly how many operations are going to be used in the expression.
+                int depth = RANDOM.nextInt(1, 20);
+                Expression expression = Expression.nestRandomly(type, Operations.SCALAR_NUMERIC_OPERATIONS, depth);
+                tests.add(testTemplate.asToken(expression));
+            }
+        }
+
         // Create the test class, which runs all tests.
         return TestFrameworkClass.render(
             // package and class name.
@@ -341,7 +363,8 @@ public static String generate(CompileFramework comp) {
             Set.of("compiler.lib.verify.*",
                    "java.util.Random",
                    "jdk.test.lib.Utils",
-                   "compiler.lib.generators.*"),
+                   "compiler.lib.generators.*",
+                   "jdk.incubator.vector.Float16"),
             // classpath, so the Test VM has access to the compiled class files.
             comp.getEscapedClassPathOfCompiledClasses(),
             // The list of tests.

test/hotspot/jtreg/compiler/lib/template_framework/library/CodeGenerationDataNameType.java

@@ -100,6 +100,13 @@ public interface CodeGenerationDataNameType extends DataName.Type {
      */
     static PrimitiveType booleans() { return PrimitiveType.BOOLEANS; }
 
+    /**
+     * The Float16 type.
+     *
+     * @return The Float16 type.
+     */
+    static CodeGenerationDataNameType float16() { return Float16Type.FLOAT16; }
+
     /**
      * List of all {@link PrimitiveType}s.
      */
@@ -154,4 +161,19 @@ public interface CodeGenerationDataNameType extends DataName.Type {
         floats(),
         doubles()
     );
+
+    /**
+     * List of all scalar numeric types.
+     */
+    List<CodeGenerationDataNameType> SCALAR_NUMERIC_TYPES = List.of(
+        bytes(),
+        chars(),
+        shorts(),
+        ints(),
+        longs(),
+        floats(),
+        doubles(),
+        booleans(),
+        float16()
+    );
 }

test/hotspot/jtreg/compiler/lib/template_framework/library/Float16Type.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 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.
+ *
+ * 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.
+ */
+
+package compiler.lib.template_framework.library;
+
+import compiler.lib.generators.Generators;
+import compiler.lib.generators.Generator;
+
+import compiler.lib.template_framework.DataName;
+
+/**
+ * The {@link Float16Type} models Java's {@link Float16} type.
+ */
+final class Float16Type implements CodeGenerationDataNameType {
+    private static final Generator<Short> GEN_FLOAT16 = Generators.G.float16s();
+
+    // We only need one static instance of the class.
+    static final Float16Type FLOAT16 = new Float16Type();
+
+    // Private constructor so nobody can create duplicate instances.
+    private Float16Type() {}
+
+    @Override
+    public boolean isSubtypeOf(DataName.Type other) {
+        return other instanceof Float16Type;
+    }
+
+    @Override
+    public String name() {
+        return "Float16";
+    }
+
+    @Override
+    public String toString() {
+        return name();
+    }
+
+    @Override
+    public Object con() {
+        return "Float16.shortBitsToFloat16((short)" + GEN_FLOAT16.next() + ")";
+    }
+}