C ช้ากว่าฟอร์แทรนในการยิงบรรทัดฐานสเปกตรัม (ใช้ gcc, intel และคอมไพเลอร์อื่น ๆ ) หรือไม่

ข้อสรุปที่นี่:

คอมไพเลอร์ของ Fortran นั้นดีกว่ามากแค่ไหน?

คือ gfortran และ gcc นั้นรวดเร็วสำหรับโค้ดง่าย ๆ ฉันอยากลองอะไรที่ซับซ้อนกว่านี้ ฉันเอาตัวอย่างการยิงบรรทัดฐานสเปกตรัม ฉันก่อนการคำนวณเมทริกซ์ 2 มิติ A (:, :) แล้วคำนวณเกณฑ์ปกติ (วิธีแก้ปัญหานี้ไม่ได้รับอนุญาตในการยิงที่ฉันคิดว่า) ฉันได้ใช้ Fortran และรุ่น C นี่คือรหัส:

https://github.com/certik/spectral_norm

รุ่น gfortran ที่เร็วที่สุดคือ spectral_norm2.f90 และ spectral_norm6.f90 (อันหนึ่งใช้ matmul ในตัวและ dot_product ของ Fortran อีกตัวหนึ่งใช้ฟังก์ชันทั้งสองนี้ในรหัส - โดยไม่มีความแตกต่างด้านความเร็ว) รหัส C / C ++ ที่เร็วที่สุดที่ฉันสามารถเขียนได้คือ spectral_norm7.cpp การจับเวลาของ git รุ่น 457d9d9 บนแล็ปท็อปของฉันคือ:

$ time ./spectral_norm6 5500
1.274224153

real    0m2.675s
user    0m2.520s
sys 0m0.132s


$ time ./spectral_norm7 5500
1.274224153

real    0m2.871s
user    0m2.724s
sys 0m0.124s

ดังนั้นเวอร์ชันของ gfortran จึงเร็วขึ้นเล็กน้อย ทำไมถึงเป็นอย่างนั้น? หากคุณส่งคำขอดึงพร้อมการติดตั้ง C เร็วขึ้น (หรือเพียงวางรหัส) ฉันจะอัปเดตที่เก็บ

ใน Fortran ฉันผ่านอาร์เรย์ 2 มิติในขณะที่ใน CI ใช้อาร์เรย์ 1D อย่าลังเลที่จะใช้อาร์เรย์ 2 มิติหรือวิธีอื่นที่คุณเห็นว่าเหมาะสม

สำหรับคอมไพเลอร์ลองเปรียบเทียบ gcc กับ gfortran, icc vs ifort และอื่น ๆ (ไม่เหมือนกับหน้าจุดโทษซึ่งเปรียบเทียบ ifort กับ gcc.)

อัปเดต : ใช้รุ่น 179dae2 ซึ่งปรับปรุง matmul3 () ในเวอร์ชั่น C ของฉันตอนนี้มันเร็วพอ:

$ time ./spectral_norm6 5500
1.274224153

real    0m2.669s
user    0m2.500s
sys 0m0.144s

$ time ./spectral_norm7 5500
1.274224153

real    0m2.665s
user    0m2.472s
sys 0m0.168s

เวอร์ชัน vectorized ของ Pedro ด้านล่างนั้นเร็วกว่า:

$ time ./spectral_norm8 5500
1.274224153

real    0m2.523s
user    0m2.336s
sys 0m0.156s

ท้ายที่สุดจากรายงาน laxxy ด้านล่างสำหรับคอมไพเลอร์ของ Intel ดูเหมือนจะไม่แตกต่างกันมากนักและแม้แต่รหัส Fortran ที่ง่ายที่สุด (spectral_norm1) ก็เป็นวิธีที่เร็วที่สุด

