Discussion :

[tazer]

Bonne année et mes meilleurs vœux à tous et à toutes,
Pour commencer l'année, il m'est posé un problème sur un sujet auquel je n'avait pas accordé d'importance avant: Il s'agit de la lecture et l'ecriture de gros buffer sur le disque. J'ai toujours cru que windoz s'en occupe et qu'il n'y a pas de fonction plus rapide que d'autre, et bien que nini.
J'utilise Visual C++ 6 SP6 ou visual studio 2008 sur XP SP3 avec une machine assez robuste (dual 3Ghz, RAM 4 Go et un disque SATA2 à 11 000T/mn)
Je me suis fait un petit projet de test tout ce qu'il ya de plus banal :
Je lis un fichier binaire contenant 2048*2048*3 float et je le réecrit par bloc, je fais ca 10 fois.
C'est peut être plus simple de mettre le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
void CTestReadHBFDlg::OnFREAD() 
{
CString strFunction("OnFREAD" );
 
for (int i=0; i<10; i++)
{
 
	CString strFileName = "XYZ.raw";
 
	CWaitCursor wait;
 
	FILE *Stream=fopen(strFileName,"rb");
	// Lire l'entete
	char pszTypeName[45];
	int nTypeNameLen=45;
	fread(pszTypeName,sizeof(char),nTypeNameLen,Stream);
	// Lire la version
	unsigned long nVersion;
	fread(&nVersion,sizeof(unsigned long),1,Stream);
	// Lire les dimensions
	unsigned long nLi;
	fread(&nLi,sizeof(unsigned long),1,Stream);
	unsigned long nCo;
	fread(&nCo,sizeof(unsigned long),1,Stream);
	// Lire les données
	int m_nSize = 3*nLi*nCo;
	float* m_pData= new float[m_nSize] ;
MTDebugMessage(strModule, strFunction, "fread Début ");
	fread(m_pData,sizeof(float),m_nSize,Stream);
MTDebugMessage(strModule, strFunction, "fread Fin ");
	// Fermer et detruire.
	fclose(Stream);
 
 
	ifstream ifs;
	ifs.open(strFileName, ios::in | ios::binary);
	// Lire l'entete
	ifs.read(pszTypeName,sizeof(char)*nTypeNameLen);
	// Lire la version
	ifs.read((char *)&nVersion,sizeof(unsigned long)*1);
	// Lire les dimensions
	ifs.read((char *)&nLi,sizeof(unsigned long)*1);
	ifs.read((char *)&nCo,sizeof(unsigned long)*1);
	// Lire les données
MTDebugMessage(strModule, strFunction, "IOsread Début ");
	ifs.read((char *)m_pData,sizeof(float)*m_nSize);
MTDebugMessage(strModule, strFunction, "IOsread Fin ");
	// Fermer et detruire.
	ifs.close();
 
	strFileName = "XYZ_fwrite.raw";
	Stream=fopen(strFileName,"wb");
	// Lire l'entete
	fwrite(pszTypeName,sizeof(char),nTypeNameLen,Stream);
	// Lire la version
	fwrite(&nVersion,sizeof(unsigned long),1,Stream);
	// Lire les dimensions
	fwrite(&nLi,sizeof(unsigned long),1,Stream);
	fwrite(&nCo,sizeof(unsigned long),1,Stream);
	// Lire les données
MTDebugMessage(strModule, strFunction, "fsave Début ");
	fwrite(m_pData,sizeof(float),m_nSize,Stream);
MTDebugMessage(strModule, strFunction, "fsave Fin ");
	// Fermer et detruire.
	fclose(Stream);
 
	strFileName = "XYZ_write.raw";
	int fh;
	int nw;
	fh=_open(strFileName,_O_WRONLY | _O_CREAT, _S_IREAD | _S_IWRITE );
	// Lire l'entete
	nw = _write(fh, pszTypeName,sizeof(char)*nTypeNameLen);
	// Lire la version
	nw = _write(fh, &nVersion,sizeof(unsigned long)*1);
	// Lire les dimensions
	nw = _write(fh, &nLi,sizeof(unsigned long)*1);
	nw = _write(fh, &nCo,sizeof(unsigned long)*1);
	// Lire les données
MTDebugMessage(strModule, strFunction, "_write Début ");
	nw = _write(fh, m_pData,sizeof(float)*m_nSize);
MTDebugMessage(strModule, strFunction, "_write Fin ");
	// Fermer et detruire.
	_close(fh);
 
	strFileName = "XYZ_IO.raw";
	ofstream ofs;
	ofs.open(strFileName, ios::out | ios::binary);
	// Lire l'entete
	ofs.write(pszTypeName,sizeof(char)*nTypeNameLen);
	// Lire la version
	ofs.write((char *)&nVersion,sizeof(unsigned long)*1);
	// Lire les dimensions
	ofs.write((char *)&nLi,sizeof(unsigned long)*1);
	ofs.write((char *)&nCo,sizeof(unsigned long)*1);
	// Lire les données
MTDebugMessage(strModule, strFunction, "IOswrite Début ");
	ofs.write((char *)m_pData,sizeof(float)*m_nSize);
MTDebugMessage(strModule, strFunction, "IOswrite Fin ");
	// Fermer et detruire.
	ofs.close();
 
	delete[] m_pData;
}
}

