2.6版本RaBitQ索引性能测试结论与官网不符， 2.6 查询性能相比2.4下降很多

[lengdanlexin]

Milvus 版本 2.6.9
部署方式： Helm, https://github.com/zilliztech/milvus-helm/tree/milvus-5.0.11

部署参数：

helm  upgrade --install \
  milvus-cluster  milvus  -n milvus-cluster \
  --create-namespace \
  --set queryNode.resources.requests.cpu=100m \
  --set queryNode.resources.requests.memory=100Mi \
  --set queryNode.replicas=1 \
  --set queryNode.resources.limits.cpu=4 \
  --set queryNode.resources.limits.memory=12Gi \
  \
  --set dataNode.resources.requests.cpu=100m \
  --set dataNode.resources.requests.memory=100Mi \
  --set dataNode.replicas=1 \
  --set dataNode.resources.limits.memory=6Gi \
  \
  --set mixCoordinator.resources.requests.cpu=100m \
  --set mixCoordinator.resources.requests.memory=100Mi \
  --set mixCoordinator.replicas=1 \
  --set mixCoordinator.resources.limits.memory=6Gi \
  \
  --set proxy.resources.requests.cpu=100m \
  --set proxy.resources.requests.memory=100Mi \
  --set proxy.replicas=1 \
  --set proxy.resources.limits.memory=6Gi \
  \
  --set externalS3.accessKey=root \
  --set externalS3.secretKey=minio \
  --set externalS3.host=milvus-cluster-minio.minio.svc.cluster.local \
  --set externalS3.port=9000 \
  --set externalS3.bucketName="milvus-bucket" \
  --set externalS3.rootPath="file" \
  --set externalS3.enabled=true \
  \
  --set externalEtcd.endpoints[0]=etcd-instance-headless.etcd.svc.cluster.local:2379 \
  --set externalEtcd.enabled=true \
  \
  --set externalEtcd.enabled=true \
  --set minio.enabled=false   \
  --set etcd.enabled=false     \
  --set image.all.tag=v2.6.9 \
  --set pulsarv3.enabled=false \
  --set woodpecker.enabled=true \
  --set streaming.enabled=true \
  --set indexNode.enabled=false \
  --set attu.enabled=true

vectordbbench使用多进程不方便测试性能，所以我又用ai编写了一个go的程序

qps测试程序

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"math"
	"math/rand"
	"os"
	"sort"
	"strings"
	"sync"
	"sync/atomic"
	"time"

	"github.com/milvus-io/milvus/client/v2/entity"
	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

type BenchmarkConfig struct {
	MilvusAddr       string
	CollectionName   string
	VectorFieldName  string
	TopK             int
	Nq               int // 每次查询的向量数（批量查询）
	ConcNumList      []int
	TestDuration     time.Duration // 每个并发数的测试持续时间
	WarmupDuration   time.Duration // 预热时间
	VectorDim        int
	SearchEf         int           // HNSW 索引的 ef 参数
	UseRandomVector  bool          // 是否使用随机向量（更接近真实场景，推荐 true）
	NormalizeVector  bool          // 是否归一化向量（某些距离度量需要）
	SearchTimeout    time.Duration // 单次搜索超时时间
	ConsistencyLevel string        // 一致性级别: Strong, Bounded, Session, Eventually
	MetricType       string        // 距离度量类型: COSINE, L2, IP
	OutputFields     []string      // 需要返回的字段（为空则只返回 ID 和 score）
	SkipSerialTest   bool          // 是否跳过单独的串行测试（如果并发列表不包含1）
	StageInterval    time.Duration // 每个并发阶段之间的间隔时间

	// 索引类型和搜索参数
	IndexType    string            // 索引类型：HNSW, IVF_FLAT, IVF_SQ8, IVF_PQ, SCANN 等
	SearchParams map[string]string // 搜索参数，根据索引类型不同而不同
}

// JSON 配置文件结构
type ConfigFile struct {
	MilvusAddr            string            `json:"milvus_addr"`
	CollectionName        string            `json:"collection_name"`
	VectorFieldName       string            `json:"vector_field_name"`
	VectorDim             int               `json:"vector_dim"`
	TopK                  int               `json:"top_k"`
	Nq                    int               `json:"nq"`
	SearchEf              int               `json:"search_ef"`
	ConcNumList           []int             `json:"conc_num_list"`
	TestDurationSeconds   int               `json:"test_duration_seconds"`
	WarmupDurationSeconds int               `json:"warmup_duration_seconds"`
	SearchTimeoutSeconds  int               `json:"search_timeout_seconds"`
	UseRandomVector       bool              `json:"use_random_vector"`
	NormalizeVector       bool              `json:"normalize_vector"`
	ConsistencyLevel      string            `json:"consistency_level"`
	MetricType            string            `json:"metric_type"`
	OutputFields          []string          `json:"output_fields"`
	SkipSerialTest        bool              `json:"skip_serial_test"`
	StageIntervalSeconds  int               `json:"stage_interval_seconds"`
	IndexType             string            `json:"index_type"`
	SearchParams          map[string]string `json:"search_params"`
}

// 从配置文件加载配置
func loadConfigFromFile(filename string) (BenchmarkConfig, error) {
	data, err := os.ReadFile(filename)
	if err != nil {
		return BenchmarkConfig{}, err
	}

	var cf ConfigFile
	if err := json.Unmarshal(data, &cf); err != nil {
		return BenchmarkConfig{}, err
	}

	// 设置默认值
	if cf.Nq == 0 {
		cf.Nq = 1
	}
	if cf.SearchTimeoutSeconds == 0 {
		cf.SearchTimeoutSeconds = 5
	}
	if cf.ConsistencyLevel == "" {
		cf.ConsistencyLevel = "Bounded" // 默认使用 Bounded 一致性
	}
	if cf.MetricType == "" {
		cf.MetricType = "COSINE" // 默认使用 COSINE（根据你的 collection）
	}
	if cf.StageIntervalSeconds == 0 {
		cf.StageIntervalSeconds = 5 // 默认间隔 5 秒
	}

	config := BenchmarkConfig{
		MilvusAddr:       cf.MilvusAddr,
		CollectionName:   cf.CollectionName,
		VectorFieldName:  cf.VectorFieldName,
		TopK:             cf.TopK,
		Nq:               cf.Nq,
		ConcNumList:      cf.ConcNumList,
		TestDuration:     time.Duration(cf.TestDurationSeconds) * time.Second,
		WarmupDuration:   time.Duration(cf.WarmupDurationSeconds) * time.Second,
		SearchTimeout:    time.Duration(cf.SearchTimeoutSeconds) * time.Second,
		StageInterval:    time.Duration(cf.StageIntervalSeconds) * time.Second,
		VectorDim:        cf.VectorDim,
		SearchEf:         cf.SearchEf,
		UseRandomVector:  cf.UseRandomVector,
		NormalizeVector:  cf.NormalizeVector,
		ConsistencyLevel: cf.ConsistencyLevel,
		MetricType:       cf.MetricType,
		OutputFields:     cf.OutputFields,
		SkipSerialTest:   cf.SkipSerialTest,
		IndexType:        cf.IndexType,
		SearchParams:     cf.SearchParams,
	}

	// 验证配置
	if err := validateConfig(config); err != nil {
		return BenchmarkConfig{}, fmt.Errorf("配置验证失败: %v", err)
	}

	return config, nil
}

