Discussion :

[Nico_stras]

Bonjour,
Je souhaitrais savoir quel est le moyen le plus efficace pour lire un fichier octet par octet (pour calculer un checksum).

ce qui parait le simple, c'est :

- fopen()
- fread() de 1 octet jusqu'à EOF
- fclose()

Sachant que le fichier est sur une mémoire de masse, est ce que le fopen() va tout copier en RAM ?
Est ce que la fonction fread est une fonction "lente" ?
Est-il plus efficace de de lire tout le fichier d'un coup (quid de la récupération sa taille...) et de le placer dans un char* avant de manipuler cette variable ?

Merci d'avance pour vos avis.

PS : développement sur un OS type UNIX

Nicolas

[Neckara]

Tu peux déjà utiliser les fonctions open, read et close au lieu de fopen, fread et fclose pour être plus rapide.

Pour fopen, il ne me semble pas qu'il copie tout en RAM mais qu'il copie le(s) partie(s) du fichiers sur lequel tu travaille actuellement (à vérifier tout de même)

Tu peux en effet lire ton fichier d'un coup je pense que ce sera plus pratique et rapide. Dans ce cas là pour récupérer la taille de ton fichier, utilise struct stat de sys/stat.h

[matafan]

Au contraire, si tu fais des lectures octet par octet fopen/fread sera beaucoup plus rapide que open/read puisque les lectures sont bufferisées.

Effectivement fread charge le fichier par morceaux. On peut changer la taille du buffer avec setvbuf().

L'autre option, c'est de mapper le fichier en mémoire avec mmap(). C'est plus simple et potentiellement plus efficace si tu dois faire des accès aléatoires. Si tu lis le fichier séquentiellement, ça ne change pas grand chose.

[phi1981]

Au contraire, si tu fais des lectures octet par octet fopen/fread sera beaucoup plus rapide que open/read puisque les lectures sont bufferisées

En effet, fopen cause une bufferisation du fichier, que open ne fait pas (du moins par défaut).
Mais une fois fopen appelée, lire le fichier octet par octet peut se faire simplement avec fgetc(), qui utilisera le buffer créé par fopen. C'est plus simple que d'utiliser fread.

[Nico_stras]

Voici ce que j'ai pour le moment :

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
UINT16 CRC_File(const char* szPath)
{
	FILE* fichier ;
	char c ;
 
	UINT8 j = 0 ;
	UINT16 usCRCWord = 0;
	UINT16 usPoly = 0x8408;
	UINT8 bParite=0 ;
 
 
	fichier = fopen(szPath,"r") ;
	if(0!=fichier)
	{
		while(feof(fichier)==0)
		{
			fread(&c,1,1,fichier) ;
 
			usCRCWord^=c;
			for(j=0;j<8;j++)
			{
				if(usCRCWord & 1)
					bParite=0;
				else
					bParite=1;
				usCRCWord>>=1;
				if(!bParite)
					usCRCWord^=usPoly;
			}
 
		}
 
		fclose(fichier) ;
	}
	return usCRCWord ;
}

Donc si j'ai bien compris, mieux vaut utiliser une variable intermédiaire (const char*) et appeler une seule fois la fonction fread().

Dans ce cas, je suis obligé de passer par un malloc() pour créer mon buffer.

Correct ?

[Nico_stras]

Mais une fois fopen appelée, lire le fichier octet par octet peut se faire simplement avec fgetc(), qui utilisera le buffer créé par fopen. C'est plus simple que d'utiliser fread.

Pourquoi plus simple ?
fgetc() n'est pas à utiliser que pour de l'ascii ?

[Taurre]

Salut,

Mais une fois fopen appelée, lire le fichier octet par octet peut se faire simplement avec fgetc(), qui utilisera le buffer créé par fopen. C'est plus simple que d'utiliser fread.

Juste pour dire, parce que la phrase est ambiguë, la fonction fread utilise également le tampon alloué par fopen. De manière générale, toute les fonctions standard de traitement de flux utilisent le tampon associé à un flux (lorsqu'il en a un).

fgetc() n'est pas à utiliser que pour de l'ascii ?

Non, étant donné qu'un flux binaire n'est qu'une suite ordonnée de byte (char), il est tout à fait possible de lire chacun d'entre eux à l'aide de fgetc.

Sinon, pour répondre à la question, la bonne solution me semble d'ouvrir le fichier en mode binaire ("rb") et d'effectuer la lecture par bloc de taille BUFSIZ. Autrement dit, de remplir un tableau de unsigned char de taille BUFSIZ à l'aide de fread et de parcourir ensuite ce dernier caractère par caractère pour effectuer la somme.

L'autre option, c'est de mapper le fichier en mémoire avec mmap(). C'est plus simple et potentiellement plus efficace si tu dois faire des accès aléatoires. Si tu lis le fichier séquentiellement, ça ne change pas grand chose.

Tu peux en effet lire ton fichier d'un coup je pense que ce sera plus pratique et rapide. Dans ce cas là pour récupérer la taille de ton fichier, utilise struct stat de sys/stat.h

Je doute que ces deux solutions soient plus rapide qu'une lecture par bloc étant donné qu'elles impliquent une allocation dynamique potentiellement importante (voir irréalisable si le fichier est trop volumineux).

[Obsidian]

Hello,

Pourquoi plus simple ?
fgetc() n'est pas à utiliser que pour de l'ascii ?

Non. fgetc() va te renvoyer un unsigned char dans le sens C du terme, transtypé en INT pour pouvoir éventuellement te renvoyer EOF. C'est assurément ce qu'il y a de plus simple ici.