Waktu skrip dan prosedur bash Anda dari dalam kode

Secara umum, seseorang dapat menggunakan waktu Utilitas bash (lihat waktu pria Untuk informasi lebih lanjut) untuk menjalankan program, dan mendapatkan ringkasan durasi runtime dan penggunaan sumber daya sistem. Tetapi bagaimana suatu kali bagian kode tertentu, langsung dari dalam kode sumber bash?

Menggunakan beberapa tugas dan perhitungan variabel yang mudah, dimungkinkan untuk mencapai metrik waktu yang akurat untuk eksekusi skrip bash.

Dalam tutorial ini Anda akan belajar:

• Cara waktu bash skrip menggunakan penugasan dan perhitungan variabel
• Cara menggunakan timer yang tumpang tindih untuk bagian spesifik skrip Anda
• Contoh yang mencontohkan bagaimana bagian kode tertentu dapat diatur waktunya

Persyaratan dan konvensi perangkat lunak yang digunakan

Dasar -dasar Tanggal

Kami akan menggunakan tanggal Perintah untuk timing kami. Secara khusus, kami akan menggunakan tanggal +%s Untuk mendapatkan waktu dalam detik sejak zaman, atau dengan kata lain, jumlah detik sejak 1970-01-01 00:00:00 UTC.

$ tanggal +%s 1607481317 

Perintah tanggal juga dapat memberikan presisi nanoseconds (000000000 ... 999999999) presisi, jika waktu Anda harus sangat akurat:

$ Tanggal +%S%N 1607488248328243029 

Mendiskusikan implementasi timer yang tepat nanosecond berada di luar ruang lingkup artikel ini, tapi tolong beri tahu kami jika topik ini menarik minat Anda. Pengaturan akan sangat mirip dengan pengaturan yang ditunjukkan di bawah ini, dengan beberapa perhitungan dan ketentuan tambahan untuk menangani detik versus milidetik dll.

Contoh 1: Contoh Waktu Sederhana

Mari kita mulai dengan contoh yang mudah, di mana kita akan mengatur waktu satu perintah, yaitu Tidur 1, menggunakan dua tanggal +%s perintah dan satu tugas variabel. Simpan skrip di bawah ini ke dalam file yang dipanggil tes.SH:

#!/bin/bash start = "$ (tanggal +%s)" sleep 1 durasi = $ [$ (tanggal +%s) - $ start] echo $ durasi 

Di sini pertama -tama kami menunjukkan bahwa kami ingin skrip dieksekusi sebagai kode bash dengan menggunakan #!/bin/bash pemilihan penerjemah. Kami juga dieksekusi chmod +x ./tes.SH untuk membuat skrip dapat dieksekusi setelah membuatnya.

Selanjutnya kami mengatur variabel AWAL ke detik saat ini sejak waktu zaman dengan memanggil subshell (seperti yang ditunjukkan oleh $ (...)) dan di dalam subshell itu kami mengeksekusi tanggal +%s. Kami kemudian menggunakan tidur Fungsi untuk menjeda skrip kami selama satu detik. Perhatikan bahwa Tidur 1 dapat diganti dengan kode program Anda yang sebenarnya, dengan kata lain bagian yang Anda inginkan waktu.

Akhirnya kami menetapkan variabel baru DURASI dengan melakukan perhitungan (seperti yang ditunjukkan oleh $ […]) - yaitu bahwa kami mengambil detik saat ini sejak zaman (lagi dengan menggunakan tanggal +%s dari dalam subshell) dan kemudian mengurangi waktu mulai dari yang sama. Hasilnya adalah jumlah detik yang telah berlalu sejak mulai.

Ketika kami menjalankan skrip ini, output seperti yang diharapkan:

$ ./tes.Sh 1 

Contoh 2: Contoh waktu yang sedikit lebih kompleks

Kali ini, mari kita kembangkan sedikit dan buat waktu lebih modular. test2.SH:

