Microarchitectural performance tuning is one of the most difficult parts of the performance tuning process. In contrast to other tuning activities, it is not immediately clear what the bottlenecks are. Usually, discovering them requires studying processor manuals, which provide the details of the execution flow. Furthermore, a certain understanding of assembly language is needed to reflect the findings back onto the original source code. Each processor model will also have its own microarchitectural characteristics that have to be considered when writing efficient software.

In this chapter, we outline some of the general design principles of modern processors that will allow you to understand the do’s and don’ts of diagnosing bottlenecks and to exploit tools to extract the required information that will allow you to tune software on the microarchitectural level.

Overview of a Modern Processor Pipeline

Let’s discuss the most important features of a current CPU core in these beginning few pages. Features that you will find in most cores are pipelining, out-of-order and superscalar execution, data-parallel (SIMD) execution, and branch prediction. We will associate these features with the Intel Xeon E5-2600 series processor (code name Sandy Bridge).

To begin, let’s briefly define some important terms that we will use extensively in this chapter:

  • Register: A small, but very fast storage directly connected to the processor core. Since registers must be able to hold memory addresses, they need to be as big as the address space. A 64-bit architecture has 64-bit registers. And there might be additional, larger registers that we will deal with later.

  • Assembly language: The one-to-one translation of the machine instructions that the CPU is able to understand. On a Linux system, you can see the assembly language for an object file with the objdump tool. For example,

$ objdump -M intel intel-mnemonic -d <object file or executable>

  • The output will look like

48 89 c1    mov    rcx,rax

  • where the numbers on the left are the actual numerical codes of the machine language and the right hand side is the translation into an assembly language instruction, consisting of human-readable mnemonics and its arguments. In this example, the translation into English would be “move the contents of register rax to the register rcx.” Machine language and assembly language can be thought of as bijective. A compiler is not required; instead, a “translator” is used, called an assembler. The system-supplied assembler on a Linux system is called “as.” (If you are interested in the details of assembly language programming, there are good books available, such as Sivara P. Dandamudi’s.1 We also recommend the Intel processor manuals.2)

  • Instruction: A machine language command having none, one, or more arguments. One line of assembly language as described above corresponds to a single machine command. The instructions valid for a given processor are defined in the instruction set architecture (ISA). The ISA that 64-bit Intel processors understand is often dubbed x86_64 with various downward-compatible extensions; that is, a processor being able to execute Advanced Vector Extensions (AVX) can also execute Streaming SIMD extensions (SSE), but not vice versa.

  • Micro-operation (uop): Instructions translated into micro-operations in the decoder. This is done in order to formally keep the ISA as is and still be able to change the underlying functionality of a processor. It allows programs written for one ISA to execute on two fundamentally different processor architectures. In the case of Intel processors, this is the Intel64 ISA. The micro-operations are not disclosed, nor are they directly programmable.

Pipelined Execution

Pipelines are the computer-science version of an industrial assembly line, and they are the overarching design principle of a modern CPU core. Thus, all techniques introduced here need to be seen in light of this concept. In a pipeline, throughput performance is gained by exploiting parallelism in the execution of a stream of instructions. Pipeline stages are each executing specialized tasks.

A classic pipeline model used by Tanenbaum3 looks like this:

  • Instruction fetch (IF): Loads the instruction indicated by the instruction pointer. The instruction pointer is a CPU register containing the memory address of the next instruction to be executed.

  • Instruction decode (ID): The processor parses the instruction and associates it with the functionality to be executed.

  • Load operands (LO): Data from the argument(s) are loaded. In general this is data thought to be contained in a CPU register, but it might also be a memory address.

  • Execution (EX): The instruction is executed. In the case of an arithmetic instruction, the actual computation will be done.

  • Write-back results (WB): The computed result is committed to the specified destination, usually a register.

In a non-pipelined approach, each of these steps needs to be completed before another instruction can be fetched. While one of these stages is active, the other ones is idle, which renders most of the processor’s capacity unutilized. In a pipeline approach, however, each pipeline stage is active at the same time, leading to a throughput of one instruction per clock cycle (assuming that completion of a stage requires one clock cycle). If you assume that there is no dependence between individual instructions, you can fetch the third instruction while the second one is being decoded; you can load the operands for the first one at the same time, and so on. In this way, no pipeline stage is ever idle, as shown in Figure 7-1.

Figure 7-1.
figure 1

Comparison of pipelined vs. non-pipelined execution of instructions

In a pipeline, although the latency of the individual instruction (the time during which the instruction is individually executed) does not change, the overall throughput increases dramatically.

Let’s estimate the time it takes to execute a number of instructions N instructions in N stages stages, where we assume each stage takes the same time T stages to complete:

T no-pipeline = N instructions N stages T stage

T pipeline = N stages T stage + (N instructions –1) T stage.

The ideal speedup is

S = T no-pipeline /T pipeline = N stages  ,

assuming an infinite number of instructions. This estimation is highly idealized. If, for some reason, one stage of the pipeline fails to complete in time, the whole pipeline will come to a halt—that,s what we call a pipeline stall. Without claiming completeness, some common reasons for pipeline stalls are as follows.

Data Conflicts

Data conflicts arise from the parallel execution of instructions within a pipeline when the results of one instruction are an input argument to another instruction. Data conflicts play an important role when we speak about vectorization, and we will come back to them when we deal with this topic later in the chapter.

We can distinguish three important types of data conflict:

  1. 1.

    Read after write (RAW) or flow dependence: A variable must be read after it was written previously. The use of the updated value cannot be started until the update is completed. Example in C:



Clearly, the first line needs to complete before the second can be executed, since otherwise the variable var1 might contain an arbitrary value.

  1. 2.

    Write after read (WAR) or anti-dependence: This is just the opposite of RAW: a variable must be written after it has been read previously. Example in C:



The second line must be prohibited from committing the value 5 to var1before the first completes.

  1. 3.

    Write after write (WAW): This is a situation where the same variable is written by two different values in very close proximity. Example in C:


<other instructions>


The WAW case is not a problem in a simple in-order pipeline. However, in the context of out-of-order and superscalar execution discussed later, this conflict is possible when the order of instructions can be changed and instructions might even be executed concurrently.

Control Conflicts

The instruction flow often reaches a point where a decision needs to be made about which further instructions will be executed. Such points are unmistakably indicated by explicit conditional constructs (e.g., if-statements) in the source code. Other language constructs require decisions to be made, as well. A common example is loops where a counter variable is compared with the upper limit of the loop. If the upper limit is not reached, the instruction pointer will be set to the beginning of the loop body and the next iteration is executed. If the upper limit is reached, the execution will continue with the next instruction after the loop body.

Consider a loop summing up all numbers below 100:



In assembly language, this is translated into a comparison and a conditional jump:

mov eax, 0x0      # set the counter variable to zero

loop1:            # a marker, translated into a position by the assembler

add ebx, eax    # this is the loop body

inc eax         # increment the loop counter

cmp eax, 0x64   # compare if we have reached the upper limit

jle <loop1>     # if the comparison yields less or equal, jump to loop1


With the result of the comparison not yet being available, the pipeline cannot reliably execute the jump and the pipeline will stall until the comparison has written-back its results. A control conflict can partly be resolved by branch prediction, as discussed later.

Structural Conflicts

A structural conflict appears when more hardware functionality is required than is available in a section of the instruction flow. If you have only, say, four registers and two instructions, each uses two registers to copy data; if these two instructions are executing in the pipeline, an instruction that requires one of the registers will have to wait until the resources are freed up.

Out-of-order vs. In-order Execution

In the previous section we considered pipelines and how they improve performance when issued instructions are independent and do not show any conflicts. One problem a pipeline does not solve is the following. Consider an instruction, inst1, which shows a true dependence and will have to wait until some result of a number of previous calculations becomes available. The next instruction, inst2, might have all its dependences satisfied but cannot execute because the order of instructions needs to be guaranteed for the instruction flow to deliver consistent results. We call this in-order execution. However, if we could keep track of the order of instructions and reorder them again before the results become apparent when we commit them to the register in the WB (write-back) stage, we could allow inst2 to bypass inst1 and be executed while inst1 is waiting.

