90/10 program optimizasyon kuralının anlamı nedir?

Wikipedia göre, programın optimizasyonu 90/10 kuralı (İkinci paragrafa bakın “bir program yürütme zaman% 90 kod% 10 infaz harcanmaktadır” belirtiyor burada ).

Bunu gerçekten anlamıyorum. Bu tam olarak ne anlama geliyor? Uygulama süresinin% 90'ı kodun sadece% 10'unu çalıştırarak nasıl harcanabilir? Peki ya kodun diğer% 90'ı? Zamanın sadece% 10'unda nasıl yürütülürler?

Burada oyunda iki temel ilke var:

• Bazı kodlar diğer kodlardan daha sık yürütülür. Örneğin, bazı hata işlem kodları asla kullanılamaz. Bazı kodlar yalnızca programınızı başlattığınızda yürütülecektir. Programınız çalışırken diğer kodlar tekrar tekrar çalıştırılacaktır.
• Bazı kodların çalıştırılması diğer kodlardan daha uzun sürer . Örneğin, bir veritabanında bir sorgu çalıştıran veya internetten bir dosya çeken tek bir satır muhtemelen milyonlarca matematiksel işlemden daha uzun sürecektir.

90/10 kuralı kelimenin tam anlamıyla doğru değil. Programa göre değişir (ve belirli 90 ve 10 numaralarının herhangi bir temeli olduğundan şüpheliyim; birisi muhtemelen onları ince havadan çıkardı). Fakat mesele şu ki, programınızın daha hızlı çalışması için ihtiyacınız varsa, bunun gerçekleşmesi için muhtemelen sadece az sayıda satır olması önemlidir. Yazılımınızın yavaş kısımlarını tanımlamak çoğu zaman optimizasyonun en büyük parçasıdır.

Bu önemli bir içgörüdür ve yeni bir geliştiriciye karşı sezgisel görünen kararların çoğu zaman doğru olabileceği anlamına gelir. Örneğin:

• Aptalca, basit bir şekilde işler yapıyor olsa bile, "daha iyi" hale getirmek için zaman ayırmaya değmeyeceğiniz birçok kod var . XYZ uygulaması için daha verimli bir arama algoritması yazabilir misiniz? Evet, ama aslında her değerin basit bir şekilde karşılaştırılması, binlerce değer olsa bile, önemli miktarda zaman alır. Yani buna değmez. Yeni geliştiricilerin gereksiz optimizasyonlardan kaçınmaları zor olabilir, çünkü lisans programlarında "doğru" (en verimli) algoritmasını yazmak için çok zaman harcandı. Fakat gerçek dünyada, doğru algoritma, yeterince hızlı çalışan ve çalışan herhangi bir algoritmadır.
• Kodunuzu daha uzun ve daha karmaşık hale getiren değişiklikler yine de bir performans kazanması olabilir. Örneğin, FOO uygulamasında, sadece tek bir veritabanı çağrısından kaçınmak için yüzlerce satır yeni mantık satırı eklemek faydalı olabilir.

Bu bir doğa yasası değil, geniş deneyime sahip bir kuraldır. Aynı zamanda 80/20 kuralı olarak da bilinir ve sadece kaba bir yaklaşımdır.

Döngüler, Dallar ve diğer akış kontrolü.

Eğer if olan her bir yer, diğer branştan daha sık alınan bir kolunuz olacaktır. Bu nedenle yürütme süresinin daha fazlası, programın bu bölümünü yürütmek için harcanır, diğerini değil.

Bir kereden fazla çalışan bir döngüye sahip olan her yerde, çevreleyen koddan daha fazla yürütülen kodunuz olur. Böylece orada daha fazla zaman harcanır.

Örnek olarak, şunları göz önünde bulundurun:

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

Burada print("Oh No!")irade en fazla bir kere, en fazla bir kere, çoğu zaman asla değil, ancak DoWork(i)milyonlarca kez gerçekleşecek.

Döngüler.

Orada durmak için can atıyorum! :-)

Bu programı düşünün

1. do_something

2. loop 10 times
3.    do_another_thing

4.    loop 5 times
5.        do_more_stuff

Satır 1 bir kez yürütülürken, satır 3 10 kez yürütülür. Sırasıyla her satıra bakıyor

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

İki satır yürütme süresinin% 83'ünü oluşturur (tüm satırların çalışması yaklaşık aynı zaman alırsa, programın% 40'ı>% 80 alır).

