debianforum.de

Laufzeit von Befehlen herausfinden

SNIPPET_TEXT:

1. #!/bin/bash
2. #
3. # Script um die Laufzeit von Befehlszeilen auszuwerten.
4. #
5. #
6. # laufzeit_messer.sh -b BEFEHLSDATEI [-d DURCHLAEUFE] [-a AUSGABEDATEI] [-g AUSGABEGROESSE] [-t] [--help]
7.  
8. versioN='V 0.01'
9.  
10. # Pfad in dem das Script liegt
11. script_pfad="$(dirname `readlink -f $0`)"
12.  
13. # Befehl zum Zeitmessen
14. time_befehl="`which time`"
15. time_optionen="-fuser %U\nreal %e\nsys  %S"
16. # Wichtig!      ^^^^^^    ^^^^^    ^^^^^
17.  
18.  
19. # Ausgabedatei
20. ausgabedatei="$script_pfad/ausgabe.txt"
21.  
22. # Temppfad
23. temppfad="/tmp/laufzeitmesser"
24. # Tempdatei
25. tempdatei="$temppfad/LM-tEMp"
26.  
27. # Datei fuer den Groessentest
28. groessentestdatei="$temppfad/LM-gTSt"
29. groesse_fuer_groessentest=0
30.  
31. # Name fuer die Sammeldateien
32. werte_sammeldatei="$temppfad/LM-wERte"
33.  
34. # Name der Befehlsdatei
35. befehlsdatei=
36. befehls_arbeitsdatei="$temppfad/LM-bEFehle"
37.  
38. # Anzahl der Durchlaeufe pro Befehl
39. anzahl_durchlaeufe=10
40.  
41. # Terminal zu ausfuehrung der Befehlszeilen
42. terminal='xterm -e'
43.  
44. # Kein extra Terminalfenster oeffnen
45. kein_fenster=true
46.  
47.  
48.  
49.  
50.  
51. # Funktionen -------------------------------------------------------------------
52. function Hilfe # ($1=Scriptname)
53. {
54.         echo
55.         echo "${1##*/} -b BEFEHLSDATEI [-d DURCHLAEUFE] [-a AUSGABEDATEI] [-g AUSGABEGROESSE] [-t] [-h / --help]"
56.         echo -e '\n'
57.         echo "-b BEFEHLSDATEI    | In dieser Datei befinden sich die Befehle, deren Laufzeit"
58.         echo "                   | gemessen werden sollen."
59.         echo "                   | (Leerzeilen und Kommentarzeilen erlaubt.)"
60.         echo "                   |"
61.         echo "-d DURCHLAEUFE     | Anzahl, wie oft jede Befehlszeile getestet werden soll."
62.         echo "                   | (Vorgabe=$anzahl_durchlaeufe)"
63.         echo "                   |"
64.         echo "-a AUSGABEDATEI    | In dieser Datei werden die Ergebnisse zusammengefasst."
65.         echo "                   | (Vorgabe=$ausgabedatei)"
66.         echo "                   |"
67.         echo "-g AUSGABEGROESSE  | Die Menge der Zeichen, die ein Befehl ausgeben muss."
68.         echo "                   | (Bei Befehlen, bei denen es unwichtig ist, diese"
69.         echo "                   |  Option einfach weglassen.)"
70.         echo "                   |"
71.         echo "-t                 | Fuer jeden Test ein extra Terminalfenster (${terminal%% *})"
72.         echo "                   | oeffnen in dem der Befehl ablaeuft. (Vorgabe=`$kein_fenster && echo nein || echo ja`)"
73.         echo
74.         echo "$versioN"
75.         echo
76.  
77.         exit 0
78. }
79.  
80.  
81.  
82.  
83.  
84.  
85.  
86.  
87.  
88. function Zeit_messen # ($1=befehl, $2=zeilennummer)
89. {
90.         local nochmal_fragen=true
91.         for d in `seq $anzahl_durchlaeufe`
92.         do
93.                 printf '%4i/%i    \r' $d $anzahl_durchlaeufe
94.  
95.                 if $kein_fenster
96.                 then
97.                         echo "$befehl 2>/dev/null" >"$tempdatei"
98.                         $time_befehl "$time_optionen" -ao "$werte_sammeldatei.`printf '%05i' $2`" /bin/bash "$tempdatei" >"$groessentestdatei"
99.                 else
100.                         echo "$befehl 2>/dev/null |tee $groessentestdatei" >"$tempdatei"
101.                         $terminal $time_befehl "$time_optionen" -ao "$werte_sammeldatei.`printf '%05i' $2`" /bin/bash "$tempdatei"
102.                 fi
103.  
104.                 if $nochmal_fragen && test $groesse_fuer_groessentest -gt 0
105.                 then
106.                         if test `wc -c <"$groessentestdatei"` -ne $groesse_fuer_groessentest
107.                         then
108.                                 echo -e "\aDie Groesse der Ausgabe ist nicht korrekt!\nSoll = $groesse_fuer_groessentest\nIst  = `wc -c <"$groessentestdatei"`"
109.                                 read -sn1 -p 'Script beenden (j/n/N) (ja / nein / Nicht nochmal fragen fuer diesen Befehl)'
110.                                 case "$REPLY" in
111.                                         'j')Ende;;
112.                                         'N')nochmal_fragen=false;;
113.                                 esac
114.                                 test -e "$groessentestdatei" && rm "$groessentestdatei"
115.                                 echo
116.                         fi
117.                 fi
118.         done
119. }
120.  
121.  
122.  
123.  
124.  
125.  
126.  
127.  
128.  
129.  
130. function Ende # ($1=leer=normal $1=Abbruch=Abruch durch benutzer)
131. {
132.         test "$1" == "Abbruch" && echo -ne "\n\nAbbruch durch benutzer!"
133.  
134.         echo -e "\nRaeume auf..."
135.  
136.         test -e "$befehls_arbeitsdatei" && rm "$befehls_arbeitsdatei"
137.         test -e "$tempdatei" && rm "$tempdatei"
138.         test -e "$groessentestdatei" && rm "$groessentestdatei"
139.         test -e "$werte_sammeldatei.00001" && rm $werte_sammeldatei.[0-9][0-9][0-9][0-9][0-9]
140.         test -e "$temppfad" && rmdir "$temppfad"
141.  
142.         echo -e "Fertig.\n"
143.         exit 0
144. }
145.  
146.  
147.  
148.  
149.  
150.  
151.  
152.  
153. # Optionen auswerten -----------------------------------------------------------
154. test -z "$1" && Hilfe "$0"
155.  
156. while test -n "$1"
157. do
158.         case "${1:0:2}" in
159.                 '-b') # Befehlsdatei
160.                         if test -n "${1:2}"
161.                         then
162.                                 befehlsdatei="${1:2}"
163.                         else
164.                                 shift
165.                                 befehlsdatei="$1"
166.                         fi
167.                 ;;
168.  
169.                 '-a') # Ausgabedatei
170.                         if test -n "${1:2}"
171.                         then
172.                                 ausgabedatei="${1:2}"
173.                         else
174.                                 shift
175.                                 ausgabedatei="$1"
176.                         fi
177.                 ;;
178.  
179.                 '-d') # Durchlaeufe
180.                         if test -n "${1:2}"
181.                         then
182.                                 anzahl_durchlaeufe="${1:2}"
183.                         else
184.                                 shift
185.                                 anzahl_durchlaeufe="$1"
186.                         fi
187.                 ;;
188.  
189.                 '-g') # Ausgabegroessentest
190.                         if test -n "${1:2}"
191.                         then
192.                                 groesse_fuer_groessentest="${1:2}"
193.                         else
194.                                 shift
195.                                 groesse_fuer_groessentest="$1"
196.                         fi
197.                 ;;
198.  
199.                 '-t')
200.                         kein_fenster=false
201.                 ;;
202.  
203.                 *)
204.                         Hilfe "$0"
205.                 ;;
206.         esac
207.         shift
208. done
209.  
210.  
211.  
212.  
213. # Optionen testen
214. echo -e "\nTeste Optionen...\n"
215.  
216. # Befehlsdatei
217. if ! test -s "$befehlsdatei"
218. then
219.         echo -e "\aBefehlsdatei >$befehlsdatei< existiert nicht oder ist leer!"
220.         exit 1
221. fi
222.  
223. # Ausgabedatei
224. if test -e "$ausgabedatei"
225. then
226.         echo -e "\aAusgabedatei >$ausgabedatei< existiert bereits!\nUeberschreiben (j/n)"
227.         read -sn1
228.         test "$REPLY" != 'j' && exit 1
229.         rm "$ausgabedatei"
230. fi
231.  
232. # Anzahl der Durchlaeufe
233. if test -n "`tr -d '[:digit:]' <<<$anzahl_durchlaeufe`"
234. then
235.         echo -e "\aAnzahl der Durchlaeufe >$anzahl_durchlaeufe< enthaelt ungueltige Zeichen!"
236.         exit 1
237. fi
238. if test $anzahl_durchlaeufe -lt 0
239. then
240.         echo -e "\aAnzahl der Durchlaeufe >$anzahl_durchlaeufe< muss min. 1 sein!"
241.         exit 1
242. fi
243.  
244.  
245.  
246.  
247.  
248.  
249.  
250.  
251.  
252.  
253.  
254. # Hauptteil ####################################################################
255. # [strg]+c und "Fenster schliessen" abfangen um noch ordentlich aufzuraeumen
256. trap 'Ende Abbruch' 1 2
257.  
258. # Temppfad anlegen
259. test -e "$temppfad" || mkdir "$temppfad"
260.  
261. # Befehlsdatei saeubern (leere Zeilen und Zeilen mit einem # am Anfang entfernen)
262. grep -ve '^$' -e '^#' "$befehlsdatei" >"$befehls_arbeitsdatei"
263.  
264.  
265.  
266.  
267.  
268.  
269. # Laufzeit der Befehle messen
270. echo -e "\nLaufzeiten der Befehle werden gemessen...\n"
271.  
272. anzahl_der_befehle=`wc -l <"$befehls_arbeitsdatei"`
273. zeile=1
274. for zeile in `seq $anzahl_der_befehle`
275. do
276.         befehl="`ed -s "$befehls_arbeitsdatei" <<<$zeile 2>/dev/null`"
277.  
278.         echo "[Zeile $zeile von $anzahl_der_befehle] $befehl"
279.         Zeit_messen "$befehl" "$zeile"
280. done
281. echo "          "
282.  
283.  
284.  
285.  
286.  
287.  
288. # Zeiten mitteln
289. echo -e "\nDurchschnitt der Zeiten werden ermittelt...\n"
290.  
291. for zeile in `seq $anzahl_der_befehle`
292. do
293.         z0=`printf '%05i' $zeile`
294.         sort -g $werte_sammeldatei.$z0|uniq >"$tempdatei"
295.  
296.         user=( `grep -e 'user' "$tempdatei" |cut -b6-` )
297.         echo -n "user " >"$werte_sammeldatei.$z0"
298.         echo "scale=6;(`tr ' ' '+' <<<${user[*]}`)/${#user[*]}"|bc >>"$werte_sammeldatei.$z0"
299.  
300.         real=( `grep -e 'real' "$tempdatei" |cut -b6-` )
301.         echo -n "real " >>"$werte_sammeldatei.$z0"
302.         echo "scale=6;(`tr ' ' '+' <<<${real[*]}`)/${#real[*]}"|bc >>"$werte_sammeldatei.$z0"
303.  
304.         sys=( `grep -e 'sys' "$tempdatei" |cut -b6-` )
305.         echo -n "sys  " >>"$werte_sammeldatei.$z0"
306.         echo "scale=6;(`tr ' ' '+' <<<${sys[*]}`)/${#sys[*]}"|bc >>"$werte_sammeldatei.$z0"
307. done
308.  
309.  
310.  
311.  
312.  
313.  
314. # Ausgabe erstellen
315. echo -e "\nErstelle Ausgabedatei >$ausgabedatei<\n"
316.  
317. echo "Jeder Befehl wurde $anzahl_durchlaeufe mal ausgefuehrt." >"$ausgabedatei"
318. yes -|head -n 79|tr -d '\n' >>"$ausgabedatei"
319. echo >>"$ausgabedatei"
320.  
321. # Durchschnittszeiten ermitteln
322. test -e "$tempdatei" && rm "$tempdatei"
323. for zeile in `seq $anzahl_der_befehle`
324. do
325.         z0=`printf '%05i' $zeile`
326.         echo -n "$zeile " >>"$tempdatei"
327.         echo "scale=6;(`cut -b6- "$werte_sammeldatei.$z0"|tr '\n' '+'`0)/3"|bc >>"$tempdatei"
328. done
329.  
330. # Liste Sortieren
331. sort -nk2 "$tempdatei" -o "$tempdatei"
332.  
333. # Ausgabedatei schreiben
334. for zeile in `seq $anzahl_der_befehle`
335. do
336.         lesezeile=`ed -s "$tempdatei" <<<$zeile`
337.         echo "Platz $zeile:" >>"$ausgabedatei"
338.         ed -s "$befehls_arbeitsdatei" <<<${lesezeile%% *} >>"$ausgabedatei"
339.         cat "$werte_sammeldatei.`printf '%05i' ${lesezeile%% *}`" >>"$ausgabedatei"
340.         yes -|head -n 79|tr -d '\n' >>"$ausgabedatei"
341.         echo >>"$ausgabedatei"
342. done
343.  
344.  
345.  
346.  
347.  
348. Ende
349.  
350.  
351.  
352.  
353.  
354.  
355.  
356.  
357.  
358.  
359.  
360.  
361.  
362.  
363.  
364.  
365.  
366.  
367.  
368.  
369.  
370.  
371.  
372.  
373.  
374.  
375.  
376.  
377.  
378.  

Quellcode

Hier kannst du den Code kopieren und ihn in deinen bevorzugten Editor einfügen. PASTEBIN_DOWNLOAD_SNIPPET_EXPLAIN