
## 结论先行

本机（.NET 10.0.5 / Apple M4 / 10 核 / macOS arm64）上，10 万条 768 维 float 向量的暴力余弦检索，四个数字：

| 写法 | 每次查询耗时 | 相对手写标量 |
|---|---|---|
| 手写标量循环（dot + 两个模长） | 47.4 ms | 1.00x |
| `TensorPrimitives.CosineSimilarity` | 10.9 ms | 4.4x |
| `TensorPrimitives.Dot` + 预计算模长 | **7.0 ms** | **6.8x** |
| 同上 + 10 核 `Parallel.For` | 2.8 ms | 17x |

三条可以直接拿去用：

1. **别直接调 `CosineSimilarity`**。它每次调用都重算两行的模长，白读两遍内存；预存模长改调 `Dot`，快 1.56 倍。
2. **手写 SIMD 打不过 `TensorPrimitives`**。同样 768 维，手写 `Vector<float>` 单累加器 115 ns，四个累加器 99 ns，`TensorPrimitives.Dot` 66.6 ns——差在累加器展开，不在指令集。
3. **多核救不了暴力检索**。单线程 7.0 ms 已经跑到约 44 GB/s，10 核并行只提到 2.8 ms（2.5 倍），剩下的是内存带宽。

另外有个和性能无关但更贵的坑：拿到 10 万个分数后，`Array.Sort` 排序取 top-10 要 8.06 ms——**比检索本身还慢**。换定长插入是 0.03 ms。

## 环境与复现

```
OS   : macOS 26.7.1 / Arm64
NET  : 10.0.5  cores=10
SIMD : IsHardwareAccelerated=True  Vector<float>.Count=4
Data : 100,000 rows x 768 dim x 4B = 293 MiB
```

`Vector<float>.Count = 4`，即 ARM64 上走的是 128 位 NEON，不是 AVX-512 那种 16 lane。

项目文件只有一行关键的：

```xml
<PackageReference Include="System.Numerics.Tensors" Version="10.0.0" />
```

**第一个坑就在这里**：`System.Numerics.Tensors` 到 .NET 10 仍然不在默认引用集里，`using System.Numerics.Tensors;` 会直接编译失败（CS0234），必须显式装 NuGet 包。

数据用 xorshift32 生成均匀 `[-1,1)` 的 float。别用 `Random.NextBytes` 直接怼内存——随机比特会产生 Inf/NaN/denormal，我先踩了一遍，符号位随机导致模长算成 `∞`，所有相似度变成 `-0.000000`，top-1 全错。这种数据会让测量结果完全失真。

## 一、余弦相似度别直接调：预计算模长快 1.56 倍

`TensorPrimitives.CosineSimilarity(a, b)` 的语义很干净，代价是它每次都算 `dot / (|a| * |b|)`。做检索时 `|b|`（文档向量模长）是固定的，`|a|`（查询向量）查一次也就一个——十万行里你重算了十万次模长，等于把内存读三遍。

改成入库时存 `1/(|doc| * |query|)` 一个 float，查询时只算点积：

```csharp
// 入库时一次算好
_scale[r] = 1f / (_norms[r] * _queryNorm);

// 查询时只读一遍向量
float score = TensorPrimitives.Dot(_query, _flat.AsSpan(r * Dim, Dim)) * _scale[r];
```

| 写法 | 全量 10 万行 |
|---|---|
| `CosineSimilarity`（每行重算模长） | 10.9 ms |
| `Dot` + 预存 `1/(|doc||query|)` | 7.0 ms |

省下来的 3.9 ms 全是重复读内存。768 维 float 是 3072 字节，十万行 293 MiB——**这个规模下检索是内存带宽任务，不是算术任务**，任何多余的一遍遍历都按比例收费。

前提要说清楚：预计算要求文档向量入库后不再变。向量更新（重新 embedding）时必须同步更新模长，否则分数是错的，而且错得很安静——不会抛异常，只是排序变了。

