Problem with Vector/Shared Pointer

I started using boost::shared_ptr to handle my pointer, then after applying it to my resource manager I realized I was losing a lot of performance in initialization, and shutdown was taking 10x as long to release my memory. So, I decided to make a test program to see what was happening, and I still can't figure it out. I am assuming it has something to do with the vector, but I am not sure.

Here is the test program to test speed. On release build it allocates 79,000k in task manager in about 3 seconds, and it takes my computer about 2 minutes to free it.
I am hoping someone can help me solve this issue. If not shared_ptr just isnt going to work for me.

Code:

---

template<class T>
struct SPtr
{
    typedef boost::shared_ptr<T> Type;
};

int main()
{
    std::vector<SPtr<int>::Type> Test;
    Test.resize(1000000);
    std::vector<SPtr<int>::Type>::iterator it = Test.begin();
    int x = 0;
    for ( ; it != Test.end(); ++it )
    {
        (*it).reset(new int(x));
        ++x;
    }
    system("pause");
    return 0;
}

---

Thank you for any assistance.

Don't know. It takes slightly less time to free it for me and both happens in less than a second.

Did you also compare it against plain pointers?

Also, testing it with the simplest built-in type seems not very realistic: in real life the things you'd allocate dynamically would be more complex.

You might try profiling the code to see where it is slow.

>>Also, testing it with the simplest built-in type seems not very realistic: in real life the things you'd allocate dynamically would be more complex.

Maybe so, but if it takes forever allocating/de-allocating built in data types, then naturally it will take even longer to do so with larger datatypes.

I am using VS C++ 9.0 sp1. Is there something with VS vector that makes it slow? ( such as debug stuff ) speed doesn't change from debug to release build.

I tried it with raw pointers (no vector/shared_ptr) and it is instantaneous .023 seconds. So, it has to be the vector I am assuming. I get a heap corruption error when creating a dynamic array of shared_ptr's.

I have been adding counters in my code that produce a message box with allocation/de-allocation times on different elements, and the speeds are ridiculous. 3 seconds to load 100 textures. approx. 10mb of data. Which with raw pointers is unnoticeable. ( This is not due to file streams. All data is contiguous in a single file. )

I believe there is bound checking for vectors in Visual C++. Don't know if this is not done in release mode. Don't know how to turn it off.

Quote:

---

Originally Posted by Raigne

I tried it with raw pointers (no vector/shared_ptr) and it is instantaneous .023 seconds. So, it has to be the vector I am assuming. I get a heap corruption error when creating a dynamic array of shared_ptr's.

---

The combination of shared_ptrs with vector might or might not be the problem, but boost::ptr_vector provides an alternative that might perform better.

Quote:

---

Originally Posted by C_ntua

I believe there is bound checking for vectors in Visual C++. Don't know if this is not done in release mode. Don't know how to turn it off.

---

The bounds checking is enabled in the default release configuration as well, but can be disabled by setting _SECURE_SCL=0