Daha büyük gerçek dünya örnekleri ile bu yükselir, bu nedenle çalışma süresinin büyük bir kısmını yalnızca az miktarda satır oluşturur.

90/10 kuralı (ya da bazen 80/20'de belirtildiği gibi) bir "temel kural" dır - sadece yaklaşık olarak doğru.

Ayrıca bakınız Pareto Prensibi

Yalnızca yürütme süresi hakkında sorduğunuzda, bu örnek yardımcı olabilir:

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;
}

Biraz daha ciddi olmak gerekirse, gerçek hayat kodunda neredeyse her zaman bir döngüde ağır bir işlev çağırdığınız anlamına gelir (bunun yerine sleep(90);), kalan zamanın% 10'unu da bazı tek geçişli hesaplamaları yaparsınız.

Başka bir örnek, bazı HA servislerinde hata işlemedir. Herhangi bir yüksek kullanılabilir servis, normal şartlar altında sonsuz bir süre çalışmak üzere tasarlanmıştır . Zamanın% 99'unda normal çalışır, ancak bazen bir hata olması durumunda, servisin kendisinden bile daha mantıklı karmaşık olabilecek bir hata işleme ve kurtarma işlemi yürütür.

90/10 akıl yürütme, kodunuzun küçük bir bölümünün diğerlerinden daha fazla tekrarlanacağı veya kullanılacağı anlamına gelir. Bu genellikle geliştirme / optimizasyon çabanızın% 90'ını kodunuzun% 10'una konsantre etmeniz gerektiğini önermek için kullanılır.

Microsoft Word veya OpenOffice gibi normal bir metin işlemcisini düşünün :

• Tercihler iletişim kutusu çok fazla kullanılmaz;
• Karakter çizen alt yordamlar her zaman kullanılır.

Bu deyiş aynı zamanda yönetim bilimlerinde de kullanılmaktadır ... Bu hayatın kendisinin bir dersidir ... Anlamı: Çabalarının çoğunu size daha fazla sonuç veren yerlere yoğunlaştırın.

Bunun gibi bir program düşünün:

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"

Burada 11 satırın 3'ünün for döngü olduğu, bu küçük kod parçası için ne kadar zaman harcandığına dikkat edin. Diğer 8 satır yalnızca tek bir karakter yazdırırken, biraz zor. Bu nedenle, bazı kodların kısa olmasına rağmen, bunun ne sıklıkta yürütüldüğünü ve ne kadar zaman alacağını söylemediğine dikkat edin.

Döngüye ek olarak, diğer büyük cevapların da belirttiği gibi, dikkate alınması gereken DRY ilkeleri de vardır. İyi yazılmış, Nesne Yönelimli kodun çok sayıda yeniden kullanılabilir kısmı vardır. Yeniden kullanılan parçalar, tanım gereği, yalnızca bir kez çalıştırılan bir şeyden en az iki kat daha fazla kullanılır. Çok fazla sayıda OO kodunuz varsa, birkaç sınıfı ve yöntemi birçok kez ve birkaç başka kod parçasını yalnızca bir kez yeniden kullanma olasılığınız olabilir.

Diğer cevaplarda da belirtildiği gibi, yalnızca bir kez kullanılan kodu iyileştirmekten daha sık kullanılan kodu daha iyi yapmak için çaba harcamak muhtemelen daha iyidir.

Bu bir kural değil, sadece Wikipedia'dan bazılarını ince havadan çekip onu kural olarak adlandırmış olan bir dostum. Diğer bağlamlarda daha sıkı bir şekilde kurulan Pareto Prensibi ile karşılaştırın. Bu "kural" ın doğruluğu konusunda (eğer varsa) hangi araştırmaların yapıldığını görmek isterim.

Ancak temelde sorunuzun cevabı, bazı kodlar diğer kodlardan çok daha sık çalıştırılıyor. Döngüler genellikle bunun nedenidir. Diğer nedenler, zaman alan aramalardır; örneğin, web servisleri veya depolama ortamları gibi harici kaynaklar.

80/20 kuralı olarak da bilinen "birçok olay için, etkilerin yaklaşık% 80'inin nedenlerinin% 20'sinden geldiğini" belirten "Pareto prensibi" nin yeniden yorumlanmasıdır. Bu kural çoğunlukla ekonomiye uygulanır, bu nedenle programlama için kullanılması amaçlanmıştı.

Sadece uzun bir süre boyunca gözlemlenen bir kalıp.

İşte böyle kalıplar hakkında çok güzel bir video ve Pareto Prensibi'ni de açıklıyor.

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