ก่อนอื่นขอขอบคุณที่โพสต์คำถาม / ความท้าทายนี้! ตามข้อจำกัดความรับผิดชอบฉันเป็นโปรแกรมเมอร์ภาษาซีที่มีประสบการณ์ Fortran และรู้สึกเหมือนอยู่บ้านมากที่สุดใน C ดังนั้นฉันจะมุ่งเน้นเฉพาะการปรับปรุงรุ่น C เท่านั้น ฉันขอเชิญผู้ที่มาเยี่ยม Fortran ทุกคนให้ไปด้วย!

เพียงเพื่อเตือนผู้มาใหม่เกี่ยวกับสิ่งนี้คืออะไร: หลักฐานพื้นฐานในหัวข้อนี้คือ gcc / fortran และ icc / ifort ควรเนื่องจากพวกเขามี back-end เดียวกันตามลำดับสร้างรหัสที่เทียบเท่าสำหรับโปรแกรมเดียวกัน (semantically เหมือนกัน) โดยไม่คำนึงถึง มันอยู่ใน C หรือ Fortran คุณภาพของผลลัพธ์ขึ้นอยู่กับคุณภาพของการใช้งานที่เกี่ยวข้อง

ฉันเล่นด้วยรหัสเล็กน้อยและบนคอมพิวเตอร์ของฉัน (ThinkPad 201x, Intel Core i5 M560, 2.67 GHz) โดยใช้gcc4.6.1 และธงคอมไพเลอร์ต่อไปนี้:

GCCFLAGS= -O3 -g -Wall -msse2 -march=native -funroll-loops -ffast-math -fomit-frame-pointer -fstrict-aliasing

ฉันยังไปข้างหน้าและเขียนรหัส C ++ ภาษา SIMD-vectorized ของ C ++ spectral_norm_vec.c:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

/* Define the generic vector type macro. */  
#define vector(elcount, type)  __attribute__((vector_size((elcount)*sizeof(type)))) type

double Ac(int i, int j)
{
    return 1.0 / ((i+j) * (i+j+1)/2 + i+1);
}

double dot_product2(int n, double u[], double v[])
{
    double w;
    int i;
    union {
        vector(2,double) v;
        double d[2];
        } *vu = u, *vv = v, acc[2];

    /* Init some stuff. */
    acc[0].d[0] = 0.0; acc[0].d[1] = 0.0;
    acc[1].d[0] = 0.0; acc[1].d[1] = 0.0;

    /* Take in chunks of two by two doubles. */
    for ( i = 0 ; i < (n/2 & ~1) ; i += 2 ) {
        acc[0].v += vu[i].v * vv[i].v;
        acc[1].v += vu[i+1].v * vv[i+1].v;
        }
    w = acc[0].d[0] + acc[0].d[1] + acc[1].d[0] + acc[1].d[1];

    /* Catch leftovers (if any) */
    for ( i = n & ~3 ; i < n ; i++ )
        w += u[i] * v[i];

    return w;

}

void matmul2(int n, double v[], double A[], double u[])
{
    int i, j;
    union {
        vector(2,double) v;
        double d[2];
        } *vu = u, *vA, vi;

    bzero( u , sizeof(double) * n );

    for (i = 0; i < n; i++) {
        vi.d[0] = v[i];
        vi.d[1] = v[i];
        vA = &A[i*n];
        for ( j = 0 ; j < (n/2 & ~1) ; j += 2 ) {
            vu[j].v += vA[j].v * vi.v;
            vu[j+1].v += vA[j+1].v * vi.v;
            }
        for ( j = n & ~3 ; j < n ; j++ )
            u[j] += A[i*n+j] * v[i];
        }

}


void matmul3(int n, double A[], double v[], double u[])
{
    int i;

    for (i = 0; i < n; i++)
        u[i] = dot_product2( n , &A[i*n] , v );

}

void AvA(int n, double A[], double v[], double u[])
{
    double tmp[n] __attribute__ ((aligned (16)));
    matmul3(n, A, v, tmp);
    matmul2(n, tmp, A, u);
}


