标签: benchmarkdotnet

我第一次关注 BenchmarkDotNet 和一般基准测试。由于我们工作笔记本电脑上的防病毒限制，我似乎无法使用普通的 BenchmarkRunner 运行基准测试，因此我尝试使用 InProcessEmitToolchain，如此处所述。然而，在这些示例和此处列出的示例中，我看不到真正会触发基准测试的应用程序的入口点，并且我在阅读文档时没有得到任何有用的信息。

谁能向我指出如何使用 InProcessEmitToolchain 和/或作业的完整示例，以解释如何将作业与应用程序入口点结合使用来运行测试？

我正在尝试运行这段代码：

public class Parsing
{
    private const string Url ="blabla";
    private static HttpClient client = new HttpClient();

    private static Task<string> newton = ParseNewton();
    private static Task<string> servicestack = ParseServiceStack();

    [Benchmark]
    private static async Task<string> ParseNewton()
    {

        var response = client.GetAsync(Url).Result;

        var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);

        var serializer = new Newtonsoft.Json.JsonSerializer();

        using (var sr = new StreamReader(stream))
        using (var jsonTextReader = new JsonTextReader(sr))
        {
            return serializer.Deserialize<string>(jsonTextReader);
        }

    }

    [Benchmark]
    private static async Task<string> ParseServiceStack()
    {

        var response = client.GetAsync(Url).Result;

        var stream …

我在这里撞墙，所以我希望你们中的一些人可以教育我。我当时使用BenchmarkDotNet进行了一些性能基准测试，并且遇到了这个奇怪的情况，在该情况下，声明成员似乎const会大大降低性能。

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;

namespace PerfTest
{
    [DisassemblyDiagnoser(printAsm: true, printSource: true)]
    public class Test
    {
        private int[] data;
        private int Threshold = 90;
        private const int ConstThreshold = 90;

        [GlobalSetup]
        public void GlobalSetup()
        {
            data = new int[1000];
            var random = new Random(42);
            for (var i = 0; i < data.Length; i++)
            {
                data[i] = random.Next(100);
            }
        }

        static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Test>();
        }

        [Benchmark(Baseline = true)]
        public void ClampToMemberValue()
        { …

我出于好奇创建了一个简单的基准,但无法解释结果.

作为基准数据,我准备了一些带有一些随机值的结构数组.准备阶段没有基准:

struct Val 
{
    public float val;
    public float min;
    public float max;
    public float padding;
}

const int iterations = 1000;
Val[] values = new Val[iterations];
// fill the array with randoms

基本上,我想比较这两个钳位实现:

static class Clamps
{
    public static float ClampSimple(float val, float min, float max)
    {
        if (val < min) return min;          
        if (val > max) return max;
        return val;
    }

    public static T ClampExt<T>(this T val, T min, T max) where T : IComparable<T>
    {
        if …

我正在使用BenchmarkDotNet库进行性能检查，并且我想在使用基准类时注入参数。像这样的东西：

public class Program
{
    public static void Main()
    {
        var benchmark1 = new BenchmarkWithParameter(100);
        BenchmarkRunner.Run(benchmark1);

        var benchmark2 = new BenchmarkWithParameter(200);
        BenchmarkRunner.Run(benchmark2);
    }
}

public class BenchmarkWithParameter
{
    public BenchmarkWithParameter(int waitTime)
    {
        WaitTime = waitTime;
    }

    public int WaitTime { get; }

    [Benchmark]
    public void Run()
    {
        Thread.Sleep(WaitTime);
    }
}

有办法实现吗？

我知道我可以使用Params,ParamsSource和ArgumentsSource属性，但这意味着我需要为每个参数更改更改基准类，而不是注入不同的参数。

我的主要目标是编写一次基准测试类，并使用不同的参数多次使用它。

我运行了一个基准示例并得到了这张表。

BenchmarkDotNet=v0.12.0, OS=Windows 7 SP1 (6.1.7601.0)
Intel Xeon CPU E5-4660 v3 2.10GHz, 1 CPU, 28 logical and 14 physical cores
Frequency=2050214 Hz, Resolution=487.7540 ns, Timer=TSC
  [Host]     : .NET Framework 4.8 (4.8.4018.0), X86 LegacyJIT  [AttachedDebugger]
  DefaultJob : .NET Framework 4.8 (4.8.4018.0), X86 LegacyJIT


| Method |      Mean |    Error |   StdDev |
|------- |----------:|---------:|---------:|
| Sha256 | 173.60 us | 3.466 us | 9.604 us |
|    Md5 |  29.95 us | 0.599 us | 1.709 us |

嗯……怎么读？ …

我正在对一些 .net 框架的东西进行基准测试，我正在使用 .net 框架、C# 和BenchmarkDotNet

我想做的是；我正在编写很多基准测试，我只对报告的摘要部分感兴趣。如何配置 BenchmarkDotNet 以仅显示测试的摘要部分？

这是一个更清晰的屏幕截图；

我在.NET Core 2.1中遇到了一个我想要了解的性能问题.可以在此处找到此代码:

https://github.com/mike-eee/StructureActivation

以下是BenchmarkDotNet的相关基准代码:

public class Program
{
    static void Main()
    {
        BenchmarkRunner.Run<Program>();
    }

    [Benchmark(Baseline = true)]
    public uint? Activated() => new Structure(100).SomeValue;

    [Benchmark]
    public uint? ActivatedAssignment()
    {
        var selection = new Structure(100);
        return selection.SomeValue;
    }
}

public readonly struct Structure
{
    public Structure(uint? someValue) => SomeValue = someValue;

    public uint? SomeValue { get; }
}

从一开始,我希望Activated是更快,因为它没有存储在本地变量,这是我一直理解为对性能产生负面定位和当前栈框架内预留的空间这样做.

但是,在运行测试时,我得到以下结果:

// * Summary *

BenchmarkDotNet=v0.11.1, OS=Windows 10.0.17134.285 (1803/April2018Update/Redstone4)
Intel Core i7-4820K CPU 3.70GHz (Haswell), 1 …

我对如何使用Newtonsoft.Json反序列化 HTTP 响应 JSON 有效负载的两种方法的性能（速度、内存使用）比较感兴趣。

我知道Newtonsoft.Json 的使用流的性能提示，但我想了解更多并有确切的数字。我已经使用BenchmarkDotNet编写了简单的基准测试，但我对结果有点困惑（参见下面的数字）。

我得到了什么：

• 从流中解析总是更快，但也不是很多
• 使用字符串作为输入时，解析小型和“中型”JSON 具有更好或相同的内存使用率
• 对于大型 JSON（字符串本身以 LOH 结尾），内存使用情况开始出现显着差异

我还没有时间进行适当的分析，我对流方法的内存开销感到有点惊讶（如果没有错误）。完整代码在这里。

？

• 我的做法正确吗？（使用MemoryStream；模拟HttpResponseMessage及其内容；...）
• 基准测试代码有问题吗？
• 为什么我会看到这样的结果？

基准设置

我准备MemoryStream在基准测试中反复使用：

[GlobalSetup]
public void GlobalSetup()
{
    var resourceName = _resourceMapping[typeof(T)];
    using (var resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName))
    {
        _memory = new MemoryStream();
        resourceStream.CopyTo(_memory);
    }

    _iterationRepeats = _repeatMapping[typeof(T)];
}

流反序列化

[Benchmark(Description = "Stream d13n")]
public async Task DeserializeStream()
{
    for (var i = 0; i < _iterationRepeats; i++) …