Add LRUCache implementation to optimize route caching

Author: sdogruyol

src/kemal/route_handler.cr

@@ -1,6 +1,107 @@
 require "radix"
 
 module Kemal
+  # Small, private LRU cache used by the router to avoid full cache clears
+  # when many distinct paths are accessed. Keeps get/put at O(1).
+  # This is intentionally minimal and file-local to avoid API surface.
+  class LRUCache(K, V)
+    # Doubly-linked list node
+    class Node(K, V)
+      property key : K
+      property value : V
+      property prev : Node(K, V)?
+      property next : Node(K, V)?
+
+      def initialize(@key : K, @value : V)
+        @prev = nil
+        @next = nil
+      end
+    end
+
+    @capacity : Int32
+    @map : Hash(K, Node(K, V))
+    @head : Node(K, V)? # most-recent
+    @tail : Node(K, V)? # least-recent
+
+    def initialize(@capacity : Int32)
+      @map = Hash(K, Node(K, V)).new
+      @head = nil
+      @tail = nil
+    end
+
+    def size : Int32
+      @map.size
+    end
+
+    def get(key : K) : V?
+      if node = @map[key]?
+        move_to_front(node)
+        return node.value
+      end
+      nil
+    end
+
+    def put(key : K, value : V) : Nil
+      if node = @map[key]?
+        node.value = value
+        move_to_front(node)
+        return
+      end
+
+      node = Node(K, V).new(key, value)
+      @map[key] = node
+      insert_front(node)
+      evict_if_needed
+    end
+
+    private def insert_front(node : Node(K, V))
+      node.prev = nil
+      node.next = @head
+      @head.try { |h| h.prev = node }
+      @head = node
+      @tail = node if @tail.nil?
+    end
+
+    private def move_to_front(node : Node(K, V))
+      return if node == @head
+
+      # unlink
+      prev = node.prev
+      nxt = node.next
+      prev.try { |p| p.next = nxt }
+      nxt.try { |n| n.prev = prev }
+
+      # fix tail if needed
+      if node == @tail
+        @tail = prev
+      end
+
+      # insert at head
+      node.prev = nil
+      node.next = @head
+      @head.try { |h| h.prev = node }
+      @head = node
+    end
+
+    private def evict_if_needed
+      return if @map.size <= @capacity
+
+      if lru = @tail
+        # unlink tail
+        prev = lru.prev
+        if prev
+          prev.next = nil
+          @tail = prev
+        else
+          # only one element
+          @head = nil
+          @tail = nil
+        end
+        @map.delete(lru.key)
+      end
+    end
+  end
+
   class RouteHandler
     include HTTP::Handler
 
@@ -10,7 +111,7 @@ module Kemal
 
     def initialize
       @routes = Radix::Tree(Route).new
-      @cached_routes = Hash(String, Radix::Result(Route)).new
+      @cached_routes = LRUCache(String, Radix::Result(Route)).new(CACHED_ROUTES_LIMIT)
     end
 
     def call(context : HTTP::Server::Context)
@@ -26,7 +127,7 @@ module Kemal
     def lookup_route(verb : String, path : String)
       lookup_path = radix_path(verb, path)
 
-      if cached_route = @cached_routes[lookup_path]?
+      if cached_route = @cached_routes.get(lookup_path)
         return cached_route
       end
 
@@ -38,8 +139,7 @@ module Kemal
       end
 
       if route.found?
-        @cached_routes.clear if @cached_routes.size == CACHED_ROUTES_LIMIT
-        @cached_routes[lookup_path] = route
+        @cached_routes.put(lookup_path, route)
       end
 
       route