// 验证配置参数
func validateConfig(config BenchmarkConfig) error {
	// 验证 TopK 范围
	if config.TopK < 1 || config.TopK > 16384 {
		return fmt.Errorf("TopK 必须在 [1, 16384] 范围内，当前值: %d", config.TopK)
	}

	// 验证 Nq 范围
	if config.Nq < 1 || config.Nq > 16384 {
		return fmt.Errorf("Nq 必须在 [1, 16384] 范围内，当前值: %d", config.Nq)
	}

	// 验证向量维度
	if config.VectorDim < 1 || config.VectorDim > 32768 {
		return fmt.Errorf("向量维度必须在 [1, 32768] 范围内，当前值: %d", config.VectorDim)
	}

	// 验证 HNSW 索引的 ef 参数
	if strings.ToUpper(config.IndexType) == "HNSW" {
		// 从 search_params 中检查 ef
		if efStr, ok := config.SearchParams["ef"]; ok {
			var ef int
			if _, err := fmt.Sscanf(efStr, "%d", &ef); err == nil {
				if ef < config.TopK {
					return fmt.Errorf("HNSW 索引的 ef 参数必须 >= TopK，当前 ef=%d, TopK=%d", ef, config.TopK)
				}
			}
		} else if config.SearchEf > 0 && config.SearchEf < config.TopK {
			return fmt.Errorf("HNSW 索引的 ef 参数必须 >= TopK，当前 ef=%d, TopK=%d", config.SearchEf, config.TopK)
		}
	}

	// 验证一致性级别
	validLevels := map[string]bool{
		"Strong": true, "Bounded": true, "Session": true, "Eventually": true,
		"STRONG": true, "BOUNDED": true, "SESSION": true, "EVENTUALLY": true,
	}
	if !validLevels[config.ConsistencyLevel] {
		return fmt.Errorf("无效的一致性级别: %s，有效值: Strong, Bounded, Session, Eventually", config.ConsistencyLevel)
	}

	// 验证 metric_type
	validMetrics := map[string]bool{
		"COSINE": true, "L2": true, "IP": true,
		"cosine": true, "l2": true, "ip": true,
	}
	if config.MetricType != "" && !validMetrics[config.MetricType] {
		return fmt.Errorf("无效的距离度量类型: %s，有效值: COSINE, L2, IP", config.MetricType)
	}

	// 验证 COSINE 度量时是否归一化
	if strings.ToUpper(config.MetricType) == "COSINE" && !config.NormalizeVector {
		log.Printf("警告: 使用 COSINE 度量但未启用向量归一化，建议设置 normalize_vector=true")
	}

	// 验证并发数列表
	if len(config.ConcNumList) == 0 {
		return fmt.Errorf("并发数列表不能为空")
	}
	for _, conc := range config.ConcNumList {
		if conc < 1 {
			return fmt.Errorf("并发数必须 >= 1，当前值: %d", conc)
		}
	}

	return nil
}

// 随机数生成器池，避免锁竞争
var (
	seedCounter int64 // 用于生成唯一种子
	randPool    = sync.Pool{
		New: func() interface{} {
			// 使用原子计数器生成唯一种子，避免使用带锁的全局 rand.Int()
			seed := time.Now().UnixNano() + atomic.AddInt64(&seedCounter, 1)
			return rand.New(rand.NewSource(seed))
		},
	}
)

type LatencyStats struct {
	Latencies    []float64
	maxSize      int // 限制最大样本数，避免内存无限增长
	ErrorCount   int64
	TimeoutCount int64 // 超时错误计数
	SuccessCount int64
	mu           sync.Mutex
}

func (ls *LatencyStats) Add(latency float64) {
	ls.mu.Lock()
	defer ls.mu.Unlock()

	// 限制样本数量，避免内存无限增长
	if len(ls.Latencies) < ls.maxSize {
		ls.Latencies = append(ls.Latencies, latency)
	} else {
		// 使用水塘抽样算法随机替换
		idx := rand.Intn(int(atomic.LoadInt64(&ls.SuccessCount)))
		if idx < ls.maxSize {
			ls.Latencies[idx] = latency
		}
	}
}

func (ls *LatencyStats) GetPercentile(p float64) float64 {
	ls.mu.Lock()
	defer ls.mu.Unlock()

	if len(ls.Latencies) == 0 {
		return 0
	}

	sorted := make([]float64, len(ls.Latencies))
	copy(sorted, ls.Latencies)
	sort.Float64s(sorted)

	index := int(math.Ceil(float64(len(sorted)) * p / 100.0))
	if index >= len(sorted) {
		index = len(sorted) - 1
	}
	return sorted[index]
}

func (ls *LatencyStats) GetAvg() float64 {
	ls.mu.Lock()
	defer ls.mu.Unlock()

	if len(ls.Latencies) == 0 {
		return 0
	}

	sum := 0.0
	for _, l := range ls.Latencies {
		sum += l
	}
	return sum / float64(len(ls.Latencies))
}

func (ls *LatencyStats) GetErrorRate() float64 {
	total := ls.ErrorCount + ls.SuccessCount
	if total == 0 {
		return 0
	}
	return float64(ls.ErrorCount) / float64(total)
}

type BenchmarkResult struct {
	RunID        string                   `json:"run_id"`
	TaskLabel    string                   `json:"task_label"`
	TestConfig   TestConfig               `json:"test_config"`
	Metrics      Metrics                  `json:"metrics"`
	StageResults []ConcurrencyStageResult `json:"stage_results"` // 每个并发阶段的详细结果
}

