प्रोफाइलर के बिना सी ++ में कोड की गति का परीक्षण करने का सबसे अच्छा तरीका है, या यह कोशिश करने के लिए समझ में नहीं आता है?

Question

एसओ पर, प्रदर्शन प्रोफाइलिंग के बारे में कुछ सवाल हैं, लेकिन मुझे पूरी तस्वीर नहीं मिलती है। इसमें बहुत से मुद्दे शामिल हैं और अधिकांश प्रश्न & एक समय में कुछ को अनदेखा करते हैं, या उनके प्रस्तावों को उचित नहीं ठहराते हैं।

मैं किस बारे में सोच रहा हूं। यदि मेरे पास दो कार्य हैं जो एक ही काम करते हैं, और मैं गति में अंतर के बारे में उत्सुक हूं, तो क्या यह बाहरी उपकरणों के बिना परीक्षण करने के लिए समझ में आता है, टाइमर के साथ, या परीक्षण में संकलित यह परिणाम को प्रभावित करेगा?

मैं यह पूछता हूं क्योंकि यदि यह समझदार है, सी ++ प्रोग्रामर के रूप में, मैं जानना चाहता हूं कि इसे कैसे किया जाना चाहिए, क्योंकि वे बाहरी उपकरणों का उपयोग करने से कहीं अधिक सरल हैं। यदि यह समझ में आता है, तो सभी संभावित नुकसान के साथ आगे बढ़ने दें:

इस उदाहरण पर विचार करें।

#include <algorithm> 
#include <ctime> 
#include <iostream> 

typedef unsigned char byte; 

inline 
void 
swapBytes(void* in, size_t n) 
{ 
    for(size_t lo=0, hi=n-1; hi>lo; ++lo, --hi) 

     in[lo] ^= in[hi] 
    , in[hi] ^= in[lo] 
    , in[lo] ^= in[hi] ; 
} 

int 
main() 
{ 
     byte arr[9]  = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h' }; 
    const int  iterations = 100000000; 
     clock_t begin  = clock(); 

    for(int i=iterations; i!=0; --i) 

     swapBytes(arr, 8); 

    clock_t middle = clock(); 

    for(int i=iterations; i!=0; --i) 

     std::reverse(arr, arr+8); 

    clock_t end = clock(); 

    double secSwap = (double) (middle-begin)/CLOCKS_PER_SEC; 
    double secReve = (double) (end-middle )/CLOCKS_PER_SEC; 


    std::cout << "swapBytes, for: " << iterations << " times takes: " << middle-begin 
      << " clock ticks, which is: " << secSwap << "sec."   << std::endl; 

    std::cout << "std::reverse, for: " << iterations << " times takes: " << end-middle 
      << " clock ticks, which is: " << secReve << "sec."   << std::endl; 

    std::cin.get(); 
    return 0; 
} 

// Output: 

// Release: 
// swapBytes, for: 100000000 times takes: 3000 clock ticks, which is: 3sec. 
// std::reverse, for: 100000000 times takes: 1437 clock ticks, which is: 1.437sec. 

// Debug: 
// swapBytes, for: 10000000 times takes: 1781 clock ticks, which is: 1.781sec. 
// std::reverse, for: 10000000 times takes: 12781 clock ticks, which is: 12.781sec. 

मुद्दों:: निम्नलिखित कोड ही बात कर के 2 तरीकों से पता चलता

