Performance_basics

Performance Optimization Basics

This chapter covers essential techniques for writing high-performance C++ code.

Rule of Optimization

┌─────────────────────────────────────────────────────────────┐
│                   Rule of Optimization                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. Don't optimize prematurely                              │
│  2. Profile first to find bottlenecks                       │
│  3. Measure after optimization                               │
│  4. Focus on the critical path                              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Common Optimizations

1. Use const Correctly

// Allows compiler optimizations
void process(const std::vector<int>& data);

2. Pass by Reference

// Bad: Copy
void process(std::vector<int> v);

// Good: Reference
void process(const std::vector<int>& v);

3. Use Reserve for Vectors

std::vector<int> v;
v.reserve(1000);  // Pre-allocate

4. Avoid Unnecessary Copies

// Bad
auto copy = original;

// Good
auto& ref = original;

5. Use Inline Functions

inline int square(int x) { return x * x; }

6. Prefer Stack over Heap

// Bad: Heap allocation
int* arr = new int[100];

// Good: Stack allocation
int arr[100];

Profiling Tools

• gprof: GNU profiler
• Valgrind: Memory profiler
• perf: Linux performance analyzer
• Visual Studio Profiler: Windows

Compiler Optimizations

# Basic optimization
g++ -O2 program.cpp -o program

# Aggressive optimization
g++ -O3 program.cpp -o program

# Optimize for size
g++ -Os program.cpp -o program

Key Takeaways

• Profile before optimizing
• Focus on algorithmic improvements first
• Use compiler optimizations
• Prefer stack over heap when possible
• Use const and references appropriately