c++ - Instrucciones SSE 4 generadas por Visual Studio 2013 Update 2 y Update 3

c++11 visual-studio-2013

Question

Si compilo este código en VS 2013 Update 2 o Update 3: (a continuación viene de Update 3)

#include "stdafx.h"
#include <iostream>
#include <random>

struct Buffer
{
  long* data;
  int   count;
};

#ifndef max
#define max(a,b)            (((a) > (b)) ? (a) : (b))
#endif

long Code(long* data, int count)
{
  long nMaxY = data[0];

  for (int nNode = 0; nNode < count; nNode++)
  {
    nMaxY = max(data[nNode], nMaxY);
  }

  return(nMaxY);
}

int _tmain(int argc, _TCHAR* argv[])
{
#ifdef __AVX__
  static_assert(false, "AVX should be disabled");
#endif
#ifdef __AVX2__
  static_assert(false, "AVX2 should be disabled");
#endif
  static_assert(_M_IX86_FP == 2, "SSE2 instructions should be enabled");
  Buffer buff;
  std::mt19937 engine;
  engine.seed(std::random_device{}());
  std::uniform_int_distribution<int> distribution(0, 100);

  buff.count = 1;
  buff.data = new long[1];
  buff.data[0] = distribution(engine);

  long result = Code(buff.data, buff.count);
  std::cout << result; // ensure result is used
  return result;
}