## 二、手写 SIMD 打不过 BCL：累加器数量

同一行 768 维、常驻 L1、调用 20 万次，纯内核耗时：

| 实现 | ns/call |
|---|---|
| 标量循环 | 394.7 |
| `Vector<float>` 单累加器 | 115.0 |
| `Vector<float>` 4 累加器 | 99.2 |
| `TensorPrimitives.Dot` | **66.6** |
| `TensorPrimitives.CosineSimilarity` | 108.2 |

手写 SIMD 有 3.4 倍加速，这不意外。意外的是**四个累加器仍然比 `TensorPrimitives.Dot` 慢 1.5 倍**。

原因写起来很朴素。768 / 4 = 192 次向量加，单累加器时这 192 次是一条串行依赖链；NEON 的向量加法延迟约 3~4 个周期，192 × 4 ≈ 768 周期全在等，算力根本没用满。拆成四个独立累加器后链长降到 48，周期数跟着掉下来——实测 115 ns → 99 ns，方向和预期一致。

`TensorPrimitives.Dot` 再多出来的部分，是它内部的向量化路径按平台特化，展开深度和尾处理的写法不同。结论很实用：**768 维这个量级，直接调 BCL 就行，手写 SIMD 的收益已经小于维护成本**。要写，至少四个累加器起步。

顺带一个容易误读的数字：热行 394.7 ns 的标量版，放到 20,000 行扫描里变成 592 ns。同一份代码慢 50%，差的是内存——每次换一行就是一冷 3072 字节，L1 装不下。

## 三、10 万条 7ms，10 核只快 2.5 倍

单线程扫完 10 万行 7.0 ms，换算约 44 GB/s，这已经接近 M4 单核能吃到的内存带宽。10 核 `Parallel.For` 分块：

```
单线程 7.0 ms  ->  Parallel.For 2.53x  ->  2.8 ms
```

2.5 倍，不是 10 倍。293 MiB / 2.8 ms ≈ 110 GB/s，撞到的是整机内存带宽，不是核心数。

这条对架构选型的影响很直接：**在这个数据规模上，优化查询要减字节数，不是加线程**。想让检索更快，能动的只有三件事——向量量化（float → int8，带宽直接除以 4）、降维（768 → 256）、或者换 ANN 索引（HNSW 之类只碰一小部分数据）。给 `Parallel.For` 加线程属于第四件，收益封顶 2.5 倍。

顺便算一下 QPS：单线程 143 QPS，10 核 357 QPS。如果服务端要做真实并发，这个数字还得再打个折——并行检索之间会互相抢带宽。

## 四、比检索更贵的是排序

检索出来 10 万个 float，取 top-10：

| 写法 | 耗时 |
|---|---|
| `Array.Sort` 全量排序 | 8.06 ms |
| 定长数组插入（只留 10 个） | 0.03 ms |

240 倍。检索 7.0 ms + 排序 8.06 ms，等于排序吃掉了 53% 的总时间——**最慢的一步不是你以为的那步**。

定长插入的写法没有技巧，维护一个长度 10 的有序数组，比末位小就直接 `continue`：

```csharp
static void TopKInsertion(ReadOnlySpan<float> src, Span<float> best, Span<int> pos)
{
    best.Fill(float.MinValue);
    int filled = 0;
    for (int i = 0; i < src.Length; i++)
    {
        float v = src[i];
        if (filled == 10 && v <= best[9]) continue;   // 绝大多数在这里出局
        int j = Math.Min(filled, 9);
        while (j > 0 && best[j - 1] < v) { best[j] = best[j - 1]; pos[j] = pos[j - 1]; j--; }
        best[j] = v; pos[j] = i;
        if (filled < 10) filled++;
    }
}
```

复杂度是 O(n·K) 但 K 是常数 10，且内层循环几乎不执行——朴素写法赢在常数。

