Làm thế nào có thể đạt được hiệu suất cao nhất về mặt lý thuyết của 4 thao tác điểm nổi (độ chính xác kép) trên mỗi chu kỳ trên CPU Intel x86-64 hiện đại?

Theo tôi hiểu, phải mất ba chu kỳ cho một SSE add và năm chu kỳ mulđể hoàn thành trên hầu hết các CPU Intel hiện đại (xem ví dụ 'Bảng hướng dẫn' của Agner Fog ). Do đường ống, người ta có thể nhận được thông lượng một addlần trong mỗi chu kỳ nếu thuật toán có ít nhất ba phép tính tổng độc lập. Vì điều đó đúng với addpdcác addsdphiên bản đóng gói cũng như các thanh ghi vô hướng và các thanh ghi SSE có thể chứa hai doublethông lượng có thể bằng hai flop mỗi chu kỳ.

Hơn nữa, dường như (mặc dù tôi chưa thấy bất kỳ tài liệu phù hợp nào về vấn đề này) addvà mulcó thể được thực thi song song với thông lượng tối đa về mặt lý thuyết là bốn flops mỗi chu kỳ.

Tuy nhiên, tôi không thể sao chép hiệu suất đó bằng chương trình C / C ++ đơn giản. Nỗ lực tốt nhất của tôi dẫn đến khoảng 2,7 flops / chu kỳ. Nếu bất cứ ai cũng có thể đóng góp một chương trình C / C ++ hoặc trình biên dịch chương trình biên dịch đơn giản thể hiện hiệu suất cao nhất sẽ được đánh giá cao.

Nỗ lực của tôi:

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

double stoptime(void) {
   struct timeval t;
   gettimeofday(&t,NULL);
   return (double) t.tv_sec + t.tv_usec/1000000.0;
}

double addmul(double add, double mul, int ops){
   // Need to initialise differently otherwise compiler might optimise away
   double sum1=0.1, sum2=-0.1, sum3=0.2, sum4=-0.2, sum5=0.0;
   double mul1=1.0, mul2= 1.1, mul3=1.2, mul4= 1.3, mul5=1.4;
   int loops=ops/10;          // We have 10 floating point operations inside the loop
   double expected = 5.0*add*loops + (sum1+sum2+sum3+sum4+sum5)
               + pow(mul,loops)*(mul1+mul2+mul3+mul4+mul5);

   for (int i=0; i<loops; i++) {
      mul1*=mul; mul2*=mul; mul3*=mul; mul4*=mul; mul5*=mul;
      sum1+=add; sum2+=add; sum3+=add; sum4+=add; sum5+=add;
   }
   return  sum1+sum2+sum3+sum4+sum5+mul1+mul2+mul3+mul4+mul5 - expected;
}

int main(int argc, char** argv) {
   if (argc != 2) {
      printf("usage: %s <num>\n", argv[0]);
      printf("number of operations: <num> millions\n");
      exit(EXIT_FAILURE);
   }
   int n = atoi(argv[1]) * 1000000;
   if (n<=0)
       n=1000;

   double x = M_PI;
   double y = 1.0 + 1e-8;
   double t = stoptime();
   x = addmul(x, y, n);
   t = stoptime() - t;
   printf("addmul:\t %.3f s, %.3f Gflops, res=%f\n", t, (double)n/t/1e9, x);
   return EXIT_SUCCESS;
}

Tổng hợp với

g++ -O2 -march=native addmul.cpp ; ./a.out 1000

tạo ra đầu ra sau trên Intel Core i5-750, 2,66 GHz.

addmul:  0.270 s, 3.707 Gflops, res=1.326463

Đó là, chỉ khoảng 1,4 flops mỗi chu kỳ. Nhìn vào mã trình biên dịch với g++ -S -O2 -march=native -masm=intel addmul.cppvòng lặp chính có vẻ tối ưu với tôi:

.L4:
inc    eax
mulsd    xmm8, xmm3
mulsd    xmm7, xmm3
mulsd    xmm6, xmm3
mulsd    xmm5, xmm3
mulsd    xmm1, xmm3
addsd    xmm13, xmm2
addsd    xmm12, xmm2
addsd    xmm11, xmm2
addsd    xmm10, xmm2
addsd    xmm9, xmm2
cmp    eax, ebx
jne    .L4

Thay đổi các phiên bản vô hướng với các phiên bản đóng gói ( addpdvà mulpd) sẽ tăng gấp đôi số lượng flop mà không thay đổi thời gian thực hiện và vì vậy tôi chỉ nhận được 2,8 flop mỗi chu kỳ. Có một ví dụ đơn giản mà đạt được bốn flops mỗi chu kỳ?

