मैटलैब: क्या एक ही मैप फ़ंक्शन को बार-बार लूप से कॉल करना बहुत अधिक ओवरहेड होता है?

Question

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

मेरा पहला विचार यह कार्य करने के लिए फ़ंक्शन को मैक्स (मैटलैब कोडर का उपयोग करके) में परिवर्तित करना था। हालांकि, सामान्य प्रोग्रामिंग भावना मुझे बताती है कि मैटलैब और मैक्स कोड के बीच इंटरफ़ेस कुछ ओवरहेड का कारण बन जाएगा, जिसका मतलब है कि इस मैक्स फ़ंक्शन को हजारों बार बुलाया जाना अच्छा विचार नहीं हो सकता है। क्या ये सही है? या मैटलैब कुछ जादू करता है जब यह वही मैक्स को ओवरहेड को हटाने के लिए बार-बार कहा जाता है?

अगर वहाँ महत्वपूर्ण ओवरहेड है, मैं इतना के रूप में कार्य ही है और तो इस बात का एक MEX बनाने के लिए लूप जोड़ने के लिए कोड के पुनर्गठन के बारे में सोच रहा हूँ। ऐसा करने से पहले, मैं इस पर खर्च किए गए समय को उचित ठहराने के लिए अपनी धारणा को मान्य करना चाहता हूं।

अद्यतन:

मैं @ angainor के सुझाव की कोशिश की, और निम्न कोड के साथ बनाया donothing.m:

function nothing = donothing(dummy) %#codegen 
nothing = dummy; 
end 

फिर, मैं एक MEX समारोह इस से donothing_mex के रूप में बनाया है, और निम्नलिखित कोड की कोशिश की :

tic; 
for i=1:1000000 
    donothing_mex(5); 
end 
toc; 

परिणाम यह था कि समारोह में दस लाख कॉल लगभग 9 सेकंड लग गए। यह हमारे उद्देश्यों के लिए एक महत्वपूर्ण ओवरहेड नहीं है, इसलिए अब मुझे लगता है कि मैं अकेले बुलाए गए फ़ंक्शन को मैक्स में बदल दूंगा। हालांकि, एक लूप से फ़ंक्शन को कॉल करना जो दस लाख बार निष्पादित करता है, यह पीछे की ओर एक सुंदर बेवकूफ विचार प्रतीत होता है, क्योंकि यह प्रदर्शन महत्वपूर्ण कोड है, इसलिए लूप को मैक्स फ़ंक्शन में ले जाना अभी भी पुस्तकों में है, लेकिन बहुत कम प्राथमिकता के साथ।

Answer 1

सामान्य रूप से, यह सब एमएक्स फ़ाइल में आपके द्वारा किए गए काम की मात्रा पर निर्भर करता है .. एमईएक्स फ़ंक्शन को कॉल करने का ओवरहेड स्थिर है और समस्या के आकार पर निर्भर नहीं है। इसका मतलब है कि तर्क नए, अस्थायी सरणी में प्रतिलिपि नहीं हैं। इसलिए, यदि यह पर्याप्त काम है, तो MEX फ़ाइल को कॉल करने के MATLAB ओवरहेड नहीं दिखाए जाएंगे। वैसे भी, मेरे अनुभव में एमएक्स कॉल ओवरहेड केवल पहली बार मैक्स फ़ंक्शन कहलाता है - गतिशील लाइब्रेरी को लोड किया जाना चाहिए, प्रतीक हल हो गए हैं। बाद में एमएक्स कॉलों में बहुत कम ओवरहेड है और यह बहुत ही कुशल हैं।

MATLAB में लगभग हर चीज इस उच्च स्तरीय भाषा की प्रकृति के कारण कुछ ओवरहेड से जुड़ा हुआ है। जब तक आपके पास कोई कोड न हो, जिसे आप निश्चित रूप से पूरी तरह से जेआईटी के साथ संकलित कर चुके हैं (लेकिन फिर आपको एक मेक्स फ़ाइल की आवश्यकता नहीं है :)) तो आपके पास एक ओवरहेड का विकल्प है ..

तो समेट - I एमएक्स कॉलिंग ओवरहेड से बहुत डर नहीं होगा।

संपादित जैसा कि अक्सर यहाँ और कहीं और सुना है, केवल उचित बात किसी विशेष मामले में क्या करने के लिए पाठ्यक्रम बेंचमार्क की है और अपने स्वयं के लिए जाँच। आप आसानी से एक छोटी सी MEX समारोह लिख कर MEX कॉल भूमि के ऊपर का अनुमान कर सकते हैं:

