mmap verwenden

Memory Mapping (Mmap) ermöglicht den direkten Speicherzugriff auf große Dateien auf der Festplatte, so dass Milvus Indizes und Daten sowohl im Speicher als auch auf der Festplatte speichern kann. Dieser Ansatz hilft bei der Optimierung der Datenplatzierungspolitik auf der Grundlage der Zugriffshäufigkeit und erweitert die Speicherkapazität für Sammlungen, ohne die Suchleistung wesentlich zu beeinträchtigen. Diese Seite hilft Ihnen zu verstehen, wie Milvus mmap verwendet, um eine schnelle und effiziente Datenspeicherung und -abfrage zu ermöglichen.

Überblick

Milvus verwendet Sammlungen, um Vektoreinbettungen und ihre Metadaten zu organisieren, wobei jede Zeile in der Sammlung eine Entität darstellt. Wie in der linken Abbildung unten dargestellt, speichert das Vektorfeld die Vektoreinbettungen und die Skalarfelder deren Metadaten. Wenn Sie Indizes für bestimmte Felder erstellt und die Sammlung geladen haben, lädt Milvus die erstellten Indizes und Feldrohdaten in den Speicher.

Mmap illustriert

Milvus ist ein speicherintensives Datenbanksystem, und die verfügbare Speichergröße bestimmt die Kapazität einer Sammlung. Das Laden von Feldern mit einer großen Datenmenge in den Speicher ist unmöglich, wenn die Datengröße die Speicherkapazität übersteigt, was bei KI-gesteuerten Anwendungen der Normalfall ist.

Um solche Probleme zu lösen, führt Milvus mmap ein, um das Laden von heißen und kalten Daten in Sammlungen auszugleichen. Wie in der rechten Abbildung oben gezeigt, können Sie Milvus so konfigurieren, dass die Rohdaten in bestimmten Feldern in den Speicher gemappt werden, anstatt sie vollständig in den Speicher zu laden. Auf diese Weise können Sie direkten Speicherzugriff auf die Felder erhalten, ohne sich um Speicherprobleme zu kümmern, und die Kapazität der Sammlung erweitern.

Wenn Sie die Datenplatzierungsverfahren in der linken und rechten Abbildung vergleichen, können Sie feststellen, dass der Speicherverbrauch in der linken Abbildung viel höher ist als in der rechten. Wenn mmap aktiviert ist, werden die Daten, die in den Speicher geladen werden sollten, auf die Festplatte ausgelagert und im Seiten-Cache des Betriebssystems zwischengespeichert, wodurch der Speicherbedarf verringert wird. Allerdings können Cache-Treffer zu einer Leistungsverschlechterung führen. Einzelheiten hierzu finden Sie in diesem Artikel.

Wenn Sie mmap auf Milvus konfigurieren, müssen Sie sich an einen Grundsatz halten: Lassen Sie die Daten und Indizes, auf die häufig zugegriffen wird, immer vollständig in den Speicher geladen und verwenden Sie mmap für die übrigen Felder.

Verwendung von mmap in Milvus

Milvus bietet hierarchische mmap-Einstellungen auf globaler, Feld-, Index- und Sammlungsebene, wobei die Index- und Feldebene Vorrang vor der Sammlungsebene und die Sammlungsebene vor der globalen Ebene hat.

Globale mmap-Einstellungen

Die Einstellung auf Clusterebene ist die globale Einstellung und hat den geringsten Vorrang. Milvus bietet mehrere mmap-bezogene Einstellungen in milvus.yaml. Diese Einstellungen gelten für alle Sammlungen im Cluster.

...
queryNode:
  mmap:
    scalarField: false
    scalarIndex: false
    vectorField: false
    vectorIndex: false
    # The following should be a path on a high-performance disk
    mmapDirPath: any/valid/path 
....

