8246338: Reduce overhead of normalizing file paths

Reviewed-by: alanb

src/java.base/unix/classes/java/io/UnixFileSystem.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2020, 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
@@ -64,14 +64,17 @@ class UnixFileSystem extends FileSystem {
     /* A normal Unix pathname contains no duplicate slashes and does not end
        with a slash.  It may be the empty string. */
 
-    /* Normalize the given pathname, whose length is len, starting at the given
-       offset; everything before this offset is already normal. */
-    private String normalize(String pathname, int len, int off) {
-        if (len == 0) return pathname;
-        int n = len;
+    /**
+     * Normalize the given pathname, starting at the given
+     * offset; everything before off is already normal, and there's at least
+     * one duplicate or trailing slash to be removed
+     */
+    private String normalize(String pathname, int off) {
+        int n = pathname.length();
         while ((n > 0) && (pathname.charAt(n - 1) == '/')) n--;
         if (n == 0) return "/";
-        StringBuilder sb = new StringBuilder(pathname.length());
+
+        StringBuilder sb = new StringBuilder(n);
         if (off > 0) sb.append(pathname, 0, off);
         char prevChar = 0;
         for (int i = off; i < n; i++) {
@@ -88,22 +91,19 @@ class UnixFileSystem extends FileSystem {
        This way we iterate through the whole pathname string only once. */
     @Override
     public String normalize(String pathname) {
-        int n = pathname.length();
-        char prevChar = 0;
-        for (int i = 0; i < n; i++) {
-            char c = pathname.charAt(i);
-            if ((prevChar == '/') && (c == '/'))
-                return normalize(pathname, n, i - 1);
-            prevChar = c;
+        int doubleSlash = pathname.indexOf("//");
+        if (doubleSlash >= 0) {
+            return normalize(pathname, doubleSlash);
+        }
+        if (pathname.endsWith("/")) {
+            return normalize(pathname, pathname.length() - 1);
         }
-        if (prevChar == '/') return normalize(pathname, n, n - 1);
         return pathname;
     }
 
     @Override
     public int prefixLength(String pathname) {
-        if (pathname.isEmpty()) return 0;
-        return (pathname.charAt(0) == '/') ? 1 : 0;
+        return pathname.startsWith("/") ? 1 : 0;
     }
 
     @Override

test/micro/org/openjdk/bench/java/io/FileOpen.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2020, 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.io;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.io.File;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Tests the overheads of I/O API.
+ */
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Thread)
+@Warmup(time=2, iterations=5)
+@Measurement(time=3, iterations=5)
+@Fork(value=2, jvmArgs="-Xmx1g")
+public class FileOpen {
+
+    public String normalFile = "/test/dir/file/name.txt";
+    public String root = "/";
+    public String trailingSlash = "/test/dir/file//name.txt";
+    public String notNormalizedFile = "/test/dir/file//name.txt";
+
+    @Benchmark
+    public void mix(Blackhole bh) {
+        bh.consume(new File(normalFile));
+        bh.consume(new File(root));
+        bh.consume(new File(trailingSlash));
+        bh.consume(new File(notNormalizedFile));
+    }
+
+    @Benchmark
+    public File normalized() {
+        return new File(normalFile);
+    }
+
+    @Benchmark
+    public File trailingSlash() {
+        return new File(trailingSlash);
+    }
+
+    @Benchmark
+    public File notNormalized() {
+        return new File(notNormalizedFile);
+    }
+}