**SUMMARY**

Here’s a way to make sure you’re optimizing the writing of your code with an example in Fortran. It’s a neat, non-obvious trick to an engineer, but may be more obvious to a computer scientist. It involves the writing of a do loop where you are updating your value for an array, and instead of copying that array into a temporary variable, you simply use the programming logic to continue to use that information (location in memory) during every other time step. I was able to get 25% better performance for this simple change (and it scales). Not clear yet? Let me show you.

**BACKGROUND**

I’m a mediocre Fortran programmer but I’m learning new tricks with practice, challenges, and going to professor office hours. Taking Scientific Computing and High Performance Computing Systems right now is really increasing the strength of my programming skills. I hope to be an intermediate Fortran programmer by the end of the semester. Below is a sample from a code I wrote for a recent class project. The goal of the project was not to write a sequential version, so I feel comfortable posting a piece of the serial version.

**CODE DESCRIPTION**

The user is stepping in time from igen to gmax, calculating the neighbor value (‘naybs’) of a cell in the array ‘pop.’ Then, it updates the value of the cell in the array ‘pop’ for the next time step based on the neighbor values. But it does this update in ‘buffer,’ unnecessarily copying the data back to the array ‘pop.’ In this way, the loop proceeds without conflict. This works, but you may be sacrificing performance without even realizing it. I wrote EXAMPLE 1 below and then my instructor said “BUT WHY NOT DO IT BETTER?” and I went back to my computer and coded EXAMPLE 2.

**EXAMPLE 1: Original Code**

do igen = 1, gmax
naybs = 0
buffer = 0
! This loop finds neighbor values
do j = 2, y_limit + 1
do i = 2, x_limit +1
naybs(i,j) = pop(i-1,j-1) + pop(i,j-1) + pop(i+1,j-1)+ &
pop(i-1,j ) + pop(i+1,j )+ &
pop(i-1,j+1) + pop(i,j+1) + pop(i+1,j+1)
! Birth
if (pop(i,j)==0 .and. naybs(i,j)==3) then
buffer(i,j)=1
! Survival
else if (pop(i,j)==1 .and. &
(naybs(i,j)==2 .or. naybs(i,j)==3)) then
buffer(i,j)=1
! Death
else
buffer(i,j)=0
end if
pop(i,j) = buffer(i,j)
end do
end do
end do

**EXAMPLE 2: Improved Code**

do igen = 1, gmax
naybs = 0
if (mod(igen,2)==1) then
! This loop finds neighbor values
do j = 2, y_limit + 1
do i = 2, x_limit +1
naybs(i,j) = pop(i-1,j-1) + pop(i,j-1) + pop(i+1,j-1)+ &
pop(i-1,j ) + pop(i+1,j )+ &
pop(i-1,j+1) + pop(i,j+1) + pop(i+1,j+1)
! Birth
if (pop(i,j)==0 .and. naybs(i,j)==3) then
buffer(i,j)=1
! Survival
else if (pop(i,j)==1 .and. &
(naybs(i,j)==2 .or. naybs(i,j)==3)) then
buffer(i,j)=1
! Death
else
buffer(i,j)=0
end if
end do
end do
else if (mod(igen,2)==0) then
! This loop finds neighbor values
do j = 2, y_limit + 1
do i = 2, x_limit +1
naybs(i,j)=buffer(i-1,j-1)+buffer(i,j-1)+buffer(i+1,j-1)+ &
buffer(i-1,j ) +buffer(i+1,j )+ &
buffer(i-1,j+1)+buffer(i,j+1)+buffer(i+1,j+1)
! Birth
if (buffer(i,j)==0 .and. naybs(i,j)==3) then
pop(i,j)=1
! Survival
else if (buffer(i,j)==1 .and. &
(naybs(i,j)==2 .or. naybs(i,j)==3)) then
pop(i,j)=1
! Death
else
pop(i,j)=0
end if
end do
end do
end if
end do

I will say that you do have to write more code, but if that’s your hang-up, then you might not be very interested in performance in the first place.

More importantly, note the logic here. What I’m doing is identifying which time step is odd or even (by computing the mod of each time step), and then based on that result, I will update the next time step with a value from another grid. As far as I know, this can be done more elegantly in C by switching pointers. I don’t even know how to yet use pointers effectively in Fortran, so that might be possible here too. That would then give you the performance you desire, and the brevity that everyone likes. This result did increase my performance by 25%, which is dramatic if you are in the scientific computing world.

I note that this may be obvious to others, and they might even think that I made it harder on myself in the first place by doing something silly (which I did), but remember that I was *taught* this by *multiple* people, *multiple* times. Once I started to get an understanding of how data is held in memory, I started to make more advanced strides in programming. Hope this helps!