POC for hyperscan usage in UrlDispatcher

.mypy.ini

@@ -34,3 +34,6 @@ ignore_missing_imports = True
 
 [mypy-gunicorn.*]
 ignore_missing_imports = True
+
+[mypy-hyperscan]
+ignore_missing_imports = True

aiohttp/web_urldispatcher.py

@@ -41,6 +41,7 @@
 from .abc import AbstractMatchInfo, AbstractRouter, AbstractView
 from .helpers import DEBUG
 from .http import HttpVersion11
+from .log import web_logger
 from .typedefs import Handler, PathLike
 from .web_exceptions import (
     HTTPException,
@@ -68,6 +69,14 @@
 )
 
 
+try:
+    import hyperscan
+
+    HAS_HYPERSCAN = True
+except ImportError:
+    HAS_HYPERSCAN = False
+
+
 if TYPE_CHECKING:
     from .web_app import Application
 
@@ -735,6 +744,7 @@
     def add_prefix(self, prefix: str) -> None:
         super().add_prefix(prefix)
         self._add_prefix_to_resources(prefix)
+        self._app.router._rebuild()
 
     def _add_prefix_to_resources(self, prefix: str) -> None:
         router = self._app.router
@@ -998,27 +1008,75 @@
         self._named_resources: Dict[str, AbstractResource] = {}
         self._resource_index: dict[str, list[AbstractResource]] = {}
         self._matched_sub_app_resources: List[MatchedSubAppResource] = []
+        self._hyperdb: Optional[hyperscan.Database] = None  # type: ignore[no-any-unimported]
+        self._plain_resources: dict[str, PlainResource] = {}
+        self._prefix_resources: list[tuple[str, PrefixResource]] = []
+
+    def _on_match(
+        self, id_: int, from_: int, to: int, flags: int, found: list[int]
+    ) -> Optional[bool]:
+        found.append(id_)
+        return None
 
     async def resolve(self, request: Request) -> UrlMappingMatchInfo:
-        resource_index = self._resource_index
-        allowed_methods: Set[str] = set()
-
-        # Walk the url parts looking for candidates. We walk the url backwards
-        # to ensure the most explicit match is found first. If there are multiple
-        # candidates for a given url part because there are multiple resources
-        # registered for the same canonical path, we resolve them in a linear
-        # fashion to ensure registration order is respected.
-        url_part = request.rel_url.path_safe
-        while url_part:
-            for candidate in resource_index.get(url_part, ()):
-                match_dict, allowed = await candidate.resolve(request)
-                if match_dict is not None:
-                    return match_dict
-                else:
-                    allowed_methods |= allowed
-            if url_part == "/":
-                break
-            url_part = url_part.rpartition("/")[0] or "/"
+        allowed_methods: set[str] = set()
+        path = request.rel_url.path_safe
+
+        if (plain_resource := self._plain_resources.get(path)) is not None:
+            match_dict, allowed = await plain_resource.resolve(request)
+            if match_dict is not None:
+                return match_dict
+            else:
+                allowed_methods |= allowed
+
+        for prefix, prefix_resource in self._prefix_resources:
+            match_dict, allowed = await prefix_resource.resolve(request)
+            if match_dict is not None:
+                return match_dict
+            else:
+                allowed_methods |= allowed
+
+        if self._hyperdb is not None:
+            found: list[int] = []
+            resources = self._resources
+
+            self._hyperdb.scan(
+                path.encode("utf8"), match_event_handler=self._on_match, context=found
+            )
+            if found:
+                if len(found) > 1:
+                    # Multiple matches are found,
+                    # use the FIRST match.
+                    # Match ids are basically indexes in self._resources
+                    # with an offset for variable resources
+                    found.sort()
+
+                for idx in found:
+                    resource = resources[idx]
+                    match_dict, allowed = await resource.resolve(request)
+                    if match_dict is not None:
+                        return match_dict
+                    else:
+                        allowed_methods |= allowed
+        else:
+            url_part = path
+            resource_index = self._resource_index
+
+            # Walk the url parts looking for candidates. We walk the url backwards
+            # to ensure the most explicit match is found first. If there are multiple
+            # candidates for a given url part because there are multiple resources
+            # registered for the same canonical path, we resolve them in a linear
+            # fashion to ensure registration order is respected.
+            while url_part:
+                for candidate in resource_index.get(url_part, ()):
+                    match_dict, allowed = await candidate.resolve(request)
+                    if match_dict is not None:
+                        return match_dict
+                    else:
+                        allowed_methods |= allowed
+                if url_part == "/":
+                    break
+                url_part = url_part.rpartition("/")[0] or "/"
 
         #
         # We didn't find any candidates, so we'll try the matched sub-app
