Can exceptions be "duplicated" via exception pointers?

Question

For some multithreaded code, I would like to capture all exceptions and pass a them to a single exception handling thread. Here's the message passing framework:

#include <exception>

struct message
{
    virtual ~message() = default;
    virtual void act() = 0;
};

struct exception_message : message
{
    std::exception_ptr ep;

    virtual void act()
    {
        std::rethrow_exception(ep);
    }

    // ...
};

Here's the use case:

try
{
    // ...
}
catch (...)
{
    exception_message em { std::current_exception(); }
    handler_thread.post_message(em);
}

The handler thread goes through all its messages and calls act(), and it can install its own try/catch block to handle all the posted exceptions.

Now I was wondering what happens if I send copies this message to multiple receivers. In general, messages may have any number of recipients, and so I don't want to put arbitrary restrictions on exception propagation messages. The exception_ptr is documented as a "shared-ownership" smart pointer, and rethrow_exception "does not introduce a data race".

So my question: Is it legitimate to duplicate an active exception by storing it in an exception_ptr, copying the pointer, and calling rethrow_exception multiple times?

just find by google: msdn.microsoft.com/en-us/library/dd293602.aspx "Transporting Exceptions Between Threads" — PiotrNycz
– PiotrNycz, Commented Oct 2, 2012 at 13:06
Never tried anything like that. Copying/communicating an exception to another thread and re-raising it there sounds a bit strange since the exception, once received, has lost all its context re. the original thread except in so far as what it contains itself. Inspecting the signaled exceptiion in one thread, and maybe logging it or whatever, I could understand. — Martin James
– Martin James, Commented Oct 2, 2012 at 13:12
@PiotrNycz: That page isn't C++. There's no std::copy_exception in C++, — Kerrek SB
– Kerrek SB, Commented Oct 2, 2012 at 13:13
@KerrekSB: Actually "std::"copy_exception means std::make_exception_ptr in standard C++. — kennytm
– kennytm, Commented Oct 2, 2012 at 13:18
@KerrekSB - granted, that page is Windows-intensive (and it's interesting that Microsoft claims credit for implementing pretty much what the C++ standard requires), but copy_exception is the name in earlier drafts of C++11 for make_exception_ptr. — Pete Becker
– Pete Becker, Commented Oct 2, 2012 at 13:20

Matthieu M. · Accepted Answer · 2012-10-02 14:13:42Z

6

From my understanding of the Standard, it is legitimate. However I would note that the rethrow does not duplicate the exception, and therefore the shared exception object itself is submitted to data races should you modify it and access it from other threads meantime. If the exception is read-only (once thrown), then you should not have any issue.

Regarding storage duration:

15.1 Throwing an exception [except.throw]

4 The memory for the exception object is allocated in an unspecified way, except as noted in 3.7.4.1. If a handler exits by rethrowing, control is passed to another handler for the same exception. The exception object is destroyed after either the last remaining active handler for the exception exits by any means other than rethrowing, or the last object of type std::exception_ptr (18.8.5) that refers to the exception object is destroyed, whichever is later. In the former case, the destruction occurs when the handler exits, immediately after the destruction of the object declared in the exception-declaration in the handler, if any. In the latter case, the destruction occurs before the destructor of std::exception_ptr returns.

Regarding data races:

18.8.5 Exception propagation [propagation]

7 For purposes of determining the presence of a data race, operations on exception_ptr objects shall access and modify only the exception_ptr objects themselves and not the exceptions they refer to. Use of rethrow_exception on exception_ptr objects that refer to the same exception object shall not introduce a data race. [ Note: if rethrow_exception rethrows the same exception object (rather than a copy), concurrent access to that rethrown exception object may introduce a data race. Changes in the number of exception_ptr objects that refer to a particular exception do not introduce a data race. —end note ]

Regarding rethrow:

[[noreturn]] void rethrow_exception(exception_ptr p);

9 Requires: p shall not be a null pointer.

10 Throws: the exception object to which p refers.

edited Oct 2, 2012 at 14:13

answered Oct 2, 2012 at 13:16

Matthieu M.

303k58 gold badges495 silver badges754 bronze badges

Sign up to request clarification or add additional context in comments.

9 Comments

Kerrek SB Over a year ago

I read that, too, but what does it mean? Is the actual, same exception object thrown multiple times? Is that OK? Does that even mean anything?

Matthieu M. Over a year ago

@KerrekSB: What does thrown mean ? throw is just a goto/jump within the context of a thread that happen to respect stack unwinding. Therefore it poses no problem to rethrow the exact same object several times, the object itself can be seen as directing the jump (toward the right catch clause).

Pete Becker Over a year ago

@KerrekSB - I just went through the same exercise, and I don't think there's anything that says whether multiple rethrows of copies of the same exception_ptr object throw distinct copies of the underlying exception. The implication of "if rethrow_exception rethrows the same exception object (rather than a copy)..." is that either is allowed. In practice, I don't think it matters much; catching an exception by reference and modifying its contents is just plain weird, and that's pretty much the only way you'd run into varying behavior depending on whether the exception is copied.

Pete Becker Over a year ago

I agree, but there are two separate questions here: first, whether two calls to current_exception get pointers that refer to distinct objects; second, whether rethrow_exception copies the exception object. In both cases, I think the answer is that it's unspecified.

Howard Hinnant Over a year ago

Pete is correct. rethrow_exception is allowed but not required to throw a copy of the exception. The Itanium ABI provides no capability to make a copy of the exception at this point. Several vendors follow this ABI including gcc/Linux and Apple. IIRC, Microsoft does make a copy at rethrow_exception, but I'm less sure of this latter statement. In any event, both approaches are conforming.

|

Collectives™ on Stack Overflow

Can exceptions be "duplicated" via exception pointers?

1 Answer 1

9 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

9 Comments

Your Answer

Sign up or log in

Post as a guest

Related