Problème de création de fichiers .txt en boucle

Version imprimable

25/08/2008, 18h15
droledelolo

Problème de création de fichiers .txt en boucle

Slt à tous,

Je suis actuellement confronté à un petit problème concernant la création de fichiers.

J'ai hérité d'un code dans lequel on crée autant de fichiers .txt que l'utilisateurs en paramètre, au moyen du code suivant :

Citation:

ofstream *sortie_streaming = NULL;

if (pdc->nb_utilisateurS != 0)
sortie_streaming = new ofstream[pdc->nb_utilisateurS];

sortie_streaming[i].open(fichier_out[i]);

où fichier_out[i] est le nom du fichier à créer.

Seulement, lorsque "pdc->nb_utilisateurS" est grand (>508) les fichiers ne sont plus créés. Quoi qu'il se passe, il n'y aura que 508 fichiers .txt créés.

Quelqu'un a-t-il une idée d'où ça peut venir, ou sinon connaissez-vous une autre méthode pour créer des fichiers .txt à la chaine ?

Merci d'avance.
25/08/2008, 18h26
Jean-Marc.Bourguet

Les OS imposent generalement une limite au nombre de fichiers ouverts simultanement par un process. Ton nombre 508 est fort proche de 512 ce qui est un nombre suspect de ce point de vue (tenir compte de cin, cout et d'un autre fichier ou l'autre).

S'il est possible, il vaut mieux refermer les fichiers quand tu n'en n'a plus besoin et ne les ouvrir qu'a ce moment la (avoir besoin de plus de 500 fichiers ouverts simultanement, ca demande vraisemblablement un redesign).

Sinon, tu peux chercher si ton OS permet de controler ce nombre (limit/ulimit sous Unix par exemple).
25/08/2008, 18h33
droledelolo

D'accord,

Mais j'avais pensé au nombre limité de fichiers à ouvrir en même temps, et pour voir si j'avais atteint la limite, j'ai mis dans la boucle un deuxième fichier à ouvrir à chaque fois.

Ce coup-ci ça bloque à 500 fichiers x 2 = 1000 fichiers. Donc je ne pense pas avoir atteint la limite avec 508 ?
25/08/2008, 19h31
Jean-Marc.Bourguet

Citation:

Envoyé par droledelolo

D'accord,

Mais j'avais pensé au nombre limité de fichiers à ouvrir en même temps, et pour voir si j'avais atteint la limite, j'ai mis dans la boucle un deuxième fichier à ouvrir à chaque fois.

Tu ne le refermerais pas par hazard? La limite porte sur le nombre de fichiers ouverts simultanément.
25/08/2008, 23h56
droledelolo

Non du tout. Je les ouvre tous en même temps et je les referme à la toute fin du programme. C'est à dire que je peux en ouvrir au moins 1000 à la fois !:?
26/08/2008, 11h57
Obsidian

Citation:

Envoyé par Jean-Marc.Bourguet

Les OS imposent generalement une limite au nombre de fichiers ouverts simultanement par un process. Ton nombre 508 est fort proche de 512 ce qui est un nombre suspect de ce point de vue (tenir compte de cin, cout et d'un autre fichier ou l'autre).

Oui ! Si tu ajoutes cin, cout et cerr, ça monte à 511 ! :-)
26/08/2008, 12h33
Obsidian

Citation:

Envoyé par droledelolo

Non du tout. Je les ouvre tous en même temps et je les referme à la toute fin du programme. C'est à dire que je peux en ouvrir au moins 1000 à la fois !:?

Est-ce que tu n'ouvrirais pas deux fois le même fichier ? En rw ou ro ?
26/08/2008, 16h11
droledelolo

Non du tout.

J'ouvre simultanément 1000 fichiers différents.
26/08/2008, 19h56
wiztricks

a tout hasard vérifiez que les fichiers_out[i] sont bien distincts.
- W
27/08/2008, 11h18
droledelolo

Non j'ai bien vérifié et tous les fichiers ont un nom différent.