Chương trình nhỏ xinh của Mysticial; đây là kết quả của tôi (chỉ chạy trong vài giây):

• gcc -O2 -march=nocona: 5,6 Gflops trong số 10,66 Gflops (2,1 flops / chu kỳ)
• cl /O2, openmp đã bị xóa: 10.1 Gflops trong số 10,66 Gflops (3,8 flops / chu kỳ)

Tất cả có vẻ hơi phức tạp, nhưng kết luận của tôi cho đến nay:

• gcc -O2thay đổi thứ tự của các phép toán dấu phẩy động độc lập với mục đích xen kẽ addpdvà mulpdnếu có thể. Áp dụng tương tự cho gcc-4.6.2 -O2 -march=core2.

• gcc -O2 -march=nocona dường như giữ nguyên thứ tự của các phép toán dấu phẩy động như được định nghĩa trong nguồn C ++.

• cl /O2, trình biên dịch 64 bit từ SDK cho Windows 7 sẽ tự động hủy vòng lặp và dường như thử và sắp xếp các hoạt động sao cho các nhóm ba addpdthay thế với ba mulpd(ít nhất là trên hệ thống của tôi và cho chương trình đơn giản của tôi) .

• My Core i5 750 ( kiến trúc Nehalem ) không thích xen kẽ các add và mul và dường như không thể chạy song song cả hai hoạt động. Tuy nhiên, nếu được nhóm thành 3 thì nó đột nhiên hoạt động như ma thuật.

• Các kiến ​​trúc khác (có thể là Sandy Bridge và các công trình khác) dường như có thể thực thi song song add / mul mà không gặp vấn đề gì nếu chúng thay thế trong mã lắp ráp.

• Mặc dù khó thừa nhận, nhưng trên hệ thống của tôi cl /O2thực hiện công việc tốt hơn nhiều ở các hoạt động tối ưu hóa ở mức độ thấp cho hệ thống của tôi và đạt được hiệu suất cao nhất cho ví dụ C ++ nhỏ ở trên. Tôi đo được giữa 1,85-2,01 flops / chu kỳ (đã sử dụng đồng hồ () trong Windows không chính xác. Tôi đoán, cần sử dụng bộ hẹn giờ tốt hơn - cảm ơn Mackie Messer).

• Cách tốt nhất tôi quản lý gcclà lặp lại thủ công hủy đăng ký và sắp xếp các phép cộng và phép nhân trong các nhóm ba. Với g++ -O2 -march=nocona addmul_unroll.cpp tôi nhận được tốt nhất 0.207s, 4.825 Gflopstương ứng với 1,8 flops / chu kỳ mà bây giờ tôi khá hài lòng.

Trong mã C ++, tôi đã thay thế forvòng lặp bằng

   for (int i=0; i<loops/3; i++) {
       mul1*=mul; mul2*=mul; mul3*=mul;
       sum1+=add; sum2+=add; sum3+=add;
       mul4*=mul; mul5*=mul; mul1*=mul;
       sum4+=add; sum5+=add; sum1+=add;

       mul2*=mul; mul3*=mul; mul4*=mul;
       sum2+=add; sum3+=add; sum4+=add;
       mul5*=mul; mul1*=mul; mul2*=mul;
       sum5+=add; sum1+=add; sum2+=add;

       mul3*=mul; mul4*=mul; mul5*=mul;
       sum3+=add; sum4+=add; sum5+=add;
   }

Và lắp ráp bây giờ trông giống như

.L4:
mulsd    xmm8, xmm3
mulsd    xmm7, xmm3
mulsd    xmm6, xmm3
addsd    xmm13, xmm2
addsd    xmm12, xmm2
addsd    xmm11, xmm2
mulsd    xmm5, xmm3
mulsd    xmm1, xmm3
mulsd    xmm8, xmm3
addsd    xmm10, xmm2
addsd    xmm9, xmm2
addsd    xmm13, xmm2
...

Tôi đã thực hiện nhiệm vụ chính xác này trước đây. Nhưng nó chủ yếu để đo mức tiêu thụ năng lượng và nhiệt độ CPU. Đoạn mã sau (khá dài) đạt gần tối ưu trên Core i7 2600K của tôi.

Điều quan trọng cần lưu ý ở đây là số lượng lớn vòng lặp thủ công - không kiểm soát cũng như xen kẽ các bội số và thêm ...

Dự án đầy đủ có thể được tìm thấy trên GitHub của tôi: https://github.com/Mysticial/Flops

