Code optimization for size in C++

The techniques you have tried won't reduce your code size at all, some of them make your code even bigger.

- Inline functions: Are a tool to make your code faster and generally make your code bigger!

- Virtual functions: Have nothing to do with code size.

- Unused variable removal: Don't reduce your code size and the compiler will probably take care of them anyway.

- Moving local variables to the inner most scope: Has nothing to do with code size.

So what should you try? First of all you should analyze your code and see where the big chunks are. Take a linker listing and see what uses up most of your code size. Then work on those things.

If your code is big, because you have tens of thousands of functions, there is not much you can do except to try to find out common functionality and restructure your code accordingly.

In general there are two big issues that can potentially blow up your code:

1. The libraries you are using -- you don't have much influence there.

2. Usage of templates: This can blow up your code significantly if not done properly.

Also check whether you are still building in debug mode, instead of production mode. The debug information that the compiler adds can make your code several times bigger!

Good luck.

Quote:

-> Inline Functions

Bad: inline functions explicitly increase code size to the benefit of performances due to less stack manipulation required.

Quote:

-> Virtual Functions

No impact at best, actually it increases the code size a bit due to the virtual tables needing space.

Quote:

-> Unused variables removal

Unless they are statics it does not change code size but the memory footprint of the application when running. Good but not for what you want to achieve.

Quote:

-> Moving local variables to the inner most scope

What for? A variable declaration does not increase code size, only memory footprint. Inside a function ALL the variables are memorized in the stack. At best, with very specialized compilers, you earn a stack address reuse to minimize runtime memory footprint.

To minimize code size you should:
* Eliminate all unneeded static libraries.
* Reduce the call paths and the number of intermediate objects in the hierarchy.
* If possible, with functions having multiple signatures, using only a single one of them in order to not have the other variants linked at compile time. Careful: a single missed function will add its variant to the linked file.
* See if your cross platform framework has options (usually in form of #defines) to eliminate most of th marshalling and intermediate calls when compiled for a specific MCU. Cross platform frameworks are great but they do increase code size.
* Eliminate any huge library like boost, which is fantastic but bloated.

These are my 2 cents,
Denis

The fattest issue are normally resources like bitmaps or strings, but you didnt mention them. Did you use frameworks like libraries?

The next level is to use the compiler and linker for smaller size like with removing unused functions. Enhance the output in the build process.

Check that it is not a debug build or with some excessive diagnosis tool. My top tip ;-)

Then think about data size like having big buffers or structs. Always work with pointers and the smallest data size.

Take a look at the suggestions here: pts.blog: How to make smaller C and C++ binaries[^]

Quote:

But these techniques have helped us in improving performance rather than size, we need size reduction!

Difficult to tell without seeing code.
General technique to reduce binary size
- Remove code duplicates: find code duplicates or almost duplicates and see how you can reduce the number of duplicates.
Example: you have a bubble sort and an insertion sort, chances are that a single subroutine can do the job.
- Ensure the code is efficient.

General technique to reduce runtime size
- When handling arrays, try to avoid intermediate copies of the arrays when possible.

Code optimizing is almost a job by itself, hiring a specialist can be your solution.