In what ways do C++ exceptions slow down code when there are no exceptions thown?

Question

I have read that there is some overhead to using C++ exceptions for exception handling as opposed to, say, checking return values. I'm only talking about overhead that is incurred when no exception is thrown. I'm also assuming that you would need to implement the code that actually checks the return value and does the appropriate thing, whatever would be the equivalent to what the catch block would have done. And, it's also not fair to compare code that throws exception objects with 45 state variables inside to code that returns a negative integer for every error.

I'm not trying to build a case for or against C++ exceptions solely based on which one might execute faster. I heard someone make the case recently that code using exceptions ought to run just as fast as code based on return codes, once you take into account all the extra bookkeeping code that would be needed to check the return values and handle the errors. What am I missing?

Answer 1

In .NET (if you are referring to C++/CLI), minimal overhead. As far as native C++, I would assume it's the same.

The overhead mainly comes from using exceptions as control logic, when an exception is thrown there is a higher cost than just checking for whatever would have thrown it to begin with.

Answer 2

Only try/catch and try/except block take a few instructions to set up. The overhead should generally be negligible in every case except the tighest loops. But you wouldn't normally use try/catch/except in an inner loop anyway.

I would advise not to worry about this, and use a profiler instead to optimize your code where needed.

Answer 3

It's completely implementation dependent but many recent implementations have very little or no performance overhead when exceptions aren't thrown. In fact you are right. Correctly checking return codes from all functions in code that doesn't use exceptions can be slower then doing nothing for code using exceptions.

Of course, you would need to measure the performance for your particular requirements to be sure.

Answer 4

There is a cost associated with exception handling on some platforms and with certain compilers.

Namely, Visual Studio, when building a 32-bit target, will register a handler in every function that has local variables with non-trivial destructor. Basically, it sets up a try/finally handler.

The other technique, employed by gcc and Visual Studio targeting 64-bits, only incurs overhead when an exception is thrown (the technique involves traversing the call stack and table lookup). In cases where exceptions are rarely thrown, this can actually lead to a more efficient code, as error codes don't have to be processed.

Answer 5

Nothing like actually trying the experiment:

#include <exception>

long int g_i1 = 0;
long int g_i2 = 0;

void noException() {
    g_i1 += 1;

    if (g_i1 < 0) {
    return;
    }
}

void withException() {
    g_i2 += 1;

    if (g_i2 < 0) {
        throw new std::exception();
    }
}

int main(void) {
    int i;

    for (i = 0; i < 100000000; i++) {
        // noException();
    withException();  
    }

    return 0;
}

When I had noException in the loop, my results were:

% time ./NoException
./NoException  0.53s user 0.00s system 94% cpu 0.566 total

When I had withException in the loop, my results were:

% time ./NoException
./NoException  0.97s user 0.00s system 96% cpu 1.003 total

Answer 6

There is some overhead with exceptions (as the other answers pointed out).

But you do not have much of a choice nowadays. Try do disable exceptions in your project, and make sure that ALL dependent code and libraries can compile and run without.

Do they work with exceptions disabled?

Lets assume they do! Then benchmark some cases, but note that you have to set a "disable exceptions" compile switch. Without that switch you still have the overhead - even if the code never throws exceptions.

Answer 7

Only overhead is ~6 instructions which add 2 SEH at the start of the function and leave them at the end. No matter how many try/catches you have in a thread it is always the same.

Also what is this about local variables? I hear people always complaining about them when using try/catch. I don't get it, because the deconstructors would eventually be called anyways. Also you shouldn't be letting an exception go up more then 1-3 calls.