Could wrapping a loop in a try-catch block cause performance problems?

Question

In a game or some other application where an infinite loop would be used, could wrapping the loop in a try-catch block be a detriment to performance?

Something like this:

auto main() -> int{
    game::init();

    try{
        while(1){
            some_func();
            some_other_func();

            if(breaking_func())
                break;

            something_that_could_throw(); // unlikely, though

            draw();
            swap_buffers();
        }
    }
    catch(const std::exception &err){
        // do error handling
    }

    game::cleanup();
}

I tagged gcc, but any other compilers would also be applicable.

Have you tried benchmarking the code or anything to see what happens? — Ricky Mutschlechner, Jul 24 '15 at 16:14
@RickyMutschlechner not possible right now, but I will when I get the chance — RamblingMad, Jul 24 '15 at 16:14
@CoffeeandCode: Why is it "not possible right now"? You should take the time to do it _before asking us_. If that means you have to wait a while, then so be it. :) — Lightness Races in Orbit, Jul 24 '15 at 16:26
@LightnessRacesinOrbit because I'm not at home and I'm interested — RamblingMad, Jul 24 '15 at 16:26
@NathanOliver yeah, I was going about to close as a duplicate of that. — RamblingMad, Jul 24 '15 at 16:27
@CoffeeandCode: At the risk of sounding rude, that's not really our problem.. — Lightness Races in Orbit, Jul 24 '15 at 16:27
-1 No research effort has been shown. Question does not add to the repository or present additional value to the kinship. — Lightness Races in Orbit, Jul 24 '15 at 16:28
@CoffeeandCode The answer to that question answers yours too (even though the question is slightly different). — Walter, Jul 24 '15 at 16:30

πάντα ῥεῖ · Accepted Answer · 2015-07-24T17:09:17.213

1

Well, wrapping the loop in a try {} catch() {} block, will give you a small performance hit when the try {} block is entered, but not for execution of the individual iterations in the loop.

Vs. a non wrapped version, entering the try { } block requires the compiler to emit some additional instructions to be able entering the defined catch() {} blocks coming after. These additional instructions will have a (very small) performance difference vs. an unwrapped loop.

Even, if the try {} catch() {} would be applied to the inner part of the loop, the overhead for installing the catch() {} block entry points will be applied only once, and not for individual iterations.

edited Jul 24 '15 at 17:09

answered Jul 24 '15 at 16:20

πάντα ῥεῖ

1
13
116
190

2

Can you elaborate on that? Why does entering the `try` block incur a performance hit and why is there none for the execution of the loop? – Walter Jul 24 '15 at 16:25
@Walter Because some entry point(s) for the `catch() {}` blocks for stack unwinding in case of thrown exceptions need to be installed. – πάντα ῥεῖ Jul 24 '15 at 16:34
I agree with @Walter; this answer could do with some fleshing out. – Lightness Races in Orbit Jul 24 '15 at 16:57
@LightnessRacesinOrbit Giving the best from my nexus10 ;-) ... – πάντα ῥεῖ Jul 24 '15 at 17:10

Could wrapping a loop in a try-catch block cause performance problems?

1 Answers1