double spectral_game(int n)
{
    double *A;
    double u[n] __attribute__ ((aligned (16)));
    double v[n] __attribute__ ((aligned (16)));
    int i, j;

    /* Aligned allocation. */
    /* A = (double *)malloc(n*n*sizeof(double)); */
    if ( posix_memalign( (void **)&A , 4*sizeof(double) , sizeof(double) * n * n ) != 0 ) {
        printf( "spectral_game:%i: call to posix_memalign failed.\n" , __LINE__ );
        abort();
        }


    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            A[i*n+j] = Ac(i, j);
        }
    }


    for (i = 0; i < n; i++) {
        u[i] = 1.0;
    }
    for (i = 0; i < 10; i++) {
        AvA(n, A, u, v);
        AvA(n, A, v, u);
    }
    free(A);
    return sqrt(dot_product2(n, u, v) / dot_product2(n, v, v));
}

int main(int argc, char *argv[]) {
    int i, N = ((argc >= 2) ? atoi(argv[1]) : 2000);
    for ( i = 0 ; i < 10 ; i++ )
        printf("%.9f\n", spectral_game(N));
    return 0;
}

ทั้งสามเวอร์ชันรวบรวมด้วยแฟล็กเดียวกันและgccเวอร์ชันเดียวกัน โปรดทราบว่าฉันปิดการเรียกฟังก์ชั่นหลักเป็นวงจาก 0..9 เพื่อให้ได้เวลาที่แม่นยำยิ่งขึ้น

$ time ./spectral_norm6 5500
1.274224153
...
real    0m22.682s
user    0m21.113s
sys 0m1.500s

$ time ./spectral_norm7 5500
1.274224153
...
real    0m21.596s
user    0m20.373s
sys 0m1.132s

$ time ./spectral_norm_vec 5500
1.274224153
...
real    0m21.336s
user    0m19.821s
sys 0m1.444s

ดังนั้นด้วยแฟล็กคอมไพเลอร์ "ดีกว่า" รุ่น C ++ ที่ออกมาจะทำหน้าที่เวอร์ชัน Fortran และลูปแบบเวกเตอร์แบบเข้ารหัสด้วยมือเท่านั้นจึงให้การปรับปรุงเล็กน้อย การดูอย่างรวดเร็วของแอสเซมเบลอร์สำหรับเวอร์ชัน C ++ แสดงว่าลูปหลักได้รับการทำให้เป็นเวกเตอร์ด้วยซ้ำ

ฉันได้ดูที่แอสเซมเบลอร์ที่สร้างโดยgfortranและนี่คือความประหลาดใจที่ยิ่งใหญ่: ไม่มี vectorization ฉันเชื่อว่ามันช้าลงเล็กน้อยกับปัญหาที่แบนด์วิดธ์ จำกัด อย่างน้อยในสถาปัตยกรรมของฉัน สำหรับการคูณเมทริกซ์แต่ละครั้งจะมีการสำรวจข้อมูล 230MB ซึ่งทำให้แคชในทุกระดับมีจำนวนมาก หากคุณใช้ค่าอินพุตที่น้อยลงเช่น100ความแตกต่างของประสิทธิภาพจะเพิ่มขึ้นอย่างมาก

ในฐานะที่เป็นหมายเหตุด้านข้างแทนที่จะมัวเมาเกี่ยวกับการทำให้เป็นเวกเตอร์, การจัดตำแหน่งและการคอมไพเลอร์การปรับให้เหมาะสมที่ชัดเจนที่สุดคือการคำนวณการวนซ้ำสองสามครั้งแรกในคณิตศาสตร์ที่มีความแม่นยำเดียวจนกระทั่งเรามีผลลัพธ์ประมาณ 8 หลัก คำแนะนำที่มีความแม่นยำเพียงอย่างเดียวไม่เพียง แต่เร็วขึ้นเท่านั้น แต่จำนวนหน่วยความจำที่ต้องเลื่อนไปรอบ ๆ ก็ลดลงครึ่งหนึ่ง

