What is Code Optimization?

Shilpa Prabhudesai

“Good developers write good code. Great developers reuse good code.”

In the software development process, code is much more than the instructions given to a computer; it forms the backbone of software applications, websites, and systems that drive our lives. However, not all codes are created equally. While some programs are fast, reliable, and resource-efficient, others may be sluggish, memory-consuming, or hard to maintain.

When these situations arise, we go for code optimization.

This article explores the concept of code optimization, why it is necessary, its advantages and disadvantages, and the various code optimization techniques that developers use.

Code Optimization – Definition and Importance

Code optimization is the process of improving a computer program to make it more efficient and effective.

Code optimization is an important phase in compiler design that aims to enhance the performance and efficiency of the executable code.

In code optimization, the program code is modified to improve its efficiency and performance, either by reducing its execution time, minimizing its resource (CPU, memory, power) consumption, or both, without changing its functionality.

Code optimization involves the various techniques and strategies applied during compilation to produce more efficient code without altering the program’s functionality. Developers and compilers use techniques like eliminating redundant code, improving algorithms, and using efficient data structures to achieve optimized code, which ultimately results in faster, smaller, and more resource-friendly programs.

The key principle of code optimization is to improve the program’s performance without changing its functionality or behavior.

Objectives of Code Optimization

The code optimization process must fulfill the following objectives:

• Speed: Code optimization should increase the speed and performance of the program, making the program run faster by reducing the total execution time.
• Resource Reduction: The Program should use fewer computer resources, such as:
  • Less CPU Time: Code takes less CPU time and executes faster.
  • Less Memory: The amount of memory consumed by a program is less.
  • Less Disk Space or Network Access: The program should use less disk space and network bandwidth.
  • Less Power Consumption: Power used should be less relevant in mobile devices and embedded systems.
• Maintainability: Improve the overall quality and readability of the code to make it manageable and readable.
• Scalability: Code should be able to handle growth in users, requests, or data without collapsing.
• Correctness: The optimization techniques used should not in any way change the meaning of the program.

Why Code Optimization Matters

Code optimization is important for the following reasons:

• User Experience: Speed is paramount in the digital landscape, and according to research, users are far more likely to abandon a slow website or application. Optimized code improves the responsiveness and performance of the application or website, which directly impacts customer experience and satisfaction.
• Resource Efficiency: Optimized code makes better use of resources, reducing the costs related to compute time and storage.
• Energy Savings: Code optimization reduces power consumption, especially in data centers, where it is a critical factor for sustainability and cost reduction.
• Scalability: A poorly optimized application is not scalable. It may work for 50 or 100 users, but it will crash if the number of users increases to thousands. An optimized system can scale to meet demand without frequent re-engineering.
• Maintainability and Longevity: Developers find maintaining, extending, and debugging readable and optimized code easier. This reduces the technical debt and the risk of future errors.

Types of Code Optimization

Code optimization in compiler design is broadly classified into two main types:

Machine-Independent Code Optimization

This type of optimization is performed on the intermediate representation of the code before the final machine code is generated. Machine-independent optimization improves the efficiency of code without considering the specific architecture of the target machine (hence, it is machine-independent).

Most of the compile-time code optimization techniques are of this type. These techniques mainly modify the code for optimization.

Machine-Dependent Code Optimization

This optimization is performed once the target machine code has been generated. The architecture and specific features of the target CPU are used for machine-dependent optimization to further enhance its performance.

As the name suggests, the optimization is performed on the machine. Examples of machine-dependent optimization techniques include:

• Register Allocation: Assigning variables to CPU registers to minimize memory access.
• Instruction Scheduling: Reordering instructions to improve pipeline utilization and reduce execution time.
• Peephole Optimization: Examining a small “code window” to replace inefficient sequences with more optimal ones.
• Memory Hierarchy Optimization: Optimizing code to make better use of caches and other memory levels.

Code Optimization Techniques

In this section, we will discuss various code optimization techniques. Most of the techniques are compile-time optimization techniques in which compilers make improvements during the build process.

Compile Time Evaluation

This technique involves evaluating variables and constants at compile-time. Compile-time evaluation consists of two techniques:

