Получение максимальных FLOPS для умножения плотных матриц с помощью Xeon Phi Knights Landing

Question

Недавно я начал работать с компьютером Xeon Phi Knights Landing (KNL) 7250 ( http://ark.intel.com/products/94035/Intel-Xeon-Phi-Processor-7250-16GB-1_40-GHz-68-core),

Это 68 ядер и AVX 512. Базовая частота составляет 1,4 ГГц, а турбо частота составляет 1,6 ГГц. Я не знаю, что такое турбо частота для всех ядер, потому что обычно турбо частота указана только для одного ядра.

Каждое ядро ​​Landings Landing может выполнять две двойные операции FMA шириной 8 за цикл. Поскольку каждая операция FMA представляет собой две операции с плавающей запятой, двойных операций с плавающей запятой за цикл на ядро ​​составляет 32.

Следовательно, максимальная GFLOPS 32*68*1.4 = 3046.4 DP GFLOPS,

Для одного ядра пик FLOPS 32*1.6 = 51.2 DP GLOPS,

Умножение плотных матриц - одна из немногих операций, которая на самом деле способна приблизиться к пиковым флопам. Библиотека Intel MKL обеспечивает оптимизированные функции умножения плотных матриц. На системах Sandy Bridge я получил лучше, чем 97% пика FLOPS с DGEMM. На Haswell я получил около 90% пика, когда проверил несколько лет назад, так что было явно труднее получить пик с FMA в то время. Тем не менее, с Knights Landing и MKL я получаю намного меньше 50% пика.

Я модифицировал dgemm_example.c файл в каталоге примеров MKL для расчета GFLOPS с помощью 2.0*1E-9*n*n*n/time (увидеть ниже).

Я также пытался export KMP_AFFINITY=scatter а также export OMP_NUM_THREADS=68 но это, кажется, не имеет значения. Тем не мение, KMP_AFFINITY=compact значительно медленнее и так OMP_NUM_THREADS=1 таким образом, топология потока по умолчанию, кажется, разбросана в любом случае, и многопоточность работает.

Лучший GFLOPS, который я видел, составляет около 1301 GFLOPS, что составляет около 43% от пика. Для одного потока я видел 38 GFLOPS, что составляет около 74% от пика. Это говорит о том, что MKL DGEMM оптимизирован для AVX512, иначе он будет видеть менее 50%. С другой стороны, для одного потока я думаю, что я должен получить 90% пика.

Память KNL может работать в трех режимах (кэшированный, плоский и гибридный), которые можно установить из BIOS ( http://www.anandtech.com/show/9794/a-few-notes-on-intels-knights-landing-and-mcdram-modes-from-sc15). Я не знаю, в каком режиме находится моя (или, скорее, моя рабочая) система KNL. Может ли это повлиять на DGEMM?

Мой вопрос: почему FLOPS от DGEMM так низки и что я могу сделать, чтобы улучшить их? Возможно я не настроил MKL оптимально (я использую ICC 17.0).

source /opt/intel/mkl/bin/mklvars.sh  intel64
icc -O3 -mkl dgemm_example.c 

Вот код

#define min(x,y) (((x) < (y)) ? (x) : (y))

#include <stdio.h>
#include <stdlib.h>
#include "mkl.h"
#include "omp.h"

int main()
{
    double *A, *B, *C;
    int m, n, k, i, j;
    double alpha, beta;

    printf ("\n This example computes real matrix C=alpha*A*B+beta*C using \n"
            " Intel(R) MKL function dgemm, where A, B, and  C are matrices and \n"
            " alpha and beta are double precision scalars\n\n");

    m = 30000, k = 30000, n = 30000;
    printf (" Initializing data for matrix multiplication C=A*B for matrix \n"
            " A(%ix%i) and matrix B(%ix%i)\n\n", m, k, k, n);
    alpha = 1.0; beta = 0.0;

    printf (" Allocating memory for matrices aligned on 64-byte boundary for better \n"
            " performance \n\n");
    A = (double *)mkl_malloc( m*k*sizeof( double ), 64 );
    B = (double *)mkl_malloc( k*n*sizeof( double ), 64 );
    C = (double *)mkl_malloc( m*n*sizeof( double ), 64 );
    if (A == NULL || B == NULL || C == NULL) {
      printf( "\n ERROR: Can't allocate memory for matrices. Aborting... \n\n");
      mkl_free(A);
      mkl_free(B);
      mkl_free(C);
      return 1;
    }

    printf (" Intializing matrix data \n\n");
    for (i = 0; i < (m*k); i++) {
        A[i] = (double)(i+1);
    }

    for (i = 0; i < (k*n); i++) {
        B[i] = (double)(-i-1);
    }

    for (i = 0; i < (m*n); i++) {
        C[i] = 0.0;
    }

    printf (" Computing matrix product using Intel(R) MKL dgemm function via CBLAS interface \n\n");
    double dtime;
    dtime = -omp_get_wtime();

    cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, 
                m, n, k, alpha, A, k, B, n, beta, C, n);
    dtime += omp_get_wtime();
    printf ("\n Computations completed.\n\n");
    printf ("time %f\n", dtime);
    printf ("GFLOPS %f\n", 2.0*1E-9*m*n*k/dtime);

    printf (" Top left corner of matrix A: \n");
    for (i=0; i<min(m,6); i++) {
      for (j=0; j<min(k,6); j++) {
        printf ("%12.0f", A[j+i*k]);
      }
      printf ("\n");
    }

    printf ("\n Top left corner of matrix B: \n");
    for (i=0; i<min(k,6); i++) {
      for (j=0; j<min(n,6); j++) {
        printf ("%12.0f", B[j+i*n]);
      }
      printf ("\n");
    }

    printf ("\n Top left corner of matrix C: \n");
    for (i=0; i<min(m,6); i++) {
      for (j=0; j<min(n,6); j++) {
        printf ("%12.5G", C[j+i*n]);
      }
      printf ("\n");
    }

    printf ("\n Deallocating memory \n\n");
    mkl_free(A);
    mkl_free(B);
    mkl_free(C);

    printf (" Example completed. \n\n");
    return 0;
}