คำตอบของผู้ใช้ 389 ถูกลบไปแล้ว แต่ให้ฉันบอกว่าฉันอยู่ในค่ายของเขาอย่างเหนียวแน่น: ฉันไม่ได้เห็นสิ่งที่เราเรียนรู้โดยการเปรียบเทียบมาตรฐานไมโครในภาษาต่างๆ ไม่แปลกใจสำหรับฉันที่ C และ Fortran จะได้รับประสิทธิภาพเดียวกันในเกณฑ์มาตรฐานนี้มากแค่ไหนเพราะมันสั้นแค่ไหน แต่มาตรฐานก็น่าเบื่อเช่นกันเพราะสามารถเขียนได้ง่ายทั้งสองภาษาในสองสามบรรทัด จากมุมมองของซอฟต์แวร์นั่นไม่ใช่กรณีตัวแทน: เราควรใส่ใจเกี่ยวกับซอฟต์แวร์ที่มีโค้ด 10,000 หรือ 100,000 บรรทัดและคอมไพเลอร์ทำอย่างไร แน่นอนว่าในระดับนั้นจะพบสิ่งอื่นได้อย่างรวดเร็ว: ภาษานั้นต้องมี 10,000 บรรทัดในขณะที่ภาษา B ต้องการ 50,000 หรือวิธีอื่น ๆ ขึ้นอยู่กับว่าคุณต้องการทำอะไร และทันใดนั้นเอง

มันไม่สำคัญสำหรับฉันเลยว่าใบสมัครของฉันอาจเร็วกว่า 50% ถ้าฉันพัฒนาใน Fortran 77 ถ้ามันใช้เวลาแค่ 1 เดือนเพื่อให้มันทำงานอย่างถูกต้องในขณะที่มันใช้เวลา 3 เดือน ใน F77 ปัญหาของคำถามที่นี่คือมันมุ่งเน้นไปที่แง่มุม (แต่ละเมล็ด) ที่ไม่เกี่ยวข้องในทางปฏิบัติในมุมมองของฉัน

ปรากฎว่าฉันสามารถเขียนรหัส Python (ใช้ numpy เพื่อทำการดำเนินการ BLAS) เร็วกว่ารหัส Fortran ที่คอมไพล์ด้วยคอมไพเลอร์ gfortran ของระบบของฉัน

$ gfortran -o sn6a sn6a.f90 -O3 -march=native
    
    $ ./sn6a 5500
1.274224153
1.274224153
1.274224153
   1.9640001      sec per iteration

$ python ./foo1.py
1.27422415279
1.27422415279
1.27422415279
1.20618661245 sec per iteration

foo1.py:

import numpy
import scipy.linalg
import timeit

def specNormDot(A,n):
    u = numpy.ones(n)
    v = numpy.zeros(n)

    for i in xrange(10):
        v  = numpy.dot(numpy.dot(A,u),A)
        u  = numpy.dot(numpy.dot(A,v),A)

    print numpy.sqrt(numpy.vdot(u,v)/numpy.vdot(v,v))

    return

n = 5500

ii, jj = numpy.meshgrid(numpy.arange(1,n+1), numpy.arange(1,n+1))
A  = (1./((ii+jj-2.)*(ii+jj-1.)/2. + ii))

t = timeit.Timer("specNormDot(A,n)", "from __main__ import specNormDot,A,n")
ntries = 3

print t.timeit(ntries)/ntries, "sec per iteration"

และ sn6a.f90, spectral_norm6.f90 ที่ปรับเปลี่ยนเล็กน้อยมาก:

program spectral_norm6
! This uses spectral_norm3 as a starting point, but does not use the
! Fortrans
! builtin matmul and dotproduct (to make sure it does not call some
! optimized
! BLAS behind the scene).
implicit none

integer, parameter :: dp = kind(0d0)
real(dp), allocatable :: A(:, :), u(:), v(:)
integer :: i, j, n
character(len=6) :: argv
integer :: calc, iter
integer, parameter :: niters=3

call get_command_argument(1, argv)
read(argv, *) n

