Compattazione Force MergeCompatible with Milvus 3.0.x

Force Merge è progettato per consolidare segmenti piccoli e frammentati in segmenti più piccoli e più grandi per migliorare le prestazioni delle query e l'efficienza dello storage. Questa guida spiega come usare la compattazione force merge.

Panoramica

La compattazione standard mantiene le dimensioni dei segmenti vicino all'indirizzo maxSize grazie alle unioni molti-a-uno, ma può comunque lasciare frammenti di medie dimensioni che non possono essere uniti ulteriormente senza superare i limiti. Ad esempio, come illustrato di seguito, se una raccolta ha cinque segmenti da 2 MB e maxSize è di 3 MB, l'unione di due segmenti qualsiasi supererebbe il limite, quindi la compattazione standard non può ridurre ulteriormente il numero di segmenti e il layout frammentato rimane.

Force merge aggiunge il parametro target_size e supporta la riorganizzazione dei segmenti verso la dimensione desiderata entro una stretta tolleranza, quando possibile. Come illustrato di seguito, se target_size specificato è di 4 MB, i cinque segmenti piccoli da 2 MB possono essere ulteriormente uniti in un numero inferiore di segmenti più grandi. In questo modo si riduce il numero di segmenti in eccesso, si supportano obiettivi più grandi delle impostazioni predefinite di maxSize e, quando l'obiettivo è molto grande, si consente al sistema di scegliere una dimensione di output e un numero di segmenti pratici per l'hardware e la topologia del QueryNode corrente.

Per capire quale metodo di compattazione utilizzare, vedere le FAQ.

R8eow3kaqhktokblcmocnvxmnee

La compattazione force merge estende l'API esistente Compaction con un parametro target_size. È completamente retrocompatibile: le chiamate di compattazione esistenti senza target_size continuano a funzionare come prima.

Force merge opera in modo asincrono. Non blocca le operazioni di ricerca o di interrogazione, anche se consuma risorse di I/O e di memoria durante l'esecuzione.

Utilizzare la compattazione Force Merge

Prerequisiti

• Milvus versione 3.0 o successiva

• PyMilvus 3.0 o successivo

Configurazione globale

I seguenti parametri di configurazione controllano il comportamento di Force Merge. Vanno impostati nel file di configurazione di Milvus o tramite variabili d'ambiente.

dataCoord:
  segment:
    maxSize: 512         # Default segment max size (MB).
                         # Used when target_size is 0 or omitted.
  compaction:
    maxFullSegmentThreshold: 100
                         # When segment count exceeds this threshold,
                         # a faster greedy algorithm is used instead
                         # of the standard merge algorithm.
    forceMerge:
      datanodeMemoryFactor: 4.0
                         # DataNode memory divided by this factor
                         # determines the the largest segment
                         # size the system can allow.
      querynodeMemoryFactor: 4.0
                         # Minimum QueryNode memory divided by this
                         # factor. Used in automatic size calculation
                         # to ensure merged segments can be loaded.

Parametro	Valore predefinito	Descrizione
dataCoord.segment.maxSize	512	Dimensione massima predefinita del segmento in MB. Utilizzato come target quando target_size è 0 o omesso. Serve anche come valore minimo consentito per target_size esplicito.
dataCoord.compaction.maxFullSegmentThreshold	100	Soglia di conteggio dei segmenti per la selezione dell'algoritmo. Quando il numero di segmenti supera questo valore, Milvus utilizza un algoritmo greedy più veloce per la pianificazione dell'unione. Algoritmo standard (usato quando il numero di segmenti è <= dataCoord.compaction.maxFullSegmentThreshold): produce risultati di fusione più ottimali, ma richiede più tempo per il calcolo. Algoritmo greedy (usato quando il numero di segmenti > dataCoord.compaction.maxFullSegmentThreshold): completa la pianificazione molto più velocemente, a costo di un raggruppamento dei segmenti leggermente meno ottimale.
dataCoord.compaction.forceMerge.datanodeMemoryFactor	4.0	La memoria del DataNode viene divisa per questo fattore per calcolare la dimensione massima del segmento che il sistema può consentire. Un valore maggiore alloca meno memoria per la fusione, ma ne lascia di più per le altre operazioni del DataNode, migliorando la stabilità del nodo. Un valore più basso consente fusioni più grandi, ma aumenta la pressione sulla memoria. Ad esempio, con il fattore predefinito di 4,0 e un DataNode con 16 GB di memoria, il budget di fusione è di 4 GB. Ciò significa che la dimensione totale dei segmenti uniti in una singola operazione non può superare i 4 GB.
dataCoord.compaction.forceMerge.querynodeMemoryFactor	4.0	La memoria minima del QueryNode viene divisa per questo fattore. Utilizzato durante il calcolo automatico delle dimensioni (target_size=max_int64) per garantire che i segmenti uniti possano essere caricati dai QueryNode. Un valore maggiore produce segmenti più piccoli che sono più facili da caricare per i QueryNode. Un valore più piccolo consente di ottenere segmenti più grandi, ma può causare errori di caricamento sui QueryNode con problemi di memoria. Ad esempio, con il fattore predefinito di 4,0 e il QueryNode più piccolo con 16 GB di memoria, la dimensione target calcolata automaticamente non supererà i 4 GB. Questo impedisce a Force Merge di produrre segmenti così grandi che i QueryNode non possono caricarli.

