C++ Performance with/without "cout"

Question

Hello guys and girls.

My question is simple one but I have no answer. Below you can see my C++ code - it is a little bit big but simple - when I run the code with //std::cout<<yy<<endl; (commented) it run less than 1 second, when I un-comment that line it runs about 2 minutes (I speak about Release because in Debug it run more time). Please pay attention that that line produce only few output lines (so the problem is not that the program have to call "cout" too many times) Thank you all. Here is my code:

#include <cstdlib>
#include <iostream>

using namespace std;

struct cell {
    int x;
    int y;
};

int main(int argc, char** argv) {
    cell vector[8];
    unsigned long int yy=0;

    for (int aaa = 0; aaa < 8; aaa++) {
        vector[0].x = aaa;
        for (int aab = 0; aab < 8; aab++) {
            vector[0].y = aab;
            for (int aac = 0; aac < 8; aac++) {
                vector[1].x = aac;
                for (int aad = 0; aad < 8; aad++) {
                    vector[1].y = aad;
                    for (int aae = 0; aae < 8; aae++) {
                        vector[2].x = aae;
                        for (int aaf = 0; aaf < 8; aaf++) {
                            vector[2].y = aaf;
                            for (int aag = 0; aag < 8; aag++) {
                                vector[3].x = aag;
                                for (int aah = 0; aah < 8; aah++) {
                                    vector[3].y = aah;
                                    for (int aai = 0; aai < 8; aai++) {
                                        vector[4].x = aai;
                                        for (int aaj = 0; aaj < 8; aaj++) {
                                            vector[4].y = aaj;
                                            for (int aak = 0; aak < 8; aak++) {
                                                vector[5].x = aak;
                                                for (int aal = 0; aal < 8; aal++) {
                                                    vector[5].y = aal;
                                                                    yy++;
                                                                    if(yy%10000000000==0){
                                                                    vector[5].y = aal-1;
                                                                    //std::cout<<yy<<endl;
                                                                    }

                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    std::cout<<yy<<endl;
    std::cout<<vector[5].y<<endl;
    return 0;
}

Ow my gosh, how did you even have the patience to write these nested loops???! — ForceBru, Sep 06 '17 at 16:00
`iostreams` are pretty well known to be slow. Try to remove output from the loop - accumulate data somewhere and print it as one shot.. — Slava, Sep 06 '17 at 16:01
probably branch prediction in the if works differently when there is more than just assignment inside. — Artemy Vysotsky, Sep 06 '17 at 16:02
[Why is std::cout so time consuming?](https://stackoverflow.com/q/43051948/995714), [Why is istream/ostream slow](https://stackoverflow.com/q/18688763/995714), [Does cout statement makes code slower](https://stackoverflow.com/q/14573424/995714) — phuclv, Sep 06 '17 at 16:04
This happens because your loops do nothing but that `cout` and can be completely removed by the compiler without it. https://godbolt.org/g/b8JCSr — Baum mit Augen, Sep 06 '17 at 16:04
the "cout" in the loop is called 6 times - so it can not be the problem of a such big difference - 1 sec and more that 1 min. — Sergiu Velescu, Sep 06 '17 at 16:06
Also, I would *strongly* advice against this kind of code generation, you are most likely attacking an XY-problem. — Baum mit Augen, Sep 06 '17 at 16:06
@SergiuVelescu The 68719476736 extra loop iterations is what makes the difference. — Baum mit Augen, Sep 06 '17 at 16:07
I can't reproduce 1 sec result with VS2017. I have no patience to wait till the program exits (even when cout is commented out) — Artemy Vysotsky, Sep 06 '17 at 16:09
@ArtemyVysotsky Try clang. It basically gets compiled to `int main () {std::cout << 68719476736 << '\n' << 7 << '\n';}`. — Baum mit Augen, Sep 06 '17 at 16:10
@ Baum mit Augen - at the moment - yes - the code does nothing useful, just output the yy value (6 times), but why without these 6 cout it run so fast, (or why with 6 cout it run so slow)? — Sergiu Velescu, Sep 06 '17 at 16:11
@SergiuVelescu Click the link in my first comment and see for yourself. — Baum mit Augen, Sep 06 '17 at 16:12
@ Baum mit Augen - I am not assembler expert but i will analyze that - thanks. — Sergiu Velescu, Sep 06 '17 at 16:26
Calling `std::ios::sync_with_stdio(false);` should speed things up somewhat but `std::cout` is a blocking output and its speed is largely determined by the output device it is connected to. Often that is a terminal emulator that spends a lot of time shuffling text and memory around as it scrolls its output display. — Galik, Sep 06 '17 at 17:32

Jerry Coffin · Accepted Answer · 2017-09-06T16:12:31.290

2

Most of this is a simple matter of optimization: as long as you don't produce any output from the loops, the compiler determines that the loops are basically dead code, and simply doesn't execute them at all. It has to do a little bit of pre-computation to determine the value that vector[5].y would have following the loops, but it can do that entirely at compile time, so at run-time, it's basically just printing out a fixed number.

When you produce visible output inside the loops, the compiler can't just eliminate executing them, so the code runs dramatically slower.

edited Sep 06 '17 at 16:12

answered Sep 06 '17 at 16:07

Jerry Coffin

437,173
71
570
1,035

@LưuVĩnhPhúc: Looking more carefully, that was a red herring. – Jerry Coffin Sep 06 '17 at 16:14
Ok - I thought about this - what about "vector[5].y = aal-1;" in the loop - doesn't this force the compiler to run these loops and calculate the value? (at the end I COUT this value also) – Sergiu Velescu Sep 06 '17 at 16:16
It looks like the loops are running as when I comment one loop it takes 160ms to finish, if I un-comment it takes around 1 sec. – Sergiu Velescu Sep 06 '17 at 16:23
Looks like part of the loop is still there https://godbolt.org/g/WZDvrC . Perhaps the real story is that with all the cruft eliminated, the actual looping isn't too computationally expensive. – Mikhail Sep 06 '17 at 16:25
Some compilers may do this more aggressively than others. Clang removes all the loops, the code runs in .004s on my PC, gcc leaves some of them in and runs around .8s. Either way, the take-home message from this should be "Only profile meaningful code, and just putting stuff in a huge loop is not a proper microbenchmark." – Baum mit Augen Sep 06 '17 at 16:28

C++ Performance with/without "cout"

1 Answers1