Neem een rapport van 400 pagina's dat één font van 2 MB insluit: als elke pagina alles betaalt waarnaar ze verwijst, levert dat een vreemd totaal op, want de pagina's komen samen uit op 800 MB font in een bestand dat op schijf hooguit 30 MB meet. Verdeelt u het font eerlijk over de pagina's, dan kost het er elke pagina nog zo'n 5 KB, zodat niets duur lijkt en het geheugen uit het niets lijkt te komen. Geen van beide getallen beantwoordt de echte vraag: hoeveel bytes zouden vrijkomen als een bepaald object zou verdwijnen
In heap-analyse heeft dat getal een naam, retained size, en de graaftheorie rekent het netjes uit. Een object wordt toegerekend aan zijn dominator: het dichtstbijzijnde object dat elk pad vanaf de wortel op weg ernaartoe moet passeren. Gedeelde objecten schuiven omhoog tot ze uitkomen bij een node die ze echt in bezit heeft, exclusieve blijven waar ze staan, en de totalen tellen op zonder dubbeltelling
Shallow size, retained size en de dominatorregel in HotPDF
Voor een geladen document rekent HotPDF dit uit via THotPDF.BuildLoadedObjectDependencyGraph. De aanroep geeft één THPDFObjectDependencyNode terug per geladen indirect object en één THPDFObjectDependencyEdge per indirecte verwijzing, en voert daarna een dominatoranalyse uit met de Catalog van het document als wortel, het object dat de /Root-entry van de trailer noemt (ISO 32000-1 §7.7.2). Elke node draagt twee groottes mee. EstimatedShallowBytes is wat het object op zichzelf kost. EstimatedRetainedBytes is die eigen kost plus de shallow-kost van elk object dat hij domineert
Terug naar het font. Elke pagina verwijst ernaar, dus geen enkele pagina domineert het; de paden komen pas samen in de paginaboomnode boven die pagina's, wat bij een platte boom het /Pages-object aan de wortel is. De 2 MB van het font landt daar en rolt daarna op naar de Catalog. Een image-XObject dat op pagina 12 getekend wordt en nergens anders, is de tegengestelde zaak: elk pad ernaartoe loopt via pagina 12, dus de retained-grootte van pagina 12 omvat de hele afbeelding. De top van de retained-lijst is daarmee een lijst van objecten waarvan verwijdering geheugen zou vrijmaken
Dezelfde rekenkunde levert gratis één kruiscontrole op. THPDFObjectDependencyGraphInfo.CatalogRetainedBytes is gelijk aan de som van de shallow-grootte van elk object dat vanaf de Catalog bereikbaar is, en TotalEstimatedBytes is de som van de shallow-grootte van elk geladen object, bereikbaar of niet. Het gat tussen die twee is geheugen dat door objecten wordt vastgehouden waarnaar het document niet meer wijst
De graaf draaien en een mislukt resultaat lezen
De methode geeft alleen True terug als de hele analyse is afgerond, en die returnwaarde is het eerste wat u controleert. Een False resultaat vult het info-record nog steeds, maar met de arrays valt niets zinnigs te rapporteren. Overschrijdt het objectaantal MaxObjects (standaard 250.000), dan stopt de methode nog voordat er nodes gebouwd worden en zet ze ObjectCount op één meer dan de limiet, zodat u leert dat de limiet te klein was, niet hoe groot het document is. Wordt tijdens de scan het edge-budget (standaard 2.000.000) of de nestingslimiet van 256 niveaus voor directe objecten geraakt, dan komen nodes terug met partiële shallow-groottes en helemaal geen retained-groottes of bereikbaarheid
uses
SysUtils, HPDFDoc;
procedure ProfileLoadedPdf(const FileName: string);
var
Pdf: THotPDF;
Nodes: THPDFObjectDependencyNodeArray;
Edges: THPDFObjectDependencyEdgeArray;
Info: THPDFObjectDependencyGraphInfo;
begin
Pdf := THotPDF.Create(nil);
try
// LoadFromFile geeft het aantal pagina's terug; 0 betekent dat het laden mislukte
if Pdf.LoadFromFile(FileName) = 0 then
Exit;
// Verhoogde limieten voor een offline forensische run
if not Pdf.BuildLoadedObjectDependencyGraph(Nodes, Edges, Info,
1000000, 8000000) then
begin
// Log is uw eigen logroutine
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; // rangschik of sommeer nooit een partiële array
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;
Twee andere vlaggen verdienen in die failure-tak een blik. InvalidObjectGraph wordt gezet als het Catalog-object niet tussen de geladen objecten te vinden is, of als een direct object zichzelf blijkt te bevatten, wat alleen bij misvormde invoer voorkomt. LimitExceeded dekt ook een dominatoranalyse die na 128 passes nog niet gestabiliseerd is. Diagnostic legt elk geval in één regel uit. Geeft u voor MaxObjects nul of een negatieve waarde door, of een negatieve MaxEdges, dan volgt een EArgumentOutOfRangeException in plaats van False
Faalt de aanroep op een limiet, dan gooit u de arrays weg en draait u opnieuw met grotere grenzen. Partiële shallow-groottes zien er in een log geloofwaardig uit en zijn precies op de manier fout die mensen het verkeerde object laat najagen. Die grenzen bestaan omdat de graaf zelf ook kost: elke edge bewaart een Path-string, dus een run met acht miljoen edges alloceert acht miljoen kleine strings bovenop het document dat hij meet. Zo'n analyse hoort op een diagnostisch pad dat iemand bewust triggert
Wat telt EstimatedShallowBytes eigenlijk?
EstimatedShallowBytes schat resident geheugen, niet de bytes in het bestand. Per object telt het de instancegrootte van het geparsede object en zijn directe kinderen mee, de slots die de dictionary- en arraylijsten vasthouden, de lengte van elke sleutel, naam en string, en de payload van een stream als die payload in het RAM staat: een memorystream, of een lazy geladen stream die al in het geheugen gelezen is. Een stream waarvan de bytes nog in het bronbestand zitten of die naar een tijdelijk bestand is wegeschreven, levert alleen zijn objectoverhead in
Daar hangt een praktisch gevolg aan. Een scan-zwaar bestand dat direct na het laden geprofileerd wordt, kan bescheiden retained-groottes voor zijn afbeeldingen tonen, omdat nog niets gedecodeerd is. Draait u de graaf na de stap die het proces deed aangroeien (renderen, tekstextractie, een merge), dan verschijnen de gematerialiseerde streams met hun echte gewicht. Voor een reproduceerbare controle profileert u hetzelfde bestand twee keer, een keer direct na LoadFromFile en een keer na de dure operatie, en vergelijkt u de bovenste entries
ObjectType is grof. Het meldt het PDF-waardetype, otStream of otDictionary enzovoort, dus een afbeelding, een fontprogramma en een content stream van een pagina lezen allemaal als otStream. De binnenkomende edge verraadt de rol. THPDFObjectDependencyEdge.Path registreert waar in het bronobject de verwijzing gevonden werd, beginnend bij $, met /Key voor dictionary-entries, [n] voor array-items en /dictionary voor de dictionary van een stream. Een pad als $/Resources/XObject/Im3 vanaf een pagina, of $/XObject/Im3 vanaf een aparte resourcedictionary, betekent dat het object als XObject met de naam Im3 gebruikt wordt; $/FontFile2 vanaf een fontdescriptor betekent een ingesloten TrueType-programma; $/Contents[0] betekent pagina-inhoud
// Uw eigen helper, geen deel van de bibliotheek: rangschikt de top Count nodes op
// retained-grootte en drukt per node het pad van één binnenkomende verwijzing af
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;
Eén binnenkomend pad volstaat om de meeste objecten te classificeren. Voor een gedeeld object vertelt IncomingReferenceCount u hoeveel verwijzingen er zijn, en ImmediateDominatorObjectNumber met zijn generatienummer vertelt u welk object hem na de dominatoranalyse in bezit heeft. Dat veld is -1 voor de Catalog en voor elk object dat de Catalog niet kan bereiken. Een edge waarvan de vlag Resolved op False staat, wijst op een objectnummer dat niet geladen is; die worden meegeteld in UnresolvedReferenceCount, en een hoog aantal bij een verder gezond bestand betekent meestal een beschadigde cross-referencesectie
Waar komen onbereikbare objecten vandaan?
Een node waarvoor ReachableFromCatalog op False staat, is geladen en kost geheugen, maar geen enkele referentieketen vanaf de Catalog leidt ernaartoe, dus niets in de documentstructuur brengt een viewer erbij. Zijn retained-grootte is gelijk aan zijn shallow-grootte, want de dominatoranalyse loopt alleen over bereikbare objecten. EstimatedRetainedBytes sommeren over onbereikbare nodes geeft daarom hetzelfde antwoord als TotalEstimatedBytes - CatalogRetainedBytes
Incrementele updates zijn een veelvoorkomende bron, al niet op de manier waarop mensen doorgaans aannemen. Wanneer een latere revisie object 2120 herdefinieert, wint de nieuwste cross-reference-entry en wordt de oudere definitie nooit geladen, dus vervangen kopieën van hetzelfde objectnummer duiken niet in de graaf op. Wat wel opduikt is een object waarnaar een latere revisie simpelweg stopte met verwijzen: een annotatie die uit een herschreven /Annots-array viel, een afbeelding die door een nieuw objectnummer vervangen werd, een formulierveld dat uit de AcroForm verdween. Niets in ISO 32000-1 §7.5.6 verplicht een update om die entries vrij te markeren, en zolang de cross-referencegegevens ze als in gebruik vermelden, behandelt de loader ze als levende objecten. Het artikel over objectstromen en incrementele updates beschrijft hoe revisies stapelen
De andere twee bronnen zijn producenten die objecten wegschrijven en ze daarna niet koppelen, en beschadigde bestanden waarvan de cross-referencegegevens via een scan herbouwd moesten worden en die zo objectdefinities kunnen oppikken waarnaar niets verwijst. Zit een groot deel van het geschatte totaal in onbereikbare nodes, dan wint een schone herschrijving van het bestand het van nog een revisie toevoegen, en geeft de graaf u het byte-aantal om de tragere opslag te rechtvaardigen
Zit het geheugen bij de parser?
Voordat u het document de schuld geeft, controleert u hoe het laden zelf verliep. Twee aanroepen beschrijven de parser in plaats van de inhoud, en beide resetten aan het begin van elke LoadFromFile of LoadFromStream, dus ze beschrijven altijd de meest recente laadbeurt
GetLastParserArenaStatistics vult een record THPDFParserArenaStatistics voor de blokarena die tijdens het parsen kortlevende tokens en buffers vasthoudt. Blokken zijn 64 KiB (BlockSize), en een allocatie groter dan een blok krijgt een blok op zijn eigen grootte. AllocationCount min ReusedAllocationCount is gelijk aan BlockAllocationCount, het aantal keren dat de arena bij de memory manager voor een nieuw blok aanklopte. Blokken blijven gedurende de levensduur van het THotPDF-exemplaar bestaan en worden vrijgegeven als dat wordt vernietigd. Verwerkt één exemplaar een hele batch, dan weerspiegelt RetainedBytes grofweg de grootste working set die een bestand in die batch nodig had, wat een plateau verklaart dat duurt tot de component wordt vrijgegeven. TemporaryObjectElisionCount telt dictionary-sleutels die rechtstreeks in de arena gelezen werden in plaats van als tijdelijke naamobjecten gebouwd te worden
GetDocumentStringInternStatistics beschrijft de per-document pool die PDF-namen, content-stream-operatoren en korte strings dedupliceert. Strings van 1 tot 64 bytes komen in aanmerking. De pool bevat hooguit 65.536 entries en 4 MiB, en die plafonds komen in het record terug als MaxStringLength, MaxEntryCount en MaxRetainedBytes. Een string die leeg is, langer dan 64 bytes, of nieuw terwijl de pool vol zit, wordt geteld in BypassCount en als gewone string bewaard. Een bestand dat enorme aantallen unieke namen genereert, kost daardoor grofweg wat het ook zonder de pool zou kosten, en niet meer
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]));
// Uw eigen controle, geen bibliotheekaanroep: vlagt een pool die zijn plafonds raakte
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 PDF's herhalen een kleine woordenschat aan namen en operatoren, dus HitCount blijft dicht bij RequestCount en ReusedBytes groeit met het pagina-aantal. Een BypassCount die bij een bescheiden bestand naar RequestCount opklimt, is ongebruikelijk. Log het op een intakepad voor niet-vertrouwde uploads
Een triagevolgorde bij een geheugenklacht
Begin met CatalogRetainedBytes. Zit dat getal dicht bij de groei die u in het proces mat, dan zit het geheugen in het document en zal de top van de retained-lijst het benoemen. Zit het er ver onder, dan huist het geheugen ergens waar de graaf niet meet, zoals uw eigen caches, gerenderde bitmaps of de parser-arena, en is het arena-record het volgende om te lezen
- Rangschik nodes op
EstimatedRetainedBytesen lees de binnenkomendePathvan de top tien. XObject-doelen bovenaan wijzen meestal op scan-zware inhoud waar downsampling rendement oplevert; doelen als/FontFile,/FontFile2of/FontFile3wijzen op volledige fontprogramma's die ingesloten zijn waar subsets hadden volstaan; grote/Contents-streams komen meestal uit gegenereerde vectoruitvoer zoals kaarten of CAD-exports - Trek
CatalogRetainedBytesvanTotalEstimatedBytesaf. Een groot restant zijn gestrande objecten, dus de oplossing hoort in de opslagstap thuis - Lees het arena- en intern-record als laatste. Ze verklaren zelden gigabytes, maar wel een proces dat groot blijft nadat elk document gesloten is
Doorloop die stappen in die volgorde. De eerste beslecht de meeste klachten, en voor zeer grote documenten is het structurele antwoord vaak om niet langer de hele objectgraaf tegelijk vast te houden, en daarvoor is de workflow van de direct file API gebouwd
Alledrie de diagnostieken zijn gewone methodeaanroepen die kale records teruggeven, dus ze sluiten aan bij elke logging of telemetrie die een Delphi- of C++Builder-toepassing al heeft. HotPDF wordt geleverd als native VCL-component met volledige broncode; documentatie en een proefdownload staan op de HotPDF Delphi PDF-componentpagina