1. उपयोग करने के लिए और कैसे CPU समय वास्तव में प्रश्न के अंतर्गत कोड से भस्म हो टाइमर है?
2. कंपाइलर अनुकूलन के प्रभाव क्या हैं (चूंकि ये फ़ंक्शंस केवल बाइट्स को स्वैप करते हैं, सबसे कुशल बात स्पष्ट रूप से कुछ भी नहीं करने के लिए है)?
3. यहां प्रस्तुत परिणामों को ध्यान में रखते हुए, क्या आपको लगता है कि वे सटीक हैं (मैं आपको आश्वस्त कर सकता हूं कि एकाधिक रन बहुत समान परिणाम देते हैं)? यदि हां, तो क्या आप कस्टम फ़ंक्शन की सादगी पर विचार कर सकते हैं कि std :: रिवर्स इतनी तेजी से कैसे हो सकता है। मेरे पास vC++ संस्करण से स्रोत कोड नहीं है जिसे मैंने इस परीक्षण के लिए उपयोग किया था, लेकिन जीएनयू से here is the implementation। यह iter_swap फ़ंक्शन पर उबालता है, जो मेरे लिए पूरी तरह से समझ में नहीं आता है। क्या यह भी कस्टम कार्य के रूप में तेज़ी से दो बार दौड़ने की उम्मीद की जाएगी, और यदि हां, तो क्यों?

contemplations:

1. ऐसा लगता है दो उच्च परिशुद्धता टाइमर दिया जा रहा है: clock() और QueryPerformanceCounter (खिड़कियों पर)। जाहिर है, हम अपने कोड के सीपीयू समय को मापना चाहते हैं, वास्तविक समय नहीं, लेकिन जहां तक ​​मैं समझता हूं, ये कार्य उस कार्यक्षमता को नहीं देते हैं, इसलिए सिस्टम पर अन्य प्रक्रिया मापों में हस्तक्षेप करेगी। This page gnu c लाइब्रेरी पर विरोधाभास प्रतीत होता है, लेकिन जब मैं vC++ में ब्रेकपॉइंट डालता हूं, तो डीबग प्रक्रिया को निलंबित कर दिया गया है, भले ही इसे निलंबित कर दिया गया हो (मैंने gnu के तहत परीक्षण नहीं किया है)। क्या मैं इसके लिए वैकल्पिक काउंटर खो रहा हूं, या इसके लिए हमें कम से कम विशेष पुस्तकालयों या कक्षाओं की आवश्यकता है? यदि नहीं, तो इस उदाहरण में घड़ी काफी अच्छी है या क्या QueryPerformanceCounter का उपयोग करने का कोई कारण होगा?

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

किसी भी दिशा के लिए धन्यवाद।

अद्यतन

धन्यवाद swapBytes समारोह अब भी जितनी जल्दी संभव std :: रिवर्स चलाता है एक hinttojas से करने के लिए। मैं यह महसूस करने में नाकाम रहा था कि बाइट के मामले में अस्थायी प्रति केवल एक रजिस्टर होना चाहिए, और इस प्रकार यह बहुत तेज़ है। लालित्य आपको अंधेरा कर सकता है।

inline 
void 
swapBytes(byte* in, size_t n) 
{ 
    byte t; 

    for(int i=0; i<7-i; ++i) 
    { 
     t  = in[i]; 
     in[i] = in[7-i]; 
     in[7-i] = t; 
    } 
} 

धन्यवाद एक tipChrisW से करने के लिए मैं ने पाया है कि खिड़कियों पर आप वास्तविक CPU समय एक से भस्म प्राप्त कर सकते हैं (पढ़ें: अपने) प्रक्रिया गर्त Windows Management Instrumentation। यह निश्चित रूप से उच्च परिशुद्धता काउंटर की तुलना में अधिक दिलचस्प लग रहा है।

Answer 1

जाहिर है हम अपने कोड के CPU समय और नहीं वास्तविक समय को मापने के लिए चाहते हैं, लेकिन जहाँ तक मैं समझता हूँ, इन कार्यों उस कार्यक्षमता को न दें, इसलिए सिस्टम पर अन्य प्रक्रिया मापों में हस्तक्षेप करेगी। समय की एक महत्वपूर्ण लंबाई के लिए

• टेस्ट, यानी कई सेकंड (एक परीक्षण से जैसे:

मैं दो काम करने, कि दीवार-घड़ी समय और CPU समय सुनिश्चित करने के लिए लगभग एक ही बात कर रहे हैं हालांकि कई हजारों पुनरावृत्तियों का लूप)