Cảnh báo:

Nếu bạn quyết định biên dịch và chạy nó, hãy chú ý đến nhiệt độ CPU của bạn !!!
Hãy chắc chắn rằng bạn không quá nóng. Và đảm bảo điều chỉnh CPU không ảnh hưởng đến kết quả của bạn!

Hơn nữa, tôi không chịu trách nhiệm cho bất kỳ thiệt hại nào có thể xảy ra do chạy mã này.

Ghi chú:

• Mã này được tối ưu hóa cho x64. x86 không có đủ các thanh ghi để biên dịch tốt.
• Mã này đã được thử nghiệm để hoạt động tốt trên Visual Studio 2010/2012 và GCC 4.6.
  ICC 11 (Intel Compiler 11) đáng ngạc nhiên đã gặp sự cố khi biên dịch nó tốt.
• Đây là cho các bộ xử lý trước FMA. Để đạt được FLOPS cao nhất trên bộ xử lý Intel Haswell và AMD Bulldozer (và sau này), sẽ cần các hướng dẫn FMA (Fuse Multiply Add). Đây là vượt quá phạm vi của điểm chuẩn này.

#include <emmintrin.h>
#include <omp.h>
#include <iostream>
using namespace std;

typedef unsigned long long uint64;

double test_dp_mac_SSE(double x,double y,uint64 iterations){
    register __m128d r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;

    //  Generate starting data.
    r0 = _mm_set1_pd(x);
    r1 = _mm_set1_pd(y);

    r8 = _mm_set1_pd(-0.0);

    r2 = _mm_xor_pd(r0,r8);
    r3 = _mm_or_pd(r0,r8);
    r4 = _mm_andnot_pd(r8,r0);
    r5 = _mm_mul_pd(r1,_mm_set1_pd(0.37796447300922722721));
    r6 = _mm_mul_pd(r1,_mm_set1_pd(0.24253562503633297352));
    r7 = _mm_mul_pd(r1,_mm_set1_pd(4.1231056256176605498));
    r8 = _mm_add_pd(r0,_mm_set1_pd(0.37796447300922722721));
    r9 = _mm_add_pd(r1,_mm_set1_pd(0.24253562503633297352));
    rA = _mm_sub_pd(r0,_mm_set1_pd(4.1231056256176605498));
    rB = _mm_sub_pd(r1,_mm_set1_pd(4.1231056256176605498));

    rC = _mm_set1_pd(1.4142135623730950488);
    rD = _mm_set1_pd(1.7320508075688772935);
    rE = _mm_set1_pd(0.57735026918962576451);
    rF = _mm_set1_pd(0.70710678118654752440);

    uint64 iMASK = 0x800fffffffffffffull;
    __m128d MASK = _mm_set1_pd(*(double*)&iMASK);
    __m128d vONE = _mm_set1_pd(1.0);

    uint64 c = 0;
    while (c < iterations){
        size_t i = 0;
        while (i < 1000){
            //  Here's the meat - the part that really matters.

            r0 = _mm_mul_pd(r0,rC);
            r1 = _mm_add_pd(r1,rD);
            r2 = _mm_mul_pd(r2,rE);
            r3 = _mm_sub_pd(r3,rF);
            r4 = _mm_mul_pd(r4,rC);
            r5 = _mm_add_pd(r5,rD);
            r6 = _mm_mul_pd(r6,rE);
            r7 = _mm_sub_pd(r7,rF);
            r8 = _mm_mul_pd(r8,rC);
            r9 = _mm_add_pd(r9,rD);
            rA = _mm_mul_pd(rA,rE);
            rB = _mm_sub_pd(rB,rF);

            r0 = _mm_add_pd(r0,rF);
            r1 = _mm_mul_pd(r1,rE);
            r2 = _mm_sub_pd(r2,rD);
            r3 = _mm_mul_pd(r3,rC);
            r4 = _mm_add_pd(r4,rF);
            r5 = _mm_mul_pd(r5,rE);
            r6 = _mm_sub_pd(r6,rD);
            r7 = _mm_mul_pd(r7,rC);
            r8 = _mm_add_pd(r8,rF);
            r9 = _mm_mul_pd(r9,rE);
            rA = _mm_sub_pd(rA,rD);
            rB = _mm_mul_pd(rB,rC);

            r0 = _mm_mul_pd(r0,rC);
            r1 = _mm_add_pd(r1,rD);
            r2 = _mm_mul_pd(r2,rE);
            r3 = _mm_sub_pd(r3,rF);
            r4 = _mm_mul_pd(r4,rC);
            r5 = _mm_add_pd(r5,rD);
            r6 = _mm_mul_pd(r6,rE);
            r7 = _mm_sub_pd(r7,rF);
            r8 = _mm_mul_pd(r8,rC);
            r9 = _mm_add_pd(r9,rD);
            rA = _mm_mul_pd(rA,rE);
            rB = _mm_sub_pd(rB,rF);

            r0 = _mm_add_pd(r0,rF);
            r1 = _mm_mul_pd(r1,rE);
            r2 = _mm_sub_pd(r2,rD);
            r3 = _mm_mul_pd(r3,rC);
            r4 = _mm_add_pd(r4,rF);
            r5 = _mm_mul_pd(r5,rE);
            r6 = _mm_sub_pd(r6,rD);
            r7 = _mm_mul_pd(r7,rC);
            r8 = _mm_add_pd(r8,rF);
            r9 = _mm_mul_pd(r9,rE);
            rA = _mm_sub_pd(rA,rD);
            rB = _mm_mul_pd(rB,rC);

            i++;
        }

        //  Need to renormalize to prevent denormal/overflow.
        r0 = _mm_and_pd(r0,MASK);
        r1 = _mm_and_pd(r1,MASK);
        r2 = _mm_and_pd(r2,MASK);
        r3 = _mm_and_pd(r3,MASK);
        r4 = _mm_and_pd(r4,MASK);
        r5 = _mm_and_pd(r5,MASK);
        r6 = _mm_and_pd(r6,MASK);
        r7 = _mm_and_pd(r7,MASK);
        r8 = _mm_and_pd(r8,MASK);
        r9 = _mm_and_pd(r9,MASK);
        rA = _mm_and_pd(rA,MASK);
        rB = _mm_and_pd(rB,MASK);
        r0 = _mm_or_pd(r0,vONE);
        r1 = _mm_or_pd(r1,vONE);
        r2 = _mm_or_pd(r2,vONE);
        r3 = _mm_or_pd(r3,vONE);
        r4 = _mm_or_pd(r4,vONE);
        r5 = _mm_or_pd(r5,vONE);
        r6 = _mm_or_pd(r6,vONE);
        r7 = _mm_or_pd(r7,vONE);
        r8 = _mm_or_pd(r8,vONE);
        r9 = _mm_or_pd(r9,vONE);
        rA = _mm_or_pd(rA,vONE);
        rB = _mm_or_pd(rB,vONE);

        c++;
    }

    r0 = _mm_add_pd(r0,r1);
    r2 = _mm_add_pd(r2,r3);
    r4 = _mm_add_pd(r4,r5);
    r6 = _mm_add_pd(r6,r7);
    r8 = _mm_add_pd(r8,r9);
    rA = _mm_add_pd(rA,rB);

    r0 = _mm_add_pd(r0,r2);
    r4 = _mm_add_pd(r4,r6);
    r8 = _mm_add_pd(r8,rA);

    r0 = _mm_add_pd(r0,r4);
    r0 = _mm_add_pd(r0,r8);


    //  Prevent Dead Code Elimination
    double out = 0;
    __m128d temp = r0;
    out += ((double*)&temp)[0];
    out += ((double*)&temp)[1];

    return out;
}

