Linux Befehlszeitmessung

Einführung

In diesem Lab lernen Sie, wie Sie die Ausführungszeit von Befehlen in Linux messen können. Die Fähigkeit, die Ausführungsdauer von Befehlen zu verfolgen, ist eine wertvolle Fähigkeit für die Leistungsanalyse, Optimierung und Fehlerbehebung.

Der Befehl time ist ein einfaches, aber leistungsstarkes Werkzeug, mit dem Sie messen können, wie lange ein Programm oder Befehl zur Ausführung benötigt. Dies kann besonders nützlich sein, wenn Sie Ihre Skripte optimieren oder die Effizienz verschiedener Ansätze zur Lösung eines Problems vergleichen möchten.

Am Ende dieses Labs werden Sie in der Lage sein, den Befehl time zu verwenden, um Ausführungszeiten zu messen und die Ergebnisse zu interpretieren, um fundierte Entscheidungen über die Befehlseffizienz zu treffen.

Einführung in den Befehl Time

Der Befehl time ist ein Hilfsprogramm, das die Ausführungszeit eines bestimmten Befehls oder Programms misst. Dieses Tool hilft Ihnen zu verstehen, wie lange ein Befehl benötigt, um abgeschlossen zu werden, was für die Leistungsüberwachung und -optimierung nützlich ist.

Beginnen wir mit der Erstellung eines einfachen Skripts, mit dem wir den Befehl time demonstrieren können.

Navigieren Sie zunächst zum Projektverzeichnis, falls Sie sich noch nicht dort befinden:

cd ~/project

Erstellen wir nun ein einfaches Skript namens simple_echo.sh, das lediglich eine Nachricht ausgibt:

echo '#!/bin/bash' > ~/project/simple_echo.sh
echo 'echo "Hello, this is a simple script!"' >> ~/project/simple_echo.sh

Wir müssen das Skript ausführbar machen, bevor wir es ausführen können:

chmod +x ~/project/simple_echo.sh

Verwenden wir nun den Befehl time, um zu messen, wie lange die Ausführung dieses Skripts dauert:

time ~/project/simple_echo.sh

Sie sollten eine ähnliche Ausgabe wie diese sehen:

Hello, this is a simple script!
~/project/simple_echo.sh  0.00s user 0.00s system 90% cpu 0.001 total

In dieser Ausgabe:

• Die erste Zeile ist die Ausgabe Ihres Skripts.
• Die zweite Zeile zeigt die Zeitinformationen:
  • user: Die CPU-Zeit, die im Benutzermodus verbracht wurde (in diesem Fall 0,00s).
  • system: Die CPU-Zeit, die im Kernelmodus verbracht wurde (in diesem Fall 0,00s).
  • cpu: Der Prozentsatz der CPU-Auslastung (in diesem Fall 90%).
  • total: Die gesamte verstrichene Zeit (Wall-Clock-Zeit) von Anfang bis Ende (in diesem Fall 0,001 Sekunden).

Dieses einfache Beispiel zeigt, dass unser Skript erwartungsgemäß sehr schnell ausgeführt wird.

Die Ausgabe des Time-Befehls verstehen

Nachdem wir die grundlegende Verwendung des Befehls time kennengelernt haben, wollen wir uns die Ausgabe genauer ansehen. Das Verständnis dieser Metriken ist entscheidend für eine ordnungsgemäße Leistungsanalyse.

Als Sie den Befehl time im vorherigen Schritt ausgeführt haben, sahen Sie mehrere Zeitmessungen in einer einzigen Zeile:

1. user - Dies ist die CPU-Zeit, die im Benutzermodus-Code (außerhalb des Kernels) verbracht wurde. Es zählt nur die Zeit, in der die CPU aktiv am Code Ihres Programms gearbeitet hat.

2. system - Dies ist die CPU-Zeit, die im Kernel verbracht wurde. Dies beinhaltet die Zeit für Systemaufrufe (system calls) wie das Lesen oder Schreiben von Dateien.

3. cpu - Dies zeigt den Prozentsatz der CPU-Auslastung während der Ausführung.

4. total - Dies ist die gesamte Wall-Clock-Zeit (tatsächliche Zeit), von dem Zeitpunkt, an dem der Befehl gestartet wurde, bis zu dem Zeitpunkt, an dem er beendet wurde. Dies ist das, was Sie mit einer Stoppuhr messen würden.

Für unser einfaches Skript waren all diese Zeiten sehr kurz, da das Skript nur sehr wenig Arbeit verrichtet.

Erstellen wir ein CPU-intensiveres Skript, um diese Werte deutlicher zu sehen:

echo '#!/bin/bash' > ~/project/cpu_intensive.sh
echo 'for i in {1..1000000}; do' >> ~/project/cpu_intensive.sh
echo '  let "sum = $i + $i"' >> ~/project/cpu_intensive.sh
echo 'done' >> ~/project/cpu_intensive.sh
echo 'echo "Calculation complete"' >> ~/project/cpu_intensive.sh

Machen Sie das Skript ausführbar:

chmod +x ~/project/cpu_intensive.sh

Lassen Sie uns nun dieses Skript timen:

time ~/project/cpu_intensive.sh

Sie sollten eine ähnliche Ausgabe wie diese sehen (die tatsächlichen Zeiten variieren je nach Ihrem System):

Calculation complete
~/project/cpu_intensive.sh  2.10s user 0.09s system 93% cpu 2.335 total

