I made a few tests with this code: http://pastebin.com/7k0Gj8qf (i use the standard output to output the time because on CodinGame i don't really have the choice).
I tested this code in Onboarding puzzle. The output is around 200ms (you can test it). If you add
#pragma GCC optimize "-O3" at the start of the code, the output is around 5ms.
On my computer, if i try the both codes (with and without the pragma) with this compilation:
g++ code.cpp -o code.exe -std=c++11
I got the same times. And i also got the same times if i had a -g flag, i got the same times too. But now if i run it with gdb (simple gdb command like
gdb code.exe), i got 520ms for the first code (without the pragma) and 325ms for the second code (with the pragma directive). Adding the -g flag doesn't change anything. I got also the same results if i compile with -O3 flag.
I don't know how you can run a C++ code with gdb without losing almost any time. But i'll be glad to learn it.
For codingame, i don't think the code is really running with gdb. The code performance is really too different. It would be impossible to do a puzzle like Nintendo with gdb. The code would be far too slow.
But for codingame you can test it easily: Just make 2 codes. One with an inline function and a second one without it (just copy/paste the function content) and see how the both codes are doing. An inline function is supposed to have no impact on a code speed (if you are using it properly, of course), but on CodinGame it does.
The -g flag can impact performances. But it depends of the compiler. gcc have a -g3 option to avoid that. It is not used by CodinGame but it's not a big problem.
My code is pretty simple, so the pragma directive act the same as a the -O3 flag. With a bigger code you'll see some differences. Now see this 2 codes:
If you try this 2 codes on Onboarding puzzle, the first one take around 28ms. The second one takes less than 0.001ms. If you remove the -O3 pragma directive, the first one take around 45ms and the second one take around 5ms.
But according to the C++ documentation and specifications, an inlined function (with reference parameters and const values) does not impact the performances. And a vector has the less overhead possible. But try to run this code on your computer with the -O3 flag at the compilation (not with the pragma directive). On my computer i got 5ms for the first code and less than 0.001ms for the second code.
The problem on CodinGame is the lack of -O3 at the compilation. Without it, you can't use classes and function without impacting the speed of your code. It always leads to bad pratices to keep your code fast (like i explained in my previous post)