type TestConfig struct {
	MilvusAddr      string    `json:"milvus_addr"`
	CollectionName  string    `json:"collection_name"`
	VectorFieldName string    `json:"vector_field_name"`
	VectorDim       int       `json:"vector_dim"`
	TopK            int       `json:"top_k"`
	SearchEf        int       `json:"search_ef"`
	TestDuration    string    `json:"test_duration"`
	WarmupDuration  string    `json:"warmup_duration"`
	UseRandomVector bool      `json:"use_random_vector"`
	NormalizeVector bool      `json:"normalize_vector"`
	TestTime        time.Time `json:"test_time"`
}

type Metrics struct {
	MaxLoadCount       int       `json:"max_load_count"`
	InsertDuration     float64   `json:"insert_duration"`
	OptimizeDuration   float64   `json:"optimize_duration"`
	LoadDuration       float64   `json:"load_duration"`
	QPS                float64   `json:"qps"`
	SerialLatencyP99   float64   `json:"serial_latency_p99"`
	SerialLatencyP95   float64   `json:"serial_latency_p95"`
	ConcNumList        []int     `json:"conc_num_list"`
	ConcQPSList        []float64 `json:"conc_qps_list"`
	ConcLatencyP99List []float64 `json:"conc_latency_p99_list"`
	ConcLatencyP95List []float64 `json:"conc_latency_p95_list"`
	ConcLatencyAvgList []float64 `json:"conc_latency_avg_list"`
	ConcLatencyP50List []float64 `json:"conc_latency_p50_list"` // 中位数延迟
	ConcErrorRateList  []float64 `json:"conc_error_rate_list"`  // 错误率
	ConcTotalQueryList []int64   `json:"conc_total_query_list"` // 总查询数
	OptimalConcurrency int       `json:"optimal_concurrency"`   // 最优并发数
}

type ConcurrencyStageResult struct {
	Concurrency  int     `json:"concurrency"`
	QPS          float64 `json:"qps"`
	LatencyP99   float64 `json:"latency_p99"`
	LatencyP95   float64 `json:"latency_p95"`
	LatencyP50   float64 `json:"latency_p50"`
	LatencyAvg   float64 `json:"latency_avg"`
	ErrorRate    float64 `json:"error_rate"`
	TimeoutRate  float64 `json:"timeout_rate"` // 超时错误率
	TotalQueries int64   `json:"total_queries"`
	SuccessCount int64   `json:"success_count"`
	ErrorCount   int64   `json:"error_count"`
	TimeoutCount int64   `json:"timeout_count"` // 超时错误数
}

func main() {
	var config BenchmarkConfig
	var err error

	// 尝试从配置文件加载
	if _, err := os.Stat("config.json"); err == nil {
		config, err = loadConfigFromFile("config.json")
		if err != nil {
			log.Printf("警告: 无法加载配置文件 config.json: %v，使用默认配置\n", err)
			config = getDefaultConfig()
		} else {
			fmt.Println("✓ 已从 config.json 加载配置")
		}
	} else {
		fmt.Println("未找到 config.json，使用默认配置")
		config = getDefaultConfig()
	}

	fmt.Println("\n=== Milvus 性能测试开始 ===")
	fmt.Printf("Milvus 地址: %s\n", config.MilvusAddr)
	fmt.Printf("Collection: %s\n", config.CollectionName)
	fmt.Printf("向量维度: %d, TopK: %d, Nq: %d\n", config.VectorDim, config.TopK, config.Nq)
	fmt.Printf("索引类型: %s, 距离度量: %s\n", config.IndexType, config.MetricType)
	fmt.Printf("一致性级别: %s, 搜索超时: %v\n", config.ConsistencyLevel, config.SearchTimeout)
	fmt.Printf("并发数列表: %v\n", config.ConcNumList)
	fmt.Printf("每阶段测试时长: %v, 预热时长: %v\n", config.TestDuration, config.WarmupDuration)
	fmt.Printf("随机向量: %v, 归一化: %v\n\n", config.UseRandomVector, config.NormalizeVector)

	result := runBenchmark(config)

	// 输出 JSON 结果
	fmt.Println("\n=== JSON 格式结果 ===")
	jsonData, err := json.MarshalIndent(result, "", "  ")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(jsonData))

	// 创建 results 目录
	resultsDir := "results"
	if _, err := os.Stat(resultsDir); os.IsNotExist(err) {
		err := os.Mkdir(resultsDir, 0755)
		if err != nil {
			log.Printf("警告: 无法创建 results 目录: %v", err)
			resultsDir = "." // 如果创建失败，保存到当前目录
		}
	}

	// 保存到文件
	timestamp := time.Now().Format("20060102_150405")
	filename := fmt.Sprintf("%s/benchmark_%s_%s.json", resultsDir, config.CollectionName, timestamp)
	err = os.WriteFile(filename, jsonData, 0644)
	if err != nil {
		log.Printf("警告: 无法保存 JSON 文件: %v", err)
	} else {
		fmt.Printf("\n✓ 结果已保存到: %s\n", filename)
	}

	// 生成简化的 CSV 报告
	generateCSVReport(result, filename, resultsDir)
}

// 获取默认配置（根据你的 VDBBench collection）
func getDefaultConfig() BenchmarkConfig {
	return BenchmarkConfig{
		MilvusAddr:       "10.72.9.83:30767", // Milvus 地址
		CollectionName:   "VDBBench",         // Collection 名称
		VectorFieldName:  "vector",           // 向量字段名称
		TopK:             10,                 // 每个查询向量返回 Top K 个最相似结果
		Nq:               1,                  // 每次请求查询的向量数（1=单个查询，推荐用于性能测试）
		ConcNumList:      []int{1, 5, 10, 20, 30, 40, 60, 80},
		TestDuration:     30 * time.Second, // 每个并发数测试 30 秒
		WarmupDuration:   10 * time.Second, // 预热 10 秒
		SearchTimeout:    5 * time.Second,  // 单次搜索超时 5 秒
		VectorDim:        1024,             // 向量维度（根据你的 collection）
		SearchEf:         100,              // HNSW 索引的 ef 参数
		UseRandomVector:  true,             // 推荐 true：随机向量更接近真实搜索场景
		NormalizeVector:  true,             // 你的索引使用 COSINE 度量，推荐 true
		ConsistencyLevel: "Bounded",        // 一致性级别
		MetricType:       "COSINE",         // 距离度量类型
		OutputFields:     []string{},       // 只返回 ID 和 score，减少数据传输
		SkipSerialTest:   false,            // 不跳过串行测试
		StageInterval:    5 * time.Second,  // 每个并发阶段之间间隔 5 秒
		IndexType:        "HNSW",           // 索引类型
		SearchParams: map[string]string{
			"ef": "100", // HNSW 搜索参数
		},
	}
}

