Para un informe de 400 páginas que incrusta una única fuente de 2 MB, cobrarle a cada página todo lo que referencia produce un total extraño: las páginas suman 800 MB de fuente en un fichero que quizá ocupe 30 MB en disco. Reparta en cambio la fuente a partes iguales y cada página cuesta unos 5 KB, con lo que nada parece caro y la memoria parece salir de ninguna parte. Ninguno de los dos números responde a la pregunta real: cuántos bytes se liberarían si un objeto concreto desapareciera
Esa cifra tiene nombre en el análisis de heap, tamaño retenido, y la teoría de grafos ofrece una forma limpia de calcularla. Un objeto se le imputa a su dominador, el objeto más cercano por el que toda ruta desde la raíz tiene que pasar para llegar a él. Los objetos compartidos flotan hacia arriba hasta alcanzar un nodo que de verdad los posee, los exclusivos se quedan donde están, y los totales cuadran sin contabilizaciones dobles
Tamaño superficial, tamaño retenido y la regla del dominador en HotPDF
HotPDF calcula esto para un documento cargado mediante THotPDF.BuildLoadedObjectDependencyGraph. La llamada devuelve un THPDFObjectDependencyNode por cada objeto indirecto cargado y un THPDFObjectDependencyEdge por cada referencia indirecta, y después ejecuta un análisis de dominadores con raíz en el Catalog del documento, el objeto nombrado por la entrada /Root del trailer (ISO 32000-1 §7.7.2). Cada nodo lleva dos tamaños. EstimatedShallowBytes es lo que el objeto cuesta por sí solo. EstimatedRetainedBytes es su propio coste más el coste superficial de cada objeto que domina
Volvamos a la fuente. Cada página la referencia, así que ninguna página la domina por sí sola; las rutas solo convergen en el nodo del árbol de páginas situado sobre esas páginas, que en un árbol plano es el objeto /Pages raíz. Los 2 MB de la fuente caen ahí y luego ascienden hasta el Catalog. Un XObject de imagen dibujado en la página 12 y en ninguna otra es el caso contrario: toda ruta hacia él pasa por la página 12, de modo que el tamaño retenido de la página 12 incluye la imagen entera. Por eso, lo más alto de la lista de retenidos es una lista de objetos cuya eliminación liberaría memoria
La misma aritmética regala una comprobación cruzada. THPDFObjectDependencyGraphInfo.CatalogRetainedBytes equivale a la suma de tamaños superficiales de todos los objetos alcanzables desde el Catalog, y TotalEstimatedBytes es la suma de tamaños superficiales de todos los objetos cargados, alcanzables o no. La diferencia entre ambos es memoria retenida por objetos a los que el documento ya no apunta
Ejecutar el grafo y leer un resultado fallido
El método devuelve True solo cuando el análisis completo terminó, y ese valor de retorno es lo que hay que comprobar. Un resultado False también rellena el registro de información, pero los arrays no son algo de lo que informar. Cuando el recuento de objetos supera MaxObjects (por defecto 250.000), el método se detiene antes de construir nodos y fija ObjectCount en uno más que el límite, de modo que usted se entera de que el límite era demasiado pequeño, no de lo grande que es el documento. Cuando se alcanza el presupuesto de aristas (por defecto 2.000.000) o el límite de anidamiento de 256 niveles para objetos directos durante el barrido, los nodos vuelven con tamaños superficiales parciales y sin tamaños retenidos ni alcanzabilidad
uses
SysUtils, HPDFDoc;
procedure ProfileLoadedPdf(const FileName: string);
var
Pdf: THotPDF;
Nodes: THPDFObjectDependencyNodeArray;
Edges: THPDFObjectDependencyEdgeArray;
Info: THPDFObjectDependencyGraphInfo;
begin
Pdf := THotPDF.Create(nil);
try
// LoadFromFile devuelve el número de páginas; 0 significa que la carga falló
if Pdf.LoadFromFile(FileName) = 0 then
Exit;
// Límites elevados para una ejecución forense sin conexión
if not Pdf.BuildLoadedObjectDependencyGraph(Nodes, Edges, Info,
1000000, 8000000) then
begin
// Log es su propia rutina de registro
Log(Format('graph incomplete: %s (limit %s, invalid %s, objects %d)',
[string(Info.Diagnostic), BoolToStr(Info.LimitExceeded, True),
BoolToStr(Info.InvalidObjectGraph, True), Info.ObjectCount]));
Exit; // no ordene ni sume un array de nodos parcial
end;
Log(Format('%d objects, %d edges (%d unresolved), %d reachable',
[Info.ObjectCount, Info.EdgeCount, Info.UnresolvedReferenceCount,
Info.ReachableObjectCount]));
Log(Format('estimated %d bytes, Catalog retains %d, unreachable %d',
[Info.TotalEstimatedBytes, Info.CatalogRetainedBytes,
Info.TotalEstimatedBytes - Info.CatalogRetainedBytes]));
LogTopRetained(Nodes, Edges, 10);
finally
Pdf.Free;
end;
end;
Dos indicadores más merecen una mirada en esa rama de fallo. InvalidObjectGraph se activa cuando el objeto Catalog no se encuentra entre los objetos cargados, o cuando un objeto directo resulta contenerse a sí mismo, lo que solo ocurre en entradas mal formadas. LimitExceeded cubre también un análisis de dominadores que no ha convergido tras 128 pasadas. Diagnostic explica cada caso en una línea. Pasar cero o un valor negativo en MaxObjects, o un MaxEdges negativo, lanza EArgumentOutOfRangeException en lugar de devolver False
Cuando la llamada falla por un límite, tire los arrays y ejecútela de nuevo con límites mayores. Los tamaños superficiales parciales parecen verosímiles en un registro y están equivocados exactamente de la manera que manda a la gente tras el objeto equivocado. Los límites existen porque el grafo tiene su propio coste: cada arista guarda una cadena Path, así que una ejecución de ocho millones de aristas asigna ocho millones de cadenas pequeñas encima del documento que está midiendo. Su sitio es una ruta de diagnóstico que alguien lanza a propósito
¿Qué cuenta realmente EstimatedShallowBytes?
EstimatedShallowBytes estima memoria residente, no bytes en el fichero. Para cada objeto suma el tamaño de instancia del objeto analizado y de sus hijos directos, las ranuras que mantienen las listas de diccionarios y arrays, la longitud de cada clave, nombre y cadena, y la carga útil de un flujo si esa carga está en RAM: un flujo de memoria, o un flujo de carga diferida que ya se ha leído a memoria. Un flujo cuyos bytes siguen en el fichero de origen, o que se ha derramado a un fichero temporal, solo aporta su sobrecarga de objeto
Eso tiene una consecuencia práctica. Un fichero cargado de escaneos perfilado justo después de la carga puede mostrar tamaños retenidos modestos para sus imágenes, porque nada las ha decodificado todavía. Ejecute el grafo después del paso que hizo crecer el proceso (renderizado, extracción de texto, una fusión) y los flujos materializados aparecerán con su peso real. Para una comprobación reproducible, perfile el mismo fichero dos veces, una justo tras LoadFromFile y otra tras la operación cara, y compare las entradas superiores
ObjectType es grueso. Informa del tipo de valor PDF, otStream o otDictionary y demás, así que una imagen, un programa de fuente y un flujo de contenido de página se leen todos como otStream. La arista entrante es donde se ve el papel. THPDFObjectDependencyEdge.Path registra dónde se encontró la referencia en el objeto de origen, empezando por $, con /Key para entradas de diccionario, [n] para elementos de array y /dictionary para el diccionario de un flujo. Una ruta $/Resources/XObject/Im3 desde una página, o $/XObject/Im3 desde un diccionario de recursos separado, significa que el objeto se usa como un XObject llamado Im3; $/FontFile2 viniendo de un descriptor de fuente significa un programa TrueType incrustado; $/Contents[0] significa contenido de página
// Ayudante propio, no forma parte de la biblioteca: ordena los primeros Count nodos por
// tamaño retenido y muestra la ruta de una referencia entrante de cada uno
procedure LogTopRetained(const Nodes: THPDFObjectDependencyNodeArray;
const Edges: THPDFObjectDependencyEdgeArray; Count: Integer);
var
Taken: array of Boolean;
I, J, Best: Integer;
Via: AnsiString;
begin
SetLength(Taken, Length(Nodes));
for I := 1 to Count do
begin
Best := -1;
for J := 0 to High(Nodes) do
if (not Taken[J]) and ((Best < 0) or
(Nodes[J].EstimatedRetainedBytes >
Nodes[Best].EstimatedRetainedBytes)) then
Best := J;
if Best < 0 then
Break;
Taken[Best] := True;
Via := '(no incoming reference)';
for J := 0 to High(Edges) do
if Edges[J].Resolved and
(Edges[J].TargetObjectNumber = Nodes[Best].ObjectNumber) and
(Edges[J].TargetGenerationNumber = Nodes[Best].GenerationNumber) then
begin
Via := Edges[J].Path;
Break;
end;
Log(Format('%d %d obj shallow %d retained %d refs in %d via %s',
[Nodes[Best].ObjectNumber, Nodes[Best].GenerationNumber,
Nodes[Best].EstimatedShallowBytes, Nodes[Best].EstimatedRetainedBytes,
Nodes[Best].IncomingReferenceCount, string(Via)]));
end;
end;
Una ruta entrante basta para clasificar la mayoría de los objetos. Para un objeto compartido, IncomingReferenceCount le dice cuántas referencias hay, y ImmediateDominatorObjectNumber con su número de generación le dice qué objeto lo posee tras el análisis de dominadores. Ese campo vale -1 para el Catalog y para cada objeto que el Catalog no puede alcanzar. Una arista cuyo indicador Resolved es False apunta a un número de objeto que no está cargado; esas se cuentan en UnresolvedReferenceCount, y un recuento alto en un fichero por lo demás sano suele significar una sección de referencias cruzadas dañada
¿De dónde salen los objetos inalcanzables?
Un nodo con ReachableFromCatalog a False está cargado y cuesta memoria, pero ninguna cadena de referencias desde el Catalog conduce a él, así que nada en la estructura del documento lleva un visor hasta él. Su tamaño retenido equivale a su tamaño superficial, porque el análisis de dominadores solo se ejecuta sobre objetos alcanzables. Sumar EstimatedRetainedBytes sobre los nodos inalcanzables da por tanto la misma respuesta que TotalEstimatedBytes - CatalogRetainedBytes
Las actualizaciones incrementales son una fuente habitual, aunque no de la manera que la gente suele asumir. Cuando una revisión posterior redefine el objeto 2120, gana la entrada más nueva de la tabla de referencias cruzadas y la definición antigua nunca se carga, así que las copias sustituidas de un mismo número de objeto no aparecen en el grafo. Lo que sí aparece es un objeto al que una revisión posterior simplemente dejó de referenciar: una anotación retirada de un array /Annots reescrito, una imagen reemplazada por un número de objeto nuevo, un campo de formulario eliminado del AcroForm. Nada en ISO 32000-1 §7.5.6 obliga a una actualización a marcar esas entradas como libres, y mientras los datos de referencias cruzadas las mantengan como en uso, el cargador las trata como objetos vivos. El artículo sobre flujos de objetos y actualizaciones incrementales explica cómo se apilan las revisiones
Las otras dos fuentes son productores que escriben objetos y luego no llegan a enlazarlos, y ficheros dañados cuyos datos de referencias cruzadas hubo que reconstruir barriendo, lo cual puede recoger definiciones de objeto que nada referencia. Cuando una parte grande del total estimado está en nodos inalcanzables, reescribir el fichero limpiamente gana a añadir otra revisión más, y el grafo le da el recuento de bytes que justifica el guardado más lento
¿Es el analizador quien retiene la memoria?
Antes de culpar al documento, compruebe cómo se comportó la carga. Dos llamadas describen al analizador en lugar del contenido, y ambas se reinician al principio de cada LoadFromFile o LoadFromStream, así que siempre describen la carga más reciente
GetLastParserArenaStatistics rellena un registro THPDFParserArenaStatistics para el área de bloques que guarda tokens y búferes de vida corta durante el análisis. Los bloques son de 64 KiB (BlockSize), y una asignación mayor que un bloque recibe un bloque de su propio tamaño. AllocationCount menos ReusedAllocationCount equivale a BlockAllocationCount, el número de veces que el área tuvo que pedir un bloque nuevo al gestor de memoria. Los bloques se conservan durante la vida de la instancia THotPDF y se liberan al destruirla. Si una instancia procesa un lote entero, RetainedBytes refleja aproximadamente el mayor conjunto de trabajo que cualquier fichero del lote necesitó, lo que explica una meseta que dura hasta que se libera el componente. TemporaryObjectElisionCount cuenta las claves de diccionario leídas directamente en el área en lugar de construirse como objetos de nombre temporales
GetDocumentStringInternStatistics describe el pool por documento que deduplica nombres PDF, operadores de flujo de contenido y cadenas cortas. Las cadenas de 1 a 64 bytes son elegibles. El pool retiene como máximo 65.536 entradas y 4 MiB, y esos topes vuelven en el registro como MaxStringLength, MaxEntryCount y MaxRetainedBytes. Una cadena vacía, de más de 64 bytes, o nueva cuando el pool está lleno se cuenta en BypassCount y se conserva como cadena ordinaria. Un fichero que genera enormes cantidades de nombres únicos cuesta por tanto aproximadamente lo que costaría sin el pool, y no más
var
Arena: THPDFParserArenaStatistics;
Intern: THPDFDocumentStringInternStatistics;
begin
if Pdf.GetLastParserArenaStatistics(Arena) then
Log(Format('arena: %d blocks, %d bytes held, peak %d, ' +
'%d new blocks for %d allocations, %d tokens',
[Arena.RetainedBlockCount, Arena.RetainedBytes, Arena.PeakUsedBytes,
Arena.BlockAllocationCount, Arena.AllocationCount, Arena.TokenCount]));
if Pdf.GetDocumentStringInternStatistics(Intern) then
begin
Log(Format('intern: %d of %d requests hit, %d bypassed, %d bytes reused',
[Intern.HitCount, Intern.RequestCount, Intern.BypassCount,
Intern.ReusedBytes]));
// Comprobación propia, no es una llamada de la biblioteca: avisa de un pool que alcanzó sus topes
if (Intern.EntryCount >= Intern.MaxEntryCount) or
(Intern.RetainedBytes + Intern.MaxStringLength >
Intern.MaxRetainedBytes) then
Log('intern pool at its cap: later strings were not deduplicated');
end;
end;
Los PDF típicos repiten un vocabulario pequeño de nombres y operadores, así que HitCount se queda cerca de RequestCount y ReusedBytes crece con el número de páginas. Un BypassCount que se acerca a RequestCount en un fichero modesto es inusual. En una ruta de ingesta para subidas no confiables, regístrelo
Un orden de triaje para una queja de memoria
Empiece por CatalogRetainedBytes. Si está cerca del crecimiento que midió en el proceso, la memoria está en el documento y lo más alto de la lista de retenidos lo nombrará. Si está muy por debajo, la memoria vive en algún sitio que el grafo no mide, como sus propias cachés, mapas de bits renderizados o el área del analizador, y el registro del área es lo siguiente que hay que leer
- Ordene los nodos por
EstimatedRetainedBytesy lea laPathentrante de los diez primeros. Los destinos XObject en lo alto suelen apuntar a contenido cargado de escaneos donde el submuestreo compensa; los destinos/FontFile,/FontFile2o/FontFile3apuntan a programas de fuente completos incrustados donde bastarían subconjuntos; los flujos/Contentsgrandes suelen venir de salida vectorial generada, como mapas o exportaciones de CAD - Reste
CatalogRetainedBytesaTotalEstimatedBytes. Un resto grande son objetos abandonados, así que la corrección va en el paso de guardado - Lea los registros del área y del intern al final. Rara vez explican gigabytes, pero sí explican un proceso que sigue grande después de cerrar cada documento
Ejecute esos pasos en ese orden. El primero resuelve la mayoría de las quejas, y para documentos muy grandes la respuesta estructural suele ser dejar de mantener el grafo de objetos completo de una vez, que es para lo que está pensado el flujo de trabajo de la API directa de ficheros
Los tres diagnósticos son llamadas de método ordinarias que devuelven registros planos, así que encajan en cualquier registro o telemetría que una aplicación Delphi o C++Builder ya tenga. HotPDF se distribuye como componente VCL nativo con código fuente completo; la documentación y una descarga de prueba están en la página del componente HotPDF Delphi PDF