Comment puis-je maximiser la vitesse d'écriture des fichiers binaires en C ?

Améliorer la vitesse de transfert de données dans les écritures de fichiers binaires en C

Introduction :

L'écriture efficace de grands tampons dans des fichiers binaires est souvent crucial pour les applications sensibles aux performances. Dans cet article, nous explorerons la question de savoir comment optimiser ce processus en C.

Approche initiale et goulots d'étranglement :

Le code fourni semble sous-performant par rapport au fichier opérations de copie. Les goulots d'étranglement potentiels incluent :

• Utilisation de fstream au lieu de FILE* (E/S standard) pour les écritures binaires
• Boucle d'écriture inefficace avec des appels système fréquents

Solution optimisée :

Une approche beaucoup plus rapide consiste à utiliser FILE* et fwrite :

#include <stdio.h>

const unsigned long long size = 8ULL*1024ULL*1024ULL;
unsigned long long a[size];

int main()
{
    FILE* pFile;
    pFile = fopen("file.binary", "wb");
    for (unsigned long long j = 0; j < 1024; ++j)
    {
        // Data generation
        fwrite(a, 1, size*sizeof(unsigned long long), pFile);
    }
    fclose(pFile);
    return 0;
}

Ce code a atteint des vitesses d'écriture d'environ 220 Mo/s, se rapprochant des limites du SSD.

Autres raffinements :

Pour améliorer davantage l'efficacité du code, nous pouvons implémenter les éléments suivants :

• Désactiver la synchronisation du flux avec std::ios_base::sync_with_stdio(false)
• Génération de données vectorisées à l'aide de std::vector et std::iota, std::shuffle et std::random_device
• Mesures de temps à l'aide de std ::chrono

Benchmarking et Résultats :

L'analyse comparative du code sur différentes plates-formes (ordinateurs portables et de bureau) avec différentes tailles de tampon (1 Mo à 4 Go) a révélé :

• Sur les deux plates-formes, fstream a surpassé FILE* lors de l'utilisation de petits tampons (1 Mo), mais a pris du retard pour les tampons plus grands.
• fstream a pu utiliser pleinement la bande passante SSD pour les grands tampons, éliminant l'avantage en termes de performances de FILE*.

Conclusion :

En résumé, pour écrire efficacement des tampons volumineux dans des fichiers binaires en C, considérez :

• Utiliser std::fstream pour les petits tampons
• Utiliser FILE* et fwrite pour les grands buffers
• Désactivation de la synchronisation du flux std::ios
• Optimisation de la génération de données et de l'analyse comparative

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!