@@ -1239,6 +1297,55 @@
         super().freeze()
         for resource in self._resources:
             resource.freeze()
+        self._rebuild()
+
+    def _rebuild(self) -> None:
+        self._hyperdb = None
+        self._plain_resources.clear()
+        del self._prefix_resources[:]
+        patterns: list[bytes] = []
+        ids: list[int] = []
+        for id_, resource in enumerate(self._resources):
+            if isinstance(resource, PlainResource):
+                self._plain_resources[resource.get_info()["path"]] = resource
+                continue
+            elif isinstance(resource, DynamicResource):
+                pattern = resource.get_info()["pattern"].pattern
+            elif isinstance(resource, PrefixResource):
+                if isinstance(resource, MatchedSubAppResource):
+                    # wildcard resources doesn't fit hyperscan table
+                    continue
+                self._prefix_resources.append((resource.get_info()["prefix"], resource))
+                continue
+            else:
+                raise RuntimeError(f"Unsupported resource type {type(resource)}")
+
+            patterns.append(f"^{pattern}$".encode())
+            ids.append(id_)
+
+        if not HAS_HYPERSCAN:
+            return
+
+        count = len(patterns)
+        self._hyperdb = hyperscan.Database()
+        try:
+            self._hyperdb.compile(
+                expressions=patterns,
+                ids=ids,
+                elements=count,
+                flags=[
+                    hyperscan.HS_FLAG_UTF8
+                    | hyperscan.HS_FLAG_UCP
+                    | hyperscan.HS_FLAG_SINGLEMATCH
+                ]
+                * count,
+            )
+        except hyperscan.error as exc:
+            web_logger.warning(
+                "Cannot compile hyperscan database: %s, switching to fallback url resolver",
+                repr(exc),
+            )
+            self._hyperdb = None
 
     def add_routes(self, routes: Iterable[AbstractRouteDef]) -> List[AbstractRoute]:
         """Append routes to route table.

requirements/runtime-deps.in

@@ -7,6 +7,7 @@ async-timeout >= 4.0, < 6.0 ; python_version < "3.11"
 Brotli; platform_python_implementation == 'CPython'
 brotlicffi; platform_python_implementation != 'CPython'
 frozenlist >= 1.1.1
+hyperscan >= 0.7.8; platform_python_implementation == 'CPython' and (sys_platform=="linux" or sys_platform=="darwin") and (python_version < "3.14")
 multidict >=4.5, < 7.0
 propcache >= 0.2.0
 yarl >= 1.17.0, < 2.0

requirements/runtime-deps.txt

@@ -20,6 +20,8 @@ frozenlist==1.5.0
     # via
     #   -r requirements/runtime-deps.in
     #   aiosignal
+hyperscan == 0.7.8 ; platform_python_implementation == "CPython" and (sys_platform=="linux" or sys_platform=="darwin") and (python_version < "3.14")
+    # via -r requirements/runtime-deps.in
 idna==3.6
     # via yarl
 multidict==6.1.0

setup.cfg

@@ -70,6 +70,7 @@ speedups =
   aiodns >= 3.2.0; sys_platform=="linux" or sys_platform=="darwin"
   Brotli; platform_python_implementation == 'CPython'
   brotlicffi; platform_python_implementation != 'CPython'
+  hyperscan >= 0.7.8; platform_python_implementation == 'CPython' and (sys_platform=="linux" or sys_platform=="darwin") and (python_version < "3.14")
 
 [options.packages.find]
 exclude =