Hoe lang duurt het om een miljoen documenten te indexeren op een gewone computer? Hoe groot wordt de index en hoe snel is het zoeken daarna? In plaats van een synthetische test hebben we een echt corpus van bijna één miljoen bestanden genomen, dit geïndexeerd met GroupDocs.Search for .NET 26.11 op een desktop‑pc en elke stap gemeten.

Kort antwoord: 919.896 documenten werden geïndexeerd in 3 uur 48 minuten, en 17 van de 20 soorten zoekopdrachten beantwoordden in 35 tot 539 ms, hoewel de meeste queries werden gevonden in tientallen of honderden duizenden documenten. De benchmark is open source, dus je kunt je eigen documenten op dezelfde manier meten.

De resultaten in één tabel

Wat Resultaat
Documenten geïndexeerd 919,896
Indexeren 3 h 48 min, 67 documenten per seconde
Indexgrootte 60.2 GB, 49.5 GB na optimalisatie
Openen van de geoptimaliseerde index 9.8 s
17 van de 20 soorten zoekopdrachten 35 tot 539 ms (mediaan 158 ms) in herhaalde runs
De zwaarste queries 8.5 tot 87 s voor resultaten van miljoenen tot honderden miljoenen voorkomens

De configuratie

  • Computer: Intel Core i5-11500 (6 cores, 12 threads), 32 GB RAM, een SATA SSD, Windows 10 – een gewone desktop‑pc, geen server.
  • Software: GroupDocs.Search for .NET 26.11 op .NET 10, met de standaard indexinstellingen.
  • Documenten: de govdocs1 corpus van Digital Corpora – bijna één miljoen bestanden van Amerikaanse overheidswebservers: PDF, HTML, Word, Excel, PowerPoint, tekst, XML, CSV, afbeeldingen en meer. Het is een moeilijke corpus: veel van de bestanden zijn spreadsheets en data‑bestanden, en elk verschillend nummer of code wordt een term, waardoor de index eindigde met 285.6 miljoen unieke termen.
  • Methode: de tekst van de documenten werd één keer geëxtraheerd en opgeslagen in bestanden, zodat het indexeren afzonderlijk kon worden gemeten. De data werd vervolgens toegevoegd aan een nieuwe index in batches van maximaal 512 MB met 4 indexeer‑threads, de index werd geoptimaliseerd, en 20 soorten zoekopdrachten werden elk 3 keer uitgevoerd.

Van de 983,840 geëxtraheerde bestanden leverden 63,943 geen tekst op (PostScript, gzip, Flash‑ en dBase‑bestanden en bestanden die niet gelezen konden worden, onder andere), en één document was te groot voor de index, dus werden 919,896 documenten geïndexeerd.

Indexeren: 920 duizend documenten in minder dan vier uur

Het indexeren duurde 3 uur 48 minuten, of gemiddeld 67 documenten per seconde, inclusief 28 minuten die besteed werden aan het lezen van de geëxtraheerde data van de schijf. De index besloeg 60.2 GB in 727 segmenten.

De meest bruikbare bevinding voor planning is hoe de tijd van één aanroep van Index.Add veranderde naarmate de index groeide:

Documenten al in de index Gemiddelde tijd van een aanroep
0 tot 27,000 12.7 s
208,000 tot 338,000 52.7 s
497,000 tot 639,000 98.9 s
639,000 tot 920,000 109.4 s

De laatste aanroep voegde slechts 1,240 documenten toe en duurde nog steeds 113 s, net zo lang als de aanroepen met meer dan 9,000 documenten ervoor. In een grote index bepaalt het aantal aanroepen, niet het aantal documenten, het grootste deel van de indexeertijd. Voeg dus documenten toe aan een grote index in batches zo groot als je geheugen toelaat.

Zoeken: tienden van een seconde voor de meeste queries

De geoptimaliseerde index van 28 segmenten werd geopend in 9.8 s. Elke query werd vervolgens drie keer uitgevoerd: de eerste uitvoering is wat de eerste gebruiker van een net gestartte applicatie moet wachten, en de herhaalde uitvoeringen zijn het gebruikelijke geval van een draaiende service.

