Utilizzare mmap

La mappatura della memoria (Mmap) consente l'accesso diretto alla memoria di file di grandi dimensioni su disco, permettendo a Milvus di memorizzare indici e dati sia nella memoria che sul disco rigido. Questo approccio consente di ottimizzare i criteri di posizionamento dei dati in base alla frequenza di accesso, ampliando la capacità di archiviazione delle raccolte senza incidere significativamente sulle prestazioni di ricerca. Questa pagina aiuta a capire come Milvus utilizza mmap per consentire l'archiviazione e il recupero dei dati in modo rapido ed efficiente.

Panoramica

Milvus utilizza le collezioni per organizzare le incorporazioni vettoriali e i loro metadati; ogni riga della collezione rappresenta un'entità. Come mostrato nella figura a sinistra, il campo vettoriale memorizza le incorporazioni vettoriali, mentre i campi scalari memorizzano i loro metadati. Una volta creati gli indici su alcuni campi e caricata la collezione, Milvus carica in memoria gli indici creati e i dati grezzi dei campi.

Mmap illustrata

Milvus è un sistema di database ad alta intensità di memoria e la dimensione della memoria disponibile determina la capacità di una raccolta. Il caricamento in memoria di campi contenenti un grande volume di dati è impossibile se le dimensioni dei dati superano la capacità di memoria, il che è il caso abituale delle applicazioni guidate dall'intelligenza artificiale.

Per risolvere questi problemi, Milvus introduce mmap per bilanciare il caricamento di dati caldi e freddi nelle raccolte. Come mostrato nella figura a destra, è possibile configurare Milvus in modo da creare delle mappe di memoria per i dati grezzi in alcuni campi, invece di caricarli completamente in memoria. In questo modo, è possibile ottenere l'accesso diretto alla memoria dei campi senza preoccuparsi dei problemi di memoria ed estendere la capacità della collezione.

Confrontando le procedure di posizionamento dei dati nelle figure di sinistra e di destra, si può notare che l'utilizzo della memoria è molto più elevato nella figura di sinistra che in quella di destra. Con mmap abilitato, i dati che avrebbero dovuto essere caricati in memoria vengono scaricati sul disco rigido e memorizzati nella cache di pagina del sistema operativo, riducendo l'ingombro della memoria. Tuttavia, le mancate risposte alla cache possono comportare una riduzione delle prestazioni. Per maggiori dettagli, consultare questo articolo.

Quando si configura mmap su Milvus, bisogna sempre attenersi a un principio: Mantenere sempre i dati e gli indici ad accesso frequente completamente caricati in memoria e usare mmap per quelli nei campi rimanenti.

Utilizzare mmap in Milvus

Milvus fornisce impostazioni mmap gerarchiche a livello globale, di campo, di indice e di collezione, dove i livelli di indice e di campo hanno la precedenza sul livello di collezione e il livello di collezione sul livello globale.

Impostazioni mmap globali

L'impostazione a livello di cluster è l'impostazione globale e ha la precedenza più bassa. Milvus fornisce diverse impostazioni relative a mmap in milvus.yaml. Queste impostazioni si applicano a tutte le raccolte nel 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 
....

