Ziehen Sie Ihre Bash -Skripte und -Ver Prozeduren aus dem Code aus

Im Allgemeinen kann man die verwenden Zeit Bash -Dienstprogramm (siehe Mannzeit Um weitere Informationen) auszuführen und ein Programm auszuführen und Laufzeit- und Systemressourcen -Nutzungszusammenfassungen zu erhalten. Aber wie kann ein Mal bestimmte Codeabschnitte direkt aus dem Bash -Quellcode aus dem Bash -Quellcode?

Mit einigen einfachen variablen Zuordnungen und Berechnungen können genaue Zeitmetriken für Bash -Skript -Ausführungen erreicht werden.

In diesem Tutorial lernen Sie:

• So zeitliche Skripte mit variablen Zuordnungen und Berechnungen verprügeln
• So verwenden Sie überlappende Timer zu zeitspezifischen Abschnitten Ihrer Skripte
• Beispiele, die veranschaulichen, wie bestimmte Codeabschnitte zeitlich festgelegt werden können

Softwareanforderungen und Konventionen verwendet

Date -Grundlagen

Wir werden die verwenden Datum Befehl für unsere Timings. Insbesondere werden wir verwenden Datum +%s Um die Zeit in Sekunden seit der Epoche oder mit anderen Worten die Anzahl der Sekunden seit 1970-01-01 00:00:00 UTC zu erhalten.

$ Datum +%S 1607481317 

Der Datumskommando kann auch Nanosekunden (000000000… 999999999) Präzision bereitstellen, wenn Ihre Zeiten super genau sein müssen:

$ Datum +%S%N 1607488248328243029 

Die Erörterung der Implementierung von genauen Timern von Nanosekunden liegt außerhalb des Rahmens dieses Artikels. Bitte teilen Sie uns bitte mit, ob dieses Thema Sie interessiert. Das Setup wäre dem unten gezeigten Setup sehr ähnlich, mit einigen zusätzlichen Berechnungen und Bestimmungen, um die Sekunden im Vergleich zu den Millisekunden usw. zu bewältigen, usw.

Beispiel 1: Ein einfaches Timing -Beispiel

Beginnen wir mit einem einfachen Beispiel, in dem wir einen einzigen Befehl angeben werden, nämlich Schlaf 1, mit zwei Datum +%s Befehle und eine variable Zuordnung. Speichern Sie das folgende Skript in eine Datei mit dem Namen prüfen.Sch:

#!/bin/bash start = "$ (Datum +%s)" Schlaf 1 Dauer = $ [$ (Datum +%s) - $ start] echo $ Dauer 

Hier geben wir zunächst an, dass das Skript mithilfe der Skript als Bash -Code ausgeführt wird #!/Bin/Bash Interpreterauswahl. Wir haben auch ausgeführt Chmod +x ./prüfen.Sch Um das Skript nach dem Erstellen ausführbar zu machen.

Als nächstes setzen wir die Variable START zu den aktuellen Sekunden seit der Epoche, indem sie eine Unterschale aufrief (wie angegeben von $ (…)) und innerhalb dieser Unterschale führen wir aus Datum +%s. Wir verwenden dann die schlafen Funktion, unser Skript für eine Sekunde zu pausieren. Notiere dass der Schlaf 1 Könnte Ihren tatsächlichen Programmcode ersetzt werden, mit anderen Worten der Teil, den Sie Zeit haben möchten.

Schließlich setzen wir eine neue Variable DAUER durch Berechnung (wie angegeben von $ […]) - nämlich, dass wir die aktuellen Sekunden seit der Epoche nehmen (erneut durch Verwendung Datum +%s aus einer Unterschale aus) und dann die Startzeit von derselben abziehen. Das Ergebnis ist die Anzahl der Sekunden, die seit Beginn vergangen sind.

Wenn wir dieses Skript ausführen, ist die Ausgabe wie erwartet:

$ ./prüfen.Sh 1 

Beispiel 2: Ein wenig komplexeres Timing -Beispiel

