Czas Twoje scenariusze i procedury Bash z wnętrza kodu

Ogólnie rzecz biorąc, można użyć czas Narzędzie do bashu (patrz czas człowieka Aby uzyskać więcej informacji), aby uruchomić program i uzyskać czas trwania czasu wykonywania i podsumowania wykorzystania zasobów systemowych. Ale w jaki sposób można określić określone sekcje kodu, bezpośrednio z kodu źródłowego BASH?

Korzystając z niektórych łatwych przypisań i obliczeń zmiennych, możliwe jest osiągnięcie dokładnych wskaźników taktowania dla wykonywania skryptów BASH.

W tym samouczku się nauczysz:

• Jak skoncentrować się na bash za pomocą przypisań i obliczeń zmiennych
• Jak używać nakładających się timerów do określonych przez czas sekcji scenariuszy
• Przykłady, które są przykładem, w jaki sposób można określić określone sekcje kodu

Zastosowane wymagania i konwencje oprogramowania

Podstawy daty

Będziemy używać data polecenie naszych czasów. W szczególności będziemy używać Data +%s Aby uzyskać czas w sekundach od epoki lub innymi słowy, liczba sekund od 1970-01-01 00:00:00 UTC.

$ data +%s 1607481317 

Polecenie daty może również dostarczyć nanosekund (000000000… 999999999) precyzja, jeśli twoje czasy muszą być bardzo dokładne:

$ data +%s%n 1607488248328243029 

Omówienie wdrażania precyzyjnych timerów nanosekundowych jest poza zakresem tego artykułu, ale daj nam znać, czy ten temat Cię interesuje. Konfiguracja byłaby bardzo podobna do konfiguracji pokazanej poniżej, z kilkoma dodatkowymi obliczeniami i przepisami do obsługi sekund w porównaniu z milisekundami itp.

Przykład 1: Prosty przykład czasu

Zacznijmy od łatwego przykładu, w którym będziemy czas na jedno polecenie, a mianowicie sen 1, za pomocą dwóch Data +%s Polecenia i jedno przypisanie zmienne. Przechowuj poniższy skrypt w pliku o nazwie test.cii:

#!/bin/bash start = "$ (data +%s)" spać 1 czas trwania = $ [$ (data +%s) - $ start] echo $ czas trwania 

Tutaj najpierw wskazujemy, że chcemy, aby skrypt został wykonany jako kod bash za pomocą #!/bin/bash Wybór tłumacza. Wykonaliśmy również chmod +x ./test.cii Aby skrypt był wykonywany po utworzeniu.

Następnie ustawiamy zmienną POCZĄTEK do bieżących sekund od czasu epoki, dzwoniąc do subshella (jak wskazuje $ (…)) i w ramach tej subshelly wykonujemy Data +%s. Następnie używamy spać Funkcja, aby zatrzymać nasz skrypt na sekundę. Zauważ, że sen 1 można zastąpić faktycznym kodem programu, innymi słowy, co chcesz na czas.

Wreszcie ustawiliśmy nową zmienną CZAS TRWANIA wykonując obliczenia (jak wskazuje $ […]) - mianowicie, że bierzemy bieżące sekundy od epoki (ponownie przy użyciu Data +%s od wnętrza subshell), a następnie odejmowanie czasu rozpoczęcia od tego samego. Rezultatem jest liczba sekund, które minęły od początku.

Kiedy wykonujemy ten skrypt, dane wyjściowe jest zgodne z oczekiwaniami:

$ ./test.sh 1 

Przykład 2: Nieco bardziej złożony przykład czasu

Tym razem rozszerzmy trochę i uczyńmy czas bardziej modułową. test2.cii:

#!/bin/bash start1 = "$ (data +%s)" sleep 2 end1 = "$ (data +%s)" sleep 2 start2 = "$ (data +%s)" sleep 3 end2 = "$ (data + + %s) "czas trwania1 = $ [$ end1 - $ start1] czas trwania2 = $ [$ end2 - $ start2] echo" Pierwsza część kodu wzięła: $ czas trwania1 "echo" echo "echo" echo " Druga część kodu wzięła: $ czas trwania 2 " 

Tutaj dokonaliśmy podobnej konfiguracji do pierwszego przykładu, ale tym razem mieliśmy czas na dwa różne polecenia, używając podwójnego zestawu zmiennych, i ustrukturyzowaliśmy to nieco bardziej, używając KONIEC Zmienna dla obu poleceń. Moglibyśmy również napisać ostatnie linie echo w następujący sposób test3.cii:

#!/bin/bash start1 = "$ (data +%s)" sleep 2 end1 = "$ (data +%s)" sleep 2 start2 = "$ (data +%s)" sleep 3 end2 = "$ (data + + %s) „echo” 1. część kodu wzięła: $ [$ end1 - $ start1] „echo” Druga część kodu: $ [end2 - $ start2] ” 

Jak dwa CZAS TRWANIA Zmienne były w pewnym sensie niepotrzebne. Mogły czytać kod, ale nie wypełniają żadnej innej funkcji, w przeciwieństwie do POCZĄTEK I KONIEC Zmienne stosowane do faktycznych obliczeń.

Zwróć jednak uwagę, że nie moglibyśmy pisać test4.cii:

#!/bin/bash start1 = "$ (data +%s)" sleep 2 sleep 2 start2 = "$ (data +%s)" sleep 3 echo "Pierwsza część kodu wzięła: $ [$ (data +%s ) - $ start1] „echo” 2. część kodu wzięła: $ [$ (data +%s) - $ start2] ” 

Ponieważ data przechwycona w subshellowie jest czasem, w którym echo jest wykonywane, czasy dla obu byłyby wyłączone: czas końcowy powinien być przyjmowany bezpośrednio po odpowiednich poleceń.

