Tengo esta función:

bool interpolate(const Mat &im, float ofsx, float ofsy, float a11, float a12, float a21, float a22, Mat &res)
{         
   bool ret = false;
   // input size (-1 for the safe bilinear interpolation)
   const int width = im.cols-1;
   const int height = im.rows-1;
   // output size
   const int halfWidth  = res.cols >> 1;
   const int halfHeight = res.rows >> 1;
   float *out = res.ptr<float>(0);
   const float *imptr  = im.ptr<float>(0);
   for (int j=-halfHeight; j<=halfHeight; ++j)
   {
      const float rx = ofsx + j * a12;
      const float ry = ofsy + j * a22;
      #pragma omp simd
      for(int i=-halfWidth; i<=halfWidth; ++i, out++)
      {
         float wx = rx + i * a11;
         float wy = ry + i * a21;
         const int x = (int) floor(wx);
         const int y = (int) floor(wy);
         if (x >= 0 && y >= 0 && x < width && y < height)
         {
            // compute weights
            wx -= x; wy -= y;
            int rowOffset = y*im.cols;
            int rowOffset1 = (y+1)*im.cols;
            // bilinear interpolation
            *out =
                (1.0f - wy) * ((1.0f - wx) * imptr[rowOffset+x]   + wx * imptr[rowOffset+x+1]) +
                (       wy) * ((1.0f - wx) * imptr[rowOffset1+x] + wx * imptr[rowOffset1+x+1]);
         } else {
        ,    *out = 0;
            ret =  true; // touching boundary of the input            
         }
      }
   }
   return ret;
}

halfWidth es muy aleatorio: puede ser 9, 84, 20, 95, 111 ... Solo estoy tratando de optimizar este código, no lo entiendo en detalle.

Como puedes ver, lo internofor ya se ha vectorizado, pero Intel Advisor sugiere esto:

Y este es el resultado del análisis de Trip Count:

A mi entender, esto significa que:

La longitud del vector es 8, por lo que significa que se pueden procesar 8 flotadores al mismo tiempo para cada bucle. Esto significaría (si no me equivoco) que los datos están alineados a 32 bytes (aunque como explicoaquí parece que el compilador piensa que los datos no están alineados).En promedio, 2 ciclos están totalmente vectorizados, mientras que 3 ciclos son bucles restantes. Lo mismo vale para Min y Max. De lo contrario no entiendo qué; medio.

Ahora mi pregunta es: ¿cómo puedo seguir la primera sugerencia de Intel Advisor? Dice "aumentar el tamaño de los objetos y agregar iteraciones para que el recuento de viajes sea un múltiplo de la longitud del vector" ... Ok, entonces simplemente dice "hey man haz estohalfWidth*2+1 (ya que va desde-halfWidth a+halfWidth es un múltiplo de 8) ". ¿Pero cómo puedo hacer esto? ¡Si agrego ciclos aleatorios, esto obviamente rompería el algoritmo!

La única solución que se me ocurrió es agregar iteraciones "falsas" como esta:

const int vectorLength = 8;
const int iterations = halfWidth*2+1;
const int remainder = iterations%vectorLength;

for(int i=0; i<loop+length-remainder; i++){
  //this iteration was not supposed to exist, skip it!
  if(i>halfWidth) 
     continue;
}

Por supuesto, este código no funcionaría ya que va desde-halfWidth ahalfWidth, pero es para hacerle entender mi estrategia de iteraciones "falsas".

Acerca de la segunda opción ("Aumentar el tamaño de los objetos estáticos y automáticos, y usar una opción de compilación para agregar relleno de datos") No tengo idea de cómo implementar esto.