Lassen Sie uns diesmal ein wenig erweitern und die Timings modularer machen. Test2.Sch:

#!/bin/bash start1 = "$ (Datum +%s)" Sleep 2 End1 = "$ (Datum +%s)" Sleep 2 start2 = "$ (Datum +%s)" Sleep 3 End2 = "$ (Datum + %s) "Duration1 = $ [$ end1 - $ start1] duration2 = $ [$ end2 - $ start2] echo" Der 1. Teil des Codes nahm: $ Duration1 "echo" die 2. Teil des Codes nahm: $ duration2 " 

Hier haben wir das erste Beispiel ähnlich eingerichtet ENDE Variable für beide Befehle. Wir hätten auch die letzten Echo -Zeilen wie folgt schreiben können Test3.Sch:

#!/bin/bash start1 = "$ (Datum +%s)" Sleep 2 End1 = "$ (Datum +%s)" Sleep 2 start2 = "$ (Datum +%s)" Sleep 3 End2 = "$ (Datum + %s) "echo" Der 1. Teil des Codes nahm: $ [$ end1 - $ start1] "echo" Der 2. Teil des Codes wurde: $ [$ end2 - $ start2] " 

Als die beiden DAUER Variablen waren in gewisser Weise unnötig. Der Code hat den Code klarer zum Lesen gemacht, aber sie erfüllen keine wirkliche andere Funktion, anders als die START Und ENDE Variablen, die für tatsächliche Berechnungen verwendet werden.

Beachten Sie jedoch, dass wir nicht schreiben können test4.Sch:

#!/bin/bash start1 = "$ (Datum +%s)" Schlaf 2 Schlaf 2 Start2 = "$ (Datum +%s)" Schlaf 3 echo "Der 1. Teil des Codes wurde: $ [$ (Datum +%s) ) - $ start1] "echo" Der zweite Teil des Code hat: $ [$ (Datum +%s) - $ start2] " 

Da das in der Unterschale erfasste Datum die Zeit ist, in der das Echo ausgeführt wird.

Vielleicht wäre es für das zweite Timing möglich gewesen, a zu verwenden Datum +%s Direkt im Echo (da das erste Echo nur einige Millisekunden zum Ausführen dauern würde, auch wenn die Unterschale und das Datum enthalten ist), ist es jedoch nicht perfekt und würde definitiv nicht funktionieren, wenn ein Präzisionszeitpunkt der Nanosekunden erforderlich ist. Es ist auch keine saubere Codierung und schwerer zu lesen/zu verstehen.

Lassen Sie uns diese Skripte ausführen und die Ausgabe vergleichen:

$ ./test2.SH Der 1. Teil des Code dauerte: 2 Der 2. Teil des Codes dauerte: 3 $ ./test3.SH Der 1. Teil des Code dauerte: 2 Der 2. Teil des Codes dauerte: 3 $ ./test4.SH Der 1. Teil des Codes nahm: 7 Der 2. Teil des Codes nahm: 3 

Der Test2.Sch Und Test3.Sch wie erwartet die richtigen Zeiten gemeldet. Der test4.Sch Das Skript meldete falsche Timings, ebenso wie erwartet.

Können Sie sehen, wie lange das Skript insgesamt ungefähr in Sekunden dauerte, unabhängig von allen Zeitungen? Wenn Sie antworten, waren Sie sechs Sekunden. Sie können sehen, wie rein Test2.Sch Und Test3.Sch Es gibt zusätzliche Schlaf 2 das wird in den Timing -Befehlen nicht erfasst. Dies veranschaulicht, wie Sie verschiedene Codeabschnitte zeitieren können.

Beispiel 3: Überlappende Timer

Schauen wir uns nun ein endgültiges Beispiel an, das überlappende Timer und Zeiten eine Funktion hat.Test5.Sch:

