script a optimiser

Version imprimable

script a optimiser

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:

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:

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:

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 ^^

04/02/2009, 21h14
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)

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
#!/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:

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

05/02/2009, 08h52
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 :D

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

Code:

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)

05/02/2009, 10h27
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.
05/02/2009, 10h37
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.
05/02/2009, 10h58
LLB
Dans un script shell, tu peux mettre :
Code:

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:

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:

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. :)
05/02/2009, 14h42
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 !!

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:

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