a.  su into root.

       b.  Create a ~/.rpmmacros file containing:

       %_topdir %(echo $HOME)/rpmbuild

      %_smp_mflags -j3

      %__arch_install_post /usr/lib/rpm/check-rpaths /usr/lib/rpm/check-buildroot

      %_default_patch_fuzz 2

      #end of file

      fuzz=2 is critical to allow the 915 patches to merge correctly.

_smp_mflags -jN, N should be set to the number of processor cores on your build system

2.  Setup and do initial build.  Download the kernel source from a source repository:

(Used http://repo.moblin.org/moblin/releases/2.1/source/kernel-2.6.31.5-10.1.moblin2.src.rpm)

       a.  Extract the rpm:

       $ rpm -ivh kernel-2.6.31.5-10.1.moblin2.src.rpm

       b. Prepare and do initial build to rpm:

       $ cd rpmbuild/SPECS

       c. Remove lines 762 & 763, 'BuildKernel %make_target %kernel_image menlow' & 'BuildKernel %make_target %kernel_image ivi'

       $ rpmbuild -bc --target=i586 kernel.spec

       The previous step ensures you have the components to build successfully.

3.  Rebuild with gcc:

       $ cd rpmbuild/BUILD/kernel-2.6.31/linux-2.6.31

       $ make clean

       $ make bzImage

       $ make modules

       $ make modules_install

       $ make install 

      Test the image on your netbook by rebooting the system and selecting the kernel at the grub screen.

Rebuild with Intel Compiler

1.  Perform step 1 in the previous section

2.  Setup Intel Compiler environment:

       a.  Set the compiler environment:

       $ source /opt/intel/Compiler/11.1/XXX/bin/ia32/iccvars_ia32.sh

       where XXX is the particular version you are using.

3.  Make source code modifications.

      a.  Modify include/linux/compiler-intel.h and add the following line at

the end of the file:

       #undef __compiler_offsetof

       b.  Modify arch/x86/include/asm/xor_32.h at line 843, change

       : "+r" (lines),

       To:

       : "+rm" (lines),

       This change is required because the code is written to work with gcc's assumption that the stack is 16 byte aligned (contrary to the ABI) and thus there is one additional register available.

c.  Add libirc_s.a to the link command by modifying Makefile at line 699.  Change:

       --start-group $(vmlinux-main) --end-group

       to:

       --start-group $(vmlinux-main) /opt/intel/Compiler/11.1/XXX/lib/ia32/libirc_s.a

--end-group

       d.  Modify arch/x86/include/asm/delay.h and remove the references to __bad_udelay and replace the calls to it with 0.

       e.  Modify include/linux/log2.h and remove the references to ____ilog2_NaN() and replace the calls to it with 0.

       f.  Modify line 47 of arch/x86/kernel/acpi/realmode/Makefile adding a reference to libirc_s.a as follows:
        WAKEUP_OBJS = $(addprefix $(obj)/,$(wakeup-y)) /opt/intel/Compiler/11.1/053/lib/ia32/libirc_s.a

        g.  Modify line 89 of arch/x86/boot/Makefile adding a reference to libirc_s.a as follows:
SETUP_OBJS = $(addprefix $(obj)/,$(setup-y)) /opt/intel/Compiler/11.1/053/lib/ia32/libirc_s.a

        h. Modify kernel/trace/trace_events.c by adding the following line of code (line 915) at the start of event_create_dir():
        if (call->system==NULL) return -1;
This change is due to a kernel issue where the source code makes alignment assumptions that are not enforced in the kernel source code.  This change is merely a workaround, not a fix for the real issue.

        i.  Modify the intelwrapper file documented at www.linuxdna.com and make the following changes:
          - Enable script to replace -march=i686 | -mtune=pentium3 | -mtune=generic with ‘'
          - Enable script to replace -O2 | -Os with ‘-O3 -ip -xSSE3_ATOM'
            Performance BKM: The goal of this option change is to enable higher performance.  Note that the default kernel options uses things such as -mnosse and -fno-omit-frame-pointer which can override the higher optimizations in some places.
          - Enable script to call gcc to compile drivers/net/wimax/i2400m/fw.c | lib/libcrc32c* | crypto/testmgr* - this is required because 11.1 does not yet support some instances of variable length arrays
          - Enable script to call gcc to compile arch/x86/boot/compressed/misc.c - issue with PIC in icc
          - Enable script to call gcc to compile drivers/block/spectra/ffsport.c - inline asm issue

4.  Start the build:

       $ cd <build path>/rpmbuild/BUILD/kernel-2.6.31/linux-2.6.31

       $ make clean

       $ make HOSTCC=intelwrapper CC=intelwrapper CONFIG_DEBUG_SECTION_MISMATCH=y KBUILD_MODPOST_WARN=n bzImage

       $ make HOSTCC=intelwrapper CC=intelwrapper CONFIG_DEBUG_SECTION_MISMATCH=y KBUILD_MODPOST_WARN=n modules

       $ make HOSTCC=intelwrapper CC=intelwrapper CONFIG_DEBUG_SECTION_MISMATCH=y KBUILD_MODPOST_WARN=n modules_install

       $ make HOSTCC=intelwrapper CC=intelwrapper CONFIG_DEBUG_SECTION_MISMATCH=y KBUILD_MODPOST_WARN=n install

The make install step will install the kernel and modify grub so that the kernel can be selected upon bootup.

Use cache blocking to arrange a loop so it will perform as many computations as possible on data already residing in cache. (The next block of data is not read into cache until computations using the first block are finished.)

The loop blocking optimization is part of HLO phase in Intel compiler and is available when using compiler option -O3. The compiler uses default heuristics for loop blocking. But you may also use /Qopt-block-factor:n in Windows or -opt-block-factor:n in Linux to specify loop blocking factor.

Data reuse:

Data reuse is important to understand blocking. There are two types of data reuse associated with loop blocking:

• Spatial reuse
• Temporal reuse

Spatial reuse

Spatial reuse uses data that was encached as a result of fetching another piece of data from memory. The data is fetched one cache lines at a time. This is 64 bytes for Intel(R) Core2 processors. If the requested data is located at the beginning of the cache line (aligned data), and the rest of the cache line contains subsequent array elements then for float array, this means the requested element and the seven following elements are cached on each fetch after the first. If any of these seven elements could then be used on any subsequent iterations of the loop, the loop would be exploiting spatial reuse. For loops with strides greater than one, spatial reuse can still occur. However, the cache lines contain fewer usable elements.

Temporal reuse

Temporal reuse uses the same data item in more than one iteration of the loop. If the loop uses the same element in subsequent loop iterations then loop exhibits temporal reuse in the context of the loop. The blocking exploits spatial reuse by ensuring that once fetched, cache lines are not overwritten until their spatial reuse is exhausted.

Example 1: Simple Loop Blocking

The following example demonstrates the simple loop blocking. The loop blocking allows arrays A and B to be blocked into smaller rectangular chunks so that the total combined size of two blocked (A and B) chunks is smaller than cache size, which can improve data reuse.

// before_loopblocking.cpp

/*

* icl /Qoption,link,"/STACK:1000000000" before_loopblocking.cpp

*/

#include <time.h>

#include <stdio.h>

#define MAX 8000

void add(int a[][MAX], int b[][MAX]);

int main()

{

int i, j;

int A[MAX][MAX];

int B[MAX][MAX];

clock_t before, after;

//Initialize array

for(i=0;i<MAX;i++)

{

for(j=0;j<MAX; j++)

{

A[i][j]=j;

B[i][j]=j;

}

}

before = clock();

add(A, B);

add(A, B);

add(A, B);

add(A, B);

after = clock();

printf("\nTime taken to complete : %7.2lf secs\n", (float)(after - before)/ CLOCKS_PER_SEC); //List time taken to complete add function

}

void add(int a[][MAX], int b[][MAX])

{

int i, j;

for(i=0;i<MAX;i++)

{

for(j=0; j<MAX;j++)

{

a[i][j] = a[i][j] + b[j][i]; //Adds two matrices

}

}

}

The above code is modified below to enhance reuse of the cached data:

// after_loopblocking.cpp

/*

* icl /Qoption,link,"/STACK:1000000000" after_loopblocking.cpp

*/

#include <stdio.h>

#include <time.h>

#define MAX 8000

#define BS 16 //Block size is selected as the loop-blocking factor.

void add(int a[][MAX], int b[][MAX]);

int main()

{

int i, j;

int A[MAX][MAX];

int B[MAX][MAX];

clock_t before, after;

//Initialize array

for(i=0;i<MAX;i++)

{

for(j=0;j<MAX; j++)

{

A[i][j]=j;

B[i][j]=j;

}

}

before = clock();

add(A, B);

add(A, B);

add(A, B);

add(A, B);

after = clock();

printf("\nTime taken to complete : %7.2lf secs\n", (float)(after - before)/ CLOCKS_PER_SEC); //List time taken to complete add function

}

void add(int a[][MAX], int b[][MAX])

{

int i, j, ii, jj;

for(i=0;i<MAX;i+=BS)

{

for(j=0; j<MAX;j+=BS)

{

for(ii=i; ii<i+BS; ii++)//outer loop

{

for(jj=j; jj<j+BS; jj++)

{

//Array B experiences one cache miss

//for every iteration of outer loop

a[ii][jj] = a[ii][jj] + b[jj][ii]; }

}

}

}

}

Example 2: Complex Blocking

// matrixMul.cpp

/*

* icl /Qoption,link,"/STACK:1000000000" matrixMul.cpp

*/

#include <stdio.h>

#include <time.h>

#define MAX 800

void matmul(int c[][MAX], int a[][MAX], int b[][MAX]);

int main()

{

int i, j;

int A[MAX][MAX];

int B[MAX][MAX];

int C[MAX][MAX];

clock_t before, after;

//Initialize array

for(i=0;i<MAX;i++)

{

for(j=0;j<MAX; j++)

{

A[i][j]=j;

B[i][j]=j;

}

}

before = clock();

matmul(C, A, B);

after = clock();

printf("\nTime taken to complete : %7.2lf secs\n", (float)(after - before)/ CLOCKS_PER_SEC); //List time taken to complete add function

}

void matmul(int c[][MAX], int a[][MAX], int b[][MAX])

{

int i, j, k;

for(i=0;i<MAX;i++)

{

for(j=0; j<MAX;j++)

{

for(k=0; k < MAX; k++)

{

c[i][j] = c[i][j] + a[i][k] * b[k][j];

}

}

}

}

The above code is modified below to enhance spatial and temporal reuse of the cached data for array a, b and c:

// matrixMulBlk.cpp

/*

* icl /Qoption,link,"/STACK:1000000000" matrixMulBlk.cpp

*/

#include <stdio.h>

#include <time.h>

#define MAX 800

#define BS 16 //Block size is selected as the loop-blocking factor.

void matmul(int c[][MAX], int a[][MAX], int b[][MAX]);

int main()

{

int i, j;

int A[MAX][MAX];

int B[MAX][MAX];

int C[MAX][MAX];

clock_t before, after;

//Initialize array

for(i=0;i<MAX;i++)

{

for(j=0;j<MAX; j++)

{

A[i][j]=j;

B[i][j]=j;

}

}

before = clock();

matmul(C, A, B);

after = clock();

printf("\nTime taken to complete : %7.2lf secs\n", (float)(after - before)/ CLOCKS_PER_SEC); //List time taken to complete add function

}

void matmul(int c[][MAX], int a[][MAX], int b[][MAX])

{

int i, j, k, jj, kk;

for(j=0;j<MAX; j += BS)

{

for(k=0; k<MAX; k += BS)

{

for(i=0; i < MAX; i++)

{

for(kk=k; kk<k+BS; kk++)

{

for(jj=j; jj<j+BS; jj++)

{

c[i][jj] = (c[i][jj] + a[i][kk] * b[kk][jj]);

}

}

}

}

}

}