微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

c# – 为什么添加DoubleStructs比添加双倍的速度要慢得多？

分类：C#作者：编程之家
假设

对于任何简单的操作,包含单个基元的只读结构应该与基元本身一样快.

测试

以下所有测试都是在Windows 7 x64上运行.NET Core 2.2,代码优化.在.NET 4.7.2上测试时,我也得到了类似的结果.

测试：渴望

用long类型测试这个前提,似乎这有：

// =============== SETUP ===================

public readonly struct LongStruct
{
    public readonly long Primitive;

    public LongStruct(long value) => Primitive = value;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static LongStruct Add(in LongStruct lhs,in LongStruct rhs)
        => new LongStruct(lhs.Primitive + rhs.Primitive);
}

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static long LongAdd(long lhs,long rhs) => lhs + rhs;

// =============== TESTS ===================

public static void TestLong(long a,long b,out long result)
{
    var sw = Stopwatch.StartNew();

    for (var i = 1000000000; i > 0; --i)
    {
        a = LongAdd(a,b);
    }

    sw.Stop();

    result = a;

    return sw.ElapsedMilliseconds;
}

public static void TestLongStruct(LongStruct a,LongStruct b,out LongStruct result)
{
    var sw = Stopwatch.StartNew();

    for (var i = 1000000000; i > 0; --i)
    {
        a = LongStruct.Add(a,b);
    }

    sw.Stop();

    result = a;

    return sw.ElapsedMilliseconds;
}

// ============= TEST LOOP =================

public static void RunTests()
{
    var longStruct = new LongStruct(1);

    var count = 0;
    var longTime = 0L;
    var longStructTime = 0L;

    while (true)
    {
        count++;
        Console.WriteLine("Test #" + count);

        longTime += TestLong(1,1,out var longResult);
        var longMean = longTime / count;
        Console.WriteLine($"Long: value={longResult},Mean Time elapsed: {longMean} ms");

        longStructTime += TestLongStruct(longStruct,longStruct,out var longstructresult);
        var longStructMean = longStructTime / count;
        Console.WriteLine($"LongStruct: value={longstructresult.Primitive},Mean Time elapsed: {longStructMean} ms");

        Console.WriteLine();
    }
}

使用LongAdd使测试循环匹配 – 每个循环调用一个方法来进行一些添加,而不是内联案例的内联

在我的机器上,这两次已经稳定在彼此的2％之内,足够近以至于我确信它们已经针对几乎相同的代码进行了优化.

IL的差异相当小：

>测试循环代码是相同的,除了调用哪个方法(LongAdd vs LongStruct.Add).
> LongStruct.Add有一些额外的说明：

>一对ldfld指令从结构中加载Primitive
> newobj指令将新的long打包回LongStruct

所以要么抖动正在优化这些指令,要么它们基本上是免费的.

测试：双打

如果我采用上面的代码并用double替换每个long,我会期望相同的结果(绝对值较慢,因为add指令稍微慢一点,但两者都是相同的余量).

我实际看到的是DoubleStruct版本比双版本慢大约4.8倍(即480％).

IL与long case相同(除了交换用于float64和DoubleStruct的int64和LongStruct),但不知何故,运行时正在为LongStruct案例或双案例中不存在的DoubleStruct案例进行额外的工作.

测试：其他类型

测试一些其他原始类型,我看到float(465％)的行为与double的行为相同,而short和int的行为方式与long相同,所以看起来它是关于浮点导致一些优化不被采取.

题

为什么DoubleStruct和FloatStruct比double和float慢得多,其中long,int和short等价物没有这样的减速？

解决方法

这不是一个单独的答案,但它在x86和x64上都是一个更严格的基准测试,所以希望它能为其他可以解释这个问题的人提供更多信息.

我试图用BenchmarkDotNet复制它.我也想知道删除in会有什么区别.我把它作为x86和x64单独运行.

x86(LegacyJIT)

|                 Method |     Mean |    Error |   StdDev |
|----------------------- |---------:|---------:|---------:|
|               TestLong | 257.9 ms | 2.099 ms | 1.964 ms |
|         TestLongStruct | 529.3 ms | 4.977 ms | 4.412 ms |
|   TestLongStructWithIn | 526.2 ms | 6.722 ms | 6.288 ms |
|             TestDouble | 256.7 ms | 1.466 ms | 1.300 ms |
|       TestDoubleStruct | 342.5 ms | 5.189 ms | 4.600 ms |
| TestDoubleStructWithIn | 338.7 ms | 3.808 ms | 3.376 ms |

