Xeon Phi 《协处理器高性能编程指南》随书代码整理 part 3

▶ 第二章，几个简单的程序

● 代码，单线程

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/time.h>

 #define SIZE            (1024*1024)
 #define MAXFLOP_ITER    100000000
 #define LOOP_COUNT      128
 #define FLOP_PER_CALC   2

 float fa[SIZE] __attribute__((align()));
 float fb[SIZE] __attribute__((align()));

 double dtime()
 {
     struct timeval mytime;
     gettimeofday(&mytime, (struct timezone*));
     return (double)(mytime.tv_sec + mytime.tv_usec*1.0e-6);
 }

 int main(int argc, char *argv[])
 {
     const float a = 1.1;

     printf("Initializing\r\n");
     for (int i = ; i < SIZE; i++)
     {
         fa[i] = (float)i + 0.1;
         fb[i] = (float)i + 0.2;
     }

     printf("Starting Compute\r\n");
     double time_b, time_e;
     time_b = dtime();
     for (int j = ; j < MAXFLOP_ITER; j++)
     {
         for (int k = ; k < LOOP_COUNT; k++)
             fa[k] = a * fa[k] + fb[k];
     }
     time_e = dtime();

     double gflops = 1.0e-9 * LOOP_COUNT * MAXFLOP_ITER * FLOP_PER_CALC;
     printf("GFlops = %10.3lf, Secs = %10.3lf, GFlops per sec = %10.3lf\r\n", gflops, time_e - time_b, gflops / (time_e - time_b));

     return ;
 }

■ 输出结果

GFlops =     25.600, Secs =      1.464, GFlops per sec =     17.484

● 单核心两线程的 OpenMP（注意总计算量提升了，而不是固定计算量看运行时间减少）

 int main(int argc, char *argv[])
 {
     const float a = 1.1;
     int i, j, k, numthreads;                    // 循环变量放到外边来

     omp_set_num_threads();                     // 运行时设置 OpenMP 参数
     kmp_set_defaults("KMP_AFFINITY=compact");

 #pragma omp parallel
 #pragma omp master
     numthreads = omp_get_num_threads();

     printf("Initializing\r\n");
 #pragma omp parallel for
     for (i = ; i < SIZE; i++)
     {
         fa[i] = (float)i + 0.1;
         fb[i] = (float)i + 0.2;
     }
     printf("Starting Compute on %d threads\r\n", numthreads);
     double time_b, time_e;
     time_b = dtime();
 #pragma omp parallel for private(j, k)
     for (i = ; i < numthreads; i++)
     {
         int offset = i * LOOP_COUNT;
         for (j = ; j < MAXFLOP_ITER; j++)
         {
             for (k = ; k < LOOP_COUNT; k++)
                 fa[k + offset] = a * fa[k + offset] + fb[k + offset];
         }
     }
     time_e = dtime();

     double gflops = 1.0e-9 * numthreads * LOOP_COUNT * MAXFLOP_ITER * FLOP_PER_CALC;
     printf("GFlops = %10.3lf, Secs = %10.3lf, GFlops per sec = %10.3lf\r\n", gflops, time_e - time_b, gflops / (time_e - time_b));

     return ;
 }

■ 输出结果

 GFlops =     51.200, Secs =      1.464, GFlops per sec =     34.968

● 线程数、线程亲缘性调整

 // 替换
     omp_set_num_threads();
     kmp_set_defaults("KMP_AFFINITY=compact");
 // 替换为
     omp_set_num_threads();
     kmp_set_defaults("KMP_AFFINITY=scatter");

■ 输出结果

GFlops =   2867.200, Secs =      1.619, GFlops per sec =   1771.298

