You might be surprised. Unrolling the follwing naive loop:

x = 0;
for(int a = 0; a<READ_UNROLL_BLOCKSIZE; a++)
{
x += p[a];
}

To the following:
int a;
x = 0;

// we will use 16-fold unroll
int blockLimit = READ_UNROLL_BLOCKSIZE & ~15;
for(a = 0; a < blockLimit; a+=16)
{
x += p[a + 0];
x += p[a + 1];
x += p[a + 2];
x += p[a + 3];
x += p[a + 4];
x += p[a + 5];
x += p[a + 6];
x += p[a + 7];
x += p[a + 8];
x += p[a + 9];
x += p[a + 10];
x += p[a + 11];
x += p[a + 12];
x += p[a + 13];
x += p[a + 14];
x += p[a + 15];
}

// process the remaining reads
for (a = blockLimit; a < READ_UNROLL_BLOCKSIZE;)
{
x += p[a++];
}
results in a significant perf increase. If we run the routine several million times to get a nice sample wed see numbers like this:

Running : Loop Unroll Read
Running unoptimized version
Elapsed time [6.33] seconds
Running optimized version
Elapsed time [3.17] seconds

During the unrolled loop we do 16 read operations before we hit the conditional. This allows the processor to do a lot more pipelining. Unrolling more than 16-fold appears to result in negligible further improvement however.