Być może w drugim czasie byłoby możliwe użycie Data +%s Bezpośrednio w echo (ponieważ pierwsze echo zajęłoby tylko kilka milisekund, nawet przy zawartości subshell i datę), ale nie jest idealne i zdecydowanie nie zadziałałoby, gdyby wymagany jest precyzyjny czas nanosekundowy. Nie jest również czyste kodowanie i trudniejsze do odczytania/zrozumienia.

Wykonajmy te skrypty i porównajmy dane wyjściowe:

$ ./test2.sh Wystąpił 1. część kodu: 2 drugą część kodu wzięła: 3 $ ./test3.sh Wystąpił 1. część kodu: 2 drugą część kodu wzięła: 3 $ ./test4.sh, pierwsza część kodu: 7 druga część kodu wzięła: 3 

test2.cii I test3.cii Zgłoszone prawidłowe czasy, zgodnie z oczekiwaniami. test4.cii Skrypt zgłosił nieprawidłowe czasy, również zgodnie z oczekiwaniami.

Czy widzisz, jak długo scenariusz działał ogólnie, w przybliżeniu w ciągu kilku sekund, niezależnie od żadnych czasów? Jeśli odpowiedz na sześć sekund, masz rację. Możesz zobaczyć, jak się w niej test2.cii I test3.cii Jest dodatkowy Sleep 2 który nie jest przechwytywany w poleceń czasowych. To jest przykład, w jaki sposób możesz czas na różne sekcje kodu.

Przykład 3: Nakładające się timery

Spójrzmy teraz na ostatni przykład, który ma nakładające się liczniki i czasy funkcji.test5.cii:

#!/bin/bash my_sleep_function () sleep 1 ogólny_start = "$ (data +%s)" function_start = "$ (data +%s)" my_sleep_function funkcja_end = "$ (data +%s)" sleep 2 comic_end = " $ (data +%s) „echo” część funkcji wzięła część kodu: $ [$ function_end - $ funkcja_start] sekundy uruchamiać „echo” ogólny kod: $ [$ ogólnie_end - $ $  COLOGALNE_START] sekundy do uruchomienia ” 

Tutaj definiujemy funkcję my_sleep_function który po prostu śpi przez sekundę. Następnie ustawiamy ogólny timer startowy za pomocą COLOGAKTY_START zmienne i znowu nasze Data +%s w subshellowie. Następnie rozpoczynamy kolejny timer (licznik funkcji oparty na Funkcja_start zmienny). Uruchamiamy funkcję i natychmiast kończymy timer funkcji, ustawiając Funkcja_d zmienny.

Następnie robimy dodatkowe Sleep 2 a następnie zakończ ogólny timer, ustawiając Ogólnie_d regulator czasowy. Wreszcie, informujemy informacje w ładnym formacie pod koniec skryptu. Dwójka Echo Oświadczenia nie są częścią czasu, ale ich czas wykonawczy byłby minimalny; Zwykle staramy się czas na różne i konkretne sekcje naszego kodu, które zwykle mają długie czasy, takie jak rozległe pętle, zewnętrzne wywołania programów, wiele subshellów itp.

Spójrzmy na poza test5.cii:

$ ./test5.SH Funkcja część kodu zajęła: 1 sekundy, aby uruchomić ogólny kod: 3 sekundy do uruchomienia 

Wygląda dobrze. Skrypt poprawnie wyczyścił funkcję na 1 sekundę, a ogólny czas wykonywania skryptu jako 3 sekundy, będąc kombinacją wywołania funkcji i dodatkowym dwoma sekundami.

Zauważ, że jeśli funkcja jest rekurencyjnie, sensowne może być użycie dodatkowej globalnej zmiennej czasowej, do której można dodać czas wykonania funkcji. Możesz także policzyć liczbę wywołań funkcji, a następnie na końcu podzielić liczbę wywołań funkcji za pomocą pne (Ref, jak dokonać obliczeń dziesiętnych w BASH za pomocą BC). W tym przypadku najlepiej może być przeniesienie liczników startowych i zatrzymywanych, a także obliczanie czasu trwania funkcji w funkcji. Tworzy czystszy i wyraźniejszy kod i może wyeliminować niepotrzebne powielanie kodu.

Wniosek

W tym artykule spojrzeliśmy na czas różnych części naszego kodu skryptu Bash, używając Data +%s jako podstawa do uzyskania sekund od czasu epoki, a także jedno lub więcej zmiennych przypisań do obliczania terminów wydajności jedna lub więcej sekcji kodu. Korzystając z tych podstawowych elementów konstrukcyjnych, można wykonać złożone struktury pomiaru czasu, na funkcję, nazywane skryptem, a nawet timery, które nakładają się (na przykład jeden na skrypt, a także jeden na funkcję itp.) Za pomocą różnych zmiennych. Cieszyć się!

Jeśli chcesz dowiedzieć się więcej o Bash, zobacz naszą użyteczną serię linii poleceń Bash.

Powiązane samouczki Linux:

• Jak zbudować aplikację Tkinter za pomocą obiektu zorientowanego na…
• Samouczek debugowania GDB dla początkujących
• Wyrażenia regularne Pythona z przykładami
• Advanced Bash Regex z przykładami
• Zagnieżdżone pętle w skryptach Bash
• Pętle bash z przykładami
• Jak pracować z WooCommerce Rest API z Pythonem
• Zainstaluj Arch Linux na stacji roboczej VMware
• Jak skonfigurować serwer OpenVPN na Ubuntu 20.04
• Bash Advanced zmienne idiomy dla wrażliwości na przypadki…