Performance Considerations with std::exception_ptr

Using std::exception_ptr to capture, store, and rethrow exceptions does have some performance implications that are worth considering:

1. Capturing exceptions: When an exception is captured into a std::exception_ptr using std::current_exception(), the exception object is copied. This copy operation can have a performance cost, especially if the exception object is large or has a complex copy constructor.
2. Memory allocation: Capturing an exception into a std::exception_ptr involves allocating memory on the heap for the copied exception object. This memory allocation can have a performance impact, particularly if exceptions are frequently captured.
3. Rethrowing exceptions: Rethrowing an exception using std::rethrow_exception() is generally as efficient as throwing the exception directly. However, there is a small overhead due to the indirection through the std::exception_ptr.
4. Exception handling in general: Exception handling itself has a performance cost, regardless of whether std::exception_ptr is used. When an exception is thrown, the stack must be unwound to find the appropriate catch block, which can be expensive.

Here's an example that demonstrates the performance difference between rethrowing an exception directly and using std::exception_ptr:

1#include <chrono>
2#include <exception>
3#include <iostream>
4
5void throwException() {
6  throw std::runtime_error("Exception");
7}
8
9void rethrowDirect() {
10  try {
11    throwException();
12  } catch (...) {
13    throw;
14  }
15}
16
17void rethrowPtr() {
18  try {
19    throwException();
20  } catch (...) {
21    std::exception_ptr eptr =
22      std::current_exception();
23    std::rethrow_exception(eptr);
24  }
25}
26
27int main() {
28  using namespace std::chrono;
29  auto start = high_resolution_clock::now();
30  try {
31    rethrowDirect();
32  } catch (...) {}
33  auto end = high_resolution_clock::now();
34  duration<double, std::micro> elapsed =
35    end - start;
36  std::cout << "Direct rethrow took "
37    << elapsed.count() << "us\n";
38
39  start = high_resolution_clock::now();
40  try {
41    rethrowPtr();
42  } catch (...) {}
43  end = high_resolution_clock::now();
44  elapsed = end - start;
45  std::cout << "Rethrow using std::exception_ptr"
46    " took " << elapsed.count() << "us\n";
47}

1Direct rethrow took 1021.8us
2Rethrow using std::exception_ptr took 1798.6us

In this example, we measure the time taken to rethrow an exception directly (rethrowDirect()) and to rethrow it using std::exception_ptr (rethrowPtr()). The results show that using std::exception_ptr is slightly slower due to the additional overhead.

However, it's important to note that the performance difference is usually negligible unless exceptions are used very frequently. The benefits of using std::exception_ptr, such as the ability to store and transfer exceptions, often outweigh the small performance cost.

As with all performance considerations, it's important to profile and measure in the context of your specific application to determine if the use of std::exception_ptr has a significant impact.