Restricted Pointers are Coming

Figure 1: What possible compiler optimizations might look like if done by hand

#define N 1000
     
/* Kernel with hoisting of invariant done by hand. */
void 
with_hoisting( float * restrict a, float * restrict b, 
    int n, int j ) {

    float t0 = (b[j+N/4] + b[j-N/4]) * 0.5f; 
    int i; 
    for( i=0; i<n; ++i ) 
        a[i] = t0;
}
     
/* 
 * Kernel with software pipelining done by hand.
 * The optimal pipelining depends upon the target machine. 
 * The example here is only one such way.  
 * It's mighty peculiar to do it in this example 
 * since b[..] can be hoisted, 
 * but nonetheless at least one compiler did something 
 * similar to this. 
 */
void 
with_software_pipelining( float * restrict a, float * restrict b, 
    int n, int j ) {

    int i; 
    float t0, t1, t2, t3;
    if( 3 <= n ) {
        /* prologue for pipelined loop */
        t0 = b[j+(N/4)];        /* Part of iteration i=0 */ 
        t1 = b[j-(N/4)];        /* "    "  "         i=0 */
     
        t2 = t0 + t1;           /* "    "  "         i=0 */ 
        t0 = b[j+(N/4)];        /* "    "  "         i=1 */ 
        t1 = b[j-(N/4)];        /* "    "  "         i=1 */
     
        t3 = 0.5f * t2;         /* Part of iteration i=0 */ 
        t2 = t0 + t1;           /* "    "  "         i=1 */ 
        t0 = b[j+(N/4)];        /* "    "  "         i=2 */ 
        t1 = b[j-(N/4)];        /* "    "  "         i=2 */
     
        /* The pipelined loop */
        for( i=3; i<n; ++i ) {
            /* Next five statements could be evaluated 
               in single step. */ 
            a[i-3] = t3;
            t3 = 0.5f * t2;
            t2 = t0 + t1;
            t0 = b[j+(N/4)];
            t1 = b[j-(N/4)];
        }
     
        /* epilogue for pipelined loop */
        a[n-3] = t3;            /* Part of iteration i=n-3 */ 
        t3 = 0.5f * t2;         /* "    "  "         i=n-2 */ 
        t2 = t0 + t1;           /* "    "  "         i=n-1 */
     
        a[n-2] = t3;            /* "    "  "         i=n-2 */ 
        t3 = 0.5f * t2;         /* "    "  "         i=n-1 */
     
        a[n-1] = t3;            /* "    "  "         i=n-1 */
    } else {
        // Not enough iterations to pipeline the loop
        for( i=0; i<n; ++i ) 
            a[i] = (b[j+N/4] + b[j-N/4]) * 0.5f;
    }   
}