Pourquoi est-il plus rapide d'écrire un fichier qui est ouvert avec stdout?

Question

Lorsqu'il est exécuté sous Windows, ce code de test:

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h> 
#include <time.h> 
#include <assert.h> 

int main() { 
    // The clock() function returns an approximation of processor time used by the program. 
    // The value returned is the CPU time used so far as a clock_t; 
    // to get the number of seconds used, divide by CLOCKS_PER_SEC. 
    auto buf = new char[1048576]; // 1MB 
    auto cache = new char[512 * 1024]; 

    // initialize the buffer 
    for (int i = 0; i < 1048576; ++i) 
     buf[i] = i; 

    auto fp_reopen = freopen("data_freopen.bin", "wb", stdout); 
    assert(fp_reopen != nullptr); 
    setvbuf(fp_reopen, cache, _IOLBF, 512 * 1024); 
    auto clock_begin = clock(); 
    for (int i = 0; i < 1000; ++i) { 
     auto n = fwrite(buf, 1048576, 1, fp_reopen); 
     assert(n == 1); 
    } 
    fflush(fp_reopen); 
    auto clock_end = clock(); 

#ifdef _WIN32 
    freopen("CONOUT$", "w", stdout); 
#else 
    freopen("/dev/tty", "w", stdout); 
#endif 

    printf("write with freopen clocks elapsed: %zu\n", clock_end - clock_begin); 

    auto fp = fopen("data_fopen.bin", "wb"); 
    assert(fp != nullptr); 
    setvbuf(fp, cache, _IOLBF, 512 * 1024); 
    clock_begin = clock(); 
    for (int i = 0; i < 1000; ++i) { 
     auto n = fwrite(buf, 1048576, 1, fp); 
     assert(n == 1); 
    } 
    fflush(fp); 
    clock_end = clock(); 
    fclose(fp); 

    printf("write with fopen clocks elapsed: %zu\n", clock_end - clock_begin); 
    delete[] buf; 
    delete[] cache; 
    getchar(); 
} 

ces résultats: Génère

• write with freopen clocks elapsed: 2767
• write with fopen clocks elapsed: 8337

Pourquoi?

Answer 1

Votre question est intéressante, mais très système spécifique:

• sur Linux avec gcc et la glibc, je reçois des timings très similaires pour les courses
• sur OS/X, avec clang et Apple Libc , les timings fopen semblent toujours un peu plus rapides que les timings fopen.
• vous exécutez votre test sur Windows, comme le suggère l'appel final à getchar() ... Je ne peux malheureusement pas tester ce système pour essayer de recouper vos observations.

Il est possible que Microsoft ait fait quelque chose de bizarre dans sa bibliothèque d'exécution, mais plus vraisemblablement vous comparez réellement la création de 2 fichiers distincts de 1 Go. Il est possible que le deuxième fichier soit plus long à créer que le premier, en raison de l'état de votre système de fichiers, de son cache ou d'autres causes spécifiques au système d'exploitation. Vous devriez essayer de supprimer cet effet secondaire potentiel en supprimant chaque fichier après l'avoir fermé ou en essayant d'exécuter les tests dans un ordre différent.