Eu tenho esta função:

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 é muito aleatório: pode ser 9, 84, 20, 95, 111 ... Estou apenas tentando otimizar esse código, não o entendo em detalhes.

Como você pode ver, o interiorfor já foi vetorizado, mas o Intel Advisor sugere o seguinte:

E este é o resultado da análise do Trip Count:

Para mim, isso significa que:

O comprimento do vetor é 8, portanto, 8 flutuadores podem ser processados ao mesmo tempo para cada loop. Isso significaria (se não estiver errado) que os dados estão alinhados em 32 bytes (mesmo que eu expliqueaqui parece que o compilador acha que os dados não estão alinhados).Em média, 2 ciclos são totalmente vetorizados, enquanto 3 ciclos são loops restantes. O mesmo vale para Mín e Máx. Caso contrário, eu não entendo o que; significa.

Agora, minha pergunta é: como posso seguir a primeira sugestão do Intel Advisor? Ele diz para "aumentar o tamanho dos objetos e adicionar iterações para que a contagem de viagens seja um múltiplo de comprimento vetorial" ... Ok, então está simplesmente dizendo "ei, cara, faça issohalfWidth*2+1 (desde que passa de-halfWidth para+halfWidth é um múltiplo de 8) ". Mas como posso fazer isso? Se eu adicionar ciclos aleatórios, isso obviamente quebraria o algoritmo!

A única solução que me veio à mente é adicionar iterações "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;
}

É claro que esse código não funcionaria, pois passa de-halfWidth parahalfWidth, mas é para fazer você entender minha estratégia de iterações "falsas".

Sobre a segunda opção ("Aumente o tamanho de objetos estáticos e automáticos e use uma opção de compilador para adicionar preenchimento de dados") Não tenho idéia de como implementar isso.