Discussion :

[Platon d'athene]

bonjour tout le monde,
c'etait vraiment un peu penible de developper le code source suivant qui fait:
-la création d'un fichier.
-le remplissage de ce fichier par une quantité de données aux choix, cette quantité est fixées comme argument lors de l'exécution sur le shell linux.

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
 
#include <sys/time.h>
 
int usage(char* prog_name) {
    printf("%s output_file_name length (in Megabytes)\n", prog_name);
    return -1;
}
 
int main(int argc, char* argv[]) {
    int rc = 0;
    FILE* fp_outfile;
    int len, count, wrote;
    unsigned char bytes[1024 * 1024];
    struct timeval start, finish, difference;
 
    memset(bytes, 0xAA, sizeof(bytes));
 
    if (argc < 3) {
	return usage(argv[0]);
    } else {
	len = atoi(argv[2]);
	count = len;
	if (len > 0) {
	    fp_outfile = fopen(argv[1], "w+");
	    if (fp_outfile != NULL) {
		gettimeofday(&start, NULL);
		while (len > 0) {
		    wrote = fwrite(bytes, 1, sizeof(bytes), fp_outfile);
		    if (wrote != sizeof(bytes)) {
			printf("error %d during fwrite\n", ferror(fp_outfile));
		    }
		    --len;
		}
		gettimeofday(&finish, NULL);
		timersub(&finish, &start, &difference);
		fclose(fp_outfile);
		printf("wrote %d megabytes in %d seconds and %d microseconds\n",
		    count, (int)difference.tv_sec, (int)difference.tv_usec);
	    } else {
		rc = errno;
		printf("error %d opening file %s\n", rc, argv[1]);
	    }
	} else {
	    printf("error %d length %d is not permitted\n", EINVAL, len);
	    rc = EINVAL;
	}
    }
    return rc;
}

quand je fixe une quantité de données inferieure a 2048 mega octet (c'est équivalent à 2 Giga Octet REELLES) ça marche parfaitement, pourtant quand je fixe une qunatité superieure (2049 et plus, ça ne marche pas, on fait l'écriture dans le fichier ne depasse pas les 2048 megas octets )
j'en ai marre vraiment

[Obsidian]

Est que, par hasard, tu n'aurais pas déjà reçu une explication concernant ce phénomène ?

[Platon d'athene]

bonjour Obsidian ,,,
le proplème c'est que, une fois compilé, ce code fonctionne correctement pour n'importe quelle valeur qu'on introduit, en depassant les 2048 mega octets, l'ecriture cesse, le message d'erreur

Code :

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

printf("error %d opening file %s\n", rc, argv[1]);

que j'ai introduit apparait une fois pour chaque mega octet qui depasse les 2048 ,,,, par examlpe il s'affiche 2 fois si on met 2049 comme argument.

[Obsidian]

On t'a dit pourquoi : relis mon message précédent (et suis le lien qu'y s'y trouve).

• Si ton système de fichiers est un peu trop ancien, il ne saura pas gérer les fichiers plus grands que 2 Gio ;
• Si tu travailles sur une architecture 32 bits, les « int » eux-mêmes ne pourront pas coder de valeur supérieure à 2 Gio ;
• Ton programme contient encore plein de bugs par ailleurs.

Encore un effort !

[Platon d'athene]

Bonjour Obsidian ,,,

ouais, en fait j'ai bien rendu compte de ta remarque concernant les fichiers de taille superieure à 2G ,, en fait j'utilise le système de fichiers ext2 qui peut suporter jusqu'à 16GB, et j'avoue, l'architecture que je suis entrain d'utiliser une machine a 32bit

Ps: je ne suis ni ingenieur ni expert, je ne suis qu'un simple étudiant en génie éléctrique aui est entrain d'effectuer un projet de fin d'études. donc je suis encore débutant, en tout cas j'apprécie bien ton aide Obsidian, et j'avoue que j'ai beaucoup appris grâce à tes conseils

[Obsidian]

ouais, en fait j'ai bien rendu compte de ta remarque concernant les fichiers de taille superieure à 2G ,, en fait j'utilise le système de fichiers ext2 qui peut suporter jusqu'à 16GB, et j'avoue, l'architecture que je suis entrain d'utiliser une machine a 32bit

Oui, mais ça ne suffit pas : le système de fichiers peut être indépendant du système qui l'utilise si le support est amovible. Ça veut dire que tout le VFS, c'est-à-dire l'infrastructure qui permet au système de gérer des fichiers de manière générale, indépendamment du filesystem employé, code a priori ses valeurs sur 32 bits. Regarde la man page de open(2) :

O_LARGEFILE
Sur les systèmes 32 bits qui supportent les Systèmes de Fichiers Larges, autoriser quand même l'ouverture des fichiers dont la taille ne peut pas être représentée sur 31 bits.

Et sur une man page plus récente (Fedora 16) :

O_LARGEFILE
(LFS) Permet d'ouvrir des fichiers dont la taille ne peut pas être représentée dans un off_t (mais peut l'être dans un off64_t). La macro _LARGEFILE64_SOURCE doit être définie pour obtenir cette définition. Fixer la macro _FILE_OFFSET_BITS à 64 est la méthode à favoriser pour accéder à des grands fichiers sur des systèmes 32 bits, plutôt que d'utiliser O_LARGEFILE (voir feature_test_macros(7)).

Attention : fopen() est défini par le langage C, mais open() l'est par UNIX (et maintenant POSIX). Gérer les grands fichiers relève donc de la programmation système.

La vraie question, maintenant, est : pourquoi est-ce que tu veux produire de si gros fichiers ? À part pour l'exercice, c'est se causer des ennuis, à soi et à ceux qui devront gérer tes fichiers ensuite.

Ps: je ne suis ni ingenieur ni expert, je ne suis qu'un simple étudiant en génie éléctrique aui est entrain d'effectuer un projet de fin d'études. donc je suis encore débutant, en tout cas j'apprécie bien ton aide Obsidian, et j'avoue que j'ai beaucoup appris grâce à tes conseils

Ben, dans ce cas-là, change de profil : il est écrit « ingénieur validation » dans ta fiche, à gauche de tes commentaires. Ce n'est pas une honte d'être étudiant, au contraire. Nous en avons beaucoup ici et ça permet aux membres de savoir directement à quel genre de profil ils s'adressent.

[Bktero]

Si tu es étudiant en génie électrique, n'affiche pas dans ton profil que tu es ingénieur en validation, car certaines personnes ici adaptent leur discours et leurs réactions en fonction du niveau supposé des posteurs
(message écrit simultanément à celui d'Obsidian ^^)

Ce paragraphe http://en.wikipedia.org/wiki/Ext2#File_system_limits et cet article http://en.wikipedia.org/wiki/Large_file_support devraient t'intéresser.

[Platon d'athene]

Bonjour tout le monde, le problème est finalement résolu, en fait pour les machines a 32bit on ne peut pas ouvrir un fichier de taille supérieure a 2 GB, en fait 2147483648 octets est le resultat de 2^31. Or, en utilisant une machine de 32 bits, on est entrain d’utiliser un pointeur FILE* de 32 bits,,,
En fait avec une formule « magique » on peut recompiler le code comme la suite :
gcc -g -Wall -W -pedantic -o main main.c -D_FILE_OFFSET_BITS=64

Maintenant on peut écrire des fichiers autant plus grands que l’on veut,
Mes amis, en fait si vous posez la question : pourquoi aurons nous besoin d’une telle création, de tels grands fichiers, en fait une partie de mon projet consiste à effectuer des transferts de grande masse su un disque dur monté sur un port USB3.0 afin de tester la performance de cette liaison plus ou moins nouvelle.
Merci pour votre aide précieux et extrêmement utile.