func runBenchmark(config BenchmarkConfig) BenchmarkResult {
	ctx := context.Background()

	// 连接 Milvus
	fmt.Println("正在连接 Milvus...")
	c, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: config.MilvusAddr,
	})
	if err != nil {
		log.Fatal("连接 Milvus 失败:", err)
	}
	defer c.Close(ctx)
	fmt.Println("✓ 已连接到 Milvus")

	// 检查 collection 是否存在
	fmt.Printf("正在检查 Collection '%s'...\n", config.CollectionName)
	has, err := c.HasCollection(ctx, milvusclient.NewHasCollectionOption(config.CollectionName))
	if err != nil {
		log.Fatalf("检查 Collection 失败: %v", err)
	}
	if !has {
		log.Fatalf("Collection '%s' 不存在", config.CollectionName)
	}
	fmt.Printf("✓ Collection '%s' 存在\n", config.CollectionName)

	result := BenchmarkResult{
		RunID:     fmt.Sprintf("%x", time.Now().UnixNano()),
		TaskLabel: time.Now().Format("2006010215"),
		TestConfig: TestConfig{
			MilvusAddr:      config.MilvusAddr,
			CollectionName:  config.CollectionName,
			VectorFieldName: config.VectorFieldName,
			VectorDim:       config.VectorDim,
			TopK:            config.TopK,
			SearchEf:        config.SearchEf,
			TestDuration:    config.TestDuration.String(),
			WarmupDuration:  config.WarmupDuration.String(),
			UseRandomVector: config.UseRandomVector,
			NormalizeVector: config.NormalizeVector,
			TestTime:        time.Now(),
		},
		Metrics: Metrics{
			ConcNumList:        config.ConcNumList,
			ConcQPSList:        make([]float64, len(config.ConcNumList)),
			ConcLatencyP99List: make([]float64, len(config.ConcNumList)),
			ConcLatencyP95List: make([]float64, len(config.ConcNumList)),
			ConcLatencyP50List: make([]float64, len(config.ConcNumList)),
			ConcLatencyAvgList: make([]float64, len(config.ConcNumList)),
			ConcErrorRateList:  make([]float64, len(config.ConcNumList)),
			ConcTotalQueryList: make([]int64, len(config.ConcNumList)),
		},
		StageResults: make([]ConcurrencyStageResult, 0),
	}

	// 预热阶段
	if config.WarmupDuration > 0 {
		fmt.Printf("\n预热阶段 (%v)...\n", config.WarmupDuration)
		warmup(c, config)
		fmt.Println("✓ 预热完成")
	}

	// 串行测试 (并发数为1) - 用于获取基准延迟
	// 如果并发列表中已经包含 1，则跳过单独的串行测试
	skipSerialTest := config.SkipSerialTest
	if !skipSerialTest {
		for _, conc := range config.ConcNumList {
			if conc == 1 {
				skipSerialTest = true
				break
			}
		}
	}

	if !skipSerialTest {
		fmt.Println("\n开始串行测试（并发=1，获取基准延迟）...")
		serialStats := testConcurrency(c, config, 1)
		result.Metrics.SerialLatencyP99 = serialStats.GetPercentile(99)
		result.Metrics.SerialLatencyP95 = serialStats.GetPercentile(95)
		fmt.Printf("✓ 串行测试完成 - P99: %.4fs, P95: %.4fs\n",
			serialStats.GetPercentile(99), serialStats.GetPercentile(95))
	} else {
		if config.SkipSerialTest {
			fmt.Println("\n跳过串行测试（配置中设置 skip_serial_test=true）")
		} else {
			fmt.Println("\n跳过单独的串行测试（并发列表中已包含 1）")
		}
	}

	// 并发测试
	fmt.Println("\n=== 并发性能测试 ===")
	fmt.Printf("%-12s %-12s %-12s %-12s %-12s %-12s %-12s %-12s\n",
		"并发数", "QPS", "P99(s)", "P95(s)", "P50(s)", "Avg(s)", "错误率", "超时率")
	fmt.Println(strings.Repeat("-", 96))

	maxQPS := 0.0
	optimalConc := 1
	for i, concNum := range config.ConcNumList {
		// 在每个并发阶段之间添加间隔（第一个阶段除外）
		if i > 0 && config.StageInterval > 0 {
			fmt.Printf("\n⏸  等待 %v 后开始下一个并发测试...\n", config.StageInterval)
			time.Sleep(config.StageInterval)
		}

		stats := testConcurrency(c, config, concNum)

		qps := float64(stats.SuccessCount) / config.TestDuration.Seconds()
		errorRate := stats.GetErrorRate()
		timeoutRate := float64(stats.TimeoutCount) / float64(stats.SuccessCount+stats.ErrorCount)
		p99 := stats.GetPercentile(99)
		p95 := stats.GetPercentile(95)
		p50 := stats.GetPercentile(50)
		avg := stats.GetAvg()

		// 记录到 Metrics
		result.Metrics.ConcQPSList[i] = qps
		result.Metrics.ConcLatencyP99List[i] = p99
		result.Metrics.ConcLatencyP95List[i] = p95
		result.Metrics.ConcLatencyP50List[i] = p50
		result.Metrics.ConcLatencyAvgList[i] = avg
		result.Metrics.ConcErrorRateList[i] = errorRate
		result.Metrics.ConcTotalQueryList[i] = stats.SuccessCount + stats.ErrorCount

		// 记录详细的阶段结果
		stageResult := ConcurrencyStageResult{
			Concurrency:  concNum,
			QPS:          qps,
			LatencyP99:   p99,
			LatencyP95:   p95,
			LatencyP50:   p50,
			LatencyAvg:   avg,
			ErrorRate:    errorRate,
			TimeoutRate:  timeoutRate,
			TotalQueries: stats.SuccessCount + stats.ErrorCount,
			SuccessCount: stats.SuccessCount,
			ErrorCount:   stats.ErrorCount,
			TimeoutCount: stats.TimeoutCount,
		}
		result.StageResults = append(result.StageResults, stageResult)

		if qps > maxQPS {
			maxQPS = qps
			optimalConc = concNum
		}

		// 打印表格行
		fmt.Printf("%-12d %-12.2f %-12.4f %-12.4f %-12.4f %-12.4f %-12.2f%% %-12.2f%%\n",
			concNum, qps, p99, p95, p50, avg, errorRate*100, timeoutRate*100)
	}

	fmt.Println(strings.Repeat("-", 96))
	result.Metrics.QPS = maxQPS
	result.Metrics.OptimalConcurrency = optimalConc
	fmt.Printf("\n最优并发数: %d, 最大 QPS: %.2f\n", optimalConc, maxQPS)

	return result
}

