पायथन बनाम जूलिया गति की तुलना

Question

मैंने इन दो स्निपेट की तुलना करने की कोशिश की और देखा कि एक सेकंड में कितने पुनरावृत्तियों को किया जा सकता है। पता चलता है कि जूलिया 2.5 मिलियन पुनरावृत्तियों को प्राप्त करता है जबकि पायथन 4 मिलियन। क्या जूलिया जल्दी नहीं माना जाता है। या हो सकता है कि ये दोनों स्निपेट्स बराबर न हों?

अजगर:

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

जूलिया:

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

Comments

मुझे यकीन नहीं है कि जूलिया कैसे काम करती है, लेकिन ऐसा लगता है कि आपको हर तुलना के लिए एक नई वस्तु का निर्माण करना होगा, जबकि पायथन सरल पूर्णांक तुलना कर रहा है।

— चेपनर

कृपया यह भी ध्यान दें कि यह किसी प्रकार की खराब आदमी की गति की तुलना है, है ना? आजकल आप प्रेरणा की उचित मात्रा (दोनों सिरों पर) के साथ पाइथन और जूलिया को समान गति से चला सकते हैं। यदि आप दोनों भाषाओं में से किसी एक को लेने के लिए ऐसा कर रहे हैं, तो देखिए कि आपके लिए किसके साथ सोचना आसान है। आप बाद में इसका अनुकूलन कर सकते हैं, जब आपको वास्तव में इसकी आवश्यकता होती है।

— नोरोक 2

@ norok2 यह कुछ कोडों के लिए सही है लेकिन दूसरों के लिए नहीं। यदि आप एक तेज भाषा में लिखे गए लाइब्रेरी फंक्शन में अजगर कोड को कॉल में बदलने में सक्षम हैं, या यदि यह सुंबा द्वारा समर्थित है, या ऐसा ही कुछ है, तो हो सकता है, लेकिन अन्यथा पायथन काफी धीमा है।

— डीएनएफ

@DNF कुछ चीजें हैं जहां पायथन तेज है और कुछ अन्य जहां जूलिया तेज है। मुझे यकीन है कि आप दोनों के उदाहरण पा सकते हैं। यह कहना कि पाइथन "काफी" है (जो भी इसका मतलब हो सकता है) केवल अपेक्षाकृत महंगी स्पष्ट लूपिंग और फ़ंक्शन कॉल के कारण धीमी है। यकीन है, अगर वह तुम्हारा काम-घोड़ा है तो शायद आप जूलिया से बेहतर हैं। हालांकि, यदि आप सही साधनों का उपयोग करते हैं, तो आप पायथन में समान रूप से तेज़ हो सकते हैं। क्या यह इन साधनों को सीखने के लायक है या अलग भाषा सीखना बेहतर है। यह कहना कठिन है।

— नोरोक 2

मैं दोनों भाषाओं का उपयोग करता हूं, और जबकि दोनों के 'कुछ' उदाहरण तेजी से हो रहे हैं, संतुलन एक तरफ काफी है। यह केवल पायथन की व्याख्या का परिणाम है और शायद ही प्रदर्शन पर ध्यान केंद्रित कर रहा है, जबकि जूलिया के प्रदर्शन पर एक मजबूत ध्यान केंद्रित है। यह वास्तव में बहुत कुछ कह रहा है कि पायथन सी के रूप में उपवास है। यह बहुत ही अजीब होगा यदि कोई महत्वपूर्ण अंतर नहीं था , और यह जूलिया के उद्देश्य को बहुत कम कर देगा।

— DNF

Answer 1

यह तुलनात्मक रूप से एक प्रकार का अजीब प्रदर्शन है क्योंकि आमतौर पर किसी पदार्थ की किसी चीज़ की गणना करने में लगने वाले समय को मापने के बजाय, यह देखने के बजाय कि एक निश्चित समय में कितने तुच्छ पुनरावृत्तियों को किया जा सकता है। मुझे आपके पायथन और जूलिया कोड को काम करने में परेशानी हो रही थी, इसलिए मैंने जूलिया कोड को काम करने के लिए संशोधित किया और सिर्फ पायथन कोड नहीं चलाया। जैसा कि @chepner ने एक टिप्पणी में कहा है, वस्तुओं के now()साथ समय की तुलना करना और करना DateTimeकाफी महंगा है। पायथन time.time()फ़ंक्शन केवल एक फ़्लोटिंग-पॉइंट मान लौटाता है। जैसा कि यह पता चला है, एक जूलिया फंक्शन है जिसे time()वही काम करता है:

