{"id":5058,"date":"2016-12-06T16:21:55","date_gmt":"2016-12-06T16:21:55","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/memory-and-performance-overhead-of-smart-pointer\/"},"modified":"2023-06-26T12:33:43","modified_gmt":"2023-06-26T12:33:43","slug":"memory-and-performance-overhead-of-smart-pointer","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/memory-and-performance-overhead-of-smart-pointer\/","title":{"rendered":"Memory and Performance Overhead of Smart Pointers"},"content":{"rendered":"

C++11 offers four different smart pointers. I will have a closer look in this post regarding memory and performance overhead on two of them. My first candidate, std::unique_ptr<\/span> takes care of the lifetime of one resource exclusively; std::shared_ptr shares the ownership of a resource with another std::shared_ptr. I will state the result of my tests before I show you the raw numbers: There are only a few reasons in modern C++ justifying the memory management with new and delete.<\/strong><\/p>\n

 <\/p>\n

<\/p>\n

 <\/p>\n

Why? Here are the numbers.<\/p>\n

Memory overhead<\/h2>\n

std::unique_ptr<\/h3>\n

std::unique_ptr<\/span> needs, by default, no additional memory. That means std::unique_ptr<\/span> is as big as its underlying raw pointer. But what does default mean? You can parametrize a std::unique_ptr<\/span> with a special deleter function. If this deleter function has been stated, you will have an enriched std::unique_ptr<\/span> and pay for it. As I mentioned, that is the special use case.<\/p>\n

In opposition to the std::unique_ptr<\/span>, the std::shared_ptr<\/span> has a little overhead.<\/p>\n

std::shared_ptr<\/h3>\n

std::shared_ptr<\/span>‘s share a resource. They internally use a reference counter. That means if a std::shared_ptr <\/span>is copied, the reference counter will be increased. The reference count will be decreased if the std::shared_ptr<\/span> goes out of scope. Therefore, the std::shared_ptr<\/span> needs additional memory for the reference counter. (To be precise, there is an additional reference counter for the std::weak_ptr<\/span>). That’s the overhead a std::shared_ptr<\/span> has in opposite to a raw pointer.<\/p>\n<\/p>\n

Performance overhead<\/h2>\n

The story of the performance is a little bit more involved. Therefore, I let the numbers speak for themself. A simple performance test should give an idea of the overall performance.<\/p>\n

The performance test<\/h3>\n

I allocate and deallocate in the test 100’000’000 times memory. Of course, I’m interested in how long it takes.<\/p>\n

<\/p>\n

\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24<\/pre>\n<\/td>\n
\n
\/\/ all.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n\r\nstatic<\/span> const<\/span> long<\/span> long<\/span> numInt= 100000000;\r\n\r\nint<\/span> main(){\r\n\r\n  auto<\/span> start = std::chrono::system_clock::now();\r\n\r\n  for<\/span> ( long<\/span> long<\/span> i=0 ; i < numInt; ++i){\r\n    int<\/span>* tmp(new<\/span> int<\/span>(i));\r\n    delete<\/span> tmp;\r\n    \/\/ std::shared_ptr<int> tmp(new int(i));<\/span>\r\n    \/\/ std::shared_ptr<int> tmp(std::make_shared<int>(i));<\/span>\r\n    \/\/ std::unique_ptr<int> tmp(new int(i));<\/span>\r\n    \/\/ std::unique_ptr<int> tmp(std::make_unique<int>(i));<\/span>\r\n  }\r\n\r\n  std::chrono::duration<double<\/span>> dur= std::chrono::system_clock::now() - start;\r\n  std::cout << \"time native: \"<\/span> << dur.count() << \" seconds\"<\/span> << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
I compare in my test the explicit calls of new<\/span> and delete<\/span> (lines 13 and 14) with the usage of  std::shared_ptr<\/span> (line 15), std::make_shared<\/span> (line 16), std::unique_ptr<\/span> (line 17), and std::make_unique<\/span> (line 18). In this small program, handling the smart pointer (lines 15 – 18) is much simpler because it automatically releases its dynamically created int<\/span> variable if it goes out of scope.  <\/p>\n
The functions std::make_shared<\/span> (line 16) and std::make_unique<\/span>(line 18) are quite handy. They create the smart pointer, respectively. In particular, std::make_shared<\/span> is very interesting. There are more memory allocations necessary for the creation of a std::shared_ptr. Memory is necessary for the managed resource and the reference counters. std::make_shared<\/span> make one memory allocation out of them. The performance benefits. std::make_unique<\/span> is available since C++14; the other smart pointer functionality since C++11.<\/p>\n
I use GCC 4.9.2 and a cl.exe for my performance tests. The cl.exe is part of Microsoft Visual Studio 2015. Although cl.exe officially supports only C++11, the helper function std::make_unique<\/span> is already available. Therefore, I can run my performance test with maximum and without optimization. I must admit that my Windows PC is less powerful than my Linux PC. Therefore, I’m interested in comparing the raw memory allocation and the smart pointers. I’m not comparing Windows and Linux.<\/p>\n
Here a the raw numbers.<\/p>\n
The raw numbers<\/h3>\n
For simplicity reasons, I will not show the screenshots of the programs and present you only the table holding the numbers.<\/p>\n
\"comparisonEng\"<\/p>\n
I want to draw a few interesting conclusions from the table.<\/p>\n
    \n
  1. Optimization matters. In the case of std::make_shared_ptr, the program with maximum optimizations is almost ten times faster. But these observations also hold for the other smart pointers. The optimized program is about 2 to 3 times faster. Interestingly, this observation will not hold for new<\/span> and delete.<\/span><\/li>\n
  2. std::unique_ptr<\/span>, std::make_unique, <\/span>and with minor deviations, std::make_shared<\/span> are in the same performance range as new<\/span> and delete.<\/span><\/li>\n
  3. You should not use std::shared_ptr<\/span> and std::make_shared<\/span> without optimization. std::shared_ptr<\/span> is about two times slower than new and deletes even with optimization.<\/span><\/li>\n<\/ol>\n
    My conclusion<\/h2>\n