void test_dp_mac_SSE(int tds,uint64 iterations){

    double *sum = (double*)malloc(tds * sizeof(double));
    double start = omp_get_wtime();

#pragma omp parallel num_threads(tds)
    {
        double ret = test_dp_mac_SSE(1.1,2.1,iterations);
        sum[omp_get_thread_num()] = ret;
    }

    double secs = omp_get_wtime() - start;
    uint64 ops = 48 * 1000 * iterations * tds * 2;
    cout << "Seconds = " << secs << endl;
    cout << "FP Ops  = " << ops << endl;
    cout << "FLOPs   = " << ops / secs << endl;

    double out = 0;
    int c = 0;
    while (c < tds){
        out += sum[c++];
    }

    cout << "sum = " << out << endl;
    cout << endl;

    free(sum);
}

int main(){
    //  (threads, iterations)
    test_dp_mac_SSE(8,10000000);

    system("pause");
}

Đầu ra (1 luồng, 10000000 lần lặp) - Được biên dịch với Visual Studio 2010 SP1 - x64 Phát hành:

Seconds = 55.5104
FP Ops  = 960000000000
FLOPs   = 1.7294e+010
sum = 2.22652

Máy là Core i7 2600K @ 4,4 GHz. Đỉnh SSE lý thuyết là 4 flops * 4,4 GHz = 17,6 GFlops . Mã này đạt được 17,3 GFlops - không tệ.

