foreach()%% कभी-कभी धीमा क्यों होता है?

Question

मैं पहली बार आर में समांतरता के साथ खेल रहा हूं। पहली बार एक खिलौना उदाहरण के रूप में, मैंने कोशिश की

library(doMC) 
registerDoMC() 

B<-10000 

myFunc<-function() 
{ 
    for(i in 1:B) sqrt(i) 
} 

myFunc2<-function() 
{ 
    foreach(i = 1:B) %do% sqrt(i) 
} 

myParFunc<-function() 
{ 
    foreach(i = 1:B) %dopar% sqrt(i) 
} 

मुझे पता है कि sqrt() parallellization बात करने के लिए बहुत तेजी से निष्पादित करता है, लेकिन मैं क्या उम्मीद नहीं थी था कि foreach() %do% होगा for() की तुलना में धीमी:

> system.time(myFunc()) 
    user system elapsed 
    0.004 0.000 0.005 
> system.time(myFunc2()) 
    user system elapsed 
    6.756 0.000 6.759 
> system.time(myParFunc()) 
    user system elapsed 
    6.140 0.524 6.096 

मैंने देखा है कि अधिकांश उदाहरणों में, foreach() %dopar% की तुलना में for() की तुलना में किया गया है। चूंकि foreach() %do% मेरे खिलौने उदाहरण में for() से बहुत धीमी थी, अब मैं थोड़ा उलझन में हूं। किसी भी तरह, मैंने सोचा कि ये फॉर-लूप बनाने के बराबर तरीके थे। अंतर क्या है? क्या वे कभी समकक्ष हैं? foreach() %do% हमेशा धीमा है?

अद्यतन: निम्नलिखित @Peter जुर्माना का जवाब, मैं अद्यतन myFunc इस प्रकार है:

a<-rep(NA,B) 
myFunc<-function() 
{ 
    for(i in 1:B) a[i]<-sqrt(i) 
} 

यह बनाता है for() थोड़ा धीमा है, लेकिन बहुत ज्यादा नहीं:

> system.time(myFunc()) 
    user system elapsed 
    0.036 0.000 0.035 
> system.time(myFunc2()) 
    user system elapsed 
    6.380 0.000 6.385 

Answer 1

forsqrt बी बार चलाया जाएगा, संभावित रूप से हर बार जवाब को छोड़ दें। foreach, हालांकि, लूप बॉडी के प्रत्येक निष्पादन के परिणाम वाली एक सूची देता है। यह काफी अतिरिक्त ओवरहेड का योगदान करेगा, भले ही यह समानांतर या अनुक्रमिक मोड (%dopar% या %do%) में चल रहा हो।

मैं निम्नलिखित कोड चलाकर अपना उत्तर आधारित करता हूं, जो foreach vignette द्वारा पुष्टि की जाती है, जिसमें कहा गया है कि "फोरच एक लूप से अलग है जिसमें इसकी वापसी मूल्यों की एक सूची है, जबकि लूप के लिए कोई मूल्य नहीं है और इसका परिणाम व्यक्त करने के लिए साइड इफेक्ट्स का उपयोग करता है। "

> print(for(i in 1:10) sqrt(i)) 
NULL 

> print(foreach(i = 1:10) %do% sqrt(i)) 
[[1]] 
[1] 1 

[[2]] 
[1] 1.414214 

[[3]] 
... etc 

अद्यतन: मैं अपने अद्यतन प्रश्न है जो उपरोक्त जवाब लगभग प्रदर्शन को ध्यान में पर्याप्त नहीं है से देखते हैं। तो मैंने source code को foreach पर देखा और देख सकते हैं कि बहुत कुछ चल रहा है! मैं समझने के लिए यह वास्तव में कैसे, काम करता है लेकिन do.R प्रयास नहीं किया है और foreach.R है कि जब भी %do% चलाया जाता है, foreach विन्यास के बड़े हिस्से अभी भी चलाया जाता है जो भावना है, तो शायद %do% विकल्प काफी हद तक की अनुमति दी जाती है होगा दिखाने परीक्षण foreach कोड समानांतर बैकएंड कॉन्फ़िगर और लोड किए बिना कोड। इसे foreach प्रदान करता है कि अधिक उन्नत घोंसले और पुनरावृत्ति सुविधाओं का समर्थन करने की भी आवश्यकता है।

प्रत्येक पुनरावृत्ति के तर्कों के लिए कैशिंग, त्रुटि जांच, डिबगिंग और स्थानीय पर्यावरण चर के निर्माण के लिए कोड में संदर्भ हैं (उदाहरण के लिए do.R में फ़ंक्शन doSEQ देखें)। मुझे लगता है कि यह वही है जो आपने देखा है। बेशक, यदि आप अपने लूप के अंदर अधिक जटिल कोड चला रहे थे (जो वास्तव में foreach जैसे समांतरता फ्रेमवर्क से लाभान्वित होगा), यह ओवरहेड इसके द्वारा प्रदान किए जाने वाले लाभों की तुलना में अप्रासंगिक हो जाएगा।