सी # (काफी धीमी) और Win32/C के बीच प्रदर्शन अंतर क्यों?

Question

हम एक प्रदर्शन महत्वपूर्ण अनुप्रयोग को .NET पर माइग्रेट करना चाहते हैं और यह पता लगाएं कि सी # संस्करण प्रोसेसर के आधार पर Win32/C की तुलना में 30% से 100% धीमा है (मोबाइल T7200 प्रोसेसर पर अधिक अंतर)। मेरे पास कोड का एक बहुत ही सरल नमूना है जो इसे प्रदर्शित करता है। संक्षिप्तता के लिए मैं सिर्फ सी संस्करण दिखाऊंगा - सी # एक सीधा अनुवाद है:

#include "stdafx.h" 
#include "Windows.h" 

int array1[100000]; 
int array2[100000]; 

int Test(); 

int main(int argc, char* argv[]) 
{ 
    int res = Test(); 

    return 0; 
} 

int Test() 
{ 
    int calc,i,k; 
    calc = 0; 

    for (i = 0; i < 50000; i++) array1[i] = i + 2; 

    for (i = 0; i < 50000; i++) array2[i] = 2 * i - 2; 

    for (i = 0; i < 50000; i++) 
    { 
     for (k = 0; k < 50000; k++) 
     { 
      if (array1[i] == array2[k]) calc = calc - array2[i] + array1[k]; 
      else calc = calc + array1[i] - array2[k]; 
     } 
    } 
    return calc; 
} 

अगर हम के लिए Win32 में disassembly को देखो 'शेष' हमने:

35:    else calc = calc + array1[i] - array2[k]; 
004011A0 jmp   Test+0FCh (004011bc) 
004011A2 mov   eax,dword ptr [ebp-8] 
004011A5 mov   ecx,dword ptr [ebp-4] 
004011A8 add   ecx,dword ptr [eax*4+48DA70h] 
004011AF mov   edx,dword ptr [ebp-0Ch] 
004011B2 sub   ecx,dword ptr [edx*4+42BFF0h] 
004011B9 mov   dword ptr [ebp-4],ecx 

(यह है डिबग लेकिन मेरे साथ सहन) में

अनुकूलित C# अनुकूलित exe पर CLR डीबगर का उपयोग कर संस्करण के लिए disassembly:

    else calc = calc + pev_tmp[i] - gat_tmp[k]; 
000000a7 mov   eax,dword ptr [ebp-4] 
000000aa mov   edx,dword ptr [ebp-8] 
000000ad mov   ecx,dword ptr [ebp-10h] 
000000b0 mov   ecx,dword ptr [ecx] 
000000b2 cmp   edx,dword ptr [ecx+4] 
000000b5 jb   000000BC 
000000b7 call  792BC16C 
000000bc add   eax,dword ptr [ecx+edx*4+8] 
000000c0 mov   edx,dword ptr [ebp-0Ch] 
000000c3 mov   ecx,dword ptr [ebp-14h] 
000000c6 mov   ecx,dword ptr [ecx] 
000000c8 cmp   edx,dword ptr [ecx+4] 
000000cb jb   000000D2 
000000cd call  792BC16C 
000000d2 sub   eax,dword ptr [ecx+edx*4+8] 
000000d6 mov   dword ptr [ebp-4],eax 

संभवतः प्रदर्शन अंतर का कारण कई और निर्देश।

तो 3 प्रश्न वास्तव में:

1. 2 कार्यक्रमों के लिए सही disassembly तलाश में हूं या उपकरण मुझे गुमराह कर रहे हैं?

2. तो उत्पन्न निर्देश की संख्या में अंतर क्या अंतर है का कारण नहीं है?

3. क्या हम संभवतः इसके बारे में क्या कर सकते हैं अन्य की तुलना में एक देशी DLL में हमारे सभी प्रदर्शन महत्वपूर्ण कोड रहते हैं।

अग्रिम धन्यवाद स्टीव

पुनश्च मैं एक तरह बिल्डिंग प्रदर्शन महत्वपूर्ण देशी अनुप्रयोगों 'हम्म एक संयुक्त एमएस/इंटेल संगोष्ठी हकदार कुछ करने के लिए हाल ही में आमंत्रण प्राप्त था ...

