# Re-engineering loops for efficiency (i)

When it comes to program efficiency, most times people tend to ignore it. I mean computers get faster all the time, so inefficiencies in a program will eventually dissipate, right? One of the more interesting area for efficiency is loops. Why? Because loops more often than not are used to process large pieces of data, like images. Sometimes it is the language being used that is inherently inefficient when it comes to loops – prime example? Python.

### Loop Fusion

The best way of cutting down the amount of time spent in loops is to decrease the number of loops, hence decreasing overhead associated with incrementing indexes and testing. This is termed loop fusion, jamming, or merging. For example, consider the following two loops, each of which initializes an array:

```int a[1000], b[1000], i, j;
for (i=0; i<1000; i=i+1)
a[i] = 0;
for (i=0; i<1000; i=i+1)
b[i] = 0;```

These loops involve 2000 index increases and tests. This can be reduced by half by merging the loops:

```int a[1000], b[1000], i;

for (i=0; i<1000; i=i+1){
a[i] = 0;
b[i] = 0;
}```

### LOOP PEELING

Loop peeling (or loop splitting) attempts to simplify a loop or eliminate dependencies by breaking a loop into multiple loops that have the same bodies but iterate over different contiguous portions of the index range. A useful special case is simplifying a loop with a problematic first (or first few) iteration by performing that iteration separately before entering the loop. Here is an example of loop peeling. Suppose the original code looks like this:

```int vector[100], r[100], i;
for (i=0; i<1000; i=i+1){
r[i] = vector[i-1] * vector[i];
}```

The problem here is the fact that the loop can not safely handle the case of vector[i-1] when i = 0, for the index becomes -1, which is illegal. A better solution would be to peel the first iteration off:

```int vector[100], r[100], i;
r[0] = vector[0];
for (i=1; i<1000; i=i+1){
r[i] = vector[i-1] * vector[i];
}```