This idea is implemented in out-of-order execution pipelines. We do not go into detail on how this is exactly implemented, as those details are of no importance here, but there is a considerable amount of literature covering this subject.4,5l What is important, though, are the additional two stages this strategy introduces to the pipeline. First, we need one stage to check the instruction flow for data dependences, record the order, and issue the instruction into execution. We call this stage the dispatch or reservation station. Then, we need a pipeline stage that reorders the instructions after execution and commits the results to registers in the original execution order. We call this stage retirement. On Intel architectures, the out-of-order engine is the part that works on micro-operations (uops).

Superscalar Pipelines

With out-of-order execution in place, there is a straightforward way to increase performance: instead of executing out-of-order in a single pipeline, you could execute the micro-instructions in parallel, in two or more independent pipelines, because their execution is independent from the beginning (see Figure 7-2). The retirement buffer will then take care of the proper ordering across all pipelines after the execution. The level of parallelism that can be achieved in this approach is, of course, limited by the inherent parallelism in the flow of instructions.

Figure 7-2.
figure 2

Parallel execution in a superscalar out-of-order pipeline

SIMD Execution

In practice, we often apply the same instructions to each element of a large dataset. This gives rise to an additional level of parallelism to be exploited. The potential speedup is proportional to the number of data elements we can process in parallel. In hardware, this is implemented by making registers available that are as wide as the number of elements that we want to treat in parallel, which is a significant hardware investment limiting the vector length.

Current Intel CPUs support three types of vector extensions: multimedia extensions (MMX, 64 bit), various versions of Stream SIMD extensions (SSE, 128 bit), and advanced vector extensions (AVX, 256 bit). Chapter 2 discussed the benefits of SIMD execution in detail; see especially Figures 2-2 through 2-8 for AVX.

Speculative Execution: Branch Prediction

A limiting factor for the performance of a pipeline is the presence of branches. Branches appear when the execution can continue at another position in the instruction flow. There are two types of branches: conditional and unconditional. Conditional branches implement decisions taken at runtime, such as “if” and “while.” Unconditional branches are created for subroutines, functions, and function pointer calls.

When a conditional branch appears in the instruction flow, the pipeline stalls at this position until the condition has been calculated and the next instruction can be fetched, which can mean a big hit to performance. To alleviate this problem, the processor could predict the target of the branch and continue feeding the pipeline with instructions from this point in the code. For this purpose, the processor has a branch target buffer that stores the last branch target taken from this point in the code, along with information about the success of the last predictions.

A very simple implementation of a branch prediction would be to predict the last observed behavior; that is, we predict “branch taken” if we took it the last time and “not taken” if we didn’t take it. This is easy to store in a single bit associated with the position of the branch in the code. Figure 7-3 shows a more advanced branch predictor using two bits. If a branch is taken, the predictor will enter the state 11 “predict taken.” While the prediction is true, it will stay in this state. If the prediction is once false, it will not immediately predict “not taken” but, rather, go to state 10, but still “predict taken.” Only if the prediction is wrong a second time will the state change to “00” and “predict not taken.”

Figure 7-3.
figure 3

A 2-bit branch predictor (see description in  text)

These branch prediction schemes are called dynamic predictions. The branch predictor compares the current position in the code with information it already has stored for this particular branch. At the first encounter of a particular branch, this solution will not work because there is no information available in the branch target buffer. For this instance, the branch predictor has a default behavior, called the static prediction. The rules for static branch prediction are as follows:

  • A forward conditional branch (an if-statement) is predicted not to be taken

  • A backward conditional branch (a loop) is predicted to be taken

  • An unconditional branch (a call to or return from a subroutine) is predicted to be taken

Branch predictors can have a very high hit rate, but at one point a prediction will fail. If you consider a loop, the prediction will be wrong when the loop counter has reached the limit. In this case, the processor speculatively executes the wrong code path and the pipeline will be cleared (called a pipeline flush). The computation is then restarted at the point before the prediction, using the now-known correct branch target. A pipeline flush can have a serious performance impact. The minimum impact is the time it takes to refill the pipeline—which is, at best, the number of pipeline stages.

Memory Subsystem

A problem in the last decade of CPU design was the growing divergence in performance of memory and CPU. While the CPU follows the principle of Moore’s Law and doubles the number of components (translating directly into performance) each 18 months, memory performance (that is, the number of bytes delivered per second) grows much slower. To have the data readily available when needed by the execution units, fast but small and expensive storage is directly built into the CPU, called a cache. The idea of a cache was inspired by the temporal principle of locality: data that you have used once you will likely use again in the near future. The cache memory, then, stores intermediate copies of data that actually reside in the main memory. Often, more than one cache is present, which is then called a cache hierarchy.

Three different cache implementations are used:

  • Direct-mapped cache: Each memory address can be stored only in a specific cache line. If a memory address is loaded in a cache line that is already occupied, the previous content of this line is evicted. This approach allows for a much leaner logic to determine a hit and has relatively low access latency. The hit ratios are lower than with the fully associative cache, but this technique is cheaper.

  • Fully associative cache: The memory address of the data within the cache is stored alongside. To find where a memory location has been stored in the cache requires a compare operation across the memory addresses stored for each line. Fully associative caches have high hit rates but relatively long access latencies. Also, they require a larger chip space to incorporate the extensive hit logic and are therefore more expensive.

  • Set associative cache: This is a compromise between the two aforementioned alternatives. The set associative cache divides the cache into a number of sets (say eight). A cache line is placed into a given set, based on its memory address. Searching within a set, then, is internally fully associative. While cost and chip space stay reasonable, this technique offers a high hit ratio.

Current product lines of Intel processor cores feature 32 Kbyte instruction and data Level 1 (L1) caches and a 256 Kbyte unified Level 2 cache (L2), both eight-way set associative. (Cache latencies and bandwidth have been discussed in Chapter 2.)

Even if we cache data entries for fast access by the execution units, many programs stream data through the processor, which exceeds the cache capacity. The cache then becomes useless because you will not find the entry you loaded in the past, as it was already evicted. The cache also adds latency to the loading of such streaming data into the processor. In modern CPU design, this problem is attacked by preloading data in the caches that is likely to be used next, so that it is readily available. This technique is called prefetching and is extensively used in the Sandy Bridge architecture, which has four different hardware prefetchers.6

Putting It All Together: A Final Look at the Sandy Bridge Pipeline

Let’s now relate the architecture design principles discussed to the block diagram of the Sandy Bridge microarchitecture, as shown in Figure 7-4, and follow an instruction from fetching to retirement. Instructions stored in main memory come in through the 32 KB L1 instruction cache (ICache) at a rate of 16 bytes per cycle and are decoded (there is actually a pre-decode stage) into microinstructions. Up to four instructions can be decoded in one cycle. Instructions that have already been decoded are stored into a uop cache that can hold up to 1536 uops. Then, resources (for example registers) are allocated whereby unnecessary structural conflicts are resolved through register renaming. The scheduler can queue up to 56 uops and distribute up to six uops to the execution ports, depending on the requested functionality by the instruction. Instructions are dispatched out-of-order and a reorder buffer is used to keep track of the original sequence. Upon completion of an instruction, execution results are committed in the right sequence and the instructions retire, up to four per cycle.

Figure 7-4.
figure 4

Block diagram of the Sandy Bridge core

A Top-down Method for Categorizing the Pipeline Performance

The Sandy Bridge pipeline is designed to deliver maximum performance. The target of all software microarchitectural optimization is to keep the pipeline running and avoid pipeline stalls. But how do you actually know what good performance is and what is not? How can you determine where in the pipeline the problems appear? In this section, we introduce an easy scheme to categorize optimization opportunities and determine where the pipeline stalls.

The Sandy Bridge core pipeline, as shown in Figure 7-4, is certainly very complicated with a lot of interacting units. We could look at each unit individually, which gets confusing and is hard to remember; instead, we will consider the broader picture.

