un de mes scripts fait sous linux fonctionne bien et est quasiment
instantané par contre le même scripts avec les mêmes données => 2
minutes temps réels sous windows .
avec des données de moins de 1 mo le matériel compte pas !
le script en résumé
en gros j'ai un fichier qui contient 10000 lignes avec les 8 premier
caracteres = une date
le but est d'exploser ce fichier en autant de fichier qu'il y de date
je sais c'est brutal et pas trop reflechi mais bon
il ne doit tourner qu'une fois par jour et en batch
sub do_it()
{
my ($fic) = @_ ;
my @LIGNES;
my $date;
open( FIC, $fichier );
while (<FIC>)
{
$date = substr $_,0,8 ;
my $record = { DATE => $date , LIG => $_ } ;
push @LIGNES, $record;
}
close(FIC);
foreach my $l (@LIGNES)
{
my $f = $l->{DATE}.".s5";
my $lig = $l->{LIG};
open( OUT, ">>".$f );
print OUT $lig;
close(OUT);
}
}
si quelqu'un peut me dire comment optimiser cela sans en faire une usine
a gaz
je suis preneur
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Klaus
Chris wrote:
sub do_it() { my ($fic) = @_ ;
my $fic = shift;
my @LIGNES; my $date;
open( FIC, $fichier );
open my $fic, '<', $fichier or die qq{Erreur open '<', '$fichier': ($!)};
while (<FIC>)
while (<$fic>)
{ $date = substr $_,0,8 ; my $record = { DATE => $date , LIG => $_ } ; push @LIGNES, $record; } close(FIC);
close $fic
foreach my $l (@LIGNES) { my $f = $l->{DATE}.".s5"; my $lig = $l->{LIG}; open( OUT, ">>".$f );
open my $out, '>>', $f or die qq{Erreur open '>>', '$f': ($!)};
print OUT $lig;
print {$out} $lig;
close(OUT);
close $out;
} }
si quelqu'un peut me dire comment optimiser cela sans en faire une usine a gaz je suis preneur
Optimiser en termes de programmation ? -- voir mes commentaires ci-dessus.
un de mes scripts fait sous linux fonctionne bien et est quasiment instantané par contre le même scripts avec les mêmes données => 2 minutes temps réels sous windows .
Optimiser en termes de performance ? -- difficile à dire, je ne sais pas, mais j'ai une idée.
Sous windows: =========== Si tu n'as pas beaucoup de mémoire vive disponible sous windows, il y a un risque que la mémoire va fragmenter et le système passe beaucoup de temps à gérer la fragmentation, donc le programme va ralentir.
Sous linux: ======== Si ta mémoire vive sous linux est beaucoup plus important, le risque de fragmentation est moins élevé, donc le programme est plus rapide.
Bon, c'était juste une idée.
Chris wrote:
sub do_it()
{
my ($fic) = @_ ;
my $fic = shift;
my @LIGNES;
my $date;
open( FIC, $fichier );
open my $fic, '<', $fichier or die qq{Erreur open '<', '$fichier':
($!)};
while (<FIC>)
while (<$fic>)
{
$date = substr $_,0,8 ;
my $record = { DATE => $date , LIG => $_ } ;
push @LIGNES, $record;
}
close(FIC);
close $fic
foreach my $l (@LIGNES)
{
my $f = $l->{DATE}.".s5";
my $lig = $l->{LIG};
open( OUT, ">>".$f );
open my $out, '>>', $f or die qq{Erreur open '>>', '$f':
($!)};
print OUT $lig;
print {$out} $lig;
close(OUT);
close $out;
}
}
si quelqu'un peut me dire comment optimiser cela sans en faire une usine
a gaz
je suis preneur
Optimiser en termes de programmation ? -- voir mes commentaires
ci-dessus.
un de mes scripts fait sous linux fonctionne bien et est quasiment
instantané par contre le même scripts avec les mêmes données => 2
minutes temps réels sous windows .
Optimiser en termes de performance ? -- difficile à dire, je ne sais
pas, mais j'ai une idée.
Sous windows:
===========
Si tu n'as pas beaucoup de mémoire vive disponible sous windows, il y
a un risque que la mémoire va fragmenter et le système passe beaucoup
de temps à gérer la fragmentation, donc le programme va ralentir.
Sous linux:
========
Si ta mémoire vive sous linux est beaucoup plus important, le risque
de fragmentation est moins élevé, donc le programme est plus rapide.
open my $fic, '<', $fichier or die qq{Erreur open '<', '$fichier': ($!)};
while (<FIC>)
while (<$fic>)
{ $date = substr $_,0,8 ; my $record = { DATE => $date , LIG => $_ } ; push @LIGNES, $record; } close(FIC);
close $fic
foreach my $l (@LIGNES) { my $f = $l->{DATE}.".s5"; my $lig = $l->{LIG}; open( OUT, ">>".$f );
open my $out, '>>', $f or die qq{Erreur open '>>', '$f': ($!)};
print OUT $lig;
print {$out} $lig;
close(OUT);
close $out;
} }
si quelqu'un peut me dire comment optimiser cela sans en faire une usine a gaz je suis preneur
Optimiser en termes de programmation ? -- voir mes commentaires ci-dessus.
un de mes scripts fait sous linux fonctionne bien et est quasiment instantané par contre le même scripts avec les mêmes données => 2 minutes temps réels sous windows .
Optimiser en termes de performance ? -- difficile à dire, je ne sais pas, mais j'ai une idée.
Sous windows: =========== Si tu n'as pas beaucoup de mémoire vive disponible sous windows, il y a un risque que la mémoire va fragmenter et le système passe beaucoup de temps à gérer la fragmentation, donc le programme va ralentir.
Sous linux: ======== Si ta mémoire vive sous linux est beaucoup plus important, le risque de fragmentation est moins élevé, donc le programme est plus rapide.
Bon, c'était juste une idée.
Nicolas George
"Klaus" wrote in message :
close $fic
Je trouve plus élégant de rajouter un niveau d'accolades et de supprimer le close.
"Klaus" wrote in message
<1156864558.003467.28120@i3g2000cwc.googlegroups.com>:
close $fic
Je trouve plus élégant de rajouter un niveau d'accolades et de supprimer le
close.
Je trouve plus élégant de rajouter un niveau d'accolades et de supprimer le close.
Klaus
Nicolas George wrote:
"Klaus" wrote in message :
close $fic
Je trouve plus élégant de rajouter un niveau d'accolades et de suppri mer le close.
je suis tout à fait d'accord, voir aussi http://perl.enstimac.fr/DocFr/perlfunc.html#item_open
========================= === :: En utilisant le constructeur du paquetage IO::Handle :: (ou de l'une de ses sous-classes telles que IO::File :: ou IO::Socket), vous pouvez générer des descripteurs :: anonymes qui ont la même portée que les variables qui :: gardent une référence sur eux et qui se ferment :: automatiquement dès qu'ils sont hors de portée. ========================= ===
Nicolas George wrote:
"Klaus" wrote in message
<1156864558.003467.28120@i3g2000cwc.googlegroups.com>:
close $fic
Je trouve plus élégant de rajouter un niveau d'accolades et de suppri mer le
close.
je suis tout à fait d'accord, voir aussi
http://perl.enstimac.fr/DocFr/perlfunc.html#item_open
========================= ===
:: En utilisant le constructeur du paquetage IO::Handle
:: (ou de l'une de ses sous-classes telles que IO::File
:: ou IO::Socket), vous pouvez générer des descripteurs
:: anonymes qui ont la même portée que les variables qui
:: gardent une référence sur eux et qui se ferment
:: automatiquement dès qu'ils sont hors de portée.
========================= ===
Je trouve plus élégant de rajouter un niveau d'accolades et de suppri mer le close.
je suis tout à fait d'accord, voir aussi http://perl.enstimac.fr/DocFr/perlfunc.html#item_open
========================= === :: En utilisant le constructeur du paquetage IO::Handle :: (ou de l'une de ses sous-classes telles que IO::File :: ou IO::Socket), vous pouvez générer des descripteurs :: anonymes qui ont la même portée que les variables qui :: gardent une référence sur eux et qui se ferment :: automatiquement dès qu'ils sont hors de portée. ========================= ===
Nicolas George
"Klaus" wrote in message :
=========================== > :: En utilisant le constructeur du paquetage IO::Handle :: (ou de l'une de ses sous-classes telles que IO::File :: ou IO::Socket), vous pouvez générer des descripteurs :: anonymes qui ont la même portée que les variables qui :: gardent une référence sur eux et qui se ferment :: automatiquement dès qu'ils sont hors de portée. =========================== Cette partie de la doc devrait être ré-écrite : c'est vrai, mais ce n'est
pas nécessaire, la construction que tu as écrite deux message plus haut suffit.
"Klaus" wrote in message
<1156865836.738280.317480@h48g2000cwc.googlegroups.com>:
=========================== > :: En utilisant le constructeur du paquetage IO::Handle
:: (ou de l'une de ses sous-classes telles que IO::File
:: ou IO::Socket), vous pouvez générer des descripteurs
:: anonymes qui ont la même portée que les variables qui
:: gardent une référence sur eux et qui se ferment
:: automatiquement dès qu'ils sont hors de portée.
===========================
Cette partie de la doc devrait être ré-écrite : c'est vrai, mais ce n'est
pas nécessaire, la construction que tu as écrite deux message plus haut
suffit.
=========================== > :: En utilisant le constructeur du paquetage IO::Handle :: (ou de l'une de ses sous-classes telles que IO::File :: ou IO::Socket), vous pouvez générer des descripteurs :: anonymes qui ont la même portée que les variables qui :: gardent une référence sur eux et qui se ferment :: automatiquement dès qu'ils sont hors de portée. =========================== Cette partie de la doc devrait être ré-écrite : c'est vrai, mais ce n'est
pas nécessaire, la construction que tu as écrite deux message plus haut suffit.
Dam
C'est barbard c'est clair...
Tu devrais récupérer les lignes dans un hash ou la clé serait la date puis la valeur serait un tableau de ligne... Puis tu écrit des fichiers (du hash) après, évitant ainsi des open-close inutiles!
Bonjour,
ATTENTION TROLLER la tentation est grande ...
un de mes scripts fait sous linux fonctionne bien et est quasiment instantané par contre le même scripts avec les mêmes données => 2 minutes temps réels sous windows .
avec des données de moins de 1 mo le matériel compte pas !
le script en résumé
en gros j'ai un fichier qui contient 10000 lignes avec les 8 premier caracteres = une date le but est d'exploser ce fichier en autant de fichier qu'il y de date
je sais c'est brutal et pas trop reflechi mais bon il ne doit tourner qu'une fois par jour et en batch
sub do_it() { my ($fic) = @_ ;
my @LIGNES; my $date;
open( FIC, $fichier ); while (<FIC>) { $date = substr $_,0,8 ; my $record = { DATE => $date , LIG => $_ } ; push @LIGNES, $record; } close(FIC);
foreach my $l (@LIGNES) { my $f = $l->{DATE}.".s5"; my $lig = $l->{LIG}; open( OUT, ">>".$f ); print OUT $lig; close(OUT); } }
si quelqu'un peut me dire comment optimiser cela sans en faire une usine a gaz je suis preneur
A+ chris
C'est barbard c'est clair...
Tu devrais récupérer les lignes dans un hash ou la clé serait la
date puis la valeur serait un tableau de ligne... Puis tu écrit des
fichiers (du hash) après, évitant ainsi des open-close inutiles!
Bonjour,
ATTENTION TROLLER la tentation est grande ...
un de mes scripts fait sous linux fonctionne bien et est quasiment
instantané par contre le même scripts avec les mêmes données => 2
minutes temps réels sous windows .
avec des données de moins de 1 mo le matériel compte pas !
le script en résumé
en gros j'ai un fichier qui contient 10000 lignes avec les 8 premier
caracteres = une date
le but est d'exploser ce fichier en autant de fichier qu'il y de date
je sais c'est brutal et pas trop reflechi mais bon
il ne doit tourner qu'une fois par jour et en batch
sub do_it()
{
my ($fic) = @_ ;
my @LIGNES;
my $date;
open( FIC, $fichier );
while (<FIC>)
{
$date = substr $_,0,8 ;
my $record = { DATE => $date , LIG => $_ } ;
push @LIGNES, $record;
}
close(FIC);
foreach my $l (@LIGNES)
{
my $f = $l->{DATE}.".s5";
my $lig = $l->{LIG};
open( OUT, ">>".$f );
print OUT $lig;
close(OUT);
}
}
si quelqu'un peut me dire comment optimiser cela sans en faire une usine
a gaz
je suis preneur
Tu devrais récupérer les lignes dans un hash ou la clé serait la date puis la valeur serait un tableau de ligne... Puis tu écrit des fichiers (du hash) après, évitant ainsi des open-close inutiles!
Bonjour,
ATTENTION TROLLER la tentation est grande ...
un de mes scripts fait sous linux fonctionne bien et est quasiment instantané par contre le même scripts avec les mêmes données => 2 minutes temps réels sous windows .
avec des données de moins de 1 mo le matériel compte pas !
le script en résumé
en gros j'ai un fichier qui contient 10000 lignes avec les 8 premier caracteres = une date le but est d'exploser ce fichier en autant de fichier qu'il y de date
je sais c'est brutal et pas trop reflechi mais bon il ne doit tourner qu'une fois par jour et en batch
sub do_it() { my ($fic) = @_ ;
my @LIGNES; my $date;
open( FIC, $fichier ); while (<FIC>) { $date = substr $_,0,8 ; my $record = { DATE => $date , LIG => $_ } ; push @LIGNES, $record; } close(FIC);
foreach my $l (@LIGNES) { my $f = $l->{DATE}.".s5"; my $lig = $l->{LIG}; open( OUT, ">>".$f ); print OUT $lig; close(OUT); } }
si quelqu'un peut me dire comment optimiser cela sans en faire une usine a gaz je suis preneur
A+ chris
Chris
open my $fic, '<', $fichier or die qq{Erreur open '<', '$fichier': ($!)};
Oui et non la syntaxe en majuscule me parle mieux, mais c'est une question de gout sans la portee du handle à son importance.
Optimiser en termes de performance ? -- difficile à dire, je ne sais pas, mais j'ai une idée.
Sous windows: ========== > Si tu n'as pas beaucoup de mémoire vive disponible sous windows, il y a un risque que la mémoire va fragmenter et le système passe beaucoup de temps à gérer la fragmentation, donc le programme va ralentir.
Sous linux: ======= > Si ta mémoire vive sous linux est beaucoup plus important, le risque de fragmentation est moins élevé, donc le programme est plus rapide.
Bon, c'était juste une idée.
Apres reflexion un open/close sous window doit couter beaucoup plus cher
que sous linux surtout si ya pas de couche graphique La difference doit etre par la
Merci pour la correction A+ chris
open my $fic, '<', $fichier or die qq{Erreur open '<', '$fichier':
($!)};
Oui et non la syntaxe en majuscule me parle mieux, mais c'est une
question de gout
sans la portee du handle à son importance.
Optimiser en termes de performance ? -- difficile à dire, je ne sais
pas, mais j'ai une idée.
Sous windows:
========== > Si tu n'as pas beaucoup de mémoire vive disponible sous windows, il y
a un risque que la mémoire va fragmenter et le système passe beaucoup
de temps à gérer la fragmentation, donc le programme va ralentir.
Sous linux:
======= > Si ta mémoire vive sous linux est beaucoup plus important, le risque
de fragmentation est moins élevé, donc le programme est plus rapide.
Bon, c'était juste une idée.
Apres reflexion un open/close sous window doit couter beaucoup plus cher
que sous linux surtout si ya pas de couche graphique
La difference doit etre par la
open my $fic, '<', $fichier or die qq{Erreur open '<', '$fichier': ($!)};
Oui et non la syntaxe en majuscule me parle mieux, mais c'est une question de gout sans la portee du handle à son importance.
Optimiser en termes de performance ? -- difficile à dire, je ne sais pas, mais j'ai une idée.
Sous windows: ========== > Si tu n'as pas beaucoup de mémoire vive disponible sous windows, il y a un risque que la mémoire va fragmenter et le système passe beaucoup de temps à gérer la fragmentation, donc le programme va ralentir.
Sous linux: ======= > Si ta mémoire vive sous linux est beaucoup plus important, le risque de fragmentation est moins élevé, donc le programme est plus rapide.
Bon, c'était juste une idée.
Apres reflexion un open/close sous window doit couter beaucoup plus cher
que sous linux surtout si ya pas de couche graphique La difference doit etre par la
Merci pour la correction A+ chris
Chris
C'est barbard c'est clair...
Tu devrais récupérer les lignes dans un hash ou la clé serait la date puis la valeur serait un tableau de ligne... Puis tu écrit des fichiers (du hash) après, évitant ainsi des open-close inutiles!
au lieu de
my $record = { DATE => $date , LIG => $_ } ;
un truc du style if !exist($hashage{$date}) $hashage{$date} = ();
push $_, $hashage{$date};
mouais a tester, en tout cas plus elegant
Merci A+
C'est barbard c'est clair...
Tu devrais récupérer les lignes dans un hash ou la clé serait la
date puis la valeur serait un tableau de ligne... Puis tu écrit des
fichiers (du hash) après, évitant ainsi des open-close inutiles!
au lieu de
my $record = { DATE => $date , LIG => $_ } ;
un truc du style
if !exist($hashage{$date})
$hashage{$date} = ();
Tu devrais récupérer les lignes dans un hash ou la clé serait la date puis la valeur serait un tableau de ligne... Puis tu écrit des fichiers (du hash) après, évitant ainsi des open-close inutiles!
au lieu de
my $record = { DATE => $date , LIG => $_ } ;
un truc du style if !exist($hashage{$date}) $hashage{$date} = ();
push $_, $hashage{$date};
mouais a tester, en tout cas plus elegant
Merci A+
Klaus
Chris wrote:
open my $fic, '<', $fichier or die qq{Erreur open '<', '$fichier': ($!)};
Oui et non la syntaxe en majuscule me parle mieux,
D'accord, je modifie ma proposition:
original --> open my $fic, '<', $fichier... modifié --> open my $FIC, '<', $fichier...
mais c'est une question de gout sans la portee du handle à son importance.
La plus importante différence de "open FIC..." contre "open my $FIC..." est le passage --> du "bareword" ("FIC") --> en variable propre ("$FIC").
Je donne un exemple du livre "Perl Best Practices" de Damian Conway, chapiter 10 "I/O":
========================= ======= use POSIX;
open EXDEV, '<', $filename or croak "Can't open '$filename': $OS_ERROR";
while (my $next_reading = <EXDEV>) { process_reading($next_reading); } ========================= =======
le module POSIX exporte la fonction EXDEV() dans le programme, par conséquence, l'opération "open" sera interprété de la façon suivante sans aucun avertissement:
open EXDEV(), '<', $filename
la fonction EXDEV() retourne la valeur 18, donc l'opération "open" est équivalent à
open *18, '<', $filename
Perl permet les variables du nom numérique, donc l'opération "open" réussit avec *18.
Mais le problème se manifeste à l'accès du fichier:
while (my $next_reading = <EXDEV>)
Ici, entre les paranthèses "<...>", le "bareword" EXDEV ne regarde pas les fonctions, donc le programme essaie de lire *EXDEV, mais il échoue, car *EXDEV n'est pas ouvert.
A mon gout, je préfère les variables de fichier du type "open my $EXDEV..." (et non pas "open EXDEV...")
Chris wrote:
open my $fic, '<', $fichier or die qq{Erreur open '<', '$fichier':
($!)};
Oui et non la syntaxe en majuscule me parle mieux,
D'accord, je modifie ma proposition:
original --> open my $fic, '<', $fichier...
modifié --> open my $FIC, '<', $fichier...
mais c'est une question de gout
sans la portee du handle à son importance.
La plus importante différence de "open FIC..." contre "open my
$FIC..." est le passage
--> du "bareword" ("FIC")
--> en variable propre ("$FIC").
Je donne un exemple du livre "Perl Best Practices" de Damian Conway,
chapiter 10 "I/O":
========================= =======
use POSIX;
open EXDEV, '<', $filename
or croak "Can't open '$filename': $OS_ERROR";
while (my $next_reading = <EXDEV>) {
process_reading($next_reading);
}
========================= =======
le module POSIX exporte la fonction EXDEV() dans le programme, par
conséquence, l'opération "open" sera interprété de la façon
suivante sans aucun avertissement:
open EXDEV(), '<', $filename
la fonction EXDEV() retourne la valeur 18, donc l'opération "open" est
équivalent à
open *18, '<', $filename
Perl permet les variables du nom numérique, donc l'opération "open"
réussit avec *18.
Mais le problème se manifeste à l'accès du fichier:
while (my $next_reading = <EXDEV>)
Ici, entre les paranthèses "<...>", le "bareword" EXDEV ne regarde pas
les fonctions, donc le programme essaie de lire *EXDEV, mais il
échoue, car *EXDEV n'est pas ouvert.
A mon gout, je préfère les variables de fichier du type "open my
$EXDEV..." (et non pas "open EXDEV...")
open my $fic, '<', $fichier or die qq{Erreur open '<', '$fichier': ($!)};
Oui et non la syntaxe en majuscule me parle mieux,
D'accord, je modifie ma proposition:
original --> open my $fic, '<', $fichier... modifié --> open my $FIC, '<', $fichier...
mais c'est une question de gout sans la portee du handle à son importance.
La plus importante différence de "open FIC..." contre "open my $FIC..." est le passage --> du "bareword" ("FIC") --> en variable propre ("$FIC").
Je donne un exemple du livre "Perl Best Practices" de Damian Conway, chapiter 10 "I/O":
========================= ======= use POSIX;
open EXDEV, '<', $filename or croak "Can't open '$filename': $OS_ERROR";
while (my $next_reading = <EXDEV>) { process_reading($next_reading); } ========================= =======
le module POSIX exporte la fonction EXDEV() dans le programme, par conséquence, l'opération "open" sera interprété de la façon suivante sans aucun avertissement:
open EXDEV(), '<', $filename
la fonction EXDEV() retourne la valeur 18, donc l'opération "open" est équivalent à
open *18, '<', $filename
Perl permet les variables du nom numérique, donc l'opération "open" réussit avec *18.
Mais le problème se manifeste à l'accès du fichier:
while (my $next_reading = <EXDEV>)
Ici, entre les paranthèses "<...>", le "bareword" EXDEV ne regarde pas les fonctions, donc le programme essaie de lire *EXDEV, mais il échoue, car *EXDEV n'est pas ouvert.
A mon gout, je préfère les variables de fichier du type "open my $EXDEV..." (et non pas "open EXDEV...")