Đầu ra (8 luồng, 10000000 lần lặp) - Được biên dịch với Visual Studio 2010 SP1 - x64 Phát hành:

Seconds = 117.202
FP Ops  = 7680000000000
FLOPs   = 6.55279e+010
sum = 17.8122

Đỉnh SSE lý thuyết là 4 flops * 4 lõi * 4,4 GHz = 70,4 GFlops. Thực tế là 65,5 GFlops .

Hãy tiến lên một bước nữa. AVX ...

#include <immintrin.h>
#include <omp.h>
#include <iostream>
using namespace std;

typedef unsigned long long uint64;

double test_dp_mac_AVX(double x,double y,uint64 iterations){
    register __m256d r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;

    //  Generate starting data.
    r0 = _mm256_set1_pd(x);
    r1 = _mm256_set1_pd(y);

    r8 = _mm256_set1_pd(-0.0);

    r2 = _mm256_xor_pd(r0,r8);
    r3 = _mm256_or_pd(r0,r8);
    r4 = _mm256_andnot_pd(r8,r0);
    r5 = _mm256_mul_pd(r1,_mm256_set1_pd(0.37796447300922722721));
    r6 = _mm256_mul_pd(r1,_mm256_set1_pd(0.24253562503633297352));
    r7 = _mm256_mul_pd(r1,_mm256_set1_pd(4.1231056256176605498));
    r8 = _mm256_add_pd(r0,_mm256_set1_pd(0.37796447300922722721));
    r9 = _mm256_add_pd(r1,_mm256_set1_pd(0.24253562503633297352));
    rA = _mm256_sub_pd(r0,_mm256_set1_pd(4.1231056256176605498));
    rB = _mm256_sub_pd(r1,_mm256_set1_pd(4.1231056256176605498));

    rC = _mm256_set1_pd(1.4142135623730950488);
    rD = _mm256_set1_pd(1.7320508075688772935);
    rE = _mm256_set1_pd(0.57735026918962576451);
    rF = _mm256_set1_pd(0.70710678118654752440);

    uint64 iMASK = 0x800fffffffffffffull;
    __m256d MASK = _mm256_set1_pd(*(double*)&iMASK);
    __m256d vONE = _mm256_set1_pd(1.0);

    uint64 c = 0;
    while (c < iterations){
        size_t i = 0;
        while (i < 1000){
            //  Here's the meat - the part that really matters.

            r0 = _mm256_mul_pd(r0,rC);
            r1 = _mm256_add_pd(r1,rD);
            r2 = _mm256_mul_pd(r2,rE);
            r3 = _mm256_sub_pd(r3,rF);
            r4 = _mm256_mul_pd(r4,rC);
            r5 = _mm256_add_pd(r5,rD);
            r6 = _mm256_mul_pd(r6,rE);
            r7 = _mm256_sub_pd(r7,rF);
            r8 = _mm256_mul_pd(r8,rC);
            r9 = _mm256_add_pd(r9,rD);
            rA = _mm256_mul_pd(rA,rE);
            rB = _mm256_sub_pd(rB,rF);

            r0 = _mm256_add_pd(r0,rF);
            r1 = _mm256_mul_pd(r1,rE);
            r2 = _mm256_sub_pd(r2,rD);
            r3 = _mm256_mul_pd(r3,rC);
            r4 = _mm256_add_pd(r4,rF);
            r5 = _mm256_mul_pd(r5,rE);
            r6 = _mm256_sub_pd(r6,rD);
            r7 = _mm256_mul_pd(r7,rC);
            r8 = _mm256_add_pd(r8,rF);
            r9 = _mm256_mul_pd(r9,rE);
            rA = _mm256_sub_pd(rA,rD);
            rB = _mm256_mul_pd(rB,rC);

            r0 = _mm256_mul_pd(r0,rC);
            r1 = _mm256_add_pd(r1,rD);
            r2 = _mm256_mul_pd(r2,rE);
            r3 = _mm256_sub_pd(r3,rF);
            r4 = _mm256_mul_pd(r4,rC);
            r5 = _mm256_add_pd(r5,rD);
            r6 = _mm256_mul_pd(r6,rE);
            r7 = _mm256_sub_pd(r7,rF);
            r8 = _mm256_mul_pd(r8,rC);
            r9 = _mm256_add_pd(r9,rD);
            rA = _mm256_mul_pd(rA,rE);
            rB = _mm256_sub_pd(rB,rF);

            r0 = _mm256_add_pd(r0,rF);
            r1 = _mm256_mul_pd(r1,rE);
            r2 = _mm256_sub_pd(r2,rD);
            r3 = _mm256_mul_pd(r3,rC);
            r4 = _mm256_add_pd(r4,rF);
            r5 = _mm256_mul_pd(r5,rE);
            r6 = _mm256_sub_pd(r6,rD);
            r7 = _mm256_mul_pd(r7,rC);
            r8 = _mm256_add_pd(r8,rF);
            r9 = _mm256_mul_pd(r9,rE);
            rA = _mm256_sub_pd(rA,rD);
            rB = _mm256_mul_pd(rB,rC);

            i++;
        }

        //  Need to renormalize to prevent denormal/overflow.
        r0 = _mm256_and_pd(r0,MASK);
        r1 = _mm256_and_pd(r1,MASK);
        r2 = _mm256_and_pd(r2,MASK);
        r3 = _mm256_and_pd(r3,MASK);
        r4 = _mm256_and_pd(r4,MASK);
        r5 = _mm256_and_pd(r5,MASK);
        r6 = _mm256_and_pd(r6,MASK);
        r7 = _mm256_and_pd(r7,MASK);
        r8 = _mm256_and_pd(r8,MASK);
        r9 = _mm256_and_pd(r9,MASK);
        rA = _mm256_and_pd(rA,MASK);
        rB = _mm256_and_pd(rB,MASK);
        r0 = _mm256_or_pd(r0,vONE);
        r1 = _mm256_or_pd(r1,vONE);
        r2 = _mm256_or_pd(r2,vONE);
        r3 = _mm256_or_pd(r3,vONE);
        r4 = _mm256_or_pd(r4,vONE);
        r5 = _mm256_or_pd(r5,vONE);
        r6 = _mm256_or_pd(r6,vONE);
        r7 = _mm256_or_pd(r7,vONE);
        r8 = _mm256_or_pd(r8,vONE);
        r9 = _mm256_or_pd(r9,vONE);
        rA = _mm256_or_pd(rA,vONE);
        rB = _mm256_or_pd(rB,vONE);

        c++;
    }

    r0 = _mm256_add_pd(r0,r1);
    r2 = _mm256_add_pd(r2,r3);
    r4 = _mm256_add_pd(r4,r5);
    r6 = _mm256_add_pd(r6,r7);
    r8 = _mm256_add_pd(r8,r9);
    rA = _mm256_add_pd(rA,rB);

    r0 = _mm256_add_pd(r0,r2);
    r4 = _mm256_add_pd(r4,r6);
    r8 = _mm256_add_pd(r8,rA);

    r0 = _mm256_add_pd(r0,r4);
    r0 = _mm256_add_pd(r0,r8);

    //  Prevent Dead Code Elimination
    double out = 0;
    __m256d temp = r0;
    out += ((double*)&temp)[0];
    out += ((double*)&temp)[1];
    out += ((double*)&temp)[2];
    out += ((double*)&temp)[3];

    return out;
}

