foreach

Question

के साथ वस्तुओं को डुप्लिकेट मैं एक बहुत ही विशाल स्ट्रिंग वेक्टर है और एक समानांतर कंप्यूटिंग foreach और dosnow पैकेज का उपयोग करना चाहते हैं से बचने के लिए कैसे। मैंने देखा कि foreach प्रत्येक प्रक्रिया के लिए वेक्टर की प्रतियां बनायेगा, इस प्रकार सिस्टम मेमोरी को जल्दी से निकालें। मैंने सूची वस्तु में वेक्टर को छोटे टुकड़ों में तोड़ने की कोशिश की, लेकिन अभी भी कोई स्मृति उपयोग में कमी नहीं दिख रही है। क्या किसी के पास इस पर विचार है? उपयोग किए जा रहे आम तौर पर क्योंकि श्रमिकों को प्रभावी ढंग से fork के जादू से tt साझा कर सकते हैं doMC बैकएंड के साथ अच्छी तरह से काम करता है बार-बार दोहराना की

library(foreach) 
library(doSNOW) 
library(snow) 

x<-rep('some string', 200000000) 
# split x into smaller pieces in a list object 
splits<-getsplits(x, mode='bysize', size=1000000) 
tt<-vector('list', length(splits$start)) 
for (i in 1:length(tt)) tt[[i]]<-x[splits$start[i]: splits$end[i]] 

ret<-foreach(i = 1:length(splits$start), .export=c('somefun'), .combine=c) %dopar% somefun(tt[[i]]) 

Answer 1

शैली: नीचे कुछ डेमो कोड हैं। लेकिन doSNOW के साथ, tt श्रमिकों को स्वत: निर्यात किया जाएगा, बहुत सारी मेमोरी का उपयोग करके, भले ही उन्हें केवल इसके एक अंश की आवश्यकता हो। @Beasterfield द्वारा सीधे tt पर फिर से शुरू करने के सुझाव को हल किया गया है, लेकिन यह इटरेटर्स के उपयोग और उचित समांतर बैकएंड के माध्यम से और अधिक मेमोरी कुशल होना संभव है।

इस तरह के मामलों में, मैं itertools पैकेज से isplitVector फ़ंक्शन का उपयोग करता हूं। यह एक वेक्टर को उप-वैक्टरों के अनुक्रम में विभाजित करता है, जिससे उन्हें वेक्टरेशन के लाभों को खोए बिना समानांतर में संसाधित किया जा सकता है। दुर्भाग्यवश, doSNOW के साथ, यह clusterApplyLB फ़ंक्शन snow पर clusterApplyLB पर इटरेटर्स का समर्थन नहीं करता है, तो यह इन उप-वैक्टरों को एक सूची में रखेगा। हालांकि, doMPI और doRedis बैकएंड ऐसा नहीं करेंगे। वे उप-वैक्टरों को श्रमिकों को सीधे आधे से ज्यादा स्मृति का उपयोग करके, श्रमिकों को भेज देंगे।

यहां एक संपूर्ण उदाहरण doMPI का उपयोग कर रहा है:

suppressMessages(library(doMPI)) 
library(itertools) 
cl <- startMPIcluster() 
registerDoMPI(cl) 
n <- 20000000 
chunkSize <- 1000000 
x <- rep('some string', n) 
somefun <- function(s) toupper(s) 
ret <- foreach(s=isplitVector(x, chunkSize=chunkSize), .combine='c') %dopar% { 
    somefun(s) 
} 
print(length(ret)) 
closeCluster(cl) 
mpi.quit() 

जब मैं अपने मैकबुक पर इस चलाने के प्रो स्मृति

$ time mpirun -n 5 R --slave -f split.R 

इसके बारे में 16 सेकंड लेता है 4 GB के साथ।

आप, श्रमिकों है कि आप एक ही मशीन पर बनाने की संख्या के साथ सावधान रहना होगा हालांकि chunkSize का मूल्य कम हो रही आप और अधिक शुरू करने के लिए अनुमति दे सकता है है।

यदि आप एक इटरेटर का उपयोग करने में सक्षम हैं, तो आप अपने मेमोरी उपयोग को और भी कम कर सकते हैं, जिसमें सभी तारों को एक ही समय में स्मृति में होने की आवश्यकता नहीं होती है। उदाहरण के लिए, यदि तार 'strings.txt' नाम की फ़ाइल में हैं, तो आप s=ireadLines('strings.txt', n=chunkSize) का उपयोग कर सकते हैं।