Beachten Sie, dass die Werte diesmal deutlich höher sind, da unser Skript mehr Arbeit verrichtet. Die user-Zeit ist viel höher (2,10s), da unser Skript die meiste Zeit mit Berechnungen im Benutzermodus verbringt. Die system-Zeit ist ebenfalls höher (0,09s), aber immer noch relativ gering, da unser Skript nicht viele Systemaufrufe tätigt. Die gesamte Wall-Clock-Zeit beträgt 2,335 Sekunden und die CPU-Auslastung 93%.

Sie können diese Metriken verwenden, um zu identifizieren, wo ein Programm seine Zeit verbringt:

• Eine hohe user-Zeit bedeutet, dass das Programm im User Space (Benutzerbereich) CPU-intensiv ist.
• Eine hohe system-Zeit bedeutet, dass das Programm viele Systemaufrufe tätigt oder auf E/A wartet.
• Wenn total viel höher ist als die Summe von user und system, kann dies darauf hindeuten, dass das Programm auf Ressourcen wartet oder parallel ausgeführt wird.
• Der CPU-Prozentsatz gibt an, wie effizient die CPU während der Ausführung genutzt wurde.

Vergleich der Ausführungszeiten verschiedener Befehle

Nachdem wir nun wissen, wie man den Befehl time verwendet und seine Ausgabe interpretiert, wollen wir die Ausführungszeiten verschiedener Befehle vergleichen, um ihre Leistungsmerkmale zu verstehen.

Erstellen wir zunächst ein E/A-intensives Skript, das Daten liest und schreibt:

echo '#!/bin/bash' > ~/project/io_intensive.sh
echo 'for i in {1..10}; do' >> ~/project/io_intensive.sh
echo '  cat /etc/passwd > ~/project/temp_file_$i.txt' >> ~/project/io_intensive.sh
echo '  cat ~/project/temp_file_$i.txt > /dev/null' >> ~/project/io_intensive.sh
echo 'done' >> ~/project/io_intensive.sh
echo 'rm ~/project/temp_file_*.txt' >> ~/project/io_intensive.sh
echo 'echo "I/O operations complete"' >> ~/project/io_intensive.sh

Machen Sie das Skript ausführbar:

chmod +x ~/project/io_intensive.sh

Lassen Sie uns nun dieses E/A-intensive Skript timen:

time ~/project/io_intensive.sh

Sie sollten eine ähnliche Ausgabe wie diese sehen:

I/O operations complete
~/project/io_intensive.sh  0.01s user 0.00s system 96% cpu 0.014 total

Beachten Sie, dass die system-Zeit im Vergleich zur user-Zeit im Vergleich zu unserem CPU-intensiven Skript nun höher ist. Dies liegt daran, dass Datei-E/A-Operationen Systemaufrufe (system calls) erfordern, die im Kernelmodus ausgeführt werden. Der hohe CPU-Prozentsatz (96%) deutet darauf hin, dass das System die meiste Zeit während der Ausführung aktiv gearbeitet hat.

Lassen Sie uns auch einen gängigen Linux-Befehl timen, der nach Textmustern sucht:

time grep -r "root" /etc

Dieser Befehl sucht rekursiv nach dem Wort "root" in allen Dateien unter dem Verzeichnis /etc. Die Ausgabe könnte wie folgt aussehen:

[many matches shown here]
grep -r "root" /etc  0.18s user 0.08s system 99% cpu 0.259 total

Vergleichen wir nun alle drei Befehle, die wir getimed haben:

1. simple_echo.sh: Sehr schnelle Ausführung (0,001s total), minimale CPU- und Systemzeit.
2. cpu_intensive.sh: Längere Ausführung (2,335s total), hauptsächlich User-CPU-Zeit (2,10s).
3. io_intensive.sh: Moderate Ausführungszeit (0,014s total), ausgewogen zwischen User- und Systemzeit aufgrund von E/A-Operationen.
4. grep -r "root" /etc: Moderate Ausführungszeit (0,259s total), ausgewogen zwischen User- und Systemzeit aufgrund von Textverarbeitung und Datei-E/A.

Dieser Vergleich zeigt, wie sich verschiedene Arten von Operationen auf die Ausführungszeit und die Ressourcennutzung auswirken. Das Verständnis dieser Muster kann Ihnen helfen, Engpässe in Ihren Skripten und Befehlen zu identifizieren, was zu effizienterem Code führt.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie den Befehl time in Linux verwenden, um die Ausführungszeit von Befehlen und Skripten zu messen und zu analysieren. Sie haben praktische Erfahrungen gesammelt mit:

• Verwenden der grundlegenden time-Befehlssyntax zur Messung der Ausführungsdauer
• Verstehen der Schlüsselmetriken: User (Benutzer), System, CPU-Prozentsatz und Gesamtzeit (total time)
• Erstellen und Timen von Skripten mit unterschiedlichen Leistungsmerkmalen
• Vergleichen von Ausführungszeiten zur Identifizierung von Leistungsmustern
• Verwenden von Timing-Tools für eine detaillierte Leistungsanalyse

Die Fähigkeit, die Ausführungszeit von Befehlen zu messen, ist eine wesentliche Fähigkeit für Systemadministratoren, Entwickler und Power-User. Sie ermöglicht es Ihnen, Leistungsengpässe zu identifizieren, Ihren Code zu optimieren und fundierte Entscheidungen über die Ressourcenzuweisung zu treffen.

Wenn Sie weiterhin mit Linux arbeiten, werden Sie feststellen, dass der Befehl time ein wertvolles Werkzeug in Ihrem Performance Analysis Toolkit (Werkzeugkasten für die Leistungsanalyse) ist, das Ihnen hilft, effizientere Skripte und Befehle zu erstellen.