Answer 1

मेरा मानना ​​है कि आप सरणी पर सीमाओं के चेक के परिणाम देख रहे हैं। आप असुरक्षित कोड का उपयोग कर सीमाओं से बच सकते हैं।

मेरा मानना ​​है कि JITer छोरों कि array.Length और से बचने के सीमा की जाँच करने के लिए ऊपर जाना जैसे प्रतिमानों की पहचान कर सकते हैं, लेकिन यह नहीं लगता है अपने कोड की तरह है कि utilizate कर सकते हैं।

Answer 2

मुझे यकीन है कि सी के लिए अनुकूलन सी # से अलग है। इसके अलावा आपको कम से कम प्रदर्शन की धीमी गति से उम्मीद करनी होगी। .NET ढांचे के साथ एप्लिकेशन में एक और परत जोड़ता है।

व्यापार बंद एक तेज मात्रा में गति (क्या होना चाहिए) के लिए अधिक तेज़ विकास, विशाल पुस्तकालय और कार्य है।

Answer 3

सी # सीमा

जाँच जब सी # असुरक्षित कोड में गणना हिस्सा यह प्रदर्शन करता है और साथ ही देशी कार्यान्वयन चल कर रहा है?

Answer 4

मेरा मानना ​​है कि इस कोड में आपका मुख्य मुद्दा आपके सरणी पर जांच कर रहा है।

आप सी # में असुरक्षित कोड का उपयोग करने के लिए स्विच, और सूचक गणित का उपयोग करते हैं, आप एक ही (या संभावित तेज) कोड प्राप्त करने के लिए सक्षम होना चाहिए।

यह वही समस्या previously discussed in detail in this question थी।

Answer 5

जैसा कि अन्य ने कहा है, पहलुओं में से एक जांच की सीमा है। सरणी पहुंच के संदर्भ में आपके कोड में कुछ अनावश्यकता भी है। मैं करने के लिए भीतरी ब्लॉक बदलकर कुछ हद तक प्रदर्शन में सुधार करने में कामयाब रहे है: परिवर्तन ~ 8.8s को ~ 5s से नीचे गिरा दिया

int tmp1 = array1[i]; 
int tmp2 = array2[k]; 
if (tmp1 == tmp2) 
{ 
    calc = calc - array2[i] + array1[k]; 
} 
else 
{ 
    calc = calc + tmp1 - tmp2; 
} 

कि कुल समय।

Answer 6

यदि आपके एप्लिकेशन के प्रदर्शन महत्वपूर्ण पथ में पूरी तरह से अनचेक सरणी प्रसंस्करण शामिल है, तो मैं आपको सलाह देता हूं कि इसे सी # में फिर से लिखना न पड़े।

लेकिन फिर भी, अगर आपके आवेदन पहले से ही भाषा एक्स में ठीक काम करता है, मैं तुम्हें भाषा वाई

क्या आप फिर से लिखने से हासिल करना चाहते हैं में यह फिर से लिखने के लिए नहीं की सलाह देंगे? कम से कम, उच्च प्रदर्शन अनुभागों के लिए अपने पहले से डीबग किए गए सी कोड का उपयोग करके और एक अच्छा यूजर इंटरफेस या नवीनतम समृद्ध .NET पुस्तकालयों के साथ सुविधाजनक एकीकरण प्राप्त करने के लिए सी # का उपयोग करके मिश्रित भाषा समाधान पर गंभीर विचार दें।

A longer answer on a possibly related theme.

Answer 7

बस मस्ती के लिए, मैं दृश्य स्टूडियो 2010 में सी # में इस निर्माण की कोशिश की, और JITed disassembly पर एक दृष्टि डाली:

    else 
         calc = calc + array1[i] - array2[k]; 
000000cf mov   eax,dword ptr [ebp-10h] 
000000d2 add   eax,dword ptr [ebp-14h] 
000000d5 sub   eax,edx 
000000d7 mov   dword ptr [ebp-10h],eax 

वे में घबराना के लिए सुधार की एक संख्या बनाया सीएलआर का 4.0।