CODEWITHSUNDEEP
cembedded
Joe Vince
Joe Vince

Reputation: 355

Advantage of #define instead of creating a function in embedded

Recently I got to view an embedded code in that they are using 

#define print() printf("hello world")

instead of 

void print() { printf("hello world"); }

My question what is the gain on using #define instead of creating a function?

Upvotes: 5

Views: 1785

Answers (3)

doron
doron

Reputation: 28872

Sometimes you want to stub out functionality at compile time. Macros give you an easy way to do this.

Upvotes: 3

Lundin
Lundin

Reputation: 213690

There is no advantage. Using #define like this is quite ancient C programming style.

In the year 1999, the C language got the inline keyword to make all such macros obsolete. And with modern compilers, inline is often superfluous too, since the compiler is nowadays better than the programmer when it comes to determining when to inline.

Some of the embedded compilers out can still be rather bad at such optimizations though, and that's why embedded C code tends to lag behind in modernization.

In general, doing micro-optimizations like this is called "pre-mature optimizations", meaning the programmer is meddling with optimizations that they should leave to the compiler. Even in hard real time systems. Optimizations should only be the last resort when you have 1) detected an actual bottleneck, and 2) disassembled to see if manual inlining actually does anything good for performance.

Upvotes: 5

4386427
4386427

Reputation: 44274

It may be related to performance.

A function call has some overhead (i.e. calling, saving things on the stack, returning, etc) while a macro is a direct substitution of the macro name with it's contents (i.e. no overhead).

In this example the functions foo and bar does exactly the same. foo uses a macro while bar uses a function call.

enter image description here

As you can see bar and printY together requires more instructions than foo .

So by using a macro the performance got a little better.

But... there are downsides to this approach:

  • Macros are hard to debug as you can't single step a macro

  • Extensive use of a macro increases the size of the binary (compared to using function call). Something that can impact performance in a negative direction.

Also notice that modern compilers (with optimization on) are really good at figuring out when it's a good idea to automatically inline a function (i.e. your code is written with a function call but the compiler decides to inline the function as if it was a macro). So you might get the same performance using function call.

Further, you can use the inline key word as a hint to the compiler that you think it will be good to inline a function. But even with that keyword the compiler may decide not to inline. The only way to make sure that the code gets inline, is by using a macro.

Upvotes: 13

Related Questions