Discussion :

[DrTank]

Hello,

J'aimerais trouver l'algorithme qui me permettrait de remplir un fichier, d'une taille inconnue à l'avance, le plus rapidement possible et également le moins couteux possible en terme de mémoire (alloc dynamique interdite).

En gros moi je vois quelque chose de ce genre :

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
 
long Size, NbBytes;
long lBuf = 0xAAAAAAAA;
char cBuf = 0xAA;
 
File.Open(pName)
 
Size = File.Size();
NbBytes = Size;
 
File.Seek(0);
 
if (Size > sizeof(long)) {
  do {
    File.Write(&lBuf, sizeof(long));
    NbBytes -= sizeof(long);
  } while(NbBytes >= sizeof(long));
}
 
while (NbBytes-- > 0) {
  File.Write(&cBuf, 1);
}
 
File.Close();

En résumé écrire des pattern de 4 octets. Ou alors ai-je meilleur temps d'écrire des gros blocs de plusieurs dizaines d'octets?

Qu'en pensez-vous?

[ram-0000]

Je dirai par bloc de 512 ou 1024 octets plutôt que par bloc de 4 ou 10.

Maintenant, tu peux aussi essayez cela :

Code :

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

1
2
3
FILE *fd = fopen();
fseek(fd, SEEK_SET, <taille désirée>);
fclose(fd);

Je pense que cela te créé ton fichier de la bonne taille directement mais par contre, je ne sais pas le contenu du fichier.

[orfix]

Malheureusement chez moi cela ne fonctionne pas (Linux 2.6.27-11-generic) j'en déduis qu'il faut à tout prix écrire quelque chose et c'est logique je pense :

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
 
#include  <stdio.h>
#include  <stdlib.h>
 
#define  KB	* 1024L
 
int main( void )
{
	FILE *fd = fopen("dummy", "wb");
 
	if( fd!=NULL )
	{
		fseek(fd, 4 KB ,SEEK_SET);
		fputc('X',fd);
		fclose(fd);
	}
 
	return 0;
}

Code :

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

1
2
3
4
5
6
7
 
4,0K dummy
 
00000000  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00001000  58                                                |X|
00001001

[Mac LAK]

Il n'y a pas de méthode générique... Cela dépend de beaucoup de facteurs :

• Le système d'exploitation,
• La taille des buffers de fichiers de l'OS, qui peut être un pourcentage de la mémoire physique présente.
• La mémoire cache présente sur les disques durs.
• La taille des clusters sur la partition cible.

Bref, pas de réponse "absolue"... Et sans allocation dynamique, ni buffer de taille "conséquente" alloués sur la pile (variable locale), ce sera encore plus difficile d'aller à la vitesse maximale.

Dans tous les cas, prépare un bench quand même afin d'être objectif, et il faudrait même redémarrer le PC entre chaque test pour être certain de ne pas avoir d'effet de bord lié à la mémoire cache.

[DrTank]

Effectivement j'aurais du préciser que je suis en contexte embarqué, le filesystem pèse environ 1Mo (ça peut faire peur ) et je n'ai pas accès à la lib standard pour la gestion des fichiers.

[nicolas.sitbon]

Je dirai par bloc de 512 ou 1024 octets plutôt que par bloc de 4 ou 10.

Maintenant, tu peux aussi essayez cela :

Code :

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

1
2
3
FILE *fd = fopen();
fseek(fd, SEEK_SET, <taille désirée>);
fclose(fd);

Je pense que cela te créé ton fichier de la bonne taille directement mais par contre, je ne sais pas le contenu du fichier.

Non, mais truncate() et ftruncate() le font, par contre c'est POSIX et non standard C.