func warmup(c *milvusclient.Client, config BenchmarkConfig) {
	// 使用 channel 来控制预热时间
	stopChan := make(chan struct{})

	// 启动定时器，到时间后关闭 channel
	timer := time.AfterFunc(config.WarmupDuration, func() {
		close(stopChan)
	})
	defer timer.Stop()

	warmupCount := 0
	maxWarmup := 100 // 限制预热查询数量，避免过度压力

	for warmupCount < maxWarmup {
		// 检查是否应该停止
		select {
		case <-stopChan:
			fmt.Printf("\r预热完成: %d/%d 次查询\n", warmupCount, maxWarmup)
			return
		default:
		}

		// 生成查询向量（支持批量查询）
		queryVectors := make([]entity.Vector, config.Nq)
		for j := 0; j < config.Nq; j++ {
			var queryVector []float32
			if config.UseRandomVector {
				queryVector = generateRandomVectorFast(config.VectorDim, config.NormalizeVector)
			} else {
				queryVector = generateSequentialVector(config.VectorDim)
			}
			queryVectors[j] = entity.FloatVector(queryVector)
		}

		// 创建搜索选项并设置参数
		searchOption := createSearchOption(config, queryVectors)

		// 执行搜索（使用独立的 context）
		searchCtx, searchCancel := context.WithTimeout(context.Background(), config.SearchTimeout)
		c.Search(searchCtx, searchOption)
		searchCancel()

		warmupCount++
		// 显示清晰的进度
		if warmupCount%5 == 0 || warmupCount == maxWarmup {
			fmt.Printf("\r预热进度: %d/%d (%.0f%%)", warmupCount, maxWarmup, float64(warmupCount)*100/float64(maxWarmup))
		}
		time.Sleep(100 * time.Millisecond) // 避免过于频繁
	}
	fmt.Printf("\r预热完成: %d/%d 次查询\n", warmupCount, maxWarmup)
}

func testConcurrency(c *milvusclient.Client, config BenchmarkConfig, concurrency int) *LatencyStats {
	stats := &LatencyStats{
		Latencies: make([]float64, 0, 10000), // 预分配容量
		maxSize:   10000,                     // 限制最大样本数
	}

	var wg sync.WaitGroup

	// 使用 channel 来控制测试时间，而不是 context
	stopChan := make(chan struct{})

	// 启动定时器，到时间后关闭 channel
	timer := time.AfterFunc(config.TestDuration, func() {
		close(stopChan)
	})
	defer timer.Stop()

	startTime := time.Now()

	// 实时 QPS 监控（每 5 秒显示一次）
	ticker := time.NewTicker(5 * time.Second)
	stopMonitor := make(chan bool)
	go func() {
		for {
			select {
			case <-ticker.C:
				elapsed := time.Since(startTime).Seconds()
				currentQPS := float64(atomic.LoadInt64(&stats.SuccessCount)) / elapsed
				fmt.Printf("\r  [并发=%d] 当前 QPS: %.2f, 已完成: %d 次查询, 用时: %.0fs",
					concurrency, currentQPS, atomic.LoadInt64(&stats.SuccessCount), elapsed)
			case <-stopMonitor:
				ticker.Stop()
				return
			}
		}
	}()

	// 启动并发 goroutine
	for i := 0; i < concurrency; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()

			for {
				// 检查是否应该停止发起新查询
				select {
				case <-stopChan:
					return
				default:
				}

				// 生成查询向量（支持批量查询）
				queryVectors := make([]entity.Vector, config.Nq)
				for j := 0; j < config.Nq; j++ {
					var queryVector []float32
					if config.UseRandomVector {
						queryVector = generateRandomVectorFast(config.VectorDim, config.NormalizeVector)
					} else {
						queryVector = generateSequentialVector(config.VectorDim)
					}
					queryVectors[j] = entity.FloatVector(queryVector)
				}

				// 创建搜索选项并设置参数
				searchOption := createSearchOption(config, queryVectors)

				// 执行查询并记录延迟（使用独立的 context，不受测试时间限制）
				searchCtx, searchCancel := context.WithTimeout(context.Background(), config.SearchTimeout)
				start := time.Now()
				_, err := c.Search(searchCtx, searchOption)
				latency := time.Since(start).Seconds()
				searchCancel()

				if err == nil {
					stats.Add(latency)
					atomic.AddInt64(&stats.SuccessCount, 1)
				} else {
					atomic.AddInt64(&stats.ErrorCount, 1)
					// 判断是否为超时错误
					if strings.Contains(err.Error(), "timeout") || strings.Contains(err.Error(), "deadline exceeded") {
						atomic.AddInt64(&stats.TimeoutCount, 1)
					}
					// 只打印前 10 个错误，避免日志泛滥
					if atomic.LoadInt64(&stats.ErrorCount) <= 10 {
						log.Printf("\n查询失败 (并发=%d): %v", concurrency, err)
					}
				}
			}
		}()
	}

	wg.Wait()
	stopMonitor <- true
	fmt.Printf("\r") // 清除实时监控行
	return stats
}

