यह डेवॉक्टेड जूलिया कोड 20x से अधिक धीमा क्यों है?

Question

मैंने जूलिया में विचार किया (आर या मैटलैब के विपरीत) devectorized कोड वेक्टरकृत कोड से अक्सर तेज था। लेकिन मुझे यह मामला नहीं मिल रहा है। यहां एक उदाहरण दिया गया है:

julia> x = Float64[1:10000000]; 

julia> y = Array(Float64, length(x)); 

julia> @time for i = 1:length(x) y[i] = exp(x[i]) end; 
elapsed time: 7.014107314 seconds (959983704 bytes allocated, 25.39% gc time) 

julia> @time y = exp(x); 
elapsed time: 0.364695612 seconds (80000128 bytes allocated) 

वेक्टरकृत कोड इतना तेज़ क्यों है? ऐसा लगता है कि devectorized कोड 10x से अधिक स्मृति आवंटित कर रहा है। लेकिन केवल कुछ बाइट्स को वास्तव में किसी भी फ्लोट को फैलाने के लिए आवंटित करने की आवश्यकता है। क्या डिवेक्टरिज्ड कोड लिखने का कोई तरीका है ताकि यह इतनी मेमोरी आवंटित न करे, और इस प्रकार वेक्टरकृत कोड से तेज़ी से चलता है?

धन्यवाद!

Answer 1

पर विचार करें निम्नलिखित कोड का टुकड़ा:

x = Float64[1:10000000]; 
y = Array(Float64, length(x)); 
function nonglobal_devec!(x,y) 
    for i = 1:length(x) y[i] = exp(x[i]) end 
end 
function nonglobal_vec(x) 
    exp(x) 
end 
@time nonglobal_devec!(x,y); 
@time y = nonglobal_vec(x); 
x = Float64[1:10000000]; 
y = Array(Float64, length(x)); 
@time for i = 1:length(x) y[i] = exp(x[i]) end 
@time y = exp(x) 

जो बार

A: elapsed time: 0.072701108 seconds (115508 bytes allocated) 
B: elapsed time: 0.074584697 seconds (80201532 bytes allocated) 
C: elapsed time: 2.029597656 seconds (959990464 bytes allocated, 22.86% gc time) 
D: elapsed time: 0.058509661 seconds (80000128 bytes allocated) 

अजीब एक बाहर देता है, सी, due to it operating in the global scope है, जहां प्रकार अनुमान परिचालन नहीं करता है, और एस निचला कोड उत्पन्न होता है।

ए और बी के बीच सापेक्ष समय कुछ भिन्नता के अधीन होते हैं क्योंकि पहली बार उनके द्वारा उपयोग किए जाने वाले कार्यों को संकलित किया जाता है। हम इसे फिर से चलाने अगर हम

A2: elapsed time: 0.038542212 seconds (80 bytes allocated) 
B2: elapsed time: 0.063630172 seconds (80000128 bytes allocated) 

जो भावना ए 2 स्मृति को आबंटित नहीं है (कि 80 बाइट्स समारोह की वापसी मान के लिए है) बनाता है, और बी 2 एक नया वेक्टर बनाता है मिलता है। यह भी ध्यान रखें कि बी 2 समान मात्रा में स्मृति आवंटित करता है क्योंकि डी करता है - पहली बार अतिरिक्त संकलन के लिए आवंटित स्मृति थी।

अंत में, वेक्टरेटेड बनाम वेक्टरिज्ड केस-दर-मामले आधार है। उदाहरण के लिए, यदि आपने लूप के लिए मैट्रिक्स गुणात्मक रूप से कार्यान्वित किया है, और कोई कैश जागरूकता नहीं है, तो आप वेक्टर A*b का उपयोग करने से अधिक धीमे होने की संभावना है जो बीएलएएस का उपयोग करता है।

Answer 2

गैर लगातार वैश्विक चर धीमी गति से कर रहे हैं:

http://julia.readthedocs.org/en/latest/manual/performance-tips/