Automatic eviction from memory pool - Kestrel and HTTP.sys (#35822)

* Update aspnetcore/fundamentals/servers/includes/memory-eviction2.md

* ms.date

* Change link to xref link

* Change date to trigger build of include

* check MaxBufferSize

Co-authored-by: Brennan <[email protected]>

---------

Co-authored-by: Brennan <[email protected]>

Author: tdykstra

aspnetcore/fundamentals/servers/httpsys.md

@@ -5,7 +5,7 @@ description: Learn about HTTP.sys, a web server for ASP.NET Core on Windows. Bui
 monikerRange: '>= aspnetcore-2.1'
 ms.author: tdykstra
 ms.custom: mvc
-ms.date: 06/13/2025
+ms.date: 08/04/2025
 uid: fundamentals/servers/httpsys
 ---
 # HTTP.sys web server implementation in ASP.NET Core
@@ -32,6 +32,7 @@ HTTP.sys supports the following features:
 * Response caching
 * WebSockets (Windows 8 or later)
 * Customizable security descriptors
+* Automatic memory pool eviction
 
 Supported Windows versions:
 
@@ -340,6 +341,8 @@ Requirements to run gRPC with HTTP.sys:
 
 For information about how to get traces from HTTP.sys, see [HTTP.sys Manageability Scenarios](/windows/win32/http/http-sys-manageability-scenarios).
 
+[!INCLUDE[](includes/memory-eviction2.md)]
+
 ## Additional resources
 
 * [Enable Windows Authentication with HTTP.sys](xref:security/authentication/windowsauth#httpsys)

aspnetcore/fundamentals/servers/includes/memory-eviction2.md

@@ -0,0 +1,26 @@
+## Automatic eviction from memory pool
+
+The memory pools used by Kestrel, IIS, and HTTP.sys automatically evict memory blocks when the application is idle or under low load. The feature runs automatically and doesn't need to be enabled or configured manually.
+
+In versions of .NET earlier than 10, memory allocated by the pool remains reserved, even when not in use. This automatic eviction feature reduces overall memory usage and helps applications stay responsive under varying workloads.
+
+### Use memory pool metrics
+
+The default memory pool used by the ASP.NET Core server implementations includes metrics, which can be used to monitor and analyze memory usage patterns. The metrics are under the name `"Microsoft.AspNetCore.MemoryPool"`.
+
+For information about metrics and how to use them, see <xref:log-mon/metrics/metrics>.
+
+## Manage memory pools
+
+Besides using memory pools efficiently by evicting unneeded memory blocks, ASP.NET Core provides a built-in [IMemoryPoolFactory](https://source.dot.net/#Microsoft.AspNetCore.Connections.Abstractions/IMemoryPoolFactory.cs) and an implementation. It makes the implementation available to your application through dependency injection.
+
+The following code example shows a simple background service that uses the built-in memory pool factory implementation to create memory pools. These pools benefit from the automatic eviction feature:
+
+:::code language="csharp" source="~/fundamentals/servers/snippets/10.x/my-background-service.cs":::
+
+To use a custom memory pool factory, make a class that implements `IMemoryPoolFactory` and register it with dependency injection, as the following example does. Memory pools created this way also benefit from the automatic eviction feature:
+
+:::code language="csharp" source="~/fundamentals/servers/snippets/10.x/memory-pool-factory.cs":::
+
+When you're using a memory pool, be aware of the pool's <xref:System.Buffers.MemoryPool`1.MaxBufferSize>.
+

aspnetcore/fundamentals/servers/kestrel.md

@@ -5,7 +5,7 @@ description: Learn about Kestrel, the cross-platform web server for ASP.NET Core
 monikerRange: '>= aspnetcore-3.1'
 ms.author: tdykstra
 ms.custom: mvc
-ms.date: 04/04/2023
+ms.date: 08/04/2023
 uid: fundamentals/servers/kestrel
 ---
 # Kestrel web server in ASP.NET Core
@@ -14,7 +14,7 @@ uid: fundamentals/servers/kestrel
 
 By [Tom Dykstra](https://github.com/tdykstra), [Chris Ross](https://github.com/Tratcher), and [Stephen Halter](https://twitter.com/halter73)
 
-:::moniker range=">= aspnetcore-8.0"
+:::moniker range=">= aspnetcore-10.0"
 
 Kestrel is a cross-platform [web server for ASP.NET Core](xref:fundamentals/servers/index). Kestrel is the recommended server for ASP.NET Core, and it's configured by default in ASP.NET Core project templates.
 
@@ -33,6 +33,7 @@ Kestrel's features include:
   * Building a reverse proxy with [YARP](https://github.com/microsoft/reverse-proxy).
 * **Extensibility:** Customize Kestrel through configuration, middleware, and custom transports.
 * **Performance diagnostics:** Kestrel provides built-in performance diagnostics features, such as logging and metrics.
+* **Memory management:** Kestrel includes features for efficient memory management, such as automatic eviction from memory pool.
 
 ## Get started
 
@@ -58,6 +59,9 @@ The following timeouts and rate limits aren't enforced when a debugger is attach
 * <xref:Microsoft.AspNetCore.Server.Kestrel.Core.Features.IHttpMinRequestBodyDataRateFeature>
 * <xref:Microsoft.AspNetCore.Server.Kestrel.Core.Features.IHttpMinResponseDataRateFeature>
 
+
+[!INCLUDE[](includes/memory-eviction2.md)]
+
 ## Additional resources
 
 <a name="endpoint-configuration"></a>

aspnetcore/fundamentals/servers/kestrel/includes/kestrel6.md

@@ -1,4 +1,4 @@
-:::moniker range=">= aspnetcore-6.0 < aspnetcore-8.0"
+:::moniker range=">= aspnetcore-6.0 <=aspnetcore-9.0"
 
 Kestrel is a cross-platform [web server for ASP.NET Core](xref:fundamentals/servers/index). Kestrel is the web server that's included and enabled by default in ASP.NET Core project templates.
 

aspnetcore/fundamentals/servers/snippets/10.x/memory-pool-factory.cs

@@ -0,0 +1,13 @@
+services.AddSingleton<IMemoryPoolFactory<byte>,
+CustomMemoryPoolFactory>();
+
+public class CustomMemoryPoolFactory : IMemoryPoolFactory<byte>
+{
+    public MemoryPool<byte> Create()
+    {
+        // Return a custom MemoryPool implementation
+        // or the default, as is shown here.
+        return MemoryPool<byte>.Shared;
+    }
+}
+

aspnetcore/fundamentals/servers/snippets/10.x/my-background-service.cs

@@ -0,0 +1,28 @@
+public class MyBackgroundService : BackgroundService
+{
+    private readonly MemoryPool<byte> _memoryPool;
+
+    public MyBackgroundService(IMemoryPoolFactory<byte> factory)
+    {
+        _memoryPool = factory.Create();
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            try
+            {
+                await Task.Delay(20, stoppingToken);
+                // do work that needs memory
+                // consider checking _memoryPool.MaxBufferSize
+                var rented = _memoryPool.Rent(100);
+                rented.Dispose();
+            }
+            catch (OperationCanceledException)
+            {
+                return;
+            }
+        }
+    }
+}