shared_ptr: horrible speed

by

shared_ptr are the most complicated type of pointer ever:

  • Ref counting takes time
  • Multiple allocation (there are 3 parts: the object, the counter, the deleter)
  • A number of virtual methods (in the counter and the deleter) for type erasure
  • Works among multiple threads (thus synchronization)

There are 2 ways to make them faster:

  • use make_shared to allocate them, because (unfortunately) the normal constructor allocates two different blocks: one for the object and one for the counter and deleter.
  • don’t copy them if you don’t need to: methods should accept shared_ptr<T> const&

But there are also many ways NOT to use them.

Looking at your code it looks like your doing a LOT of memory allocation, and I can’t help but wonder if you couldn’t find a better strategy. I must admit I didn’t got the full figure, so I may be heading straight into a wall but…

Usually code is much simpler if you have an owner for each of the objects. Therefore, shared_ptr should be a last resort measure, employed when you can’t get a single owner.

Anyway, we’re comparing apples and oranges here, the original code is buggy. You take care of deleting the memory (good) but you forgot that these objects were also referenced from other points in the program e1->setNextEdge(e21) which now holds pointers to destructed objects (in a free’d memory zone). Therefore I guess that in case of exception you just wipe out the entire list ? (Or somehow bet on undefined behavior to play nice)

So it’s hard to judge on performances since the former doesn’t recover well from exceptions while the latter does.

Finally: Have you thought about using intrusive_ptr ? It could give you some boost (hehe) if you don’t synchronize them (single thread) and you would avoid a lot of stuff performed by the shared_ptr as well as gain on locality of reference.

More Related Contents:

  1. How to overload std::swap()
  2. What’s the difference between __PRETTY_FUNCTION__, __FUNCTION__, __func__?
  3. Why is my program slow when looping over exactly 8192 elements?
  4. What is the efficient way to count set bits at a position or lower?
  5. What is special about numbers starting with zero?
  6. Best compiler warning level for C/C++ compilers? [closed]
  7. How can I measure CPU time and wall clock time on both Linux/Windows?
  8. It is more efficient to use if-return-return or if-else-return?
  9. Why does C need “struct” keyword and not C++?
  10. Why are Python Programs often slower than the Equivalent Program Written in C or C++?
  11. Is there any guarantee of alignment of address return by C++’s new operation?
  12. Getting an accurate execution time in C++ (micro seconds)
  13. Can the use of C++11’s ‘auto’ improve performance?
  14. A fast method to round a double to a 32-bit int explained
  15. Update GCC on OSX
  16. Passing shared_ptr as shared_ptr
  17. Understanding stack frame of function call in C/C++? [closed]
  18. Is accessing data in the heap faster than from the stack?
  19. C++ string literal data type storage
  20. Two classes that refer to each other
  21. Is make_shared really more efficient than new?
  22. Should I still return const objects in C++11? [duplicate]
  23. Speed difference between If-Else and Ternary operator in C…?
  24. Example to use shared_ptr?
  25. Using shared_ptr in dll-interfaces
  26. Why do I see 400x outlier timings when calling clock_gettime repeatedly?
  27. What is the modern, correct way to do type punning in C++?
  28. Why is this C++ wrapper class not being inlined away?
  29. Problems using member function as custom deleter with std::shared_ptr
  30. Does an R compiler to C/C++ exist?

Leave a Comment