#!/bin/bash start1 = "$ (tanggal +%s)" sleep 2 end1 = "$ (tanggal +%s)" sleep 2 start2 = "$ (tanggal +%s)" sleep 3 end2 = "$ (tanggal + %s) "durasi1 = $ [$ end1 - $ start1] durasi2 = $ [$ end2 - $ start2] echo" Bagian pertama dari kode mengambil: $ durasi1 "echo" the the Bagian ke -2 dari kode mengambil: $ durasi2 " 

Di sini kami membuat pengaturan yang sama dengan contoh pertama, tetapi kali ini kami mengatur waktu dua perintah yang berbeda, menggunakan satu set variabel ganda, dan kami menyusun hal -hal sedikit lebih banyak dengan menggunakan sebuah AKHIR variabel untuk kedua perintah. Kami juga bisa menulis garis gema terakhir sebagai berikut test3.SH:

#!/bin/bash start1 = "$ (tanggal +%s)" sleep 2 end1 = "$ (tanggal +%s)" sleep 2 start2 = "$ (tanggal +%s)" sleep 3 end2 = "$ (tanggal + %s) "echo" Bagian pertama dari kode mengambil: $ [$ end1 - $ start1] "echo" Bagian kedua dari kode mengambil: $ [$ end2 - $ start2] " 

Sebagai keduanya DURASI Variabel dalam beberapa hal tidak perlu. Mereka mungkin telah membuat kode lebih jelas untuk dibaca, tetapi mereka tidak memenuhi fungsi lain yang nyata, tidak seperti AWAL Dan AKHIR variabel yang digunakan untuk perhitungan aktual.

Namun perlu dicatat bahwa kami tidak dapat menulis test4.SH:

#!/bin/bash start1 = "$ (tanggal +%s)" sleep 2 sleep 2 start2 = "$ (tanggal +%s)" sleep 3 echo "Bagian pertama dari kode mengambil: $ [$ (tanggal +%s ) - $ start1] "echo" Bagian kedua dari kode mengambil: $ [$ (tanggal +%s) - $ start2] " 

Karena tanggal yang ditangkap di dalam subshell adalah waktu ketika gema sedang dieksekusi, waktu untuk keduanya akan mati: waktu akhirnya seharusnya mengambil langsung setelah perintah yang relevan.

Mungkin untuk waktu kedua mungkin untuk menggunakan a tanggal +%s Langsung di Echo (karena gema pertama hanya akan membutuhkan beberapa milidetik untuk dieksekusi, bahkan dengan subshell dan tanggal termasuk), tetapi tidak sempurna, dan pasti tidak akan berfungsi jika waktu presisi nanosecond diperlukan. Ini juga bukan pengkodean yang bersih dan lebih sulit dibaca/dimengerti.

Mari kita jalankan skrip ini dan bandingkan output:

$ ./test2.SH Bagian pertama dari kode mengambil: 2 Bagian kedua dari kode mengambil: 3 $ ./test3.SH Bagian pertama dari kode mengambil: 2 Bagian kedua dari kode mengambil: 3 $ ./test4.SH Bagian pertama dari kode mengambil: 7 Bagian ke -2 dari kode mengambil: 3 

Itu test2.SH Dan test3.SH melaporkan waktu yang benar, seperti yang diharapkan. Itu test4.SH skrip melaporkan waktu yang salah, juga seperti yang diharapkan.

Dapatkah Anda melihat berapa lama skrip berjalan secara keseluruhan, kira -kira dalam hitungan detik, terlepas dari waktu apa pun? Jika Anda menjawab enam detik, Anda benar. Anda bisa melihat bagaimana test2.SH Dan test3.SH ada tambahan tidur 2 yang tidak ditangkap dalam perintah waktu. Ini mencontohkan bagaimana Anda dapat mengatur waktu berbagai bagian kode.

Contoh 3: Timer yang tumpang tindih

Sekarang mari kita lihat contoh terakhir yang memiliki timer dan waktu yang tumpang tindih suatu fungsi.Test5.SH:

#!/bin/bash my_sleep_function () sleep 1 keseluruhan_start = "$ (tanggal +%s)" function_start = "$ (tanggal +%s)" my_sleep_function function_end = "$ (tanggal +%s)" sleep 2 keseluruhan_end = " $ (tanggal +%s) "echo" Bagian fungsi dari kode mengambil: $ [$ function_end - $ function_start] detik untuk menjalankan "echo" kode keseluruhan mengambil: $ [$ keseluruhan_end - $  Secara keseluruhan_start] detik untuk dijalankan " 

Di sini kami mendefinisikan fungsi my_sleep_function yang hanya tidur selama satu detik. Kami selanjutnya menetapkan timer start secara keseluruhan dengan menggunakan Secara keseluruhan_start variabel dan sekali lagi kami tanggal +%s di subsklell. Selanjutnya kita memulai pengatur waktu lain (pengatur waktu fungsi berdasarkan pada Function_start variabel). Kami menjalankan fungsi dan mengakhiri segera mengakhiri fungsi timer dengan mengatur Function_end variabel.

Kami kemudian melakukan tambahan tidur 2 dan kemudian mengakhiri timer keseluruhan dengan mengatur Keseluruhan_end timer. Akhirnya, kami mengeluarkan informasi dalam format yang bagus di dekat akhir skrip. Keduanya gema Pernyataan bukan bagian dari waktu, tetapi runtime mereka akan minim; Biasanya kami berusaha untuk menghitung waktu dan bagian spesifik dari kode kami yang cenderung memiliki jangka panjang seperti loop yang luas, panggilan program eksternal, banyak subsklell dll.

Mari kita lihat di luar Test5.SH:

$ ./test5.SH Fungsi bagian dari kode memakan waktu: 1 detik untuk menjalankan kode keseluruhan membutuhkan: 3 detik untuk dijalankan 

Kelihatan bagus. Script dengan benar mengatur waktu fungsi hingga 1 detik, dan runtime skrip keseluruhan sebagai 3 detik, menjadi kombinasi dari panggilan fungsi dan tidur ekstra dua detik.

Perhatikan bahwa jika fungsinya secara rekursif, mungkin masuk akal untuk menggunakan variabel waktu global tambahan yang dapat ditambahkan runtime fungsi ke mana. Anda juga dapat menghitung jumlah panggilan fungsi dan kemudian pada akhirnya membagi jumlah panggilan fungsi dengan menggunakan bc (REF Cara membuat perhitungan desimal dalam bash menggunakan BC). Dalam kasus penggunaan ini, mungkin menjadi yang terbaik untuk memindahkan timer start dan stop, serta perhitungan durasi fungsi untuk di dalam fungsi. Itu membuat kode yang lebih bersih dan lebih jelas dan dapat menghilangkan duplikasi kode yang tidak perlu.

Kesimpulan

Dalam artikel ini, kami melihat waktu berbagai bagian kode skrip bash kami dengan menggunakan tanggal +%s Sebagai dasar untuk mendapatkan detik sejak waktu zaman, serta satu atau lebih penugasan variabel untuk menghitung waktu kinerja satu atau lebih bagian dari kode. Menggunakan blok bangunan dasar ini, seseorang dapat membuat struktur pengukuran waktu yang kompleks, per fungsi, per skrip yang disebut atau bahkan timer yang tumpang tindih (misalnya satu per skrip serta satu per fungsi dll.) dengan menggunakan variabel yang berbeda. Menikmati!

Jika Anda tertarik untuk mempelajari lebih lanjut tentang Bash, silakan lihat seri Tips dan Trik Baris Perintah Bash kami yang berguna.

Tutorial Linux Terkait:

• Cara Membangun Aplikasi Tkinter Menggunakan Objek Berorientasi…
• Tutorial debugging GDB untuk pemula
• Ekspresi reguler Python dengan contoh
• Lanjutan regex bash canggih dengan contoh
• Loop bersarang dalam skrip bash
• Loop bash dengan contoh
• Bagaimana bekerja dengan WooCommerce Rest API dengan Python
• Instal Arch Linux di VMware Workstation
• Cara Mengatur Server OpenVPN di Ubuntu 20.04
• Idiom variabel lanjutan bash untuk sensitivitas kasus…