12

I have already read a lot about C++ exceptions and what i see, that especially exceptions performance is a hard topic. I even tried to look under the g++'s hood to see how exceptions are represented in assembly.

I'm a C programmer, because I prefer low level languages. Some time ago I decided to use C++ over C because with small cost it can make my life much easier (classes over structures, templates etc.).

Returning back to my question, as I see exceptions do generate overhead bud only when they occur, because it require a long sequence of jumps and comparisons instructions to find a appropriate exception handler. In normal program execution (where is no error) exceptions overhead equals to normal return code checking. Am I right?

Merlyn Morgan-Graham
  • 58,163
  • 16
  • 128
  • 183
Goofy
  • 5,187
  • 5
  • 40
  • 56

2 Answers2

14

Please see my detailed response to a similar question here.

Exception handling overhead is platform specific and depends on the OS, the compiler, and the CPU architecture you're running on.

For Visual Studio, Windows, and x86, there is a cost even when exceptions are not thrown. The compiler generates additional code to keep track of the current "scope" which is later used to determine what destructors to call and where to start searching for exception filters and handlers. Scope changes are triggered by try blocks and the creation of objects with destructors.

For Visual Studio, Windows, and x86-64, the cost is essentially zero when exceptions are not thrown. The x86-64 ABI has a much stricter protocol around exception handling than x86, and the OS does a lot of heavy lifting, so the program itself does not need to keep track of as much information in order to handle exceptions.

When exceptions occur, the cost is significant, which is why they should only happen in truly exceptional cases. Handling exceptions on x86-64 is more expensive than on x86, because the architecture is optimized for the more common case of exceptions not happening.

Community
  • 1
  • 1
Chris Schmich
  • 29,128
  • 5
  • 77
  • 94
  • I know it's been 3 years, but is there very little overhead on Linux x86-64 as well? – contrapsych May 15 '13 at 23:37
  • 1
    @JAKE6459 I can't answer definitively, but one of the benefits of x86-64 over x86 is the way in which exceptions are supported, and I'm sure Linux takes advantage of this. As always, if you really need to know, profile your code. If you're using C/C++ on Linux, look into `gprof`. – Chris Schmich May 16 '13 at 00:43
  • Can you honestly say that code compiled with exceptions turned off is not measurably faster? – John McFarlane Oct 07 '15 at 14:33
4

Here's a detailed review of the cost of the exception handling when no exceptions are actually thrown:

http://www.nwcpp.org/old/Meetings/2006/10.html

In general, in every function that uses exception handling (has either try/catch blocks or automatic objects with destructor) - the compiler generates some extra prolog/epilog code to deal with the expcetion registration record.

Plus after every automatic object is constructed and destructed - a few more assembler commands are added (adjust the exception registration record).

In addition some optimizations may be disabled. Especially this is the case when you work in the so-called "asynchronous" exception handling model.

kevinarpe
  • 20,319
  • 26
  • 127
  • 154
valdo
  • 12,632
  • 2
  • 37
  • 67