Esta es una continuación de¿Cuál es el parámetro de función equivalente de constexpr? En la pregunta original, estamos tratando de acelerar algún código que realiza cambios y rota bajo Clang y VC ++. Clang y VC ++ no optimizan bien el código porque trata la cantidad de desplazamiento / rotación como variable (es decir, noconstexpr)

Cuando intento parametrizar la cantidad de turno y el tamaño de la palabra, resulta en:

$ g++ -std=c++11 -march=native test.cxx -o test.exe
test.cxx:13:10: error: function template partial specialization is not allowed
uint32_t LeftRotate<uint32_t, unsigned int>(uint32_t v)
         ^         ~~~~~~~~~~~~~~~~~~~~~~~~
test.cxx:21:10: error: function template partial specialization is not allowed
uint64_t LeftRotate<uint64_t, unsigned int>(uint64_t v)
         ^         ~~~~~~~~~~~~~~~~~~~~~~~~
2 errors generated.

Aquí está el programa de prueba. Es un poco más grande de lo necesario para que la gente pueda ver que necesitamos manejar ambosuint32_t yuint64_t (por no mencionaruint8_t, uint16_t y otros tipos).

$ cat test.cxx
#include <iostream>
#include <stdint.h>

template<typename T, unsigned int R>
inline T LeftRotate(unsigned int v)
{
  static const unsigned int THIS_SIZE = sizeof(T)*8;
  static const unsigned int MASK = THIS_SIZE-1;
  return T((v<<R)|(v>>(-R&MASK)));
};

template<uint32_t, unsigned int R>
uint32_t LeftRotate<uint32_t, unsigned int>(uint32_t v)
{
  __asm__ ("roll %1, %0" : "+mq" (v) : "I" ((unsigned char)R));
  return v;
}

#if __x86_64__
template<uint64_t, unsigned int R>
uint64_t LeftRotate<uint64_t, unsigned int>(uint64_t v)
{
  __asm__ ("rolq %1, %0" : "+mq" (v) : "J" ((unsigned char)R));
  return v;
}
#endif

int main(int argc, char* argv[])
{
  std::cout << "Rotated: " << LeftRotate<uint32_t, 2>((uint32_t)argc) << std::endl;
  return 0;
}

He pasado por una serie de iteraciones de mensajes de error dependiendo de cómo intento implementar la rotación. Otros mensajes de error incluyenno function template matches function template specialization.... Utilizandotemplate <> parece producir el más incomprensible.

¿Cómo parametrizo la cantidad de cambio con la esperanza de que Clang y VC ++ optimicen la llamada a la función como se esperaba?