__inline__ is a non-standard extension. Typically, it tells the compiler: "inline this function", but being a non-standard extension we can't say with certainty unless we know which compiler this is on.
To inline is to remove the function call and place it's contents directly where the call would be made. This often removes the overhead of calling a function. It is not always optimal, because of code bloat (code getting too big and not fitting into cache), so most compilers will ignore all inline directives and do what they feel is best. This is a good thing. We humans are very poor at that kind of stuff, and it's usually considered bad practice to tell the compiler how to do its job.
Inlining is an important optimization, especially with the presence of helper functions. Imagine a function that returned the smaller of two ints:
int min(int x, int y)
{
return (x < y) ? x : y;
}
If I used this function in my code, it would be an enormous waste of time to actually make a function call, here. If I had:
int a = /* some calculation */;
int b = /* some other calculation */;
int minCalc = min(a, b);
And the compiler inlined that function, the code would become:
int a = /* some calculation */;
int b = /* some other calculation */;
int minCalc = (a < b) ? a : b;
Which removes the overhead of calling a function. From here, even more optimizations can be made as the compiler gets to work directly with the code that would have normally been hidden behind a function call. As you can see, if I have a big function and I force the compiler to inline it everywhere, the code size could grow very large very fast, and would actually hinder execution speed.
There is a standard inline keyword which was used to indicate to the compiler a function should be inlined, but nowadays most compilers don't even acknowledge it as a hint to inline the function.
There is an important side-effect of inline, though, and this can be useful. If a function is marked as inline, multiple definitions of the same function across multiple translation units is not an error. Instead, a single function definition is selected and the others are thrown out, and assumed to be the same (it's up to you to make sure this is actually okay!). This allows you to define a function within a header file without risking ODR violation errors.