// 生成高质量的随机向量（使用独立的随机数生成器，避免锁竞争）
func generateRandomVectorFast(dim int, normalize bool) []float32 {
	// 从池中获取随机数生成器
	r := randPool.Get().(*rand.Rand)
	defer randPool.Put(r)

	vec := make([]float32, dim)

	if normalize {
		// 生成归一化向量（适用于余弦相似度）
		var sumSquare float64
		for j := 0; j < dim; j++ {
			val := r.NormFloat64() // 正态分布
			vec[j] = float32(val)
			sumSquare += val * val
		}
		// 归一化
		norm := math.Sqrt(sumSquare)
		if norm > 0 {
			for j := 0; j < dim; j++ {
				vec[j] /= float32(norm)
			}
		}
	} else {
		// 生成 [-1, 1] 范围的随机向量（适用于 L2 距离）
		for j := 0; j < dim; j++ {
			vec[j] = float32(r.Float64()*2 - 1)
		}
	}

	return vec
}

// 旧的随机向量生成（保留用于对比）
func generateRandomVector(dim int) []float32 {
	vec := make([]float32, dim)
	for j := 0; j < dim; j++ {
		// 生成 [-1, 1] 范围的随机数
		vec[j] = (float32(time.Now().UnixNano()%1000) / 500.0) - 1.0
	}
	return vec
}

func generateSequentialVector(dim int) []float32 {
	vec := make([]float32, dim)
	for j := 0; j < dim; j++ {
		vec[j] = float32(j) * 0.01
	}
	return vec
}

// 创建搜索选项并设置参数
func createSearchOption(config BenchmarkConfig, queryVectors []entity.Vector) milvusclient.SearchOption {
	// 创建基础搜索选项
	searchOption := milvusclient.NewSearchOption(
		config.CollectionName,
		config.TopK,
		queryVectors,
	).WithANNSField(config.VectorFieldName)

	// 设置一致性级别
	consistencyLevel := parseConsistencyLevel(config.ConsistencyLevel)
	searchOption = searchOption.WithConsistencyLevel(consistencyLevel)

	// 注意：metric_type 在创建索引时已经设置，搜索时会自动使用索引的 metric type
	// Milvus Go SDK 的 SearchOption 不支持 WithMetricType 方法

	// 设置输出字段（如果指定）
	if len(config.OutputFields) > 0 {
		searchOption = searchOption.WithOutputFields(config.OutputFields...)
	}

	// 优先使用配置文件中的 search_params
	if len(config.SearchParams) > 0 {
		// 如果配置文件中有搜索参数，直接使用
		for key, value := range config.SearchParams {
			searchOption = searchOption.WithSearchParam(key, value)
		}
	} else {
		// 如果配置文件中没有搜索参数，使用默认值（根据索引类型）
		switch strings.ToUpper(config.IndexType) {
		case "HNSW":
			// HNSW 索引参数
			if config.SearchEf > 0 {
				searchOption = searchOption.WithSearchParam("ef", fmt.Sprintf("%d", config.SearchEf))
			}

		case "IVF_FLAT", "IVF_SQ8", "IVF_PQ":
			// IVF 系列索引参数
			searchOption = searchOption.WithSearchParam("nprobe", "64")

		case "IVF_RABITQ":
			// IVF_RABITQ 索引参数
			// 注意：rbq_query_bits 通常应该是正整数（如 1, 2, 4, 8）
			// refine_k 是精炼因子，通常 >= 1.0
			searchOption = searchOption.WithSearchParam("nprobe", "64")
			searchOption = searchOption.WithSearchParam("rbq_query_bits", "8")
			searchOption = searchOption.WithSearchParam("refine_k", "1.0")

		case "SCANN":
			// SCANN 索引参数
			searchOption = searchOption.WithSearchParam("nprobe", "64")
			searchOption = searchOption.WithSearchParam("reorder_k", "100")

		case "FLAT":
			// FLAT 索引不需要额外参数

		default:
			// 默认使用 HNSW 参数
			if config.SearchEf > 0 {
				searchOption = searchOption.WithSearchParam("ef", fmt.Sprintf("%d", config.SearchEf))
			}
		}
	}

	return searchOption
}

// 解析一致性级别字符串
func parseConsistencyLevel(level string) entity.ConsistencyLevel {
	switch strings.ToUpper(level) {
	case "STRONG":
		return entity.ClStrong
	case "BOUNDED":
		return entity.ClBounded
	case "SESSION":
		return entity.ClSession
	case "EVENTUALLY":
		return entity.ClEventually
	default:
		return entity.ClBounded // 默认使用 Bounded
	}
}

// 生成 CSV 格式的报告
func generateCSVReport(result BenchmarkResult, jsonFilename string, resultsDir string) {
	csvFilename := strings.Replace(jsonFilename, ".json", ".csv", 1)

	var sb strings.Builder
	sb.WriteString("并发数,QPS,P99延迟(s),P95延迟(s),P50延迟(s),平均延迟(s),错误率(%),超时率(%),总查询数,成功数,失败数,超时数\n")

	for _, stage := range result.StageResults {
		sb.WriteString(fmt.Sprintf("%d,%.2f,%.4f,%.4f,%.4f,%.4f,%.2f,%.2f,%d,%d,%d,%d\n",
			stage.Concurrency,
			stage.QPS,
			stage.LatencyP99,
			stage.LatencyP95,
			stage.LatencyP50,
			stage.LatencyAvg,
			stage.ErrorRate*100,
			stage.TimeoutRate*100,
			stage.TotalQueries,
			stage.SuccessCount,
			stage.ErrorCount,
			stage.TimeoutCount,
		))
	}

	err := os.WriteFile(csvFilename, []byte(sb.String()), 0644)
	if err != nil {
		log.Printf("警告: 无法保存 CSV 文件: %v", err)
	} else {
		fmt.Printf("✓ CSV 报告已保存到: %s\n", csvFilename)
	}
}

索引 QPS测试：

 replicas=1, cpu=4, k=1, "conc_num_list": [5,40,100,200,400,600,800,1000], "vector_dim": 1024,  100万数据（vectordbbench中的bioasq_medium_1m）

在一台16核， 64G内存的机器上测试， 压测工具在另一台12核机器测试（cpu利用率不超过百分之10）

每轮并发时间5分钟， 间隔1分钟， 预热30s， 测试过程中用grafana查看cpu和内存使用情况，querynode的cpu在并发超过40后触发上限， 其他服务均未达到瓶颈

HNSW
M=8, efConstruction=64, ef=100，"nq": 1, 
结论：
极限约为 1979 QPS。并发超过 200，P99 延迟飙升至 795ms

IVF_RABITQ
nlist=1024， nprobe=64， rbq_bits_query=0，
refine=True, refine_type=SQ8，refine_k=4, "nq": 1
结论：
极限约为 360 QPS，。并发超过 200，QPS 下降至 350，P99 延迟飙升至 4.6s，并出现 0.39% 错误率和超时

