Yerel diskten anında açılan bir PDF, aynı baytlar aralık isteklerini yanıtlayan bir HTTP sunucusundan geldiğinde ilk sayfasını göstermek için birkaç saniye alabilir; dosya yalnızca birkaç megabayt ve bağlantı hızlıyken. Sorun bant genişliği değildir. İstek sayısıdır ve çare, yüzlerce ufak dağınık okumayı bir düzine önbelleklenmiş bloğa çevirmek, sonra da erişim deseni sıralı kaldıkça ön okuma yapmaktır
Aynı PDF diskten neden anında yüklenir de HTTPde sürünür?
Bir PDF parser dosyayı baştan sona okumaz; dosyada dolaşır. ISO 32000-1 §7.5teki yapı giriş noktasını sona koyar: parser startxref için son kilobayta arama yapar, cross-reference tablosuna atlar, trailer sözlüğünü çözer, Cataloga bir referansı izler, sonra sayfa ağacı köküne, sonra bir sayfa düğümüne, sonra o sayfanın kaynak sözlüğüne. Her atlama farklı bir ofsetten birkaç düzine bayt okur ve artımlı güncellenmiş bir dosya, /Prev zinciriyle bu yürüyüşü revizyon başına bir kez yineler
Yerel bir dosyada bu desen neredeyse bedavadır; işletim sistemi, çevredeki 4 KiBlik sayfayı çoktan dosya önbelleğinde tutar ve ikinci okuma bir bellek kopyasıdır. Bir ağ taşımasında böyle bir yakınlık yoktur. Her okuma, kendi gecikmesi olan bir isteğe dönüşür ve aritmetik acımasızdır: tur başına 40 mste 300 ufak okuma, tel çoğunlukla boşken on iki saniyelik bekleme biriktirir. Daha az okumak seçenek değildir; parser tam olarak istediği baytlara ihtiyaç duyar. Değişebilen şey, her fiziksel isteğin ne kadar geri getirdiğidir
Taşımanızı THPDFCoalescingRandomAccessSource ile sarmalamak
HotPDF belgeleri, THPDFRandomAccessSourcetan türeyen her sınıftan yükler ve THPDFCoalescingRandomAccessSource o sınıf ile parserın arasına oturur. Her okuma hizalı bir bloğa yuvarlanır ve blok bellekte tutulur. BlockSize öntanımlı 262.144 bayt, MaxCacheBytes 2.097.152dir; sekiz blok yerleşik kalır ve bütçe dolunca en uzun süredir kullanılmayan gider. Parserın bir trailer anahtarı için yaptığı 40 baytlık bakış, çevresindeki 256 KiBi içerisine çeker ve o komşuluktaki sonraki düzine okuma (cross-reference girdileri, Catalog, sayfa ağacı anahtarları) bellekten çıkar
Kendi sınıfınız ince kalır. İki metot zorunludur: GetSize ile ReadAt. HTTP clientınız havadaki bir isteği iptal edebiliyorsa ReadAtCancellablei, kaynak hâllâ süren bir indirmeyse IsRangeAvailablei override edin. Sarmalayıcı her getiriden önce o soruyu sorar: bütün bir blok henüz yoksa yalnızca istenen baytlarla yeniden dener, onlar da yoksa okuma bloklamak yerine kısa döner
type
// TMyHttpClient sizin HTTP client sınıfınızı temsil eder
THttpRangeSource = class(THPDFRandomAccessSource)
private
FClient: TMyHttpClient;
FUrl: string;
FSize: Int64;
public
constructor Create(const AUrl: string);
function GetSize: Int64; override;
function ReadAt(Offset: Int64; var Buffer; Count: Longint): Longint; override;
function ReadAtCancellable(Offset: Int64; var Buffer; Count: Longint;
CancellationToken: THPDFCancellationToken): Longint; override;
end;
var
Raw: THttpRangeSource;
Cached: THPDFCoalescingRandomAccessSource;
Pdf: THotPDF;
begin
Raw := THttpRangeSource.Create('https://files.example.com/contract.pdf');
// OwnsSource=True: sarmalayıcı Rawı serbest bırakır; 256 KiB blok, 8 MiB bütçe
Cached := THPDFCoalescingRandomAccessSource.Create(Raw, True, 262144, 8388608);
Cached.MaxReadAheadBlocks := 8; // geçerli aralık 1..32
Pdf := THotPDF.Create(nil);
try
// OwnsSource=True yeniden: Pdf Cachedı serbest bırakır, o da Rawı
if Pdf.LoadFromRandomAccessSource(Cached, True) > 0 then
RenderFirstPage(Pdf); // sizin kodunuz
finally
Pdf.Free;
end;
end;
Eşzamansız prefetch ile uyarlanabilir ön okuma, sarmalayıcı kurulur kurulmaz ikisi de açıktır; örnek yalnızca pencere tavanına dokunur. Kurucu argümanlarını baştan doğrular: BlockSize 4.096 ile 16.777.216 bayt arasında olmalı ve MaxCacheBytes en az bir blok tutmalıdır; aksi halde tek bir bayt kıpırdamadan bir ERangeError alırsınız
Açık sarmalayıcıya kesinlikle ihtiyacınız yok. LoadFromRandomAccessSourcea düz bir kaynak verin, HotPDF sizin için sarmalar; GetCacheAdmissionPolicy ile SetCacheAdmissionPolicy üzerinden okuyup değiştirebildiğiniz ham önbellek politikasını, clkRawCompressed katmanıyla kullanır: sekiz girdi, toplam 2 MiB, girdi başına 256 KiB. Kendi THPDFCoalescingRandomAccessSourceunuzu geçirirseniz yapılandırıldığı gibi kullanılır. Ağı geçen her şey için sarmalayıcıyı kendiniz kurun; ön okuma düğmelerini ve tam istatistik kaydını elde edersiniz, oysa otomatik yol GetCacheAdmissionStatistics üzerinden yalnızca isabet, ıskalama, kabul ve tahliye sayaçlarını bildirir
Ne kadar ileriyi okumalı?
Uyarlanabilir ön okuma belge başına karar verir. AdaptiveReadAheadEnabled kurulu iken parserın yüklenmiş belge üzerinden yaptığı her okuma sıralı ya da rastgele olarak sınıflandırılır ve ön çekme penceresi bir skoru izler. Üst üste iki ileri okuma pencereyi iki bloğa açar; dört, dörde; altı, sekize. Pencere asla MaxReadAheadBlocksu aşmaz ve MaxCacheBytese sığan blok sayısını da aşmaz; küçük bir önbellek kendi prefetchiyle boğulamaz
Geriye atlayan ya da önceki okumanın sonundan çok öteye düşen bir okuma, skoru sıfırın altına indirir. Pencere kapanır, başka bir yöne giden her prefetch iptal edilir ve SuppressedPrefetchCount artar. İki ileri okuma sonra pencere tek blokla yeniden açılır. O gecikme asıl amaçtır: bir cross-reference takibinin ortasındaki tek şanslı bitişik okuma, kurguyu yeniden başlatmaz
SequentialReadToleranceBytes, öntanımlı 4.096, "çok öte"yi tanımlar. Bir içerik akışında yürüyen parser kusursuz bitişik ofsetler üretmez; burada bir uzunluk alanını atlar, orada bir inline image sözlüğü. Önceki sonun toleransı içine düşen okumalar hâllâ ileri sayılır. Çok düşük kurarsanız normal bir ileri tarama rastgele sınıflanır ve ön okuma hiç devreye girmez. Çok yüksek kurarsanız gerçek rastgele erişim sıralı görünür ve kimse okumayacağı megabaytları çekersiniz. Setter sıfırdan BlockSizea kadar her değeri kabul eder ve değiştiğinde skoru sıfırlar
Büyüme kademelidir, çökme anlıktır ve o asimetri bilinçlidir. Rastgele bir iş yükünde fazla çekmek gerçek bant genişliği, ölçümlü bir taşımada gerçek para yakar; sıralı bir iş yükünde az çekmek birkaç ek tur maliyetidir. AdaptiveReadAheadEnabledı açık bırakın. Kapalıyken sarmalayıcı her okumadan sonra desene bakmaksızın bir blok prefetch eder; parser cross-reference bölümleri arasında atlayorken tam olarak yanlış davranış budur
Sınıflandırma, HotPDFin bir yükleme sırasında okuduğu akıştan güdülenir. Kendi kodunuz da sarmalayıcı üzerinden bayt çekiyorsa — diyelim bir dosyayı hash etmek ya da bir eki çıkarmak için — her okumadan sonra ofset ve uzunlukla ObserveReadPattern çağırın; pencere o trafiğe de tepki verir. Hangi baytların peşinden gidileceğini zaten biliyorsanız PrefetchRange doğrudan bir arka plan getirme başlatır; IsPrefetchActive hâlâ süren olup olmadığını bildirir
Önbellek dolarken sıcak blokları tutmak
Düz en-son-kullanılan tahliyesinin bilinen bir zaafı vardır. Uzun tek bir ileri geçiş — büyük gömülü bir görsel diyelim — parserın sürekli geri döndüğü her bloğu dışarı iter; bir sonraki sayfada yeniden gerekecek cross-reference ile Catalog blokları dâhil. THPDFCoalescingRandomAccessSource her bloğun kaç kez istendiğini sayar ve bütçe dolduğunda yeni bir blok, ancak yerine geçecek blok kadar en az istenmişse önbelleğe girer. Aksi halde okuma, tam olarak istenen baytlar için doğrudan kaynağınıza gider ve RejectionCount ile FrequencyRejectionCount kaydeder
O kural öntanımlı olarak açıktır (AdaptiveAdmission kurucu argümanı). ConfigureCacheAdmission, çalışan bir sarmalayıcıda bayt bütçesini, girdi başına tavanı, isteğe bağlı bir girdi sayısı sınırını ve kabul kuralını değiştirir; süren her prefetchi iptal eder ve önbelleği yeni sınırlara anında kırpar
Aktarımı gerçekten durduran iptal
Prefetch tek bir arka plan threadinde koşar ve sarmalayıcı, bitirmesi anlamlı kalmadığı an onu iptal eder. Prefetch yapılan aralığın dışındaki baytlar için gelen bir ön plan okuma onu iptal eder; kullanıcının istediği sayfa asla kurgusal trafiğin arkasında beklemez. Rastgele bir okuma onu iptal eder. Sarmalayıcıyı yok etmek ya da CancelPrefetch ya da ClearCache çağırmak onu iptal eder ve threadin çıkmasını bekler. Bunların her biri, prefetch threadinin ReadAtCancellableinize geçtiği THPDFCancellationTokenı kurar
Baytların gerçekten durup durmadığı overrideunuza bağlıdır. THPDFRandomAccessSourceun öntanımlı ReadAtCancellablei tokeni düz bir ReadAtin öncesinde ve sonrasında kontrol eder; dosya paylaşımı için yeterlidir ama yarım kalmış bir 256 KiBlik HTTP yanıtının sonuna dek koşmasına izin verir. Yanıt gövdesini parçalarla okuyan bir client, parçalar arasında tokeni kontrol edip vazgeçebilir:
function THttpRangeSource.ReadAt(Offset: Int64; var Buffer;
Count: Longint): Longint;
begin
Result := ReadAtCancellable(Offset, Buffer, Count, nil);
end;
function THttpRangeSource.ReadAtCancellable(Offset: Int64; var Buffer;
Count: Longint; CancellationToken: THPDFCancellationToken): Longint;
var
Status: Integer;
begin
if CancellationToken <> nil then
CancellationToken.ThrowIfCancellationRequested('http range read');
// GetRange ve callbacki clientınızın APIsidir; "Range:
// bytes=Offset-(Offset+Count-1)" gönderir ve gövde parçaları arasında callbacki çağırır
Result := FClient.GetRange(FUrl, Offset, Count, Buffer, Status,
function: Boolean
begin
Result := (CancellationToken <> nil) and
CancellationToken.IsCancellationRequested;
end);
// 206 yerine 200, sunucunun Rangei yok sayıp tüm dosyayı gönderdiği anlamına gelir
if Status <> 206 then
raise EStreamError.CreateFmt('Range request not honored (HTTP %d)', [Status]);
if CancellationToken <> nil then
CancellationToken.ThrowIfCancellationRequested('http range read');
end;
Durum kontrolü, çoğu HTTP kaynağının ilk çarptığı tuzağı kapsar. RFC 9110 §14, bir sunucunun Range başlığını yok sayıp 200 ile tam gösterimi yanıtlamasına izin verir ve bazı CDN ile proxy yapılandırmaları belirli dosyalar için tam olarak bunu yapar. Bir 200 yanıtının ilk Count baytını kopyalayan bir kaynak, hangi ofseti istediyseniz isteyin parsera sıfır ofsetinden baytlar verir. Dönüş değerleri de önemlidir: sarmalayıcı, ReadAt negatif bir sayı ya da istenenden fazla bayt bildirirse EStreamError fırlatır ve sıfırı veri sonu sayar
Kaynağınızın aldığı tek nil olmayan token, prefetch threadininkidir. Yükleme sırasındaki parser okumaları ReadAtCancellableinize nil tokenle ulaşır; yüklemenin kendisini durdurmak ayrı bir anahtardır: THotPDF.OperationCancellationTokena bir token atayın, belge yüklemesi ilerlerken onu kontrol eder. Aynı token modeli, istek kuyruğuyla arka plan renderı yazısındaki kuyruğu da güdütür; bir görüntüleyici tek bir kapatma handlerından yüklemesini, renderlarını ve kurgusal ağ trafiğini iptal edebilir
Aralık önbelleği istatistiklerini okumak
GetStatistics, taşımanın yaptığını önbelleğin yaptığından ayıran bir THPDFRangeCacheStatistics kaydı doldurur. SourceReadCount ile SourceBytesRead fiziksel trafiktir. CacheHitCount ile CacheMissCount mantıksal trafiktir. SequentialReadCount ile RandomReadCount erişim deseninin nasıl sınıflandığını gösterir; CurrentReadAheadBlocks ile PeakReadAheadBlocks pencerenin ne kadar açıldığını gösterir ve dört prefetch sayacı kurgunun karşılığını verip vermediğini söyler. CachedRangeCount, CachedBytes, EvictionCount ve RejectionCount önbelleğin kendisini anlatır
var
S: THPDFRangeCacheStatistics;
begin
Cached.GetStatistics(S);
Log(Format('physical %d reads / %d bytes, hits %d, misses %d',
[S.SourceReadCount, S.SourceBytesRead, S.CacheHitCount, S.CacheMissCount]));
Log(Format('pattern: %d sequential, %d random, peak window %d blocks',
[S.SequentialReadCount, S.RandomReadCount, S.PeakReadAheadBlocks]));
Log(Format('prefetch: %d issued, %d completed, %d canceled, %d suppressed',
[S.PrefetchRequestCount, S.PrefetchCompletedCount,
S.PrefetchCancelledCount, S.SuppressedPrefetchCount]));
Log(Format('cache: %d blocks / %d bytes, %d evicted, %d rejected',
[S.CachedRangeCount, S.CachedBytes, S.EvictionCount, S.RejectionCount]));
// Çoğunlukla sıralı bir belgede biriken reddedilmeler: ona daha çok yer açın
if S.RejectionCount > S.CacheHitCount then
Cached.ConfigureCacheAdmission(16 * 1024 * 1024, Cached.BlockSize, 0);
end;
Üç okuma, neyi değiştireceğinizi söyler. Yüksek rastgele okuma sayısının yanında çok sayıda iptal edilmiş prefetch, belgenin sıra dışı yüründüğü demektir; MaxReadAheadBlocksu düşürün ve çöpe attığınız bant genişliği için ödeme yapmayı bırakın. Tepe pencere 1de takılıyken çok sayıda ıskalama, toleransın etkin biçimde sıralı bir deseni reddettiği demektir; SequentialReadToleranceBytesi yükseltin. SourceBytesReadin dosya boyutunun çok üstünde olması, bloklar yeniden kullanılmadan tahliye edildiği demektir; başka her şeye dokunmadan MaxCacheBytesi yükseltin. Örnekteki red eşiği bizim kendi başlangıç sezgimizdir; onu kendi trafiğinize göre ayarlayın
Doğrusallaştırılmış dosyalar aritmetiği değiştirir
Üreticiyi kontrol ediyorsanız belgeyi linearize etmek sorunu ayarlamak yerine değiştirir. ISO 32000-1 Ek F, ilk sayfanın nesnelerini ve bir ipucu tablosunu dosyanın önüne koyar; bir görüntüleyici, sayfa birini geri kalanına dokunmadan açılış baytlarından render edebilir. HotPDF o yolu GetProgressiveLinearizedLoadInfo ile ReadProgressiveLinearizedFirstPageSection üzerinden açar; ikisi de birleştirme için sarmalayacağınız aynı THPDFRandomAccessSourceu alır. Yazma tarafı ipucu tablolu linearize PDF üretme yazısında işlenir
İki teknik birbirini tamamlar. Birleştirme, yeniden kaydedemeyeceğiniz üçüncü taraf dosyaları dâhil her belgeyi yavaş bir bağlantıda katlanılır kılar; linearization, kendi ürettiğiniz belgelerde ilk sayfayı çabuk ulaştırır. Bellekte tutulamayacak kadar büyük yerel disk dosyaları, tur gecikmesi amorti edilecek başka bir sorundur; doğrudan dosya APIsi iş akışındaki eşlenmiş dosya ve tembel akış yolları onlara daha uygundur
Rastgele erişim kaynak sınıfları, birleştirme sarmalayıcısı, önbellek kabul politikaları ve progressive linearize yükleme çağrıları, tam kaynaklı yerel bir Delphi ve C++Builder PDF bileşeni olan HotPDFle gelir. Lisanslama ve tam API başvurusu HotPDF Delphi PDF bileşeni sayfasındadır