Investigating the Performance Overhead of C++ Exceptions

Re:Investigating the Performance Overhead of C++ Exceptions by thedance on Tuesday February 11, 2020 @05:14PM (#22303531)

Thanks for holding the discussion to exact standards. What I meant about the base class constructors is the compiler must generate a derived-class constructor that can unwind the completely constructed base in case the derived class throws, not to mention the ability to destroy constructed subobjects with non-trivial destructors in case one of _their_ constructors throws. When your project decides to outlaw exceptions then none of these events are even possible and the compiler will generate a much more compact and infallible constructor.

As for leaving the scope, you're right again and I was unclear. The problem is you are destroying automatic objects while returning from a scope and one of them throws. Now you have extra code and extra branches for all of that. The extra ways of exiting a scope generally bloat up the program, and the size and complexity of a function can prevent it from being inlined or otherwise optimized by the compiler. These are systemic performance concerns that won't just show up as hot spots on a profile.

[ Parent | on HN ]

Re:Investigating the Performance Overhead of C++ Exceptions by AnimalMuppet on Tuesday February 11, 2020 @06:51PM (#22304270)

Ah, yes, I wasn't thinking about throws during destructors. IIRC, that's considered bad form but not forbidden, and so a compiler would have to handle that. (Feel free to correct if I have that wrong.)

As to your first paragraph: That's just calling the base class's destructor if the derived class's constructor throws. That's easy - that's what the base class's destructor is for. It's essentially one function call. The harder part (or so it seems to me) is correctly destroying the only-partially-constructed derived class.

[ Parent | on HN ]

Re:Investigating the Performance Overhead of C++ Exceptions by daemin on Wednesday February 12, 2020 @06:16AM (#22307875)

Throwing during destructors will generally result in a std::terminate, since you have good odds of throwing during destruction of an object that is being cleaned up as a result of an existing in progress exception.

So it is not forbidden but odds are you'll have your program terminate.

[ Parent | on HN ]

Re:Investigating the Performance Overhead of C++ Exceptions by ncmncm on Tuesday February 11, 2020 @07:31PM (#22304535)

The compiler has to handle it, but the Standard Library definitively doesn't.

[ Parent | on HN ]

Re:Investigating the Performance Overhead of C++ Exceptions by gpderetta on Tuesday February 11, 2020 @07:31PM (#22304538)

while there is extra code, there should be no extra branches in the successful case. The exceptional code path is reached during unwind by comparing the IP of the throwing call with a per stack frame table (recursively walking up the stack). Also the extra code will be extremely cold, at the limit not even paged in from disk (which of course might make the first time an exception is thrown an explicit path extremely costly)

[ Parent | on HN ]