Ein 400-Seiten-Bericht mit einer eingebetteten 2-MB-Schriftart erzeugt, wenn man jede Seite für alles belastet, was sie referenziert, eine seltsame Summe: Die Seiten kommen zusammen auf 800 MB Schriftart in einer Datei, die auf der Platte vielleicht 30 MB hat. Teilt man die Schriftart stattdessen gleichmäßig auf, kostet jede Seite etwa 5 KB, nichts wirkt teuer, und der Speicher scheint aus dem Nichts zu kommen. Keine der beiden Zahlen beantwortet die eigentliche Frage: Wie viele Bytes würden freigegeben, wenn ein bestimmtes Objekt verschwände
Diese Zahl hat in der Heap-Analyse einen Namen: Retained Size. Und die Graphentheorie liefert eine saubere Methode, sie zu berechnen. Ein Objekt wird seinem Dominator zugerechnet, dem nächstgelegenen Objekt, durch das jeder Pfad von der Wurzel auf dem Weg zu ihm hindurch muss. Geteilte Objekte wandern nach oben, bis sie bei einem Knoten ankommen, der sie wirklich besitzt; exklusive bleiben, wo sie sind, und die Summen addieren sich ohne Doppelzählung
Shallow-Größe, Retained-Größe und die Dominator-Regel in HotPDF
HotPDF berechnet das für ein geladenes Dokument über THotPDF.BuildLoadedObjectDependencyGraph. Der Aufruf liefert einen THPDFObjectDependencyNode pro geladenem indirekten Objekt und eine THPDFObjectDependencyEdge pro indirekter Referenz, dann läuft eine Dominator-Analyse mit Wurzel im Catalog des Dokuments, dem Objekt hinter dem /Root-Eintrag des Trailers (ISO 32000-1 §7.7.2). Jeder Knoten trägt zwei Größen. EstimatedShallowBytes ist, was das Objekt allein kostet. EstimatedRetainedBytes ist diese Kostenposition plus die Shallow-Kosten jedes Objekts, das er dominiert
Zurück zur Schriftart. Jede Seite referenziert sie, also dominiert keine einzelne Seite sie; die Pfade laufen erst im Seitenbaum-Knoten über diese Seiten zusammen, der in einem flachen Baum das Wurzelobjekt /Pages ist. Die 2 MB der Schriftart landen dort und rollen dann in den Catalog auf. Ein Bild-XObject, das nur auf Seite 12 gezeichnet wird, ist der Gegenfall: Jeder Pfad zu ihm läuft über Seite 12, also enthält die Retained-Größe von Seite 12 das ganze Bild. Die Spitze der Retained-Liste ist damit eine Liste von Objekten, deren Entfernung Speicher freigeben würde
Dieselbe Rechnung liefert eine Gegenprobe gratis. THPDFObjectDependencyGraphInfo.CatalogRetainedBytes entspricht der summierten Shallow-Größe aller vom Catalog aus erreichbaren Objekte, und TotalEstimatedBytes ist die summierte Shallow-Größe aller geladenen Objekte, erreichbar oder nicht. Die Lücke zwischen beiden ist Speicher, den Objekte halten, auf die das Dokument nicht mehr zeigt
Den Graphen laufen lassen und ein fehlgeschlagenes Ergebnis lesen
Die Methode liefert nur dann True, wenn die gesamte Analyse durchgelaufen ist, und dieser Rückgabewert ist das, was man prüfen muss. Ein False-Ergebnis füllt den Info-Record trotzdem, aber die Arrays sind nichts, womit man berichten sollte. Übersteigt die Objektzahl MaxObjects (Standard 250.000), bricht die Methode ab, bevor sie irgendeinen Knoten baut, und setzt ObjectCount auf genau einen mehr als das Limit — man erfährt also, dass das Limit zu klein war, nicht, wie groß das Dokument ist. Wird während des Scans das Kantenbudget (Standard 2.000.000) oder die 256-stufige Verschachtelungsgrenze für direkte Objekte erreicht, kommen die Knoten mit teilweisen Shallow-Größen zurück und ganz ohne Retained-Größen oder Erreichbarkeitsangaben
uses
SysUtils, HPDFDoc;
procedure ProfileLoadedPdf(const FileName: string);
var
Pdf: THotPDF;
Nodes: THPDFObjectDependencyNodeArray;
Edges: THPDFObjectDependencyEdgeArray;
Info: THPDFObjectDependencyGraphInfo;
begin
Pdf := THotPDF.Create(nil);
try
// LoadFromFile liefert die Seitenzahl; 0 bedeutet, das Laden ist fehlgeschlagen
if Pdf.LoadFromFile(FileName) = 0 then
Exit;
// Erhöhte Grenzen für einen forensischen Offline-Lauf
if not Pdf.BuildLoadedObjectDependencyGraph(Nodes, Edges, Info,
1000000, 8000000) then
begin
// Log ist Ihre eigene Logging-Routine
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; // kein teilweises Node-Array rangieren oder aufsummieren
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;
Zwei weitere Flags verdienen in diesem Fehlerzweig einen Blick. InvalidObjectGraph wird gesetzt, wenn das Catalog-Objekt unter den geladenen Objekten nicht zu finden ist oder wenn sich ein direktes Objekt am Ende selbst enthält — das passiert nur bei fehlerhaften Eingabedateien. LimitExceeded deckt auch eine Dominator-Analyse ab, die nach 128 Durchläufen nicht zur Ruhe kommt. Diagnostic erklärt jeden dieser Fälle in einer Zeile. Null oder ein negativer Wert für MaxObjects, ein negativer MaxEdges-Wert löst dagegen EArgumentOutOfRangeException aus, statt False zurückzugeben
Schlägt der Aufruf an einem Limit fehl, werfen Sie die Arrays weg und lassen ihn mit größeren Grenzen erneut laufen. Partielle Shallow-Größen sehen in einem Log plausibel aus und sind genau auf die Art falsch, die der Fehlersuche das falsche Objekt vor die Füße wirft. Die Grenzen existieren, weil der Graph selbst Kosten hat: Jede Kante speichert einen Path-String, also allokiert ein Lauf mit acht Millionen Kanten acht Millionen kleine Strings — obendrauf zu dem Dokument, das er gerade misst. So etwas gehört in einen Diagnosepfad, den jemand bewusst anstößt
Was zählt EstimatedShallowBytes tatsächlich?
EstimatedShallowBytes schätzt residenten Speicher, nicht Bytes in der Datei. Pro Objekt kommt hinzu: die Instanzgröße des geparsten Objekts samt seiner direkten Kinder, die Slots, die Dictionary- und Array-Listen halten, die Länge jedes Schlüssels, Namens und Strings, und der Payload eines Streams, falls dieser im RAM liegt — ein Memory-Stream oder ein lazy geladener Stream, der bereits in den Speicher gelesen wurde. Ein Stream, dessen Bytes noch in der Quelldatei liegen oder der in eine temporäre Datei ausgelagert wurde, trägt nur seinen Objekt-Overhead bei
Das hat eine praktische Konsequenz. Eine scan-lastige Datei, direkt nach dem Laden profiliert, kann für ihre Bilder bescheidene Retained-Größen zeigen, weil noch nichts sie dekodiert hat. Lässt man den Graphen nach dem Schritt laufen, der den Prozess wachsen ließ (Rendering, Textextraktion, ein Merge), tauchen die materialisierten Streams mit ihrem echten Gewicht auf. Für einen reproduzierbaren Check: dieselbe Datei zweimal profilieren, einmal direkt nach LoadFromFile, einmal nach der teuren Operation, und die obersten Einträge vergleichen
ObjectType ist grob. Er meldet den PDF-Werttyp, otStream oder otDictionary und so weiter, weshalb ein Bild, ein Font-Programm und ein Seiten-Content-Stream alle als otStream durchgehen. Die eingehende Kante verrät die Rolle. THPDFObjectDependencyEdge.Path hält fest, wo im Quellobjekt die Referenz gefunden wurde, beginnend bei $, mit /Key für Dictionary-Einträge, [n] für Array-Elemente und /dictionary für das Dictionary eines Streams. Ein Pfad $/Resources/XObject/Im3 von einer Seite aus, oder $/XObject/Im3 aus einem separaten Resource-Dictionary, heißt, das Objekt dient als XObject namens Im3; $/FontFile2 von einem Font-Descriptor heißt ein eingebettetes TrueType-Programm; $/Contents[0] heißt Seiteninhalt
// Eigener Helfer, kein Bestandteil der Bibliothek: rangiert die obersten
// Count-Knoten nach Retained-Größe und gibt je Knoten einen Pfad aus
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;
Eine einzige eingehende Referenz reicht, um die meisten Objekte einzuordnen. Bei einem geteilten Objekt sagt IncomingReferenceCount, wie viele Referenzen es gibt, und ImmediateDominatorObjectNumber samt Generationsnummer sagt, welches Objekt es nach der Dominator-Analyse besitzt. Dieses Feld ist -1 für den Catalog und für jedes Objekt, das der Catalog nicht erreicht. Eine Kante mit Resolved auf False zeigt auf eine Objektnummer, die nicht geladen ist; solche zählen in UnresolvedReferenceCount, und ein hoher Wert bei einer sonst gesunden Datei bedeutet meist einen beschädigten Cross-Reference-Abschnitt
Woher kommen unerreichbare Objekte?
Ein Knoten mit ReachableFromCatalog auf False ist geladen und kostet Speicher, aber keine Referenzkette vom Catalog aus führt zu ihm, also führt auch nichts in der Dokumentstruktur einen Viewer zu ihm. Seine Retained-Größe entspricht seiner Shallow-Größe, denn die Dominator-Analyse läuft nur über erreichbare Objekte. Die Summe von EstimatedRetainedBytes über alle unerreichbaren Knoten liefert deshalb dasselbe Ergebnis wie TotalEstimatedBytes - CatalogRetainedBytes
Inkrementelle Updates sind eine häufige Quelle, nur nicht auf die Art, wie man meist annimmt. Redefiniert eine spätere Revision Objekt 2120, gewinnt der neueste Cross-Reference-Eintrag, und die ältere Definition wird nie geladen — überholte Kopien derselben Objektnummer tauchen im Graphen also nicht auf. Was auftaucht, ist ein Objekt, das eine spätere Revision schlicht nicht mehr referenziert: eine Annotation, die aus einem neu geschriebenen /Annots-Array geflogen ist, ein Bild, das eine neue Objektnummer ersetzt hat, ein Formularfeld, das aus dem AcroForm entfernt wurde. Nichts in ISO 32000-1 §7.5.6 verpflichtet ein Update, diese Einträge als frei zu markieren, und solange die Cross-Reference-Daten sie als belegt listen, behandelt der Loader sie als lebende Objekte. Der Artikel zu Object Streams und inkrementellen Updates beschreibt, wie Revisionen übereinander stapeln
Die anderen beiden Quellen sind Producer, die Objekte schreiben und dann versäumen, sie zu verknüpfen, und beschädigte Dateien, deren Cross-Reference-Daten per Scan rekonstruiert werden mussten — dabei können Objektdefinitionen eingesammelt werden, auf die nichts verweist. Steckt ein großer Anteil der geschätzten Gesamtsumme in unerreichbaren Knoten, schlägt ein sauberes Neuschreiben der Datei jede weitere angehängte Revision, und der Graph liefert die Bytezahl, um den langsameren Save zu rechtfertigen
Ist der Parser der, der den Speicher hält?
Bevor Sie dem Dokument die Schuld geben, prüfen Sie, wie das Laden selbst gelaufen ist. Zwei Aufrufe beschreiben den Parser statt den Inhalt, und beide setzen sich zu Beginn jedes LoadFromFile oder LoadFromStream zurück — sie beschreiben also immer die zuletzt geladene Datei
GetLastParserArenaStatistics füllt einen THPDFParserArenaStatistics-Record für die Block-Arena, die während des Parsens kurzlebige Tokens und Puffer hält. Blöcke sind 64 KiB groß (BlockSize), und eine Allokation größer als ein Block bekommt einen Block in eigener Größe. AllocationCount minus ReusedAllocationCount ergibt BlockAllocationCount, die Zahl der Male, zu denen die Arena den Memory-Manager um einen neuen Block bitten musste. Blöcke bleiben über die Lebensdauer der THotPDF-Instanz erhalten und werden freigegeben, wenn sie zerstört wird. Verarbeitet eine Instanz einen ganzen Batch, spiegelt RetainedBytes ungefähr das größte Working Set, das irgendeine Datei des Batchs brauchte — das erklärt ein Plateau, das bis zur Freigabe der Komponente anhält. TemporaryObjectElisionCount zählt Dictionary-Schlüssel, die direkt in die Arena gelesen statt als temporäre Name-Objekte gebaut werden
GetDocumentStringInternStatistics beschreibt den Pool pro Dokument, der PDF-Namen, Content-Stream-Operatoren und kurze Strings dedupliziert. Strings von 1 bis 64 Bytes sind kandidierbar. Der Pool fasst höchstens 65.536 Einträge und 4 MiB, und diese Obergrenzen kommen als MaxStringLength, MaxEntryCount und MaxRetainedBytes im Record zurück. Ein String, der leer ist, länger als 64 Bytes oder neu ist, während der Pool voll ist, zählt in BypassCount und bleibt ein gewöhnlicher String. Eine Datei, die massenhaft eindeutige Namen erzeugt, kostet deshalb ungefähr das, was sie ohne den Pool kosten würde, und nicht mehr
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]));
// Eigene Prüfung, kein Bibliotheksaufruf: markiert einen Pool an Obergrenzen
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;
Typische PDFs wiederholen einen kleinen Wortschatz aus Namen und Operatoren, deshalb liegt HitCount nahe an RequestCount, und ReusedBytes wächst mit der Seitenzahl. Ein BypassCount, der sich bei einer normalen Datei RequestCount nähert, ist ungewöhnlich. Auf einem Aufnahmepfad für nicht vertrauenswürdige Uploads: mitloggen
Eine Triage-Reihenfolge für eine Speicherbeschwerde
Beginnen Sie mit CatalogRetainedBytes. Liegt die Zahl nahe am Wachstum, das Sie im Prozess gemessen haben, steckt der Speicher im Dokument, und die Spitze der Retained-Liste nennt ihn. Liegt sie weit darunter, wohnt der Speicher irgendwo, das der Graph nicht misst — eigene Caches, gerenderte Bitmaps oder die Parser-Arena — und der Arena-Record ist der nächste, den man liest
- Knoten nach
EstimatedRetainedBytesrangieren und die eingehendenPath-Angaben der obersten zehn lesen. XObject-Ziele an der Spitze deuten meist auf scan-lastige Inhalte, wo sich Downsampling auszahlt;/FontFile-,/FontFile2- oder/FontFile3-Ziele deuten auf komplette Font-Programme, eingebettet, wo Subsets gereicht hätten; große/Contents-Streams stammen meist aus generierter Vektorausgabe wie Karten oder CAD-Exporten CatalogRetainedBytesvonTotalEstimatedBytesabziehen. Ein großer Rest sind gestrandete Objekte, also gehört die Korrektur in den Save-Schritt- Arena- und Intern-Record zuletzt lesen. Sie erklären selten Gigabytes, aber sie erklären einen Prozess, der nach dem Schließen jedes Dokuments groß bleibt
Diese Schritte in dieser Reihenfolge. Der erste erledigt die meisten Beschwerden, und bei sehr großen Dokumenten lautet die strukturelle Antwort oft, den ganzen Objektgraphen nicht mehr auf einmal zu halten — genau dafür ist der Direct-File-API-Workflow gebaut
Alle drei Diagnosen sind gewöhnliche Methodenaufrufe, die schlichte Records zurückgeben, sodass sie in jedes Logging oder jede Telemetrie passen, das eine Delphi- oder C++Builder-Anwendung bereits hat. HotPDF kommt als native VCL-Komponente mit vollständigem Quellcode; Dokumentation und ein Testdownload finden sich auf der HotPDF Delphi PDF-Komponente-Seite