Phân bổ tùy chỉnh bằng cách sử dụng tăng singleton_pool chậm hơn mặc định

Question

Tôi đã viết toán tử tùy chỉnh mới và toán tử cho lớp MyOrder. Tôi đang cấp phát bộ nhớ bằng cách sử dụng boost :: singleton pool. Đây là chương trình kiểm tra hiệu suất,

#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; 
} 

Tôi đã biên soạn chương trình trên bằng cờ -O2 và chạy trên Macbook của tôi với 2,26 GHz Intel Core 2 Duo và mất 0,16 giây. Sau đó, tôi nhận xét ra dòng mà tôi đã tuyên bố và xác định các nhà điều hành tùy chỉnh mới và điều hành xóa, biên dịch lại với cờ -O2 và chạy trên cùng một máy nó mất 0,13 giây.

Phân bổ và deallocating bộ nhớ bằng cách sử dụng singleton_pool cho các đối tượng có cùng kích thước sẽ tăng tốc độ. Tại sao nó làm cho nó chậm? Hoặc là phí tổn của việc tạo ra một hồ bơi vô hiệu hóa lợi ích hiệu suất đạt được trong chương trình nhỏ này?

Cập nhật:

tôi đã thay thế hai biến std :: string với một int và một đôi và lần này chạy hai chương trình với 100000000 (tức là 1000 lần trước đó) lặp đi lặp lại mỗi ngày một 3,0 GHZ AMD Phenom (tm) Bộ xử lý II X4 945. Một trong những bằng cách sử dụng phân bổ bộ nhớ tùy chỉnh mất 3,2 giây trong khi một trong những sử dụng phân bổ bộ nhớ mặc định mất 8,26 giây. Vì vậy, thời gian này phân bổ bộ nhớ tùy chỉnh thắng.

Answer 1

Tôi nghĩ con số của bạn là vô nghĩa. Nếu bạn chỉ kiểm tra thời gian chạy một lần và bạn thấy 0.13 so với 0.16 giây hơn điều đó hoàn toàn vô nghĩa và bị chi phối bởi chi phí.

Bạn phải chạy đoạn mã bạn muốn kiểm tra hàng ngàn lần và sau đó so sánh dữ liệu với chi phí đầu tư loại trừ.

Không thực sự, rằng 0.03 giây khác biệt có thể dễ dàng được giải thích bởi quá trình của bạn bị chuyển ra vv