x64(RyuJIT)

|                 Method |       Mean |     Error |    StdDev |
|----------------------- |-----------:|----------:|----------:|
|               TestLong |   269.8 ms |  5.359 ms |  9.099 ms |
|         TestLongStruct |   266.2 ms |  6.706 ms |  8.236 ms |
|   TestLongStructWithIn |   270.4 ms |  4.150 ms |  3.465 ms |
|             TestDouble |   270.4 ms |  5.336 ms |  6.748 ms |
|       TestDoubleStruct | 1,250.9 ms | 24.702 ms | 25.367 ms |
| TestDoubleStructWithIn |   577.1 ms | 12.159 ms | 16.644 ms |

我可以使用RyuJIT在x64上复制此内容,但不能在使用LegacyJIT的x86上复制此内容.这似乎是RyuJIT管理优化长期案例但不是双重案例的工件 – LegacyJIT也没有做出优化.

我不知道为什么TestDoubleStruct在RyuJIT上是如此异常.

码：

public readonly struct LongStruct
{
    public readonly long Primitive;

    public LongStruct(long value) => Primitive = value;

    public static LongStruct Add(LongStruct lhs,LongStruct rhs)
        => new LongStruct(lhs.Primitive + rhs.Primitive);
    public static LongStruct AddWithIn(in LongStruct lhs,in LongStruct rhs)
        => new LongStruct(lhs.Primitive + rhs.Primitive);
}

public readonly struct DoubleStruct
{
    public readonly double Primitive;

    public DoubleStruct(double value) => Primitive = value;

    public static DoubleStruct Add(DoubleStruct lhs,DoubleStruct rhs)
        => new DoubleStruct(lhs.Primitive + rhs.Primitive);
    public static DoubleStruct AddWithIn(in DoubleStruct lhs,in DoubleStruct rhs)
        => new DoubleStruct(lhs.Primitive + rhs.Primitive);
}


public class Benchmark
{
    [Benchmark]
    public void TestLong()
    {
        for (var i = 1000000000; i > 0; --i)
        {
            LongAdd(1,2);
        }
    }

    [Benchmark]
    public void TestLongStruct()
    {
        var a = new LongStruct(1);
        var b = new LongStruct(2);

        for (var i = 1000000000; i > 0; --i)
        {
            LongStruct.Add(a,b);
        }
    }

    [Benchmark]
    public void TestLongStructWithIn()
    {
        var a = new LongStruct(1);
        var b = new LongStruct(2);

        for (var i = 1000000000; i > 0; --i)
        {
            LongStruct.AddWithIn(a,b);
        }
    }

    [Benchmark]
    public void TestDouble()
    {
        for (var i = 1000000000; i > 0; --i)
        {
            DoubleAdd(1,2);
        }
    }

    [Benchmark]
    public void TestDoubleStruct()
    {
        var a = new DoubleStruct(1);
        var b = new DoubleStruct(2);

        for (var i = 1000000000; i > 0; --i)
        {
            DoubleStruct.Add(a,b);
        }
    }

    [Benchmark]
    public void TestDoubleStructWithIn()
    {
        var a = new DoubleStruct(1);
        var b = new DoubleStruct(2);

        for (var i = 1000000000; i > 0; --i)
        {
            DoubleStruct.AddWithIn(a,b);
        }
    }

    public static long LongAdd(long lhs,long rhs) => lhs + rhs;
    public static double DoubleAdd(double lhs,double rhs) => lhs + rhs;
}

class Program
{
    static void Main(string[] args)
    {
        var summary = BenchmarkRunner.Run<Benchmark>();
        Console.ReadLine();
    }
}

为了好玩,以下是两种情况下的x64程序集：

码

using System;

public class C {
    public long AddLongs(long a,long b) {
        return a + b;
    }

    public LongStruct AddLongStructs(LongStruct a,LongStruct b) {
        return LongStruct.Add(a,b);
    }

    public LongStruct AddLongStructsWithIn(LongStruct a,LongStruct b) {
        return LongStruct.AddWithIn(a,b);
    }

    public double AddDoubles(double a,double b) {
        return a + b;
    }

    public DoubleStruct AddDoubleStructs(DoubleStruct a,DoubleStruct b) {
        return DoubleStruct.Add(a,b);
    }

