Force Merge VerdichtungCompatible with Milvus 3.0.x

Force Merge wurde entwickelt, um kleine und fragmentierte Segmente in weniger und größere Segmente zu konsolidieren, um die Abfrageleistung und Speichereffizienz zu verbessern. In diesem Leitfaden wird erklärt, wie Sie die Force Merge Compaction verwenden können.

Übersicht

Die Standardverdichtung hält die Segmentgrößen durch die Zusammenführung von mehreren Segmenten in der Nähe der konfigurierten maxSize, aber es können immer noch mittelgroße Fragmente zurückbleiben, die nicht weiter zusammengeführt werden können, ohne die Grenzen zu überschreiten. Wenn eine Sammlung beispielsweise aus fünf 2-MB-Segmenten besteht und maxSize 3 MB beträgt, würde das Zusammenführen von zwei beliebigen Segmenten den Grenzwert überschreiten, so dass die Standardkompaktierung die Segmentanzahl nicht weiter reduzieren kann und das fragmentierte Layout bestehen bleibt.

Force merge fügt einen target_size Parameter hinzu und unterstützt die Reorganisation von Segmenten in Richtung der gewünschten Größe innerhalb einer engen Toleranz, wenn möglich. Wenn die angegebene target_size 4 MB beträgt, können die fünf kleinen 2 MB-Segmente in weniger größere Segmente zusammengeführt werden (siehe unten). Auf diese Weise wird die Anzahl der überzähligen Segmente reduziert, es werden Ziele unterstützt, die größer sind als die Standardeinstellungen von maxSize, und wenn das Ziel sehr groß ist, kann das System eine praktische Ausgabegröße und Segmentanzahl für die aktuelle Hardware und QueryNode-Topologie wählen.

Um zu verstehen, welche Verdichtungsmethode zu verwenden ist, siehe FAQ.

R8eow3kaqhktokblcmocnvxmnee

Die erzwungene Zusammenführung erweitert die bestehende Compaction API mit einem target_size Parameter. Sie ist vollständig abwärtskompatibel: bestehende Verdichtungsaufrufe ohne target_size funktionieren weiterhin wie bisher.

Force Merge arbeitet asynchron. Sie blockiert keine Such- oder Abfrageoperationen, verbraucht aber während der Ausführung E/A- und Speicherressourcen.

Force Merge Compaction verwenden

Voraussetzungen

• Milvus Version 3.0 oder höher

• PyMilvus 3.0 oder höher

Globale Konfiguration

Die folgenden Konfigurationsparameter steuern das Verhalten von Force Merge. Setzen Sie sie in der Milvus-Konfigurationsdatei oder über Umgebungsvariablen.

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.

Parameter	Standardwert	Beschreibung
dataCoord.segment.maxSize	512	Voreingestellte maximale Segmentgröße in MB. Wird als Ziel verwendet, wenn target_size 0 ist oder weggelassen wird. Dient auch als zulässiger Mindestwert für explizite target_size.
dataCoord.compaction.maxFullSegmentThreshold	100	Schwellenwert der Segmentanzahl für die Auswahl des Algorithmus. Wenn die Anzahl der Segmente diesen Wert überschreitet, verwendet Milvus einen schnelleren Greedy-Algorithmus für die Zusammenführungsplanung. Standardalgorithmus (wird verwendet, wenn die Anzahl der Segmente <= dataCoord.compaction.maxFullSegmentThreshold): führt zu optimaleren Zusammenführungsergebnissen, benötigt aber mehr Zeit für die Berechnung. Greedy-Algorithmus (wird verwendet, wenn die Anzahl der Abschnitte > dataCoord.compaction.maxFullSegmentThreshold): schließt die Planung viel schneller ab, allerdings auf Kosten einer etwas weniger optimalen Gruppierung der Abschnitte.
dataCoord.compaction.forceMerge.datanodeMemoryFactor	4.0	Der Datenknotenspeicher wird durch diesen Faktor geteilt, um die größte Segmentgröße zu berechnen, die das System zulässt. Ein größerer Wert weist der Zusammenführung weniger Speicher zu, lässt aber mehr für andere DataNode-Operationen übrig, was die Knotenstabilität verbessert. Ein kleinerer Wert ermöglicht größere Zusammenführungen, erhöht aber den Speicherdruck. Bei einem Standardfaktor von 4,0 und einem DataNode mit 16 GB Speicher beträgt das Zusammenführungsbudget beispielsweise 4 GB. Das bedeutet, dass die Gesamtgröße der Segmente, die in einem einzigen Vorgang zusammengeführt werden, 4 GB nicht überschreiten darf.
dataCoord.compaction.forceMerge.querynodeMemoryFactor	4.0	Der minimale QueryNode-Speicher wird durch diesen Faktor geteilt. Wird bei der automatischen Größenberechnung (target_size=max_int64) verwendet, um sicherzustellen, dass zusammengeführte Segmente von QueryNodes geladen werden können. Ein größerer Wert führt zu kleineren Segmenten, die für QueryNodes leichter zu laden sind. Ein kleinerer Wert ermöglicht größere Segmente, kann aber bei QueryNodes mit begrenztem Speicherplatz zu Ladefehlern führen. Bei einem Standardfaktor von 4,0 und einem kleinsten QueryNode mit 16 GB Speicher wird die automatisch berechnete Zielgröße 4 GB nicht überschreiten. Dadurch wird verhindert, dass Force Merge so große Segmente erzeugt, dass QueryNodes sie nicht laden können.