Configura Elemento	Descrizione	Valore predefinito
queryNode.mmap.scalarField	Specifica se mappare i dati grezzi di tutti i campi scalari in memoria. L'impostazione di true fa sì che Milvus mappi i dati grezzi dei campi scalari di una collezione in memoria, invece di caricarli completamente quando riceve una richiesta di caricamento su questa collezione.	false
queryNode.mmap.scalarIndex	Specifica se mappare tutti gli indici dei campi scalari in memoria. L'impostazione di true fa sì che Milvus mappi gli indici dei campi scalari di una collezione in memoria, invece di caricarli completamente quando riceve una richiesta di caricamento su questa collezione. Attualmente, è supportato solo il campo scalare che utilizza il seguente tipo di indice: INVERTED	false
queryNode.mmap.vectorField	Specifica se mappare i dati grezzi di tutti i campi vettoriali in memoria. L'impostazione di true fa sì che Milvus mappi i dati grezzi dei campi vettoriali di una collezione in memoria, invece di caricarli completamente quando riceve una richiesta di caricamento su questa collezione.	false
queryNode.mmap.vectorIndex	Specifica se mappare tutti gli indici dei campi vettoriali in memoria. Impostando true, Milvus mappa gli indici dei campi vettoriali di una collezione in memoria invece di caricarli completamente quando riceve una richiesta di carico su questa collezione. Attualmente sono supportati solo i campi vettoriali che utilizzano i seguenti tipi di indice: FLAT IVF_FLAT IVF_SQ8 IVF_PQ BIN_FLAT BIN_IVF_FLAT HNSW SCANN INDICE SPARSE_INVERTITO SPARSE_WAND	false
queryNode.mmap.mmapDirPath	Specifica il percorso dei file mappati in memoria. Se non viene specificato, si applica il valore predefinito. Il segnaposto localStorage.path nel valore predefinito indica il disco rigido dei QueryNode Milvus. Assicurarsi che i QueryNode abbiano un disco rigido ad alte prestazioni per ottenere vantaggi ottimali in termini di mmap.	{localStorage.path}/mmap

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

A volte le impostazioni globali di mmap non sono flessibili di fronte a casi d'uso particolari. Per applicare impostazioni alternative a una raccolta specifica o ai suoi indici, si può configurare mmap specifico per una raccolta, un campo o un indice. È necessario rilasciare e caricare una raccolta prima che le modifiche alle impostazioni mmap abbiano effetto.

Impostazioni mmap specifiche del campo

Per configurare mmap specifico per un campo, è necessario includere il parametro mmap_enabled quando si aggiunge un campo. È possibile abilitare mmap su questo campo specifico impostando questo parametro su True.

L'esempio seguente mostra come configurare mmap specifico per il campo quando si aggiunge un campo.

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" \
--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" \
-d '{
    "collectionName": "my_collection",
    "fieldName": "doc_chunk",
    "fieldParams":{
        "mmap.enabled": true
    }
}'

Quindi, si può creare una collezione utilizzando lo schema creato in precedenza. Quando si riceve una richiesta di caricamento della collezione, Milvus utilizza la mappatura in memoria dei dati grezzi del campo doc_chunk.

Impostazioni mmap specifiche per l'indice

Per configurare l'mmap specifico per l'indice, è necessario includere la proprietà mmap.enable nei parametri dell'indice quando lo si aggiunge. È possibile abilitare mmap su questo indice specifico impostando la proprietà a true.

L'esempio seguente mostra come configurare mmap specifico per l'indice quando si aggiunge un indice.

# 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" \
-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" \
-d '{
    "collectionName": "my_collection",
    "indexName": "doc_chunk",
    "properties": {
        "mmap.enabled": false
    }
}'

È quindi possibile fare riferimento ai parametri dell'indice in una collezione. Quando riceve una richiesta di caricamento della collezione, Milvus effettua una mappatura in memoria dell'indice del campo titolo.

Impostazioni di mmap specifiche per la collezione

Per configurare una strategia mmap a livello di collezione, è necessario includere la proprietà mmap.enabled nella richiesta di creazione di una collezione. È possibile abilitare mmap per una raccolta impostando questa proprietà a true.

L'esempio seguente mostra come abilitare mmap in una raccolta denominata my_collection al momento della sua creazione. Quando riceve una richiesta di caricamento della collezione, Milvus esegue il memory-mapping dei dati grezzi di tutti i campi in memoria.

# 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" \
--data "{
    \"collectionName\": \"my_collection\",
    \"schema\": $schema,
    \"params\": {
        \"mmap.enabled\": \"false\"
    }
}"

È anche possibile modificare le impostazioni di mmap di una collezione esistente.

# 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" \
-d '{
    "collectionName": "my_collection"
}'

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/alter_properties" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-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" \
-d '{
    "collectionName": "my_collection"
}'

È necessario rilasciare la collezione per apportare modifiche alle sue proprietà e ricaricarla per rendere effettive le modifiche.