// Include std::memset
#include

// Include std::size_t
#include

std:.size_t const N = ????;

typedef int elem_t;
elem_t A[ N ][ N ];

// Set all elements of A to 1 to optimize away one add operation per loop.
// Though it has been a long time that I used memset and the following line needs to be tested if this is the way memset works…
std::memset( A, 1, N * N * sizeof( elem_t ) );

The rest just in words:
Initialize the array with 1 to safe N*N add-operations.

Save the 2*i value in a const before entering the j-loop to save re-calculating it N times.
Perhaps try i lesser-than lesser-than 1 (shift-op) instead of 2*i but a good compiler would optimize multiplying by 2 by itself.

Good night.

I’ve placed my source code and makefile at http://www.plover.com/~mjd/misc/c/matrix-opt.tgz .

for (i = 0; i < N; i++) {
a[i][0] = 2*i + 1;
for (j = 1; j < N; j++) {
A[i][j] = A[i][j - 1] + 3;
}
}
}

Since the “if” test is only to distinguish the special case of j=0,
we can eliminate it by moving that case out of the loop.

In that case, I’d suggest that because of the way it’s written, the reference to A[i][j-1] is forcing the CPU to wait until the write to it in the previous iteration is complete before it can read from it again. Presumably gcc spots that it can just use a temp instead and hoists it, but the Intel compiler doesn’t.

Does replacing the section of code with:

int temp = 2*i + 1;
if( i == 0 ) {
A[i][j] = temp;
} else {
temp = temp + 3;
A[i][j] = temp;
}

improve matters? (I know the code is still clunky, but I’m trying to leave it as close to form 2 as possible.)

mov ebx, [i]
mov ecx, [j]
lea ebx, [2*ebx+ecx+1]
lea eax, [2*ecx+ebx]

leaves the value in eax. The loop indices can equally simply be hoisted into registers and incremented as a block; similarly, 2*i doesn’t change in advance either. It’s quite likely that the code could be compiled without any multiplications in it at all.

Following your suggestion, I was thinking how efficient the code would be when eliminating the unnecessary if clause like the following:

for (i = 0; i <N; i++) {
A[i][j] = 2 * i + 1;
for (j = 0; j <N; j++) {
A[i][j] = A[i][j - 1] + 3;
}
}

And then maybe taking it one step further and instead of referring back to the array for each assignment, keeping the previous value in a local variable:

for (i = 0; i <N; i++) {
val = 2 * i + 1;
A[i][j] = val;
for (j = 0; j <N; j++) {
val += 3;
A[i][j] = val;
}
}

Actually, the less branching you perform, the better it is, especially when you consider things like the optimisations done by the compiler and the processor.