परीक्षण करें जब मशीन जो भी मैं परीक्षण कर रहा हूं उसे छोड़कर मशीन कम या ज्यादा अपेक्षाकृत निष्क्रिय हो।

वैकल्पिक रूप से यदि आप धागा प्रति केवल/अधिक वास्तव में CPU समय को मापने के लिए चाहते हैं, कि एक प्रदर्शन काउंटर के रूप में उपलब्ध है (उदाहरण के लिए perfmon.exe देखें)।

डिबगिंग, असंतुलन और प्रोफाइलिंग प्रोफाइल के बिना हम निश्चित रूप से क्या जान सकते हैं?

लगभग कुछ नहीं (सिवाय इसके कि I/O अपेक्षाकृत धीमा हो जाता है)।

Answer 2

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

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

अकेले सरल समय परीक्षणों पर भरोसा करने के लिए, वे बेहद समस्याग्रस्त हैं। वह वर्तमान परीक्षण इतना बुरा नहीं है, लेकिन समय-समय पर परीक्षण परीक्षण लिखना एक बहुत ही आम गलती है जिसमें ऑप्टिमाइज़र मृत कोड को अनुकूलित करेगा और अनिवार्य रूप से एक एनओपी या यहां तक ​​कि कुछ भी करने के लिए समय लगता है। यह सुनिश्चित करने के लिए कि संकलक ऐसा नहीं कर रहा है, आपको अलग-अलग हिस्सों की व्याख्या करने के लिए कुछ ज्ञान होना चाहिए।

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

वास्तविक विश्व समय परीक्षणों के आधार पर थोड़ा बेहतर है; एक उच्च स्तर पर आपका आवेदन क्या कर रहा है इसके करीब कुछ। यह आपको बताएगा कि कितना समय ले रहा है, लेकिन यह ठीक है कि प्रोफाइलर का क्या मतलब है।

Answer 3

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

तो, वैसे भी, शायद मैं आपके प्रश्न का उत्तर दे सकता हूं कि विंडोज पर किस घड़ी का उपयोग करना है।

घड़ी() को उच्च परिशुद्धता घड़ी नहीं माना जाता है। यदि आप CLOCKS_PER_SEC के मान को देखते हैं तो आप देखेंगे कि इसमें 1 मिलीसेकंड का संकल्प है। यह केवल तभी पर्याप्त है जब आप बहुत लंबे दिनचर्या का समय ले रहे हों, या 10000 के पुनरावृत्तियों के साथ एक लूप। जैसा कि आप इंगित करते हैं, यदि आप घड़ी के साथ मापा जा सकने वाला समय प्राप्त करने के लिए 10000 बार एक साधारण विधि को दोहराते और दोहराते हैं() कंपाइलर पूरी चीज को दूर करने और अनुकूलित करने के लिए उत्तरदायी है।

तो, वास्तव में, उपयोग करने के लिए केवल घड़ी QueryPerformanceCounter() है

Answer 4

आपको मुख्य प्रश्न का उत्तर देने के लिए, यह "रिवर्स" एल्गोरिदम केवल सरणी से तत्वों को स्वैप करता है और सरणी के तत्वों पर काम नहीं करता है।

Answer 5

क्या यह कहना सुरक्षित है कि आप दो प्रश्न पूछ रहे हैं?

• कौन सा तेज़ है, और कितना?

• और यह तेज़ क्यों है?

पहले के लिए, आपको उच्च परिशुद्धता टाइमर की आवश्यकता नहीं है। आपको बस इतना करना है कि उन्हें "काफी लंबा" चलाएं और कम सटीक टाइमर के साथ मापें। (मैं बूढ़ा हूँ, मेरी wristwatch एक स्टॉप-घड़ी समारोह है, और यह पूरी तरह से पर्याप्त है।)

