Discussion :

[beware]

Bonjour,

Je suis entrain de développer un script Perl dans le cadre de mon boulot, et j'ai besoin de conseil pour optimiser une partie du traitement.

Environnement:
J'ai 5 fichiers à lire, puis à analyser (ligne par ligne). La taille de ces fichiers est variables, pouvant aller de dizaine de ko à plusieurs dizaines, voir centaines de Mo.
Ces fichiers ont une structure identique, c.à.d qu'ils sont composés de lignes de 48 caractères.
L'analyse de ces fichiers n'est pas continu, c'est à dire que je dois analyser N lignes une 1ere fois, puis M lignes une 2nde, etc.. jusqu’à la fin du fichier

Objectif
Je dois lire 1 ligne de chaque fichier, et pour chaque ligne je dois:

1. retourner la ligne
2. effacer tous les espaces et le retour chariot
3. concaténer les 5 lignes ensemble (au fur et à mesure)

Méthode
J'ai choisis de faire la fonction suivante:

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
sub extract_acq_data {
 
  my $data = q{};
  my $flag_nodata = 0;
  for ( 0..4) {
    my $rd_data  = readline( $fh_acq[$_] );
    if ( defined( $rd_data )) {
      $data .= reverse($rd_data);
    } else {
      $flag_nodata = 1;
      last;
    }
  }
 
  # Return data only if flag nodata is reset
  if ( $flag_nodata == 0 ) {
     $data =~ s/\s+//g;
      return $data;
  } else {
    return -1;
  }
}

Problème
Mon souci, vient du faite de la "lenteur" de cette fonction.
En effet, j'ai 'profilé' mon script avec 5 fichiers de 300Mo (~7.5M lignes chacun), et j'obtiens les infos suivantes:
Exécution du script : 19s
Exécution de la fonction : 16s
avec

