Discussion :

[loufoque]

Chez moi que j'utilise std::string ou char* j'ai les mêmes performances... Ce qui est absolument normal.

[Luc Hermitte]

Qu'il y ait une perte de perf à cause de copies de 300mo de chaines, ce n'est pas forcément surprenant, surtout si tu compares par rapport à l'utilisation de vues (extraction de pointeurs, 0 copie)

[epsilon68]

j'utilise beaucoup de spilt et de map<string,string>
c'est clair que ca ne peut pas rivaliser avec des char*.
surtout quand les char * ne font que pointer vers la zone du fichier en memoire.....

cas particulier ? peut-etre mais sans cette optimisation on peut laisser tomber la version C++ (inutilisable!)

bonne nouvelle pour certains: Qt n'apporte aucune ameliorations la ou je pensais que l'implicit sharing etait performant :/ je suis decu

[Luc Hermitte]

Au mieux, utilises plutôt un truc type flex_string avec une police type vue pour la gestion de la mémoire et des copies -- cf le site d'Andrei Alexandrescu pour la flex_string.

L'implicit sharing n'est qu'un COW intrusif et atomique. Certaines implémentations de la std::string sont aussi des COW (atomique, je ne sais pas). La construction fonctionne aussi comme une copie, et n'agit en rien comme une vue. Cela va souffrir du même problème que la std::string, et au mieux on gagne les copies de manipulations maps.

[epsilon68]

L'implicit sharing n'est qu'un COW intrusif et atomique. Certaines implémentations de la std::string sont aussi des COW (atomique, je ne sais pas). La construction fonctionne aussi comme une copie, et n'agit en rien comme une vue. Cela va souffrir du même problème que la std::string, et au mieux on gagne les copies de manipulations maps.

justement j'attendais un gain pour les copies mais ce n'est pas du tout le cas, malheureusement. Je revise beaucoup mes avis en ce moment....

[edit] et la STL de Qt n'a pas de bonnes perf je trouve

[etranger]

si tu travail sous windows et que tu ne souhaite pas porter ton application, tu pourait tirer profit des API windows, j'avais une fois eu le meme probleme que toi, et j'avais fini par utiliser un truc du genre MapFileEx (je ne rappel pas tres bien).

Sinon pourquoi ne pas coder ta partie critique en C ?

[epsilon68]

les resultats pour C# peuvent quand meme faire reflechir.
ce qu'il y a de bien dans le c++, c'est qu'il y a toujours un moyen pour optimiser ....

[loufoque]

j'utilise beaucoup de spilt et de map<string,string>

Ah d'accord... Moi je parlais du std::getline

[backlash]

Bonsoir,

Je déterre ce vieux poste car je dois lire un fichier de plus de 2 millions de lignes de plus de 60 caractères chacunes, sa taille est d'environ 241 Mo.

J'ai effectuer 2 tests :
-un test avec les flux C++ Fstream
-un test avec une version C à base de FILE

Etrangement la version C++ est la plus rapide contrairement aux précédents posts qui semblait prôner la toute puissance des lectures de fichier en C.

Ma machine de test est composé d'un processeur dual core Core2Duo 3GHZ, disque dur 7200 tr/min et de 2Go de ram, mon OS est Ubuntu 11.10 tournant sur un noyau Linux 3.0.0-15 generic avec gcc 4.6.1 avec l'options O0.

En ce qui concerne le comptage du temps, j'utilise une horloge Posix d'une précision de l'ordre de la nanoseconde.

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
 
#include <iostream>
#include <string>
#include <fstream>
#include <ctime>
#include <cmath>
#include <cstdio>
 
using namespace std;
 
void testFstream(string fileName)
{
	fstream file(fileName.c_str());
	string line;
 
	while (!file.eof())
	{
		getline(file, line);
	}
 
	file.close();
}
 
void testCstream(string fileName)
{
	FILE* file;
	char line[100];
 
	file = fopen(fileName.c_str(), "rw");
 
	while (!feof(file))
	{
		fgets(line, 100, file);
	}
 
	fclose(file);
}
 
int main()
{
	struct timespec tBegin, tEnd;
 
        for (int i = 0; i < 10; ++i)
	{
		clock_gettime(CLOCK_REALTIME, &tBegin);
		//testFstream("test1");
		testCstream("test1");
		clock_gettime(CLOCK_REALTIME, &tEnd);
		cout << (tEnd.tv_sec * pow(10.0, 9) + tEnd.tv_nsec - (tBegin.tv_sec * pow(10.0, 9) + tBegin.tv_nsec)) / pow(10.0, 6) << " ms" << endl;
	}
 
	return 0;
}

J'obtiens les résultats suivants :
-version C++ : environ 340 millisecondes
-version C : environ 476 millisecondes

Est ce qu'il y aurait moyen d'aller encore plus vite?

[jabbounet]

pourquoi 'rw' sur le fopen?

'r' est suffisant.

de plus il est possible d'éviter l'appel a feof car fgets retourne NULL en cas d'erreur ou si la fin du fichier est atteinte.

Code :

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

1
2
3
4
 
while (fgets(line, 100, file)
{ /* les traitement a venir */
}

Tu as au moins trois possibilité

• fgets largement abordé ici (implique un raisonnement par ligne)
• fread peut te permettre de lire plusieurs ligne à la fois mais il faudra abandonner le raisonnement par ligne pour espérer un gain par rapport a fgets.
• mmap qui te permet de monter le fichier directement en ram

en fonctions des cas (taille du fichier / os / contenu du fichier ....) une méthode peut être plus efficace qu'une autre.

Cependant plus le format du fichier est déterministe (par exemple chaque éléments à lire à une position fixe dans chaque ligne plus il sera possible d'optimiser le traitement en calculant par exemple l'a zone de la prochaine lecture.