Comment obtenir des performances d'écriture de fichiers optimales en C ?

Comment améliorer les performances d'écriture de fichiers en C

Lors de l'écriture de données volumineuses dans un fichier binaire, l'optimisation des performances est cruciale. Voici comment améliorer votre vitesse d'écriture :

Utilisation de FILE* pour la gestion directe des fichiers :

Dans l'exemple de code, l'utilisation de FILE* permet un accès direct aux fichiers, en contournant couches intermédiaires et réduisant les frais généraux. Cette approche génère des gains de performances significatifs, comme observé dans la question d'origine.

Optimisation du code pour l'utilisation de FILE* :

#include <stdio.h&gt ;<br>const non signé long long size = 8ULL<em>1024ULL</em>1024ULL;<br>unsigned long long a[size];</p><p>int main()<br>{</p><pre class="brush:php;toolbar:false">FILE* pFile;
pFile = fopen("file.binary", "wb");
for (unsigned long long j = 0; j < 1024; ++j){
    // Some calculations to fill a[]
    fwrite(a, 1, size*sizeof(unsigned long long), pFile);
}
fclose(pFile);
return 0;

}
< /pre>

Ce code optimisé utilise FILE* directement pour écrire dans le fichier binaire, atteignant des vitesses d'écriture plus rapides.

Comparaison des approches :

Des mesures récentes indiquent que std::fstream offre des performances comparables à FILE* pour l'écriture de fichiers volumineux. Voici une comparaison de différentes approches :

#include <fstream></p>
<h1>include <chrono></h1>
<h1>include <vector></h1>
<h1>inclure <cstdint></h1>
<h1>inclure <numérique></h1>
<h1>inclure <aléatoire></h1>
<h1>inclure <algorithme></h1>
<h1>inclure <iostream></h1>
<h1>inclure <cassert></h1>
<p>long long option_1(std::size_t octets)<br>{</p>
<pre class="brush:php;toolbar:false">// Using std::fstream
std::vector<uint64_t> data = GenerateData(bytes);
auto startTime = std::chrono::high_resolution_clock::now();
auto myfile = std::fstream("file.binary", std::ios::out | std::ios::binary);
myfile.write((char*)&amp;data[0], bytes);
myfile.close();
auto endTime = std::chrono::high_resolution_clock::now();
return std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();

}

long long option_2(std::size_t octets)
{

// Using FILE*
std::vector<uint64_t> data = GenerateData(bytes);
auto startTime = std::chrono::high_resolution_clock::now();
FILE* file = fopen("file.binary", "wb");
fwrite(&amp;data[0], 1, bytes, file);
fclose(file);
auto endTime = std::chrono::high_resolution_clock::now();
return std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();

}

Les mesures montrent que l'option_1 (std::fstream) et l'option_2 (FILE*) atteignent des performances comparables pour un gros fichier écriture.

Conclusion :

Pour écrire de gros tampons dans un fichier binaire en C , FILE* et std::fstream offrent des performances élevées. Le choix entre les deux dépend des exigences et des préférences spécifiques.

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!