नेट फ़ंक्शन कॉलिंग का प्रदर्शन (सी # एफ #) वीएस सी ++

Question

चूंकि एफ # 2.0 वीएस -2010 का हिस्सा बन गया है, इसलिए मैं एफ # में रूचि लेता हूं। मुझे आश्चर्य हुआ कि इसका उपयोग करने का क्या मतलब है। मैं थोड़ा सा पढ़ूंगा और मैंने फ़ंक्शन कॉलिंग को मापने के लिए एक बेंचमार्क बनाया था। मैं एकरमैन के समारोह :)

सी #

sealed class Program 
{ 
    public static int ackermann(int m, int n) 
    { 
     if (m == 0) 
      return n + 1; 
     if (m > 0 && n == 0) 
     { 
      return ackermann(m - 1, 1); 
     } 
     if (m > 0 && n > 0) 
     { 
      return ackermann(m - 1, ackermann(m, n - 1)); 
     } 
     return 0; 
    } 

    static void Main(string[] args) 
    { 

     Stopwatch stopWatch = new Stopwatch(); 

     stopWatch.Start(); 
     Console.WriteLine("C# ackermann(3,10) = " + Program.ackermann(3, 10)); 
     stopWatch.Stop(); 

     Console.WriteLine("Time required for execution: " + stopWatch.ElapsedMilliseconds + "ms"); 
     Console.ReadLine(); 
    } 
} 

सी ++

class Program{ 
public: 
static inline int ackermann(int m, int n) 
{ 
    if(m == 0) 
     return n + 1; 
    if (m > 0 && n == 0) 
    { 
     return ackermann(m - 1, 1); 
    } 
    if (m > 0 && n > 0) 
    { 
     return ackermann(m - 1, ackermann(m, n - 1)); 
    } 
    return 0; 
} 
}; 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
clock_t start, end; 

    start = clock(); 
std::cout << "CPP: ackermann(3,10) = " << Program::ackermann(3, 10) << std::endl; 
end = clock(); 
std::cout << "Time required for execution: " << (end-start) << " ms." << "\n\n"; 
int i; 
std::cin >> i; 
return 0; 
} 

एफ #

// Ackermann 
let rec ackermann m n = 
    if m = 0 then n + 1 
    elif m > 0 && n = 0 then ackermann (m - 1) 1 
    elif m > 0 && n > 0 then ackermann (m - 1) (ackermann m (n - 1)) 
    else 0 

open System.Diagnostics; 
let stopWatch = Stopwatch.StartNew() 
let x = ackermann 3 10 
stopWatch.Stop(); 

printfn "F# ackermann(3,10) = %d" x 
printfn "Time required for execution: %f" stopWatch.Elapsed.TotalMilliseconds 

जावा

public class Main 
{ 
public static int ackermann(int m, int n) 
{ 
if (m==0) 
    return n + 1; 
if (m>0 && n==0) 
{ 
return ackermann(m - 1,1); 
} 
if (m>0 && n>0) 
{ 
    return ackermann(m - 1,ackermann(m,n - 1)); 
} 
return 0; 
} 

    public static void main(String[] args) 
    { 
    System.out.println(Main.ackermann(3,10)); 
    } 
} 

का इस्तेमाल किया है 363,210

एक तो
सी # = 510ms
C++ = 130ms
एफ # = 185ms
जावा = Stackoverflow :)

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

अद्यतन। मैंने कंसोल से छुटकारा पा लिया। राइटलाइन और डीबगर के बिना सी # कोड चलाएं: सी # = 400 एमएमएस

Answer 1

मेरा मानना ​​है कि इस मामले में, सी # और एफ # के बीच का अंतर पूंछ-कॉल अनुकूलन के लिए धन्यवाद है।

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

ackermann के अपने कार्यान्वयन में, कॉल की दो पूंछ कॉल कर रहे हैं और उनमें से केवल एक नहीं है (एक जहाँ परिणाम एक और ackermann कॉल करने के लिए एक तर्क के रूप पारित हो जाता है)। इसका मतलब है कि एफ # संस्करण वास्तव में कम से कम एक "कॉल" निर्देश (ज्यादा?) का आह्वान करता है।

सामान्य रूप से, प्रदर्शन प्रोफ़ाइल लगभग सी # के प्रदर्शन प्रोफ़ाइल के समान ही है। काफी कुछ बनाम सी # प्रदर्शन यहां एफ # से संबंधित पोस्ट नहीं हैं:

• Is F# really better than C# for math?

Answer 2

एफ # के लिए आप इनलाइन कीवर्ड की कोशिश कर सकते हैं।

इसके अलावा, जैसा कि पिछले पोस्टर का उल्लेख है, सी # और एफ # संस्करण कंसोल के कारण भिन्न हैं। राइटलाइन स्टेटमेंट्स।

Answer 3

यह फ़ंक्शन कॉल को कम करने के लिए एक आम तरीका है क्योंकि यह फ़ंक्शन कॉलिंग से संबंधित है।

आप इस प्रकार के रिकर्सिव फ़ंक्शन को स्मोइज़ेशन (कैशिंग) के माध्यम से तेज़ी से चला सकते हैं। आप इसे सी # (example) में भी कर सकते हैं।) मुझे 18ms मिल गया।

open System.Collections.Generic 

let memoize2 f = 
    let cache = Dictionary<_, _>() 
    fun x y -> 
     if cache.ContainsKey (x, y) then 
      cache.[(x, y)] 
     else 
      let res = f x y 
      cache.[(x, y)] <- res 
      res 

// Ackermann 
let rec ackermann = 
    memoize2 (fun m n -> 
     if m = 0 then n + 1 
     elif m > 0 && n = 0 then ackermann (m - 1) 1 
     elif m > 0 && n > 0 then ackermann (m - 1) (ackermann m (n - 1)) 
     else 0 
    ) 

Answer 4

सीधे प्रश्न से संबंधित नहीं है, लेकिन पर्याप्त दिलचस्प उल्लेख करने के लिए: मेरे पीसी पर इस संस्करण

let rec ackermann2 m n = 
    match m,n with 
    | 0,0 -> 0 
    | 0,n -> n+1 
    | m,0 -> ackermann2 (m-1) 1 
    | m,n -> ackermann2 (m-1) (ackermann2 m (n-1)) 

कोशिश (VS2010, एफ # इंटरैक्टिव) यह लगभग 50% अपने संस्करण की तुलना में तेजी जब परिकलन करते हैं एकरमैन 3 12.

मैं काफी क्यों इस तरह के एक प्रदर्शन अंतर है व्याख्या नहीं कर सकते। मुझे लगता है कि एफ # कंपाइलर के साथ कुछ विवरण है जो मिलान अभिव्यक्ति का अनुवाद अगर कथन की श्रृंखला के बजाय एक स्विच स्टेटमेंट में कर रहा है। पहले (एम = 0, एन = 0) परीक्षण डालने से भी मदद मिल सकती है।