Per applicare le modifiche di cui sopra al vostro cluster Milvus, seguite i passaggi in Configurazione di Milvus con Helm e Configurazione di Milvus con Milvus Operators.

Attivare la compattazione Force Merge

Si attiva la compattazione Force Merge chiamando compact() con il parametro target_size. Per i dettagli sui parametri, vedere il riferimento ai parametri di seguito.

Sono disponibili tre modalità di compattazione Force Merge:

compact("my_collection", target_size=?)
│
├─ Mode 1: target_size = 0 (or omitted)
│  Uses config maxSize (default 512 MB)
│  Equivalent to standard compaction
│
├─ Mode 2: target_size = 2048
│  Merges segments to ~2 GB each
│  Must be >= config maxSize
│
└─ Mode 3: target_size = max_int64
   Auto-calculates optimal size based on
   segment distribution and node memory

Di seguito sono riportati degli esempi che mostrano come utilizzare ciascuna modalità di compattazione force merge.

Predefinita (compattazione standard)

from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

# Standard compaction — uses config maxSize (default 512 MB)
job_id = client.compact("target_collection")

Dimensione target esplicita

# Merge segments to approximately 2 GB each
job_id = client.compact(
    "target_collection",
    target_size="2048"  # The unit is MB
)

Calcolo automatico delle dimensioni

# Let Milvus determine the optimal segment size
max_int64 = (1 << 63) - 1
job_id = client.compact(
    "target_collection",
    target_size=max_int64
)

Riferimento ai parametri

La tabella seguente spiega i parametri.

Parametro	Tipo	Descrizione
collection_name	str	Richiesto. Il nome dell'insieme da compattare.
target_size	int	Opzionale. La dimensione del segmento di destinazione in MB. Esistono 3 opzioni per il valore del parametro: 0 o omesso: Utilizza l'indirizzo dataCoord.segment.maxSize configurato (valore predefinito: 512 MB). Equivale alla compattazione standard. Valore esplicito: Unisce i segmenti a circa la dimensione specificata in MB (ad esempio 2048). Deve essere maggiore o uguale alla dimensione configurata dataCoord.segment.maxSize. max_int64 ((1 << 63) - 1): Calcola automaticamente la dimensione ottimale in base alla distribuzione attuale dei segmenti e alle risorse del nodo disponibili.

Controllo dell'avanzamento della compattazione

La compattazione Force Merge viene eseguita in modo asincrono. Utilizzare l'ID del lavoro restituito per verificare l'avanzamento:

# Check compaction state
state = client.get_compaction_state(job_id)
print(f"State: {state}")

Pratiche ottimali

• Non utilizzare la compattazione force merge in ambienti di produzione.

• Usare la modalità di calcolo automatico delle dimensioni per la maggior parte dei casi. Impostando target_size su max_int64, Milvus analizza la distribuzione dei segmenti e le risorse dei nodi per determinare la dimensione migliore. Questo è l'approccio consigliato, a meno che non si abbiano requisiti specifici di dimensionamento.

• Considerare il compromesso delle prestazioni. La compattazione Force Merge è un'operazione che richiede molte risorse. Legge, unisce e riscrive i dati del segmento. Programmarla in periodi di basso traffico per ridurre al minimo l'impatto sulla latenza delle query.

