F# NativePtr.stackalloc медленнее, чем C# stackalloc - декомпилированный код включен
Продолжая тестирование производительности 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
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
Это упражнение научило меня нескольким вещам:
- Компиляторы выполняют много оптимизации. Очевидно, идентичный код высокого уровня на разных языках может привести к совершенно разным наборам машинных инструкций.
- При тестировании языков dotnet вы можете прочитать Промежуточную сборку, чтобы действительно увидеть, что происходит. Используйте ILSpy для этого.
- Вы можете изменить и скомпилировать Промежуточную сборку, используя ilasm.exe.
- компилятор 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;
}
}
}
}