void test_dp_mac_AVX(int tds,uint64 iterations){

    double *sum = (double*)malloc(tds * sizeof(double));
    double start = omp_get_wtime();

#pragma omp parallel num_threads(tds)
    {
        double ret = test_dp_mac_AVX(1.1,2.1,iterations);
        sum[omp_get_thread_num()] = ret;
    }

    double secs = omp_get_wtime() - start;
    uint64 ops = 48 * 1000 * iterations * tds * 4;
    cout << "Seconds = " << secs << endl;
    cout << "FP Ops  = " << ops << endl;
    cout << "FLOPs   = " << ops / secs << endl;

    double out = 0;
    int c = 0;
    while (c < tds){
        out += sum[c++];
    }

    cout << "sum = " << out << endl;
    cout << endl;

    free(sum);
}

int main(){
    //  (threads, iterations)
    test_dp_mac_AVX(8,10000000);

    system("pause");
}

Đầu ra (1 luồng, 10000000 lần lặp) - Được biên dịch với Visual Studio 2010 SP1 - x64 Phát hành:

Seconds = 57.4679
FP Ops  = 1920000000000
FLOPs   = 3.34099e+010
sum = 4.45305

Đỉnh AVX lý thuyết là 8 flops * 4,4 GHz = 35,2 GFlops . Thực tế là 33,4 GF .

Đầu ra (8 luồng, 10000000 lần lặp) - Được biên dịch với Visual Studio 2010 SP1 - x64 Phát hành:

Seconds = 111.119
FP Ops  = 15360000000000
FLOPs   = 1.3823e+011
sum = 35.6244