• Monitorare il conteggio dei segmenti prima e dopo. Utilizzare get_compaction_state() e list_persistent_segments per verificare che la compattazione abbia prodotto un numero inferiore di segmenti più grandi, come previsto.

DOMANDE FREQUENTI

In che modo Force Merge è diverso dalla compattazione standard?

Questi due tipi di operazioni di compattazione hanno scopi diversi.

• La compattazione standard (targetSize=0 o omesso) è un percorso di pulizia incrementale e di massimo sforzo.

• La fusione forzata (targetSize>0) è un percorso di riconfezionamento a livello di raccolta per produrre un numero inferiore di segmenti più grandi e vicini all'obiettivo.

La differenza fondamentale è la forma del merge: la compattazione standard è effettivamente m → 1 per task, mentre il force merge è m → n tra gli input raggruppati. Questo è il motivo per cui il force merge può risolvere layout di segmenti che la compattazione standard non può risolvere. La tabella seguente mette a confronto i due tipi di operazioni.

Dimensione	Compattazione standard (predefinita)	Unione forzata
Attivazione API	targetSize=0 (o non impostato), nessun flag Maggiore/L0	targetSize>0 (MB)
Obiettivo primario	Pulizia incrementale di frammenti evidenti; manutenzione ordinaria	Consolidamento dell'intera collezione per la ricerca e il bilanciamento
Fonte della dimensione del segmento	DataCoord.segment.maxSize fisso (configurazione del server)	TargetSize dell'utente, poi regolato in sicurezza da maxSafeSize
Validità dei parametri	Nessuna regolazione della dimensione utente	TargetSize dell'utente deve essere >= dataCoord.segment.maxSize; altrimenti viene rifiutato.
Limite superiore di sicurezza	Solo per il limite di configurazione	maxSafeSize = min(QueryNode mem, DataNode mem) / memory_factor (standalone non-pooling: ulteriormente dimezzato)
Forma dell'unione	m → 1 per task, output <= configMaxSize	m → n, uscite vicine a targetSize
Comportamento dei segmenti medi	Può bloccarsi in modo permanente (ad esempio, due segmenti al 60% non possono legalmente diventare un segmento al 120%).	Repack + split funziona; nessun modello "bloccato al 60%".
Capacità di appiattimento della raccolta	Limitata; le esecuzioni ripetute possono ancora lasciare molti segmenti medi	Forte; progettato per ridurre il numero di segmenti e spingere la pienezza più in alto
Consapevolezza della topologia	Nessuna	Sì; utilizza il layout QueryNode/replica/shard
Regolazione del parallelismo del percorso di lettura	Nessuno	Regola il conteggio dell'output usando queryNodeCount / (repliche × shard) se valido
Caso d'uso tipico	Pulizia giornaliera ad alto rendimento dopo scritture/cancellazioni	Preparazione di benchmark, ottimizzazione della ricerca, allineamento del parallelismo del carico
Aspettative di ambito	Non ci si aspetta un repack dell'intera collezione	Destinato all'esito del repack a livello di raccolta

Guida alla selezione:

• Scegliere la compattazione standard per una pulizia incrementale a basso rischio.

• Scegliere la fusione forzata quando si desidera esplicitamente rimodellare la raccolta in segmenti meno numerosi e più grandi, in linea con il comportamento di ricerca e caricamento.

In che modo la fusione forzata è diversa dalla compattazione a grappolo?

Lacompattazione del clustering (is_clustering=True) riorganizza i dati all'interno dei segmenti in base a una chiave di clustering per migliorare la selezione della ricerca. Force Merge (target_size=N) ottimizza le dimensioni dei segmenti senza modificare la distribuzione dei dati. I due sistemi hanno scopi diversi e possono essere usati insieme: eseguite prima la compattazione del clustering per organizzare i dati, quindi Force Merge per consolidare i segmenti risultanti.

È possibile eseguire Force Merge su una raccolta che viene interrogata?

Sì. Force Merge viene eseguito in modo asincrono e non blocca le query. Tuttavia, consuma risorse DataNode e I/O del disco, quindi la latenza delle query può aumentare durante la compattazione. Per ottenere i migliori risultati, pianificare Force Merge in periodi di basso traffico.

Cosa succede se si imposta un target_size inferiore a maxSize?

La richiesta viene rifiutata con un errore. La dimensione di destinazione deve essere maggiore o uguale alla dimensione configurata dataCoord.segment.maxSize.