• readline : 2.68s
• if ( defined... : 2.41s
• remove space (s/[[:space:]]) : 3.34s

Donc ma question, est-il possible, et si oui, comment je pourrais optimiser cette fonction pour réduire le temps d’exécution du script?

Merci

[Schmorgluck]

Je n'ai pas examiné la fonction en détail, mais je ne comprends pas à quoi servent les paramètres $sig et $array. Ils ne sont pas utilisés du tout dans la fonction.

[Lolo78]

Bah, 16 secondes pour lire 1,5 gigaoctets de données et faire les manipulations de texte que tu fais, ça ne me paraît vraiment pas excessif.

Et je ne vois pas vraiment grand chose à faire pour aller plus vite.

[Schmorgluck]

Je constate que cette "fonction" utilise une variable qui lui est extérieure : @fh_acq. Sans vouloir être trop rigoriste, j'ai tendance à estimer que c'est une façon bordélique de programmer, qui tend à entraîner des cauchemars de maintenance de code. À tout le moins, on n'appelle pas un tel sous-programme une "fonction".

Mais bon, voici mes questions : à quoi correspond la variable @fh_acq, et à quoi servent les paramètres $sig et $array, et quels arguments ces derniers sont-ils censés recevoir à l'appel de la fonction ?

[beware]

Plusieurs choses:

• Effectivement les variables $sig et $array n’étaient plus utiles, je les ai donc enlevées.
• Le tableau @fh_acq contient l'ensemble des FILEHANDLER pour les fichiers que j'ai ouvert

Peut-être que je pourrais passer ces FILEHANDLER en paramètre de la fonction. Sans optimiser le process, cela serait-il plus propre?

@Schmorgluck : Pourrais-tu m'expliquer pourquoi tu met des " autour du nom fonction? Merci.

[beware]

En cherchant un peu, j'ai pu améliorer les performances en changeant:

Code :

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

1
2
 
$data =~ s/\s+//g;

par

Code :

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

1
2
3
 
$data = tr/ //d;
$data =~ s/\s//g;

et je gagne quelque centaines de millisecondes sur cette partie.

[Lolo78]

Peut-être que je pourrais passer ces FILEHANDLER en paramètre de la fonction. Sans optimiser le process, cela serait-il plus propre?

Tant qu'à passer un paramètre à ta fonction, autant passer directement le file handler voulu, c'est plus net.

Mais, bon, je ne suis pas vraiment choqué qu'un file handler soit traité comme une variable globale, c'est presque une variable d'environnement. Normalement j'évite de le faire, mais il y a des cas où ça simplifie vraiment le code, pas besoin non plus d'être trop dogmatique.

[beware]

Passer 1 seul FILEHANDLER c'est pas possible car je dois lire les 5 fichiers d'un coup. Mais je peux toujours passer le tableau qui contient les 5
Après j'ai pris parti de mettre tout mes FH en "variable globale", par feneantise, car ainsi j'ai pas besoin de les passer à toutes les sous-fonctions qui les utilisent

[Philou67430]

Code :

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

1
2
3
 
$data = tr/ //d;
$data =~ s/\s//g;

se simplifie encore ainsi ;

Code :

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

$data =~ tr/ \n//d;

De plus, dans cette ligne

Code :

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

$data .= reverse($rd_data);

je n'ai pas compris l'intérêt de "reverse" qui n'est ni dans le l'énoncé, ni dans le rapport de profilage.

[Schmorgluck]

Si si, Philou, c'est dans le premier message.

Objectif
Je dois lire 1 ligne de chaque fichier, et pour chaque ligne je dois:

1. retourner la ligne
2. effacer tous les espaces et le retour chariot
3. concaténer les 5 lignes ensemble (au fur et à mesure)

@Schmorgluck : Pourrais-tu m'expliquer pourquoi tu met des " autour du nom fonction? Merci.

Justement parce que ton sous-programme utilise une variable qui lui est extérieure. C'est un peu du pinaillage sémantique de ma part, mais j'ai tendance à considérer que le mot "fonction" devrait être réservé, en programmation, à une part de code indépendante de l'environnement d'appel. Parler de "fonction" en Perl est un abus de langage courant et assez bénin, qui vient sans doute du fait que la plupart des programmeurs en Perl sont passés par le C dans leur apprentissage. Mais si on veut être strict, on devrait s'en tenir au terme "sous-programme". D'ailleurs la commande de déclaration en Perl est bien "sub", pour "sub-program", et pas "func" ou "fun", comme c'est le cas dans d'autres langages.

Ceci dit, même ce que j'appelle une fonction peut dépendre de l'environnement global du système. Et je peux à l'occasion appeler fonction un sous-programme qui aurait des effets de bord, donc au fond je ne suis pas si strict. Et Lolo78 a raison, utiliser les filehandles comme variables globales peut dans certains cas simplifier le code.Mais je ne trouve pas que ça soit le cas ici.

Il y a des tas de choses qu'on peut faire en Perl, des manières de faire qui sont possibles mais déconseillées, à n'utiliser que s'il y a un vrai bénéfice.

[beware]

@Philou67430
Merci, effectivement, cela simplifie la lecture du code, que d'avoir 1 seule ligne (et possiblement le temps d’exécution).
Je n'ai pas indiqué le temps pris par le 'reverse' dans mon message, car sa durée est dérisoire par rapport aux autres parties mentionnées.

EDIT: Je viens juste d'y penser, mais ne faut-il pas rajouter \r si je traite des fichiers au format DOS?

@Schmorgluck
Merci de ton explication sémantique. Je comprends mieux ton 1er message après avoir lu celui-ci

[Philou67430]

Si si, Philou, c'est dans le premier message.

J'avais compris "retourner" comme étant "le retour de la fonction" et non pas "inverser l'ordre des lettres"

EDIT: Je viens juste d'y penser, mais ne faut-il pas rajouter \r si je traite des fichiers au format DOS?

Si bien sûr.

A voir s'il ceci modifie le temps :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
sub extract_acq_data {
 
  my @rd_data = map reverse(scalar(<$_>)), @fh_acq; # on suppose que @fh_acq contient 5 file handle
  if (@rd_data == 5) {
    my $data = join "", @rd_data;
    $data =~ tr/\n\r //d; # \s couvre \n, espace, \f, \t et \r
    return $data;
  }
  else {
    return -1;
  }
}

[beware]

Merci pour ce bout de code.
Je crois dans un 1er temps je vais essayer de comprendre ce qu'il se cache derrière.

[Philou67430]

Code :

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

1
2
3
sub extract_acq_data {
 
  my @rd_data = map reverse(scalar(<$_>)), @fh_acq; # on suppose que @fh_acq contient 5 file handle

map est une fonction qui applique une fonction (ou une expression) à un tableau. Ici, pour chaque élément de @fh_acs (c'est à dire pour chaque file handle de fichier), on applique l'expression reverse(scalar(<$_>)), et on retourne le résultat dans @rd_data (il y aura donc autant d'élément dans @rd_data que dans @fh_acs.

Dans cette expression, la sous-expression scalar(<$_>) permet de fournir à l'opérateur <> un contexte scalaire (l'opérateur <> est équivalent à readline).
Ainsi, cet opérateur retournera "une ligne" depuis le fichier de file handle $_ ($_ étant la variable automatique qui résulte du parcours du tableau @fh_acq).
La fonction reverse inverse le résultat de cette ligne avant de le placer dans @rd_data.

Code :

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

1
2
 
  if (@rd_data == 5) {

Ici, on veut vérifier que l'on a pu lire les 5 fichiers.
Je me rends compte que ce test est erroné : il y aura toujours 5 éléments dans le tableau.
Il faut donc modifier la ligne précédente pour éliminer les lignes qui ne sont pas lues (pour cause de fin de fichier).
la ligne précédente doit donc s'écrire :

Code :

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

  my @rd_data = map reverse, grep defined, map scalar(<$_>)), @fh_acq; # on suppose que @fh_acq contient 5 file handle

Code :

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

1
2
    my $data = join "", @rd_data;
    $data =~ tr/\n\r //d; # \s couvre \n, espace, \f, \t et \r

Enfin, si tous les fichiers ont pu être lus, on réassemble les 5 lignes avec la fonction join, et on supprime les espaces sur le résultat.

Code :

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

1
2
3
4
5
6
    return $data;
  }
  else {
    return -1;
  }
}

Le reste est trivial à priori.

[beware]

Alors là, merci Philou.
Les explications sont claires et fort utiles.
Je connaissais pas la fonction map (du moins sont utilisation n'était pas très claires pour moi

j'ai du faire autre chose ces derniers jours, et je vais essayer ta proposition, et mesurer son impact sur la durée d’exécution du script.

[beware]

Bon j'ai pu faire quelque essai (enfin ), avec des fichiers plus gros, et plus représentatif du travail final.
Avec la 1ere version (sans le grep), j'ai gagné ~7s sur la fonction, et ~1s sur la lecture elle même (15_847_605 de lecture).

Pour la 2nde version, il manque une parenthèse ouvrante, et je n'ai pas réussi à la mettre au bon endroit.


Toujours pour traiter ce point, j'ai une questions: est-il possible en Perl de lire d'un coup N lignes?
Je m'explique, dans mon traitement, je viens lire mes fichiers par "paquet". C-à-d que la 1ere fois, je viens lire 1k lignes, puis dans un 2nd temps, je viens lire 2.5k lignes, etc...
Donc, est-il possible de faire " readline( filehandler, nb_ligne)" ?

A+

[Philou67430]

Pour la 2nde version, il manque une parenthèse ouvrante, et je n'ai pas réussi à la mettre au bon endroit.

Peux-tu rappeler le bout de code concerné ? Merci.

Toujours pour traiter ce point, j'ai une questions: est-il possible en Perl de lire d'un coup N lignes?
Je m'explique, dans mon traitement, je viens lire mes fichiers par "paquet". C-à-d que la 1ere fois, je viens lire 1k lignes, puis dans un 2nd temps, je viens lire 2.5k lignes, etc...
Donc, est-il possible de faire " readline( filehandler, nb_ligne)" ?

Tu peux faire une lecture de toutes les lignes à la fois aussi ...

Code :

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

my @every_lines = <$_>;

Pour n'en lire que n à part une boucle ...

Code :

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

my @height_lines = map <$_>, 1 .. 8;

[beware]

Voici le bout de code concerné pour la parenthèse manquante (ou en trop, je ne serais dire):

Code :

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

1
2
 
my @rd_data = map reverse, grep defined, map scalar(<$_>)), @fh_acq; # on suppose que @fh_acq contient 5 file handle

Pour la lecture de plusieurs ligne à la fois, j'avais bien pensé à une boucle. Mais mon but, ici, est toujours d'essayer de 'gratter' quelque secondes.
Mais en y réfléchissant un peu, ce n'est pas forcement un gain. Car de toute façon, il faut que je retourne chaque ligne que je lis dans chaque fichier.
Au final, je suis pas convaincu du gain que cela pourrait apporter, dans le cas ou cela en apporte bien sur.

Et puis, je ne dois pas oublier non plus, que je dois aussi être "maître" de mon code (au sens comprendre clairement ce que j'ai écrit et pourquoi), afin de pouvoir le modifier/corriger/améliorer plus tard.

[Philou67430]

La correction à apporter au code :

Code :

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

my @rd_data = map reverse, grep defined, map scalar(<$_>), @fh_acq; # on suppose que @fh_acq contient 5 file handle

[beware]

J'ai copié la ligne de code dans mon script :

Code :

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

1
2
my @rd_data = map reverse, grep defined, map scalar(<$_>), @fh_acq; # on suppose que @fh_acq contient 5 file handle
print "size of data : ".scalar(@rd_data);

J'obtiens -> size of data : 0

les fichiers contiennent des données, le tableau @fh_acq contient 5 FILEHANDLER.
mais le tableau @rd_data est vide.