    public DoubleStruct AddDoubleStructsWithIn(DoubleStruct a,DoubleStruct b) {
        return DoubleStruct.AddWithIn(a,b);
    }
}

public readonly struct LongStruct
{
    public readonly long Primitive;

    public LongStruct(long value) => Primitive = value;

    public static LongStruct Add(LongStruct lhs,in LongStruct rhs)
        => new LongStruct(lhs.Primitive + rhs.Primitive);
}   

public readonly struct DoubleStruct
{
    public readonly double Primitive;

    public DoubleStruct(double value) => Primitive = value;

    public static DoubleStruct Add(DoubleStruct lhs,in DoubleStruct rhs)
        => new DoubleStruct(lhs.Primitive + rhs.Primitive);
}

x86汇编

C.AddLongs(Int64,Int64)
    L0000: mov eax,[esp+0xc]
    L0004: mov edx,[esp+0x10]
    L0008: add eax,[esp+0x4]
    L000c: adc edx,[esp+0x8]
    L0010: ret 0x10

C.AddLongStructs(LongStruct,LongStruct)
    L0000: push esi
    L0001: mov eax,[esp+0x10]
    L0005: mov esi,[esp+0x14]
    L0009: add eax,[esp+0x8]
    L000d: adc esi,[esp+0xc]
    L0011: mov [edx],eax
    L0013: mov [edx+0x4],esi
    L0016: pop esi
    L0017: ret 0x10