Konfigurieren Element	Beschreibung	Standardwert
queryNode.mmap.scalarField	Gibt an, ob die Rohdaten aller skalaren Felder in den Speicher abgebildet werden sollen. Die Einstellung true bewirkt, dass Milvus die Rohdaten der Skalarfelddaten einer Sammlung in den Speicher abbildet, anstatt sie beim Empfang einer Ladeanforderung für diese Sammlung vollständig zu laden.	false
queryNode.mmap.scalarIndex	Gibt an, ob alle skalaren Feldindizes in den Speicher abgebildet werden sollen. Die Einstellung true bewirkt, dass Milvus die Skalarfeld-Indizes einer Sammlung in den Speicher abbildet, anstatt sie beim Empfang einer Ladeanforderung für diese Sammlung vollständig zu laden. Derzeit wird nur das Skalarfeld unterstützt, das den folgenden Index-Typ verwendet: INVERTED	false
queryNode.mmap.vectorField	Gibt an, ob die Rohdaten aller Vektorfelder im Speicher abgebildet werden sollen. Die Einstellung true bewirkt, dass Milvus die Rohdaten der Vektorfelddaten einer Sammlung in den Speicher abbildet, anstatt sie beim Empfang einer Ladeanforderung für diese Sammlung vollständig zu laden.	false
queryNode.mmap.vectorIndex	Gibt an, ob alle Vektorfeld-Indizes in den Speicher abgebildet werden sollen. Die Einstellung true bewirkt, dass Milvus die Vektorfeld-Indizes einer Sammlung in den Speicher abbildet, anstatt sie beim Empfang einer Ladeanforderung für diese Sammlung vollständig zu laden. Derzeit werden nur die Vektorfelder mit den folgenden Index-Typen unterstützt: FLAT IVF_FLAT IVF_SQ8 IVF_PQ BIN_FLAT BIN_IVF_FLAT HNSW SCANN SPÄRLICHER_INVERTIERTER_INDEX SPARSE_WAND	false
queryNode.mmap.mmapDirPath	Gibt den Pfad zu den memory-mapped Dateien an. Der Standardwert gilt, wenn dieser nicht angegeben wird. Der Platzhalter localStorage.path im Standardwert gibt das Festplattenlaufwerk von Milvus QueryNodes an. Stellen Sie sicher, dass Ihre QueryNodes über eine leistungsstarke Festplatte verfügen, um optimale mmap-Vorteile zu erzielen.	{localStorage.path}/mmap

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

Manchmal sind die globalen mmap-Einstellungen für bestimmte Anwendungsfälle nicht flexibel. Um alternative Einstellungen auf eine bestimmte Sammlung oder ihre Indizes anzuwenden, sollten Sie mmap speziell für eine Sammlung, ein Feld oder einen Index konfigurieren. Sie müssen eine Sammlung freigeben und laden, bevor die Änderungen an den mmap-Einstellungen wirksam werden.

Feldspezifische mmap-Einstellungen

Um feldspezifisches mmap zu konfigurieren, müssen Sie den Parameter mmap_enabled beim Hinzufügen eines Feldes angeben. Sie können mmap für dieses spezifische Feld aktivieren, indem Sie diesen Parameter auf True setzen.

Das folgende Beispiel zeigt, wie Sie feldspezifisches mmap konfigurieren, wenn Sie ein Feld hinzufügen.

from pymilvus import MilvusClient, DataType

CLUSTER_ENDPOINT="http://localhost:19530"
TOKEN="root:Milvus"

client = MilvusClient(
    uri=CLUSTER_ENDPOINT,
    token=TOKEN
)

schema = MilvusClient.create_schema()
schema.add_field("id", DataType.INT64, is_primary=True, auto_id=False)
schema.add_field("vector", DataType.FLOAT_VECTOR, dim=5)

schema = MilvusClient.create_schema()

# Add a scalar field and enable mmap
schema.add_field(
    field_name="doc_chunk",
    datatype=DataType.INT64,
    is_primary=True,
    mmap_enabled=True,
)

# Alter mmap settings on a specific field
# The following assumes that you have a collection named `my_collection`
client.alter_collection_field(
    collection_name="my_collection",
    field_name="doc_chunk",
    field_params={"mmap.enabled": True}
)

import io.milvus.param.Constant;
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.common.DataType;
import io.milvus.v2.service.collection.request.*;

import java.util.*;

String CLUSTER_ENDPOINT = "http://localhost:19530";
String TOKEN = "root:Milvus";
client = new MilvusClientV2(ConnectConfig.builder()
        .uri(CLUSTER_ENDPOINT)
        .token(TOKEN)
        .build());
        
CreateCollectionReq.CollectionSchema schema = client.createSchema();

