डिफ़ॉल्ट सिंगलटन_पूल का उपयोग कर कस्टम आवंटन डिफ़ॉल्ट

Question

से धीमा है मैंने कस्टम ऑपरेटर नया और ऑपरेटर क्लास मायऑर्डर के लिए हटा दिया है। मैं बूस्ट :: सिंगलटन पूल का उपयोग कर स्मृति आवंटित कर रहा हूं। यहां कार्यक्रम प्रदर्शन का परीक्षण,

#include <boost/pool/singleton_pool.hpp> 
#include <boost/progress.hpp> 
#include <iostream> 
#include <new> 
#include <vector> 


class MyOrder{ 
    std::vector<int> v1_; 
    std::vector<double> v2_; 

    std::string s1_; 
    std::string s2_; 

public: 
    MyOrder(std::string s1, std::string s2): s1_(s1), s2_(s2) {} 

    ~MyOrder(){} 

    static void * operator new(size_t size); 
    static void operator delete(void * rawMemory) throw(); 
}; 

struct MyOrderTag{}; 
typedef boost::singleton_pool<MyOrderTag, sizeof(MyOrder)> MyOrderPool; 

void* MyOrder:: operator new(size_t size) 
{ 
    if (size != sizeof(MyOrder)) 
     return ::operator new(size); 

    while(true){ 
     void * ptr = MyOrderPool::malloc(); 
     if (ptr != NULL) return ptr; 

     std::new_handler globalNewHandler = std::set_new_handler(0); 
     std::set_new_handler(globalNewHandler); 

     if(globalNewHandler) globalNewHandler(); 
     else throw std::bad_alloc(); 

    } 
} 

void MyOrder::operator delete(void * rawMemory) throw() 
{ 
    if(rawMemory == 0) return; 
    MyOrderPool::free(rawMemory); 
} 

int main() 
{ 
    MyOrder* mo = NULL; 
    std::vector<MyOrder*> v; 
    v.reserve(100000); 

    boost::progress_timer howlong; 
    for(int i = 0; i< 100000; ++i) 
    { 
     mo = new MyOrder("Sanket", "Sharma"); 
     v.push_back(mo); 
    } 

    for (std::vector<MyOrder*>::const_iterator it = v.begin(); it != v.end(); ++it) 
    { 
     delete *it; 
    } 
    return 0; 
} 

मैं है -O2 ध्वज का उपयोग कर उपरोक्त कार्यक्रम संकलित और साथ 2.26 गीगा इंटेल कोर 2 डुओ मेरी मैकबुक पर भाग गया और यह 0.16 सेकण्ड लगे। तब मैंने उन पंक्तियों पर टिप्पणी की जहां मैंने कस्टम ऑपरेटर को घोषित और परिभाषित किया है और ऑपरेटर हटा दिया है, ओओ 2 झंडे के साथ पुनः संकलित किया है और उसी मशीन पर चला गया है जिसमें 0.13 सेकंड लग गए थे।

समान आकार की वस्तुओं के लिए सिंगलटन_पूल का उपयोग करके स्मृति आवंटित और डिलीकेट करना इसे तेज करना चाहिए। यह धीमा क्यों कर रहा है? या इस छोटे कार्यक्रम में प्राप्त प्रदर्शन लाभ को रद्द करने वाला पूल बनाने का उपर है?

अद्यतन:

मैं एक पूर्णांक और एक डबल के साथ दो std :: स्ट्रिंग चर बदल दिया और इस बार 100000000 (यानी 1000 बार से पहले) के साथ दो कार्यक्रमों एक 3.0 GHz AMD Phenom (टीएम पर प्रत्येक पुनरावृत्तियों भाग गया) II एक्स 4 9 45 प्रोसेसर। कस्टम मेमोरी आवंटन का उपयोग करने वाला एक 3.2 सेकंड लेता है जबकि डिफ़ॉल्ट मेमोरी आवंटन का उपयोग करने वाले व्यक्ति को 8.26 सेकंड लगते हैं। तो इस बार कस्टम मेमोरी आवंटन जीतता है।

Answer 1

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

आपको उस स्निपेट को चलाना होगा जिसे आप हजारों बार परीक्षण करना चाहते हैं और फिर ओवरहेड को रद्द करने के लिए डेटा की तुलना करें।

नहीं वास्तव में, कि 0.03 सेकंड का अंतर आसानी से अपने प्रक्रिया से समझाया जा सकता बाहर बंद, आदि हो रही