allocate(u(n), v(n), A(n, n))
do j = 1, n
    do i = 1, n
        A(i, j) = Ac(i, j)
    end do
end do

call tick(calc)

do iter=1,niters
    u = 1
    do i = 1, 10
        v = AvA(A, u)
        u = AvA(A, v)
    end do

    write(*, "(f0.9)") sqrt(dot_product2(u, v) / dot_product2(v, v))
enddo

print *, tock(calc)/niters, ' sec per iteration'

contains

pure real(dp) function Ac(i, j) result(r)
integer, intent(in) :: i, j
r = 1._dp / ((i+j-2) * (i+j-1)/2 + i)
end function

pure function matmul2(v, A) result(u)
! Calculates u = matmul(v, A), but much faster (in gfortran)
real(dp), intent(in) :: v(:), A(:, :)
real(dp) :: u(size(v))
integer :: i
do i = 1, size(v)
    u(i) = dot_product2(A(:, i), v)
end do
end function

pure real(dp) function dot_product2(u, v) result(w)
! Calculates w = dot_product(u, v)
real(dp), intent(in) :: u(:), v(:)
integer :: i
w = 0
do i = 1, size(u)
    w = w + u(i)*v(i)
end do
end function

pure function matmul3(A, v) result(u)
! Calculates u = matmul(v, A), but much faster (in gfortran)
real(dp), intent(in) :: v(:), A(:, :)
real(dp) :: u(size(v))
integer :: i, j
u = 0
do j = 1, size(v)
    do i = 1, size(v)
        u(i) = u(i) + A(i, j)*v(j)
    end do
end do
end function

pure function AvA(A, v) result(u)
! Calculates u = matmul2(matmul3(A, v), A)
! In gfortran, this function is sligthly faster than calling
! matmul2(matmul3(A, v), A) directly.
real(dp), intent(in) :: v(:), A(:, :)
real(dp) :: u(size(v))
u = matmul2(matmul3(A, v), A)
end function

subroutine tick(t)
    integer, intent(OUT) :: t

    call system_clock(t)
end subroutine tick

! returns time in seconds from now to time described by t 
real function tock(t)
    integer, intent(in) :: t
    integer :: now, clock_rate

    call system_clock(now,clock_rate)

    tock = real(now - t)/real(clock_rate)
end function tock
end program

ตรวจสอบเรื่องนี้ด้วยคอมไพเลอร์ของ Intel ด้วย 11.1 (-fast, implying -O3) และ 12.0 (-O2) ค่าที่เร็วที่สุดคือ 1,2,6,7 และ 8 (เช่นรหัส Fortran และ C ที่ "ง่ายที่สุด" และ hand-vectorized C) - สิ่งเหล่านี้แยกไม่ออกจากกันที่ ~ 1.5s การทดสอบ 3 และ 5 (โดยมีอาร์เรย์เป็นฟังก์ชัน) จะช้ากว่า # 4 ฉันไม่สามารถรวบรวมได้

โดยเฉพาะอย่างยิ่งถ้าคอมไพล์ด้วย 12.0 และ -O3 แทนที่จะเป็น -O2 รหัส Fortran 2 ("ง่ายที่สุด") 2 อันแรกจะชะลอความเร็วลงมาก (1.5 -> 10.2 วินาที) - นี่ไม่ใช่ครั้งแรกที่ฉันเห็นบางสิ่งเช่น สิ่งนี้ แต่นี่อาจเป็นตัวอย่างที่น่าทึ่งที่สุด หากนี่เป็นกรณีในรุ่นปัจจุบันฉันคิดว่าเป็นความคิดที่ดีที่จะรายงานต่อ Intel เนื่องจากมีบางอย่างผิดปกติอย่างชัดเจนกับการเพิ่มประสิทธิภาพในกรณีที่ค่อนข้างง่าย

มิฉะนั้นฉันก็เห็นด้วยกับโจนาธานว่านี่ไม่ใช่แบบฝึกหัดที่ให้ข้อมูล :)