● 代码，带宽测试

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/time.h>
 #include <omp.h>

 #define REAL            double
 #define SIZE            (1000*1000*64)
 #define MAXFLOP_ITER    1000
 #define FLOP_PER_CALC   2    

 REAL fa[SIZE] __attribute__((align()));
 REAL fb[SIZE] __attribute__((align()));
 REAL fc[SIZE] __attribute__((align()));

 double dtime()
 {
     struct timeval mytime;
     gettimeofday(&mytime, (struct timezone*));
     return (double)(mytime.tv_sec + mytime.tv_usec*1.0e-6);
 }

 int main(int argc, char *argv[])
 {
     const REAL a = 1.1;
     int i, j;           

     omp_set_num_threads();
     kmp_set_defaults("KMP_AFFINITY=scatter");

     printf("Initializing\r\n");
 #pragma omp parallel for
     for (i = ; i < SIZE; i++)
     {
         fa[i] = (REAL)i + 0.1;
         fb[i] = (REAL)i + 0.2;
     }

 #pragma omp parallel
 #pragma omp master
     printf("Starting BW Test on %d threads\r\n", omp_get_num_threads());
     double time_b, time_e;
     time_b = dtime();
     for (i = ; i < MAXFLOP_ITER; i++)
     {
 #pragma omp parallel for
         for (j = ; j < SIZE; j++)
             fa[j] = fb[j];
     }
     time_e = dtime();
     double gbytes = 1.0e-9 * MAXFLOP_ITER * SIZE * FLOP_PER_CALC * sizeof(REAL);
     printf("Gbytes = %10.3lf, Secs = %10.3lf, GBytes per sec = %10.3lf\r\n", gbytes, time_e - time_b, gbytes / (time_e - time_b));

     return ;
 }

■ 输出结果

Starting BW Test on  threads
Gbytes =   1024.000, Secs =     10.293, GBytes per sec =     99.488

● 代码，offload 模式（注意全局变量和编译选项的调整）

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/time.h>
 #include <omp.h>

 #define SIZE            (1024*512)
 #define MAXFLOP_ITER    100000000
 #define LOOP_COUNT      128
 #define FLOP_PER_CALC   2     

 __declspec (target(mic)) float fa[SIZE] __attribute__((align()));  // 声明 mic 上的存储类型
 __declspec (target(mic)) float fb[SIZE] __attribute__((align()));

 double dtime()
 {
     struct timeval mytime;
     gettimeofday(&mytime, (struct timezone*));
     return (double)(mytime.tv_sec + mytime.tv_usec*1.0e-6);
 }

 int main(int argc, char *argv[])
 {
     const float a = 1.1;
     int i, j, k, numthreads;

     omp_set_num_threads();
     kmp_set_defaults("KMP_AFFINITY=scatter");
 #pragma offload target (mic)// 声明需要使用 mic 的 offload 模式
 #pragma omp parallel
 #pragma omp master
     numthreads = omp_get_num_threads();

     printf("Initializing\r\n");
 #pragma omp parallel for
     for (i = ; i<SIZE; i++)
     {
         fa[i] = (float)i + 0.1;
         fb[i] = (float)i + 0.2;
     }
     printf("Starting Compute on %d threads\r\n", numthreads);
     double time_b, time_e;
     time_b = dtime();
 #pragma offload target (mic)// 声明需要使用 mic 的 offload 模式
 #pragma omp parallel for private(j, k)
     for (i = ; i<numthreads; i++)
     {
         int offset = i * LOOP_COUNT;
         for (j = ; j < MAXFLOP_ITER; j++)
         {
 #pragma vector aligned// 强制向量对齐
             for (k = ; k < LOOP_COUNT; k++)
                 fa[k + offset] = a * fa[k + offset] + fb[k + offset];
         }
     }
     time_e = dtime();

     double gflops = 1.0e-9 * numthreads * LOOP_COUNT * MAXFLOP_ITER * FLOP_PER_CALC;
     printf("GFlops = %10.3lf, Secs = %10.3lf, GFlops per sec = %10.3lf\r\n", gflops, time_e - time_b, gflops / (time_e - time_b));

     return ;
 }

■ 输出结果

Starting Compute on  threads
GFlops =   5734.400, Secs =      2.976, GFlops per sec =   1927.124