Ожидается, что активация структуры без сохранения ее в качестве локальной переменной будет медленнее, чем сохранение ее в качестве локальной переменной? - PullRequest
Новая
       50

Ожидается, что активация структуры без сохранения ее в качестве локальной переменной будет медленнее, чем сохранение ее в качестве локальной переменной?

0 голосов
/ 29 сентября 2018

Я столкнулся с проблемой производительности в .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 CPU, 8 logical and 4 physical cores
.NET Core SDK=2.1.402
  [Host]     : .NET Core 2.1.4 (CoreCLR 4.6.26814.03, CoreFX 4.6.26814.02), 64bit RyuJIT
  DefaultJob : .NET Core 2.1.4 (CoreCLR 4.6.26814.03, CoreFX 4.6.26814.02), 64bit RyuJIT


              Method |     Mean |     Error |    StdDev | Scaled |
-------------------- |---------:|----------:|----------:|-------:|
           Activated | 4.700 ns | 0.0128 ns | 0.0107 ns |   1.00 |
 ActivatedAssignment | 3.331 ns | 0.0278 ns | 0.0260 ns |   0.71 |

Активированная структура (без сохранения локальной переменной) примерно на 30% медленнее .

Для справки, ниже приводится IL, предоставленный ReSharper's IL Viewer: 

.method /*06000002*/ public hidebysig instance valuetype [System.Runtime/*23000001*/]System.Nullable`1/*0100000E*/<unsigned int32> 
  Activated() cil managed 
{
  .custom /*0C00000C*/ instance void [BenchmarkDotNet/*23000002*/]BenchmarkDotNet.Attributes.BenchmarkAttribute/*0100000D*/::.ctor() 
    = (01 00 01 00 54 02 08 42 61 73 65 6c 69 6e 65 01 ) // ....T..Baseline.
    // property bool 'Baseline' = bool(true)
  .maxstack 1
  .locals /*11000001*/ init (
    [0] valuetype StructureActivation.Structure/*02000003*/ V_0
  )

  // [14 31 - 14 59]
  IL_0000: ldc.i4.s     100 // 0x64
  IL_0002: newobj       instance void valuetype [System.Runtime/*23000001*/]System.Nullable`1/*0100000E*/<unsigned int32>/*1B000001*/::.ctor(!0/*unsigned int32*/)/*0A00000F*/
  IL_0007: newobj       instance void StructureActivation.Structure/*02000003*/::.ctor(valuetype [System.Runtime/*23000001*/]System.Nullable`1/*0100000E*/<unsigned int32>)/*06000005*/
  IL_000c: stloc.0      // V_0
  IL_000d: ldloca.s     V_0
  IL_000f: call         instance valuetype [System.Runtime/*23000001*/]System.Nullable`1/*0100000E*/<unsigned int32> StructureActivation.Structure/*02000003*/::get_SomeValue()/*06000006*/
  IL_0014: ret          

} // end of method Program::Activated

.method /*06000003*/ public hidebysig instance valuetype [System.Runtime/*23000001*/]System.Nullable`1/*0100000E*/<unsigned int32> 
  ActivatedAssignment() cil managed 
{
  .custom /*0C00000D*/ instance void [BenchmarkDotNet/*23000002*/]BenchmarkDotNet.Attributes.BenchmarkAttribute/*0100000D*/::.ctor() 
    = (01 00 00 00 )
  .maxstack 2
  .locals /*11000001*/ init (
    [0] valuetype StructureActivation.Structure/*02000003*/ selection
  )

  // [19 4 - 19 39]
  IL_0000: ldloca.s     selection
  IL_0002: ldc.i4.s     100 // 0x64
  IL_0004: newobj       instance void valuetype [System.Runtime/*23000001*/]System.Nullable`1/*0100000E*/<unsigned int32>/*1B000001*/::.ctor(!0/*unsigned int32*/)/*0A00000F*/
  IL_0009: call         instance void StructureActivation.Structure/*02000003*/::.ctor(valuetype [System.Runtime/*23000001*/]System.Nullable`1/*0100000E*/<unsigned int32>)/*06000005*/

  // [20 4 - 20 31]
  IL_000e: ldloca.s     selection
  IL_0010: call         instance valuetype [System.Runtime/*23000001*/]System.Nullable`1/*0100000E*/<unsigned int32> StructureActivation.Structure/*02000003*/::get_SomeValue()/*06000006*/
  IL_0015: ret          

} // end of method Program::ActivatedAssignment

