测试显示“等待”明显变慢，即使正在等待的对象已经完成也是如此
本文关键字：对象 在等待 等待 显示 测试 | 更新日期: 2023-09-27 17:56:36
我想通过使用await/async来测试归因于程序的开销。
为了测试这一点，我编写了以下测试类：
public class Entity : INotifyCompletion {
private Action continuation;
private int i;
public void OnCompleted(Action continuation) {
this.continuation = continuation;
}
public Entity GetAwaiter() {
return this;
}
public Entity GetResult() {
return this;
}
public bool IsCompleted { get { return true; } }
public void Execute() {
if (i > 0) Console.WriteLine("What");
}
}
然后我写了一个测试工具。测试工具遍历 TestA 和 TestB 1600 次，仅测量后者 1500 次（以允许 JIT "预热"）。 set 是实体对象的集合（但实现无关紧要）。集合中有 50,000 个实体。测试工具使用 Stopwatch 类进行测试。
private static void DoTestA() {
Entity[] objects = set.GetElements();
Parallel.For(0, objects.Length, async i => {
Entity e = objects[i];
if (e == null) return;
(await e).Execute();
});
}
private static void DoTestB() {
Entity[] objects = set.GetElements();
Parallel.For(0, objects.Length, i => {
Entity e = objects[i];
if (e == null) return;
e.Execute();
});
}
这两个例程是相同的，除了一个在调用 Execute（） 之前等待实体（Execute()没有任何用处，它只是一些愚蠢的代码，以确保处理器确实为每个实体做一些事情）。
在针对 AnyCPU 的发布模式下执行测试后，我得到以下输出：
>>> 1500 repetitions >>> IN NANOSECONDS (1000ns = 0.001ms)
Method Avg. Min. Max. Jitter Total
A 1,301,465ns 1,232,200ns 2,869,000ns 1,567,534ns ! 1952.199ms
B 130,053ns 116,000ns 711,200ns 581,146ns ! 195.081ms
如您所见，包含 await 的方法大约慢 10 倍。
问题是，据我所知，没有什么"等待"的——GetResult总是正确的。这是否意味着即使等待的"事物"已经准备就绪，状态机也会被执行？
如果是这样，有什么办法可以解决这个问题吗？我想使用 async/await 的语义，但这个开销对于我的应用程序来说太高了......
编辑：请求后添加完整的基准代码：
程序.cs
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace CSharpPerfTest {
public class Entity : INotifyCompletion {
private Action continuation;
private int i;
public void OnCompleted(Action continuation) {
this.continuation = continuation;
}
public Entity GetAwaiter() {
return this;
}
public Entity GetResult() {
return this;
}
public bool IsCompleted { get { return true; } }
public void Execute() {
if (i > 0) Console.WriteLine("What");
}
}
static class Program {
static ConcurrentSet<Entity> set;
const int MAX_ELEMENTS = 50000;
// Called once before all testing begins
private static void OnceBefore() {
set = new ConcurrentSet<Entity>();
Parallel.For(0, MAX_ELEMENTS, i => {
set.Add(new Entity());
});
}
// Called twice each repetition, once before DoTestA and once before DoTestB
private static void PreTest() {
}
private static void DoTestA() {
Entity[] objects = set.GetElements();
Parallel.For(0, objects.Length, async i => {
Entity e = objects[i];
if (e == null) return;
(await e).Execute();
});
}
private static void DoTestB() {
Entity[] objects = set.GetElements();
Parallel.For(0, objects.Length, i => {
Entity e = objects[i];
if (e == null) return;
e.Execute();
});
}
private const int REPETITIONS = 1500;
private const int JIT_WARMUPS = 10;
#region Test Harness
private static double[] aTimes = new double[REPETITIONS];
private static double[] bTimes = new double[REPETITIONS];
private static void Main(string[] args) {
Stopwatch stopwatch = new Stopwatch();
OnceBefore();
for (int i = JIT_WARMUPS * -1; i < REPETITIONS; ++i) {
Console.WriteLine("Starting repetition " + i);
PreTest();
stopwatch.Restart();
DoTestA();
stopwatch.Stop();
if (i >= 0) aTimes[i] = stopwatch.Elapsed.TotalMilliseconds;
PreTest();
stopwatch.Restart();
DoTestB();
stopwatch.Stop();
if (i >= 0) bTimes[i] = stopwatch.Elapsed.TotalMilliseconds;
}
DisplayScores();
}
private static void DisplayScores() {
Console.WriteLine();
Console.WriteLine();
bool inNanos = false;
if (aTimes.Average() < 10 || bTimes.Average() < 10) {
inNanos = true;
for (int i = 0; i < aTimes.Length; ++i) aTimes[i] *= 1000000;
for (int i = 0; i < bTimes.Length; ++i) bTimes[i] *= 1000000;
}
Console.WriteLine(">>> " + REPETITIONS + " repetitions >>> " + (inNanos ? "IN NANOSECONDS (1000ns = 0.001ms)" : "IN MILLISECONDS (1000ms = 1s)"));
Console.WriteLine("Method Avg. Min. Max. Jitter Total");
Console.WriteLine(
"A "
+ (String.Format("{0:N0}", (long) aTimes.Average()) + (inNanos ? "ns" : "ms")).PadRight(13, ' ')
+ (String.Format("{0:N0}", (long) aTimes.Min()) + (inNanos ? "ns" : "ms")).PadRight(13, ' ')
+ (String.Format("{0:N0}", (long) aTimes.Max()) + (inNanos ? "ns" : "ms")).PadRight(13, ' ')
+ (String.Format("{0:N0}", (long) Math.Max(aTimes.Average() - aTimes.Min(), aTimes.Max() - aTimes.Average())) + (inNanos ? "ns" : "ms")).PadRight(13, ' ')
+ ((long) aTimes.Sum() >= 10000 && inNanos ? "! " + String.Format("{0:f3}", aTimes.Sum() / 1000000) + "ms" : (long) aTimes.Sum() + (inNanos ? "ns" : "ms"))
);
Console.WriteLine(
"B "
+ (String.Format("{0:N0}", (long) bTimes.Average()) + (inNanos ? "ns" : "ms")).PadRight(13, ' ')
+ (String.Format("{0:N0}", (long) bTimes.Min()) + (inNanos ? "ns" : "ms")).PadRight(13, ' ')
+ (String.Format("{0:N0}", (long) bTimes.Max()) + (inNanos ? "ns" : "ms")).PadRight(13, ' ')
+ (String.Format("{0:N0}", (long) Math.Max(bTimes.Average() - bTimes.Min(), bTimes.Max() - bTimes.Average())) + (inNanos ? "ns" : "ms")).PadRight(13, ' ')
+ ((long) bTimes.Sum() >= 10000 && inNanos ? "! " + String.Format("{0:f3}", bTimes.Sum() / 1000000) + "ms" : (long) bTimes.Sum() + (inNanos ? "ns" : "ms"))
);
Console.ReadKey();
}
#endregion
}
}
如果您的函数的响应时间为 50,000 次调用的 1ms 被认为是重要的，则不应等待该代码，而应同步运行它。
使用异步代码的开销很小，它必须为内部驱动它的状态机添加一个函数调用。如果与运行状态机的开销成本相比，您所做的异步工作也很小，您应该制作代码，您需要重新考虑代码是否应该是异步的。
从评论中转换为答案：显然，这不是一个干净的基准测试。
如果您不需要异步延续，请不要使用它。没有它，代码总是更快。如果您确实需要它，那么预计会有一些开销。当您使用特定语言/运行时功能时，您应该了解幕后发生的事情。
即使你删除了Parallel.For，将lambda转换为方法并防止内联，仍然会有一些struct复制和await延续闭包分配，以支持状态机功能（生成的代码的示例）。
更公平的基准测试是在没有同步上下文的线程上使用回调闭包和Task.ContinueWith测试async/await与替代实现。在这种情况下，我不希望有任何显着差异。
附带说明一下，您正在将async void lambda Action传递到Parallel.For 中。您应该知道，一旦 lambda 内部出现第 1 个await，执行控件就会返回到 Parallel.For，然后它本质上是 Parallel.For 外部的即发即弃调用。我真的想不出任何有用的场景。