c# - HttpClient dando como resultado la fuga del nodo<Objeto> en mscorlib

memory memory-leaks

Question

Considere el siguiente programa, with all of HttpRequestMessage, and HttpResponseMessage, and HttpClient disposed properly. Siempre termina con aproximadamente 50 MB de memoria al final, después de la recopilación. Agregue un cero a la cantidad de solicitudes y la memoria no recuperada se duplica.

   class Program
    {
        static void Main(string[] args)
        {
            var client = new HttpClient { 
                   BaseAddress = new Uri("http://localhost:5000/")};

            var t = Task.Run(async () =>
            {
                var resps = new List<Task<HttpResponseMessage>>();
                var postProcessing = new List<Task>();

                for (int i = 0; i < 10000; i++)
                {
                    Console.WriteLine("Firing..");
                    var req = new HttpRequestMessage(HttpMethod.Get,
                                                        "test/delay/5");
                    var tsk = client.SendAsync(req);
                    resps.Add(tsk);
                    postProcessing.Add(tsk.ContinueWith(async ts =>
                    {
                        req.Dispose();
                        var resp = ts.Result;
                        var content = await resp.Content.ReadAsStringAsync();
                        resp.Dispose();
                        Console.WriteLine(content);
                    }));
                }

                await Task.WhenAll(resps);
                resps.Clear();
                Console.WriteLine("All requests done.");
                await Task.WhenAll(postProcessing);
                postProcessing.Clear();
                Console.WriteLine("All postprocessing done.");
            });

            t.Wait();
            Console.Clear();

            var t2 = Task.Run(async () =>
            {
                var resps = new List<Task<HttpResponseMessage>>();
                var postProcessing = new List<Task>();

                for (int i = 0; i < 10000; i++)
                {
                    Console.WriteLine("Firing..");
                    var req = new HttpRequestMessage(HttpMethod.Get,
                                                        "test/delay/5");
                    var tsk = client.SendAsync(req);
                    resps.Add(tsk);
                    postProcessing.Add(tsk.ContinueWith(async ts =>
                    {
                        var resp = ts.Result;
                        var content = await resp.Content.ReadAsStringAsync();
                        Console.WriteLine(content);
                    }));
                }

                await Task.WhenAll(resps);
                resps.Clear();
                Console.WriteLine("All requests done.");
                await Task.WhenAll(postProcessing);
                postProcessing.Clear();
                Console.WriteLine("All postprocessing done.");
            });

            t2.Wait();
            Console.Clear();
            client.Dispose();

            GC.Collect();
            Console.WriteLine("Done");
            Console.ReadLine();
        }
    }

En una investigación rápida con un generador de perfiles de memoria, parece que los objetos que ocupan la memoria son todos del tipo Node<Object> dentro de mscorlib.

Sin embargo, mi inicial fue que era un diccionario interno o una pila, ya que son los tipos que usan Nodo como estructura interna, pero no pude encontrar ningún resultado para un Node<T> genérico Node<T> en la fuente de referencia ya que este en realidad es el tipo de Node<object> .

¿Es esto un error, o una especie de optimización esperada (no consideraría un consumo proporcional de memoria siempre retenido como una optimización de ninguna manera)? Y puramente académico, ¿cuál es el Node<Object> .

Cualquier ayuda para entender esto sería muy apreciada. Gracias :)

Actualización: para extrapolar los resultados de un conjunto de pruebas mucho más grande, lo optimicé ligeramente al estrangularlo.

Aquí está el programa cambiado. Y ahora, it seems to stay consistent at 60-70MB , para un conjunto de solicitud de 1 millón. Todavía estoy desconcertado por lo que esos Node<object> realmente son, y se le permite mantener una cantidad tan alta de objetos irrecuperables.

Y la conclusión lógica de las diferencias en estos dos resultados me lleva a adivinar, esto puede no ser realmente un problema con HttpClient o WebRequest, más bien algo rooteado directamente con async - Dado que la variante real en estas dos pruebas es la cantidad de asincronías incompletas tareas que existen en un punto dado en el tiempo. Esto es meramente una especulación de la inspección rápida.