При проверке Activated имеет два newobj, тогда как ActivatedAssignment имеет только один, который можетвнести свой вклад в разницу между двумя критериями.

Мой вопрос: ожидается ли это?Я пытаюсь понять, почему тест с меньшим количеством кода на самом деле медленнее, чем тест с большим количеством кода.Будем весьма благодарны за любые рекомендации и рекомендации, которые помогут мне следовать передовым методам.

1 Ответ

0 голосов
/ 29 сентября 2018

Немного более понятно, что происходит, если вы посмотрите на сборку JITted из ваших методов: 

Program.Activated()
L0000: sub rsp, 0x18
L0004: xor eax, eax              // Initialize Structure to {0}
L0006: mov [rsp+0x10], rax       // Store to stack
L000b: mov eax, 0x64             // Load literal 100
L0010: mov edx, 0x1              // Load literal 1
L0015: xor ecx, ecx              // Initialize SomeValue to {0}
L0017: mov [rsp+0x8], rcx        // Store to stack
L001c: lea rcx, [rsp+0x8]        // Load pointer to SomeValue from stack
L0021: mov [rcx], dl             // Set SomeValue.HasValue to 1
L0023: mov [rcx+0x4], eax        // Set SomeValue.Value to 100
L0026: mov rax, [rsp+0x8]        // Load SomeValue's value from stack
L002b: mov [rsp+0x10], rax       // Store it to a different location on stack
L0030: mov rax, [rsp+0x10]       // Return it from that location
L0035: add rsp, 0x18
L0039: ret

Program.ActivatedAssignment()
L0000: push rax
L0001: xor eax, eax              // Initialize SomeValue to {0}
L0003: mov [rsp], rax            // Store to stack
L0007: mov eax, 0x64             // Load literal 100
L000c: mov edx, 0x1              // Load literal 1
L0011: lea rcx, [rsp]            // Load pointer to SomeValue from stack
L0015: mov [rcx], dl             // Set SomeValue.HasValue to 1
L0017: mov [rcx+0x4], eax        // Set SomeValue.Value to 100
L001a: mov rax, [rsp]            // Return SomeValue
L001e: add rsp, 0x8
L0022: ret

Очевидно, Activated() выполняет больше работы, и поэтому медленнее.То, к чему это сводится, - много перетасовки стека (все ссылки на rsp).Я прокомментировал их как мог, но метод Activated() немного запутан из-за избыточных mov s.ActivatedAssigment() гораздо проще.

В конечном счете, вы фактически не экономите место в стеке, опуская локальную переменную.Переменная должна существовать в какой-то момент независимо от того, даете вы ей имя или нет.Вставленный вами IL-код показывает локальную переменную (они называют ее V_0), которая представляет собой временную переменную, созданную компилятором C #, поскольку вы не создали ее явно.

Если эти два отличия заключаются в том, что версия спеременная temp резервирует только один слот стека (.maxstack 1) и использует его как для Nullable<T>, так и для Structure, следовательно, для перемешивания.В версии с указанной переменной она резервирует 2 слота (.maxstack 2).

По иронии судьбы, в версии с предварительно зарезервированной локальной переменной для selection JIT может устранить внешнюю структуру.и иметь дело только со встроенным Nullable<T>, что делает код чище / быстрее.

Я не уверен, что вы можете извлечь какие-либо рекомендации из этого примера, но я думаю, что достаточно легко увидеть, что компилятор C #является источником разницы перф.JIT достаточно умен, чтобы делать правильные вещи с вашей структурой, но только если он выглядит определенным образом.

...