Почему Clang (с -O3) не векторизует данный цикл?

Question

[floppa322]

В первом примере компилятор успешно векторизовал цикл:

struct Word
{
    int a;
    int b;
    int c;
    int d;
};

size_t N = 1'000'000'000;

Word * words = new Word[N];

for (size_t i = 0; i < N; ++i)
{
        words[i].a = value + 1;
        words[i].b = value + 2;
        words[i].c = value + 3;
        words[i].d = value + 4;
}

Тело цикла:

=> 0x0000000000404c40 <+96>:	movdqu %xmm0,-0x70(%rdi)
   0x0000000000404c45 <+101>:	movdqu %xmm0,-0x60(%rdi)
   0x0000000000404c4a <+106>:	movdqu %xmm0,-0x50(%rdi)
   0x0000000000404c4f <+111>:	movdqu %xmm0,-0x40(%rdi)
   0x0000000000404c54 <+116>:	movdqu %xmm0,-0x30(%rdi)
   0x0000000000404c59 <+121>:	movdqu %xmm0,-0x20(%rdi)
   0x0000000000404c5e <+126>:	movdqu %xmm0,-0x10(%rdi)
   0x0000000000404c63 <+131>:	movdqu %xmm0,(%rdi)
   0x0000000000404c67 <+135>:	add    $0x8,%rsi
   0x0000000000404c6b <+139>:	sub    $0xffffffffffffff80,%rdi
   0x0000000000404c6f <+143>:	cmp    %rsi,%rdx
   0x0000000000404c72 <+146>:	jne    0x404c40 <run()+96>

А вот во втором, где происходит то же самое, но Word разделилась на 2 части и теперь 2 массива - нет:

struct Word
{
    int a;
    int b;
};

struct Half
{
    int c;
    int d;
};

size_t N = 1'000'000'000;

Word * words = new Word[N];
Half * halfs = new Half[N];

for (size_t i = 0; i < N; ++i)
{
        words[i].a = value + 1;
        words[i].b = value + 2;
        halfs[i].c = value + 3;
        halfs[i].d = value + 4;
}

Тело цикла:

=> 0x0000000000404c50 <+96>:	mov    %r9d,(%rsi,%rdx,8)
   0x0000000000404c54 <+100>:	mov    %edi,0x4(%rsi,%rdx,8)
   0x0000000000404c58 <+104>:	mov    %ebx,(%rcx,%rdx,8)
   0x0000000000404c5b <+107>:	mov    %eax,0x4(%rcx,%rdx,8)
   0x0000000000404c5f <+111>:	mov    %r9d,0x8(%rsi,%rdx,8)
   0x0000000000404c64 <+116>:	mov    %edi,0xc(%rsi,%rdx,8)
   0x0000000000404c68 <+120>:	mov    %ebx,0x8(%rcx,%rdx,8)
   0x0000000000404c6c <+124>:	mov    %eax,0xc(%rcx,%rdx,8)
   0x0000000000404c70 <+128>:	add    $0x2,%rdx
   0x0000000000404c74 <+132>:	cmp    %rdx,%r10
   0x0000000000404c77 <+135>:	jne    0x404c50 <run()+96>

Comments

[Евгений Шатунов]

floppa322 , а как он должен это векторизовать если у тебя блоки памяти даже в true sharing не укладываются?
Чтобы операцию можно было векторизовать, у тебя данные довольно строго должны укладываться в 128 бит. Желательно еще и выравнивание на 16 байт сделать. А то на x64 у тебя просто производительность упадет, когда на ARM упадет уже процесс по недопустимой операции на невыравненной памяти.

[floppa322]

Чтобы операцию можно было векторизовать, у тебя данные довольно строго должны укладываться в 128 бит. Желательно еще и выравнивание на 16 байт сделать.

Ну это понятно, просто было немного неясно, почему в 1-м случае он смог это сделать без выравнивания, а во втором нет.
Ниже дали разъяснение

Answer 1

[mayton2019]

В первом варианте был массив четверок int или массив 128 битных элементов.
Во втором случае - два независимых массивка 64х битных элементов которые в памяти
расположены достаточно далеко и для них скорее всего не нашлось такой векторной
команды которая-бы адресовалась к паре 64 + 64.

Comments

[floppa322]

Спасибо

[jcmvbkbc]

Во втором случае - два независимых массивка 64х битных элементов которые в памяти
расположены достаточно далеко

но каждый из массивов по-прежнему непрерывен, просто один регистр xmm теперь накрывает не один элемент массива, а два. gcc -O3 второй пример прекрасно векторизует именно таким способом.
Возможно и clang сможет векторизовать, если один цикл по двум массивам разбить на два отдельных цикла, каждый по своему массиву.

[mayton2019]

Попробуй так

for (size_t i = 0; i < N; ++i)
{
        words[i].a = value + 1;
        words[i].b = value + 2;
}
for (size_t i = 0; i < N; ++i)
        halfs[i].c = value + 3;
        halfs[i].d = value + 4;
}

[floppa322]

mayton2019, не векторизовал :(

[floppa322]

mayton2019, даже так не хочет

Word * words = new (std::align_val_t(16)) Word[N];
Half * halfs = new (std::align_val_t(16)) Half[N];

[mayton2019]

floppa322, а попробуй другой компиллятор. GCC например.

[floppa322]

mayton2019, ну да, gcc сделал это

0x0000555555559e78 <+88>:	movups %xmm1,(%rdx,%rax,1)
 0x0000555555559e7c <+92>:	movups %xmm0,(%rcx,%rax,1)

[mayton2019]

floppa322, красавчик. Бери gcc.

[floppa322]

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