C.AddLongStructsWithIn(LongStruct,esi
    L0016: pop esi
    L0017: ret 0x10

C.AddDoubles(Double,Double)
    L0000: fld qword [esp+0xc]
    L0004: fadd qword [esp+0x4]
    L0008: ret 0x10

C.AddDoubleStructs(DoubleStruct,DoubleStruct)
    L0000: fld qword [esp+0xc]
    L0004: fld qword [esp+0x4]
    L0008: faddp st1,st0
    L000a: fstp qword [edx]
    L000c: ret 0x10

C.AddDoubleStructsWithIn(DoubleStruct,DoubleStruct)
    L0000: fld qword [esp+0xc]
    L0004: fadd qword [esp+0x4]
    L0008: fstp qword [edx]
    L000a: ret 0x10

x64汇编

C..ctor()
    L0000: ret

C.AddLongs(Int64,Int64)
    L0000: lea rax,[rdx+r8]
    L0004: ret

C.AddLongStructs(LongStruct,LongStruct)
    L0000: lea rax,[rdx+r8]
    L0004: ret

C.AddLongStructsWithIn(LongStruct,[rdx+r8]
    L0004: ret

C.AddDoubles(Double,Double)
    L0000: vzeroupper
    L0003: vmovaps xmm0,xmm1
    L0008: vaddsd xmm0,xmm0,xmm2
    L000d: ret

C.AddDoubleStructs(DoubleStruct,DoubleStruct)
    L0000: sub rsp,0x18
    L0004: vzeroupper
    L0007: mov [rsp+0x28],rdx
    L000c: mov [rsp+0x30],r8
    L0011: mov rax,[rsp+0x28]
    L0016: mov [rsp+0x10],rax
    L001b: mov rax,[rsp+0x30]
    L0020: mov [rsp+0x8],rax
    L0025: vmovsd xmm0,qword [rsp+0x10]
    L002c: vaddsd xmm0,[rsp+0x8]
    L0033: vmovsd [rsp],xmm0
    L0039: mov rax,[rsp]
    L003d: add rsp,0x18
    L0041: ret

C.AddDoubleStructsWithIn(DoubleStruct,DoubleStruct)
    L0000: push rax
    L0001: vzeroupper
    L0004: mov [rsp+0x18],rdx
    L0009: mov [rsp+0x20],r8
    L000e: vmovsd xmm0,qword [rsp+0x18]
    L0015: vaddsd xmm0,[rsp+0x20]
    L001c: vmovsd [rsp],xmm0
    L0022: mov rax,[rsp]
    L0026: add rsp,0x8
    L002a: ret

SharpLab

如果你添加循环：

码

public class C {
    public void AddLongs(long a,long b) {
        for (var i = 1000000000; i > 0; --i) {
            long c = a + b;
        }
    }

    public void AddLongStructs(LongStruct a,LongStruct b) {
        for (var i = 1000000000; i > 0; --i) {
            a = LongStruct.Add(a,b);
        }
    }

    public void AddLongStructsWithIn(LongStruct a,LongStruct b) {
        for (var i = 1000000000; i > 0; --i) {
            a = LongStruct.AddWithIn(a,b);
        }
    }

    public void AddDoubles(double a,double b) {
        for (var i = 1000000000; i > 0; --i) {
            a = a + b;
        }
    }

    public void AddDoubleStructs(DoubleStruct a,DoubleStruct b) {
        for (var i = 1000000000; i > 0; --i) {
            a = DoubleStruct.Add(a,b);
        }
    }

    public void AddDoubleStructsWithIn(DoubleStruct a,DoubleStruct b) {
        for (var i = 1000000000; i > 0; --i) {
            a = DoubleStruct.AddWithIn(a,b);
        }
    }
}

public readonly struct LongStruct
{
    public readonly long Primitive;

    public LongStruct(long value) => Primitive = value;

    public static LongStruct Add(LongStruct lhs,in DoubleStruct rhs)
        => new DoubleStruct(lhs.Primitive + rhs.Primitive);
}

86

C.AddLongs(Int64,Int64)
    L0000: push ebp
    L0001: mov ebp,esp
    L0003: mov eax,0x3b9aca00
    L0008: dec eax
    L0009: test eax,eax
    L000b: jg L0008
    L000d: pop ebp
    L000e: ret 0x10

C.AddLongStructs(LongStruct,LongStruct)
    L0000: push ebp
    L0001: mov ebp,esp
    L0003: push esi
    L0004: mov esi,0x3b9aca00
    L0009: mov eax,[ebp+0x10]
    L000c: mov edx,[ebp+0x14]
    L000f: add eax,[ebp+0x8]
    L0012: adc edx,[ebp+0xc]
    L0015: mov [ebp+0x10],eax
    L0018: mov [ebp+0x14],edx
    L001b: dec esi
    L001c: test esi,esi
    L001e: jg L0009
    L0020: pop esi
    L0021: pop ebp
    L0022: ret 0x10

C.AddLongStructsWithIn(LongStruct,esi
    L001e: jg L0009
    L0020: pop esi
    L0021: pop ebp
    L0022: ret 0x10

C.AddDoubles(Double,Double)
    L0000: push ebp
    L0001: mov ebp,eax
    L000b: jg L0008
    L000d: pop ebp
    L000e: ret 0x10

C.AddDoubleStructs(DoubleStruct,DoubleStruct)
    L0000: push ebp
    L0001: mov ebp,0x3b9aca00
    L0008: fld qword [ebp+0x10]
    L000b: fld qword [ebp+0x8]
    L000e: faddp st1,st0
    L0010: fstp qword [ebp+0x10]
    L0013: dec eax
    L0014: test eax,eax
    L0016: jg L0008
    L0018: pop ebp
    L0019: ret 0x10

C.AddDoubleStructsWithIn(DoubleStruct,0x3b9aca00
    L0008: fld qword [ebp+0x10]
    L000b: fadd qword [ebp+0x8]
    L000e: fstp qword [ebp+0x10]
    L0011: dec eax
    L0012: test eax,eax
    L0014: jg L0008
    L0016: pop ebp
    L0017: ret 0x10

64位

C.AddLongs(Int64,0x3b9aca00
    L0005: dec eax
    L0007: test eax,eax
    L0009: jg L0005
    L000b: ret

C.AddLongStructs(LongStruct,LongStruct)
    L0000: mov eax,0x3b9aca00
    L0005: add rdx,r8
    L0008: dec eax
    L000a: test eax,eax
    L000c: jg L0005
    L000e: ret

C.AddLongStructsWithIn(LongStruct,eax
    L000c: jg L0005
    L000e: ret

C.AddDoubles(Double,Double)
    L0000: vzeroupper
    L0003: mov eax,0x3b9aca00
    L0008: vaddsd xmm1,xmm1,xmm2
    L000d: dec eax
    L000f: test eax,eax
    L0011: jg L0008
    L0013: ret

C.AddDoubleStructs(DoubleStruct,r8
    L0011: mov eax,0x3b9aca00
    L0016: mov rdx,[rsp+0x28]
    L001b: mov [rsp+0x10],rdx
    L0020: mov rdx,[rsp+0x30]
    L0025: mov [rsp+0x8],rdx
    L002a: vmovsd xmm0,qword [rsp+0x10]
    L0031: vaddsd xmm0,[rsp+0x8]
    L0038: vmovsd [rsp],xmm0
    L003e: mov rdx,[rsp]
    L0042: mov [rsp+0x28],rdx
    L0047: dec eax
    L0049: test eax,eax
    L004b: jg L0016
    L004d: add rsp,0x18
    L0051: ret

C.AddDoubleStructsWithIn(DoubleStruct,r8
    L000e: mov eax,0x3b9aca00
    L0013: vmovsd xmm0,qword [rsp+0x20]
    L001a: vmovaps xmm1,xmm0
    L001f: vaddsd xmm1,[rsp+0x18]
    L0026: vmovsd [rsp],xmm1
    L002c: mov rdx,[rsp]
    L0030: mov [rsp+0x18],rdx
    L0035: dec eax
    L0037: test eax,eax
    L0039: jg L001a
    L003b: add rsp,0x8
    L003f: ret

SharpLab

我对汇编不够熟悉,无法解释它究竟在做什么,但很明显AddDoubleStructs中的工作比AddLongStructs更多.

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

Blazor 调用 Clipboard API 读写剪贴板数据
目录简介使用JS互操作使用ClipLazor库创建项目使用方法简单测试参考链接 简介 Clipboard API 是一种允许网页读取剪贴板数据或向其中写入数据的API，主要有两个方法： navigator.clipboard.writeText() ：用于将文本写入剪贴板。 navigator.cl
C# 轻量级 ORM 框架 NPoco 的简单应用
目录简介快速入门安装 NuGet 包实体类User数据库类DbFactory增删改查InsertSelectUpdateDelete总结 简介 NPoco 是 PetaPoco 的一个分支，具有一些额外的功能，截至现在 github 星数 839。NPoco 中文资料没多少，我是被博客园群友推荐的，
C#简单配置类及数据绑定
本文实现一个简单的配置类，原理比较简单，适用于一些小型项目。主要实现以下功能：保存配置到json文件、从文件或实例加载配置类的属性值、数据绑定到界面控件。&#xA;一般情况下，项目都会提供配置的设置界面，很少手动更改配置文件，所以选择以json文件保存配置数据。
C#获取Description特性的扩展类
C#中Description特性主要用于枚举和属性，方法比较简单，记录一下以便后期使用。 扩展类DescriptionExtension代码如下： using System; using System.ComponentModel; using System.Reflection; /// &lt;
C#实现软件开机自启动（不需要管理员权限）
[TOC] # 原理简介 本文参考[C#/WPF/WinForm/程序实现软件开机自动启动的两种常用方法](https://blog.csdn.net/weixin_42288432/article/details/120059296)，将里面中的第一种方法做了封装成**AutoStart**类，使
C#爬取动态网页上的信息：B站主页
目录简介获取 HTML 文档解析 HTML 文档测试补充：使用 CSS 选择器参考文章 简介 动态内容网站使用 JavaScript 脚本动态检索和渲染数据，爬取信息时需要模拟浏览器行为，否则获取到的源码基本是空的。 本文使用的爬取步骤如下： 使用 Selenium 获取渲染后的 HTML 文档 使
C#项目管理引用的dll文件
这篇文章主要简单记录一下C#项目的dll文件管理方法，以便后期使用。 设置dll路径 参考C#开发奇技淫巧三：把dll放在不同的目录让你的程序更整洁中间的 方法一：配置App.config文件的privatePath ： &lt;runtime&gt; &lt;assemblyBinding xml
C# 常用特性(Attribute)
使用特性，可以有效地将元数据或声明性信息与代码（程序集、类型、方法、属性等）相关联。 将特性与程序实体相关联后，可以在运行时使用反射这项技术查询特性。&#xA;在 C# 中，通过用方括号 ([]) 将特性名称括起来，并置于应用该特性的实体的声明上方以指定特性。
C#事件总线
事件总线是对发布-订阅模式的一种实现，是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。&#xA;EventBus维护一个事件的字典，发布者、订阅者在事件总线中获取事件实例并执行发布、订阅操作，事件实例负责维护、执行事件处理程序。
C#中使用jieba.NET、WordCloudSharp制作词云图
词云”由美国西北大学新闻学副教授、新媒体专业主任里奇·戈登（Rich Gordon）于2006年最先使用，是通过形成“关键词云层”或“关键词渲染”，对文本中出现频率较高的“关键词”的视觉上的突出。词云图过滤掉大量的文本信息，使浏览者只要一眼扫过文本就可以领略文本的主旨。&#xA;网上大部分文章介绍的是使用P
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native