Come si può indicizzare un milione di documenti su un computer ordinario? Quanto cresce l’indice e quanto è veloce la ricerca successiva? Invece di un test sintetico, abbiamo preso un corpus reale di quasi un milione di file, lo abbiamo indicizzato con GroupDocs.Search for .NET 26.11 su un PC desktop e abbiamo misurato ogni fase.

La risposta breve: 919.896 documenti sono stati indicizzati in 3 ore 48 minuti, e 17 dei 20 tipi di ricerca hanno risposto in da 35 a 539 ms, sebbene la maggior parte delle query abbia trovato decine o centinaia di migliaia di documenti. Il benchmark è open source, così puoi misurare i tuoi documenti nello stesso modo.

I risultati in una tabella

Cosa Risultato
Documenti indicizzati 919.896
Indicizzazione 3 h 48 min, 67 documenti al secondo
Dimensione indice 60,2 GB, 49,5 GB dopo l’ottimizzazione
Apertura dell’indice ottimizzato 9,8 s
17 dei 20 tipi di ricerca da 35 a 539 ms (mediana 158 ms) in esecuzioni ripetute
Le query più pesanti da 8,5 a 87 s per risultati di milioni a centinaia di milioni di occorrenze

Configurazione

  • Computer: Intel Core i5-11500 (6 core, 12 thread), 32 GB di RAM, SSD SATA, Windows 10 – un desktop ordinario, non un server.
  • Software: GroupDocs.Search for .NET 26.11 su .NET 10, con le impostazioni predefinite dell’indice.
  • Documenti: il corpus govdocs1 di Digital Corpora – quasi un milione di file provenienti da server web governativi USA: PDF, HTML, Word, Excel, PowerPoint, testo, XML, CSV, immagini e altro. È un corpus difficile: molti file sono fogli di calcolo e dati, e ogni numero o codice distinto diventa un termine, perciò l’indice contiene 285,6 milioni di termini unici.
  • Metodo: il testo dei documenti è stato estratto una volta e salvato su file, così l’indicizzazione è stata misurata separatamente. I dati sono stati poi aggiunti a un nuovo indice in batch fino a 512 MB con 4 thread di indicizzazione, l’indice è stato ottimizzato e 20 tipi di ricerca sono stati eseguiti 3 volte ciascuno.

Su 983.840 file estratti, 63.943 non hanno prodotto testo (PostScript, gzip, Flash e file dBase e file non leggibili, tra gli altri), e un documento era troppo grande per l’indice, così sono stati indicizzati 919.896 documenti.

Indicizzazione: 920 mila documenti in meno di quattro ore

L’indicizzazione ha richiesto 3 ore 48 minuti, ovvero una media di 67 documenti al secondo, includendo 28 minuti spesi a leggere i dati estratti dal disco. L’indice occupa 60,2 GB in 727 segmenti.

Il risultato più utile per la pianificazione è come è cambiato il tempo di una chiamata a Index.Add man mano che l’indice cresceva:

Documenti già presenti nell’indice Tempo medio di una chiamata
0 a 27 000 12,7 s
208 000 a 338 000 52,7 s
497 000 a 639 000 98,9 s
639 000 a 920 000 109,4 s

L’ultima chiamata ha aggiunto solo 1 240 documenti e ha comunque impiegato 113 s, così come le chiamate con più di 9 000 documenti precedenti. In un indice grande, è il numero di chiamate, non il numero di documenti, a determinare la maggior parte del tempo di indicizzazione. Quindi aggiungi documenti a un indice grande in batch grandi quanto la tua memoria lo consente.

Ricerca: decimi di secondo per la maggior parte delle query

L’indice ottimizzato di 28 segmenti è stato aperto in 9,8 s. Ogni query è stata poi eseguita tre volte: la prima esecuzione è ciò che il primo utente di un’app appena avviata attende, e le esecuzioni ripetute rappresentano il caso tipico di un servizio in esecuzione.

