C Programming Optimizing Code For Performance And Size Complete Guide

Example 1: Simple Loop Optimization

Problem Statement: Optimize a loop that calculates the sum of an array.

Naïve Approach:

#include <stdio.h>

int main() {
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int sum = 0;
    for (int i = 0; i < 10; i++) {
        sum += arr[i];
    }
    printf("Sum: %d\n", sum);
    return 0;
}

Optimized Approach: Reduce the overhead caused by accessing the array's size in every iteration.

#include <stdio.h>

int main() {
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int sum = 0;
    int n = sizeof(arr) / sizeof(arr[0]);  // Calculate the number of elements
    for (int i = 0; i < n; i++) {            // Use a pre-calculated size
        sum += arr[i];
    }
    printf("Sum: %d\n", sum);
    return 0;
}

Example 2: Inline Functions

Problem Statement: Optimize function calls by reducing overhead.

Naïve Approach:

#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

int main() {
    int a = 5, b = 10, c;
    c = add(a, b);
    printf("Sum: %d\n", c);
    return 0;
}

Optimized Approach: Use inline keyword to suggest to the compiler to embed the function directly into the caller.

#include <stdio.h>

inline int add(int a, int b) { // Suggest inlining
    return a + b;
}

int main() {
    int a = 5, b = 10, c;
    c = add(a, b);
    printf("Sum: %d\n", c);
    return 0;
}

Example 3: Efficient Use of Bitwise Operations

Problem Statement: Optimize the multiplication of an integer by a power of two.

Naïve Approach:

#include <stdio.h>

int main() {
    int num = 5;
    int result = num * 8;
    printf("Result: %d\n", result);
    return 0;
}

Optimized Approach: Use bitwise left shift.

#include <stdio.h>

int main() {
    int num = 5;
    int result = num << 3;  // Shifting left by 3 is equivalent to multiplying by 8
    printf("Result: %d\n", result);
    return 0;
}

Example 4: Minimize Stack Usage

Problem Statement: Reduce the stack size usage of recursive functions.

Naïve Approach:

#include <stdio.h>

void recursiveFunction(int n) {
    if (n == 0) return;
    printf("%d\n", n);
    recursiveFunction(n - 1);
}

int main() {
    recursiveFunction(1000);
    return 0;
}

Optimized Approach: Use an iterative approach.

#include <stdio.h>

void iterativeFunction(int n) {
    for (int i = n; i > 0; i--) {
        printf("%d\n", i);
    }
}

int main() {
    iterativeFunction(1000);
    return 0;
}

Example 5: Optimize Memory Usage

Problem Statement: Minimize memory usage while storing a large array of 0s and 1s.

Naïve Approach:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = (int*)malloc(1000 * sizeof(int));  // 4 bytes per element
    for (int i = 0; i < 1000; i++) {
        arr[i] = 0;
    }
    free(arr);
    return 0;
}

Optimized Approach: Use a bit array.

#include <stdio.h>
#include <stdlib.h>

void setBit(unsigned char *arr, int pos) {
    arr[pos / 8] |= (1 << (pos % 8));
}

int getBit(unsigned char *arr, int pos) {
    return (arr[pos / 8] & (1 << (pos % 8))) != 0;
}

int main() {
    unsigned char *arr = (unsigned char*)calloc((1000 + 7) / 8, sizeof(unsigned char));  // 1 bit per element
    for (int i = 0; i < 1000; i++) {
        setBit(arr, i, 0);
    }
    free(arr);
    return 0;
}

Example 6: Compiler Flags for Optimization

Problem Statement: Use compiler flags to optimize code.

Naïve Approach: Compile with default flags: gcc -o program program.c

Optimized Approach: Compile with optimization flag: gcc -O2 -o program program.c or gcc -O3 -o program program.c

Wrapping Up

• Loop Unrolling: Manually unroll loops to reduce control overhead.
• Avoid Expensive Operations: Minimize the use of floating-point arithmetic and function calls inside loops.
• Profile Your Code: Use tools like gprof to identify bottlenecks.
• Use Efficient Libraries: Leverage optimized math and standard libraries.