Constant Folding

In constant folding, as the name implies, the constants are folded. The expression containing one of the operands as a constant value at compile time is evaluated and replaced with the respective result.

circle_area = (22/7) x radius x radius;

In this example, the expression 22/7 is evaluated at compile time and then replaced with its result 3.14, which saves computation time at runtime.

Constant Propagation

The constant propagation technique acts on variables that are assigned constant values. It replaces such variables with their constant values during compilation, provided the value is not altered in between.

pi = 3.14;
radius = 10;
area_circle = pi x radius x radius;

In the above code, the variables ‘pi’ and ‘radius’ are substituted with their values at compile time so that the expression is area_circle = 3.14 x 10 x 10;

The expression is then directly replaced with its result = 314.

This saves computation time at run time.

Common Sub-Expression Elimination

As the name suggests, the common subexpressions are eliminated in this technique.

An expression that has already been computed before and reappears in the computation code is called a Common Sub-Expression.

The already computed result is used in the program instead of a repeated expression.

s1 = i x4;
s2 = a[s1];
s3 = j x 3;
s4 = 4 x i; // Redundant Expression
s5 = n;
s6 = a[s4] + s5;

In this code, the statements s1 = i x4; and s4 = 4 x i; generate the same results. Since s1 is already computed, s4 is the redundant expression.

Using elimination method, code is optimized by eliminating s4 and then replacing s4 by s1 in statement s6 = a[s4] + s5;

s1 = i x4;
s2 = a[s1];
s3 = j x 3;
s5 = n;
s6 = a[s1] + s5; //s4 replaced by s1

Dead Code Elimination

This technique removes the code that does not affect the program output. The dead code includes unused variables, unreachable code, non-executing statements, or statements that do not affect variable values.

Consider the following code snippets:

i = 0 ;

if (i == 1){
  a = x + 5 ;
}

i = 0 ;

In this example, the code block that follows i = 0 has no effect on the program and is never executed. Hence, eliminating this code block can optimize the code. The optimized code is shown in the second column of the table.

Code Movement

In the code movement optimization technique, the code is moved to its proper place to reduce the execution time or prevent it from being executed repeatedly, for example, in a loop.

for ( int j = 0 ; j < n ; j ++)
{
  x = y + z ;  //not part of the loop
  a[j] = 6 x j;
}

In this code snippet, the expression x = y + z; is not part of the loop construct. The variables, x, y, and z, are not part of the loop; hence, the entire expression can be moved out. This way, the expression is evaluated only once outside the for loop.

x = y + z ;

for ( int j = 0 ; j < n ; j ++)
{
  a[j] = 6 x j;
}

Strength Reduction

In the strength reduction optimization technique, expensive operations such as multiplication and division are replaced by less expensive ones, such as addition or bit shifting, where results are equivalent.

This reduced the strength of operations and thereby the cost.

For example, the expression b=a x 2; involves multiplication, which is an expensive operation.

Since multiplication is repeated addition, this operation can be replaced using the addition operator as b = a + a;

Inline Expansion

An inline expression optimization technique is also known as function inlining or inlining. In this technique, a function call is directly replaced with the actual body of the called function.

Inlining eliminates the overhead associated with a function call, such as saving and restoring registers, pushing arguments onto the stack, and jumping to and from the function code when the call is made and returned, respectively.

Programming languages such as C and C++ support inline functions.

int add(int x, int y) {
  return x + y;
}

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

inline int add(int x, int y) {
  return x + y;
}

int calculate_sum(int a, int b) {
  return a + b; // The body of 'add' is directly inserted
}

This removes the overhead of a separate function call to add (), potentially improving performance, especially for small, frequently called functions.

Loop Optimization

Code optimization that involves loops is critical. Loops are part of most programs, and optimizing loops to minimize the number of iterations or eliminate redundant calculations is important to improve performance and efficiency.

Loop optimization involves the following techniques:

• Code Motion / Loop Invariants: A Loop invariant is a piece of code inside the loop but is independent of the loop index and can be moved out so that it is computed only once. Loop invariant technique is the same as code movement.
  Consider the following example:

  // original code
  for (i=0; i<1000; i++)
  {
    loop_invar = 100*b[0]+15; //loop invariant independent of loop index
    a[i] = loop_invar +10*i;
  }
  
  // Optimized code
  loop_invar = 100*b[0]+15; // invariant out of the loop
  
  for (i=0; i<1000; i++)
  {
    a[i] = loop_invar +10*i; // loop executes fewer times
  }

• Loop Fusion: Sometimes, two or more loops can be combined into a single loop. This is called loop fusion, and it reduces the number of tests and increment instructions executed.
  Consider the following code:

  //Original Code having two for loops
  for (i=0; i<1000; i++)
  {
    a[i] = i;
  }
  
  for (i=0; i<1000; i++)
  {
    b[i] = i+5;
  }
  
  
  // one fused loop here
  for (i=0; i<1000; i++)
  {
    a[i] = i;
    b[i] = i+5;
  }

  In the original code above, the for loop has the same initialization condition, increment, and limit in both cases. Hence, it can be combined into one loop.
• Unswitching: This technique is the opposite of fusion. In it, the loop is split into two or more loops, of which only one needs to be executed at any time.
  The example of unswitching of loops is shown below:

  // Original Code
  for (i=0; i<1000; i++)
  {
    if (X>Y) // executed every time inside the loop
     a[i] = i;
    else
      b[i] = i+10;
  }
  
  // Optimized code: loop split in two here
  if (X>Y) // condition taken out; now executed only once
  {
    for (i=0; i<1000; i++)
    {
      a[i] = i;
    }
  }
  else
  {
    for (i=0; i<1000; i++)
    {
      b[i] = i+10;
    }
  }

  In the original code, the condition is tested inside the loop and executed for every iteration. By taking the condition statement out of the loop, computation time is saved as it is executed only once. This also enhances the code’s performance.
• Array Linearization: In this technique, a multidimensional array in a loop is handled as if it were a simple one-dimensional array. Most compilers store a multidimensional array in memory as a one-dimensional array using a linearization scheme.
  This same method can be used to access the array data like a big one-dimensional array. This is demonstrated in the code below:

  // nested loop
  // N = M = 20
  // total array size = NxM = 400
  for (i=0; i<20; i+=1)
  {
    for (j=0; j<20; j+=1)
    {
      // in most cases, linearization is straightforward
      a[i, j] = 0;
    }
  }
  
  // array linearized single loop
  for (i=0; i<400; i++)
    a[i] = 0; // same as previous with a single loop

• Loop Unrolling: Reducing the number of loop executions or completely eliminating the loop is called loop unrolling.
  Partial loop unrolling reduces the number of loop executions by performing the computations corresponding to two (or more) loop iterations in a single loop iteration.
  In full loop unrolling, the loop is completely eliminated, and all the iterations are performed explicitly in the code (when the number of iterations is fixed).
  Loop unrolling results in the loop executing fewer times, thus speeding up the computations.
  An example of loop unrolling is shown below:

  // Original code: "rolled" usual loop
  for (i=0; i<1000; i++)
  {
    a[i] = b[i]*c[i];
  } 
  
  // Optimized code: partially unrolled loop (half iterations)
  for (i=0; i<1000; i+=2)
  {
    a[i] = b[i]*c[i];
    // unroll the next iteration into the current one and
    // increase the loop iteration step to 2
    a[i+1] = b[i+1]*c[i+1];
  }

Register Allocation

This is a machine-dependent optimization technique. In this technique, variables are assigned to CPU registers for faster access, as registers are quicker to access than memory.

This technique efficiently utilizes hardware registers by storing frequently accessed variables and temporary values in registers instead of main memory.

Original Code:
a = 10
b = 20
c = a + b
d = 40
e = c * d

Intermediate Representation (before register allocation):
MOV a, R1
MOV b, R2
ADD R1, R2, T1 // T1 = a + b
MOV d, R3   // Assuming another temporary register is needed
MUL T1, R3, T2 // T2 = c * d

MOV a, R1
MOV b, R2
ADD R1, R2, R1      // R1 now holds 'c' (T1)
STORE R1, MEM[temp_c]  // Spill 'c' to memory
MOV d, R2        // R2 now holds 'd'
LOAD MEM[temp_c], R1  // Load 'c' back into R1
MUL R1, R2, R1    // R1 now holds 'e' (T2)