Đỉnh AVX lý thuyết là 8 flops * 4 lõi * 4,4 GHz = 140,8 GFlops. Thực tế là 138,2 GFlops .

Bây giờ cho một số giải thích:

Phần quan trọng về hiệu năng rõ ràng là 48 lệnh bên trong vòng lặp bên trong. Bạn sẽ nhận thấy rằng nó được chia thành 4 khối 12 hướng dẫn mỗi khối. Mỗi khối trong số 12 khối lệnh này hoàn toàn độc lập với nhau - và thực hiện trung bình 6 chu kỳ để thực hiện.

Vì vậy, có 12 hướng dẫn và 6 chu kỳ giữa các vấn đề sử dụng. Độ trễ của phép nhân là 5 chu kỳ, vì vậy nó chỉ đủ để tránh các quầy hàng có độ trễ.

Bước chuẩn hóa là cần thiết để giữ cho dữ liệu không bị tràn / tràn. Điều này là cần thiết vì mã không làm gì sẽ từ từ tăng / giảm độ lớn của dữ liệu.

Vì vậy, thực sự có thể làm tốt hơn thế này nếu bạn chỉ sử dụng tất cả các số không và thoát khỏi bước chuẩn hóa. Tuy nhiên, vì tôi đã viết điểm chuẩn để đo mức tiêu thụ năng lượng và nhiệt độ, tôi phải đảm bảo các flop là trên dữ liệu "thực", chứ không phải số không - vì các đơn vị thực thi có thể xử lý trường hợp đặc biệt cho các số không sử dụng ít năng lượng hơn và sản xuất ít nhiệt hơn.

Kết quả khác:

• Intel Core i7 920 @ 3.5 GHz
• Windows 7 Ultimate x64
• Visual Studio 2010 SP1 - Phát hành x64

Chủ đề: 1

Seconds = 72.1116
FP Ops  = 960000000000
FLOPs   = 1.33127e+010
sum = 2.22652

Đỉnh SSE lý thuyết: 4 flops * 3,5 GHz = 14,0 GFlops . Thực tế là 13,3 GF .

Chủ đề: 8

Seconds = 149.576
FP Ops  = 7680000000000
FLOPs   = 5.13452e+010
sum = 17.8122

Đỉnh SSE lý thuyết: 4 flops * 4 lõi * 3.5 GHz = 56.0 GFlops . Thực tế là 51,3 GF .

Temps bộ xử lý của tôi đạt 76C trên đường chạy đa luồng! Nếu bạn chạy những thứ này, hãy chắc chắn rằng kết quả không bị ảnh hưởng bởi điều tiết CPU.

• 2 x Intel Xeon X5482 Harpertown @ 3,2 GHz
• Ubuntu Linux 10 x64
• GCC 4.5.2 x64 - (-O2 -msse3 -fopenmp)

Chủ đề: 1

Seconds = 78.3357
FP Ops  = 960000000000
FLOPs   = 1.22549e+10
sum = 2.22652

Đỉnh SSE lý thuyết: 4 flops * 3,2 GHz = 12,8 GFlops . Thực tế là 12,3 GF .

Chủ đề: 8

Seconds = 78.4733
FP Ops  = 7680000000000
FLOPs   = 9.78676e+10
sum = 17.8122

Đỉnh SSE lý thuyết: 4 flops * 8 lõi * 3,2 GHz = 102,4 GFlops . Thực tế là 97,9 GFlops .

Có một điểm trong kiến ​​trúc Intel mà mọi người thường quên, các cổng điều phối được chia sẻ giữa Int và FP / SIMD. Điều này có nghĩa là bạn sẽ chỉ nhận được một số lượng nhất định của FP / SIMD trước khi logic vòng lặp sẽ tạo ra các bong bóng trong luồng điểm nổi của bạn. Mystical nhận được nhiều flops hơn từ mã của mình, bởi vì anh ta đã sử dụng những bước dài hơn trong vòng lặp không được kiểm soát của mình.

Nếu bạn nhìn vào kiến ​​trúc Nehalem / Sandy Bridge tại đây http://www.realworldtech.com/page.cfm?ArticleID=RWT091810191937&p=6 thì rõ ràng điều gì sẽ xảy ra.

Ngược lại, sẽ dễ dàng đạt được hiệu suất cao nhất trên AMD (Bulldozer) vì các ống INT và FP / SIMD có các cổng phát hành riêng biệt với bộ lập lịch riêng.

Đây chỉ là lý thuyết vì tôi không có bộ xử lý nào để kiểm tra.

