Een pagecache met de bestandsnaam als key laat de pagina's van gisteren zien voor een PDF die 's nachts onder dezelfde naam met een nieuwe revisie is overschreven. Een cache met een volledige SHA-256 van het bestand als key maakt die fout nooit, maar bij een gescand archief van 400 MB kan de hash langer duren dan het renderen van de twee pagina's die de gebruiker werkelijk opent. De werkbare key zit tussen die twee in, en het kiezen ervan dwingt ook een tweede beslissing af: wat een bewerking in het geheugen moet doen met pagina's die al op schijf staan
Hoe de schijftier van RenderCacheFolder achter de geheugencache zit
HotPDF RenderCacheFolder voegt een persistente tier toe achter de rastercache in het geheugen van de HotPDF Delphi-component, en hij doet alleen mee als de eigenschap een niet-lege pad bevat. Een aanroep van RenderLoadedPageToBitmapCached(PageIndex, DPI) controleert eerst het geheugen, met pagina-index, DPI en de huidige renderinstellingen als key. Bij een misser vraagt hij de schijf. Een schijfhit decodeert de opgeslagen PNG, promoveert hem terug naar het geheugen en geeft je een kopie. Pas wanneer beide tiers missen gaat de pagina door de volledige renderer die in een geladen PDF-pagina naar een TBitmap renderen wordt beschreven, en die verse bitmap wordt op de weg naar buiten naar schijf geschreven
De maplay-out is kaal genoeg om in de Verkenner na te kijken. Elk document krijgt een submap waarvan de naam een documentkey van 16 hex-tekens combineert met een renderinstellingen-key van 16 hex-tekens, en elke pagina belandt daar als <page>@<dpi>.png. Een index.txt in de root somt documenten op in meest recent gebruikte volgorde onder een schema-tag; klopt de tag niet, dan wordt de hele map bij eerste gebruik gewist. PNG- en index-schrijfacties gaan eerst naar een tijdelijk bestand en worden daarna met MoveFileExW en de replace-existing-vlag ingewisseld, dus een crash halverwege een schrijfactie laat het vorige bestand of geen bestand achter. Een PNG die niet decodeert wordt verwijderd en als misser geteld
Drie grenzen houden de map binnen perken:
RenderCacheMaxDocuments(default 20) begrenst het aantal documentsubmappen en zet eerst de minst recent gebruikte buiten spelRenderCacheMaxBytes(default 524288000, oftewel 500 MB) begrenst de gecombineerde grootte van elke PNG onder de root- Elke documentmap bevat ten hoogste 200 pagina-afbeeldingen; die grens zit vast in THotPDF en heeft geen eigenschap
RenderCacheCapacity (default 8) heeft niets met de schijf te maken. Hij telt pagina's die in het geheugen worden gehouden
uses
SysUtils, Graphics, HPDFDoc;
procedure WarmThumbnails(const FileName: string);
var
Pdf: THotPDF;
Bmp: TBitmap;
I: Integer;
begin
Pdf := THotPDF.Create(nil);
try
// De schijftier leest de map en beide grenzen één keer, bij de eerste
// gecachte render, dus zet ze vóór die aanroep
Pdf.RenderCacheFolder := IncludeTrailingPathDelimiter(
GetEnvironmentVariable('LOCALAPPDATA')) + 'MyViewer\PageCache';
Pdf.RenderCacheMaxDocuments := 50;
Pdf.RenderCacheMaxBytes := Int64(1024) * 1024 * 1024; // 1 GiB
Pdf.RenderCacheCapacity := 16; // pagina's in het geheugen
if Pdf.LoadFromFile(FileName) > 0 then
for I := 0 to Pdf.LoadedPageCount - 1 do
begin
Bmp := Pdf.RenderLoadedPageToBitmapCached(I, 96);
if Bmp <> nil then
try
// Geef de kopie hier aan de miniaturenbalk
finally
Bmp.Free; // de gecachte aanroep geeft altijd een kopie in aanroeper-bezit terug
end;
end;
finally
Pdf.Free; // schijfentries overleven voor de volgende sessie
end;
end;
Draai die procedure twee keer op hetzelfde bestand en de tweede pass rasteriseert niets dat binnen de grenzen paste. De schijfcache wordt bij de eerste gecachte render aangemaakt en leeft zo lang als de THotPDF-instantie, dus de map of een van beide grenzen daarna wijzigen verplaatst of herschaalt hem niet. Twee voorwaarden meer houden een pagina van de schijf af. Een bitmap boven het default plafond per entry van de geheugencache (64 MiB aan 32-bit pixels, een pagina van 4096 × 4096) wordt niet bewaard. En de schijftier wordt alleen geraadpleegd zolang RenderFallbackPolicy op zijn default rfpIgnore blijft, want een PNG draagt pixels maar geen van de fallback-diagnostica die een strenger beleid meldt
Waarom falen de voor de hand liggende cachekeys?
Drie keys komen het eerst in je op, en elk faalt op zijn eigen manier. Het bestandspad faalt op overschrijven. Een hash van een in-memory kopie van de PDF-bytes lijkt veilig tot je doorhebt dat een parser die het bestand ter plekke leest geen reden heeft zo'n kopie vast te houden; een buffer hashen die nooit is gevuld levert een lege key op, en een cache die een lege key als "sla de schijf over" behandelt laat een correct geconfigureerde map achter die nooit een PNG ontvangt. Het hele bestand vanaf schijf hashen werkt, tegen de prijs van elke byte lezen bij elke open
De zwaardere valkuil is invalidatie. Zo'n component moet zijn pagina's in het geheugen wissen bij het begin van elke laad, na elke bewerking en bij zijn vernietiging, en de verleidelijke zet is de schijfmap van het document op dezelfde plek te verwijderen. Doe dat en elke viewer-sessie veegt zijn eigen cache uit bij het afsluiten, dus de volgende morgen begint toch koud. De key na een bewerking opnieuw uit de ongewijzigde source berekenen is nog erger: de bewerkte renders belanden onder de key van het originele bestand en worden geserveerd aan wie de onaangeroerde PDF hierna opent. Identiteit en invalidatie moeten als één geheel worden ontworpen. Verkeer met een van beide en je verscheept een cache die nooit raakt, of één die pagina's toont die het bestand niet bevat
Hoe HotPDF een PDF-bron van een vingerprint voorziet
HotPDF identificeert een met LoadFromFile geladen PDF door zijn grootte, zijn laatst-geschreven-tijd en zijn eerste en laatste 64 KiB met SHA-256 te hashen, en identificeert een stream- of random-access-source met een SHA-256 van de volledige inhoud. De identiteit wordt eenmaal vastgelegd, op het moment dat een laad slaagt, en de eerste 16 hex-tekens van de digest (64 bits) worden de documentkey
| Bron | Identiteit | Kost | Vastgelegd wanneer |
|---|---|---|---|
LoadFromFile | Grootte + laatst-geschreven-tijd + eerste en laatste 64 KiB, gehasht met SHA-256 | Ten hoogste 128 KiB gelezen, wat de bestandsgrootte ook is | Elke geslaagde laad, ook als RenderCacheFolder pas erna wordt gezet |
LoadFromStream | SHA-256 van de hele stream | Eén volledige passage over de source | Alleen als RenderCacheFolder vóór de laad was gezet |
LoadFromRandomAccessSource | SHA-256 van de hele source | Eén volledige passage over de source | Alleen als de map eerst was gezet en elk bytebereik beschikbaar is |
Elke source met een /Encrypt-entry | Geen | Geen | Nooit; de schijftier wordt omzeild |
Voor een desktopviewer is de gesampelde vingerprint de juiste default, en volledig hashen bij elke open de verkeerde. De twee gesampelde regio's zijn uit de bestandsstructuur gekozen. De header zit aan het begin; de trailer en het laatste cross-reference-gedeelte zitten aan het einde (ISO 32000-1 §7.5). Een incrementele update voegt een nieuwe body, cross-reference-gedeelte en trailer toe (§7.5.6), wat grootte en staart tegelijk verandert, en elke gewone volledige herschrijving duwt de laatst-geschreven-tijd op. Onder 128 KiB overlappen de twee samples en dekken elke byte, dus kleine documenten worden toch volledig gehasht
Wat erdoorheen glipt is een even-grote bewerking midden in een groot bestand door een gereedschap dat daarna de originele tijdstempel herstelt. Editors die bewust modificatietijden vasthouden terwijl ze inhoud veranderen bestaan, maar ze zijn zeldzaam, en tegen zo'n bestand serveert de cache verouderde pagina's. Het tegenovergestelde geval werkt in je voordeel: een Windows-bestandskopie houdt de laatst-geschreven-tijd vast, dus een kopie van een gecacht document raakt dezelfde entries, wat klopt want de bytes matchen
Een stream heeft geen tijdstempel. Inhoud is de enige eerlijke identiteit, dus HotPDF betaalt de volledige SHA-256-passage alleen wanneer vóór de laad om een schijfcache is gevraagd, en code die LoadFromStream aanroept zonder cachemap betaalt niets extra. Daardoor telt de volgorde van twee regels:
procedure OpenDownloadedPdf(Pdf: THotPDF; Data: TStream;
const CacheRoot: string);
begin
// Verkeerde volgorde voor streams: de content hash wordt alleen berekend als de
// map al is gezet, dus dit document zou de schijftier omzeilen
// Pdf.LoadFromStream(Data);
// Pdf.RenderCacheFolder := CacheRoot;
Pdf.RenderCacheFolder := CacheRoot; // eerst zetten
Data.Position := 0;
if Pdf.LoadFromStream(Data) <= 0 then
raise Exception.Create('The stream is not a loadable PDF');
end;
Een random-access-source die nog aan het downloaden is krijgt helemaal geen identiteit in plaats van een hash van de ranges die tot dusver zijn aangekomen. Gooit het berekenen van de identiteit om welke reden dan ook een exception, dan slaagt de laad toch en rendert het document alleen door het geheugen
Wat gebeurt er met gecachte pagina's na een bewerking?
Het bewerken van een geladen document verwijdert nooit iets uit de HotPDF-schijfrendercache. De bewerking laat in plaats daarvan de identiteit van het document vallen, dus de rest van die laad omzeilt de schijftier, en de opgeslagen pagina's blijven geldig voor het ongewijzigde bestand waaruit ze zijn gerenderd. Entries verlaten de schijf alleen via de document- en bytelimieten, de grens van 200 pagina's, een PNG die niet decodeert, of een schemawijziging
De key beschrijft een bestand op schijf. Zodra je een pagina van stempel voorziet of een annotatie verandert, matcht het document in het geheugen hem niet meer, dus noch lezen noch schrijven onder die key zou eerlijk zijn. InvalidateRenderedPageCache en de per-pagina-invalidation die bewerkingen triggeren wissen allebei de identiteit en laten de map met rust. Een tweede controle dekt bewerkingspaden die nooit iets invalideerden: vóór elke schijfopvraag vraagt THotPDF zich af of een geladen object niet-opgeslagen wijzigingen draagt en, zo ja, behandelt het document als zonder identiteit
Renderinstellingen gaan de andere kant op. Het toewijzen van PageRenderBackend (wat UseNativeGDIRenderBackend voor je doet), het aanroepen van ConfigureRenderICCWorkflow of van ClearRenderICCWorkflow spoelt de pagina's in het geheugen maar houdt de identiteit vast, want het document matcht nog steeds met zijn bestand. Die instellingen veranderen pixels zonder in de geheugenkey te verschijnen, dus de schijfkey vouwt de backendnaam, de black-point-compensatievlag en SHA-256-digests van de ICC-proof- en outputprofielen in. De geheugenkey dekt al de kleurintentie, uitvoerdithering, overprint preview, luminosity-maskermodus, fallback-beleid en de zichtbaarheid van elke optional content group
Laagzichtbaarheid is een goed voorbeeld van een wijziging die op schijf blijft. SetLoadedOptionalContentGroupVisible registreert de overschrijding in het geheugen zonder een PDF-object aan te raken, dus het document houdt zijn identiteit en de omgeschakelde weergave rendert in zijn eigen submap naast de default:
procedure ShowLayer(Pdf: THotPDF; const LayerName: AnsiString;
PageIndex: Integer; out Bmp: TBitmap);
var
I: Integer;
begin
for I := 0 to Pdf.GetLoadedOptionalContentGroupCount - 1 do
if Pdf.GetLoadedOptionalContentGroupName(I) = LayerName then
Pdf.SetLoadedOptionalContentGroupVisible(I, True);
// Zelfde documentkey, andere renderinstellingen-key: deze pagina wordt uit een
// tweede map gelezen of erin geschreven, en de defaultweergave blijft onaangeroerd
Bmp := Pdf.RenderLoadedPageToBitmapCached(PageIndex, 150);
end;
Een bewerkt document komt alleen terug op de schijftier door een nieuw bestand te worden. Sla het op en laad het resultaat:
procedure CommitEditsAndRekey(Pdf: THotPDF; const EditedFile: string);
begin
// Na het bewerken: ververs de pagina's in het geheugen. De bronidentiteit is
// al weg, dus de map van het originele document wordt niet gelezen
// en niet geschreven
Pdf.InvalidateRenderedPageCache;
// Het opgeslagen bestand heeft zijn eigen grootte en laatst-geschreven-tijd, dus zijn
// eigen identiteit; renders na deze laad worden onder de nieuwe key gecacht
Pdf.SaveLoadedDocument(EditedFile);
if Pdf.LoadFromFile(EditedFile) <= 0 then
raise Exception.Create('Could not reload the edited document');
end;
De map van het originele document blijft waar hij was en verloopt via RenderCacheMaxDocuments en RenderCacheMaxBytes zoals elke andere entry. Heropen de onbewerkte origineel en zijn pagina's staan er nog
Versleutelde bronnen, junctions en gedeelde roots
De HotPDF-schijfrendercache weigert met opzet twee invoeren: pagina's van een versleutelde PDF, en documentsubmappen die junctions of andere reparse points zijn. Beide regels ruilen cachetreffers in voor veiligheid
Versleutelde PDFs blijven in het geheugen
Een gerenderde pagina is ontsleutelde inhoud. Haar als kale PNG in een cachemap wegschrijven zou een leesbare kopie van een met wachtwoord beveiligd document op schijf achterlaten, buiten de bescherming die zijn auteur koos (ISO 32000-1 §7.6). HotPDF legt voor geen enkele source waarvan de trailer een /Encrypt-entry draagt een identiteit vast, of hij nu met een wachtwoord of met een leeg gebruikerswachtwoord werd geopend. Die documenten gebruiken nog steeds de geheugentier, die met het proces verdwijnt
Gekoppelde documentmappen worden overgeslagen
De cacheroot kies je zelf, en hem naar een junction wijzen is prima. De submappen eronder zijn iets anders: de cache maakt ze aan, raakt ze aan en verwijdert ze zelfstandig tijdens de opruiming bij het opstarten, de opvraag, het opslaan en alle drie de evictiegrenzen. Wisselt iemand met schrijftoegang tot de root een documentmap om voor een junction naar een andere map, dan volgt elk van die operaties hem mee, en evictie zou elders bestanden verwijderen. Elk toegangspunt leest eerst de attributen van de map en slaat alles over dat als reparse point is gemarkeerd. Een opvraag telt een misser, een opslag telt een schrijffaling, en evictie laat hem met rust
Unicode-paden en één root per proces
RenderCacheFolder is een Unicode-string, en de atomische vervanging roept de wide Windows API aan, dus een profielpad buiten de systeemcodepagina (een Chinese gebruikersnaam op een Engelse Windows-installatie, zeg) bereikt de cache intact. Meerdere THotPDF-instanties in één proces die naar dezelfde root resolven, vergeleken case-insensitief na padexpansie, delen één op referentietellingen gebaseerde index en één lock. Dat telt voor de grenzen: aparte kopieën van index.txt zouden elk het 500 MB-budget tegen een partieel beeld afdwingen en de map meermalen voorbij laten groeien
Delen stopt bij de procesgrens. Twee processen op dezelfde root houden aparte indexes in het geheugen, dus elke gelijktijdig draaiende applicatie verdient zijn eigen root. Werkerthreads binnen één proces zijn prima: PrefetchLoadedPages en de wachtrij uit renderen op de achtergrond met een aanvraagwachtrij gaan door hetzelfde gecachte pad en dezelfde lock
Instellingen om vóór het verschepen goed te zetten
- Zet de map en beide grenzen vóór de eerste gecachte render, en bij stream- of random-access-laden vóór het laden
- Reken op renderen alleen in het geheugen voor versleutelde PDFs, voor documenten die na de laad zijn bewerkt, en telkens als
RenderFallbackPolicynietrfpIgnoreis - Geef elke draaiende applicatie zijn eigen cacheroot onder een locatie per gebruiker zoals
%LOCALAPPDATA%
Een persistente pagecache verdient zijn schijfruimte in een viewer die dezelfde documenten de hele dag heropent, en dat is de werklast achter de architectuur voor een eigen PDF-viewer in Delphi op deze blog. De schijftier, de rastercache in het geheugen en de paginarenderaar zijn allemaal onderdeel van de HotPDF Delphi PDF-component, beschikbaar voor Delphi en C++Builder