Peephole Optimization

This technique is performed on a minimal set of instructions in a code segment. This small set of instructions for optimization is called a peephole or window.

It basically works on the replacement theory, in which a part of code is replaced by shorter and faster code without a change in output. The peephole is a machine-dependent optimization. Using peephole optimization techniques, redundant instructions or code that has no effect in the peephole can be eliminated without changing the output.

Peephole optimization improves the overall program efficiency.

Advantages of Code Optimization

The following are various advantages offered by code optimization:

• Improved Performance: The application’s performance is significantly enhanced as the optimized code executes faster and more efficiently. This leads to quicker program execution and enhanced responsiveness.
• Reduced Resource Consumption: Optimization reduces memory usage, CPU cycles, and power consumption, and ensures optimal resource utilization.
  Smaller Code Size: Certain optimization techniques can reduce overall code size, which is beneficial for distribution and deployment.
  Enhanced Scalability: Code optimization increases systems’ scalability, as an optimized codebase is better equipped to handle large workloads and increased user demands without compromising performance.
• Better User Experience: Code optimization results in a more positive user experience with faster execution times and smoother operations.

Disadvantages of Code Optimization

Although the advantages of code optimization are numerous, there are also several disadvantages:

• Increased Compilation Time: When software projects are large and complex, the code optimization process may significantly extend the compilation time.
• Increased Code Complexity: Optimized code can become more intricate, less readable, more complex to debug, maintain, and understand.
• Potential for Introducing Bugs: Optimization can introduce subtle bugs, or code may behave weirdly if not performed correctly.
• Diminishing Returns: The resources and effort invested in code optimization may not always yield high performance, especially if the original code is already efficient enough.
• Platform Specificity: Code portability may be reduced if some optimization techniques highly depend on the target hardware or operating system.

Real-World Examples of Code Optimization

Here are some real-world examples of code optimization:

Best Practices for Code Optimization

Some of the best practices the developers should adopt for effective code optimization are:

• Measure Before Optimizing: Identify performance bottlenecks in the code by profiling before any optimizations.
• Focus on Algorithms First: Algorithm improvements are the fastest and most efficient way of optimizing. Consider algorithms and data structures that are inherently well-suited for the problem at hand, as this often yields the most significant performance gains.
• Keep Code Readable: Unless gaining performance is too critical, do not sacrifice code clarity.
• Optimize Iteratively: Perform small, incremental optimizations first and measure their impact. Then proceed to more.
• Minimize Resource Usage: Reduce memory footprint, I/O operations, and unnecessary computations to get better optimization results.
• Employ Modern Compiler and Tools: Modern compilers, interpreters, and tools provide powerful optimizations, so make use of them more often. Use compiler-specific flags to enable automatic optimizations during compilation.
• Document Optimizations: Make it a habit to document optimizations for future maintainers.
• Test Thoroughly: Test optimized code thoroughly to ensure functionality remains correct after changes.
• Consider Asynchronous Programming: Using asynchronous programming for I/O-bound or concurrent tasks can improve responsiveness.

The Future of Code Optimization

Some of the emerging trends in code optimization are:

• AI-driven Optimization: As AI and machine learning evolve, optimization also evolves as it uses more AI-driven optimization techniques.
• Cloud-based Analysis for Optimization: Cloud-based platforms analyze millions of executions to optimize code paths dynamically.
• Sustainable Optimization: As sustainability gains bigger focus, energy-aware, sustainable optimization is gaining ground as future software development may not only prioritize speed but also energy efficiency and carbon footprint.

Conclusion

Code optimization is more of an art than a science. It combines algorithmic theory with practical coding techniques and a deep understanding of hardware and software interactions. Knowing when and what to optimize can make the difference between sluggish applications and world-class products.

Finally, effective optimization is about striking a perfect balance between improving speed, memory usage, and scalability while maintaining good performance, scalability, and maintainability. Developers can master these principles to ensure that their programs are not only functional but also sustainable, efficient, and future-ready.