[NEW BUG] Reduce allocations from Class.toString() for primitives

[Christoph Dreis]

Hi,

I just noticed an opportunity to optimize Class.toString() for primitive types.

I've written a small benchmark and ran it against JDK 15 vs a patched variant.

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class MyBenchmark {

    @State(Scope.Benchmark)
    public static class ThreadState {

        private Class<?> primitive = long.class;
        private Class<?> clazz = Long.class;
        private Class<?> interfaze = Map.class;

    }

    @Benchmark
    public String testPrimitive(ThreadState threadState) {
        return threadState.primitive.toString();
    }

    @Benchmark
    public String testClass(ThreadState threadState) {
        return threadState.clazz.toString();
    }

    @Benchmark
    public String testInterface(ThreadState threadState) {
        return threadState.interfaze.toString();
    }

}

This yields the following results:

Before
Benchmark                                                   Mode  Cnt     Score     Error   Units
MyBenchmark.testClass                                       avgt   10    32,268 ±   2,961   ns/op
MyBenchmark.testClass:·gc.alloc.rate                        avgt   10  3601,964 ± 336,786  MB/sec
MyBenchmark.testClass:·gc.alloc.rate.norm                   avgt   10   152,009 ±   0,001    B/op
MyBenchmark.testClass:·gc.count                             avgt   10   203,000            counts
MyBenchmark.testClass:·gc.time                              avgt   10   138,000                ms
MyBenchmark.testInterface                                   avgt   10    37,685 ±   3,728   ns/op
MyBenchmark.testInterface:·gc.alloc.rate                    avgt   10  3086,794 ± 309,983  MB/sec
MyBenchmark.testInterface:·gc.alloc.rate.norm               avgt   10   152,008 ±   0,001    B/op
MyBenchmark.testInterface:·gc.count                         avgt   10   160,000            counts
MyBenchmark.testInterface:·gc.time                          avgt   10   107,000                ms
MyBenchmark.testPrimitive                                   avgt   10    20,937 ±   2,668   ns/op
MyBenchmark.testPrimitive:·gc.alloc.rate                    avgt   10  3809,437 ± 470,140  MB/sec
MyBenchmark.testPrimitive:·gc.alloc.rate.norm               avgt   10   104,006 ±   0,001    B/op
MyBenchmark.testPrimitive:·gc.count                         avgt   10   215,000            counts
MyBenchmark.testPrimitive:·gc.time                          avgt   10   167,000                ms


After
Benchmark                                                   Mode  Cnt     Score     Error   Units
MyBenchmark.testClass                                       avgt   10    31,585 ±   5,365   ns/op
MyBenchmark.testClass:·gc.alloc.rate                        avgt   10  3704,714 ± 549,224  MB/sec
MyBenchmark.testClass:·gc.alloc.rate.norm                   avgt   10   152,008 ±   0,001    B/op
MyBenchmark.testClass:·gc.count                             avgt   10   191,000            counts
MyBenchmark.testClass:·gc.time                              avgt   10   139,000                ms
MyBenchmark.testInterface                                   avgt   10    34,534 ±   2,073   ns/op
MyBenchmark.testInterface:·gc.alloc.rate                    avgt   10  3358,401 ± 193,391  MB/sec
MyBenchmark.testInterface:·gc.alloc.rate.norm               avgt   10   152,008 ±   0,001    B/op
MyBenchmark.testInterface:·gc.count                         avgt   10   173,000            counts
MyBenchmark.testInterface:·gc.time                          avgt   10   131,000                ms
MyBenchmark.testPrimitive                                   avgt   10     2,829 ±   0,139   ns/op
MyBenchmark.testPrimitive:·gc.alloc.rate                    avgt   10    ≈ 10⁻⁴            MB/sec
MyBenchmark.testPrimitive:·gc.alloc.rate.norm               avgt   10    ≈ 10⁻⁶              B/op
MyBenchmark.testPrimitive:·gc.count                         avgt   10       ≈ 0            counts

I don't think the patched version is actually faster for classes & interfaces; I guess it's rather a draw for those.
Yet, for primitives we can see a 10x improvement due to the avoided string concats.

In case you think this is worthwhile I would need someone to sponsor this patch.
I would highly appreciate that. Let me know what you think

Cheers,
Christoph


===== PATCH =====
diff --git a/src/java.base/share/classes/java/lang/Class.java b/src/java.base/share/classes/java/lang/Class.java
--- a/src/java.base/share/classes/java/lang/Class.java
+++ b/src/java.base/share/classes/java/lang/Class.java
@@ -196,8 +196,11 @@
      * @return a string representation of this {@code Class} object.
      */
     public String toString() {
-        return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
-            + getName();
+        String name = getName();
+        if (isPrimitive()) {
+               return name;
+        }
+        return (isInterface() ? "interface " : "class ") + name;
     }