NoPaste

Laufzeit von Befehlen herausfinden

von heinz

Dein Code:
  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. Alternativ kannst du den gesamten Eintrag auch als Datei herunterladen.