les MTDebugMessage permettent d'écrire un message daté dans un fichier de log.

J'obtiens les résultats suivants :
Lecture :
fread en secondes: 0,047 0,062 0,062 0,047 0,063 0,047 0,063 0,047 0,047 0,063
ifstream.read : 3,359 3,391 3,391 3,421 3,390 3,359 3,390 3,359 3,422 3,375
Ecriture :
fsave : 1,187 1,187 1,172 1,156 1,172 1,172 1,172 1,156 1,171 1,156
_write : 2,640 2,594 2,406 2,422 2,625 2,515 2,500 2,719 2,297 2,579
ofstream.write : 4,796 5,047 4,344 4,813 4,437 4,984 4,266 5,359 4,203 4,641

J'en conclu que dans le cas de lecture ou d'écriture d'un bloc de données :
Les fonctions fread et fsave (stdio) sont les plus optimisées.
Les classes ifstream et ofstream (iostream, fstream) sont les pires !! (je me sens mal en disant ça)
Les fonctions _read et _write (io) sont entre les deux.

Qu'en pensez vous ? et quelle est votre expérience ?

bien a vous

[ram-0000]

Intéressant comme bench. Juste il manque les temps de lecture pour _read().

D'abord, et pour lever tout doute, es tu sûr que chaque fichier généré dans les 3 modes fait exactement la même taille ?

Est ce que tu as les moyen de faire la même chose sur une machine Linux ? (probablement/surement en retouchant le programme)

Je vais m'y pencher aussi sur ce bench

[tazer]

J'ai refait le test ce matin sur la même machine après redémmarage en y incluant aussi le _read.

fread : 0,063 0,046 0,063 0,062 0,047 0,062 0,047 0,063 0,063 0,062
_read : 0,047 0,047 0,047 0,032 0,047 0,032 0,047 0,047 0,047 0,032
Iread : 3,453 3,438 3,437 3,437 3,438 3,453 3,484 3,484 3,453 3,500

fwrite : 1,156 1,094 1,110 1,187 1,187 1,187 1,141 1,156 1,140 1,140
_write : 1,281 1,312 1,328 1,328 1,328 1,313 1,313 1,282 1,313 1,313
Iwrite : 3,578 3,531 3,532 3,531 3,547 3,547 3,531 3,546 3,515 3,516

Les fichiers générés sont identiques en taille et avec winmerge.
La quantité de données lues est la meme avec fread et _read je n'ai pas calculé pour iostream.

Autrement je n'ai que des machines sous XP

le gagnant est :
lecture : _read
Ecriture : fwrite

[ram-0000]

Je viens de faire le même genre de test:
Ma machine : PC Dell Optiplex GX280 avec Windows XP SP3, 512 MO RAM et Intel Pentium 4double coeur à 2,8 GHz
Mon environnement de développement : Visual Studio 2005 Pro
Mon programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
 
// Test.cpp*: définit le point d'entrée pour l'application console.
//
 
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <fstream>
#include <time.h>
 
clock_t _chrono = 0;
void _start_chrono(void)
{
	_chrono = clock();
}
 
void _display_chrono(const char * Message)
{
clock_t diff = clock() - _chrono;
	printf("%s : Elapsed time is %.2f s\n", Message, (double)diff / CLOCKS_PER_SEC);
}
 
void _test_write_io(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	int fh = _open(Filename, _O_WRONLY | _O_CREAT, _S_IREAD | _S_IWRITE);
	if(fh == -1)
	{
		printf("Error while opening the IO file (write mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			_write(fh, &nb1, sizeof(nb1));
			_write(fh, &nb2, sizeof(nb2));
			_write(fh, &nb3, sizeof(nb3));
		}
	}
 
	// fermeture du fichier
	_close(fh);
}
 
void _test_read_io(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	int fh = _open(Filename, _O_RDONLY);
	if(fh == -1)
	{
		printf("Error while opening the IO file (read mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			_read(fh, &nb1, sizeof(nb1));
			_read(fh, &nb2, sizeof(nb2));
			_read(fh, &nb3, sizeof(nb3));
		}
	}
 
	// fermeture du fichier
	_close(fh);
}
 
void _test_write_stdio(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	FILE *fh = fopen(Filename, "wb");
	if(fh == NULL)
	{
		printf("Error while opening the STDIO file (write mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			fwrite(&nb1, sizeof(nb1), 1, fh);
			fwrite(&nb2, sizeof(nb2), 1, fh);
			fwrite(&nb3, sizeof(nb3), 1, fh);
		}
	}
 
	// fermeture du fichier
	fclose(fh);
}
 
void _test_read_stdio(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	FILE *fh = fopen(Filename, "rb");
	if(fh == NULL)
	{
		printf("Error while opening the STDIO file (read mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			fread(&nb1, sizeof(nb1), 1, fh);
			fread(&nb2, sizeof(nb2), 1, fh);
			fread(&nb3, sizeof(nb3), 1, fh);
		}
	}
 
	// fermeture du fichier
	fclose(fh);
}
 