schema.addField(AddFieldReq.builder()
        .fieldName("id")
        .dataType(DataType.Int64)
        .isPrimaryKey(true)
        .autoID(false)
        .build());

schema.addField(AddFieldReq.builder()
        .fieldName("vector")
        .dataType(DataType.FloatVector)
        .dimension(5)
        .build());

Map<String, String> typeParams = new HashMap<String, String>() {{
    put(Constant.MMAP_ENABLED, "false");
}};
schema.addField(AddFieldReq.builder()
        .fieldName("doc_chunk")
        .dataType(DataType.VarChar)
        .maxLength(512)
        .typeParams(typeParams)
        .build());

CreateCollectionReq req = CreateCollectionReq.builder()
        .collectionName("my_collection")
        .collectionSchema(schema)
        .build();
client.createCollection(req);

client.alterCollectionField(AlterCollectionFieldReq.builder()
        .collectionName("my_collection")
        .fieldName("doc_chunk")
        .property(Constant.MMAP_ENABLED, "true")
        .build());

import { MilvusClient, DataType } from '@zilliz/milvus2-sdk-node';

const CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT";
const TOKEN="YOUR_TOKEN";

const client = await MilvusClient({
    address: CLUSTER_ENDPOINT,
    token: TOKEN
});

const schema = [
{
    name: 'vector',
    data_type: DataType.FloatVector
},
{
    name: "doc_chunk",
    data_type: DataType.VarChar,
    max_length: 512,
    'mmap.enabled': false,
}
];

await client.createCollection({
    collection_name: "my_collection",
    schema: schema
});

await client.alterCollectionFieldProperties({
    collection_name: "my_collection",
    field_name: "doc_chunk",
    properties: {"mmap_enable": true}
});

// go

#restful
export TOKEN="root:Milvus"
export CLUSTER_ENDPOINT="http://localhost:19530"

export idField='{
    "fieldName": "id",
    "dataType": "Int64",
    "elementTypeParams": {
        "max_length": 512
    },
    "isPrimary": true,
    "auto_id": false
}'

export vectorField='{
    "fieldName": "vector",
    "dataType": "FloatVector",
    "elementTypeParams": {
       "dim": 5
    }
}'

export docChunkField='{
    "fieldName": "doc_chunk",
    "dataType": "Int64",
    "elementTypeParams": {
        "max_length": 512,
        "mmap.enabled": false
    }
}'

export schema="{
    \"autoID\": false,
    \"fields\": [
        $idField,
        $docChunkField,
        $vectorField
    ]
}"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
--data "{
    \"collectionName\": \"my_collection\",
    \"schema\": $schema
}"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/fields/alter_properties" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "fieldName": "doc_chunk",
    "fieldParams":{
        "mmap.enabled": true
    }
}'

Anschließend können Sie eine Sammlung mit dem oben erstellten Schema erstellen. Wenn eine Anfrage zum Laden der Sammlung eingeht, mappt Milvus die Rohdaten des doc_chunk-Feldes in den Speicher.

Indexspezifische mmap-Einstellungen

Um indexspezifisches mmap zu konfigurieren, müssen Sie die Eigenschaft mmap.enable in die Indexparameter aufnehmen, wenn Sie den Index hinzufügen. Sie können mmap für diesen spezifischen Index aktivieren, indem Sie die Eigenschaft auf true setzen.

Das folgende Beispiel zeigt, wie Sie indexspezifisches mmap konfigurieren, wenn Sie einen Index hinzufügen.

# Add a varchar field
schema.add_field(
    field_name="title",
    datatype=DataType.VARCHAR,
    max_length=512   
)

index_params = MilvusClient.prepare_index_params()

# Create index on the varchar field with mmap settings
index_params.add_index(
    field_name="title",
    index_type="AUTOINDEX",
    params={ "mmap.enabled": "false" }
)

# Change mmap settings for an index
# The following assumes that you have a collection named `my_collection`
client.alter_index_properties(
    collection_name="my_collection",
    index_name="title",
    properties={"mmap.enabled": True}
)

schema.addField(AddFieldReq.builder()
        .fieldName("title")
        .dataType(DataType.VarChar)
        .maxLength(512)
        .build());
        