#!/bin/bash my_sleep_function () sleep 1 insgesamt_start = "$ (Datum +%s)" function_start = "$ (Datum +%s)" my_sleep_function function_end = "$ (Datum +%s)" Sleep 2 allgemein_end = " $ (Datum +%s) "echo" Der Funktionsteil des Code hat: $ [$ function_end - $ function_start] Sekunden zum Ausführen "echo" Der Gesamtcode nahm: $ [$ insgesamt - $ $ $  Insgesamt_start] Sekunden zum Ausführen " 

Hier definieren wir eine Funktion my_sleep_function was einfach für eine Sekunde schläft. Als nächstes setzen wir einen Gesamtstart -Timer, indem wir die verwenden Insgesamt_start variabel und wieder unsere Datum +%s in einer Unterschale. Als nächstes starten wir einen weiteren Timer (der Funktions -Timer basierend auf dem Funktion_Start Variable). Wir führen die Funktion aus und beenden den Funktionstimer sofort, indem wir die festlegen Funktion_end Variable.

Wir machen dann eine zusätzliche Schlaf 2 und beenden Sie dann den Gesamt -Timer, indem Sie die festlegen Insgesamt_end Timer. Schließlich geben wir die Informationen gegen Ende des Skripts in einem schönen Format aus. Die Zwei Echo Aussagen sind nicht Teil des Timings, aber ihre Laufzeit wäre minimal; Normalerweise versuchen wir, verschiedene und bestimmte Abschnitte unseres Code zu zeitieren, die tendenziell lange Zeiten wie umfangreiche Schleifen, externe Programmanrufe, viele Unterschalen usw. haben.

Schauen wir uns das aus Test5.Sch:

$ ./Test5.SH Der Funktionsteil des Code dauerte: 1 Sekunden, um den Gesamtcode auszuführen: 3 Sekunden lang dauerte der Betrieb 

Sieht gut aus. Das Skript zeitete die Funktion korrekt auf 1 Sekunde und die Gesamtlauflaufzeit von 3 Sekunden, was die Kombination des Funktionsaufrufs und der zwei zusätzlichen Sekunden Schlaf ist.

Beachten Sie, dass die Funktion, wenn die Funktion rekursiv ist. Sie können auch die Anzahl der Funktionsaufrufe zählen und am Ende die Anzahl der Funktionsaufrufe mithilfe verwenden BC (Ref wie man Dezimalberechnungen in Bash mit BC erstellt). In diesem Anwendungsfall kann es am besten sein, die Start- und Stopptimer sowie die Berechnung der Funktionsdauer in die Funktion zu verschieben. Es sorgt für sauberere und klarere Code und kann unnötige Code -Duplikation beseitigen.

Abschluss

In diesem Artikel haben wir uns mit dem Timing verschiedener Teile unseres Bash -Skript -Codes untersucht Datum +%s als Grundlage für die Erzielung von Sekunden seit der Epoche und eine oder mehrere variable Zuordnungen zur Berechnung der Leistungszeitpunkte eines oder mehrere Abschnitte des Codes. Mit diesen grundlegenden Bausteinen kann pro Funktion komplexe Timing -Messstrukturen pro Funktion gemäß Skript oder sogar Timer erfolgen, die sich überlappen (z. B. eine pro Skript sowie eine pro Funktion usw.) Durch die Verwendung verschiedener Variablen. Genießen!

Wenn Sie mehr über Bash erfahren möchten.

Verwandte Linux -Tutorials:

• So erstellen Sie eine Tkinter -Anwendung mithilfe eines objektorientierten…
• GDB -Debugging -Tutorial für Anfänger
• Python reguläre Ausdrücke mit Beispielen
• Advanced Bash Regex mit Beispielen
• Verschachtelte Schleifen in Bash -Skripten
• Schleifen mit Beispielen verprügeln
• Wie man mit der Woocommerce -REST -API mit Python arbeitet
• Installieren Sie Arch Linux in VMware Workstation
• So richten Sie einen OpenVPN -Server auf Ubuntu 20 ein.04
• Bash Advanced Variable Idiome für die Fallempfindlichkeit…