IVF_FLAT
nlist=1024， nprobe=64
结论：
极限约为 557 QPS，并发超过 200，QPS 开始下降至 532，P99 延迟飙升至 2.88s

如果结果不够详细我再放一个详细的
测试程序就是简单的统计规定时间内执行成功的请求，然后计算qps

按照官网 https://milvus.io/blog/bring-vector-compression-to-the-extreme-how-milvus-serves-3%C3%97-more-queries-with-rabitq.md 的结论， qps应该是ivf_rabitq高一些， 但是我测试出来的实际是IVF_FLAT更高， 能帮忙看下是我哪里没设置对么

2.4 和 2.6 qps 对比

另一个问题是我分别测试了 2.4.17 和 2.6.9 的 qps（12核，内存不限， 单实例， m=8, efConstruction=64, ef=100，k=1）

HNSW

2.6 :

并发数	QPS	P99延迟(s)	P95延迟(s)	P50延迟(s)	平均延迟(s)	错误率(%)	超时率(%)	总查询数	成功数	失败数	超时数
5	1117.96	0.0075	0.0058	0.0043	0.0045	0.00	0.00	335,388	335,388	0	0
40	3068.58	0.0306	0.0241	0.0117	0.0131	0.00	0.00	920,573	920,573	0	0
100	3725.71	0.0649	0.0507	0.0237	0.0267	0.00	0.00	1,117,714	1,117,714	0	0
200	4146.32	0.1094	0.0888	0.0463	0.0479	0.00	0.00	1,243,896	1,243,896	0	0
400	4600.15	0.1695	0.1336	0.0902	0.0869	0.00	0.00	1,380,044	1,380,044	0	0
600	4684.77	0.2490	0.2167	0.1250	0.1284	0.00	0.00	1,405,432	1,405,432	0	0
800	4831.82	0.3222	0.2736	0.1735	0.1667	0.00	0.00	1,449,546	1,449,546	0	0
1000	4837.89	0.4024	0.3369	0.2028	0.2066	0.00	0.00	1,451,366	1,451,366	0	0

2.4：

并发数	QPS	P99延迟(s)	P95延迟(s)	P50延迟(s)	平均延迟(s)	错误率(%)	超时率(%)	总查询数	成功数	失败数	超时数
5	1656.91	0.0049	0.0038	0.0029	0.0030	0	0	497,074	497,074	0	0
40	4727.78	0.0310	0.0237	0.0068	0.0084	0	0	1,418,333	1,418,333	0	0
100	5582.27	0.0506	0.0437	0.0142	0.0179	0	0	1,674,681	1,674,681	0	0
200	6092.06	0.0734	0.0637	0.0278	0.0329	0	0	1,827,617	1,827,617	0	0
400	6474.82	0.1096	0.0974	0.0662	0.0619	0	0	1,942,446	1,942,446	0	0
600	6604.80	0.1740	0.1515	0.0928	0.0907	0	0	1,981,440	1,981,440	0	0
800	6651.06	0.2193	0.1951	0.1146	0.1200	0	0	1,995,319	1,995,319	0	0
1000	6604.40	0.2949	0.2639	0.1471	0.1522	0	0	1,981,319	1,981,319	0	0

[foxspy]

Hi @lengdanlexin Thank you for the update. Could you please provide details regarding the test environment's architecture? Specifically, I am looking for the instruction set (x64 or ARM) and the CPU specifications. Thank you.

[lengdanlexin]

lscpu>>

架构：                           x86_64
CPU 运行模式：                   32-bit, 64-bit
字节序：                         Little Endian
Address sizes:                   46 bits physical, 48 bits virtual
CPU:                             22
在线 CPU 列表：                  0-21
每个核的线程数：                 1
每个座的核数：                   22
座：                             1
NUMA 节点：                      1
厂商 ID：                        GenuineIntel
CPU 系列：                       6
型号：                           60
型号名称：                       Intel Core Processor (Haswell, no TSX)
步进：                           1
CPU MHz：                        2893.198
BogoMIPS：                       5786.39
超管理器厂商：                   KVM
虚拟化类型：                     完全
L1d 缓存：                       704 KiB
L1i 缓存：                       704 KiB
L2 缓存：                        88 MiB

free -h
              total        used        free      shared  buff/cache   available
Mem:           97Gi        10Gi        73Gi       4.1Gi        13Gi        82Gi
Swap:            0B          0B          0B

Thanks for your help. Please let me know if you need any further information.

I am using a 3-node cluster, and each node has the same configuration.

[foxspy]

lscpu>>

架构：                           x86_64
CPU 运行模式：                   32-bit, 64-bit
字节序：                         Little Endian
Address sizes:                   46 bits physical, 48 bits virtual
CPU:                             22
在线 CPU 列表：                  0-21
每个核的线程数：                 1
每个座的核数：                   22
座：                             1
NUMA 节点：                      1
厂商 ID：                        GenuineIntel
CPU 系列：                       6
型号：                           60
型号名称：                       Intel Core Processor (Haswell, no TSX)
步进：                           1
CPU MHz：                        2893.198
BogoMIPS：                       5786.39
超管理器厂商：                   KVM
虚拟化类型：                     完全
L1d 缓存：                       704 KiB
L1i 缓存：                       704 KiB
L2 缓存：                        88 MiB

free -h
              total        used        free      shared  buff/cache   available
Mem:           97Gi        10Gi        73Gi       4.1Gi        13Gi        82Gi
Swap:            0B          0B          0B

Thanks for your help. Please let me know if you need any further information.

I am using a 3-node cluster, and each node has the same configuration.

I have completed local testing using the provided scripts, and IVF_RABITQ performance definitely exceeds that of IVF_FLAT. Could you please verify that the index was built successfully? You might consider dropping the 'A' index and recreating 'B' to ensure the data distribution remains consistent, then confirming the index status.

[lengdanlexin]

https://milvus.io/blog/bring-vector-compression-to-the-extreme-how-milvus-serves-3%C3%97-more-queries-with-rabitq.md says it uses CPU acceleration, and since my CPU doesn't support it, is that why this is happening?

Also, is the query performance degradation a known issue? I noticed that others have raised similar concerns.
#45839

[foxspy]