#include "mex.h" 
void mexFunction(int nlhs, mxArray *plhs[ ], int nrhs, const mxArray *prhs[ ]) 
{  
} 

अपने कंप्यूटर पर आप

tic; for i=1:1000000; mexFun; end; toc 
Elapsed time is 2.104849 seconds. 

मिल MEX प्रति कॉल 2 ई-6s भूमि के ऊपर है कि।अपना कोड जोड़ें, इसे समय दें और देखें, अगर ओवरहेड स्वीकार्य स्तर पर है, या नहीं।

जैसा कि एंड्रयू जंक ने नीचे उल्लेख किया है (धन्यवाद!), एमएक्स फ़ंक्शन ओवरहेड जाहिर है कि आप एमएक्स फ़ंक्शन में भेजे गए तर्कों की संख्या पर निर्भर करते हैं। यह एक छोटा सा निर्भरता है, लेकिन यह नहीं है:

a = ones(1000,1); 
tic; for i=1:1000000; mexFun(a); end; toc 
Elapsed time is 2.41 seconds. 

यह a के आकार से संबंधित नहीं है:

a = ones(1000000,1); 
tic; for i=1:1000000; mexFun(a); end; toc 
Elapsed time is 2.41805 seconds. 

लेकिन यह तर्क की संख्या से संबंधित है

a = ones(1000000,1); 
b = ones(1000000,1); 
tic; for i=1:1000000; mexFun(a, b); end; toc 
Elapsed time is 2.690237 seconds. 

तो आप इसे अपने परीक्षणों में ध्यान में रखना चाहेंगे।

Answer 2

आपको बिना किसी हिचकिचाहट के मैक्स फ़ाइल के अंदर लूप को स्थानांतरित करना चाहिए। नीचे दिया गया उदाहरण लूप में वर्चुअल रिक्त कार्य इकाई के लिए 1000 गुना गति का प्रदर्शन करता है। स्पष्ट रूप से लूप के लिए काम की मात्रा में परिवर्तन के रूप में यह गति कम हो जाएगी।

मेक्स समारोह आंतरिक पाश के बिना:

#include "mex.h" 
void mexFunction(int nlhs, mxArray *plhs[ ], int nrhs, const mxArray *prhs[ ]) 
{  
    int i=1;  
    plhs[0] = mxCreateDoubleScalar(i); 
} 

मैटलैब में कहा जाता है:

tic;for i=1:1000000;donothing();end;toc 
Elapsed time is 3.683634 seconds. 

आंतरिक पाश के साथ

मेक्स समारोह:

#include "mex.h" 
void mexFunction(int nlhs, mxArray *plhs[ ], int nrhs, const mxArray *prhs[ ]) 
{  
    int M = mxGetScalar(prhs[0]); 
    plhs[0] = mxCreateNumericMatrix(M, 1, mxDOUBLE_CLASS, mxREAL); 
    double* mymat = mxGetPr(plhs[0]); 
    for (int i=0; i< M; i++) 
     mymat[i] = M-i; 
} 

यहाँ अंतर का एक उदाहरण है

मैटलैब में कहा जाता है:

tic; a = donothing(1000000); toc 
Elapsed time is 0.003350 seconds. 

Answer 3

खैर, यह मैं Matlab में यह कर सकते हैं सबसे तेज है:

%#eml 
function L = test(s,t) 

    m = numel(s); 
    n = numel(t); 

    % trivial cases 
    if m==0 && n==0 
     L = 0; return; end 
    if n==0 
     L = m; return; end 
    if m==0 
     L = n; return; end 

    % non-trivial cases 
    M = zeros(m+1,n+1);  
    M(:,1) = 0:m; 

    for j = 2:n+1 
     for i = 2:m+1 
      M(i,j) = min([ 
       M(i-1,j) + 1 
       M(i,j-1) + 1 
       M(i-1,j-1) + (s(i-1)~=t(j-1)); 
       ]); 
     end 
    end 

    L = min(M(end,:)); 

end 

आप इस संकलन और कुछ परीक्षण चला सकते हैं? (कुछ अजीब कारणों से, संकलन मेरी स्थापना पर काम करने में विफल रहता है ...) शायद %#eml से %#codegen को पहले बदलें, अगर आपको लगता है कि यह आसान है।

नोट: सी संस्करण के लिए, आपको फॉर-लूप का भी आदान-प्रदान करना चाहिए, ताकि j पर लूप आंतरिक हो।

इसके अलावा, row1 और row2 दृष्टिकोण बहुत अधिक मेमोरी कुशल है। यदि आप वैसे भी संकलन करने जा रहे हैं, तो मैं उस दृष्टिकोण का उपयोग करूंगा।