Um die oben genannten Änderungen auf Ihren Milvus-Cluster anzuwenden, folgen Sie bitte den Schritten in Konfigurieren von Milvus mit Helm und Konfigurieren von Milvus mit Milvus Operators.

Force Merge-Verdichtung auslösen

Sie lösen Force Merge Compaction aus, indem Sie compact() mit dem Parameter target_size aufrufen. Einzelheiten zu den Parametern finden Sie unter Parameterreferenz weiter unten.

Es stehen drei Modi für die Force Merge Compaction zur Verfügung:

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

Im Folgenden finden Sie Beispiele für die Verwendung der einzelnen Verdichtungsmodi.

Standard (Standardverdichtung)

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")

Explizite Zielgröße

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

Automatische Größenberechnung

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

Parameter-Referenz

In der folgenden Tabelle werden die Parameter erläutert.

Parameter	Typ	Beschreibung
collection_name	str	Erforderlich. Der Name der zu verdichtenden Sammlung.
target_size	int	Optional. Die Zielsegmentgröße in MB. Es gibt 3 Optionen für den Parameterwert: 0 oder weggelassen: Verwendet die konfigurierte dataCoord.segment.maxSize (Standard: 512 MB). Entspricht der Standardkompaktierung. Expliziter Wert: Führt Segmente zu ungefähr der angegebenen Größe in MB zusammen (z. B. 2048). Muss größer oder gleich der konfigurierten dataCoord.segment.maxSize sein. max_int64 ((1 << 63) - 1): Berechnet automatisch die optimale Größe auf der Grundlage der aktuellen Segmentverteilung und der verfügbaren Knotenressourcen.

Überprüfung des Verdichtungsfortschritts

Die Force Merge-Verdichtung läuft asynchron. Verwenden Sie die zurückgegebene Job-ID, um den Fortschritt zu überprüfen:

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

Bewährte Verfahren

• Verwenden Sie Force Merge Compaction nicht in Produktionsumgebungen.

• Verwenden Sie in den meisten Fällen den automatischen Größenberechnungsmodus. Wenn Sie target_size auf max_int64 setzen, kann Milvus Ihre Segmentverteilung und Knotenressourcen analysieren, um die beste Größe zu bestimmen. Dies ist der empfohlene Ansatz, es sei denn, Sie haben spezielle Anforderungen an die Größe.

• Berücksichtigen Sie den Kompromiss bei der Leistung. Force Merge Verdichtung ist ein ressourcenintensiver Vorgang. Es werden Segmentdaten gelesen, zusammengeführt und neu geschrieben. Planen Sie ihn in Zeiten mit geringem Datenverkehr, um die Auswirkungen auf die Abfragelatenz zu minimieren.

• Überwachen Sie die Segmentanzahl vorher und nachher. Verwenden Sie get_compaction_state() und list_persistent_segments, um zu überprüfen, ob die Verdichtung wie erwartet weniger und größere Segmente erzeugt hat.

FAQ

Wie unterscheidet sich Force Merge von der Standardverdichtung?

Diese beiden Arten von Verdichtungsoperationen dienen unterschiedlichen Zwecken.

• Bei der Standardverdichtung (targetSize=0 oder weggelassen) handelt es sich um einen inkrementellen Bereinigungspfad nach bestem Wissen und Gewissen.

