Apa arti dari aturan 90/10 tentang optimasi program?

Menurut Wikipedia, aturan 90/10 tentang optimasi program menyatakan bahwa “90% dari waktu eksekusi program dihabiskan untuk mengeksekusi 10% dari kode” (lihat paragraf kedua di sini ).

Saya benar-benar tidak mengerti ini. Apa sebenarnya artinya ini? Bagaimana 90% waktu eksekusi dapat dihabiskan hanya mengeksekusi 10% dari kode? Bagaimana dengan 90% kode lainnya? Bagaimana mereka dapat dieksekusi hanya dalam 10% dari waktu?

Ada dua prinsip dasar yang dimainkan di sini:

• Beberapa kode dieksekusi lebih sering daripada kode lainnya. Misalnya, beberapa kode penanganan kesalahan mungkin tidak pernah digunakan. Beberapa kode akan dieksekusi hanya ketika Anda memulai program Anda. Kode lain akan dieksekusi berulang saat program Anda berjalan.
• Beberapa kode membutuhkan waktu lebih lama untuk dijalankan daripada kode lainnya. Misalnya, satu baris yang menjalankan kueri pada database, atau menarik file dari internet mungkin akan memakan waktu lebih lama dari jutaan operasi matematika.

Aturan 90/10 tidak benar secara harfiah. Ini bervariasi berdasarkan program (dan saya ragu ada dasar untuk angka-angka spesifik 90 dan 10 sama sekali; seseorang mungkin menarik mereka keluar dari udara). Tetapi intinya adalah, jika Anda ingin program Anda berjalan lebih cepat, mungkin hanya sejumlah kecil baris yang signifikan untuk mewujudkannya. Mengidentifikasi bagian lambat dari perangkat lunak Anda seringkali merupakan bagian terbesar dari optimasi.

Ini adalah wawasan yang penting, dan itu berarti bahwa keputusan yang tampaknya berlawanan dengan pengembang baru seringkali benar. Sebagai contoh:

• Ada banyak kode yang tidak sepadan dengan waktu Anda untuk membuat "lebih baik" , bahkan jika melakukan sesuatu dengan cara yang bodoh dan sederhana. Bisakah Anda menulis algoritma pencarian yang lebih efisien untuk aplikasi XYZ? Ya, tetapi sebenarnya perbandingan sederhana dari setiap nilai membutuhkan jumlah waktu yang sepele, meskipun ada ribuan nilai. Jadi itu tidak layak. Mungkin sulit bagi pengembang baru untuk menghindari optimasi yang tidak perlu, karena dalam program gelar mereka begitu banyak waktu dihabiskan untuk menulis algoritma "benar" (yang berarti paling efisien). Tetapi di dunia nyata, algoritma yang benar adalah yang bekerja dan berjalan cukup cepat.
• Perubahan yang membuat kode Anda jauh lebih lama dan lebih kompleks mungkin masih menjadi kinerja menang. Misalnya, dalam aplikasi FOO mungkin perlu menambahkan ratusan baris logika baru, hanya untuk menghindari panggilan basis data tunggal.

Ini bukan hukum alam, tetapi aturan praktis yang lahir dari pengalaman luas. Ini juga dikenal sebagai aturan 80/20, dan hanya merupakan perkiraan kasar.

Loop, Cabang dan kontrol aliran lainnya.

Setiap tempat yang memiliki if, Anda akan memiliki satu cabang yang diambil lebih sering daripada cabang lainnya. Dengan demikian lebih banyak waktu eksekusi dihabiskan untuk mengeksekusi bagian dari program, dan bukan bagian lainnya.

Setiap tempat yang memiliki perulangan yang menjalankan lebih dari sekali, Anda memiliki kode yang dieksekusi lebih dari kode di sekitarnya. Jadi lebih banyak waktu dihabiskan di sana.

Sebagai contoh, pertimbangkan:

def DoSomeWork():
    for i in range(1000000):
        DoWork(i)
    except WorkExeption:
        print("Oh No!")

Di sini print("Oh No!")hanya akan pernah berjalan maksimal satu kali, dan sering tidak pernah, sedangkan DoWork(i)akan terjadi sekitar satu juta kali.

Loop.

Saya tergoda untuk berhenti di sana! :-)

Pertimbangkan program ini

1. do_something

2. loop 10 times
3.    do_another_thing

4.    loop 5 times
5.        do_more_stuff

Jalur 1 dieksekusi sekali, sedangkan jalur 3 dieksekusi 10 kali. Melihat setiap baris secara bergantian

1 1   0.8%
2 10  8.3%
3 10  8.3%
4 50 41.3%
5 50 41.3%

