петлевая черепица/блокировка для большого плотного матричного умножения

Мне было интересно, может ли кто-нибудь показать мне, как эффективно использовать петлевую черепицу/петлю для большого плотного матричного умножения. Я делаю C = AB с матрицами 1000x1000. Я следил за примером в Wikipedia для черепичной черепицы, но получаю худшие результаты, используя тайлинг, чем без.

http://en.wikipedia.org/wiki/Loop_tiling

http://software.intel.com/en-us/articles/how-to-use-loop-blocking-to-optimize-memory-use-on-32-bit-intel-architecture

Я привел некоторый код ниже. Наивный метод очень медленный из-за недостатков кэша. Метод транспонирования создает транспонирование B в буфере. Этот метод дает самый быстрый результат (умножение матрицы идет как O (n ^ 3) и транспонируется как O (n ^ 2), так что транспонирование не менее 1000 раз быстрее). Метод wiki без блокировки также быстрый и не нуждается в буфере. Метод блокировки медленнее. Еще одна проблема с блокировкой - это несколько раз обновить блок. Это проблема для потоковой передачи /OpenMP, потому что это может привести к условиям гонки, если вы не будете осторожны.

Я должен указать, что с помощью AVX с модификацией метода транспонирования я получаю результаты быстрее, чем Eigen. Однако мои результаты с SSE немного медленнее, чем Eigen, поэтому я думаю, что лучше использовать кеширование.

Редактировать: Я думаю, у меня есть идея, что я хочу делать. Он исходит из алгоритма Кэннона с 1969 года.
http://en.wikipedia.org/wiki/Matrix_multiplication#Communication-avoiding_and_distributed_algorithms

Мне нужно сделать умножение матрицы блоков и каждый поток обрабатывать субматрицу C, а не A и B. Например, если я разделил свои матрицы на четыре блока. Я бы сделал:

[C1 C2     [A1 A2   [B1 B2
 C3 C4]   = A3 A4] x B3 B4]
thread 1: C1 = A1B1 + A2B3
thread 2: C2 = A1B2 + A2B4
thread 3: C3 = A3B1 + A4B3
thread 4: C4 = A3B2 + A4B4

Это устраняет состояние гонки. Мне нужно подумать об этом.

void matrix_mult_naive(const float*A , const float* B, float* C, const int N, const int M, const int K) {
    #pragma omp parallel for
    for(int i=0; i<N; i++) {
        for(int j=0; j<K; j++) {
            float tmp = 0;
            for(int l=0; l<M; l++) {
                tmp += A[M*i+l]*B[K*l+j];
            }
            C[K*i + j] = tmp;
        }
    }
}
void matrix_mult_transpose(const float*A , const float* B, float* C, const int N, const int M, const int K) {
    float *B2 = (float*)aligned_malloc(M*K*sizeof(float), 32);
    transpose(B, B2, M, K, 1);
    #pragma omp parallel for
    for(int i=0; i<N; i++) {
        for(int j=0; j<K; j++) {
            float tmp = 0;
            for(int l=0; l<M; l++) {
                tmp += A[M*i+l]*B2[M*j+l];
            }
            C[K*i + j] = tmp;
        }
    }
    aligned_free(B2);
}

void matrix_mult_wiki(const float*A , const float* B, float* C, const int N, const int M, const int K) {
    for(int i=0; i<N; i++) {
        for(int j=0; j<K; j++) {
            C[K*i + j] = 0;
        }  
    }
    #pragma omp parallel for
    for(int i=0; i<N; i++) {
        for(int l=0; l<M; l++) {
            float a  = A[M*i+l];
            for(int j=0; j<K; j++) {
                C[K*i + j] += a*B[K*l+j];
            }
        }
    }
}

void matrix_mult_wiki_block(const float*A , const float* B, float* C, const int N, const int M, const int K) {
   const int block_size = 8;  //I have tried several different block sizes
   for(int i=0; i<N; i++) {
       for(int j=0; j<K; j++) {
           C[K*i + j] = 0;
       }
    }
    for(int l2=0; l2<M; l2+=block_size) {
        for(int j2=0; j2<K; j2+=block_size) {
        #pragma omp parallel for
            for(int i=0; i<N; i++) {
                for(int l=l2; l<min(M, l2+block_size); l++) {
                    for(int j=j2; j<min(K, j2+block_size); j++) {
                        C[K*i + j] += A[M*i+l]*B[K*l+j];
                    }
                }
            }
        }
    }
}

Ответ 1

Наилучшие результаты я получил это, добавив еще один for цикла, который блокирует над N, а также путем перестановки петель. Я также запустил цикл-инвариантный код, но оптимизатор компилятора должен надеяться сделать это автоматически. Размер блока должен быть размером строки кэша, sizeof(float) на sizeof(float). Это стало на 50% быстрее, чем транспонированный подход.

Если вам нужно выбрать только один из AVX или блокировки, использование расширений AVX (vfmadd###ps и haddps) по-прежнему значительно быстрее. Использование обоих является лучшим и простым для добавления, учитывая, что вы уже тестируете, если размер блока кратен 64/sizeof(float) == 16 floats == два 256-битных регистра AVX.

  • Транспортировка: 1 816 522 клещей
  • Плитка: 892 431 (на 51% быстрее)
  • Плитка AVX +: 230 512 (на 87% быстрее)

Черепица:

void matrix_mult_wiki_block(const float*A , const float* B, float* C,
                            const int N, const int M, const int K) {
    const int block_size = 64 / sizeof(float); // 64 = common cache line size
    for(int i=0; i<N; i++) {
        for(int j=0; j<K; j++) {
            C[K*i + j] = 0;
        }
    }
    for (int i0 = 0; i0 < N; i0 += block_size) {
        int imax = i0 + block_size > N ? N : i0 + block_size;

        for (int j0 = 0; j0 < M; j0 += block_size) {
            int jmax = j0 + block_size > M ? M : j0 + block_size;

            for (int k0 = 0; k0 < K; k0 += block_size) {
                int kmax = k0 + block_size > K ? K : k0 + block_size;

                for (int j1 = j0; j1 < jmax; ++j1) {
                    int sj = M * j1;

                    for (int i1 = i0; i1 < imax; ++i1) {
                        int mi = M * i1;
                        int ki = K * i1;
                        int kij = ki + j1;

                        for (int k1 = k0; k1 < kmax; ++k1) {
                            C[kij] += A[mi + k1] * B[sj + k1];
                        }
                    }
                }
            }
        }
    }
}

Что касается ссылки Cannon, алгоритм SUMMA лучше следовать.


В случае, если кто-либо еще оптимизирует высокие тощие умножения ({~ 1e9 x 50} x {50 x 50}, как я оказался здесь), транспонированный подход почти идентичен по производительности блокированному подходу до n = 18 (плавает). n = 18 - патологический случай (хуже, чем 17 или 19), и я не совсем вижу шаблоны доступа к кэшу, которые вызывают это. Все более крупные n улучшаются с помощью блокированного подхода.