F＃NativePtr.stackalloc慢于C＃stackalloc - 包含反编译代码

Question

继续我的F＃性能测试。 有关更多背景，请参阅此处：

结构构造函数中的f＃NativePtr.stackalloc

F＃NativePtr.stackalloc意外的堆栈溢出

现在我已经在F＃中使用堆栈数组了。 但是，由于某种原因，等效的C＃快约50倍。 我在下面列出了ILSpy反编译版本，看起来只有1行真的不同（在stackAlloc里面）。

这里发生了什么？ 未经检查的算术真的对这个巨大的差异负责吗？ 不知道我怎么测试这个？

https://msdn.microsoft.com/en-us/library/a569z7k8.aspx

F＃代码

#nowarn "9"

open Microsoft.FSharp.NativeInterop
open System
open System.Diagnostics    
open System.Runtime.CompilerServices        

[<MethodImpl(MethodImplOptions.NoInlining)>]
let stackAlloc x =
    let mutable ints:nativeptr<byte> = NativePtr.stackalloc x
    ()   

[<EntryPoint>]
let main argv = 
    printfn "%A" argv

    let size = 8192            
    let reps = 10000

    stackAlloc size // JIT
    let clock = Stopwatch()
    clock.Start()
    for i = 1 to reps do            
        stackAlloc size
    clock.Stop()

    let elapsed = clock.Elapsed.TotalMilliseconds
    let description = "F# NativePtr.stackalloc"
    Console.WriteLine("{0} ({1} bytes, {2} reps): {3:#,##0.####}ms", description, size, reps, elapsed)

    Console.ReadKey() |> ignore
    0

C＃代码

using System;
using System.Diagnostics;

namespace CSharpLanguageFeatures
{
    class CSharpStackArray
    {
        static void Main(string[] args)
        {
            int size = 8192;
            int reps = 10000;

            stackAlloc(size); // JIT
            Stopwatch clock = new Stopwatch();
            clock.Start();
            for (int i = 0; i < reps; i++)
            {
                stackAlloc(size);
            }
            clock.Stop();

            string elapsed = clock.Elapsed.TotalMilliseconds.ToString("#,##0.####");
            string description = "C# stackalloc";
            Console.WriteLine("{0} ({1} bytes, {2} reps): {3:#,##0.####}ms", description, size, reps, elapsed);
            Console.ReadKey();
        }

        public unsafe static void stackAlloc(int arraySize)
        {
            byte* pArr = stackalloc byte[arraySize];
        }
    }
}

F＃版本已反编译

using Microsoft.FSharp.Core;
using System;
using System.Diagnostics;
using System.IO;
using System.Runtime.CompilerServices;

[CompilationMapping(SourceConstructFlags.Module)]
public static class FSharpStackArray
{
    [MethodImpl(MethodImplOptions.NoInlining)]
    public unsafe static void stackAlloc(int x)
    {
        IntPtr ints = stackalloc byte[x * sizeof(byte)];
    }

    [EntryPoint]
    public static int main(string[] argv)
    {
        PrintfFormat<FSharpFunc<string[], Unit>, TextWriter, Unit, Unit> format = new PrintfFormat<FSharpFunc<string[], Unit>, TextWriter, Unit, Unit, string[]>("%A");
        PrintfModule.PrintFormatLineToTextWriter<FSharpFunc<string[], Unit>>(Console.Out, format).Invoke(argv);
        FSharpStackArray.stackAlloc(8192);
        Stopwatch clock = new Stopwatch();
        clock.Start();
        for (int i = 1; i < 10001; i++)
        {
            FSharpStackArray.stackAlloc(8192);
        }
        clock.Stop();
        double elapsed = clock.Elapsed.TotalMilliseconds;
        Console.WriteLine("{0} ({1} bytes, {2} reps): {3:#,##0.####}ms", "F# NativePtr.stackalloc", 8192, 10000, elapsed);
        ConsoleKeyInfo consoleKeyInfo = Console.ReadKey();
        return 0;
    }
}

C＃版本已反编译

using System;
using System.Diagnostics;

namespace CSharpLanguageFeatures
{
    internal class CSharpStackArray
    {
        private static void Main(string[] args)
        {
            int size = 8192;
            int reps = 10000;
            CSharpStackArray.stackAlloc(size);
            Stopwatch clock = new Stopwatch();
            clock.Start();
            for (int i = 0; i < reps; i++)
            {
                CSharpStackArray.stackAlloc(size);
            }
            clock.Stop();
            string elapsed = clock.Elapsed.TotalMilliseconds.ToString("#,##0.####");
            string description = "C# stackalloc";
            Console.WriteLine("{0} ({1} bytes, {2} reps): {3:#,##0.####}ms", new object[]
            {
                description,
                size,
                reps,
                elapsed
            });
            Console.ReadKey();
        }

        public unsafe static void stackAlloc(int arraySize)
        {
            IntPtr arg_06_0 = stackalloc byte[checked(unchecked((UIntPtr)arraySize) * 1)];
        }
    }
}

F＃版本IL - 字节分配

.method public static 
    void stackAlloc (
        int32 x
    ) cil managed noinlining 
{
    // Method begins at RVA 0x2050
    // Code size 13 (0xd)
    .maxstack 4
    .locals init (
        [0] native int ints
    )

    IL_0000: nop
    IL_0001: ldarg.0
    IL_0002: sizeof [mscorlib]System.Byte
    IL_0008: mul
    IL_0009: localloc
    IL_000b: stloc.0
    IL_000c: ret
} // end of method FSharpStackArray::stackAlloc

C＃版本IL - 字节分配