दूसरे के लिए, निश्चित रूप से आप एक डीबगर के तहत कोड चला सकते हैं और निर्देश पर एकल चरण स्तर। चूंकि बुनियादी परिचालन इतने सरल हैं, इसलिए आप आसानी से देख सकते हैं कि बुनियादी चक्र के लिए कितने निर्देश आवश्यक हैं।

सरल सोचें। प्रदर्शन एक कठिन विषय नहीं है। आम तौर पर, लोग को समस्याओं का पता लगाने की कोशिश कर रहे हैं, जिसके लिए this is a simple approach।

Answer 6

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

Answer 7

व्हा? एक प्रोफाइलर के बिना गति को मापने के लिए कैसे? गति मापने का बहुत ही प्रभाव प्रोफाइलिंग है! सवाल यह है कि, "मैं अपना खुद का प्रोफाइलर कैसे लिख सकता हूं?"और जवाब स्पष्ट रूप से है," नहीं "।

इसके अलावा, आप पहली जगह है, जो पूरा अमान्य कर देता है इस पूरे व्यर्थ पीछा।

निरर्थकता के लिए -1 में std::swap का उपयोग करना चाहिए।

Answer 8

(यह उत्तर विंडोज एक्सपी और 32-बिट वीसी ++ कंपाइलर के लिए विशिष्ट है।)

कोड के छोटे बिट्स के समय के लिए सबसे आसान बात सीपीयू का टाइम-स्टैम्प काउंटर है। यह 64-बिट मान है, एक गिनती सीपीयू चक्रों की संख्या अब तक चल रही है, जो कि आपको एक रिज़ॉल्यूशन के बारे में ठीक है जैसा कि आप प्राप्त करने जा रहे हैं। वास्तविक संख्याएं आपको मिलती हैं विशेष रूप से उपयोगी नहीं हैं क्योंकि वे खड़े हैं, लेकिन यदि आप विभिन्न प्रतियोगी दृष्टिकोणों के कई रनों का औसत करते हैं तो आप उनकी तुलना इस तरह से कर सकते हैं। परिणाम थोड़ा शोर हैं, लेकिन तुलनात्मक उद्देश्यों के लिए अभी भी मान्य हैं।

समय स्टाम्प काउंटर पढ़ने के लिए, निम्नलिखित की तरह कोड का उपयोग करें:

LARGE_INTEGER tsc; 
__asm { 
    cpuid 
    rdtsc 
    mov tsc.LowPart,eax 
    mov tsc.HighPart,edx 
} 

(cpuid अनुदेश वहाँ है सुनिश्चित करने के लिए वहाँ पूरा करने के लिए इंतजार कर रहे किसी भी अधूरा निर्देश नहीं हैं।)

इस दृष्टिकोण के बारे में ध्यान देने योग्य चार चीजें हैं।

सबसे पहले, इनलाइन असेंबली भाषा की वजह से, यह एमएस के x64 कंपाइलर पर काम नहीं करेगा। (आपको इसमें एक फ़ंक्शन के साथ एक .ASM फ़ाइल बनाना होगा। पाठक के लिए एक अभ्यास; मुझे विवरण नहीं पता।)

दूसरा, चक्र काउंटरों के साथ समस्याओं से बचने के लिए अलग-अलग सिंक में नहीं है कोर/थ्रेड्स/आपके पास क्या है, आपको अपनी प्रक्रिया के संबंध को सेट करना आवश्यक हो सकता है ताकि यह केवल एक विशिष्ट निष्पादन इकाई पर चलता है। (फिर फिर ... आप नहीं कर सकते हैं।)

तीसरा, आप निश्चित रूप से जेनरेट की गई असेंबली भाषा को देखना चाहते हैं ताकि यह सुनिश्चित किया जा सके कि संकलक लगभग आपके द्वारा अपेक्षित कोड उत्पन्न कर रहा है। कोड को हटाए जाने के बिट्स के लिए देखें, उस तरह की चीज को रेखांकित किया जा रहा है।

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