• Zusammenführen erzwingen (targetSize>0) ist ein Umpackungspfad auf Sammlungsebene, um weniger, größere, zielnahe Segmente zu erzeugen.

Der Hauptunterschied ist die Form der Zusammenführung: Die Standardverdichtung ist effektiv m → 1 pro Aufgabe, während die erzwungene Zusammenführung m → n über gruppierte Eingaben ist. Aus diesem Grund kann die erzwungene Zusammenführung Segment-Layouts lösen, die mit der Standardverdichtung nicht möglich sind. In der folgenden Tabelle werden die beiden Arten von Operationen miteinander verglichen.

Dimension	Standardverdichtung (Standard)	Zusammenführen erzwingen
API-Auslöser	targetSize=0 (oder nicht gesetzt), kein Major/L0-Flag	targetSize>0 (MB)
Primäres Ziel	Inkrementelle Bereinigung von offensichtlichen Fragmenten; Routinewartung	Sammlungsweite Konsolidierung für Suche und Abgleich
Quelle der Segmentgröße	Feste dataCoord.segment.maxSize (Serverkonfiguration)	Benutzer targetSize, dann durch maxSafeSize sicherheitsbegrenzt
Gültigkeit der Parameter	Keine Einstellung der Benutzergröße	Benutzer targetSize muss >= dataCoord.segment.maxSize sein; sonst abgelehnt
Obere Sicherheitsgrenze	Nur Config Cap	maxSafeSize = min(QueryNode mem, DataNode mem) / memory_factor (standalone non-pooling: weiter halbiert)
Merge-Form	m → 1 pro Task, Ausgabe <= configMaxSize	m → n, Ausgaben nahe targetSize
Mittel-Segment-Verhalten	Kann dauerhaft stecken bleiben (z. B. können zwei 60%-Segmente nicht legal zu einem 120%-Segment werden)	Umpacken + Aufteilen funktioniert; kein "Steckenbleiben bei 60 %"-Muster
Fähigkeit zur Abflachung der Sammlung	Begrenzt; wiederholte Durchläufe können immer noch viele mittlere Segmente hinterlassen	Stark; entwickelt, um die Anzahl der Segmente zu verringern und die Fülle zu erhöhen
Topologie-Bewusstsein	Keine	Ja; verwendet QueryNode/Replica/Shard-Layout
Abstimmung der Lesepfad-Parallelität	Keine	Passt die Anzahl der Ausgaben mit queryNodeCount / (Replikate × Shards) an, wenn gültig
Typischer Anwendungsfall	Tägliche Aufräumarbeiten mit hohem Aufwand nach Schreibvorgängen/Löschvorgängen	Benchmark-Vorbereitung, Suchoptimierung, Anpassung der Lastparallelität
Umfangserwartung	Erwartet keine vollständige Neupackung der Sammlung	Vorgesehen für Repack-Ergebnisse auf Sammlungsebene

Anleitung zur Auswahl:

• Wählen Sie die Standardkompaktierung für risikoarme, inkrementelle Bereinigungen.

• Wählen Sie Force Merge, wenn Sie die Sammlung explizit in weniger, größere Segmente umgestalten möchten, die dem Such- und Ladeverhalten entsprechen.

Was ist der Unterschied zwischen Force Merge und Clustering Compaction?

Clustering Compaction (is_clustering=True) reorganisiert Daten innerhalb von Segmenten auf der Grundlage eines Clustering-Schlüssels, um die Suche zu verbessern. Force Merge (target_size=N) optimiert die Segmentgrößen, ohne die Datenverteilung zu verändern. Sie dienen unterschiedlichen Zwecken und können zusammen verwendet werden: Führen Sie zuerst die Clustering-Compaction aus, um die Daten zu organisieren, und dann Force Merge, um die resultierenden Segmente zu konsolidieren.

Kann ich Force Merge für eine Sammlung ausführen, die gerade abgefragt wird?

Ja. Force Merge wird asynchron ausgeführt und blockiert keine Abfragen. Es verbraucht jedoch DataNode- und Festplatten-E/A-Ressourcen, so dass sich die Abfragelatenz während der Verdichtung erhöhen kann. Planen Sie Force Merge in Zeiten mit geringem Datenverkehr, um optimale Ergebnisse zu erzielen.

Was passiert, wenn ich eine target_size kleiner als maxSize einstelle?

Die Anfrage wird mit einer Fehlermeldung zurückgewiesen. Die Zielgröße muss größer als oder gleich der konfigurierten dataCoord.segment.maxSize sein.