# Lab 7: SIMD Intrinsics and Unrolling

## Setup

Copy the directory ~cs61c/labs/07 to an appropriate location in your home directory.

Note that ALL code using SIMD must be compiled and run on the lab computers in SDH 200!
You can find the names of those machines here if you'd like to connect with them over SSH.

## Exercise 1: Familiarize Yourself

Given the large number of available SIMD intrinsics we want you to learn how to find the ones that you'll need in your application.

Here is a way to find the necessary information:

1. Go to Intel's website. This can also be found by Googling "intel intrinsic guide."
2. Under the "Getting Started" tab on the left, download the appropriate copy of the Intel Intrinsic Guide.

Do your best to interpret the new syntax and terminology. Fine the 128-bit intrinsics for the following SIMD operations:

• Four floating point divisions in single precision (i.e. float)
• Sixteen max operations over signed 8-bit integers (i.e. char)
• Arithmetic shifts right of eight signed 16-bit integers (i.e. short)

Checkoff: Record these intrinsics in a text file to show your GSI.

## Exercise 2: Reading SIMD Code

In this exercise you will consider the vectorization of 2-by-2 matrix multiplication in double precision: This accounts to the following arithmetic operations:

```    C += A*B + A*B;
C += A*B + A*B;
C += A*B + A*B;
C += A*B + A*B;
```

You are given the code sseTest.c that implements these operations in a SIMD manner.
The following intrinsics are used:

 __m128d _mm_loadu_pd( double *p ) returns vector (p, p) __m128d _mm_load1_pd( double *p ) returns vector (p, p) __m128d _mm_add_pd( __m128d a, __m128d b ) returns vector (a0+b0, a1+b1) __m128d _mm_mul_pd( __m128d a, __m128d b ) returns vector (a0b0, a1b1) void _mm_storeu_pd( double *p, __m128d a ) stores p=a0, p=a1
1. Compile the code using "gcc -g0 -O2 -S sseTest.c" to produce the assembly file sseTest.s. Note that you can compile the .s file into binary with "gcc -o sseTest sseTest.s" and then execute as usual.

The assembly output from gcc is in AT&T syntax, which has the following differences from what we're used to:

• Uses % in front of register names instead of \$
• Puts the destination on the right instead of the left (i.e. movupd src, dst)
• Memory locations denoted by an operand with parentheses:
• (%rax) dereferences %rax as a pointer
• 8(%rax) dereferences %rax with an offset of 8
• (%rax,%rbx,4) adds %rax and 4 times %rbx to form a memory address
• "leaq 8(%rax), %rbx" loads the data at address %rax+8 into %rbx
• %rsp is the stack pointer; %rbp is the frame pointer
• %rXX registers are 64-bit; %eXX represent the lower 32 bits of them
1. Find the for-loop in sseTest.s and identify what each intrinsic is compiled into. Are they compiled into function calls? Comment the loop so that your TA can see that you understand the code.

Checkoff: Show your commented code to your TA and explain the for-loop.

## Exercise 3: Writing SIMD Code

For Exercise 3, you will vectorize/SIMDize the following code to achieve approximately 4x speedup over the naive implementation shown here:

```    int sum_naive( int n, int *a )
{
int sum = 0;
for( int i = 0; i < n; i++ )
sum += a[i];
return sum;
}
```

You might find the following intrinsics useful:

 __m128i _mm_setzero_si128( ) returns 128-bit zero vector __m128i _mm_loadu_si128( __m128i *p ) returns 128-bit vector stored at pointer p __m128i _mm_add_epi32( __m128i a, __m128i b ) returns vector (a0+b0, a1+b1, a2+b2, a3+b3) void _mm_storeu_si128( __m128i *p, __m128i a ) stores 128-bit vector a at pointer p

Start with sum.c. Use SSE instrinsics to implement the sum_vectorized() function. (Make sure to compile with the -O3 flag!!!!)

## Exercise 4: Loop Unrolling

Happily, you can obtain even more performance improvement! Carefully unroll the SIMD vector sum code that you created in the previous exercise. This should get you about a factor of 2 further increase in performance. As an example of loop unrolling, consider the supplied function sum_unrolled():

```    int sum_unrolled( int n, int *a )
{
int sum = 0;

/* do the body of the work in a faster unrolled loop */
for( int i = 0; i < n/4*4; i += 4 )
{
sum += a[i+0];
sum += a[i+1];
sum += a[i+2];
sum += a[i+3];
}

/* handle the small tail in a usual way */
for( int i = n/4*4; i < n; i++ )
sum += a[i];

return sum;
}
```

Also, feel free to check out Wikipedia's article on loop unrolling for more information.

Within sum.c, copy your sum_vectorized() code into sum_vectorized_unrolled() and unroll it four times. (Make sure to compile it with the -O3 flag!)

Checkoff: Show your TA the unrolled implementation and performance improvement.