8291641: Optimize StackTraceElement.toString()

Reviewed-by: rriggs, mchung

Author: schlosna

src/java.base/share/classes/java/lang/StackTraceElement.java

@@ -30,7 +30,6 @@
 import jdk.internal.module.ModuleHashes;
 import jdk.internal.module.ModuleReferenceImpl;
 
-import java.lang.module.ModuleDescriptor.Version;
 import java.lang.module.ModuleReference;
 import java.lang.module.ResolvedModule;
 import java.util.HashSet;
@@ -52,6 +51,9 @@
  */
 public final class StackTraceElement implements java.io.Serializable {
 
+    private static final String NATIVE_METHOD = "Native Method";
+    private static final String UNKNOWN_SOURCE = "Unknown Source";
+
     // For Throwables and StackWalker, the VM initially sets this field to a
     // reference to the declaring Class.  The Class reference is used to
     // construct the 'format' bitmap, and then is cleared.
@@ -355,27 +357,50 @@ public boolean isNativeMethod() {
      * @revised 9
      * @see    Throwable#printStackTrace()
      */
+    @Override
     public String toString() {
-        String s = "";
-        if (!dropClassLoaderName() && classLoaderName != null &&
-                !classLoaderName.isEmpty()) {
-            s += classLoaderName + "/";
+        int estimatedLength = length(classLoaderName) + 1
+                + length(moduleName) + 1
+                + length(moduleVersion) + 1
+                + declaringClass.length() + 1
+                + methodName.length() + 1
+                + Math.max(UNKNOWN_SOURCE.length(), length(fileName)) + 1
+                + 12;
+
+        StringBuilder sb = new StringBuilder(estimatedLength);
+        if (!dropClassLoaderName() && classLoaderName != null && !classLoaderName.isEmpty()) {
+            sb.append(classLoaderName).append('/');
         }
+
         if (moduleName != null && !moduleName.isEmpty()) {
-            s += moduleName;
+            sb.append(moduleName);
+            if (!dropModuleVersion() && moduleVersion != null && !moduleVersion.isEmpty()) {
+                sb.append('@').append(moduleVersion);
+            }
+        }
 
-            if (!dropModuleVersion() && moduleVersion != null &&
-                    !moduleVersion.isEmpty()) {
-                s += "@" + moduleVersion;
+        if (sb.length() > 0) {
+            sb.append('/');
+        }
+
+        sb.append(declaringClass).append('.').append(methodName).append('(');
+        if (isNativeMethod()) {
+            sb.append(NATIVE_METHOD);
+        } else if (fileName == null) {
+            sb.append(UNKNOWN_SOURCE);
+        } else {
+            sb.append(fileName);
+            if (lineNumber >= 0) {
+                sb.append(':').append(lineNumber);
             }
         }
-        s = s.isEmpty() ? declaringClass : s + "/" + declaringClass;
+        sb.append(')');
+
+        return sb.toString();
+    }
 
-        return s + "." + methodName + "(" +
-             (isNativeMethod() ? "Native Method)" :
-              (fileName != null && lineNumber >= 0 ?
-               fileName + ":" + lineNumber + ")" :
-                (fileName != null ?  ""+fileName+")" : "Unknown Source)")));
+    private static int length(String s) {
+        return (s == null) ? 0 : s.length();
     }
 
     /**

test/jdk/java/lang/StackTraceElement/SerialTest.java

@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 6479237
+ * @bug 6479237 8291641
  * @summary Test the format of StackTraceElement::toString and its serial form
  * @modules java.logging
  *

test/micro/org/openjdk/bench/java/lang/StackTraceElementBench.java

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2022, 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 org.openjdk.bench.java.lang;
+
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+
+/**
+ * Benchmarks for java.lang.StackTraceElement
+ */
+@State(value = Scope.Benchmark)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Warmup(iterations = 5, time = 1)
+@Measurement(iterations = 5, time = 1)
+@Fork(3)
+public class StackTraceElementBench {
+
+    private StackTraceElement element;
+    private Throwable throwable;
+
+    @Setup
+    public void setup() {
+        StackTraceElement[] elements = IntStream.range(0, 500)
+                .mapToObj(i -> new StackTraceElement(
+                        "classloader" + i,
+                        "module" + i,
+                        "version" + i,
+                        "class" + i,
+                        "method" + i,
+                        "file" + i + ".java",
+                        i))
+                .toArray(StackTraceElement[]::new);
+        this.element = elements[0];
+        this.throwable = new RuntimeException("benchmark") {
+            @Override
+            public synchronized Throwable fillInStackTrace() {
+                setStackTrace(elements);
+                return this;
+            }
+        };
+    }
+
+    @Benchmark
+    public String toString() {
+        return element.toString();
+    }
+
+    @Benchmark
+    public String printStackTrace() {
+        StringWriter sw = new StringWriter();
+        throwable.printStackTrace(new PrintWriter(sw));
+        return sw.toString();
+    }
+}