What Is Code Optimization in C?
Code optimization means modifying source code or using compiler features so that a program performs its required operations more efficiently.
For example, consider:
int result;
result = 10 * 20;
The calculation does not depend on any runtime input. A compiler can determine that the result is 200 during compilation instead of performing the multiplication every time the code executes.
Another example is an unnecessary calculation inside a loop:
for (int i = 0; i < 1000; i++)
{
result = value * 60;
process(result);
}
If value does not change during the loop, the multiplication can be moved outside it:
result = value * 60;
for (int i = 0; i < 1000; i++)
{
process(result);
}
The second version avoids performing the same calculation repeatedly.
The important point is that optimization should preserve the program’s required behavior. Faster code is not useful if it introduces incorrect results or makes the software unnecessarily difficult to maintain.
Code Optimization Techniques in C
There is no single optimization technique that is best for every C program. The right approach depends on the compiler, processor, application, and performance problem.
Here are some practical techniques.
1. Reduce Unnecessary Calculations
Repeated calculations can increase execution time, particularly when they occur inside frequently executed loops.
Instead of:
for (int i = 0; i < 100; i++)
{
result = width * height;
process(result);
}
Calculate the value once when width and height do not change:
result = width * height;
for (int i = 0; i < 100; i++)
{
process(result);
}
This is especially useful when the calculation is relatively expensive or the loop executes many times.
2. Optimize Loops
Loops are common places to look when profiling shows that a program spends significant execution time there.
For example:
for (int i = 0; i < 1000; i++)
{
array[i] = array[i] * factor;
}
The code is already relatively simple, but unnecessary work inside the loop should be avoided.
For example, if a value does not change:
for (int i = 0; i < 1000; i++)
{
array[i] = array[i] * constant_value;
}
There is no need to repeatedly calculate or retrieve that constant through a more expensive operation.
Avoid Unnecessary Work Inside Loops
A useful rule is:
If something does not depend on the loop iteration, consider whether it can be moved outside the loop.
However, do not blindly rewrite every loop. Modern compilers can perform many loop optimizations themselves.
3. Avoid Unnecessary Function Calls
Function calls have some overhead, although the actual cost depends on the compiler, architecture, optimization level, calling convention, and whether the compiler can inline the function.
For example:
for (int i = 0; i < 1000; i++)
{
result += calculate_value(i);
}
If calculate_value() is very small and performance profiling shows that the call overhead matters, compiler optimization such as function inlining may help.
A compiler may transform a small function call into equivalent code at the call site.
However, manually replacing every function with duplicated code is generally not a good optimization strategy. It can increase code size and reduce maintainability.
4. Choose Appropriate Data Types
Selecting a suitable data type can affect memory usage and sometimes performance.
For example:
int temperature;
If the application only needs a small non-negative range, another integer type might be sufficient depending on the platform and requirements.
In embedded systems, developers often pay close attention to the size and representation of data because RAM and Flash may be limited.
However, smaller does not always mean faster.
On some processors, operations using the processor’s natural word size may be more efficient than operations involving smaller types. Therefore, data types should be selected based on:
- Required numerical range
- Signedness
- Memory requirements
- Processor architecture
- Alignment
- Performance requirements
Do not change every int to uint8_t simply because it uses fewer bytes. Measure the result on the target system.
5. Avoid Unnecessary Data Copying
Copying large arrays or structures can consume CPU time and memory bandwidth.
For example:
struct SensorData data1;
struct SensorData data2;
data2 = data1;
This may be perfectly reasonable when a copy is actually required. But if the function only needs to read the data, passing a pointer to constant data can sometimes avoid an unnecessary copy:
void process_data(const struct SensorData *data)
{
/* Read data */
}
Then:
process_data(&data1);
This technique is particularly relevant when working with large structures or buffers.
6. Use const Where Appropriate
The const keyword tells the compiler and other developers that an object should not be modified through a particular access path.
For example:
void print_data(const char *message)
{
/* message is not modified */
}
Using const improves code clarity and can help the compiler reason about certain parts of a program.
However, const should not be treated as a guaranteed performance optimization. Its primary purpose is expressing and enforcing intended immutability.
7. Use static Appropriately
static has several meanings in C depending on where it is used.
For a function:
static void calculate(void)
{
}
The function has internal linkage within that translation unit.
For a file-scope variable:
static int counter;
The variable also has internal linkage.
For a local variable:
void function(void)
{
static int count;
count++;
}
The variable retains its value between function calls.
Using static correctly can improve program organization and sometimes provide the compiler with useful information, but it should not be added simply as a performance trick.
8. Reduce Unnecessary Memory Access
Memory access can be expensive relative to operations performed directly in registers, depending on the processor and memory hierarchy.
For example, repeatedly accessing the same value through memory may sometimes be avoided by storing it in a local variable:
int value = sensor_data;
for (int i = 0; i < 100; i++)
{
process(value);
}
Modern optimizing compilers are often capable of performing similar transformations automatically.
This is why optimization should be guided by generated code and measurements rather than assumptions.
9. Use Bitwise Operations Carefully
Bitwise operations are common in embedded C because hardware registers and packed flags frequently use individual bits.
For example:
status |= (1U << 3);
This sets bit 3 of status.
To clear it:
status &= ~(1U << 3);
To test it:
if (status & (1U << 3))
{
/* Bit is set */
}
Bitwise operations are useful for register manipulation, flags, masks, and compact data representation.
However, replacing ordinary arithmetic with bitwise operations does not automatically make code faster. Modern compilers can often optimize simple arithmetic very effectively.
Use bitwise operations when they make sense for the data representation or hardware being controlled.
10. Avoid Repeated String Operations
String processing can become expensive when operations repeatedly scan the same data.
For example:
for (int i = 0; i < strlen(buffer); i++)
{
process(buffer[i]);
}
Calling strlen() repeatedly may result in repeated scanning because the string length is calculated by searching for the terminating null character.
A simple alternative is:
size_t length = strlen(buffer);
for (size_t i = 0; i < length; i++)
{
process(buffer[i]);
}
This avoids repeatedly calculating the length.
11. Reduce Unnecessary Branching
Conditional logic can sometimes affect performance, particularly in heavily executed code.
For example:
if (condition)
{
result = value1;
}
else
{
result = value2;
}
This is normally clear and perfectly acceptable.
Do not automatically replace readable conditions with complicated expressions simply to remove a branch. Modern processors and compilers have sophisticated optimization techniques, and a complicated manual transformation may actually make the generated code worse.
Optimize branches when profiling identifies them as a meaningful bottleneck.
12. Avoid Premature Optimization
One of the most important code optimization techniques is knowing when not to optimize.
A program that is difficult to read, test, and maintain can become more expensive to develop even if it runs slightly faster.
A better approach is:
- Write correct and maintainable code.
- Measure the application’s performance.
- Identify the actual bottleneck.
- Optimize the relevant section.
- Test the optimized version.
- Measure again.
This approach avoids spending time optimizing code that has little effect on overall performance.
Compiler Optimization in C
Compiler optimization is different from manually optimizing source code.
A C compiler can analyze the program and generate machine code that performs the same required operations more efficiently.
Common compiler optimization levels include options such as:
The exact behavior and available options depend on the compiler.
For GCC and compatible toolchains, for example:
gcc -O2 program.c -o program
What Do Optimization Levels Do?
The general idea is:
| Optimization | General Purpose |
|---|
-O0 | Little or no optimization; useful for debugging |
-O1 | Basic optimization |
-O2 | More extensive optimization without generally pursuing every possible speed trade-off |
-O3 | More aggressive optimization, potentially increasing code size |
-Os | Optimization focused on reducing code size |
These descriptions are intentionally general because exact transformations depend on the compiler version, target architecture, language features, and compilation options.
Compiler optimization can perform transformations such as:
- Constant folding
- Dead-code elimination
- Function inlining
- Common subexpression elimination
- Loop transformations
- Register allocation
- Strength reduction
- Code motion
What Is Constant Folding?
Constant folding evaluates expressions whose values are known during compilation.
For example:
int x = 10 * 20;
The compiler can determine that the result is 200 before the program runs.
This means the runtime calculation may not be necessary.
What Is Dead-Code Elimination?
Dead code is code whose result has no effect on the observable behavior of the program.
For example:
int result = calculate();
result = 100;
If the first calculation has no required side effects and its result is immediately overwritten, an optimizing compiler may be able to remove it.
What Is Function Inlining?
Instead of generating a normal function call, the compiler may replace a small function call with the function’s body.
For example:
static int square(int x)
{
return x * x;
}
Used as:
int result = square(value);
The compiler may generate code equivalent to:
int result = value * value;
Inlining can reduce function-call overhead, but excessive inlining can increase code size.
Embedded C Code Optimization Techniques
Optimization becomes particularly important in embedded systems because the target hardware may have limited resources.
Important goals can include:
- Lower CPU usage
- Smaller Flash/code size
- Lower RAM usage
- Faster interrupt handling
- Lower power consumption
- Meeting real-time deadlines
- Efficient peripheral access
- Predictable execution
Optimize Interrupt Service Routines
Interrupt Service Routines, or ISRs, should generally perform only the work that must happen immediately.
Instead of performing a large amount of processing inside an ISR:
void UART_IRQHandler(void)
{
/* Large processing operation */
/* Complex calculations */
/* Long loops */
}
a common design is to capture the required event or data and defer heavier processing:
void UART_IRQHandler(void)
{
received_data = UART_READ();
data_ready = 1;
}
The main application can then process the data later.
This can help reduce interrupt latency and make system timing easier to manage.
Optimize RAM Usage
Embedded devices may have significantly less RAM than desktop systems.
Potential techniques include:
- Avoiding unnecessarily large buffers
- Choosing suitable data types
- Reusing buffers where safe
- Avoiding unnecessary structure duplication
- Storing constant data in appropriate memory
- Checking stack usage
- Avoiding unnecessary dynamic allocation
Memory optimization should always consider the target architecture and linker configuration.
Reduce Flash Usage
Large lookup tables, duplicated functions, strings, and unnecessary libraries can increase program size.
Possible approaches include:
- Removing unused code
- Avoiding unnecessary library functionality
- Using compiler and linker dead-code removal
- Sharing common functions
- Storing constant data efficiently
- Selecting suitable compiler options
The exact techniques depend heavily on the embedded toolchain.
Be Careful With volatile
volatile is important when an object can change outside the normal flow assumed by the compiler, such as certain memory-mapped hardware registers or variables modified by an interrupt in appropriate designs.
Example:
volatile uint32_t status_register;
However, volatile should not be added simply to “make the compiler safer.”
It tells the compiler that accesses to the object are significant and should not be optimized away in the usual manner.
Using volatile unnecessarily can prevent useful optimizations.
Code Optimization Examples
Here are several simple examples of optimization opportunities in C.
Example 1: Repeated Calculation
Before
for (int i = 0; i < 1000; i++)
{
result[i] = width * height + i;
}
After
int area = width * height;
for (int i = 0; i < 1000; i++)
{
result[i] = area + i;
}
The multiplication is performed once instead of repeatedly.
Example 2: Repeated strlen()
Before
for (size_t i = 0; i < strlen(buffer); i++)
{
process(buffer[i]);
}
After
size_t length = strlen(buffer);
for (size_t i = 0; i < length; i++)
{
process(buffer[i]);
}
The second version avoids recalculating the string length on every iteration.
Example 3: Avoiding an Unnecessary Structure Copy
Before
void process(struct SensorData data)
{
read_sensor(&data);
}
Passing the structure by value can require a copy depending on the ABI and compiler.
If the function only needs to read the structure:
void process(const struct SensorData *data)
{
/* Read data */
}
Then:
process(&sensor_data);
This can avoid copying a large structure.
The correct approach depends on whether the function needs to modify or own a separate copy of the data.
Example 4: Embedded Bit Manipulation
To set a hardware-control flag:
control_reg |= (1U << 5);
To clear it:
control_reg &= ~(1U << 5);
To check it:
if (control_reg & (1U << 5))
{
/* Bit is set */
}
This style is common when working with microcontroller registers and bit fields.
Source-Code Optimization vs Compiler Optimization
These two concepts are related but not identical.
| Aspect | Source-Code Optimization | Compiler Optimization |
|---|
| Performed by | Developer | Compiler |
| Example | Removing unnecessary calculations | Constant folding |
| Visibility | Usually visible in source code | Often visible in generated assembly |
| Main goal | Improve algorithm/resource usage | Generate efficient machine code |
| Dependency | Programmer’s implementation | Compiler and target architecture |
| Measurement | Profiling and testing | Compiler output and benchmarking |
A good development process often uses both.
For example, replacing an inefficient algorithm can produce a much larger improvement than manually changing a few arithmetic expressions. After that, compiler optimization can further improve the generated machine code.
How to Optimize C Code Effectively
A practical optimization workflow is:
Step 1: Establish a Baseline
Measure the original program.
Depending on the application, measure:
- Execution time
- CPU utilization
- RAM usage
- Flash/code size
- Power consumption
- Interrupt latency
Step 2: Find the Bottleneck
Use appropriate tools such as:
- Profilers
- Debuggers
- Performance counters
- Hardware trace tools
- Compiler-generated assembly
- Map files for embedded projects
Step 3: Optimize the Actual Bottleneck
Do not optimize random parts of the program simply because they look inefficient.
Step 4: Test Functionality
Optimization must not change required program behavior.
Pay particular attention to:
- Integer overflow
- Signed/unsigned conversions
- Pointer access
- Array boundaries
- Timing assumptions
- Concurrency and interrupts
- Undefined behavior
Step 5: Measure Again
Compare the optimized version with the baseline.
If the change does not provide a meaningful improvement, keeping the simpler implementation may be the better engineering decision.
What Should You Optimize First in C?
A useful order is:
- Algorithm and data structure
- Major memory and I/O operations
- Frequently executed code
- Loops and repeated calculations
- Memory usage
- Function-call or branching overhead where measurements justify it
- Low-level instruction-level optimizations
This order matters because a better algorithm can provide a much larger improvement than manually optimizing individual instructions.
Conclusion
Effective code optimization techniques in C are not about making every line of code as complicated or low-level as possible. The better approach is to identify where the program actually spends its time or resources and then make targeted improvements.
Start with the algorithm and overall design, then look at repeated calculations, loops, memory access, data copying, and code size. For embedded C, also consider interrupt latency, RAM, Flash, power consumption, and timing requirements.
Compiler optimization should be part of the process as well. Options such as -O2 or -O3 can perform many transformations automatically, but their effect should be measured rather than assumed.
The most reliable optimization process is simple: measure, identify the bottleneck, optimize, test, and measure again.