Je me demandais si ça ne viendrais pas de la syntaxe consistant à créer un tableau d'ofstream ?
Ne vaudrait-il pas mieux les ouvrir sans passer par un tableau. Mais à ce moment là comment créer les sortie_streaming1, sortie_streaming2, etc. sans cette forme : sortie_streaming[1], sortie_streaming[2], etc. ?

Merci pour votre aide.
27/08/2008, 11h21
JolyLoic

Tu peux montrer ton code avec les 1000 fichiers ?
27/08/2008, 11h43
droledelolo

Voilà :

Citation:

// Calcul du nom du fichier de sortie
strcpy(fichier_out[i], pdc->FILE_streaming);
strcat(fichier_out[i], "UE_");
strcat(fichier_out[i], nom_fichier[i]);
strcat(fichier_out[i], ".txt");

/* Ouverture du fichier streaming*/
sortie_streaming[i].open(fichier_out[i]);
if(!sortie_streaming[i])
cout << fichier_out[i] << endl;

/* Calcul du nom du fichier de sortie 2*/
strcat(fichier_out[i], ".txt");
/* Ouverture du fichier streaming*/
sortie_streaming2[i].open(fichier_out[i]);
if(!sortie_streaming2[i])
cout << fichier_out[i] << endl;

Mais au temps pour moi en fait je n'ouvre comme ça que 800 fichiers (2 x 400).

J'espère que ça peut aider.
27/08/2008, 11h47
droledelolo

Je viens de faire l'expérience. J'en ouvre 3 x 450 lorsque j'utilise sortie_streaming, sortie_streaming2, sortie_streaming3.
27/08/2008, 13h15
Jean-Marc.Bourguet

Est-ce que tu peux
1/ donner un code minimal et complet reproduisant le probleme
2/ donner ta plateforme; j'ai toujours l'impression qu'il s'y trouve peut-etre un aspect de la cause.
27/08/2008, 15h10
droledelolo

En gros le programme est construit comme cela :

Citation:

déclaration des structures (pdc par exemple)

main()
{
initialisations
scheduling(......)
......
}

avec la fonction scheduling(......) qui est comme ceci :

Citation:

scheduling(......)
{
initialisations
création problématique des fichiers textes
.....
}

Les parties d'initialisation sont en gros une initialisation de toutes les structures comprise dans le programme. Donc pas intéressante pour mon problème je pense.

Bon j'ai essayé de mettre la partie de code qui ne fonctionne pas à part. Et elle ne fonctionne toujours pas, même lorsqu'elle n'est pas imbriqué dans tout le programme.

La voici la voilà :

Code:

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
#include	<fstream>		// Gestion des flux de données 
#include	<iostream>	    // Fonctions d'entrée sortie
#include	<iomanip>
#include	<stdio.h>		// Fonctions d'entrée sortie standart
#include	<stdlib.h>		// Fonctions diverses
#include	<math.h>		// Fonctions mathématiques
#include	<string.h>		// Manipulation des châines de caractères	
#include	<time.h>		// Manipulation du temps
#include    <windows.h>
using namespace std; 
 
 
int main()
{
    char	FILE_streaming[70];
    strcpy(FILE_streaming, "./Resultat/STREAMING/streaming_");
    int nb_utilisateurS = 600;
    int i, k;
	char **nom_fichier = NULL;		// Complément du nom de fichier de sortie pour le streaming
	char **fichier_out = NULL;		// Nom du fichier de sortie pour le streaming
	ofstream *sortie_streaming = NULL;
	/* Allocation dynamique de mémoire*/
	// Sortie_streaming
	sortie_streaming = new ofstream[nb_utilisateurS];
	// Fichier_out
	fichier_out = new char *[nb_utilisateurS];
	for (i=0; i<nb_utilisateurS; i++)
		fichier_out[i] = new char[200];
	// Nom_fichier
	nom_fichier = new char *[nb_utilisateurS];
	for (i=0; i<nb_utilisateurS; i++)
		nom_fichier[i] = new char[20];
 
 
	/*  --------  Structures User_STR[i]  --------  */
	/* Parcours des utilisateurs*/
	for (i = 0; i < nb_utilisateurS; i++) {
		// Conversion de i en chaine de charactères (en base 10)
		ltoa(i, nom_fichier[i], 10);
		// Calcul du nom du fichier de sortie
		strcpy(fichier_out[i], FILE_streaming);
		strcat(fichier_out[i], "UE_");
		strcat(fichier_out[i], nom_fichier[i]);
		strcat(fichier_out[i], ".txt");
		/* Ouverture du fichier streaming*/
		sortie_streaming[i].open(fichier_out[i]);
		/* Précision de sortie_streaming*/
		sortie_streaming[i].precision(13);
	}
 
 
	/* Fermeture des fichiers sortie_streaming*/
	for (i = 0; i < nb_utilisateurS; i++)
		sortie_streaming[i].close();
	// Sortie_streaming
	delete[] sortie_streaming;
	// Fichier_out
	for (i=0; i<nb_utilisateurS; i++)
		delete[] fichier_out[i];
	delete[] fichier_out;
	// Nom_fichier
	for (i=0; i<nb_utilisateurS; i++)
		delete[] nom_fichier[i];
	delete[] nom_fichier;
 
	cout << "c'est fini" << endl;
	system("Pause");
 
	return 0;}

