Lecture 012

Optimizations

Levels of optimization

• compile, execute

• processors, memory system

• program performance, identify bottlenecks

• improve performance without destroying code modularity

Compiler: don't improve asymptotic efficiency

• register allocation

• code selection. ordering, scheduling

  • calculate loop invariant before hand
  • address increment in loop

• dead code elimination

• eliminating minor inefficiencies

• arithmetic

  • multiply to shift
  • multiply to addition
  • re-use expressions

Optimization Blockers

Limitation:

• compiler does not change program behavior

• compiler does not understand contracts (when data range more restricted than type)

• optimization analysis only within a procedure (new GCC analyze file)

• only based on static information

Procedure Calls

Since compiler does not optimize calling procedure, because functions may invoke side-effects, loop invariant involving function calls are not optimized. Compiler treats function calls as black box.

Remedies: use inline function so that compiler can optimize

Memory Aliasing

When two variable belong to the same space in memory, optimizations can be hindered because behavior of memory manipulation can change based on whether two inputs are in the same region of memory.

Remedies:

• add key word restrict:

  

• remove aliasing out of loop:

  

Instruction-Level Parallelism

Super-scalar Processor: can issue and execute multiple instructions in one cycle. Instructions are retried from a sequential instruction stream and are scheduled dynamically.

If an instruction takes more than one cycle, they can be scheduled.

Typical Hardware capability:

Loop unrolling: two operation at a time.

• original code:

  

• two operation per cycle:

  

Loop re-association:

• may change result if it is floating point

• 

Separate Accumulators: turn multiplication in loop to something like merge sort.

• 

• 

• 

Programming with AVX2 (YMM Registers, SIMD Operations)

• YMM Registers can hold many value in one place:

  

• parallel calculation with SIMD:

  

Conditionals

Branch prediction default behavior: (95% accuracy)

• if branch goes back, it is a loop, take the branch

• forward branches not taken

General Practice

Optimization

1. use correct data structure for asymptotic complexity
2. Good compiler flag (-O3)
3. Watch out for optimization blocker
   • procedure calls
   • memory reference
4. Optimize inner most loops
5. exploit instruction-level parallelism
6. avoid unpredictable branches
7. cache friendly