https://milvus.io/blog/bring-vector-compression-to-the-extreme-how-milvus-serves-3%C3%97-more-queries-with-rabitq.md says it uses CPU acceleration, and since my CPU doesn't support it, is that why this is happening?

collection

{
  "virtual_channel_names": [
    "by-dev-rootcoord-dml_0_464017061921163668v0"
  ],
  "physical_channel_names": [
    "by-dev-rootcoord-dml_0"
  ],
  "aliases": [],
  "start_positions": [],
  "properties": [
    {
      "key": "timezone",
      "value": "UTC"
    }
  ],
  "status": {
    "extra_info": {},
    "error_code": "Success",
    "reason": "",
    "code": 0,
    "retriable": false,
    "detail": ""
  },
  "schema": {
    "fields": [
      {
        "type_params": [],
        "index_params": [],
        "fieldID": "100",
        "name": "pk",
        "is_primary_key": true,
        "description": "",
        "data_type": "Int64",
        "autoID": false,
        "state": "FieldCreated",
        "element_type": "None",
        "default_value": null,
        "is_dynamic": false,
        "is_partition_key": false,
        "is_clustering_key": false,
        "nullable": false,
        "is_function_output": false,
        "dataType": 5
      },
      {
        "type_params": [],
        "index_params": [],
        "fieldID": "101",
        "name": "id",
        "is_primary_key": false,
        "description": "",
        "data_type": "Int64",
        "autoID": false,
        "state": "FieldCreated",
        "element_type": "None",
        "default_value": null,
        "is_dynamic": false,
        "is_partition_key": false,
        "is_clustering_key": false,
        "nullable": false,
        "is_function_output": false,
        "dataType": 5
      },
      {
        "type_params": [
          {
            "key": "dim",
            "value": "1024"
          }
        ],
        "index_params": [],
        "fieldID": "102",
        "name": "vector",
        "is_primary_key": false,
        "description": "",
        "data_type": "FloatVector",
        "autoID": false,
        "state": "FieldCreated",
        "element_type": "None",
        "default_value": null,
        "is_dynamic": false,
        "is_partition_key": false,
        "is_clustering_key": false,
        "nullable": false,
        "is_function_output": false,
        "dataType": 101,
        "dim": "1024"
      }
    ],
    "properties": [
      {
        "key": "timezone",
        "value": "UTC"
      }
    ],
    "functions": [],
    "name": "VDBBench",
    "description": "",
    "autoID": false,
    "enable_dynamic_field": false,
    "dbName": ""
  },
  "collectionID": "464017061921163668",
  "created_timestamp": "464017135898722321",
  "created_utc_timestamp": "1770084899516",
  "shards_num": 1,
  "consistency_level": "Session",
  "collection_name": "VDBBench",
  "db_name": "default",
  "num_partitions": "1",
  "db_id": "0",
  "request_time": "0",
  "update_timestamp": "464017135898722321"
}

Also, is the query performance degradation a known issue? I noticed that others have raised similar concerns. #45839

Maybe. RabitQ is optimized for AVX-512 but not AVX （https://github.com/zilliztech/knowhere/blob/main/src/simd/distances_avx.cc#L1113）, so you might not see the perf gains on your setup.

[foxspy]

https://milvus.io/blog/bring-vector-compression-to-the-extreme-how-milvus-serves-3%C3%97-more-queries-with-rabitq.md says it uses CPU acceleration, and since my CPU doesn't support it, is that why this is happening?

collection

{
  "virtual_channel_names": [
    "by-dev-rootcoord-dml_0_464017061921163668v0"
  ],
  "physical_channel_names": [
    "by-dev-rootcoord-dml_0"
  ],
  "aliases": [],
  "start_positions": [],
  "properties": [
    {
      "key": "timezone",
      "value": "UTC"
    }
  ],
  "status": {
    "extra_info": {},
    "error_code": "Success",
    "reason": "",
    "code": 0,
    "retriable": false,
    "detail": ""
  },
  "schema": {
    "fields": [
      {
        "type_params": [],
        "index_params": [],
        "fieldID": "100",
        "name": "pk",
        "is_primary_key": true,
        "description": "",
        "data_type": "Int64",
        "autoID": false,
        "state": "FieldCreated",
        "element_type": "None",
        "default_value": null,
        "is_dynamic": false,
        "is_partition_key": false,
        "is_clustering_key": false,
        "nullable": false,
        "is_function_output": false,
        "dataType": 5
      },
      {
        "type_params": [],
        "index_params": [],
        "fieldID": "101",
        "name": "id",
        "is_primary_key": false,
        "description": "",
        "data_type": "Int64",
        "autoID": false,
        "state": "FieldCreated",
        "element_type": "None",
        "default_value": null,
        "is_dynamic": false,
        "is_partition_key": false,
        "is_clustering_key": false,
        "nullable": false,
        "is_function_output": false,
        "dataType": 5
      },
      {
        "type_params": [
          {
            "key": "dim",
            "value": "1024"
          }
        ],
        "index_params": [],
        "fieldID": "102",
        "name": "vector",
        "is_primary_key": false,
        "description": "",
        "data_type": "FloatVector",
        "autoID": false,
        "state": "FieldCreated",
        "element_type": "None",
        "default_value": null,
        "is_dynamic": false,
        "is_partition_key": false,
        "is_clustering_key": false,
        "nullable": false,
        "is_function_output": false,
        "dataType": 101,
        "dim": "1024"
      }
    ],
    "properties": [
      {
        "key": "timezone",
        "value": "UTC"
      }
    ],
    "functions": [],
    "name": "VDBBench",
    "description": "",
    "autoID": false,
    "enable_dynamic_field": false,
    "dbName": ""
  },
  "collectionID": "464017061921163668",
  "created_timestamp": "464017135898722321",
  "created_utc_timestamp": "1770084899516",
  "shards_num": 1,
  "consistency_level": "Session",
  "collection_name": "VDBBench",
  "db_name": "default",
  "num_partitions": "1",
  "db_id": "0",
  "request_time": "0",
  "update_timestamp": "464017135898722321"
}

Also, is the query performance degradation a known issue? I noticed that others have raised similar concerns. #45839

I will investigate the performance degradation. Given the significant gap between these two versions, identifying the cause should not be so straightforward. If performance is your primary priority, HNSWSQ might be a more suitable alternative.

[lengdanlexin]

Thank you. I will verify the information regarding RaBitQ once more. Thank you for your assistance.