सी ++ ऐरे बनाम वेक्टर प्रदर्शन परीक्षण स्पष्टीकरण

Question

सी ++ में सी-जैसे सरणी और वेक्टर के प्रदर्शन में अंतर को मापने के लिए, मैंने यह छोटा प्रोग्राम लिखा था। https://github.com/rajatkhanduja/Benchmarks/blob/master/C%2B%2B/vectorVsArray.cpp

सामान्य आधार पर उनकी तुलना करने के लिए, मैंने यादृच्छिक और अनुक्रमिक पहुंच दोनों के लिए परीक्षण करने का निर्णय लिया। मैंने इटरेटर्स को भी जोड़ा, बस उनकी तुलना करने के लिए (लेकिन यह सवाल नहीं है कि सवाल किस पर केंद्रित है)।

परिणाम, के साथ 1 लाख की एक सरणी/वेक्टर आकार पर साथ 7.7 जीबी रैम 64-बिट Linux मशीन के लिए इस प्रकार हैं: -

• समय सरणी में लिखने के लिए ले लिया। : 12.0378 एमएस
• क्रमशः सरणी से पढ़ने के लिए लिया गया समय। : 2.48413 एमएस
• सरणी से यादृच्छिक रूप से पढ़ने के लिए लिया गया समय। : 37.3931 एमएस
• गतिशील सरणी को लिखने के लिए समय लिया गया। : 11.7458 एमएस
• गतिशील सरणी से क्रमशः पढ़ने के लिए लिया गया समय। : 2.85107 एमएस
• यादृच्छिक सरणी से यादृच्छिक रूप से पढ़ने के लिए लिया गया समय। : 36.0579 एमएस
• सूचकांक का उपयोग कर वेक्टर को लिखने के लिए समय लिया गया। : 11.3 9 0 9 एमएस
• क्रमशः इंडेक्स का उपयोग करके वेक्टर से पढ़ने के लिए लिया गया समय। : 4.0 9 106 एमएस
• सूचकांक का उपयोग करके वेक्टर से पढ़ने के लिए समय निकाला गया, यादृच्छिक रूप से। : 39 एमएस
• इटरेटर का उपयोग कर वेक्टर को लिखने के लिए समय लिया गया। : 24.9 9 4 9 एमएस
• इटरेटर का उपयोग कर वेक्टर से पढ़ने के लिए समय लिया गया। : 18.8049 एमएस

वेक्टर के आकार प्रारंभ के समय में सेट किया गया है और न बदल, इसलिए वहाँ वेक्टर की कोई आकार परिवर्तन है (कार्यक्रम में जोर सत्यापित करें कि मदद करता है)। समय में किसी भी आवंटित आवंटित सरणी, गतिशील आवंटित सरणी या वेक्टर के प्रारंभिक समय शामिल नहीं होते हैं।

आंकड़ों के मुताबिक, वेक्टर को लिखने का समय सरणी से कम है, लेकिन वेक्टर से पढ़ने का समय सरणी की तुलना में दोगुना है।

अंतर बहुत छोटा है, लेकिन क्या कोई स्पष्टीकरण है कि प्रदर्शन प्रदर्शन क्यों है? क्या परीक्षण में कुछ गड़बड़ है? मुझे उम्मीद है कि दोनों एक ही गति से प्रदर्शन करेंगे। इस परीक्षण की पुनरावृत्ति एक ही प्रवृत्ति दिखाती है।

कोड:

#include <vector> 
#include <iostream> 
#include <cstdlib> 
#include <ctime> 
#include <sys/time.h> 
#include <cassert> 

#define ARR_SIZE 1000000 

using std::string; 

void printtime (struct timeval& start, struct timeval& end, string str); 