## 五、float[][] 还是 float[]：差在内存账单，不在速度

| 布局 | 检索耗时 | 托管堆 |
|---|---|---|
| 连续 `float[]` + `AsSpan(r*768, 768)` | 7.0 ms | 293 MiB |
| `float[][]`，每行一个数组 | 7.2 ms | 293 MiB + 3.1 MiB 对象头 |

速度差 2.9%，基本可以忽略——每行 3072 字节，远超缓存行，两种布局都是顺序流式读。真要付出的代价在内存和 GC：十万个小数组各带 24 字节头 + 8 字节引用，多 3.1 MiB 不算多，但 GC 要扫十万个对象，Gen0 次数会明显上升（我这次构建数据时 Gen0 已跑 41 次）。

向量库建议直接上连续 `float[]`：一次分配、`AsSpan` 切行、不产生任何每查询分配（实测 `alloc/MB = 0.00`）。

## 六、什么时候该放弃暴力检索

把上面的数字拉到 100 万行：单线程 70 ms，10 核 28 ms，QPS 掉到 35。这时候再谈优化就是浪费——直接上 ANN。

暴力扫描的甜点区是 **10 万行以内、768 维**：7 ms、零分配、结果精确、没有索引构建和删除维护的麻烦。超过这个量级，`TensorPrimitives` 加得再快也追不上 HNSW 只碰 1% 数据的事实。

一条判断线：如果 top-K 的召回要求是"必须精确"（比如去重、比对、风控），10 万以内暴力扫是最省事的方案；如果只是"差不多相关就行"（推荐、RAG 初筛），从第一天就该上 ANN，别等性能不行了再迁。

## 复现步骤

```bash
dotnet new console -o VectorLab && cd VectorLab
dotnet add package System.Numerics.Tensors --version 10.0.0
# 把本文的测量代码写进 Program.cs
dotnet run -c Release
```

跑之前有两件事必须做，否则数据不可信：

1. **预热**。每个方法先跑一遍再计时，否则第一轮带着 JIT 分层编译的开销。
2. **取多轮最小值**。我取 5 轮最小值，中位数一起看；macOS 上后台进程干扰很常见，平均值会被个别离群轮次拉偏。

还有一点：三个 bench（热行 / 2 万行 / 10 万行）必须分开测。热行数据全在 L1，测出来的是内核质量；10 万行测的是内存带宽。混在一起会把"内核快"和"带宽不够"两个完全不同的问题算成一个数。


本机（.NET 10.0.5  Apple M4  10 核 / macOS arm64）上，10 万条 768 维 float 向量的暴力余弦检索，四个数字：

TensorPrimitives 实测：10 万条 768 维向量检索 7ms 扫完，但 10 核并行只快 2.5 倍

人工智能

本机测试显示，10万条768维向量暴力余弦检索中，TensorPrimitives.Dot配合预计算模长比直接调用CosineSimilarity快1.56倍，比手写SIMD更优。10核并行仅提速2.5倍，受限于内存带宽。排序取top-10比检索更耗时，建议用定长插入替代Array.Sort。向量布局推荐连续float[]以减少GC压力。

代码解释

MacOS

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

本机测试显示，10万条768维向量暴力余弦检索中，TensorPrimitives.Dot配合预计算模长比直接调用CosineSimilarity快1.56倍，比手写SIMD更优。10核并行仅提速2.5倍，受限于内存带宽。排序取top-10比检索更耗时，建议用定长插入替代Array.Sort。向量布局推荐连续float...

TensorPrimitives 实测：10 万条 768 维向量检索 7ms 扫完，但 10 核并行只快 2.5 倍-腾讯云开发者社区-腾讯云

TensorPrimitives 实测：10 万条 768 维向量检索 7ms 扫完，但 10 核并行只快 2.5 倍

TensorPrimitives 实测：10 万条 768 维向量检索 7ms 扫完，但 10 核并行只快 2.5 倍

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