List<IndexParam> indexParams = new ArrayList<>();
Map<String, Object> extraParams = new HashMap<String, Object>() {{
    put(Constant.MMAP_ENABLED, false);
}};
indexParams.add(IndexParam.builder()
        .fieldName("title")
        .indexType(IndexParam.IndexType.AUTOINDEX)
        .extraParams(extraParams)
        .build());
        
client.alterIndexProperties(AlterIndexPropertiesReq.builder()
        .collectionName("my_collection")
        .indexName("title")
        .property(Constant.MMAP_ENABLED, "true")
        .build());

// Create index on the varchar field with mmap settings
await client.createIndex({
    collection_name: "my_collection",
    field_name: "title",
    params: { "mmap.enabled": false }
});

// Change mmap settings for an index
// The following assumes that you have a collection named `my_collection`
await client.alterIndexProperties({
    collection_name: "my_collection",
    index_name: "title",
    properties:{"mmap.enabled": true}
});

// go

# restful
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/indexes/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "indexParams": [
        {
            "fieldName": "doc_chunk",
            "params": {
                "index_type": "AUTOINDEX",
                "mmap.enabled": true
            }
        }
    ]
}'

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/indexes/alter_properties" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "indexName": "doc_chunk",
    "properties": {
        "mmap.enabled": false
    }
}'

Dann können Sie die Indexparameter in einer Sammlung referenzieren. Beim Empfang einer Anfrage zum Laden der Sammlung mappt Milvus den Index des Titelfeldes in den Arbeitsspeicher.

Sammlungsspezifische mmap-Einstellungen

Um eine sammlungsweite mmap-Strategie zu konfigurieren, müssen Sie die Eigenschaft mmap.enabled in die Anforderung zum Erstellen einer Sammlung aufnehmen. Sie können mmap für eine Sammlung aktivieren, indem Sie diese Eigenschaft auf true setzen.

Das folgende Beispiel veranschaulicht, wie mmap in einer Sammlung mit dem Namen my_collection bei deren Erstellung aktiviert wird. Wenn eine Anfrage zum Laden der Sammlung eingeht, mappt Milvus die Rohdaten aller Felder in den Arbeitsspeicher.

# Enable mmap when creating a collection
client.create_collection(
    collection_name="my_collection",
    schema=schema,
    properties={ "mmap.enabled": "true" }
)

CreateCollectionReq req = CreateCollectionReq.builder()
        .collectionName("my_collection")
        .collectionSchema(schema)
        .property(Constant.MMAP_ENABLED, "false")
        .build();
client.createCollection(req);

await client.createCollection({
    collection_name: "my_collection",
    scheme: schema,
    properties: { "mmap.enabled": false }
});

// go

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
--data "{
    \"collectionName\": \"my_collection\",
    \"schema\": $schema,
    \"params\": {
        \"mmap.enabled\": \"false\"
    }
}"

Sie können auch die mmap-Einstellungen einer bestehenden Sammlung ändern.

# Release collection before change mmap settings
client.release_collection("my_collection")

# Ensure that the collection has already been released 
# and run the following
client.alter_collection_properties(
    collection_name="my_collection",
    properties={
        "mmap.enabled": false
    }
)

# Load the collection to make the above change take effect
client.load_collection("my_collection")

client.releaseCollection(ReleaseCollectionReq.builder()
        .collectionName("my_collection")
        .build());
        
client.alterCollectionProperties(AlterCollectionPropertiesReq.builder()
        .collectionName("my_collection")
        .property(Constant.MMAP_ENABLED, "false")
        .build());

client.loadCollection(LoadCollectionReq.builder()
        .collectionName("my_collection")
        .build());
       

// Release collection before change mmap settings
await client.releaseCollection({
    collection_name: "my_collection"
});

// Ensure that the collection has already been released 
// and run the following
await client.alterCollectionProperties({
    collection_name: "my_collection",
    properties: {
        "mmap.enabled": false
    }
});

// Load the collection to make the above change take effect
await client.loadCollection({
    collection_name: "my_collection"
});

// go

# restful
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/release" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection"
}'

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/alter_properties" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "properties": {
        "mmmap.enabled": false
    }
}'

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/load" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection"
}'

Sie müssen die Sammlung freigeben, um Änderungen an ihren Eigenschaften vorzunehmen, und die Sammlung neu laden, damit die Änderungen wirksam werden.