Gunakan mmap

Pemetaan memori (Mmap) memungkinkan akses memori langsung ke file besar di disk, sehingga Milvus dapat menyimpan indeks dan data di memori dan hard drive. Pendekatan ini membantu mengoptimalkan kebijakan penempatan data berdasarkan frekuensi akses, memperluas kapasitas penyimpanan untuk koleksi tanpa memengaruhi kinerja pencarian secara signifikan. Halaman ini membantu Anda memahami bagaimana Milvus menggunakan mmap untuk memungkinkan penyimpanan dan pengambilan data yang cepat dan efisien.

Gambaran Umum

Milvus menggunakan koleksi untuk mengatur penyematan vektor dan metadata mereka, dan setiap baris dalam koleksi mewakili sebuah entitas. Seperti yang ditunjukkan pada gambar kiri di bawah ini, bidang vektor menyimpan embedding vektor, dan bidang skalar menyimpan metadata mereka. Ketika Anda telah membuat indeks pada field tertentu dan memuat koleksi, Milvus akan memuat indeks yang telah dibuat dan data mentah field ke dalam memori.

Ilustrasi Mmap

Milvus adalah sistem basis data yang intensif memori, dan ukuran memori yang tersedia menentukan kapasitas koleksi. Memuat field yang berisi data dalam jumlah besar ke dalam memori tidak mungkin dilakukan jika ukuran data melebihi kapasitas memori, yang biasa terjadi pada aplikasi yang digerakkan oleh AI.

Untuk mengatasi masalah tersebut, Milvus memperkenalkan mmap untuk menyeimbangkan pemuatan data panas dan data dingin dalam koleksi. Seperti yang ditunjukkan pada gambar kanan di atas, Anda dapat mengonfigurasi Milvus untuk memetakan memori data mentah di bidang tertentu alih-alih memuatnya secara penuh ke dalam memori. Dengan cara ini, Anda dapat memperoleh akses memori langsung ke field tanpa mengkhawatirkan masalah memori dan memperluas kapasitas koleksi.

Dengan membandingkan prosedur penempatan data pada gambar kiri dan kanan, Anda dapat mengetahui bahwa penggunaan memori jauh lebih tinggi pada gambar kiri daripada gambar kanan. Dengan mmap diaktifkan, data yang seharusnya dimuat ke dalam memori akan dibuang ke dalam hard drive dan di-cache dalam cache halaman sistem operasi, sehingga mengurangi jejak memori. Namun demikian, kegagalan hit cache dapat mengakibatkan penurunan performa. Untuk detailnya, lihat artikel ini.

Ketika Anda mengonfigurasi mmap pada Milvus, selalu ada prinsip yang harus Anda patuhi: Selalu simpan data dan indeks yang sering diakses secara penuh ke dalam memori dan gunakan mmap untuk data dan indeks yang tersisa.

Menggunakan mmap di Milvus

Milvus menyediakan pengaturan mmap secara hirarkis pada tingkat global, field, indeks, dan koleksi, di mana tingkat indeks dan field didahulukan daripada tingkat koleksi, dan tingkat koleksi daripada tingkat global.

Pengaturan peta global

Pengaturan tingkat klaster adalah pengaturan global dan memiliki prioritas terendah. Milvus menyediakan beberapa pengaturan terkait mmap di milvus.yaml. Pengaturan ini akan berlaku untuk semua koleksi di dalam 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 
....

