parLapplyLB वास्तव में लोड संतुलन क्यों नहीं करता है?

Question

मैं लोड करने के लिए क्या करता है यह समझने के लिए parLapplyLB() फ़ंक्शन का परीक्षण कर रहा हूं। लेकिन मुझे कोई संतुलन नहीं दिख रहा है। के लिए सोने होगा: उदाहरण के लिए,

cl <- parallel::makeCluster(2) 

system.time(
    parallel::parLapplyLB(cl, 1:4, function(y) { 
    if (y == 1) { 
     Sys.sleep(3) 
    } else { 
     Sys.sleep(0.5) 
    }})) 
## user system elapsed 
## 0.004 0.009 3.511 

parallel::stopCluster(cl) 

यदि यह सही मायने में लोड, पहली नौकरी (नौकरी 1) कि 3 सेकंड के लिए सोता संतुलन था प्रथम नोड और अन्य तीन नौकरियों (4 नौकरियों 2) पर होगा अन्य नोड पर कुल 1.5 सेकंड। कुल मिलाकर, सिस्टम का समय केवल 3 सेकंड होना चाहिए।

इसके बजाय, मुझे लगता है कि नौकरी 1 और 2 नोड 1 को दी जाती हैं और नौकरियां 3 और 4 नोड 2 को दी जाती हैं। परिणामस्वरूप कुल समय 3 + 0.5 = 3.5 सेकंड होता है। यदि हम parLapplyLB() के बजाय parLapply() के साथ एक ही कोड चलाते हैं, तो हमें लगभग 3.5 सेकंड का सिस्टम सिस्टम मिलता है।

मैं समझ नहीं रहा या गलत क्या कर रहा हूं?

Answer 1

एक (उस बात के लिए किसी भी कार्य के लिए, जिसके लिए मैंने कभी जरूरत गए समानांतर और,,) parLapplyLB आपके जैसे कार्य के लिए वास्तव में इस काम के लिए सही उपकरण नहीं है। क्यों नहीं देखने के लिए, जिस तरह से पर एक नज़र है कि यह लागू हो जाता है है:

parLapplyLB 
# function (cl = NULL, X, fun, ...) 
# { 
#  cl <- defaultCluster(cl) 
#  do.call(c, clusterApplyLB(cl, x = splitList(X, length(cl)), 
#   fun = lapply, fun, ...), quote = TRUE) 
# } 
# <bytecode: 0x000000000f20a7e8> 
# <environment: namespace:parallel> 

## Have a look at what `splitList()` does: 
parallel:::splitList(1:4, 2) 
# [[1]] 
# [1] 1 2 
# 
# [[2]] 
# [1] 3 4 

समस्या यह है कि यह पहली बार जिनमें से प्रत्येक समान आकार की उप-सूचियों कि यह तो नोड्स के बीच वितरित करता है, में नौकरियों की अपनी सूची विभाजन है अपने दिए गए उपन्यास पर lapply() चलाता है। तो यहां, आपका पहला नोड पहले और दूसरे इनपुट पर नौकरियां चलाता है, जबकि दूसरा नोड तीसरे और चौथे इनपुट का उपयोग करके नौकरियां चलाता है।

इसके बजाय, अधिक बहुमुखी clusterApplyLB() है, जो काम करता है आप आशा करता हूँ बस के रूप में उपयोग करें:

system.time(
    parallel::clusterApplyLB(cl, 1:4, function(y) { 
    if (y == 1) { 
     Sys.sleep(3) 
    } else { 
     Sys.sleep(0.5) 
    }})) 
# user system elapsed 
# 0.00 0.00 3.09 

Answer 2

parLapplyLB लोड संतुलन नहीं है क्योंकि यह एक अर्थ बग है। हमने बग पाया और एक फिक्स प्रदान किया, here देखें। अब, यह तय करने के लिए आर devs तक है।