con las instrucciones SSE2 habilitadas, pero no AVX / AVX2, el compilador en versión genera:

  {
    nMaxY = max(data[nNode], nMaxY);
010612E1  movdqu      xmm0,xmmword ptr [eax]  
010612E5  add         esi,8  
010612E8  lea         eax,[eax+20h]  
010612EB  pmaxsd      xmm1,xmm0  
010612F0  movdqu      xmm0,xmmword ptr [eax-10h]  
010612F5  pmaxsd      xmm2,xmm0  
010612FA  cmp         esi,ebx  
010612FC  jl          Code+41h (010612E1h)  
010612FE  pmaxsd      xmm1,xmm2  
01061303  movdqa      xmm0,xmm1  
01061307  psrldq      xmm0,8  
0106130C  pmaxsd      xmm1,xmm0  
01061311  movdqa      xmm0,xmm1  
01061315  psrldq      xmm0,4  
0106131A  pmaxsd      xmm1,xmm0  
0106131F  movd        eax,xmm1  
01061323  pop         ebx  
  long nMaxY = data[0];

que contiene, entre otras cosas, instrucciones pmaxsd .

pmaxsd instrucciones pmaxsd son instrucciones SSE4_1 o instrucciones AVX, por lo que puedo decir, no instrucciones SSE2.

Intel core2s admite sse3, pero no sse4, y no pmaxsd .

Esto no ocurre en la actualización 1 o la actualización 0 de VS2013.

¿Hay alguna manera de que Visual Studio genere instrucciones SSE2 pero no instrucciones SSE4 como pmaxsd ? ¿Es este un error conocido en la actualización 2/3 de Visual Studio? ¿Hay una solución? ¿Visual Studio ya no es compatible con los procesadores Core2?

Aquí hay una versión más compleja del código anterior que compila (bajo la configuración predeterminada de la versión) el código que bloquea una CPU Core2:

#include "stdafx.h"
#include <iostream>
#include <random>
#include <array>

enum unused_name {
  _nNumPolygons = 10,
};


#ifndef max
#define max(a,b)            (((a) > (b)) ? (a) : (b))
#endif

struct Buffer
{
  std::array<long*, _nNumPolygons> data;
  std::array<int, _nNumPolygons>   count;
};

long Code(Buffer* buff)
{
  long  nMaxY = buff->data[0][0];


  for (int nPoly = 0; nPoly < _nNumPolygons; nPoly++)
  {
    for (int nNode = 0; nNode < buff->count[nPoly]; nNode++)
    {
      nMaxY = max(buff->data[nPoly][nNode], nMaxY);
    }
  }

  return(nMaxY);
}

extern "C" __int32 __isa_available;

int _tmain(int argc, _TCHAR* argv[])
{
#ifdef __AVX__
  static_assert(false, "AVX should be disabled");
#endif
#ifdef __AVX2__
  static_assert(false, "AVX2 should be disabled");
#endif
#if !( defined( _M_AMD64 ) || defined( _M_X64 ) )
  static_assert(_M_IX86_FP == 2, "SSE2 instructions should be enabled");
#endif
  // __isa_available = 1; // to force code to act as if SSE4_2 is not available
  Buffer buff;
  std::mt19937 engine;
  engine.seed(std::random_device{}());
  std::uniform_int_distribution<int> distribution(0, 100);

  for (int i = 0; i < _nNumPolygons; ++i) {
    buff.count[i] = 10;
    buff.data[i] = new long[10];
    for (int k = 0; k < 10; ++k)
    {
      buff.data[i][k] = distribution(engine);
    }
  }

  long result = Code(&buff);
  std::cout << result; // ensure result is used
  return result;
}

Aquí hay un enlace a un error para este problema que alguien más abrió al mismo tiempo que publiqué esta pregunta.

Aquí está el .asm generado:

?Code2@@YAJPAUBuffer@@@Z PROC        ; Code2, COMDAT
; _buff$ = ecx
; File c:/users/adam.nevraumont.corelcorp.000/documents/visual studio 2013/projects/consoleapplication1/consoleapplication1/consoleapplication1.cpp
; Line 22
  push  ebp
  mov  ebp, esp
  sub  esp, 12          ; 0000000cH
  push  ebx
  push  esi
  push  edi
  mov  edi, ecx
; Line 26
  xor  ebx, ebx
  mov  DWORD PTR _buff$1$[ebp], edi
  mov  DWORD PTR _nPoly$1$[ebp], ebx
  mov  eax, DWORD PTR [edi]
  mov  edx, DWORD PTR [eax]
; Line 28
  movd  xmm0, edx
  pshufd  xmm1, xmm0, 0
  movdqa  xmm2, xmm1
  npad  12
$LL6@Code2:
  lea  ecx, DWORD PTR [ebx*4]
  xor  eax, eax
  mov  esi, DWORD PTR [ecx+edi+40]
  mov  DWORD PTR tv443[ebp], ecx
  test  esi, esi
  jle  SHORT $LN5@Code2
  cmp  esi, 8
  jb  SHORT $LN25@Code2
  cmp  DWORD PTR ___isa_available, 2
  jl  SHORT $LN25@Code2
; Line 26
  mov  ebx, DWORD PTR [ecx+edi]
  mov  ecx, esi
  and  ecx, -2147483641      ; 80000007H
  jns  SHORT $LN33@Code2
  dec  ecx
  or  ecx, -8          ; fffffff8H
  inc  ecx
$LN33@Code2:
  mov  edi, esi
  sub  edi, ecx
  npad  8
$LL3@Code2:
; Line 30
  movdqu  xmm0, XMMWORD PTR [ebx+eax*4]
  pmaxsd  xmm1, xmm0
  movdqu  xmm0, XMMWORD PTR [ebx+eax*4+16]
  add  eax, 8
  pmaxsd  xmm2, xmm0
  cmp  eax, edi
  jl  SHORT $LL3@Code2
  mov  ebx, DWORD PTR _nPoly$1$[ebp]
  mov  ecx, DWORD PTR tv443[ebp]
  mov  edi, DWORD PTR _buff$1$[ebp]
$LN25@Code2:
; Line 28
  cmp  eax, esi
  jge  SHORT $LN5@Code2
; Line 26
  mov  edi, DWORD PTR [ecx+edi]
  npad  4
$LL23@Code2:
; Line 30
  cmp  DWORD PTR [edi+eax*4], edx
  cmovg  edx, DWORD PTR [edi+eax*4]
  inc  eax
  cmp  eax, esi
  jl  SHORT $LL23@Code2
$LN5@Code2:
; Line 26
  mov  edi, DWORD PTR _buff$1$[ebp]
  inc  ebx
  mov  DWORD PTR _nPoly$1$[ebp], ebx
  cmp  ebx, 10          ; 0000000aH
  jl  $LL6@Code2
; Line 28
  movd  xmm0, edx
  pshufd  xmm0, xmm0, 0
  pmaxsd  xmm1, xmm0
  pmaxsd  xmm1, xmm2
  movdqa  xmm0, xmm1
  psrldq  xmm0, 8
  pmaxsd  xmm1, xmm0
  movdqa  xmm0, xmm1
  pop  edi
  psrldq  xmm0, 4
  pmaxsd  xmm1, xmm0
  pop  esi
  movd  eax, xmm1
  pop  ebx
; Line 35
  mov  esp, ebp
  pop  ebp
  ret  0

Aquí:

  cmp  esi, 8
  jb  SHORT $LN25@Code2
  cmp  DWORD PTR ___isa_available, 2
  jl  SHORT $LN25@Code2

tenemos la prueba que se bifurca a la versión de "un solo paso" si (A) el bucle tiene una longitud inferior a 8, o (B) no tenemos soporte para SSE3 / SSE4.

La versión de un solo paso es:

$LN5@Code2:
; Line 26
  mov  edi, DWORD PTR _buff$1$[ebp]
  inc  ebx
  mov  DWORD PTR _nPoly$1$[ebp], ebx
  cmp  ebx, 10          ; 0000000aH
  jl  $LL6@Code2

que no tiene instrucciones SSE. Sin embargo, la parte importante es la caída a través. Si eax (el parámetro de iteración) pasa 10 , cae en:

; Line 28
  movd  xmm0, edx
  pshufd  xmm0, xmm0, 0
  pmaxsd  xmm1, xmm0

que es el código que encuentra el máximo de los resultados de la versión de un solo paso y los resultados del SSE4. La tercera instrucción es pmaxsd , que es una instrucción SSE4_1, y no está protegida por __isa_available .

¿Existe una configuración o solución alternativa del compilador que pueda dejar intacta la vectorización automática, mientras no se invocan las instrucciones SSE4_1 en las computadoras habilitadas para Core2 SSE2? ¿Hay un error en mi código que está causando que esto suceda?

Tenga en cuenta que mis intentos de eliminar la naturaleza de doble bucle del bucle parecen hacer que el problema desaparezca.

Answer 1

Este es un comportamiento documentado :

El Auto-Vectorizador también usa el nuevo conjunto de instrucciones SSE4.2 si su computadora lo admite.

Si observa más de cerca el código que genera el compilador, verá que el uso de las instrucciones SSE4.2 depende de una prueba de tiempo de ejecución:

cmp DWORD PTR ___isa_available, 2
jl  SHORT $LN11@Code

El valor 2 aquí aparentemente significa SSE4.2 .

Sin embargo, pude confirmar el error en tu segundo ejemplo. Resulta que la PC Core 2 que estaba usando es compatible con SSE4.1 y la instrucción PMAXSD , así que tuve que probarlo en una PC con una CPU Pentium 4 para obtener la excepción de instrucción ilegal. Debe enviar un informe de error a Microsoft Connect . Asegúrese de mencionar el modelo de CPU Core 2 específico en el que falla el código de ejemplo.

En cuanto a una solución alternativa, solo puedo sugerir cambiar el nivel de optimización para la función afectada. El cambio de la optimización de la velocidad a la optimización del tamaño parece generar casi el mismo código que se usaría solo con las instrucciones del SSE2. Puede usar #pragma optimize para cambiar el nivel de optimización de esta manera:

#pragma optimize("s", on)

long Code(Buffer* buff)
{
     ...
}

#pragma optimize("", on)

Como se documenta en este informe de errores , /d2Qvec-sse2only es un indicador no documentado que funciona en la actualización 3 (y posiblemente en la actualización 2) para evitar que el compilador envíe instrucciones SSE4. Esto puede evitar que algunos bucles se vectoricen, naturalmente. /d2Qvec-sse2only puede dejar de funcionar en cualquier momento (está "sujeto a cambios futuros sin previo aviso"), posiblemente en versiones futuras de VC.

Microsoft afirma que este problema se solucionó en la Actualización 4 y en la Actualización 4 CTP 2 (no para uso de producción).