27/08/2008, 20h10
wiztricks
Le problème décrit se reproduit chez moi: cà ne crée que 250 fichiers au lieu des 600 attendus.

So far so good, mais
Code:

1 2 ! ulimit -n 256
me semble expliquer cela... après avoir fait

Code:

! ulimit -n 400

Ca crée 394 fichiers.

Le nombre de fichiers ouverts est donc limité par l'environnement système à la valeur rapportée par ulimit -n. Ce qui est rassurant - pour mon système.

Peut être qu'à force de faire des tests dans tous les sens vous êtes sujet à une grosse fatigue?
- W
28/08/2008, 09h25
droledelolo

Citation:

! ulimit -n
256

Qu'est-ce donc que cette instruction, je n'en ai jamais entendu parlé ? Où peut-on changer ce paramètre ?

Merci d'avance !!!
28/08/2008, 11h23
Jean-Marc.Bourguet

Citation:

Envoyé par droledelolo

Qu'est-ce donc que cette instruction, je n'en ai jamais entendu parlé ? Où peut-on changer ce paramètre ?

C'est la commande Unix qui permet de fixer des limites a la consommation de ressources par les process. Aucune idee de comment ca se gere sous Windows.
28/08/2008, 18h17
wiztricks

Mon propos était de dire que le programme était "correct" et que la limitation sur le nombre de fichiers ouverts était donnée par l'environnement.
(Chez moi c'est Mac OS X ;) donc ulimit... )

Pour windows....

Le MSDN rapporte que la "libc" limite le nombre de fichiers ouverts à 512. XP autorisant lui jusqu'à 2048 fichiers ouverts.
Changer le max de la libc est possible avec _setmaxstdio(int nb_files)
Voir:
http://msdn.microsoft.com/en-us/libr...75(VS.60).aspx

- W
29/08/2008, 02h34
nicroman

En même temps... un programme qui ouvre simultanement autant de fichiers est un programme à désinstaller dans l'heure ! :D

Je ne sais pas pourquoi vous perdez du temps à chercher pourquoi ca ne marche pas, ca ne devrait même pas arriver !
Et si c'est pas l'OS qui rale, ca va être le controleur de disque pendant les lectures/ecritures (et au bout du compte le disque lui même).
29/08/2008, 08h44
droledelolo

Merci pour l'aide et aussi la critique non constructive...

Je vais tester ça.
29/08/2008, 09h24
droledelolo

Ca fonctionne à présent !!!!!!!!!!!!!!!!

Merci beaucoup beaucoup !
29/08/2008, 17h59
nicroman

Qu'est ce qui fonctionne ?
L'ouverture simultanée de 400 fichiers ? ou le programme ?
(les deux sont difficilement compatibles)

Sans déconner... qu'est ce qui peut bien te pousser à devoir ouvir simultanément 500 fichiers ? C'est LA qu'il faut réflechir

(à noter que ulimit n'est pas accessible en temps normal, à moins d'avoir les droits ad-hoc, ce qui est assez rare sous unix).