julia> time()
1.587648091474481e9

यहां f()मेरे सिस्टम पर आपके मूल कार्य (काम करने के लिए संशोधित) का समय है:

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

इसने समय से पहले लगभग 5 मिलियन पुनरावृत्तियों को किया। जैसा कि मैंने कहा, मैं आपके सिस्टम पर महत्वपूर्ण फ़िडलिंग के बिना चलने के लिए आपका पायथन कोड प्राप्त करने में सक्षम नहीं था (जो कि मुझे परेशान नहीं करता था)। लेकिन यहाँ इसके बजाय इसके f()उपयोग का एक संस्करण है time(), जिसे मैं कल्पनाशील रूप से कॉल करूंगा 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

इस संस्करण ने 36 मिलियन पुनरावृत्तियों को किया। तो मुझे लगता है कि जूलिया लूपिंग में तेज है? वाह! खैर, वास्तव में इस लूप में मुख्य काम कॉल करने के लिए time()है ... जूलिया बहुत सारे time()कॉल उत्पन्न करने में तेज है !

यह समय क्यों अजीब है? जैसा कि मैंने कहा, यहां अधिकांश वास्तविक कार्य कॉलिंग हैं time()। बाकी लूप वास्तव में कुछ भी नहीं करता है। एक अनुकूलन संकलित भाषा में, यदि कंपाइलर एक लूप देखता है जो कुछ भी नहीं करता है, तो यह इसे पूरी तरह से खत्म कर देगा। उदाहरण के लिए:

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    

वाह, शून्य सेकंड! वो कैसे संभव है? ठीक है, चलो LLVM कोड (मशीन कोड की तरह लेकिन एक काल्पनिक मशीन के लिए उपयोग किया जाता है जो एक मध्यवर्ती प्रतिनिधित्व के रूप में देखें) में यह निम्न है:

julia> @code_llvm h()

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

संकलक लूप को देखता है, यह पता लगाता है कि परिणाम हर बार समान होता है, और वास्तव में लूप को निष्पादित करने के बजाय केवल निरंतर मान देता है। जो निश्चित रूप से, शून्य समय लेता है।

Comments

यह BogoMips प्रोग्रामिंग भाषाओं की

— norok2

CPU को मापने के लिए सही, लेकिन bogomips का उपयोग किया जाता है, प्रोग्रामिंग भाषा का नहीं। लेकिन यकीन है, यह एक ऐसी चीज है जिसे कोई भी माप सकता है।

— स्टेफनकर्पिंस्की

Answer 2

आप शायद time_nsजूलिया में समारोह का उपयोग करना चाहते हैं :

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

मेरे कंप्यूटर पर यह पायथन की तुलना में 10 गुना तेज है।

Answer 3

खैर, यह वह नहीं है जो मैं अपने सिस्टम पर देखता हूं:

अजगर 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

जूलिया 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

लेकिन ध्यान दें कि बस का उपयोग time(यानी सादे संख्या की तुलना) अभी भी तेज है:

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

Comments

क्या आपको time.perf_counter_ns()पायथन में उपयोग नहीं करना चाहिए ?

— नोरोक 2

इस बेंचमार्क के लिए time.perf_counter_ns कुछ भी (कम से कम मेरे सिस्टम पर) नहीं बदलता है। मुझे लगता है कि, जब 1 सेकंड के क्रम में समय के अंतर को मापते हैं, तो समय की माप की सटीकता ज्यादा मायने नहीं रखती है। केवल माप लेने और परिणामी वस्तुओं के मामलों की तुलना करने के लिए यहां समय लगता है (साथ ही साथ स्वयं की दक्षता)।

— फ़्राँस्वा फ़ेवोटे

जूलिया में माप समय मायने रखता है - यही कारण है कि मेरे कोड में मैंने इसका इस्तेमाल time_nsनहीं timeकिया, यह तब ~ 30% तेज है।

— बोगुमील कामीस्की