int main (void) 
{ 
    int arr[ARR_SIZE]; 
    int tmp; 
    struct timeval start, stop; 

    srand (time (NULL)); 

    /* Writing data to array */ 
    gettimeofday (&start, NULL); 
    for (int i = 0; i < ARR_SIZE; i++) 
    { 
    arr[i] = rand(); 
    } 
    gettimeofday (&stop, NULL); 
    printtime (start, stop, string ("Time taken to write to array.")); 

    /* Reading data from array */ 
    gettimeofday (&start, NULL); 
    for (int i = 0; i < ARR_SIZE; i++) 
    { 
    tmp = arr[i]; 
    } 
    gettimeofday (&stop, NULL); 
    printtime (start, stop, string ("Time taken to read from array sequentially.")); 

    /* Reading data from array randomly*/ 
    gettimeofday (&start, NULL); 
    for (int i = 0; i < ARR_SIZE; i++) 
    { 
    tmp = arr[rand() % ARR_SIZE]; 
    } 
    gettimeofday (&stop, NULL); 
    printtime (start, stop, string ("Time taken to read from array randomly.")); 


    int *darr = (int *) calloc (sizeof (int), ARR_SIZE); 

    /* Writing data to array */ 
    gettimeofday (&start, NULL); 
    for (int i = 0; i < ARR_SIZE; i++) 
    { 
    darr[i] = rand(); 
    } 
    gettimeofday (&stop, NULL); 
    printtime (start, stop, string ("Time taken to write to dynamic array.")); 

    /* Reading data from array */ 
    gettimeofday (&start, NULL); 
    for (int i = 0; i < ARR_SIZE; i++) 
    { 
    tmp = darr[i]; 
    } 
    gettimeofday (&stop, NULL); 
    printtime (start, stop, string ("Time taken to read from dynamic array sequentially.")); 

    /* Reading data from dynamic array randomly*/ 
    gettimeofday (&start, NULL); 
    for (int i = 0; i < ARR_SIZE; i++) 
    { 
    tmp = darr[rand() % ARR_SIZE]; 
    } 
    gettimeofday (&stop, NULL); 
    printtime (start, stop, string ("Time taken to read from dynamic array randomly.")); 

    std::vector<int> v(ARR_SIZE); 
    assert (v.capacity() == ARR_SIZE); 

    /* Writing to vector using indices*/ 
    gettimeofday (&start, NULL); 
    for (int i = 0; i < ARR_SIZE; i++) 
    { 
    v[i] = rand(); 
    } 
    gettimeofday (&stop, NULL); 
    printtime (start, stop, string ("Time taken to write to vector using indices.")); 
    assert (v.capacity() == ARR_SIZE); 

    /* Reading from vector using indices*/ 
    gettimeofday (&start, NULL); 
    for (int i = 0; i < ARR_SIZE; i++) 
    { 
    tmp = v[i]; 
    } 
    gettimeofday (&stop, NULL); 
    printtime (start, stop, string ("Time taken to read from vector using indices, sequentially.")); 

    /* Reading data from dynamic array randomly*/ 
    gettimeofday (&start, NULL); 
    for (int i = 0; i < ARR_SIZE; i++) 
    { 
    tmp = v[rand() % ARR_SIZE]; 
    } 
    gettimeofday (&stop, NULL); 
    printtime (start, stop, string ("Time taken to read from vector using indices, randomly.")); 

    std::vector<int> v2(ARR_SIZE); 

    /* Writing to vector using iterators*/ 
    gettimeofday (&start, NULL); 
    std::vector<int>::iterator itr, itr_end; 
    for (itr = v2.begin(), itr_end = v2.end(); itr != itr_end; itr++) 
    { 
    *itr = rand(); 
    } 
    gettimeofday (&stop, NULL); 
    printtime (start, stop, string ("Time taken to write to vector using iterators.")); 


    /* Reading from vector using iterators*/ 
    gettimeofday (&start, NULL); 
    for (itr = v2.begin(), itr_end = v2.end(); itr != itr_end; itr++) 
    { 
    tmp = *itr; 
    } 
    gettimeofday (&stop, NULL); 
    printtime (start, stop, string ("Time taken to read from vector using iterators.")); 

    return 0; 
} 

void printtime (struct timeval& start, struct timeval& end, string str) 
{ 
    double start_time, end_time, diff; 

    start_time = ((start.tv_sec) * 1000 + start.tv_usec/1000.0); 
    end_time = ((end.tv_sec) * 1000 + end.tv_usec/1000.0); 
    diff = end_time - start_time; 

    std::cout << str << " : " << diff << " ms" << std::endl; 
} 

---

संपादित

टिप्पणी में सुझाव के रूप में, अधिक जानकारी है: -

• संकलक: - g ++ - 4.5.2
• ध्वज: - कोई नहीं (यानी डी गलती मान)
• अनुकूलन: - कोई नहीं (मैं सामान्य सेटिंग में व्यवहार का परीक्षण करना चाहता था। अनुकूलन कार्यक्रम के व्यवहार को बदल सकता है, उदाहरण के लिए, परिवर्तनीय टीएमपी का कभी भी उपयोग नहीं किया जाता है, इसलिए वेक्टर/सरणी पढ़ने का चरण पूरी तरह से अंतिम असाइनमेंट में छोड़ा जा सकता है या घटाया जा सकता है।कम से कम यही मैं समझता हूं)।

Answer 1

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