Why is std::unique_ptr much slower than standard pointer... before optimizations?

Question

Lesson learned, always use optimizations when doing benchmarks...

---

I decided to look at std::unique_ptr as an alternative for my program. The reasons as to why are not important.

After using compiler optimizations, they seems to take equivalent amounts of time.

How I tested:

time_t current_time;
time(&current_time);
srand((int)current_time);
//int* p0 = new int[NUM_TESTS];
//int* p1 = new int[NUM_TESTS];
std::unique_ptr<int[]> u_p0{ new int[NUM_TESTS] };
std::unique_ptr<int[]> u_p1{ new int[NUM_TESTS] };
for (unsigned i = 0; i < NUM_TESTS; ++i){
    u_p0[i] = rand(); // Use p0 and p1 for the standard ptr test
    u_p1[i] = rand();
}
int result;
auto start = std::chrono::steady_clock::now();
for (unsigned index = 0; index < NUM_TESTS; ++index){
    result = u_p0[index] + u_p1[index]; // Use p0 and p1 for standard ptr test
}
auto end = std::chrono::steady_clock::now();
double duration = std::chrono::duration_cast<std::chrono::duration<double>>(end - start).count();
printf("time: %f\n", duration);

My environment:

• Windows 8.1 64 bit
• MSVC compiler in Visual Studio 2013. Using Release.
• Intel 4790k (standard clock)
• 1600 MHz RAM

My results (using optimized compilation):

// NUM_TESTS = 1,000,000

/*
STD:
    0.001005
    0.001001
    0.001000
    0.001000
    0.001015
*/
/*
unique_ptr:
    0.001000
    0.001000
    0.000997
    0.001000
    0.001017
*/

Answer 1

Because "standard compiler flags" means you're compiling without optimizations enabled.

std::unique_ptr is a thin wrapper around a raw pointer. As such, when dereferencing it, it goes through a very simple forwarding function, which the compiler is able to optimize away. But it only does that if optimizations are enabled. If they are, then it can eliminate the overhead of going through the wrapper, so performance will be the same as if you'd just used a raw pointer.

But if you don't ask the compiler to optimize your code, then every time you access the pointer, it has to go through the small wrapper function to get to the actual internal pointer.

Always, always enable optimization when benchmarking code.