Python vs Julia hız karşılaştırması

Bu iki parçacığı karşılaştırmaya ve bir saniyede kaç yineleme yapılabileceğini görmeye çalıştım. Julia'nın 2,5 milyon iterasyona ulaştığı ortaya çıkıyor, Python 4 milyon. Julia'nın daha hızlı olması gerekmiyor mu? Ya da belki bu iki parçacık eşdeğer değildir?

Python:

t1 = time.time()
i = 0
while True:
    i += 1
    if time.time() - t1 >= 1:
        break

Julia:

function f()
    i = 0
    t1 = now()
    while true
        i += 1
        if now() - t1 >= Base.Dates.Millisecond(1000)
            break
        end
    end
    return i
end

Bu, garip bir performans karşılaştırmasıdır, çünkü tipik olarak, bir kişinin belirli bir sürede kaç önemsiz yineleme yapabileceğini görmek yerine, bir maddenin hesaplanması için geçen süreyi ölçer. Python ve Julia kodlarınızı çalıştırırken sorun yaşadım, bu yüzden Julia kodunu çalışacak şekilde değiştirdim ve sadece Python kodunu çalıştırmadı. @ Chepner tarafından bir yorumda belirtildiği gibi now(), DateTimenesnelerle zaman karşılaştırmaları kullanmak ve yapmak oldukça pahalıdır. Python time.time()işlevi sadece bir kayan nokta değeri döndürür. Görünüşe göre, time()aynı şeyi yapan bir Julia işlevi var :

julia> time()
1.587648091474481e9

İşte f()benim orijinal işlevi (çalışmak için değiştirildi) benim sistemindeki zamanlaması :

julia> using Dates

julia> function f()
           i = 0
           t1 = now()
           while true
               i += 1
               if now() - t1 >= Millisecond(1000)
                   break
               end
           end
           return i
       end
f (generic function with 1 method)

julia> f()
4943739

Zaman dolmadan yaklaşık 5 milyon tekrar yaptı. Dediğim gibi, Python kodunu önemli bir uğraşmadan sistemimde çalıştıramadım (ki bunu yapmayı zahmet etmedim). Ama burada bunun yerine f()kullanan bir versiyonu var, bu time()da yaratıcı bir şekilde arayacağım g():

julia> function g()
           i = 0
           t1 = time()
           while true
               i += 1
               if time() - t1 >= 1
                   break
               end
           end
           return i
       end
g (generic function with 1 method)

julia> g()
36087637

Bu sürüm 36 milyon yineleme yaptı. Yani sanýrým Julia döngüde daha hýzlý? Yaşasın! Aslında, bu döngüdeki ana çalışma çağrıları time()... Julia çok sayıda time()çağrı üretmekte daha hızlı !

Bunu zamanlamak neden garip? Dediğim gibi, buradaki gerçek çalışmaların çoğu çağırıyor time(). Döngünün geri kalanı gerçekten hiçbir şey yapmaz. Optimize edilmiş derlenmiş bir dilde, derleyici hiçbir şey yapmayan bir döngü görürse, bunu tamamen ortadan kaldıracaktır. Örneğin:

julia> function h()
           t = 0
           for i = 1:100_000_000
               t += i
           end
           return t
       end
h (generic function with 1 method)

julia> h()
5000000050000000

julia> @time h()
  0.000000 seconds
5000000050000000    

Woah, sıfır saniye! Bu nasıl mümkün olabilir? Şimdi, LLVM koduna bakalım (bir çeşit makine kodu gibi, ancak ara gösterim olarak kullanılan hayali bir makine için) bu şuna iner :

julia> @code_llvm h()

;  @ REPL[16]:1 within `h'
define i64 @julia_h_293() {
top:
;  @ REPL[16]:6 within `h'
  ret i64 5000000050000000
}

Derleyici döngüyü görür, sonucun her seferinde aynı olduğunu anlar ve döngüyü gerçekte yürütmek yerine bu sabit değeri döndürür. Tabii ki, sıfır zaman alır.

Muhtemelen time_nsJulia'da işlevi kullanmak istersiniz :

function f()
    i = 0
    t1 = time_ns()
    while true
        i += 1
        if time_ns() - t1 >= 10^9
            break
        end
    end
    return i
end

Bilgisayarımda Python'dan 10 kat daha hızlı çalışıyor.

Sistemimde gözlemlediğim şey bu değil:

Python 3.7.7

Python 3.7.7 (default, Mar 26 2020, 15:48:22) 
Type 'copyright', 'credits' or 'license' for more information
IPython 7.4.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]: import time                                                                                                                                                       

In [2]: def f(): 
   ...:     t1 = time.time() 
   ...:     i = 0 
   ...:     while True: 
   ...:         i += 1 
   ...:         if time.time() - t1 >= 1: 
   ...:             return i 
   ...:                                                                                                                                                                   

In [3]: f()                                                                                                                                                               
Out[3]: 4676268

Julia 1.4.0:

julia> using Dates

julia> function f()
           i = 0
           t1 = now()
           while true
               i += 1
               if now() - t1 >= Dates.Millisecond(1000)
                   break
               end
           end
           return i
       end
f (generic function with 1 method)

julia> f()
6339528

ancak basitçe kullanmanın time(yani düz sayıları karşılaştırma) hala daha hızlı olduğunu unutmayın:

julia> function f()
           i = 0
           t1 = time()
           while true
               i += 1
               if time() - t1 >= 1
                   break
               end
           end
           return i
       end
f (generic function with 1 method)

julia> f()
24742703