fortran - Tiempo de CPU en precisión cuádruple vs. doble

scientific-computing quadruple-precision

Question

Estoy haciendo algunas simulaciones a largo plazo en las que trato de lograr la mayor precisión posible en la solución de sistemas de ODE. Estoy tratando de averiguar cuánto tiempo toman los cálculos de precisión cuádruple (128 bits) frente a la precisión doble (64 bits). Busqué en Google un poco y vi varias opiniones al respecto: algunos dicen que tomará 4 veces más tiempo, otros 60-70 veces ... Así que decidí tomar el asunto en mis manos y escribí un sencillo programa de referencia de Fortran:

program QUAD_TEST
implicit none
integer,parameter :: dp = selected_int_kind(15)
integer,parameter :: qp = selected_int_kind(33)
integer :: cstart_dp,cend_dp,cstart_qp,cend_qp,crate
real :: time_dp,time_qp
real(dp) :: sum_dp,sqrt_dp,pi_dp,mone_dp,zero_dp
real(qp) :: sum_qp,sqrt_qp,pi_qp,mone_qp,zero_qp
integer :: i
! ==============================================================================
! == TEST 1. ELEMENTARY OPERATIONS ==
sum_dp = 1._dp
sum_qp = 1._qp
call SYSTEM_CLOCK(count_rate=crate)
write(*,*) ''Testing elementary operations...''
call SYSTEM_CLOCK(count=cstart_dp)
do i=1,50000000
sum_dp = sum_dp - 1._dp
sum_dp = sum_dp + 1._dp
sum_dp = sum_dp*2._dp
sum_dp = sum_dp/2._dp
end do
call SYSTEM_CLOCK(count=cend_dp)
time_dp = real(cend_dp - cstart_dp)/real(crate)
write(*,*) ''DP sum: '',sum_dp
write(*,*) ''DP time: '',time_dp,'' seconds''
call SYSTEM_CLOCK(count=cstart_qp)
do i=1,50000000
sum_qp = sum_qp - 1._qp
sum_qp = sum_qp + 1._qp
sum_qp = sum_qp*2._qp
sum_qp = sum_qp/2._qp
end do
call SYSTEM_CLOCK(count=cend_qp)
time_qp = real(cend_qp - cstart_qp)/real(crate)
write(*,*) ''QP sum: '',sum_qp
write(*,*) ''QP time: '',time_qp,'' seconds''
write(*,*)
write(*,*) ''DP is '',time_qp/time_dp,'' times faster.''
write(*,*)
! == TEST 2. SQUARE ROOT ==
sqrt_dp = 2._dp
sqrt_qp = 2._qp
write(*,*) ''Testing square root ...''
call SYSTEM_CLOCK(count=cstart_dp)
do i = 1,10000000
sqrt_dp = sqrt(sqrt_dp)
sqrt_dp = 2._dp
end do
call SYSTEM_CLOCK(count=cend_dp)
time_dp = real(cend_dp - cstart_dp)/real(crate)
write(*,*) ''DP sqrt: '',sqrt_dp
write(*,*) ''DP time: '',time_dp,'' seconds''
call SYSTEM_CLOCK(count=cstart_qp)
do i = 1,10000000
sqrt_qp = sqrt(sqrt_qp)
sqrt_qp = 2._qp
end do
call SYSTEM_CLOCK(count=cend_qp)
time_qp = real(cend_qp - cstart_qp)/real(crate)
write(*,*) ''QP sqrt: '',sqrt_qp
write(*,*) ''QP time: '',time_qp,'' seconds''
write(*,*)
write(*,*) ''DP is '',time_qp/time_dp,'' times faster.''
write(*,*)
! == TEST 3. TRIGONOMETRIC FUNCTIONS ==
pi_dp = acos(-1._dp); mone_dp = 1._dp; zero_dp = 0._dp
pi_qp = acos(-1._qp); mone_qp = 1._qp; zero_qp = 0._qp
write(*,*) ''Testing trigonometric functions ...''
call SYSTEM_CLOCK(count=cstart_dp)
do i = 1,10000000
mone_dp = cos(pi_dp)
zero_dp = sin(pi_dp)
end do
call SYSTEM_CLOCK(count=cend_dp)
time_dp = real(cend_dp - cstart_dp)/real(crate)
write(*,*) ''DP cos: '',mone_dp
write(*,*) ''DP sin: '',zero_dp
write(*,*) ''DP time: '',time_dp,'' seconds''
call SYSTEM_CLOCK(count=cstart_qp)
do i = 1,10000000
mone_qp = cos(pi_qp)
zero_qp = sin(pi_qp)
end do
call SYSTEM_CLOCK(count=cend_qp)
time_qp = real(cend_qp - cstart_qp)/real(crate)
write(*,*) ''QP cos: '',mone_qp
write(*,*) ''QP sin: '',zero_qp
write(*,*) ''QP time: '',time_qp,'' seconds''
write(*,*)
write(*,*) ''DP is '',time_qp/time_dp,'' times faster.''
write(*,*)
end program QUAD_TEST