Chi nhánh chắc chắn có thể giữ cho bạn khỏi duy trì hiệu suất lý thuyết đỉnh cao. Bạn có thấy sự khác biệt nếu bạn thực hiện một số thao tác hủy vòng lặp không? Ví dụ: nếu bạn đặt số lần lặp gấp 5 hoặc 10 lần cho mỗi vòng lặp:

for(int i=0; i<loops/5; i++) {
      mul1*=mul; mul2*=mul; mul3*=mul; mul4*=mul; mul5*=mul;
      sum1+=add; sum2+=add; sum3+=add; sum4+=add; sum5+=add;
      mul1*=mul; mul2*=mul; mul3*=mul; mul4*=mul; mul5*=mul;
      sum1+=add; sum2+=add; sum3+=add; sum4+=add; sum5+=add;
      mul1*=mul; mul2*=mul; mul3*=mul; mul4*=mul; mul5*=mul;
      sum1+=add; sum2+=add; sum3+=add; sum4+=add; sum5+=add;
      mul1*=mul; mul2*=mul; mul3*=mul; mul4*=mul; mul5*=mul;
      sum1+=add; sum2+=add; sum3+=add; sum4+=add; sum5+=add;
      mul1*=mul; mul2*=mul; mul3*=mul; mul4*=mul; mul5*=mul;
      sum1+=add; sum2+=add; sum3+=add; sum4+=add; sum5+=add;
   }

Sử dụng Intels icc Phiên bản 11.1 trên Bộ đôi Intel Core 2 2.4GHz tôi nhận được

Macintosh:~ mackie$ icc -O3 -mssse3 -oaddmul addmul.cc && ./addmul 1000
addmul:  0.105 s, 9.525 Gflops, res=0.000000
Macintosh:~ mackie$ icc -v
Version 11.1 

Điều đó rất gần với 9,6 Gflops lý tưởng.

BIÊN TẬP:

Rất tiếc, nhìn vào mã lắp ráp, có vẻ như icc không chỉ véc tơ cho phép nhân mà còn kéo các phép cộng ra khỏi vòng lặp. Buộc một ngữ nghĩa fp chặt chẽ hơn, mã không còn được vector hóa:

Macintosh:~ mackie$ icc -O3 -mssse3 -oaddmul addmul.cc -fp-model precise && ./addmul 1000
addmul:  0.516 s, 1.938 Gflops, res=1.326463

EDIT2:

Như yêu cầu:

Macintosh:~ mackie$ clang -O3 -mssse3 -oaddmul addmul.cc && ./addmul 1000
addmul:  0.209 s, 4.786 Gflops, res=1.326463
Macintosh:~ mackie$ clang -v
Apple clang version 3.0 (tags/Apple/clang-211.10.1) (based on LLVM 3.0svn)
Target: x86_64-apple-darwin11.2.0
Thread model: posix

Vòng lặp bên trong của mã clang trông như thế này:

        .align  4, 0x90
LBB2_4:                                 ## =>This Inner Loop Header: Depth=1
        addsd   %xmm2, %xmm3
        addsd   %xmm2, %xmm14
        addsd   %xmm2, %xmm5
        addsd   %xmm2, %xmm1
        addsd   %xmm2, %xmm4
        mulsd   %xmm2, %xmm0
        mulsd   %xmm2, %xmm6
        mulsd   %xmm2, %xmm7
        mulsd   %xmm2, %xmm11
        mulsd   %xmm2, %xmm13
        incl    %eax
        cmpl    %r14d, %eax
        jl      LBB2_4

EDIT3:

Cuối cùng, hai gợi ý: Thứ nhất, nếu bạn thích loại điểm chuẩn này, hãy cân nhắc sử dụng rdtschướng dẫn istead của gettimeofday(2). Nó chính xác hơn nhiều và cung cấp thời gian theo chu kỳ, thường là điều bạn quan tâm. Đối với gcc và bạn bè, bạn có thể định nghĩa nó như thế này:

#include <stdint.h>

static __inline__ uint64_t rdtsc(void)
{
        uint64_t rval;
        __asm__ volatile ("rdtsc" : "=A" (rval));
        return rval;
}

Thứ hai, bạn nên chạy chương trình điểm chuẩn của mình nhiều lần và chỉ sử dụng hiệu suất tốt nhất . Trong các hệ điều hành hiện đại, nhiều điều xảy ra song song, cpu có thể ở chế độ tiết kiệm năng lượng tần số thấp, v.v. Chạy chương trình nhiều lần sẽ cho bạn kết quả gần với trường hợp lý tưởng hơn.