C vs .NET 数组原地反转实测小数组 C 碾压大数组 .NET 反杀前几天看到一篇文章《将一个序列反序在C与C#下性能比较》链接大家可以自行搜索。作者对比了 C# 的“托管/非托管”实现和 C 的 std::reverse_copy最后得出的结论是在小数组1000 个元素下 C 远超 .NET而在大数据量下 .NET 非托管优于托管。文章的切入点挺有意思但作为老 .NET 开发者我看完代码后发现这个对比其实没有控制好变量C# 版本测试的是原地反转In-place reverse只做指针/索引交换不分配新内存而 C 版本用的是 std::reverse_copy 到一个新 vector 中包含了内存分配和数据拷贝。这俩的语义完全不对等底层的成本结构也完全不一样。拿“纯计算”去和“内存分配拷贝”比性能得出的结论很容易误导人。好奇之下我决定自己动手做个控制变量的公平测试双方都只测纯粹的原地反转并使用专业工具BenchmarkDotNet 和自写的 C 高精度基准跑一下。结果非常有意思小数组下 C 确实碾压但数据量一上来.NET 的 Array.Reverse 确实能反杀下面是完整的复现过程、代码和数据分析。为什么原文章的对比不够公平我们先快速回顾一下原文章里的代码逻辑。C# 原地反转Span Slice 写法static void Reverse(Span span) {while(span.Length 1) {T firstElement span[0];T lastElement span[^1];span[0] lastElement;span[^1] firstElement;span span[1…^1]; // Slicing in each iteration introduces noticeable overhead}}C 非原地反转分配拷贝// C11std::vector test1() {std::vector rev(NumSize); // New allocation!std::reverse_copy(vec.cbegin(), vec.cend(), rev.begin());return rev;}发现问题了吗C 每次都在 new 内存。在小数组测试中内存分配的开销成了主导在大数组测试中带宽和缓存的影响又掩盖了纯粹的反转逻辑。原作者得出的“C .NET”更多是在测“分配拷贝”的耗时而不是单纯的反转算法效率。控制变量双方纯原地反转对决为了得到准确的结论我重新制定了测试规则纯原地操作全部使用 std::reverse / Array.Reverse 或手写循环绝不分配新数组。防状态污染每轮 Benchmark 前恢复原始数据连续递增的 int 数组。防死代码消除 (DCE)对反转后的结果进行消费计算 checksum。测试规模N1,000测小规模调用的固定开销N1,000,000测大规模吞吐量。.NET 端测试代码BenchmarkDotNet为了探究极限我写了四种实现原生 Array.Reverse、Span 切片、常规下标以及 Unsafe 指针。using System;using System.Linq;using BenchmarkDotNet.Attributes;using BenchmarkDotNet.Columns;using BenchmarkDotNet.Configs;using BenchmarkDotNet.Exporters;using BenchmarkDotNet.Jobs;using BenchmarkDotNet.Order;using BenchmarkDotNet.Running;using System.Runtime.CompilerServices;using System.Runtime.InteropServices;BenchmarkRunner.Run(new Config());public sealed class Config : ManualConfig{public Config(){AddJob(Job.ShortRun.WithWarmupCount(3).WithIterationCount(8));AddColumnProvider(DefaultColumnProviders.Instance);AddExporter(MarkdownExporter.GitHub);WithOrderer(new DefaultOrderer(SummaryOrderPolicy.FastestToSlowest));}}[MemoryDiagnoser][RankColumn]public class ReverseBench{private int[] _original Array.Empty();private int[] _work Array.Empty();[Params(1_000, 1_000_000)] public int N; [GlobalSetup] public void Setup() { _original Enumerable.Range(0, N).ToArray(); _work new int[N]; } [IterationSetup] public void Reset() { Array.Copy(_original, _work, N); } [Benchmark(Baseline true)] public void ArrayReverse() Array.Reverse(https://github.com/kmoore6155-g/pusxk2dl/issues/35); [Benchmark] public void ManagedSpanSliceReverse() ManagedSpanSlice(https://github.com/erikafd8ryan1/vcgju3pn/issues/35); [Benchmark] public void ManagedIndexReverse() ManagedIndex(https://github.com/kmoore6155-g/pusxk2dl/issues/34); [Benchmark] public void UnsafeSpanReverse() UnsafeSpan(https://github.com/erikafd8ryan1/vcgju3pn/issues/34); private static void ManagedSpanSlice(Spanint span) { while (span.Length 1) { int first span[0]; int last span[^1]; span[0] last; span[^1] first; span span[1..^1]; } } private static void ManagedIndex(Spanint https://github.com/kmoore6155-g/pusxk2dl/issues/33) { int i 0; int j span.Length - 1; while (i j) { int tmp span[i]; span[i] span[j]; span[j] tmp; i; j--; } } private static void UnsafeSpan(Spanint span) { if (span.Length 1) return; ref int left ref MemoryMarshal.GetReference(span); ref int right ref Unsafe.Add(ref left, span.Length - 1); do { int a left; int b right; left b; right a; left ref Unsafe.Add(ref left, 1); right ref Unsafe.Subtract(ref right, 1); } while (Unsafe.IsAddressLessThan(ref left, ref right)); }}(环境配置: Ubuntu 24.04, AMD EPYC 7763, .NET 10.0.3 RyuJIT AVX2)C 端测试代码C 这边同样准备了三种实现std::reverse 标准库、手写下标和手写指针。为了对标 BenchmarkDotNet我自己写了个高精度计时器。#include#include#include#include#include#include#include#include#include#includeusing Clock std::chrono::steady_clock;// Prevent compiler from optimizing away the resultsstatic inline void do_not_optimize(const void* p) {asm volatile(“” : : “g”§ : “memory”);}static void reverse_std(std::vector v) {std::reverse(v.begin(), v.end());}static void reverse_index(std::vector v) {if (v.size() 1) return;size_t i 0;size_t j v.size() - 1;while (i j) {int t v[i];v[i] v[j];v[j] t;i;–j;}}static void reverse_pointer(std::vector v) {if (v.size() 1) return;int* left v.data();int* right v.data() v.size() - 1;while (left right) {int t *left;*left *right;*right t;left;–right;}}struct Result {std::string name;int n;int iterations;double mean_ns;double ns_per_element;};static Result bench(const std::string name, int n, int iterations, const std::functionvoid(std::vector) fn) {std::vector original(n);std::iota(original.begin(), original.end(), 0);std::vector work(n);// Warmup for (int i 0; i 3; i) { work original; fn(work); do_not_optimize(work.data()); } auto start Clock::now(); std::uint64_t checksum 0; for (int i 0; i iterations; i) { work original; fn(work); checksum static_caststd::uint64_t(work[n / 2]); do_not_optimize(work.data()); } auto end Clock::now(); do_not_optimize(checksum); double total_ns std::chrono::durationdouble, std::nano(end - start).count(); double mean_ns total_ns / iterations; return {name, n, iterations, mean_ns, mean_ns / n};}int main() {std::vector sizes {1000, 1000000};std::vectorstd::pairstd::string, std::functionvoid(std::vector) fns {{“std::reverse”, reverse_std},{“manual_index”, reverse_index},{“manual_pointer”, reverse_pointer},};std::cout impl,n,iterations,mean_ns,ns_per_element\n; for (int n : sizes) { int iterations n 1000 ? 200000 : 600; for (auto [name, fn] : fns) { auto r bench(name, n, iterations, fn); std::cout r.name , r.n , r.iterations , std::fixed std::setprecision(2) r.mean_ns , std::fixed std::setprecision(6) r.ns_per_element \n; } } return 0;}(环境配置: g 13.3.0, -O3 -marchnative -stdc20)核心对决谁才是真正的性能怪兽直接来看两边跑出来的最快成绩对比数组规模 (N) C 最快实现 耗时 (Mean) .NET 最快实现 耗时 (Mean) 谁赢了1,000 manual_pointer 150.83 ns Array.Reverse 445.60 ns C 快 2.95x1,000,000 manual_pointer 162,917 ns Array.Reverse 88,716 ns .NET 快 1.84xN1,000 时 C 与 C# 的正面对位对比N1,000,000 时 C 与 C# 的正面对位对比C 原始结果CSVimpl n iterations mean_ns ns_per_elementstd::reverse 1000 200000 152.29 0.152291manual_index 1000 200000 394.25 0.394251manual_pointer 1000 200000 150.83 0.150829std::reverse 1000000 600 199966.21 0.199966manual_index 1000000 600 426880.66 0.426881manual_pointer 1000000 600 162917.17 0.162917.NET BenchmarkDotNet 完整结果测试环境如下BenchmarkDotNet v0.14.0, Ubuntu 24.04.4 LTS (Noble Numbat) (container)AMD EPYC 7763, 1 CPU, 4 logical and 2 physical cores.NET SDK 10.0.103[Host] : .NET 10.0.3 (10.0.326.7603), X64 RyuJIT AVX2ShortRun : .NET 10.0.3 (10.0.326.7603), X64 RyuJIT AVX2JobShortRun InvocationCount1 IterationCount8LaunchCount1 UnrollFactor1 WarmupCount3Method N Mean Error StdDev Ratio RatioSD RankArrayReverse 1000 445.6 ns 52.67 ns 27.55 ns 1.00 0.08 1ManagedIndexReverse 1000 3,035.8 ns 53.50 ns 27.98 ns 6.83 0.40 2UnsafeSpanReverse 1000 4,873.0 ns 436.03 ns 193.60 ns 10.97 0.75 3ManagedSpanSliceReverse 1000 9,961.2 ns 120.77 ns 43.07 ns 22.43 1.30 4ArrayReverse 1000000 88,716.0 ns 761.39 ns 398.22 ns 1.00 0.01 1UnsafeSpanReverse 1000000 349,287.4 ns 22,874.65 ns 11,963.88 ns 3.94 0.13 2ManagedIndexReverse 1000000 412,116.6 ns 18,274.90 ns 9,558.12 ns 4.65 0.10 2ManagedSpanSliceReverse 1000000 501,977.0 ns 25,291.77 ns 13,228.09 ns 5.66 0.14 2为什么会出现这种两级反转小数组场景C 的主场在处理 1000 个元素时C 的指针版开销极小。没有边界检查极致紧凑的循环编译器直接将其优化到了硬件指令的极限。而 .NET 虽然 Array.Reverse 很快但在小数组下托管环境的方法调用开销、类型检查等固定成本占比就凸显出来了导致略逊一筹。大数组场景.NET 的反杀当数据量来到 100 万时.NET 的 Array.Reverse(int[]) 展现出了恐怖的吞吐量直接拉开了近一倍的差距。为什么因为 .NET 运行时的 Array.Reverse 针对基元类型Primitive types做了深度优化底层大概率走的是专属的 JIT 路径或高度优化的 SIMD/向量化指令。反观我们自己手写的 Unsafe 代码或者原生 C 循环如果没有显式进行向量化优化在大吞吐量面前反而打不过官方的基础库。永远不要盲目自信手写算法测试数据证实了原知乎文章里的一个现象用 Span Slice 的写法确实是最慢的切片开销大。但同时我们也发现在 .NET 中哪怕你用上了 Unsafe 指针操作依旧跑不过原生的 Array.Reverse。这告诉我们永远优先相信标准库。那帮写 Runtime 的微软大佬底层的骚操作远比我们手写的 while 循环要多得多。结语抛开场景谈性能就是耍流氓。通过控制好“原地反转”这个核心变量我们看到了 C 在微操作上的极致低开销也看到了当代 .NET 在大数据吞吐和标准库优化上的强悍实力。