Let us start with the most basic performance metric first. The CPI rate (cycles per instruction) is a measure of how well the code has been executing in the pipeline. Because of the super-scalar properties of the core architecture, multiple instructions can be executed at the same time. For a current Intel Core or Intel Xeon processor, the limit is four instructions, which corresponds to a CPI rate of 0.25; on average, only a quarter of a cycle is spent on an instruction if four of them are executed and retired. Applications with a CPI rate of 0.25 to 0.7 are considered to be efficient. A CPI rate above the threshold of 1.0 usually indicates that a performance problem might exist and that further analysis should be performed. The CPI rate specifies how many instructions are executed per cycle (it is not a good metric to discuss the usefulness of these instructions!). If you don’t reach a good CPI value, the pipeline is not retiring as many instructions as possible and is stalling at some point; see the diagram shown in Figure 7-4 .

It is useful to subdivide the Sandy Bridge pipeline into two parts: front end and back end. We define these two parts as follows:

  • Front end: fetching of the instruction, the decoding, the branch prediction, and the uops queue

  • Back end: renaming, scheduling, and execution (the out-of-order engine)

The front end is responsible for decoding instructions and delivering micro-operations; the back end has to execute and retire them. If the front end can’t deliver, the back end will starve. If the back end can’t take more uops, the front end will stall. In either of these two cases, no uops will be issued from front to back end.

If no uops can be issued, we again have two cases: either we can allocate resources in the back end (registers, ports) or we cannot. If resources are free but no uops are issued, we call such a code front-end bound. If no resources are free (the execution units are busy), we call it back-end bound. This might happen because the code is either core bound (waiting for computation to complete) or memory bound (waiting for memory operations to complete).

If uops can be issued into the pipeline, the next question we need to ask is: Do the uops actually retire? If the uops do retire, we have the desired outcome. If they do not, they must have vanished from the pipeline although they were issued; they must have been cleared due to bad speculation. Figure 7-5 outlines the decision tree for this categorization.

Figure 7-5.
figure 5

Hierarchical top-down analysis method (Source: Intel 64 and IA-32 Architectures Optimization Reference Manual)

Ideally we would like to see all compute cycles spent in the retired category, although this doesn’t mean there is no room for improvement. As for the other categories, let’s discuss some common reasons they will appear:

  • Front-end bound: This is caused by misses in the instruction cache (ICache) or the instruction translation lookaside buffer (ITLB), owing to a large code, excessive inlining or loop unrolling. Also, inefficiencies in the decoder, such as length-changing prefixes,7 can be the reason. (See inlining in later sections “Dealing with Branching” and “Basic Usage and Optimization.”)

  • Back-end memory bound: The cache misses at all levels—irregular data access, streaming data access, large datasets, cache conflicts, and unaligned data. (See the later section “Optimizing for Vectorization.”)

  • Back-end core bound: There are long latency instructions (divide), chains of dependent instructions, and code that is not vectorizing. (See the later section “Optimizing for Vectorization.”)

  • Bad speculation: There is wrong prediction of branches and resulting pipeline flushes and short loops. (See the later section “Dealing with Branching.”)

Intel Composer XE Usage for Microarchitecture Optimizations

Before we go into details about particular optimization problems, let’s review some basic usage of the compiler.

Basic Compiler Usage and Optimization

The first important choice to make is to specify the architecture and ISA extension you want to compile for. If you do not specify anything, the default will be SSE3, which is the one available on all 64-bit platforms. In most cases, you will have a more feature-rich and higher performance set of instructions available on more recent CPUs. The compiler switch -x<arch> will compile only for the architecture specified in <arch> and downward compatible, succeeding Intel platforms. We use -xAVX in this chapter because we want to address this instruction set. Please refer to the compiler manual for all options. If you compile on the platform you will be running on, it is easiest to use -xHOST, which will detect and apply the correct architecture automatically.

If you need to have a binary for an alternative architecture, by all means there is a workaround. By specifying -ax instead of -x, you tell the compiler to create a binary for multiple architectures that is auto-dispatching—that is, using the code path that is best for the architecture that the software is currently running on. For example, the compiler command

$ icc -axAVX,SSE4.1 <source file>

will create a binary that can execute on all Intel CPUs supporting SSE4.1, but it will still run the highest performing code path on the Sandy Bridge and Ivy Bridge processors.

The next basic choice is the optimization level. There are four optimization levels, which can be controlled with the -On switch, where n is between 0 and 3. The -O0 switch turns off optimization completely. The -O1 optimizes for speed, but doesn’t increase the code size. The default optimization level is -O2, which optimizes for speed, but increases code size through unrolling and inlining. The -O3 performs similar optimizations as -O2, but is more aggressive. When using -O3, you’ll find that increased inlining and loop unrolling can sometimes lead to slower code because of front-end stalls. It is worth playing with this switch and measuring performance before deciding on the final level to use.

Using Optimization and Vectorization Reports to Read the Compiler’s Mind

Compiler reports are an essential tool for understanding whether a particular optimization has been done by the compiler. This information is difficult to obtain otherwise, and even advanced performance-monitoring tools like VTune Amplifier XE will not provide it, hence it is worth spending some time on it here. Note that the reporting features of the compiler changed with Intel Composer XE 2015—some of the functionality described here might not be valid for older versions.

Intel Composer XE 2015 can provide extensive optimization reports in six levels, from 0 (no optimization report) to 5 (maximum). Although the level 5 report provides the most insight, it generates a lot of information for large codes.

The reports contain information for a total of nine phases, if applicable:

  • LOOP: High-level loop optimization

  • PAR: Auto-parallelization

  • VEC: Vectorization

  • OPENMP: OpenMP thread parallelization

  • OFFLOAD: Offloading to the Intel Xeon Phi co-processor

  • IPO: Inter-procedural optimization

  • PGO: Profile-guided optimization

  • CG: Code generation

  • TCOLLECT: Trace collection in MPI parallelized programs

For the scope of this chapter, three of these phases are the most interesting: LOOP, VEC, and IPO. For this first example, consider a program implementing a square matrix-matrix multiplication and inspect the optimization report produced by the compiler. The function for doing the computation is shown in Listing 7-1.

Listing 7-1. Square Matrix Multiplication in C/C++

