Thread: how to make sure g++ will not inline this?

see this:

Code:

class Series
{
	int from, to, delta;
public:
	Gamma(int f, int t, int d)
	{
		from = f;
		to = t;
		delta = d;
	}
	
	void run() const
	{
		for (int f=from; f!=to; f+=delta)
		{
			cout << "Stepping: " << f << endl;
		}
	}
};

I wrote the code in this way because it's more convenient. Will now G++ make the functions inline? Can I avoid this?

It will only suggest the compiler to inline it but it may discard this suggestion as it judges better.

It's better to break up definition and implementation for several reasons...
Plus there's no real easy way to tell a compiler not to inline. It inlines at its own discretion, if it thinks your program might benefit from it.

There is simple ways to avoid inlining. There are no sure-fire ways to ensure that something is inlined.

The don't inline this way is to put the function in a different source file. Or call it through a function pointer. Or use some compiler option to say "don't inline".

If you want the best chance of something being inlined:
1. Make sure the function is visible to the compiler - which usually means put it in a header file.
2. Keep it short.
3. Make sure it's not called from too many places.
4. Don't take the address of the function (as in using it with a function pointer).
5. Don't put static variables in the function.

gcc/g++ is actually very good at inlining even large functions, as long as they are only called from a few places - even really big functions can be inlined in this case.

--
Mats

Most modern compilers (such as gcc and MS VC++) in default settings completely ignore "inline" as a keyword when it comes to what to inline and what to not inline. I know MSVC has a switch to say "inline by inline keyword only", but it's not the default setting.

However, if you put functions in a header file, they should be marked static, or part of a class.

--
Mats

Originally Posted by manav

see this:

Code:

class Series
{
	int from, to, delta;
public:
	Gamma(int f, int t, int d)
	{
		from = f;
		to = t;
		delta = t;
	}
	
	void run() const
	{
		for (int f=from; f!=to; f+=delta)
		{
			cout << "Stepping: " << f << endl;
		}
	}
};

I wrote the code in this way because it's more convenient. Will now G++ make the functions inline? Can I avoid this?

You obviously have a misunderstanding. Inlining will in no way screw up your program, only your bugs will do that. In this case it looks to me like your bug is here:

Code:

		delta = t;

shouldn't that be d instead of t!

You also aren't using initialisation lists, but you should learn to do that.

Does it really matter? What's so horrible about inlining?

Can I safely assume that if a function is small, it will be inlined if defined this way.
But if the function is not so small then g++ will not inline, even when defined in the way I have shown??

Read the GCC docs on optimization (or how not to optimize).

And I just want to make sure that I will get a function when I wrote a function and not a compiler decided macro.
But, for really small functions it is ok for me.

An inline function is not a macro. Besides small functions, inlining is also good if the function is only called a few times*.

EDIT:
* Then again, maybe not, if it is called from a complex function. But yeah, that's why I rely on the compiler to decide if it likes my suggestion of inlining or not.

I'm with iMalc here - I think you have some sort of misconceptions about inlining.

Correct use of inlining [which to a large extent is enforced by the compiler] leads to compact and efficient code.

Obviously, excessive inlining can be bad, and calling tiny functions (like getters and setters) often cause bigger code than inlining the function, e.g.

Code:

class X
{
   int x;
public:
   void setx(int _x) { x = _x }
};

Inlined, this would be one mov instruction, without, it will be at the very least three instructions (call, mov, ret), but more likely five or six (mov, push, call, mov, ret, cleanup) [cleanup is either an add instruction or a pop instruction].

In bytes, the simple three instruciton case will take up 5 bytes per call to setx(), whilst the inline mov instruction takes 3 bytes or so [it may be 5, but then that should really be compared to the longer sequence, which again takes up nearly around a dozen bytes].

--
Mats

Originally Posted by manav

Mats: Yeah, but this holds only if the function is called just once or may be twice or even thrice, may be!
Inline the function will always save a few instructions, like saving registers, getting parameters from stack, clearing stack etc.
But I think inline will be useless if the function happens to be called more than once!

It doesn't make much difference what the data type is - a double passed will be (fld, fst) inlined, and (sub sp, fld, fst, call, fld, fst, ret, add sp) as a direct call - so it's still a 5 instructions EXTRA for the call compared to the inlined version.

--
Mats