static void Main(string[] args)
{

    Console.WriteLine("Ready to start.");
    Console.ReadLine();

    var client = new HttpClient { BaseAddress = 
                    new Uri("http://localhost:5000/") };

    var t = Task.Run(async () =>
    {
        var resps = new List<Task<HttpResponseMessage>>();
        var postProcessing = new List<Task>();

        for (int i = 0; i < 1000000; i++)
        {
            //Console.WriteLine("Firing..");
            var req = new HttpRequestMessage(HttpMethod.Get, "test/delay/5");
            var tsk = client.SendAsync(req);
            resps.Add(tsk);
            var n = i;
            postProcessing.Add(tsk.ContinueWith(async ts =>
            {
                var resp = ts.Result;
                var content = await resp.Content.ReadAsStringAsync();
                if (n%1000 == 0)
                {
                    Console.WriteLine("Requests processed: " + n);
                }

                //Console.WriteLine(content);
            }));

            if (n%20000 == 0)
            {
                await Task.WhenAll(resps);
                resps.Clear();
            }

        }

        await Task.WhenAll(resps);
        resps.Clear();
        Console.WriteLine("All requests done.");
        await Task.WhenAll(postProcessing);
        postProcessing.Clear();
        Console.WriteLine("All postprocessing done.");
    });

    t.Wait();
    Console.Clear();
    client.Dispose();

    GC.Collect();
    Console.WriteLine("Done");
    Console.ReadLine();
}

Answer 1

Investiguemos el problema con todas las herramientas que tenemos a mano.

En primer lugar, echemos un vistazo a cuáles son esos objetos, para hacerlo, puse el código dado en Visual Studio y creé una aplicación de consola simple. De lado a lado, ejecuto un servidor HTTP simple en Node.js para atender las solicitudes.

Ejecutar el cliente hasta el final y comenzar a adjuntar WinDBG, inspecciono el montón administrado y obtengo estos resultados:

0:037> !dumpheap
Address       MT     Size
02471000 00779700       10 Free
0247100c 72482744       84     
...
Statistics:
      MT    Count    TotalSize Class Name
