NoPaste

Laufzeit von Befehlen herausfinden 0.2

von wanne
Beschreibung:
Laufzeit von Befehlen herausfinden
Snippet erstellt:
11.05.2019 15:51:59
Snippet wird automatisch gelöscht:
Niemals

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

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.