void _test_write_stream(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	std::ofstream ofs;
	ofs.open(Filename, std::ios::out | std::ios::binary);
	if(ofs.is_open() == false)
	{
		printf("Error while opening the STREAM file (write mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ofs.write((const char *)&nb1, sizeof(nb1));
			ofs.write((const char *)&nb2, sizeof(nb2));
			ofs.write((const char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ofs.close();
}
 
void _test_read_stream(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	std::ifstream ifs;
	ifs.open(Filename, std::ios::in | std::ios::binary);
	if(ifs.is_open() == false)
	{
		printf("Error while opening the STREAM file (read mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ifs.read((char *)&nb1, sizeof(nb1));
			ifs.read((char *)&nb2, sizeof(nb2));
			ifs.read((char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ifs.close();
}
 
int main(int argc, char* argv[])
{
	int nb0 = 10;
	int nb1 = 1000;
	int nb2 = 1000;
 
	for(int boucle = 0; boucle != nb0; boucle++)
	{
		printf("\n", boucle);
		printf("Passe %d\n", boucle);
		_start_chrono();
		_test_write_io("c:\\temp\\file_write_io.bin", nb1, nb2);
		_display_chrono("write_io");
 
		_start_chrono();
		_test_read_io("c:\\temp\\file_write_io.bin", nb1, nb2);
		_display_chrono("read_io");
 
		_start_chrono();
		_test_write_stdio("c:\\temp\\file_write_stdio.bin", nb1, nb2);
		_display_chrono("write_stdio");
 
		_start_chrono();
		_test_read_stdio("c:\\temp\\file_write_stdio.bin", nb1, nb2);
		_display_chrono("read_stdio");
 
		_start_chrono();
		_test_write_stream("c:\\temp\\file_write_stream.bin", nb1, nb2);
		_display_chrono("write_stream");
 
		_start_chrono();
		_test_read_stream("c:\\temp\\file_write_stream.bin", nb1, nb2);
		_display_chrono("read_stream");
	}
 
	return 0;
}

write_stdio : 0.61, 0.61, 0.63, 0.63, 0.63, 0.64, 0.59, 0.66, 0.63, 0.61
write_stream : 0.86, 0.84, 1.88, 0.86, 0.86, 0.83, 0.84, 0.89, 0.86, 0.84
write_io : 16.09, 15.98, 15.98, 15.91, 15.97, 15.91, 15.91, 15.91, 15.98, 16.09

read_stdio : 0.91, 0.58, 1.33, 0.56, 1.03, 1.14, 1.31, 0.56, 0.97, 1.24
read_stream : 0.97, 1.48, 0.58, 1.41, 1.30, 1.39, 1.14, 1.17, 1.19, 1.20
read_io : 8.06, 8.09, 8.11, 8.06, 8.08, 8.08, 8.11, 8.08, 8.08, 8.08

En écriture, il semble donc que stdio soit plus rapide que stream (de peu) et beaucoup plus rapide que io

En lecture, il semble donc que stdio soit un peu plus rapide que stream (mais cela se vaut) et beaucoup plus rapide que io

La conclusion de tout cela : utilisez stdio

[Médinoc]

@Tazer: Quelles sont des options d'optimisation ?

[Sylvain Togni]

Attention, comparons ce qui est comparable. Les stream de la STL sont des entrées/sorties FORMATTÉES. Pour des entrées et sorties binaires brutes comme c'est le cas ici mieux vaut utiliser les std::filebuf, qui n'ont pas cette surcouche de formatage texte qui prend du temps pour rien ici. Avec les std::filebuf et le benchmark de ram-0000, la STL est de loin la plus rapide.

Conclusion : en C++ utilisons des solutions C++.

[zais_ethael]

Personne n'a testé avec std::filebuf ? C'est toujours une couche en moins. Idéalement il faudrait même tester avec plusieurs réglages de buffer.

Edit: ha, ça a déjà été dit

[ram-0000]

Un nouveau bench avec les filebuf et ca décoiffe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
// Test.cpp*: définit le point d'entrée pour l'application console.
//
 
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <fstream>
#include <time.h>
 
clock_t _chrono = 0;
void _start_chrono(void)
{
	_chrono = clock();
}
 
void _display_chrono(const char * Message)
{
clock_t diff = clock() - _chrono;
	printf("%s : Elapsed time is %.2f s\n", Message, (double)diff / CLOCKS_PER_SEC);
}
 
void _test_write_io(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	int fh = _open(Filename, _O_WRONLY | _O_CREAT, _S_IREAD | _S_IWRITE);
	if(fh == -1)
	{
		printf("Error while opening the IO file (write mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			_write(fh, &nb1, sizeof(nb1));
			_write(fh, &nb2, sizeof(nb2));
			_write(fh, &nb3, sizeof(nb3));
		}
	}
 
	// fermeture du fichier
	_close(fh);
}
 
void _test_read_io(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	int fh = _open(Filename, _O_RDONLY);
	if(fh == -1)
	{
		printf("Error while opening the IO file (read mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			_read(fh, &nb1, sizeof(nb1));
			_read(fh, &nb2, sizeof(nb2));
			_read(fh, &nb3, sizeof(nb3));
		}
	}
 
	// fermeture du fichier
	_close(fh);
}
 
void _test_write_stdio(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	FILE *fh = fopen(Filename, "wb");
	if(fh == NULL)
	{
		printf("Error while opening the STDIO file (write mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			fwrite(&nb1, sizeof(nb1), 1, fh);
			fwrite(&nb2, sizeof(nb2), 1, fh);
			fwrite(&nb3, sizeof(nb3), 1, fh);
		}
	}
 
	// fermeture du fichier
	fclose(fh);
}
 
void _test_read_stdio(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	FILE *fh = fopen(Filename, "rb");
	if(fh == NULL)
	{
		printf("Error while opening the STDIO file (read mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			fread(&nb1, sizeof(nb1), 1, fh);
			fread(&nb2, sizeof(nb2), 1, fh);
			fread(&nb3, sizeof(nb3), 1, fh);
		}
	}
 
	// fermeture du fichier
	fclose(fh);
}
 
void _test_write_stream(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	std::ofstream ofs;
	ofs.open(Filename, std::ios::out | std::ios::binary);
	if(ofs.is_open() == false)
	{
		printf("Error while opening the STREAM file (write mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ofs.write((const char *)&nb1, sizeof(nb1));
			ofs.write((const char *)&nb2, sizeof(nb2));
			ofs.write((const char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ofs.close();
}
 
void _test_read_stream(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	std::ifstream ifs;
	ifs.open(Filename, std::ios::in | std::ios::binary);
	if(ifs.is_open() == false)
	{
		printf("Error while opening the STREAM file (read mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ifs.read((char *)&nb1, sizeof(nb1));
			ifs.read((char *)&nb2, sizeof(nb2));
			ifs.read((char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ifs.close();
}
 
void _test_write_filebuf(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	std::filebuf ofs;
	ofs.open(Filename, std::ios::out | std::ios::binary);
	if(ofs.is_open() == false)
	{
		printf("Error while opening the filebuf file (write mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ofs.sputn((const char *)&nb1, sizeof(nb1));
			ofs.sputn((const char *)&nb2, sizeof(nb2));
			ofs.sputn((const char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ofs.close();
}
 
void _test_read_filebuf(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	std::filebuf ofs;
	ofs.open(Filename, std::ios::in | std::ios::binary);
	if(ofs.is_open() == false)
	{
		printf("Error while opening the filebuf file (read mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ofs.sgetn((char *)&nb1, sizeof(nb1));
			ofs.sgetn((char *)&nb2, sizeof(nb2));
			ofs.sgetn((char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ofs.close();
}
 
int main(int argc, char* argv[])
{
	int nb0 = 10;
	int nb1 = 1000;
	int nb2 = 1000;
 
	for(int boucle = 0; boucle != nb0; boucle++)
	{
		printf("\n", boucle);
		printf("Passe %d\n", boucle);
		_start_chrono();
		_test_write_io("c:\\temp\\file_write_io.bin", nb1, nb2);
		_display_chrono("write_io");
 
		_start_chrono();
		_test_read_io("c:\\temp\\file_write_io.bin", nb1, nb2);
		_display_chrono("read_io");
 
		_start_chrono();
		_test_write_stdio("c:\\temp\\file_write_stdio.bin", nb1, nb2);
		_display_chrono("write_stdio");
 
		_start_chrono();
		_test_read_stdio("c:\\temp\\file_write_stdio.bin", nb1, nb2);
		_display_chrono("read_stdio");
 
		_start_chrono();
		_test_write_stream("c:\\temp\\file_write_stream.bin", nb1, nb2);
		_display_chrono("write_stream");
 
		_start_chrono();
		_test_read_stream("c:\\temp\\file_write_stream.bin", nb1, nb2);
		_display_chrono("read_stream");
 
		_start_chrono();
		_test_write_filebuf("c:\\temp\\file_write_filebuf.bin", nb1, nb2);
		_display_chrono("write_filebuf");
 
		_start_chrono();
		_test_read_filebuf("c:\\temp\\file_write_filebuf.bin", nb1, nb2);
		_display_chrono("read_filebuf");
	}
 
	return 0;
}

Envoyé par Les résultats
write_filebuf : 0.25, 1.28, 1.31, 0.20, 1.36, 0.20, 1.25, 0.25, 0.30, 0.27
write_stdio : 0.61, 0.61, 0.63, 0.63, 0.63, 0.64, 0.59, 0.66, 0.63, 0.61
write_stream : 0.86, 0.84, 1.88, 0.86, 0.86, 0.83, 0.84, 0.89, 0.86, 0.84
write_io : 16.09, 15.98, 15.98, 15.91, 15.97, 15.91, 15.91, 15.91, 15.98, 16.09

read_filebuf : 0.16, 0.30, 0.19, 0.17, 0.17, 1.11, 1.13, 0.16, 0.16, 0.16
read_stdio : 0.91, 0.58, 1.33, 0.56, 1.03, 1.14, 1.31, 0.56, 0.97, 1.24
read_stream : 0.97, 1.48, 0.58, 1.41, 1.30, 1.39, 1.14, 1.17, 1.19, 1.20
read_io : 8.06, 8.09, 8.11, 8.06, 8.08, 8.08, 8.11, 8.08, 8.08, 8.08

Donc je rectifie ma première conclusion : utilisons filebuf

[tazer]

Question annexe :
Si l'on regarde bien les durées : 0.25, 1.28 , 1.31, ... pour filebuf par exemple.
Comment expliquer les écarts de plus d'une seconde ?
J'en parle car j'ai actuellement ce problème.

il n'y a que les io qui sont lentement stables.

[ram-0000]

Probablement parce que je l'ai fait sur une machine qui était occupée à faire autre chose même si j'ai bien fait attention à ne pas toucher le clavier pendant ces mesures.

Un accès réseau, un service qui se réveille, un je ne sais quoi et tu perds du temps CPU, cela doit expliquer ces écarts. La méthode utilisée pour la mesure n'est pas très précise.

[gnairod]

C'est marrant ca, t'es sous Windows et tu fais des benchs qu'avec des fonctions portable mais faudrai voir aussi a compare avec les fonctions propre a l'API Win32.

[ram-0000]

C'est marrant ca, t'es sous Windows et tu fais des benchs qu'avec des fonctions portable mais faudrai voir aussi a compare avec les fonctions propre a l'API Win32.

Ecelllente remarque, je n'y avais pas pensé !!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <fstream>
#include <windows.h>
 
DWORD _chrono = 0;
void _start_chrono(void)
{
	_chrono = GetTickCount();
}
 
void _display_chrono(const char * Message)
{
DWORD diff = GetTickCount() - _chrono;
	printf("%s : Elapsed time is %.2f s\n", Message, (double)diff / 1000);
}
 
void _test_write_io(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	int fh = _open(Filename, _O_WRONLY | _O_CREAT, _S_IREAD | _S_IWRITE);
	if(fh == -1)
	{
		printf("Error while opening the IO file (write mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			_write(fh, &nb1, sizeof(nb1));
			_write(fh, &nb2, sizeof(nb2));
			_write(fh, &nb3, sizeof(nb3));
		}
	}
 
	// fermeture du fichier
	_close(fh);
}
 
void _test_read_io(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	int fh = _open(Filename, _O_RDONLY);
	if(fh == -1)
	{
		printf("Error while opening the IO file (read mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			_read(fh, &nb1, sizeof(nb1));
			_read(fh, &nb2, sizeof(nb2));
			_read(fh, &nb3, sizeof(nb3));
		}
	}
 
	// fermeture du fichier
	_close(fh);
}
 
void _test_write_stdio(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	FILE *fh = fopen(Filename, "wb");
	if(fh == NULL)
	{
		printf("Error while opening the STDIO file (write mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			fwrite(&nb1, sizeof(nb1), 1, fh);
			fwrite(&nb2, sizeof(nb2), 1, fh);
			fwrite(&nb3, sizeof(nb3), 1, fh);
		}
	}
 
	// fermeture du fichier
	fclose(fh);
}
 
void _test_read_stdio(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	FILE *fh = fopen(Filename, "rb");
	if(fh == NULL)
	{
		printf("Error while opening the STDIO file (read mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			fread(&nb1, sizeof(nb1), 1, fh);
			fread(&nb2, sizeof(nb2), 1, fh);
			fread(&nb3, sizeof(nb3), 1, fh);
		}
	}
 
	// fermeture du fichier
	fclose(fh);
}
 
void _test_write_stream(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	std::ofstream ofs;
	ofs.open(Filename, std::ios::out | std::ios::binary);
	if(ofs.is_open() == false)
	{
		printf("Error while opening the STREAM file (write mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ofs.write((const char *)&nb1, sizeof(nb1));
			ofs.write((const char *)&nb2, sizeof(nb2));
			ofs.write((const char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ofs.close();
}
 
void _test_read_stream(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	std::ifstream ifs;
	ifs.open(Filename, std::ios::in | std::ios::binary);
	if(ifs.is_open() == false)
	{
		printf("Error while opening the STREAM file (read mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ifs.read((char *)&nb1, sizeof(nb1));
			ifs.read((char *)&nb2, sizeof(nb2));
			ifs.read((char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ifs.close();
}
 
void _test_write_filebuf(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	std::filebuf ofs;
	ofs.open(Filename, std::ios::out | std::ios::binary);
	if(ofs.is_open() == false)
	{
		printf("Error while opening the filebuf file (write mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ofs.sputn((const char *)&nb1, sizeof(nb1));
			ofs.sputn((const char *)&nb2, sizeof(nb2));
			ofs.sputn((const char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ofs.close();
}
 
void _test_read_filebuf(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
	std::filebuf ofs;
	ofs.open(Filename, std::ios::in | std::ios::binary);
	if(ofs.is_open() == false)
	{
		printf("Error while opening the filebuf file (read mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ofs.sgetn((char *)&nb1, sizeof(nb1));
			ofs.sgetn((char *)&nb2, sizeof(nb2));
			ofs.sgetn((char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ofs.close();
}
 
void _test_write_win32(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
HANDLE h = CreateFile(Filename, FILE_ALL_ACCESS, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	if(h == NULL)
	{
		printf("Error while opening the win32 file (write mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			DWORD written;
			WriteFile(h, (const char *)&nb1, sizeof(nb1), &written, NULL);
			WriteFile(h, (const char *)&nb2, sizeof(nb2), &written, NULL);
			WriteFile(h, (const char *)&nb3, sizeof(nb3), &written, NULL);
		}
	}
 
	// Fermer
	CloseHandle(h);
}
 
void _test_read_win32(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en écriture
HANDLE h = CreateFile(Filename, FILE_ALL_ACCESS, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if(h == NULL)
	{
		printf("Error while opening the win32 file (read mode)");
		return;
	}
 
	// les 3 nombres à ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// lire le nombre
			DWORD read;
			ReadFile(h, (LPVOID)&nb1, sizeof(nb1), &read, NULL);
			ReadFile(h, (LPVOID)&nb2, sizeof(nb2), &read, NULL);
			ReadFile(h, (LPVOID)&nb3, sizeof(nb3), &read, NULL);
		}
	}
 
	// Fermer
	CloseHandle(h);
}
 
int main(int argc, char* argv[])
{
	int nb0 = 10;
	int nb1 = 1000;
	int nb2 = 1000;
 
	for(int boucle = 0; boucle != nb0; boucle++)
	{
		printf("\n", boucle);
		printf("Passe %d\n", boucle);
 
		_start_chrono();
		_test_write_io("c:\\temp\\file_write_io.bin", nb1, nb2);
		_display_chrono("write_io");
 
		_start_chrono();
		_test_read_io("c:\\temp\\file_write_io.bin", nb1, nb2);
		_display_chrono("read_io");
 
		_start_chrono();
		_test_write_stdio("c:\\temp\\file_write_stdio.bin", nb1, nb2);
		_display_chrono("write_stdio");
 
		_start_chrono();
		_test_read_stdio("c:\\temp\\file_write_stdio.bin", nb1, nb2);
		_display_chrono("read_stdio");
 
		_start_chrono();
		_test_write_stream("c:\\temp\\file_write_stream.bin", nb1, nb2);
		_display_chrono("write_stream");
 
		_start_chrono();
		_test_read_stream("c:\\temp\\file_write_stream.bin", nb1, nb2);
		_display_chrono("read_stream");
 
		_start_chrono();
		_test_write_filebuf("c:\\temp\\file_write_filebuf.bin", nb1, nb2);
		_display_chrono("write_filebuf");
 
		_start_chrono();
		_test_read_filebuf("c:\\temp\\file_write_filebuf.bin", nb1, nb2);
		_display_chrono("read_filebuf");
 
		_start_chrono();
		_test_write_win32("c:\\temp\\file_write_win32.bin", nb1, nb2);
		_display_chrono("write_win32");
 
		_start_chrono();
		_test_read_win32("c:\\temp\\file_write_win32.bin", nb1, nb2);
		_display_chrono("read_win32");
	}
 
	return 0;
}

et les résultats :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
write_io : 16.28, 16.23, 16.28, 16.28, 16.25, 16.27, 16.33, 16.27, 16.25, 16.30
write_win32 : 15.53, 15.48, 15.50, 15.48, 15.52, 15.61, 15.48, 15.55, 15.48, 15.55
write_stream : 0.83, 0.83, 0.83, 0.81, 0.81, 0.88, 0.83, 1.08, 0.83, 0.98
write_stdio : 0.59, 0.58, 0.58, 0.58, 0.58, 0.58, 0.58, 0.58, 0.58, 0.58
write_filebuf : 0.20, 0.20, 0.20, 0.20, 0.80, 0.63, 0.20, 0.20, 0.19, 0.20
 
read_io : 8.22, 8.20, 8.20, 8.25, 8.22, 8.19, 8.20, 8.20, 8.19, 8.17
read_win32 : 7.45, 7.45, 7.45, 7.45, 7.45, 7.45, 7.45, 7.45, 7.45, 7.48
read_stream : 1.30, 0.84, 0.59, 0.66, 0.59, 0.59, 0.59, 0.59, 0.66, 0.59
read_stdio : 0.59, 0.59, 0.58, 0.59, 0.59, 0.59, 0.59, 0.61, 0.59, 0.59
read_filebuf : 0.16, 0.16, 0.17, 0.17, 0.16, 0.16, 0.63, 0.16, 0.17, 0.16

Donc globalement, les accès WIN32 sont à peine plus rapides que les accès IO (ce qui semble logique). Les accès filebuf restent les plus rapides dans cette configuration de test

[Médinoc]

Pour des lectures/écritures aussi petites à bas niveau, c'est parfaitement logique en effet.
Et encore, cela doit être améliorable avec certains flags du genre FILE_FLAG_SEQUENTIAL_SCAN...

[loufoque]

Et sur un vrai système d'exploitation, comme GNU/Linux, ça donne quoi ?

[ram-0000]

Et sur un vrai système d'exploitation, comme GNU/Linux, ça donne quoi ?

Un peu polèmique comme remarque

Je ne sais pas, j'ai pas. Quelqu'un pour adapter mon programme et faire les mesures ?

[Twindruff]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
#include <stdio.h>
//#include <io.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <fstream>
 
#include <sys/times.h>
#include <unistd.h>
 
const char* nom_type[] = {"io", "stdio", "stream", "filebuf"};
const char* nom_read[] = {"write", "read"};
 
const int NB0 = 6;
clock_t tps[NB0][4][2];
 
tms _chrono_a;
tms _chrono_b;
 
void _start_chrono(void)
{
	times(&_chrono_a);
}
 
void _display_chrono(int passe, int type, int read)
{
	times(&_chrono_b);
	clock_t diffa = _chrono_b.tms_utime - _chrono_a.tms_utime;
	clock_t diffb = _chrono_b.tms_stime - _chrono_a.tms_stime;
	printf("%s_%s : Elapsed time is %lu ticks\n", nom_read[read], nom_type[type], diffa + diffb);
 
	tps[passe][type][read] = diffa + diffb;
}
 
void _test_write_io(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en \u00e9criture
	int fh = open(Filename, O_WRONLY | O_CREAT, S_IREAD | S_IWRITE);
	if(fh == -1)
	{
		printf("Error while opening the IO file (write mode)");
		return;
	}
 
	// les 3 nombres \u00e0 ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(unsigned int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(unsigned int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			write(fh, &nb1, sizeof(nb1));
			write(fh, &nb2, sizeof(nb2));
			write(fh, &nb3, sizeof(nb3));
		}
	}
 
	// fermeture du fichier
	close(fh);
}
 
void _test_read_io(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en \u00e9criture
	int fh = open(Filename, O_RDONLY);
	if(fh == -1)
	{
		printf("Error while opening the IO file (read mode)");
		return;
	}
 
	// les 3 nombres \u00e0 ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(unsigned int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(unsigned int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			read(fh, &nb1, sizeof(nb1));
			read(fh, &nb2, sizeof(nb2));
			read(fh, &nb3, sizeof(nb3));
		}
	}
 
	// fermeture du fichier
	close(fh);
}
 
void _test_write_stdio(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en \u00e9criture
	FILE *fh = fopen(Filename, "wb");
	if(fh == NULL)
	{
		printf("Error while opening the STDIO file (write mode)");
		return;
	}
 
	// les 3 nombres \u00e0 ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(unsigned int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(unsigned int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			fwrite(&nb1, sizeof(nb1), 1, fh);
			fwrite(&nb2, sizeof(nb2), 1, fh);
			fwrite(&nb3, sizeof(nb3), 1, fh);
		}
	}
 
	// fermeture du fichier
	fclose(fh);
}
 
void _test_read_stdio(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en \u00e9criture
	FILE *fh = fopen(Filename, "rb");
	if(fh == NULL)
	{
		printf("Error while opening the STDIO file (read mode)");
		return;
	}
 
	// les 3 nombres \u00e0 ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(unsigned int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(unsigned int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			fread(&nb1, sizeof(nb1), 1, fh);
			fread(&nb2, sizeof(nb2), 1, fh);
			fread(&nb3, sizeof(nb3), 1, fh);
		}
	}
 
	// fermeture du fichier
	fclose(fh);
}
 
void _test_write_stream(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en \u00e9criture
	std::ofstream ofs;
	ofs.open(Filename, std::ios::out | std::ios::binary);
	if(ofs.is_open() == false)
	{
		printf("Error while opening the STREAM file (write mode)");
		return;
	}
 
	// les 3 nombres \u00e0 ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(unsigned int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(unsigned int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ofs.write((const char *)&nb1, sizeof(nb1));
			ofs.write((const char *)&nb2, sizeof(nb2));
			ofs.write((const char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ofs.close();
}
 
void _test_read_stream(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en \u00e9criture
	std::ifstream ifs;
	ifs.open(Filename, std::ios::in | std::ios::binary);
	if(ifs.is_open() == false)
	{
		printf("Error while opening the STREAM file (read mode)");
		return;
	}
 
	// les 3 nombres \u00e0 ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(unsigned int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(unsigned int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ifs.read((char *)&nb1, sizeof(nb1));
			ifs.read((char *)&nb2, sizeof(nb2));
			ifs.read((char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ifs.close();
}
 
void _test_write_filebuf(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en \u00e9criture
	std::filebuf ofs;
	ofs.open(Filename, std::ios::out | std::ios::binary);
	if(ofs.is_open() == false)
	{
		printf("Error while opening the filebuf file (write mode)");
		return;
	}
 
	// les 3 nombres \u00e0 ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(unsigned int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(unsigned int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ofs.sputn((const char *)&nb1, sizeof(nb1));
			ofs.sputn((const char *)&nb2, sizeof(nb2));
			ofs.sputn((const char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ofs.close();
}
 
void _test_read_filebuf(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en \u00e9criture
	std::filebuf ofs;
	ofs.open(Filename, std::ios::in | std::ios::binary);
	if(ofs.is_open() == false)
	{
		printf("Error while opening the filebuf file (read mode)");
		return;
	}
 
	// les 3 nombres \u00e0 ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(unsigned int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(unsigned int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			ofs.sgetn((char *)&nb1, sizeof(nb1));
			ofs.sgetn((char *)&nb2, sizeof(nb2));
			ofs.sgetn((char *)&nb3, sizeof(nb3));
		}
	}
 
	// Fermer et detruire.
	ofs.close();
}
 
/*
void _test_write_win32(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en \u00e9criture
HANDLE h = CreateFile(Filename, FILE_ALL_ACCESS, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	if(h == NULL)
	{
		printf("Error while opening the win32 file (write mode)");
		return;
	}
 
	// les 3 nombres \u00e0 ecrire
	float nb1 = 1.0;
	float nb2 = 2.0;
	float nb3 = 3.0;
 
	// ecriture 2048 * 2048 * 3
	for(unsigned int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(unsigned int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// ecrire le nombre
			DWORD written;
			WriteFile(h, (const char *)&nb1, sizeof(nb1), &written, NULL);
			WriteFile(h, (const char *)&nb2, sizeof(nb2), &written, NULL);
			WriteFile(h, (const char *)&nb3, sizeof(nb3), &written, NULL);
		}
	}
 
	// Fermer
	CloseHandle(h);
}
 
void _test_read_win32(const char * Filename, const unsigned long Nb1, const unsigned long Nb2)
{
	// ouverture du fichier en \u00e9criture
HANDLE h = CreateFile(Filename, FILE_ALL_ACCESS, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if(h == NULL)
	{
		printf("Error while opening the win32 file (read mode)");
		return;
	}
 
	// les 3 nombres \u00e0 ecrire
	float nb1 = 0.0;
	float nb2 = 0.0;
	float nb3 = 0.0;
 
	// ecriture 2048 * 2048 * 3
	for(unsigned int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(unsigned int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			// lire le nombre
			DWORD read;
			ReadFile(h, (LPVOID)&nb1, sizeof(nb1), &read, NULL);
			ReadFile(h, (LPVOID)&nb2, sizeof(nb2), &read, NULL);
			ReadFile(h, (LPVOID)&nb3, sizeof(nb3), &read, NULL);
		}
	}
 
	// Fermer
	CloseHandle(h);
}
*/
 
int main(int argc, char* argv[])
{
	int nb1 = 1000;
	int nb2 = 1000;
 
 
	for(int boucle = 0; boucle != NB0; boucle++)
	{
		printf("\n");
		printf("Passe %d\n", boucle);
 
		_start_chrono();
		_test_write_io("/tmp/file_write_io.bin", nb1, nb2);
		_display_chrono(boucle, 0, 0);
 
		_start_chrono();
		_test_read_io("/tmp/file_write_io.bin", nb1, nb2);
		_display_chrono(boucle, 0, 1);
 
		_start_chrono();
		_test_write_stdio("/tmp/file_write_stdio.bin", nb1, nb2);
		_display_chrono(boucle, 1, 0);
 
		_start_chrono();
		_test_read_stdio("/tmp/file_write_stdio.bin", nb1, nb2);
		_display_chrono(boucle, 1, 1);
 
		_start_chrono();
		_test_write_stream("/tmp/file_write_stream.bin", nb1, nb2);
		_display_chrono(boucle, 2, 0);
 
		_start_chrono();
		_test_read_stream("/tmp/file_write_stream.bin", nb1, nb2);
		_display_chrono(boucle, 2, 1);
 
		_start_chrono();
		_test_write_filebuf("/tmp/file_write_filebuf.bin", nb1, nb2);
		_display_chrono(boucle, 3, 0);
 
		_start_chrono();
		_test_read_filebuf("/tmp/file_write_filebuf.bin", nb1, nb2);
		_display_chrono(boucle, 3, 1);
 
		/*
		_start_chrono();
		_test_write_win32("/tmp/file_write_win32.bin", nb1, nb2);
		_display_chrono("write_win32");
 
		_start_chrono();
		_test_read_win32("/tmp/file_write_win32.bin", nb1, nb2);
		_display_chrono("read_win32");
		*/
	}
 
	for(int read = 0; read < 2; read++)
	{
		for(int type = 0; type < 4; type++)
		{
			printf("%s_%s: ", nom_read[read], nom_type[type]);
 
			for(int passe = 0; passe < NB0; passe ++)
			{
				printf("%lu, ", tps[passe][type][read]);
			}
			printf("\n");
		}
	}
 
	return 0;
}

Voilà ce que ça donne chez moi en linux (résultat en ticks). Et c'est normal que les appels systèmes soient bien plus lents vu que rien n'est bufferisé.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
write_io: 480, 481, 484, 482, 482, 480, 
write_stdio: 12, 13, 12, 11, 12, 12, 
write_stream: 19, 19, 19, 19, 18, 19, 
write_filebuf: 16, 15, 17, 15, 15, 15, 
read_io: 190, 190, 194, 191, 191, 190, 
read_stdio: 17, 16, 17, 17, 16, 16, 
read_stream: 16, 16, 15, 16, 17, 17, 
read_filebuf: 13, 13, 13, 13, 13, 13