Discussion :

[croc14]

Bonjours,

je me suis fait un script qui indente un fichier de log (celui en cour, 11635 ligne).

Mon soucis est qu'il met un peut 4-5 seconde pour 100 ligne donc les 10 minutes pour le traitement.
En gros, il insère une chaine donnée N fois à un endroit précis.
exemple de chaine "| "
exemple de log

Code :

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

1
2
3
4
5
6
7
2009/02/04 16:45:02:842  (t@9) BEGIN  texte
2009/02/04 16:45:02:842  (t@9) texte
2009/02/04 16:45:02:842  (t@9) BEGIN  texte
2009/02/04 16:45:02:842  (t@9) texte
2009/02/04 16:45:02:842  (t@9) END texte
2009/02/04 16:45:02:842  (t@9) texte
2009/02/04 16:45:02:842  (t@9) END texte

Exemple de résultat

Code :

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

1
2
3
4
5
6
7
8
2009/02/04 16:45:02:842  (t@9) BEGIN  texte
2009/02/04 16:45:02:842  (t@9) |  BEGIN  texte
2009/02/04 16:45:02:842  (t@9) |  |  texte
2009/02/04 16:45:02:842  (t@9) |  |  BEGIN  texte
2009/02/04 16:45:02:842  (t@9) |  |  |  texte
2009/02/04 16:45:02:842  (t@9) |  |  END texte
2009/02/04 16:45:02:842  (t@9) |  |  texte
2009/02/04 16:45:02:842  (t@9) |  END texte

Mon script

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
more ~/Tools/indentLog.sh 
#!/bin/bash
 
N=`wc ~/Logs/$1/$1_current.log | awk '{print $1}'`
 
sep="|  "
> ~/Logs/$1/$1_current_ind.log
 
tab0="  #  "
tabs="$tab0"
(( n = 0 ))
cat ~/Logs/$1/$1_current.log | while read linein
do
        printf "\r> $n/$N  "
 
        end=`echo $linein | grep "END"`
        if test -n "$end"
        then
                tabs=`echo "$tabs" | sed "s/$sep//"`
        fi
 
 
        lineout=`echo $linein | sed "s/)/)$tabs/"`
        echo -e $lineout >> ~/Logs/$1/$1_current_ind.log
 
 
        begin=`echo $linein | grep "BEGIN"`
        if test -n "$begin"
        then
                tabs=`echo "$tabs" | sed "s/$tab0/$tab0$sep/"`
        fi
 
        (( n = $n + 1 ))
done
 
echo " Done"

Une amélioration par 10 serait bien venu, mais une amélioration de façon générale aussi ^^

[D[r]eadLock]

Passe en langage plus évolué / plus performant, par exemple perl (ça évitera de créer 10 process pour analyser chaque ligne)... C'est certes un investissement au départ, mais très rentable.
Sinon, j'avoue je n'ai pas regardé en détail le code (mais trop de process créés pour ce que tu veux faire à mon avis)

[N_BaH]

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
#!/bin/bash
 
N=$(wc -l <~/Logs/$1/$1_current.log)
sep="|  "
tab0="  #  "
tabs="$tab0"
n=1
 
> ~/Logs/$1/$1_current_ind.log
 
while read linein; do
        printf "\r> $n/$N  "
 
        [ -n "$(grep END <<<$linein)" ] && tabs="${tabs/$sep/}"
 
        echo "${linein/) /)$tabs}" >>~/Logs/$1/$1_current_ind.log
 
        [ -n "$(grep BEGIN <<<$linein)" ] && tabs="${tabs/$tab0/$tab0$sep}"
 
        (( n +=1 ))
 
done <~/Logs/$1/$1_current.log
 
echo " Done"

Code qui retourne :

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

1
2
3
4
5
6
7
8
9
10
 
test/croc14.sh; cat ~/Logs/$1/$1_current_ind.log
> 7/7   Done
2009/02/04 16:45:02:842  (t@9)  #  BEGIN  texte
2009/02/04 16:45:02:842  (t@9)  #  |  texte
2009/02/04 16:45:02:842  (t@9)  #  |  BEGIN  texte
2009/02/04 16:45:02:842  (t@9)  #  |  |  texte
2009/02/04 16:45:02:842  (t@9)  #  |  END texte
2009/02/04 16:45:02:842  (t@9)  #  |  texte
2009/02/04 16:45:02:842  (t@9)  #  END texte

[ggnore]

Aussi optimisé soit il, un script bash ne sera jamais aussi rapide que du perl ou que du langage C.
Si tu veux faire du traitement de fichier, change de langage. S'il en existe autant, c'est bien parce qu'il répondent à des besoin différents.