Mengonfigurasi Item	Deskripsi	Nilai Default
queryNode.mmap.scalarField	Menentukan apakah akan memetakan data mentah dari semua bidang skalar ke dalam memori. Mengatur ini ke true akan membuat Milvus memetakan data mentah dari data bidang skalar koleksi ke dalam memori, alih-alih memuatnya secara penuh saat menerima permintaan muat terhadap koleksi ini.	false
queryNode.mmap.scalarIndex	Menentukan apakah akan memetakan semua indeks bidang skalar ke dalam memori. Mengatur ini ke true membuat Milvus memetakan indeks bidang skalar dari sebuah koleksi ke dalam memori alih-alih memuatnya secara penuh saat menerima permintaan pemuatan terhadap koleksi ini. Saat ini, hanya bidang skalar yang menggunakan tipe indeks berikut yang didukung: INVERTED	false
queryNode.mmap.vectorField	Menentukan apakah akan memetakan data mentah dari semua bidang vektor ke dalam memori. Mengatur ini ke true akan membuat Milvus memetakan data mentah dari data bidang vektor koleksi ke dalam memori, alih-alih memuatnya secara penuh saat menerima permintaan muat terhadap koleksi ini.	false
queryNode.mmap.vectorIndex	Menentukan apakah akan memetakan semua indeks bidang vektor ke dalam memori. Mengatur ini ke true akan membuat Milvus memetakan indeks bidang vektor dari sebuah koleksi ke dalam memori alih-alih memuatnya secara penuh saat menerima permintaan pemuatan terhadap koleksi ini. Saat ini, hanya bidang vektor yang menggunakan jenis indeks berikut yang didukung: FLAT IVF_FLAT IVF_SQ8 IVF_PQ BIN_FLAT BIN_IVF_FLAT HNSW SCANN INDEKS_TERBALIK_JARANG SPARSE_WAND	false
queryNode.mmap.mmapDirPath	Menentukan jalur ke file yang dipetakan dalam memori. Nilai default berlaku jika tidak ditentukan. Penampung localStorage.path pada nilai default menunjukkan hard drive Milvus QueryNodes. Pastikan bahwa QueryNodes Anda memiliki hard drive berkinerja tinggi untuk mendapatkan keuntungan mmap yang optimal.	{localStorage.path}/mmap

Untuk menerapkan pengaturan di atas pada cluster Milvus Anda, silakan ikuti langkah-langkah di Konfigurasi Milvus dengan Helm dan Konfigurasi Milvus dengan Operator Milvus.

Terkadang, pengaturan mmap global tidak fleksibel ketika menghadapi kasus penggunaan tertentu. Untuk menerapkan pengaturan alternatif pada koleksi tertentu atau indeksnya, pertimbangkan untuk mengonfigurasi mmap khusus untuk koleksi, bidang, atau indeks. Anda harus melepaskan dan memuat koleksi sebelum perubahan pada pengaturan mmap diterapkan.

Pengaturan mmap khusus bidang

Untuk mengonfigurasi mmap khusus bidang, Anda perlu menyertakan parameter mmap_enabled saat menambahkan bidang. Anda dapat mengaktifkan mmap pada bidang khusus ini dengan mengatur parameter ini ke True.

Contoh berikut ini menunjukkan cara mengonfigurasi mmap khusus bidang ketika Anda menambahkan bidang.

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
    }
}'

Kemudian, Anda dapat membuat koleksi menggunakan skema yang telah dibuat di atas. Setelah menerima permintaan untuk memuat koleksi, Milvus menggunakan memori-memetakan data mentah dari bidang doc_chunk ke dalam memori.

Pengaturan mmap khusus indeks

Untuk mengonfigurasi mmap khusus indeks, Anda harus menyertakan properti mmap.enable dalam parameter indeks ketika Anda menambahkan indeks. Anda dapat mengaktifkan mmap pada indeks khusus ini dengan mengatur properti ke true.

Contoh berikut ini mendemonstrasikan cara mengonfigurasi mmap khusus indeks ketika Anda menambahkan indeks.

# 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
    }
}'

Kemudian Anda dapat mereferensikan parameter indeks di dalam koleksi. Setelah menerima permintaan untuk memuat koleksi, Milvus memetakan indeks bidang judul ke dalam memori.

Pengaturan mmap khusus koleksi

Untuk mengonfigurasi strategi mmap seluruh koleksi, Anda harus menyertakan properti mmap.enabled dalam permintaan untuk membuat koleksi. Anda dapat mengaktifkan mmap untuk koleksi dengan mengatur properti ini ke true.

Contoh berikut ini menunjukkan cara mengaktifkan mmap dalam koleksi bernama my_collection pada saat pembuatannya. Setelah menerima permintaan untuk memuat koleksi, Milvus akan memetakan data mentah dari semua field ke dalam memori.

# 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\"
    }
}"

Anda juga dapat mengubah pengaturan mmap dari koleksi yang sudah ada.

# 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"
}'

Anda perlu melepaskan koleksi untuk membuat perubahan pada propertinya dan memuat ulang koleksi untuk membuat perubahan berlaku.