golang - rust vs c

¿Por qué un programa que actualiza una gran matriz de coma flotante estática más lenta en Rust que en C?

Question

Escribí un programa simple para comparar el rendimiento de Rust y C

La versión de Rust:

use std::time::Instant;

const STREAM_ARRAY_SIZE: usize = 10000000;
static mut A: [f64; STREAM_ARRAY_SIZE] = [1.0; STREAM_ARRAY_SIZE];

fn main() {
    let now = Instant::now();

    unsafe {
        for i in 0..STREAM_ARRAY_SIZE {
            A[i] = 2.0E0 * A[i];
        }
    }

    let duration = now.elapsed();
    println!("{}", (duration.as_secs() * 1_000_000_000 + duration.subsec_nanos() as u64) / 1000);
}

Ejecútelo en modo de depuración y liberación:

$ ./target/debug/calc
472046 us.
$ ./target/release/calc
62860 us.

La versión de lanzamiento tiene una ganancia de rendimiento drástica en comparación con la depuración.

La versión C hace lo mismo y se ejecuta en el mismo servidor:

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

#define STREAM_ARRAY_SIZE   10000000

static double A[STREAM_ARRAY_SIZE];
int mysecond(void)
{
        struct timeval tp;
        struct timezone tzp;
        int i;

        i = gettimeofday(&tp,&tzp);
        return (tp.tv_sec * 1000000 + tp.tv_usec);
}

int main(void)
{
    int j = 0;
    for (j = 0; j < STREAM_ARRAY_SIZE; j++)
    {
        A[j] = 1.0;
    }

    int t = mysecond();
    for (j = 0; j < STREAM_ARRAY_SIZE; j++)
    {
        A[j] = 2.0E0 * A[j];
    }
    printf("%d us./n", mysecond() - t);
    return 0;
}

Compilar y ejecutarlo con -O0 y -O2 :

$ gcc test.c
$ ./a.out
41626 us.
$ gcc -O2 test.c
$ ./a.out
13499 us.

La versión optimizada de Rust solo se compara con gcc -O0 , y es muy débil en comparación con gcc -O2 . Es esto razonable? ¿Cómo puedo mejorar el rendimiento de la versión Rust?

Answer 1

Rust compila el ciclo para:

.LBB0_1:
    movupd  xmm0, xmmword ptr [rcx + 8*rax - 48]
    movupd  xmm1, xmmword ptr [rcx + 8*rax - 32]
    addpd   xmm0, xmm0
    addpd   xmm1, xmm1
    movupd  xmmword ptr [rcx + 8*rax - 48], xmm0
    movupd  xmmword ptr [rcx + 8*rax - 32], xmm1
    movupd  xmm0, xmmword ptr [rcx + 8*rax - 16]
    movupd  xmm1, xmmword ptr [rcx + 8*rax]
    addpd   xmm0, xmm0
    addpd   xmm1, xmm1
    movupd  xmmword ptr [rcx + 8*rax - 16], xmm0
    movupd  xmmword ptr [rcx + 8*rax], xmm1
    add rax, 8
    cmp rax, 100006
    jne .LBB0_1

Mientras que GCC 7.1.0 compila a:

L6:
    movsd   (%rbx), %xmm0
    addq    $8, %rbx
    addsd   %xmm0, %xmm0
    movsd   %xmm0, -8(%rbx)
    cmpq    %rbp, %rbx
    jne     L6

Rust coloca la matriz en una sección de datos, mientras que C escribe ( memset con patrón) en la memoria. Esto significa que su sistema operativo que ejecuta la aplicación probablemente solo asigna el rango y depende de la memoria virtual para hacer lo correcto.

Si cambia el código para ejecutar el mismo ciclo antes de la medición, el tiempo de ejecución baja considerablemente. En realidad es más rápido que la versión C en mi máquina. (posiblemente debido a ese bucle que se desenrolla)

unsafe {
    for i in 0..STREAM_ARRAY_SIZE {
        A[i] = 2.0E0 * A[i];
    }
}

let now = Instant::now();

unsafe {
    for i in 0..STREAM_ARRAY_SIZE {
        A[i] = 2.0E0 * A[i];
    }
}

let duration = now.elapsed();