D[r]eadLock+1 en somme

[LLB]

Script sed (sous Freebsd, je pense que c'est portable) écrit en quelques secondes :

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
 cat in
2009/02/04 16:45:02:842  (t@9) BEGIN  texte
2009/02/04 16:45:02:842  (t@9) texte
2009/02/04 16:45:02:842  (t@9) BEGIN  texte
2009/02/04 16:45:02:842  (t@9) texte
2009/02/04 16:45:02:842  (t@9) END texte
2009/02/04 16:45:02:842  (t@9) texte
2009/02/04 16:45:02:842  (t@9) END texte
 
$ cat a.sed tmp
/END/{ x; s/^...//; x; }
G
s/)\(.*\)\n\(.*\)/)\2\1/
/BEGIN/{ x; s/^/ | /; x; }
 
$ sed -f a.sed in
2009/02/04 16:45:02:842  (t@9) BEGIN  texte
2009/02/04 16:45:02:842  (t@9) |  texte
2009/02/04 16:45:02:842  (t@9) |  BEGIN  texte
2009/02/04 16:45:02:842  (t@9) |  |  texte
2009/02/04 16:45:02:842  (t@9) |  END texte
2009/02/04 16:45:02:842  (t@9) |  texte
2009/02/04 16:45:02:842  (t@9) END texte

Dis-moi ce que ça donne au niveau des performances (au moins, il n'y a pas 50 forks).

(pour comprendre le script : man sed ou pose tes questions)

[croc14]

6'45 au lieu de 9'45 pour mon fichier de 11635 ligne

Ya donc un mieux ^^

SI quelqu'un voit encore une optimisation a faire !! N'hésitez pas.

Merci.

LLB, je teste ta solution.

[croc14]

LLB, ta solution est achement rapide !!

Comment il faut le rediger pour l'avoir dans un seul script.
Et pourrait tu décrire ce que cela signifie, pour pas que je reste comme une poire !!
Même après avoir tenté plein de tuto, seb j'ai vraiement du mal, principalement dans la possibilité de syntaxe qui reste peut détaillé.

encore merci.

[LLB]

Dans un script shell, tu peux mettre :

Code :

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

1
2
3
4
5
< input sed '
/END/{ x; s/^...//; x; }
G
s/)\(.*\)\n\(.*\)/)\2\1/
/BEGIN/{ x; s/^/ | /; x; }'

Sed possède deux buffers : le premier contient la ligne courante (celle qui est à traiter), le deuxième sert à sauvegarder des informations (ici, le séparateur à insérer). La commande 'x' sert à inverser les deux buffers (car les commandes fonctionnent sur le premier).


Ligne 1 : quand on voit "END", on supprime les trois premiers caractères du buffer de sauvegarde.

Ligne 2 : on ajoute le buffer de sauvegarde à la fin du buffer courant (séparé par un retour à la ligne). On obtient par exemple :

Code :

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

1
2
2009/02/04 16:45:02:842  (t@9) texte
 |  |

Ligne 3 : on sélectionne "texte" (entre la parenthèse et le retour à la ligne) et le séparateur. On les remet dans l'ordre. On obtient :

Code :

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

2009/02/04 16:45:02:842  (t@9) |  |  texte

Ligne 4 : quand on voit "BEGIN", on ajoute " | " au début du buffer de sauvegarde.


Sed est un outil excellent, permettant de réaliser des tâches complexes en très peu de lignes. Mais, ça prend 10 fois plus de temps à expliquer ce que fait le script qu'à l'écrire.

[croc14]

Bon ben j'ai compris, mais, c'est d'un tendu a écrire !!
Mais je pense que cela m'aidera pour en faire d'autre prochainement.

Merci pour la rapidité de réponse, a tout ceux qui ont participé.
Et le chalenge est bien entendu relevé puisque le script met même pas 2 seconde a faire les 11000 ligne !!

[jmelyn]

Bonsoir.

J'arrive après la bataille me semble-t-il. Je mets tout de même une solution à base de awk, qui sera certainement plus lente, mais qui marche et qui est, selon moi, plus lisible.

Code :

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

1
2
3
4
5
6
7
8
awk '
{
  printf "%s %s %s%s", $1, $2, $3, level
  for (field = 4; field <= NF; field++) {printf " %s", $field}
  if ($4 ~ /^BEGIN$/) {level = level " |"}
  else if ($4 ~ /^END$/) {level = substr(level, 0, length(level) - 2)}
  print ""
}' file_in > file_out