Векторизация: когда стоит вручную раскатывать петли?

Question

Я хотел бы иметь общее представление о , когда я могу ожидать, что компилятор векторизует al oop, а когда мне стоит развернуть l oop чтобы помочь ему, решает использовать векторизацию.

Я понимаю, что детали очень важны (какой компилятор, какие параметры компиляции, какая архитектура, как мне написать код в l oop, et c) , но мне интересно, есть ли какие-то общие рекомендации для современных компиляторов.

Я буду более конкретным c, приведя пример с простым l oop (код не должен вычислять что-либо полезное):

    double *A,*B; // two arrays
    int delay = something
    [...]


    double numer = 0, denomB = 0, denomA = 0;
    for (int idxA = 0; idxA < Asize; idxA++)
    {
        int idxB = idxA + (Bsize-Asize)/2 + delay;
        numer  += A[idxA] * B[idxB];
        denomA += A[idxA] * A[idxA];
        denomB += B[idxB] * B[idxB];
    }

Могу ли я ожидать, что компилятор векторизует l oop, или было бы полезно переписать код, как показано ниже?

    for ( int idxA = 0; idxA < Asize; idxA+=4 )
    {
        int idxB = idxA + (Bsize-Asize)/2 + delay;
        numer  += A[idxA] * B[idxB];
        denomA += A[idxA] * A[idxA];
        denomB += B[idxB] * B[idxB];

        numer  += A[idxA+1] * B[idxB+1];
        denomA += A[idxA+1] * A[idxA+1];
        denomB += B[idxB+1] * B[idxB+1];

        numer  += A[idxA+2] * B[idxB+2];
        denomA += A[idxA+2] * A[idxA+2];
        denomB += B[idxB+2] * B[idxB+2];

        numer  += A[idxA+3] * B[idxB+3];
        denomA += A[idxA+3] * A[idxA+3];
        denomB += B[idxB+3] * B[idxB+3];
    }

Answer 1

Короткий ответ, как говорили другие: нет общих рекомендаций, если вы не укажете компилятор или целевую архитектуру.

В качестве примечания, как правило, лучше позволить компилятору оптимизировать код в наши дни, потому что он «знает» лучше возможности архитектуры. В некоторых случаях развертывание циклов не будет быстрее.

Если кто-то видит это и ему это нужно, в G CC есть флаг -funroll-loops.