Lambda Actions或aggressive内联以避免评估和传递复杂的字符串来分离静态类? &g

Question

我试图避免评估和传递字符串到一个单独的静态类，如果在该类中设置的标志将跳过使用字符串。用System.Diagnostics.Stopwatch做基本的性能测量。一个c# . net Framework 4.8库，是一个语音识别应用程序的插件。

插件对静态类进行多次调用，传递各种求值字符串。根据该类中设置的静态状态筛选不同的调用，因此只有在匹配的静态bool值为真时才使用字符串。例如

Logger.MenuWrite(string msg)只在Logger.MenuItems为真时记录字符串。

从Stopwatch测量，我认为字符串总是得到评估，不管Logger类是否将不使用它们(也就是说，我不认为JIT不是内联的)。虽然这是轻微的命中率，我试图得到每一毫秒，我可以，因为我扩大它。

到目前为止我所尝试和测试的:

我在一些循环周围添加了Stopwatch测量，这些循环在Logger.MenuItems为假时进行了大量Logger.MenuWrite()调用，然后用Logger检查测量了相同的循环。对于每个调用都内联的MenuItems，并且看到了一个明确的，可重复的差异-对于只有一个求值字段的字符串，每1000个调用大约少1毫秒。

我首先尝试在Logger类中的静态方法上使用[MethodImpl(MethodImplOptions.AggressiveInlining)]，如下所示:

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void MenuWrite(string msg)
{
if (s_MenuItems )
{   vaProxy.WriteToLog(s_Prefix + msg); }
}

这将循环的时间缩短了一半，但仍然比在循环中进行实际的直接检查多了大约1/2毫秒，例如:

if (Logger.MenuItems) { Logger.MenuWrite(msg); }

所以我尝试使用委托，像这样:

static Action<string> LogIfMenu = (msg) =>
{
if (Logger.MenuItems) { Logger.MenuWrite(msg); }
};

但使用LogIfMenu调用似乎与使用[MethodImpl(MethodImplOptions.AggressiveInlining)]具有相同或更差的性能。

有什么想法是什么导致perf命中-字符串计算/创建，方法调用，其他东西?除了手动内联所有呼叫外，请提供任何建议或选择。谢谢。

编辑:

• 通过评估字符串，我的意思是拉入其他数据，如:$"Passed: {Cmd.Observable} and {Cmd.Dist}"
• 我将尝试查看列出的其他性能工具，但确实需要测量发布构建中经过的时间
• 恐怕我必须使用动态对象进行日志记录，因为这是我的插件所提供的应用程序。也就是说，我不认为这是这个问题的一部分，所以从代码片段中删除了它。

编辑:修改小可复制的例子是控制台应用程序。

// File1.cs
namespace CS_Console_Test_05
{
static public class Logger
{
public static bool MenuItems = false;
public static void MenuWrite(string msg)
{
if (MenuItems) { Console.WriteLine(msg); }
}
}
}
// File2.cs
namespace CS_Console_Test_05
{
internal class Program
{
public static void LoopMessagesInline()
{
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < 10000; i++)
{
if (Logger.MenuItems)
{ Logger.MenuWrite($"Counting Down to the time {sw.Elapsed}"); }
}
sw.Stop();
Console.WriteLine($"Inline Elapsed = {sw.Elapsed}");
}
public static void LoopMessagesCall()
{
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < 10000; i++)
{
Logger.MenuWrite($"Counting Down to the time {sw.Elapsed}");
}
sw.Stop();
Console.WriteLine($"Called Elapsed = {sw.Elapsed}");
}
static void Main(string[] args)
{
do
{
Console.WriteLine("Enter Value for MenuItems:");
string miRead = Console.ReadLine();
Logger.MenuItems = (miRead.Equals("Kludge"));    // so JIT won't know if true or false
Console.WriteLine("'x' to quit, SPACE for Inline, nothing for Call, then ENTER: ");
string way = Console.ReadLine();
way = way.ToLower();
if (way.Equals(" "))
{ LoopMessagesCall(); }
else if (way.Equals("x"))
{ return; }
else
{ LoopMessagesInline(); }
} while (true);
}
}
}

调用LoopMessageInline()大约需要7-8毫秒。调用LoopMessageCall()的时间小于1毫秒。

如上所述，MethodImplOptions。侵略性内联，不使用委托似乎有助于解决这个问题。

Answer 1

首先要使用合适的基准测试工具，比如BenchmarkDotNet。

我提出了以下基准:

namespace CS_Console_Test_05
{
static public class Logger
{
public static bool MenuItems = false;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void MenuWrite(string msg)
{
if (MenuItems)
{
Console.WriteLine(msg);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void MenuWriteFormattableString(FormattableString msg)
{
if (MenuItems)
{
Console.WriteLine(msg);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void MenuWriteFunc(Func<string> msg)
{
if (MenuItems)
{
Console.WriteLine(msg());
}
}
}
}

[MemoryDiagnoser]
public class LoggerWrapperBench
{
public static string Value = "TestVal";
private const int Iterations = 1000;
[Benchmark]
public void LoopMessagesInline()
{
for (int i = 0; i < Iterations; i++)
{
if (Logger.MenuItems)
{
Console.WriteLine($"Counting Down to the time {Value}");
}
}
}
[Benchmark]
public void LoopMessagesInlineFormatableString()
{
for (int i = 0; i < Iterations; i++)
{
Logger.MenuWriteFormattableString($"Counting Down to the time {Value}");
}
}

[Benchmark]
public void LoopMessagesInlineFunc()
{
for (int i = 0; i < Iterations; i++)
{
Logger.MenuWriteFunc(() => $"Counting Down to the time {Value}");
}
}
[Benchmark]
public void LoopMessagesCall()
{
for (int i = 0; i < Iterations; i++)
{
Logger.MenuWrite($"Counting Down to the time {Value}");
}
}
}

在我的机器上给出:

LoopMessagesInline	524.7 ns	10.10 ns	10.37 ns	-
LoopMessagesInlineFormatableString	10,908.3 ns	215.37 ns	328.89 ns	10.1929	64000 B
LoopMessagesInlineFunc	1031.8 ns	18.34 ns	21.12 ns	-
LoopMessagesCall	14523.6 ns	286.28 ns	391.86 ns	14.0228	88000 B

根据@HansPassant注释，可以通过将Logger类中的方法更改为:

来避免perf命中:

public static void MenuWrite(Func<string> msg) 
{ 
if (MenuItems) Console.Write(msg()); 
}

并将对它的调用更改为:

Logger.MenuWrite(() => $"Counting Down to the time {sw.Elapsed}");

sw。当然，Elapsed只是用于复制的情况。是时候读更多关于委托的书了——要记住这不是c++。

编辑:Per @GuruStron不得不将ConsoleWrite(msg)更改为ConsoleWrite(msg())

Perf测试是非常基本的，在问题中列出的最小repro项目中使用Stopwatch。