Struct copy using movs rather than SSE on x64

[benaadams]

Assigning a struct to another static variable struct (Memory<T> below)

public struct Memory<T> : IEquatable<Memory<T>>, IEquatable<ReadOnlyMemory<T>>
{
    readonly OwnedMemory<T> _owner;
    readonly int _id;
    readonly int _index;
    readonly int _length;
}

Can generate a movs copy

movs        qword ptr [rdi],qword ptr [rsi]  
movs        qword ptr [rdi],qword ptr [rsi]

Would this be better as a SSE copy?

movdqu      xmm0,xmmword ptr [rsi]  
movdqu      xmmword ptr [rdi],xmm0

As seen in dotnet/corefxlab#1227 (comment)

/cc @mikedn
category:cq
theme:block-opts
skill-level:intermediate
cost:small
impact:medium

[mikedn]

To be clear the entire copy code looks like this:

; rsi loaded with the source address and rdi loaded with the destination address
; copy _owner field, GC write barrier, rsi += 8, rdi += 8
E89FEE0C5F           call     CORINFO_HELP_ASSIGN_BYREF
; copy 16 bytes: _id, _index, _length and 4 padding bytes
48A5                 movsq
48A5                 movsq

If there's no reference field then the generated code is:

; copy 12 bytes
488B08               mov      rcx, qword ptr [rax]
48890A               mov      qword ptr [rdx], rcx
8B4808               mov      ecx, dword ptr [rax+8]
894A08               mov      dword ptr [rdx+8], ecx

If there's no reference field and another int field is added so the struct has 16 bytes then we get this:

; copy 16 bytes
C4E17A6F00           vmovdqu  xmm0, qword ptr [rax]
C4E17A7F02           vmovdqu  qword ptr [rdx], xmm0

If instead of a reference field we use a long field then we get this:

; copy 24 bytes
C4E17A6F00           vmovdqu  xmm0, qword ptr [rax]
C4E17A7F02           vmovdqu  qword ptr [rdx], xmm0
488B4810             mov      rcx, qword ptr [rax+16]
48894A10             mov      qword ptr [rdx+16], rcx

So movs is used when the struct contains reference fields, it complements CORINFO_HELP_ASSIGN_BYREF which uses rsi and rdi just like movs does.

The use of movs may be worth investigation, it doesn't have a good reputation performance wise. For example, on Skylake movs requires 5 uops instead of 1 or 2 needed by movdqu. That said, its association with helper calls and memory accesses might mean that the overhead is too small to matter.

[mikedn]

Some quick testing seems to indicate that when vmovdqu is used the code is ~1.5x faster. It would seem that movs is indeed very slow, especially considering that the test code includes 2 calls.

[huoyaoyuan]

I believe this can be closed now. Struct copying now uses SSE/AVX when appropriate:

https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AXEBDAzgWwB8ABAJgEYBYAKBuIGYACXDKAVzA0YFkZ9oAnjQDeNRuMaxsAEwgA7ADYDGASzlcA+hADucmFADcYiVNmLlazSulHqEyTBnylq9Yw1rpMBLfunnFm4aCjByAOYYABa+EpaM2DHiccCJrlxgqXE2NAC+NHRMZIwAwoyidhK8/FDK+KnG4sQoPAAUVYKMAG7YCmwwAJSMALwAfIz4w109fbY5QA

C.M(Memory)
    L0000: vzeroupper
    L0003: vmovdqu ymm0, [rdx]
    L0007: vmovdqu [rcx+8], ymm0
    L000c: vzeroupper
    L000f: ret

Struct with GC reference may use rep movsx though.