Soort zoekopdracht Gevonden documenten Eerste uitvoering Herhaalde uitvoeringen
Eenvoudig woord 202,079 539 ms 210 ms
Boolean 44,626 251 ms 149 ms
Zin 241,277 591 ms 539 ms
Zin met wildcards 32,270 183 ms 129 ms
Wildcard 267,231 347 ms 287 ms
Fuzzy 202,183 207 ms 157 ms
Hoofdlettergevoelig 47,010 52 ms 35 ms
Gefacetteerd (in een veld) 151,413 148 ms 124 ms
Woordvormen 150,522 163 ms 140 ms
Synoniemen 202,299 211 ms 168 ms
Homofonen 206,431 208 ms 160 ms
Spellingcorrectie 213,795 168 ms 174 ms
Toetsenbordindelingcorrectie 213,720 182 ms 168 ms
Aliassen 78,118 203 ms 143 ms
Documentfilter (alleen PDF) 88,732 147 ms 131 ms
Zoeken per fragmenten 202,079 155 ms 137 ms
Objectquery 37,935 456 ms 236 ms
Numeriek bereik 703,582 25.2 s 8.5 s
Reguliere expressie 609,547 27.9 s 26.5 s
Datumbereik van een jaar 138,876 92.1 s 87.2 s

Fuzzy‑zoekopdracht, spellingcorrectie en toetsenbordindelingcorrectie zijn hier ongeveer even snel als een eenvoudige woordzoekopdracht, hoewel de index 285.6 miljoen termen bevat.

De laatste drie rijen zijn opzettelijk extreem: de reguliere expressie kwam 310 miljoen keer voor in tweederde van alle documenten, het numerieke bereik 231 miljoen keer in driekwart van hen, en het datumbereik besloeg een heel jaar. Sinds 26.11 hergebruiken herhaalde uitvoeringen de woorden die door de eerste uitvoering werden gematcht, dus laten de herhaalde tijden zien waar de tijd naartoe gaat: in het verzamelen van de voorkomens. Een gebruiker heeft zelden een resultaat van die omvang nodig, en een korter bereik, een specifiekere patroon of een documentfilter houdt het resultaat, en de tijd, klein.

De volledige tabel met de queries en het aantal voorkomens staat in de documentatie.

Optimalisatie: een taak voor de nacht

De optimalisatie heeft de 727 segmenten samengevoegd tot 28 en de index verkleind van 60.2 GB naar 49.5 GB in 12 uur 24 minuten. De grootte van een samengevoegd segment is beperkt, dus een grote index wordt geoptimaliseerd in meerdere segmenten in plaats van één. Zoekopdrachten worden niet geblokkeerd terwijl een index wordt geoptimaliseerd, zodat de optimalisatie van een grote index op de achtergrond kan draaien, bijvoorbeeld ’s nachts.

Vijf lessen voor je project

  1. Eenmalig extraheren, meerdere keren indexeren. Separate data extraction slaat de geëxtraheerde tekst op in bestanden, zodat je de index opnieuw kunt opbouwen of andere instellingen kunt proberen zonder de documenten opnieuw te extraheren.
  2. Indexeer in grote batches. Elke aanroep van Index.Add kost meer naarmate de index groeit, dus minder, grotere aanroepen indexeren een grote collectie veel sneller.
  3. Open de index één keer. Het openen van een grote index duurt seconden; bewaar het Index‑object en voer alle zoekopdrachten daarop uit – searches are thread-safe.
  4. Optimaliseer op de achtergrond. Zoekopdrachten blijven werken terwijl de index wordt geoptimaliseerd, dus plan de optimalisatie in rustige uren.
  5. Houd de zwaarste queries smal. Reguliere expressies en bereiken die honderden miljoenen voorkomens matchen duren seconden; filters en smallere patronen houden hun resultaten, en hun tijd, klein.

Voer de benchmark uit op je documenten

Je documenten, queries en hardware bepalen je cijfers, dus meet ze. De GroupDocs.Search for .NET benchmarks applicatie meet de extractie, het indexeren, de optimalisatie en 20 soorten zoekopdrachten, rapporteert de tijd en het piekgeheugen van elke bewerking en schrijft alles naar een CSV‑bestand:

git clone https://github.com/groupdocs-search/full-text-search-benchmark-net.git
cd full-text-search-benchmark-net
dotnet run -c Release --project src/GroupDocs.Search.Benchmark

Voor het uitvoeren, stel de licentie, de mappen en de queries voor de taal van je documenten in aan de bovenkant van Program.cs. Een gratis temporary license is voldoende: zonder licentie beperkt de evaluatiemodus het aantal geïndexeerde en gevonden documenten.

Bronnen