Optimizations on hot path of the webserver - avoid splitting strings, copying arrays, excessive string equals etc. (helidon-io#10621)

Author: tomas-langer

common/parameters/src/main/java/io/helidon/common/parameters/Parameters.java

@@ -74,6 +74,19 @@ static Parameters create(String component, Map<String, List<String>> params) {
         return new ParametersMap(ParametersEmpty.MAPPERS, component, params);
     }
 
+    /**
+     * Read only parameters based on a map.
+     *
+     * @param params     underlying map
+     * @param component  component of the parameters to correctly report errors
+     * @param qualifiers qualifiers to use when mapping to different types
+     * @return new named parameters with values based on the map
+     */
+    static Parameters create(String component, Map<String, List<String>> params, String... qualifiers) {
+        // this method is to avoid parsing of component into qualifiers on WebServer hot path
+        return new ParametersMap(ParametersEmpty.MAPPERS, component, params, qualifiers);
+    }
+
     /**
      * Read only parameters based on a map with just a single value.
      *

common/parameters/src/main/java/io/helidon/common/parameters/ParametersMap.java

@@ -41,6 +41,13 @@ class ParametersMap implements Parameters {
         this.params = new LinkedHashMap<>(params);
     }
 
+    ParametersMap(Mappers mapperManager, String component, Map<String, List<String>> params, String[] qualifiers) {
+        this.qualifiers = qualifiers;
+        this.mapperManager = mapperManager;
+        this.component = component;
+        this.params = new LinkedHashMap<>(params);
+    }
+
     @Override
     public List<String> all(String name) throws NoSuchElementException {
         List<String> value = params.get(name);

http/http/src/main/java/io/helidon/http/CookieParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2025 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -51,7 +51,9 @@ static Parameters parse(Header httpHeader) {
         if (allCookies.isEmpty()) {
             return EMPTY_COOKIES;
         }
-        return Parameters.create("http/cookies", allCookies);
+        // avoids splitting the component every single time parameters are created, which is
+        // for example for every single HTTP request
+        return Parameters.create("http/cookies", allCookies, "http", "cookies");
     }
 
     static Parameters empty() {

http/http/src/main/java/io/helidon/http/HeaderValueCopy.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2025 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -49,7 +49,8 @@ public List<String> allValues() {
     @Override
     public int valueCount() {
         if (values == null) {
-            values = new ArrayList<>(original.allValues());
+            // no need to copy array just to geet a count
+            return original.valueCount();
         }
         return values.size();
     }

http/http/src/main/java/io/helidon/http/PathMatchers.java

@@ -162,9 +162,9 @@ public static PathMatcher create(String pathPattern) {
         }
 
         if (checkPattern.contains("{")
-            || checkPattern.contains("[")
-            || checkPattern.contains("*")
-            || checkPattern.contains("\\")) {
+                || checkPattern.contains("[")
+                || checkPattern.contains("*")
+                || checkPattern.contains("\\")) {
             return pattern(pathPattern);
         }
 
@@ -285,13 +285,16 @@ private static String fixPrefix(String pathToMatch) {
     }
 
     static final class ExactPathMatcher implements PathMatcher {
+        private final boolean isRoot;
         private final String path;
         private final String pathWithTrailingSlash;
 
         ExactPathMatcher(String path) {
             // We work with decoded URIs
             this.path = UriEncoding.decodeUri(path);
             this.pathWithTrailingSlash = this.path + "/";
+            // optimization - this happens one per lifetime of the server, but the check is happening for every request
+            this.isRoot = "/".equals(this.path);
         }
 
         @Override
@@ -310,27 +313,29 @@ public MatchResult match(UriPath uriPath) {
 
         @Override
         public PrefixMatchResult prefixMatch(UriPath uriPath) {
-            if (path.equals("/")) {
+            if (isRoot) {
                 return new PrefixMatchResult(true,
                                              ROUTED_ROOT,
                                              uriPath);
             }
 
             String actualPath = uriPath.path();
-            if (actualPath.startsWith(pathWithTrailingSlash) || actualPath.equals(path)) {
+            // first do an exact match, then a prefix match (to avoid doing prefix match if exactly matched)
+            if (path.equals(actualPath)) {
+                // this is an exact match
+                return new PrefixMatchResult(true,
+                                             new NoParamRoutedPath(uriPath),
+                                             UriPath.createRelative(uriPath, "/"));
+            }
+            if (actualPath.startsWith(pathWithTrailingSlash)) {
                 // we have /test
                 String remaining = actualPath.substring(path.length());
-                if (remaining.isEmpty()) {
-                    // we received /test
-                    return new PrefixMatchResult(true,
-                                                 new NoParamRoutedPath(uriPath),
-                                                 UriPath.createRelative(uriPath, "/"));
-                } else {
-                    // we received /test/whatever, remaining should be /whatever
-                    return new PrefixMatchResult(true,
-                                                 new NoParamRoutedPath(UriPath.createRelative(uriPath, path)),
-                                                 UriPath.createRelative(uriPath, remaining));
-                }
+
+                // we received /test/whatever, remaining should be /whatever
+                return new PrefixMatchResult(true,
+                                             new NoParamRoutedPath(UriPath.createRelative(uriPath, path)),
+                                             UriPath.createRelative(uriPath, remaining));
+
             }
             return PrefixMatchResult.notAccepted();
         }

webserver/webserver/src/main/java/io/helidon/webserver/http/RouteCrawler.java

@@ -148,7 +148,10 @@ public CrawlerItem parent(RoutedPath parent) {
                 newParams.put(paramName, params.all(paramName));
             }
             newParams.replaceAll((name, values) -> List.copyOf(values));
-            RoutedPath result = new CrawlerRoutedPath(path, matchingElement, Parameters.create("http/path", newParams));
+            // this is called for each request, optimize qualifiers so the do not get parsed each time
+            RoutedPath result = new CrawlerRoutedPath(path,
+                                                      matchingElement,
+                                                      Parameters.create("http/path", newParams, "http", "path"));
             return new CrawlerItem(result, parent.path() + matchingElement, handler);
         }