Resultados de una ejecución típica, después de compilar con gfortran 4.8.4 , sin ningún indicador de optimización:

 Testing elementary operations...
DP sum: 1.0000000000000000
DP time: 0.572000027 seconds
QP sum: 1.00000000000000000000000000000000000
QP time: 4.32299995 seconds
DP is 7.55769205 times faster.
Testing square root ...
DP sqrt: 2.0000000000000000
DP time: 5.20000011E-02 seconds
QP sqrt: 2.00000000000000000000000000000000000
QP time: 2.60700011 seconds
DP is 50.1346169 times faster.
Testing trigonometric functions ...
DP cos: -1.0000000000000000
DP sin: 1.2246467991473532E-016
DP time: 2.79600000 seconds
QP cos: -1.00000000000000000000000000000000000
QP sin: 8.67181013012378102479704402604335225E-0035
QP time: 5.90199995 seconds
DP is 2.11087275 times faster.

Algo debe estar pasando aquí. Mi suposición es que sqrt se calcula con gfortran través de un algoritmo optimizado, que probablemente no se haya implementado para cálculos de cuádruple precisión. Este podría no ser el caso para sin y cos , pero ¿por qué las operaciones elementales son 7.6 veces más lentas en precisión cuádruple mientras que para las funciones trigonométricas las cosas se desaceleran solo en un factor de 2? Si el algoritmo utilizado para las funciones trigonométricas fuera el mismo para precisión cuádruple y doble, también esperaría ver un aumento de siete veces en el tiempo de CPU para ellos.

¿Cuál es la desaceleración promedio en los cálculos científicos cuando se utiliza la precisión de 128 bits, en comparación con 64 bits?

Estoy ejecutando esto en un Intel i7-4771 @ 3.50GHz.

Answer 1

Es interesante notar que si cambias:

sqrt_qp = sqrt(sqrt_qp)
sqrt_qp = 2._qp

a

sqrt_qp = sqrt(2._qp)

¡el cálculo será más rápido!

Answer 2

Más un comentario extendido que una respuesta, pero ...

Las CPU actuales proporcionan una gran cantidad de aceleración de hardware para la aritmética de coma flotante de doble precisión. Algunos incluso proporcionan instalaciones para una mayor precisión. Más allá de eso, estás limitado a implementaciones de software que son (como habrás notado) considerablemente más lentas.

Sin embargo, el factor exacto de esta ralentización es casi imposible de predecir en casos genéricos. Depende de su CPU (por ejemplo, qué aceleración tiene incorporada) y de la pila de software. Para la precisión doble, normalmente utiliza diferentes bibliotecas matemáticas que para la precisión cuádruple, y es posible que utilicen algoritmos diferentes para las operaciones básicas.

Para una operación / algoritmo en particular en un hardware dado usando el mismo algoritmo, probablemente pueda derivar un número, pero esto seguramente no será universalmente cierto.