.method public hidebysig static 
    void stackAlloc (
        int32 arraySize
    ) cil managed 
{
    // Method begins at RVA 0x2094
    // Code size 8 (0x8)
    .maxstack 8

    IL_0000: ldarg.0
    IL_0001: conv.u
    IL_0002: ldc.i4.1
    IL_0003: mul.ovf.un
    IL_0004: localloc
    IL_0006: pop
    IL_0007: ret
} // end of method CSharpStackArray::stackAlloc   

更新了F＃IL - IntPtr分配

.method public static 
    void stackAlloc (
        int32 x
    ) cil managed noinlining 
{
    // Method begins at RVA 0x2050
    // Code size 13 (0xd)
    .maxstack 4
    .locals init (
        [0] native int ints
    )

    IL_0000: nop
    IL_0001: ldarg.0
    IL_0002: sizeof [mscorlib]System.IntPtr
    IL_0008: mul
    IL_0009: localloc
    IL_000b: stloc.0
    IL_000c: ret
} // end of method FSharpStackArray::stackAlloc

更新了C＃IL - IntPtr分配

.method public hidebysig static 
    void stackAlloc (
        int32 arraySize
    ) cil managed 
{
    // Method begins at RVA 0x2415
    // Code size 13 (0xd)
    .maxstack 8

    IL_0000: ldarg.0
    IL_0001: conv.u
    IL_0002: sizeof [mscorlib]System.IntPtr
    IL_0008: mul.ovf.un
    IL_0009: localloc
    IL_000b: pop
    IL_000c: ret
} // end of method CSharpStackArray::stackAlloc

Answer 1

谢谢大家的帮助。

答案是C＃编译器没有将指针存储为本地。 这是因为永远不需要分配的内存。 缺乏“sizeof”和不同的“mul”给了C＃另一个微小的优势。

F＃汇编程序 - 评论差异

.method public static 
    void stackAlloc (
        int32 x
    ) cil managed noinlining 
{
    // Method begins at RVA 0x2050
    // Code size 13 (0xd)
    .maxstack 4
    .locals init ( //***** Not in C# Version *****//
        [0] native int ints
    )

    IL_0000: nop
    IL_0001: ldarg.0
    IL_0002: sizeof [mscorlib]System.Byte //***** C# just uses "1" *****//
    IL_0008: mul //***** C# uses "mul.ovf.un" *****//
    IL_0009: localloc
    IL_000b: stloc.0 //***** Not in C# Version *****//
    IL_000c: ret
} // end of method FSharpStackArray::stackAlloc

C＃汇编程序 - 评论差异

.method public hidebysig static 
    void stackAlloc (
        int32 arraySize
    ) cil managed 
{
    // Method begins at RVA 0x2094
    // Code size 8 (0x8)
    .maxstack 8

    IL_0000: ldarg.0
    IL_0001: conv.u
    IL_0002: ldc.i4.1 //***** F# uses sizeof [mscorlib]System.Byte *****//
    IL_0003: mul.ovf.un //***** F# uses "mul" *****//
    IL_0004: localloc
    IL_0006: pop
    IL_0007: ret
} // end of method CSharpStackArray::stackAlloc  

这个练习教会了我一些东西：

1. 编译器执行了很多优化。 显然，不同语言中相同的高级代码可能会产生完全不同的机器指令集。
2. 在对dotnet语言进行基准测试时，您可以阅读Intermediate Assembly以了解最新情况。 使用ILSpy进行此操作。
3. 您可以使用ilasm.exe修改和编译Intermediate Assembly。
4. C＃编译器在这里删除不必要的代码做得更好。 设置分配的内存中的每个字节后，性能将与最初预期的非常相似。

最终的F＃代码

#nowarn "9"

open Microsoft.FSharp.NativeInterop
open System
open System.Diagnostics    
open System.Runtime.CompilerServices        

[<MethodImpl(MethodImplOptions.NoInlining)>]
let stackAlloc x =
    let mutable bytes:nativeptr<byte> = NativePtr.stackalloc x
    for i = 0 to (x - 1) do
        NativePtr.set bytes i (byte i)
    ()   

[<EntryPoint>]
let main argv = 
    printfn "%A" argv

    let size = 8192            
    let reps = 10000

    stackAlloc size // JIT
    let clock = Stopwatch()
    clock.Start()
    for i = 1 to reps do            
        stackAlloc size
    clock.Stop()

    let elapsed = clock.Elapsed.TotalMilliseconds
    let description = "F# NativePtr.stackalloc"
    Console.WriteLine("{0} ({1} bytes, {2} reps): {3:#,##0.####}ms", description, size, reps, elapsed)

    Console.ReadKey() |> ignore
    0

最终的C＃代码

using System;
using System.Diagnostics;

namespace CSharpStackArray
{
    class Program
    {
        static void Main(string[] args)
        {
            int size = 8192;
            int reps = 10000;

            stackAlloc(size); // JIT
            Stopwatch clock = new Stopwatch();
            clock.Start();
            for (int i = 0; i < reps; i++)
            {
                stackAlloc(size);
            }
            clock.Stop();

            string elapsed = clock.Elapsed.TotalMilliseconds.ToString("#,##0.####");
            string description = "C# stackalloc";
            Console.WriteLine("{0} ({1} bytes, {2} reps): {3:#,##0.####}ms", description, size, reps, elapsed);
            Console.ReadKey();
        }

        public unsafe static void stackAlloc(int arraySize)
        {
            byte* pArr = stackalloc byte[arraySize];
            for (int i = 0; i < arraySize; i++)
            {
                pArr[i] = (byte)i;
            }
        }
    }
}