void squaregemm(int size, double* a, double* b, double* c){

for(int i=0;i<size;i++){

for(int j=0;j<size;j++){

for(int k=0;k<size;k++){






Let’s look at the optimization report of the compiler generated with -opt-report5. First, there is a report header summarizing the setting for IPO, inlining, and the inlined functions. After this header information, the optimization report for the code starts, usually with the main routine:

Begin optimization report for: main

Report from: Interprocedural optimizations [ipo]

INLINE REPORT: (main) [1/2=50.0%]

-> printf(EXTERN)

-> rand(EXTERN)

-> INLINE: squaregemm(int, double*, double*, double*)() (isz = 57) (sz = 68 (33+35))

-> operator new[](unsigned long)(EXTERN)

-> operator new[](unsigned long)(EXTERN)

-> operator new[](unsigned long)(EXTERN)

The function squaregemm that we have defined is inlined; all other functions (not shown in Listing 7-1) for which no code could be found are marked extern, such as rand() or printf(). The numbers behind the inlined function summarize the increase of the code size. In this case, the size of the calling function plus the called function is 68 = 33 + 35, whereas the size of the inlined function is only 57, owing to further optimizations.

The next interesting point is the optimization report for the squaregemm function:


Begin optimization report for: squaregemm(int, double*, double*, double*)

Report from: Interprocedural optimizations [ipo]

INLINE REPORT: (squaregemm(int, double*, double*, double*)) [2/2=100.0%]


The function squaregemm was inlined.


Report from: Loop nest, Vector & Auto-parallelization optimizations [loop, vec, par]

LOOP BEGIN at main1.cpp(5,3)

remark #25448: Loopnest Interchanged : (1 2 3) --> (1 3 2)


The compiler has changed the order of the loops form i,j,k to i,k,j to provide better conditions for vectorization.


remark #15145: vectorization support: unroll factor set to 4


The last line indicates the compiler has unrolled the loop by four iterations. Checking the assembly output of objdump -d, we indeed find a vectorized version of the loop that is fourfold unrolled (four AVX vector multiplies and four AVX vector adds):

401070:    c5 fd 59 da             vmulpd %ymm2,%ymm0,%ymm3

401074:    c5 fd 59 fe             vmulpd %ymm6,%ymm0,%ymm7

401078:    c4 41 7d 59 da          vmulpd %ymm10,%ymm0,%ymm11

40107d:    c4 41 7d 59 fe          vmulpd %ymm14,%ymm0,%ymm15

401082:    c4 c1 65 58 24 d4       vaddpd (%r12,%rdx,8),%ymm3,%ymm4

401088:    c4 41 45 58 44 d4 20    vaddpd 0x20(%r12,%rdx,8),%ymm7,%ymm8

40108f:    c4 41 25 58 64 d4 40    vaddpd 0x40(%r12,%rdx,8),%ymm11,%ymm12

401096:    c4 c1 05 58 4c d4 60    vaddpd 0x60(%r12,%rdx,8),%ymm15,%ymm1

So you should now have an idea of what type of information the report creates. We have deliberately left out quite a number of lines so as to keep this readable. The original report for this very short program with a single function call is about 200 lines at report level 5. Very often this is too much detail, as you might be interested in only one function in a file or in a particular phase of the report. In this case, you can specify a filter—for instance, for a function:


Or you can indicate a phase—for instance, vectorization:


The phase must be one of CG, IPO, LOOP, OFFLOAD, OPENMP, PAR, PGO, TCOLLECT, VEC, or all, as described earlier.

Optimizing for Vectorization

SIMD vectorization is one of the main sources of performance for Intel CPUs. There are many ways to support vectorization:

  • Automatic vectorization: Expressing code in a way the compiler can easily recognize vectorizable code

  • User-assisted vectorization: Indicating vectorization opportunities to the compiler, or even forcing the compiler into vectorization via annotation by compiler pragmas

  • Language extensions: Expressing vectorization explicitly in a high-level language

We will put a strong focus on loop vectorization, since this is the most common, but it’s not the only source of vectorization.


This section addresses the front-end/back-end categories of the top-down method for the pipeline performance.

The AVX Instruction Set

The Sandy Bridge architecture introduced a set of new instructions operating on 256-bit vector registers (see also the section “Process More Data with SIMD Parallelism” in Chapter 2), called Advanced Vector Extensions (AVX). AVX supersedes the 128-bit SSE instruction set extension introduced in the Pentium processor line and doubles the floating-point performance of the CPU.

AVX instructions can operate on sixteen 256-bit vector registers ymm0-ymm15. In contrast to its predecessor SSE, which only allowed two arguments for each instruction, AVX introduces a three-argument instruction format:

<instruction> <destination>, <source1>, <source2>

This allows for non-destructive operations (none of the sources are altered) and avoids frequent save operations necessary to preserve the contents of a vector register, as well as reduces register pressure (the shortage of registers). Examples of AVX functionality for 256-bit vectors include the following (see illustrations of some vector functions in Figure 7-6):

  • Loading and storing of aligned and unaligned data. The operations may be masked, so that a load ranging into an unallocated memory range does not cause a fault.

  • Broadcasting of a memory element in all elements of a vector.

  • Elementary arithmetic operations of addition, subtraction, multiplication, and division, as well as addsub (alternating addition/subtraction), (inverse) square root, and reciprocal.

  • Comparison, minimum, maximum, and rounding.

  • Permutation of elements within a lane and permutation of lanes.

Figure 7-6.
figure 6

Examples of AVX functionality: simple vector addition (top left), in-lane permutation (top right), broadcasting (bottom left), and mask loading (bottom right)

We will consider the direct programming of AVX later, in the section “Understanding AVX: Intrinsic Programming.”

Why Doesn’t My Code Vectorize in the First Place?

Before going into actual optimizations for vectorization, let’s briefly look at reasons why the compiler can’t vectorize your code. The root cause are actual or assumed data dependences that are not resolvable at compile time.

Data Dependences

In regard to pipeline conflicts, we covered data dependences that prevent instructions from being executed in parallel in a pipelined, out-of-order, or superscalar fashion. As this pertains to the pipeline, where arbitrary instructions might act on the same data at different times, it applies even more so to vectors. Here, only a single instruction is executed on multiple, possibly dependent data elements at exactly the same time. In this sense, vector dependences are more controllable and more easily solved.

Recall the data conflicts discussed earlier: flow dependence (read after write, or RAW), anti-dependence (write after read, or WAR), and output dependence (write after write, or WAW). It is important to realize how dependences affect vectorization. Let’s look at a simple example. When a variable is written in one iteration and read in a subsequent one, we have a RAW dependence, as we can see within the loop code:

for(int i=0;i<length-1;i++){



If you unroll this loop, you get:

a[1]=a[0]; a[2]=a[1]; a[3]=a[2]; ...

After correct execution of the loop, all the elements should be set to the value in a[0] (see Figure 7-7, left panel). Now, consider a two-element vectorized version of the loop. At one time, two successive values will be loaded from the array (the parentheses indicate the vector):


Figure 7-7.
figure 7

Flow (RAW) data dependence-analysis of a shift-copy loop executed sequentially and with a two-element vector

The second value is already wrong, according to the original algorithm. In the next iteration, you get:


a[2] has already been changed to a[1] in the previous iteration and the corresponding values are loaded. Carrying this on, you get, as the final result:

a[0],a[1],a[1],a[3],a[3],a[5] ...

This is obviously wrong according to the original algorithm (see Figure 7-7, right panel). Clearly, the compiler must prevent this loop from being vectorized. Very often, however, the compiler assumes an unproven vector dependence, although you will know better that this will never occur; we will treat this case extensively later.


Try the example discussed in the preceding text:

for(int i=0;i<length-1;i++){



You can enforce vectorization by placing a pragma simd (to be explained below) before the loop.

#pragma simd

for(int i=0;i<length-1;i++){



Can you confirm the results? For which shifts i+1, i+2,... do you get correct results? For which do you get wrong results?

Data Aliasing

Another, related reason why code does not vectorize is aliasing. Under aliasing, we understand the fact that two variables (pointers or references) are associated with the same memory region. Consider a simple copy function:

void mycopy(double* a, double* b, int length){

for(int i=0;i<length-1;i++){




In principle, the compiler should be able to vectorize this easily. But wait—can the compiler be sure that the arrays a and b do not overlap? It cannot. And C/C++ explicitly allows for this situation! Call the above function from the main function like this:

int main(void){

int length=100;

int copylength=50;

double* a;

double* b;

double* data = (double*) malloc(sizeof(double)*length);





You will get the same situation as with the earlier code showing an explicit vector dependence. Consequently, the compiler must assume that there is a dependence.

Array Notations

The array notation (AN) introduced with Intel Cilk Plus is an Intel-specific language extension of C/C++ that allows for direct expression of data-level parallelism (in contrast to loops, which have the abovementioned problems). AN relieves the compiler of the dependence and aliasing analysis to a degree and provides an easy way to a correct, performing code.

AN introduces an array section notation that allows the specification of particular elements, compact or regularly strided:

<array base>[<lower bound>:<length>[:<stride>]]

The syntax resembles the Fortran syntax, but Fortran programmers beware: the semantic requires start:length and not start:end!

Examples for the array section notation are:

a[:]         // the whole array

a[0:10]      // elements 0 through 9

a[0:5:2]     // elements 0,2,4,6,8

Based on this notation, operators will now act element-wise:

c[0:10]=a[0:10]*b[0:10];   // element-wise multiplication of 10 elements

a[0:10]++;                 // increments all elements

m[0:10]=a[0:10]<b[0:10];   // m[i] will contain 1 if a[i]<b[i], 0 otherwise

It is also possible to use AN with fields of higher dimension:


Or even with totally different ranks:


The only requirement is that the number of ranks and rank sizes must match. AN provides reducer intrinsics to exercise all-element reductions. The following expression,


will return the sum of all elements. Of course, this can also be used with more complex expression as arguments, so that,


will return the inner vector product.

Let’s look at an example using AN. A problem often encountered in scientific codes is partial differential equations. Consider a 1D acoustic wave equation,

where x and t are continuous variables. This translates into a second-order finite difference equation as,

where x and t are now discrete space and time indices with distances and . We want to know the strength of the field at the time t +1 at position x. Solving the above equation for the field element yields:

In C/C++, this maybe expressed as:

for(int i=0;i<iterations;i++){        // number of time steps

for(int n=1;n<size-1;n++){          // iterate over the space dimension

f_next[n]= prefac*(f_curr[n-1]+f_curr[n+1]




f_prev=f_curr; // in the iteration, the next field becomes the current

f_curr=f_next; // ... and the current become the previous

f_next=tmp;    // The old previous we will be used to store the new next


The same example in AN would look like this:

for(int i=0;i<iterations;i++){








Although the compiler might vectorize this simple example even in straight C/C++, more complex problems—for example, a three-dimensional wave equation of a finite difference equation solved to a higher order—might not or not fully vectorize. With AN, the vector code becomes explicit.

Vectorization Directives

Pragmas are an annotation technique you already learned about in the context of OpenMP. They allow you to hint information to the compiler, for which other means of expressing it in C/C++ or Fortran are not available.

A pragma is treated by the compiler like a comment or an unknown preprocessor directive if it doesn’t know it; in the end, it does ignore it. Consequently, the resulting code maintains its portability for compilers that don’t support a certain feature, but it has the desired effect if the compiler does understand the meaning of the pragma.


The #pragma ivdep tells the compiler that assumed vector dependences in the following loop body are to be ignored. Note that proven vector dependences are not affected. The pragma has no further arguments. The #pragma ivdep is available in most compilers, though its implementation might differ.


The #pragma vector is similar in its effect as #pragma ivdep in the sense that it will ignore assumed dependences but not proven ones, but it has additional optional clauses:

  • always: This overrides the heuristics on efficiency, alignment, and stride.

  • aligned/unaligned: This tells the compiler to use aligned or unaligned data movement for memory references.

  • temporal/nontemporal: This tells the compiler to use streaming stores in case of nontemporal, or to avoid those in case of temporal. Streaming stores write directly into memory bypassing the cache, which saves an ubiquitous read for ownership (RFO) that is required to modify the data in the cache. The nontemporal clause can take a comma-separated list of variables that should be stored nontemporal.


The #pragma simdis the most powerful of the three vectorization pragmas. So, #pragma simd tells the compiler to ignore any heuristics and dependence, proven or not; you will be fully responsible for making sure the result is correct. #pragma simd is a powerful construct that can be extended by more arguments/subclauses, some similar in spirit to the OpenMP parallel for pragma discussed earlier. We discuss them briefly here:

  • vectorlength(arg1): Tells the compiler to use the specified vector length. arg<n> must be a power of 2. Ideally, the vector length is the maximum vector length supported by the underlying hardware, such as 2 for SSE2 double vectors or 4 for AVX double vectors. For example:

#pragma simd vectorlength(2)

for(int i=0;i<L;i++)


  • vectorlengthfor(datatype): Tells the compiler to choose the appropriate vector length for the architecture and data type compiled for—for example, vectorlengthfor(double) will result in a vector length of 2 for SSE2 and 4 for AVX. The benefit is that you will get the optimal vector length independent of the architecture chosen by the -x compiler switch. For example:

#pragma simd vectorlengthfor(double)

for(int i=0;i<L;i++)


The following clauses of pragma simd resemble the interface used in the OpenMP data-sharing clauses and maybe thought of in the same manner—just that a vector lane would correspond to a thread:

  • private(var1[,var2,...]): With this clause the compiler will assume that the scalar variable var1 can take different values in each loop iteration (see also the OpenMP private clause). The initial (at start of the loop) and final (after the loop) values are undefined, so make sure you set the value in the loop and after the loop completion. For example:

#pragma simd private(c)

for(int i=0;i<L;i++){




  • firstprivate(var1[,var2...]): The variable is considered to be private, and on entry the compiler will set the value of the private variable var1 to its value outside the loop.

  • lastprivate(var1[,var2...]): The variable is considered to be private, and on exit the compiler will maintain the value of the variable var1 achieved in the last iteration of the loop.

  • reduction(op:var): This performs a reduction operation of the variable var with the operator op. The value of this clause becomes immediately obvious by looking at an example:

#pragma simd reduction(+:c)

for(int i=0;i<L;i++){



  • Here, each SIMD element performs a + reduction (accumulates all the values) in the variable c, but in the end all values of all SIMD elements are summed up to give the correct result of the sum of all elements of the array a.

  • (no)assert : This causes the compiler to generate an error if the vectorization fails. The default is noassert and will generate a warning.

You will notice the close similarity between #pragma simd and the OpenMP construct #pragma omp for, which was discussed in Chapter 6.

Understanding AVX: Intrinsic Programming

We have touched on the AVX instructions a couple of times in this chapter. AVX is the most important performance improvement in the Sandy Bridge architecture, but we have described it only briefly up to this point. Here, we want to go into somewhat more detail by programming with AVX explicitly by using intrinsics. This is more for educational purposes than for practical use. Intrinsics are supposed to be the last resort when vectorization cannot be facilitated otherwise.

What Are Intrinsics?

Intrinsics are functions that the compiler recognizes and treats in special way. In our case, they are functions and types that can directly deal with vectors of a given length, hence they also directly address a particular architecture independent of what is used with the -x<architecture> switch. In most cases, intrinsics directly translate into machine instructions. In some cases, they are more complex and involve a couple of instructions.

Intrinsics mostly operate on and return vector types. For AVX, those are 256-bit vectors and the types are as follows:

  • Eight 32-bit integer elements or four 64-bit integer elements: __m256i

  • Eight single precision elements: __m256

  • Four double precision elements: __m256d

We will focus here on the double-precision types for the sake of brevity; everything we present applies to single-precision types in a similar fashion. A listing of all intrinsics can be found in the “Intel Intrinsics Guide.”8

The 256-bit floating-point intrinsic function for AVX starts with a _mm256_, then a meaningful description of the functionality—say, add—and then two letters, encoding packed (p) or scalar (s), as well as single (s) or double (d) precision. Packed and scalar in this context means to execute the operation on all elements of the vector, or only on the first element (see Figure 7-8).

Figure 7-8.
figure 8

AVX intrinsics encoding scheme

An example of an intrinsic function is:


This will add the elements of the vectors a and b and write the results into the elements of c. The a, b, and c are of type __m256d. See also Figure 7-6.

Intrinsics are only available for C/C++ and can be used in the source code freely. All AVX intrinsics are listed in the file immintrin.h that you will find in the include directory of Intel Composer XE 2015. There are hundreds of intrinsics; we will restrict discussion to the most important ones.

First Steps: Loading and Storing

The first thing we want to do is get data into a vector and back into main memory. There two ways of loading, aligned and unaligned:

  • __m256d a = _mm256_load_pd(double* memptr): Loads the four packed double precision numbers contained in the 256 bit starting at memptr. And memptr must be 32 byte aligned.

  • __m256d a = _mm256_loadu_pd(double* memptr): Loads the four packed double precision numbers contained in the 256 bit starting at memptr. And memptr does not need to be 32 byte aligned.

Notice that we now have the information in a vector register exclusively; there is no association with the memory anymore. We may now freely modify the data without having to deal with memory transactions other than use more register than the architecture can supply; the information will spill over to the cache. When we are done with the data modification in the registers, we want to write them back into memory. That’s as easy as loading:

  • void _mm256_store_pd(double* memptr,__m256 a): Stores the four packed double precision numbers contained in the register a into the 256 bit starting at memptr. And memptr must be 32 byte aligned.

  • void _mm256_storeu_pd(double* memptr,__m256 a): Stores the four packed double precision numbers contained in the register a into the 256 bit starting at memptr. And memptr doesn’t need to be 32 byte aligned.

A simple example program summarizing this would be:

void foo(double* d){

__mm256d a;



// do something meaningful




Sometimes you want to have one value in all of the vector elements. This is called broadcasting:

  • __m256 a _mm256_broadcast_sd(double* memptr): Copies the double precision value contained in the 64 bit following memptr into all the four elements of a vector register. No alignment is required.


Now that we can load data into registers, we can start computing something. The four basic arithmetic instructions are as follows:

  • __m256 c = _mm256_add_pd(__m256 a,__m256 b): Adds the four elements in the registers a and b element wise and puts the result into c.

  • __m256 c = _mm256_sub_pd(__m256 a,__m256 b): Subtracts the four elements in the register b from a element wise and puts the result into c.

  • __m256 c = _mm256_mul_pd(__m256 a,__m256 b): Multiplies the four elements in the registers a and b element wise and puts the result into c.

  • __m256 c = _mm256_div_pd(__m256 a,__m256 b): Divides the four elements in the registers a by b element wise and puts the result into c.

These four are already sufficient to do some important computation. Very often multiplication of very small matrices is required—for instance, of 4x4 matrices in a scenario covering three-dimensional space and time. (We will revisit this example in this chapter.) There are highly optimized libraries providing the BLAS9 (basic linear algebra subroutines) functionality, such as matrix-matrix multiplication. Those libraries, such as Intel MKL, are powerful and feature rich. We might require less functionality. Say, we don’t need the multiplicative factors in the DGEMM (double general matrix-matrix subroutine), just straight multiplication of the matrices. In this case, a special matrix-matrix multiplication like the following would do the trick:

#include <immintrin.h>

void dmm_4_4_4(double* a, double* b, double* c){

int i;

__m256d xa0;

__m256d xa1;

__m256d xa2;

__m256d xa3;

__m256d xb0;

__m256d xb1;

__m256d xb2;

__m256d xb3;

__m256d xc0;

xb0 = _mm256_loadu_pd(&b[0]);

xb1 = _mm256_loadu_pd(&b[4]);

xb2 = _mm256_loadu_pd(&b[8]);

xb3 = _mm256_loadu_pd(&b[12]);


xc0 = _mm256_loadu_pd(&c[i*4]);













Measure the performance of the preceding routine versus MKL’s DGEMM or a manual C implementation, such as:

void dmm_4_4_4_c(double* a, double* b, double* c){

for(int i=0;i<4;i++){

for(int j=0;j<4;j++){

for(int l=0;l<4;l++){






The number of floating-point operations in a matrix-matrix multiplication are 2×M×N×K = 2×4×4×4=128, in this case. You will have to measure many million matrix multiplications are necessary to get some reasonable runtime. How does the performance compare? How far can you tune the performance of the C version by using pragmas and loop unrolling?

Data Rearrangement

Of course, those few intrinsics are not all there are; in few cases do we get data presented so readily usable, as with a matrix multiplication. More frequently, data needs to be rearranged in one vector or between different vectors. The intrinsics functions specialized in data rearrangement often are difficult to configure, as you will see. Still, these intrinsics have high importance because this is exactly what the compiler has the biggest problems with. We provide some examples for configurations that are useful, but we don’t claim completeness:

  • __m256 b = _mm256_permute_pd(__m256d a, int m): Permutes the elements within each lane according to the bits in m from left to right. If the bit is 0, take the first element; if the bit is 1, take the second.

Let’s look at the functionality with an example: Consider a vector containing the values a0-a3: (a3,a2,a1,a0). Then, _mm256_permute_pd allows you to move the elements of the vector within each lane (remember—a lane is half the vector); see Table 7-1 for examples.

Table 7-1. Control Integer m and Result Vector for _mm256_permute_pd

You can form all 16 variations, of course.

Next, we want to exchange data between whole lanes:

  • __m256d c = _mm256_permute2f128_pd(__m256d a, __m256d b, int m): The integer value controlling this operation is somewhat more complicated, and we refer to the documentation for exact functionality. In Table 7-2 we show some functionality for different control integers.

Table 7-2. Control Integer m and Result Vector for _mm256_permute2f128_pd

Last, we want to look at blending:

  • __m256d c = _mm256_blend_pd(__m256d a, __m256d b, const int m): Copies the elements of a and b into c according to the bits in m. If the bit position n is 0, take the element from the first source (a); if it is 1, take it from the second source (b). Examples for blending can be found in Table 7-3.

Table 7-3. Control Integer m and Results Vector for _mm256_blend_pd

Let’s see what we can do with all this. Consider a cyclic rotation of a vector by one element (see also Figure 7-9):

Figure 7-9.
figure 9

Right panel: The lane concept of AVX. Left panel: The construction of a cycle rotate of a double vector with in-lane and cross-lane permutes

(a3,a2,a1,a0) → (a0,a3,a2,a1)

Here is the recipe:

  1. 1.

    Swap the elements of each lane of a into a new vector:


  1. 2.

    Swap the  two lanes of the vector b:


  1. 3.

    Blend the vectors b and c, taking the first and third elements of the second source and the second third elements of the first source:


  1. 4.

    The vector d now contains the cyclically rotated elements of a.

This concludes our short introduction to intrinsic programming. You are encouraged to have a look at the “Intel Intrinsics Guide,”10 which contains a description of all intrinsics and they can be filtered by architecture and scope.


Create a version of the cyclic rotate that shifts by two and three elements.

Dealing with Disambiguation

Aliasing in computer sciences refers to the existence of more than one reference to a single memory address. This is easy to see when it comes to scalars; for example:

double value = 5;

double* ref1 = &value;

double* ref2 = &value;

For arrays, it becomes more complex:

double* array = new double[200];

double* ref1 = & array[0];

double* ref2 = & array[50];

Of course, ref1[50] and ref2[0] are referring to the same memory address:

for(int i=0;i<50;i++){



If we assume m to be known at compile time, we can easily observe what the compiler is doing. For 0<=m<=50, the above code is vectorizable. For m=51, we obviously have a RAW dependence and the vectorization fails. If m is not known at compile time, the compiler will assume both a RAW and WAR dependence.

In practice, you will often encounter exactly these situations, in which the compiler has to make conservative assumptions to guarantee the correct execution of the program. In most cases, this is related to a function signature, like:

void foo(double* a, double* b){ ... }

The compiler has to assume that a and b reference the same memory location. It will therefore suspect that there might be a dependence. In most cases, we will know that the assumed vector dependence can never happen and so we must have ways to hint to the compiler that it should not interfere. The following are various methods that can be used to allow the compiler to vectorize our code.

  • Compiler switches: The switch -no-ansi-alias disables the use of ANSI aliasing rules and allows the compiler to optimize more aggressively. Notice that this is the default. The opposite is -ansi-alias, which will enforce the ANSI aliasing rules. A more aggressive version is -fno-alias, where no aliasing is assumed altogether. Both compiler switches are effective for the whole file that is currently compiled; you want to be careful applying those switches when more than the function under consideration is contained in the file.

  • The restrict keyword: A more comfortable and precise way to instruct the compiler to ignore assumed dependences is to use the restrict keyword defined in the C99 standard. Placed right in front of the variable, it indicates that this pointer is not referencing data referenced by other pointers. For example:

foo(double* restrict a, double* restrict b, int length){

for(int i=0;i<length;i++){




  • The restrict keyword is preferred over use of the compiler switches because it only affects the pointers explicitly declared this way.

  • Directives: If you want to be even more specific, you can indicate where a particular dependence should be ignored. As shown above, you can force the compiler into ignoring assumed dependences by #pragma ivdep, and even stronger by #pragma simd, as discussed earlier.

Dealing with Branches

Branches are points in the instruction flow that set the instruction pointer to other than the next instruction, either static or dynamic, based on previously done comparison. Branches are a necessary evil in structured programming; function calls lead to branches if not inlined, loops will check their limits, and we have true conditional branches from “if-else” statements in the code. As outlined earlier in the discussion of the pipeline, branches pose a considerable problem for the CPU because the condition on which a branch is taken first needs to be evaluated before the instruction flow can continue at another point. CPUs deal with this by predicting the target of the branch based on previous encounters with this address in the code. Frequent wrong predictions can have a severe impact on performance.


This section addresses the bad speculation category in the of the top-down method for pipeline performance.


If you observe bad speculation at a particular conditional branch, and you have a good estimation of what the expected value should be, it is quite easy to let the compiler know about it explicitly by using the build-in function, __builtin_expect. The syntax is quite straightforward: instead of writing the condition in the argument of the if-statement, you write if(__builtin_expect(condition,expectation)), where expectation is either 0 for false or 1 for true. For example:



} else {



Profile-Guided Optimization

If you don’t have a good clue as to which conditions to put first into if-statements, then profile-guided optimization (PGO) might help. The virtue of this technique is that it gives you a way to exactly check for such cases such as wrongly predicted conditions and to correct them without impacting the source code. PGO is a three-step process:

  1. 1.

    Create an instrumented binary with the compiler option -prof-gen.

  2. 2.

    Run this binary with one or more representative workloads. This will create profile files containing the desired information.

  3. 3.

    Compile once more with the compiler option -prof-use.

Profile-guided optimization can produce considerable performance improvements for code not matching the default assumption of the compiler regarding, for example, branch behavior or loop iteration count.

Pragmas for Unrolling Loops and Inlining

Loops and calls to subroutines and functions can be another source of frequent branching. One way to reduce the number of branches caused by loops and calls is to use pragmas to unroll the loops and inline function and the subroutine calls.


The #pragma unroll allows you to control the unroll factor of loops. Unrolling a loop can speed up the loop execution considerably, because the loop condition doesn’t need to be checked as often and additional optimizations might become possible in the unrolled code. Loop unrolling does increase the code size, the pressure on the instruction cache, the decode unit, and the registers.

The #pragma unroll can take an additional argument indicating the unroll factor. For example:

#pragma unroll(2)

for(int i=0;i<size;i++){



This will give you a loop transformation similar to this:

// unrolled loop

for(int i=0;i<size-(size%2);i+=2){




// remainder loop - deals with remaining iteration // for sizes not divisible by 2

for(int i=size-(size%2);size;i++){



The #pragma nounroll will prohibit the unrolling of a particular loop.


Write a program with a simple loop, such as the above one, for a different loop length. Compile it with -xAVX -opt-report5. Do you get unrolling? Try placing a #pragma unroll in front of the loop; can you change the unrolling behavior of the compiler for this loop? Have a look at the earlier discussion on optimization reports.


The #pragma unroll_and_jam does perform a nested loop transformation, where the outer loop is unrolled and the resulting inner loops are then united. Consider our squaregemm function used in the earlier optimization reports example. If you put a #pragma unroll_and_jam in front of the middle loop,

void squaregemm(int size, double* a, double* b, double* c){

for(int i=0;i<size;i++){

#pragma unroll_and_jam(2)

for(int j=0;j<size;j++){

for(int k=0;k<size;k++){





the resulting code will be equivalent to:

void squaregemm(int size, double* a, double* b, double* c){

for(int i=0;i<size;i++){

#pragma unroll_and_jam(2)

for(int j=0;j<size;j+=2){

for(int k=0;k<size;k++){






Plus, you have additional remainder loops from the unrolling.

inline, noinline, forceinline

The Intel compiler has a large set of settings to influence inline behavior. If there are particular functions you want to see inlined, you can, of course, change the general settings for the compilation of a source file, but this a shotgun approach that will try to inline all the functions in the file. A more surgical approach is to specify exactly where you want the inlining and where to avoid it when unnecessary.

The #pragma inline will instruct the compiler to inline the function after the pragma if possible within the heuristic. You can override the heuristics by using #pragma forceinline, which will definitely inline when possible. If you want to inline functions recursively, that is, inlining functions in the inline functions and so on, you augment the behavior by adding the recursive clause—for instance, #pragma forceinline recursive.

Specialized Routines: How to Exploit the Branch Prediction for Maximal Performance

Many programs are capable of dealing with a lot of different circumstances and boundary conditions. For instance, your program might be able to deal with polynomial interpolation to a degree of the nth order. If you program such versatile software, you generally leave the parameter controlling the order of the polynomial free, but in one single run or over a longer time in the execution, you use only a single case—say eighth order. In such a circumstance, the branch prediction might do magic for you! If a branch fails, it might fail once or maybe twice, but not more often. If the condition stays constant, no further misprediction will occur until the program finishes or until another polynomial order is valid over a longer period of time.

Consider a case where you have a highly specialized routine for, say, a 4th-, 8th-, and 16th-order polynomial, since this is what you are mostly using. The general case can be treated, but it is much less well performing. In this case, a simple switch will do the trick for you:

void myswitchedpolynomial(n,...){


case 4:


case 8:





polynomial_n(n, ...);



Although this seems like a brute-force method, it can be a powerful technique, especially if you have a limited set of choices. The number of specialized routines can still be high, and can go into the thousands. In each individual routine, you can now program a particular case explicitly, which will help the compiler produce better code.

When Optimization Leads to Wrong Results

Aggressive optimization is a necessity if you want to achieve the highest level of performance. Under special circumstances, aggressive optimization can lead to problematic or even erratic behavior. In this case, you need to decrease the optimization level with the command-line switch, which will affect the methods of the whole file that’s compiled. Again, pragmas allow you to control the behavior of the compiler more specifically.

The #pragma optimize off disables the optimization for code after the pragma until its counterpart, #pragma optimize on, is found. This is a huge step, as optimization is totally switched7off. More often, it will suffice to change the optimization level—say, to the basic -O1—to guarantee the correct behavior.

The #pragma intel optimization_level 1 applies -O1 to the following function. Notice the intel clause; this is to distinguish the use from GNU compiler’s use of the same pragma, which switches the optimization level for all code after the pragma.

Analyzing Pipeline Performance with Intel VTune Amplifier XE

We have discussed the Sandy Bridge pipeline and have given potential reasons why it can stall in the front end or back end, or owing to bad speculation. We also have discussed potential remedies for each of these problems by means of the compiler. In this section, we analyze the pipeline using VTune to obtain information about pipeline performance, and we apply the solutions learned to overcome stalls in particular sections of the pipeline. We covered VTune Amlifier XE earlier in this book when we discussed share memory parallelization problems. Here, we look at one analysis type in detail: general exploration. General exploration gives us exactly the front-end/back-end analysis discussed earlier.

To have a simple example demonstrating a VTune Amplifier XE analysis, we use the 4×4 matrix multiplication introduced earlier in this chapter. But here, for all N matrices C i we want to perform M matrix-matrix multiplications,

where the indices indicate full matrices, not elements.

The example is loosely based on the problem of small matrix-matrix multiplication in the DBCSR method of CP2K.11 We will only consider square matrices:

int main(void){

int msize=4;             // the matrix side length

int msize2=msize*msize;  // the number of elements in each matrix

int nmatrices=100000;    // how many c-matrices are there

int nab=100;             // how many a and b matrix multiplication

// per c-matrix

double** b = (double**) _mm_malloc(sizeof(double*)*nmatrices,32);

double** a = (double**) _mm_malloc(sizeof(double*)*nmatrices,32);

double*  c = (double*)  _mm_malloc(sizeof(double)*nmatrices*msize2,32);

// allocate matrices

for(int i=0;i<nmatrices*msize2;i++){

c[i]=((double) rand())/((double) RAND_MAX);


for(int i=0;i<nmatrices;i++){

b[i] = (double*) _mm_malloc(sizeof(double)*msize2*nab,32);

a[i] = (double*) _mm_malloc(sizeof(double)*msize2*nab,32);


// init matrices

for(int i=0;i<nmatrices;i++){

for(int n=0;n<nab*msize2;n++){

b[i][n]=((double) rand())/((double) RAND_MAX);

a[i][n]=((double) rand())/((double) RAND_MAX);



// do a couple of iterations in order to have a reasonable runtime

for(int l=0;l<10;l++){

// for all matrices C perform ...

for(int i=0;i<nmatrices;i++){

int cpos=msize*i;

// ... a number of A-B matrix multiplications

for (int n=0;n<nab;n++)


#pragma inline      // inline the method

mymatrixmethod(4,&a[i][n], &b[i][n], &c[cpos]);





Using a Standard Library Method

The basic linear algebra system (BLAS)12 is a standard library specializing in linear algebra operations, such as matrix multiplications. The subroutine applicable here is the double precision general matrix-matrix multiplication DGEMM, which computes:

We will first use Intel MKL’s DGEMM method to perform the matrix-matrix multiplication:

void mymatrixmethod(int m, double* a, double* b, double* c){

cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,

m, m, m,1.0, a,m, b,m, 1.0,c,m);


DGEMM is too powerful a method, since we are asking for a lot fewer features than it has to offer (it can also transpose the matrices and multiply with scalar factors, all of which we don’t need here).

Figure 7-10 shows the output of a basic hotspot analysis done with VTune Amplifier XE. As expected, we have the majority of time in the DGEMM method, with some fraction coming from the initialization (functions main and rand).

Figure 7-10.
figure 10

Summary output of basic hotspot analysis

If we do the math on the number of floating-point operations (Flops) performed, we get 100 A-B-matrix multiplications for 1,000,000 C matrices with 2×4×4×4 Flops each and a total of 12.80 GFlops. We need 11.32s for this, hence we get 12.80/11.32=1.13 GFlops. This is not too impressive because a Sandy Bridge core at 2.7 GHz can deliver 21.6 GFlops!

Let’s look at the next level of details for the same run. Figure 7-11 shows the summary page of a general exploration analysis performed with VTune Amplifier XE for the same binary. Actually, the results seem not that bad; the pipeline execution is quite good with a CPI of 0.503 (about 2 instructions retired per cycle). Bad speculation is at a low ratio. There is some divider activity, which VTune points out. A division is a very expensive operation. This is caused by the initialization of the matrices, where we normalize our random numbers to be between 0.0 and1.0; we can easily get rid of this by setting:

double randnorm = 1.0/((double) RAND_MAX);

and replacing division by multiplication; for instance:

   for(int i=0;i<nmatrices*msize2;i++){

c[i]=((double) rand())*randnorm;


Figure 7-11.
figure 11

Summary output of a general exploration analysis in VTune

Similarly, for the initialization of a and b. More severe seems to be the low floating-point utilization of 0.034. This goes hand in hand with our observation of low GFLOP rates. In the next section, we will make a first attempt to tackle this.

Using a Manual Implementation in C

Our real problem here seems to be that the DGEMM routine is a total overkill for a 4×4 matrix multiplication. We could make it more lightweight and spell out the mathematical operations explicitly:

void mymatrixmethod(int m, double* a, double* b, double* c){


for(int i=0;i<4;i++){

for(int j=0;j<4;j++){

for(int l=0;l<4;l++){





} else {

cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,

m, m, m,1.0, a,m, b,m, 1.0,c,m);



Since we are exclusively using 4x4 matrix multiplications, the branch predictor will not cause pipeline flushes, owing to the additional if statement; still, the method is valid for all square matrix sizes.

Let’s now create a new binary with the code changes lined out and rerun the general exploration analysis of VTune. Figure 7-12 shows the output of VTune. What a big leap. We improved from 17.474s to 6.166s in execution time. We dropped in the CPI, though, but this reinforces the point that it is important which instructions we retire, not how many. The FP arithmetic ratio took a big step from 0.034 to 0.213 (see output). This result is going in the right direction. Now let’s estimate the floating-point performance. A basic hotspot analysis shows that we spend 4.04s in main; we’ll assume that this is all compute, for the time being. Following the above considerations, we do 12.80 GFLOP/4.04s = 3.17 GFLOP/s. That’s a lot better, but is it still not enough! If you look at Figure 7-12 again, you will see that all the FP arithmetic is spend in “FP scalar.” The code doesn’t vectorize properly. Now, let’s use the compiler directives to help the compiler vectorize the code.

Figure 7-12.
figure 12

Summary page of general exploration analysis after changing to an explicit c expression

Vectorization with Directives

We found that we increased our performance significantly with a highly specialized method, but there was no vectorization present and hence the pressure was increasing on the back end. Let’s now try to ease the pressure by mandating vectorization:

void mymatrixmethod(int m, double* a, double* b, double* c){


for(int i=0;i<4;i++){

   #pragma simd

for(int j=0;j<4;j++){

   #pragma unroll(4)

for(int l=0;l<4;l++){





} else {

cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,                    m, m, m, 1.0, a, m, b, m, 1.0, c, m);



Here, we unrolled the inner loop four times and vectorized the outer loop.

Figure 7-13 shows the result of a general exploration analysis. We got even better results, but—no surprise—the “FP arithmetic” literally vanished because now everything is executed in vectors. Compared to memory operations, there is comparatively little time spent in computing. The pressure is now almost fully on the memory subsystem, so our execution functions perfectly.

Figure 7-13.
figure 13

General exploration summary after enforcing vectorization


Try to insert the intrinsics method for a 4x4 matrix multiplication developed earlier in this chapter into our sample problem. Can you get better than the result achieved with the compiler only?


We presented a brief account of the microarchitecture of modern Intel processors, plus discussed how to detect microarchitectural issues and how to solve them, ranging from hinting the compiler via directives to programming brute-force solutions using intrinsics.

As for microarchitectural design, the scope of this chapter is certainly too tight to look much deeper. Many good textbooks are available, such as the standards by Hennessy and Patterson13 or Tanenbaum.14 Hager and Wellein15 focus particularly on tuning and performance aspects. Intel’s software developer manual16 and its optimization reference manual17 are always good, if extensive, reads.

Innovative usage employing the techniques presented here can be found in the open-source space, particularly in software that has confined hotspots, such as quantum chromodynamics, molecular dynamics, or quantum chemistry applications, such as CP2K18 or Gromacs.19


1. S. P. Dandamudi, Introduction to Assembly Language Programming (Springer, 2005).

2. Intel, “Intel 64 and IA-32 Architectures Software Developer Manuals,” 2014, www.intel.com/products/processor/manuals .

3. A. S. Tanenbaum, Structured Computer Organization, 5th ed. (Pearson, 2006).

4. Ibid.

5. J. L. Hennessy and D. A. Patterson, Computer Architecture (Morgan Kaufmann, 2007).

6. “Intel 64 and IA-32 Architectures Software Developer Manual.”

7. Intel, “Intel 64 and IA-32 Architectures Optimization Reference Manual,” 2014, www.intel.com/products/processor/manuals .

8. “Intel Intrisics Guide,” https://software.intel.com/sites/landingpage/IntrinsicsGuide .

9. “BLAS (Basic Linear Algebra Subprograms),” http://www.netlib.org/blas .

10. “Intel Intrinsics Guide”

11. J. Hutter, M. Krack, T. Laino, and J. VandeVondele, “CP2K Open Source Molecular Dynamics,” www.cp2k.org .

12. “BLAS (Basic Linear Algebra Subprograms)”

13. Hennessy and Patterson, Computer Architecture.

14. Tanenbaum, Structured Computer Organization.

15. G. Hager and G. Wellein, Introduction to High Performance Computing for Scientists and Engineers (CRC Press, 2011).

16. “Intel 64 and IA-32 Architectures Software Developer Manual.”

17. “Intel 64 and IA-32 Archtectures Optimization Reference Manual.”

18. Hutter et al., “CP2K Open Source Molecular Dynamics.”

19. E. Lindahl, D. van der Spoel, and B. Hess, “Gromacs,” www. Gromacs.org .