...
72450e88      847        13552 System.Collections.Concurrent.ConcurrentStack`1+Node[[System.Object, mscorlib]]
...

El comando! Dumpheap arroja todos los objetos en el montón gestionado allí. Eso podría incluir objetos que deberían liberarse (pero aún no porque GC aún no se ha activado). En nuestro caso, eso debería ser raro porque acabamos de llamar a GC.Collect () antes de la impresión y no debe ejecutarse nada más después de la impresión.

Digno de notar es la línea específica anterior. Ese debería ser el objeto Node al que se refiere en la pregunta.

A continuación, veamos los objetos individuales de ese tipo, tomamos el valor MT de ese objeto y luego invocamos! Dumpheap nuevamente de esta manera, esto filtrará solo los objetos que nos interesan.

0:037> !dumpheap -mt 72450e88   
 Address       MT     Size
025b9234 72450e88       16     
025b93dc 72450e88       16     
...

Ahora agarrando uno al azar en la lista, y luego le pregunta al depurador por qué este objeto todavía está en el montón invocando el comando! Gcroot de la siguiente manera:

0:037> !gcroot 025bbc8c
Thread 6f24:
    0650f13c 79752354 System.Net.TimerThread.ThreadProc()
        edi:  (interior)
            ->  034734c8 System.Object[]
            ->  024915ec System.PinnableBufferCache
            ->  02491750 System.Collections.Concurrent.ConcurrentStack`1[[System.Object, mscorlib]]
            ->  09c2145c System.Collections.Concurrent.ConcurrentStack`1+Node[[System.Object, mscorlib]]
            ->  09c2144c System.Collections.Concurrent.ConcurrentStack`1+Node[[System.Object, mscorlib]]
            ->  025bbc8c System.Collections.Concurrent.ConcurrentStack`1+Node[[System.Object, mscorlib]]

Found 1 unique roots (run ''!GCRoot -all'' to see all roots).

Ahora es bastante obvio que tenemos un caché, y ese caché mantiene una pila, con la pila implementada como una lista vinculada. Si reflexionamos más, veremos en la fuente de referencia cómo se usa esa lista. Para hacer eso, primero inspeccionemos el objeto de caché, usando! DumpObj

0:037> !DumpObj 024915ec 
Name:        System.PinnableBufferCache
MethodTable: 797c2b44
EEClass:     795e5bc4
Size:        52(0x34) bytes
File:        C:/WINDOWS/Microsoft.Net/assembly/GAC_MSIL/System/v4.0_4.0.0.0__b77a5c561934e089/System.dll
Fields:
      MT    Field   Offset                 Type VT     Attr    Value Name
724825fc  40004f6        4        System.String  0 instance 024914a0 m_CacheName
7248c170  40004f7        8 ...bject, mscorlib]]  0 instance 0249162c m_factory
71fe994c  40004f8        c ...bject, mscorlib]]  0 instance 02491750 m_FreeList
71fed558  40004f9       10 ...bject, mscorlib]]  0 instance 025b93b8 m_NotGen2
72484544  40004fa       14         System.Int32  1 instance        0 m_gen1CountAtLastRestock
72484544  40004fb       18         System.Int32  1 instance 605289781 m_msecNoUseBeyondFreeListSinceThisTime
7248fc58  40004fc       2c       System.Boolean  1 instance        0 m_moreThanFreeListNeeded
72484544  40004fd       1c         System.Int32  1 instance      244 m_buffersUnderManagement
72484544  40004fe       20         System.Int32  1 instance      128 m_restockSize
7248fc58  40004ff       2d       System.Boolean  1 instance        1 m_trimmingExperimentInProgress
72484544  4000500       24         System.Int32  1 instance        0 m_minBufferCount
72484544  4000501       28         System.Int32  1 instance        0 m_numAllocCalls

Ahora que vemos algo interesante, la pila se usa realmente como una lista gratuita para el caché. El código fuente nos dice cómo se usa la lista gratuita, en particular, en el método Free () que se muestra a continuación:

http://referencesource.microsoft.com/#mscorlib/parent/parent/parent/parent/InternalApis/NDP_Common/inc/PinnableBufferCache.cs

/// <summary>
/// Return a buffer back to the buffer manager.
/// </summary>
[System.Security.SecuritySafeCritical]
internal void Free(object buffer)
{
  ...
  m_FreeList.Push(buffer);
}

Así que eso es todo, cuando la persona que llama termina el búfer, regresa a la memoria caché, la memoria caché la coloca en la lista libre, la lista gratuita se usa para fines de asignación

[System.Security.SecuritySafeCritical]
internal object Allocate()
{
  // Fast path, get it from our Gen2 aged m_FreeList.  
  object returnBuffer;
  if (!m_FreeList.TryPop(out returnBuffer))
    Restock(out returnBuffer);
  ...
}

Por último, pero no por eso menos importante, vamos a entender por qué la memoria caché en sí no se libera cuando terminamos todas esas solicitudes HTTP. Aquí está el por qué. Al agregar un punto de interrupción en mscorlib.dll! System.Collections.Concurrent.ConcurrentStack.Push (), vemos la siguiente pila de llamadas (bueno, este podría ser solo uno de los casos de uso de caché, pero esto es representativo)

mscorlib.dll!System.Collections.Concurrent.ConcurrentStack<object>.Push(object item)
System.dll!System.PinnableBufferCache.Free(object buffer)
System.dll!System.Net.HttpWebRequest.FreeWriteBuffer()
System.dll!System.Net.ConnectStream.WriteHeadersCallback(System.IAsyncResult ar)
System.dll!System.Net.LazyAsyncResult.Complete(System.IntPtr userToken)
System.dll!System.Net.ContextAwareResult.Complete(System.IntPtr userToken)
System.dll!System.Net.LazyAsyncResult.ProtectedInvokeCallback(object result, System.IntPtr userToken)
System.dll!System.Net.Sockets.BaseOverlappedAsyncResult.CompletionPortCallback(uint errorCode, uint numBytes, System.Threading.NativeOverlapped* nativeOverlapped)
mscorlib.dll!System.Threading._IOCompletionCallback.PerformIOCompletionCallback(uint errorCode, uint numBytes, System.Threading.NativeOverlapped* pOVERLAP)

En WriteHeadersCallback, hemos terminado de escribir los encabezados, por lo que devolvemos el búfer al caché. En este punto, el búfer vuelve a la lista libre y, por lo tanto, asignamos un nuevo nodo de pila. La clave a tener en cuenta es que el objeto de caché es un miembro estático de HttpWebRequest.

http://referencesource.microsoft.com/#System/net/System/Net/HttpWebRequest.cs

...
private static PinnableBufferCache _WriteBufferCache = new PinnableBufferCache("System.Net.HttpWebRequest", CachedWriteBufferSize);
...
// Return the buffer to the pinnable cache if it came from there.   
internal void FreeWriteBuffer()
{
  if (_WriteBufferFromPinnableCache)
  {
    _WriteBufferCache.FreeBuffer(_WriteBuffer);
    _WriteBufferFromPinnableCache = false;
  }
  _WriteBufferLength = 0;
  _WriteBuffer = null;
}
...

Así que ahí vamos, el caché se comparte en todas las solicitudes y no se libera cuando se realizan todas las solicitudes.

Answer 2

Tuvimos los mismos problemas cuando usamos System.Net.WebRequest para hacer algunas solicitudes http. El tamaño del proceso w3wp tenía un rango de 4-8 Gb, porque no tenemos una carga constante. A veces tenemos 10 solicitudes por segundo y 1000 en otro momento. Por supuesto, el búfer no se reutiliza en el mismo escenario.

Cambiamos todos los sitios cuando utilizamos System.Net.WebRequest en System.Net.Http.HttpClient porque no tiene ningún grupo de búferes.

Si tiene muchas solicitudes a través de su httpclient, hágalo como una variable estática para evitar filtraciones de Socket .

Creo que de una forma más simple analizar este problema: use PerfView . Esta aplicación puede mostrar el árbol de referencia para que pueda mostrar el caso raíz de su problema.