Tipo di ricerca Documenti trovati Prima esecuzione Esecuzioni ripetute
Parola semplice 202.079 539 ms 210 ms
Booleano 44.626 251 ms 149 ms
Frase 241.277 591 ms 539 ms
Frase con wildcard 32.270 183 ms 129 ms
Wildcard 267.231 347 ms 287 ms
Fuzzy 202.183 207 ms 157 ms
Sensibile a maiuscole/minuscole 47.010 52 ms 35 ms
Facettata (in un campo) 151.413 148 ms 124 ms
Forme di parole 150.522 163 ms 140 ms
Sinonimi 202.299 211 ms 168 ms
Omofoni 206.431 208 ms 160 ms
Correzione ortografica 213.795 168 ms 174 ms
Correzione layout tastiera 213.720 182 ms 168 ms
Alias 78.118 203 ms 143 ms
Filtro documento (solo PDF) 88.732 147 ms 131 ms
Ricerca per blocchi 202.079 155 ms 137 ms
Query oggetto 37.935 456 ms 236 ms
Intervallo numerico 703.582 25,2 s 8,5 s
Espressione regolare 609.547 27,9 s 26,5 s
Intervallo di date di un anno 138.876 92,1 s 87,2 s

La ricerca fuzzy, la correzione ortografica e la correzione del layout della tastiera sono quasi veloci quanto una ricerca di parola semplice, nonostante l’indice contenga 285,6 milioni di termini.

Le ultime tre righe sono deliberatamente estreme: l’espressione regolare ha corrisposto 310 milioni di occorrenze in due terzi di tutti i documenti, l’intervallo numerico 231 milioni di occorrenze in tre quarti di essi, e l’intervallo di date ha coperto un intero anno. Dalla versione 26.11, le esecuzioni ripetute riutilizzano le parole trovate nella prima esecuzione, così i tempi ripetuti mostrano dove va il tempo: nella raccolta delle occorrenze. Un utente raramente ha bisogno di un risultato di tale dimensione; un intervallo più corto, un modello più specifico o un filtro documento mantengono il risultato, e il tempo, piccoli.

La tabella completa con le query e il numero di occorrenze è nella documentazione.

Ottimizzazione: un lavoro notturno

L’ottimizzazione ha unito i 727 segmenti in 28 e ha ridotto l’indice da 60,2 GB a 49,5 GB in 12 ore 24 minuti. La dimensione di un segmento unito è limitata, quindi un indice grande viene ottimizzato in più segmenti anziché in uno solo. Le ricerche non sono bloccate mentre un indice è ottimizzato, così l’ottimizzazione di un indice grande può essere eseguita in background, ad esempio di notte.

Cinque consigli per il tuo progetto

  1. Estrai una volta, indicizza più volte. La separazione dell’estrazione dei dati salva il testo estratto su file, così puoi ricostruire l’indice o provare altre impostazioni senza dover estrarre nuovamente i documenti.
  2. Indicizza in batch grandi. Ogni chiamata a Index.Add costa di più man mano che l’indice cresce, quindi meno chiamate, più grandi, indicizzano una grande collezione molto più velocemente.
  3. Apri l’indice una sola volta. L’apertura di un indice grande richiede secondi; mantieni l’oggetto Index e esegui tutte le ricerche su di esso – le ricerche sono thread‑safe.
  4. Ottimizza in background. Le ricerche continuano a funzionare mentre l’indice è ottimizzato, quindi programma l’ottimizzazione per le ore di silenzio.
  5. Mantieni le query più pesanti ristrette. Le espressioni regolari e gli intervalli che corrispondono a centinaia di milioni di occorrenze richiedono secondi; filtri e modelli più specifici mantengono i risultati, e il tempo, piccoli.

Esegui il benchmark sui tuoi documenti

I tuoi documenti, le tue query e l’hardware determinano i tuoi numeri, quindi misurali. L’applicazione GroupDocs.Search for .NET benchmarks misura l’estrazione, l’indicizzazione, l’ottimizzazione e 20 tipi di ricerca, riporta il tempo e il picco di memoria di ogni operazione e scrive tutto in un file CSV:

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

Prima dell’esecuzione, imposta la licenza, le cartelle e le query per la lingua dei tuoi documenti all’inizio di Program.cs. Una licenza temporanea gratuita è sufficiente: senza licenza, la modalità di valutazione limita il numero di documenti indicizzati e trovati.

Risorse