Dua baris menyumbang 83% dari waktu eksekusi (dengan asumsi semua baris membutuhkan waktu yang hampir bersamaan untuk dijalankan. Jadi 40% dari program ini membutuhkan> 80%.

Dengan contoh dunia nyata yang lebih besar, ini meningkat sehingga hanya sejumlah kecil garis yang menyumbang sebagian besar waktu berjalan.

Aturan 90/10 (atau kadang-kadang menempatkan 80/20) adalah "aturan praktis" - hanya kira-kira benar.

Lihat juga Prinsip Pareto

Ketika Anda bertanya tentang waktu eksekusi saja, contoh ini mungkin bermanfaat:

int main() {
    sleep(90); // approximately 10% of the program.
    // other 90% of the program:
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    return 0;
}

Jika menjadi sedikit lebih serius, itu berarti dalam kode kehidupan nyata Anda hampir selalu memanggil fungsi berat dalam satu lingkaran (bukan sleep(90);), sedangkan sisanya 10% dari waktu Anda melakukan beberapa perhitungan single-pass.

Contoh lain adalah penanganan kesalahan di beberapa layanan HA. Setiap layanan yang sangat tersedia dirancang untuk bekerja dalam jumlah tak terbatas dalam kondisi normal. Ini beroperasi secara normal 99% dari waktu, tetapi kadang-kadang, dalam kasus kesalahan, ia menjalankan beberapa penanganan dan pemulihan kesalahan, yang mungkin bahkan lebih kompleks secara logis daripada layanan itu sendiri.

Alasan 90/10 berarti sebagian kecil dari kode Anda akan diulang atau digunakan lebih dari yang lain. Ini sering digunakan untuk menyarankan bahwa Anda harus berkonsentrasi 90% dari upaya pengembangan / optimasi Anda dalam 10% dari kode Anda.

Pikirkan prosesor teks biasa, seperti Microsoft Word atau OpenOffice :

• Dialog preferensi, tidak banyak digunakan;
• Subrutin yang menggambar karakter digunakan sepanjang waktu.

Pepatah ini juga digunakan dalam ilmu manajemen ... Ini adalah pelajaran bagi kehidupan itu sendiri ... Artinya: memusatkan sebagian besar upaya Anda di mana memberi Anda lebih banyak hasil.

Bayangkan sebuah program seperti ini:

print "H"
print "e"
print "l"
print "l"
print "o"
for i=0 to 1,000,000
    print "How long now?"
next
print "B"
print "y"
print "e"

Perhatikan bagaimana ada 11 baris di sini di mana 3 dari 11 adalah untuk loop, di mana berapa banyak waktu yang dihabiskan untuk sepotong kode yang agak kecil ini? Cukup banyak sementara 8 baris lainnya hanya mencetak satu karakter. Jadi, berhati-hatilah bahwa walaupun beberapa kode mungkin pendek, itu tidak memberi tahu Anda seberapa sering dieksekusi dan berapa lama waktu yang diperlukan.

Selain pengulangan, sebagaimana disebutkan oleh jawaban hebat lainnya, ada juga prinsip KERING yang perlu dipertimbangkan. Ditulis dengan baik, kode Berorientasi Objek memiliki banyak bagian yang dapat digunakan kembali. Bagian-bagian yang digunakan kembali, menurut definisi, digunakan setidaknya dua kali lebih sering daripada sesuatu yang hanya dijalankan sekali. Jika Anda memiliki banyak kode OO, Anda dapat berpotensi menggunakan kembali beberapa kelas dan metode berkali-kali, dan beberapa potongan kode lainnya hanya sekali.

Seperti disebutkan dalam jawaban lain, mungkin lebih baik menghabiskan upaya membuat kode yang digunakan lebih sering lebih baik daripada meningkatkan kode yang hanya digunakan satu kali.

Itu bukan aturan, itu hanya beberapa pria yang mengedit Wikipedia dengan beberapa nomor ditarik keluar dari udara dan menyebutnya aturan. Bandingkan dengan Prinsip Pareto, yang lebih mapan dalam konteks lain. Saya ingin melihat penelitian apa yang telah dilakukan (jika ada) tentang keakuratan "aturan" ini.

Tetapi pada dasarnya jawaban untuk pertanyaan Anda adalah, beberapa kode dieksekusi jauh lebih sering daripada kode lainnya. Loop sering menjadi alasan untuk ini. Alasan lain adalah panggilan yang memakan waktu, misalnya sumber daya eksternal seperti layanan web atau media penyimpanan.

Ini adalah interpretasi ulang dari "prinsip Pareto", yang menyatakan "untuk banyak peristiwa, sekitar 80% dari efek berasal dari 20% dari penyebabnya.", Juga dikenal sebagai aturan 80/20. Aturan ini sebagian besar diterapkan pada ekonomi, sehingga masuk akal bahwa itu akan dirancang ulang untuk pemrograman.

Itu hanya pola yang telah diamati selama periode waktu yang lama.

Berikut adalah video yang sangat bagus tentang pola-pola seperti ini, dan itu juga menjelaskan Prinsip Pareto.

https://www.youtube.com/watch?v=fCn8zs912OE&ab_channel=Vsauce