Compiler Optimizations and Inlining

Go’s compiler performs various optimizations to improve performance. Understanding these optimizations helps you write code that compiles efficiently.

Function Inlining

Inlining replaces function calls with the function body, eliminating call overhead.

Good: Inline-Friendly Functions

package main

import (
	"fmt"
)

// Small function - likely to be inlined
func add(a, b int) int {
	return a + b
}

// Small function - likely to be inlined
func isPositive(x int) bool {
	return x > 0
}

// Larger function - won't be inlined
func complexCalculation(a, b, c int) int {
	result := a + b
	result *= c
	result -= a
	result /= 2
	if result < 0 {
		result = -result
	}
	return result
}

func main() {
	x := add(5, 3)
	y := isPositive(x)
	z := complexCalculation(10, 20, 30)
	
	fmt.Println(x, y, z)
}

Bad: Preventing Inlining

// ❌ AVOID: Functions that prevent inlining
package main

import (
	"fmt"
)

// Defer prevents inlining
func withDefer(x int) int {
	defer func() {
		// Cleanup
	}()
	return x * 2
}

// Panic prevents inlining
func withPanic(x int) int {
	if x < 0 {
		panic("negative value")
	}
	return x * 2
}

// Recover prevents inlining
func withRecover(x int) int {
	defer func() {
		recover()
	}()
	return x * 2
}

func main() {
	fmt.Println(withDefer(5))
}

Analyzing Inlining

Use compiler flags to see inlining decisions.

Checking Inlining

# Show inlining decisions
go build -gcflags="-m" main.go

# More verbose output
go build -gcflags="-m -m" main.go

# Example output:
# ./main.go:5:6: can inline add
# ./main.go:9:6: can inline isPositive
# ./main.go:14:6: cannot inline complexCalculation

Example Analysis

package main

import (
	"fmt"
)

func small(x int) int {
	return x * 2
}

func medium(x int) int {
	result := x * 2
	result += x
	return result
}

func large(x int) int {
	result := x * 2
	result += x
	result -= 5
	if result < 0 {
		result = -result
	}
	result *= 3
	return result
}

func main() {
	fmt.Println(small(5))
	fmt.Println(medium(5))
	fmt.Println(large(5))
}

Run with: go build -gcflags="-m" main.go

Compiler Directives

Use compiler directives to control optimization behavior.

NoInline Directive

package main

import (
	"fmt"
)

// Prevent inlining
//go:noinline
func expensiveFunction(x int) int {
	// Complex logic that shouldn't be inlined
	sum := 0
	for i := 0; i < x; i++ {
		sum += i
	}
	return sum
}

func main() {
	result := expensiveFunction(1000)
	fmt.Println(result)
}

Inline Directive

package main

import (
	"fmt"
)

// Force inlining
//go:inline
func criticalPath(x int) int {
	return x * 2
}

func main() {
	result := criticalPath(5)
	fmt.Println(result)
}

Build Constraints

// +build linux,amd64

package main

import (
	"fmt"
)

func platformSpecific() {
	fmt.Println("Running on Linux AMD64")
}

func main() {
	platformSpecific()
}

Dead Code Elimination

The compiler removes unreachable code.

Good: Compiler Eliminates Dead Code

package main

import (
	"fmt"
)

const debug = false

func main() {
	if debug {
		// This code is eliminated at compile time
		fmt.Println("Debug mode")
	}
	
	fmt.Println("Production code")
}

Dead Code Example

package main

import (
	"fmt"
)

func unreachableCode() {
	fmt.Println("Reachable")
	return
	fmt.Println("Unreachable") // Eliminated
}

func main() {
	unreachableCode()
}

Constant Folding

The compiler evaluates constant expressions at compile time.

Good: Constant Folding

package main

import (
	"fmt"
)

const (
	width  = 1024
	height = 768
)

// Compiler evaluates this at compile time
const area = width * height

func main() {
	fmt.Println("Area:", area)
}

Compile-Time Evaluation

package main

import (
	"fmt"
)

const (
	a = 10
	b = 20
	c = a + b // Evaluated at compile time
)

func main() {
	// No runtime computation needed
	fmt.Println(c)
}

Bounds Check Elimination

The compiler eliminates redundant bounds checks.

Good: Bounds Check Elimination

package main

import (
	"fmt"
)

func processSlice(s []int) {
	// Compiler can eliminate bounds checks in this loop
	for i := 0; i < len(s); i++ {
		s[i] = s[i] * 2
	}
}

func main() {
	slice := []int{1, 2, 3, 4, 5}
	processSlice(slice)
	fmt.Println(slice)
}

Bounds Check Analysis

# Show bounds check elimination
go build -gcflags="-d=ssa/check_bce/debug=1" main.go

Nil Check Elimination

The compiler eliminates redundant nil checks.

Good: Nil Check Optimization

package main

import (
	"fmt"
)

type Node struct {
	value int
	next  *Node
}

func traverse(n *Node) {
	for n != nil {
		fmt.Println(n.value)
		n = n.next
	}
}

func main() {
	node := &Node{value: 1}
	node.next = &Node{value: 2}
	traverse(node)
}

Escape Analysis Optimization

The compiler uses escape analysis to optimize allocations.

Good: Stack Allocation

package main

import (
	"fmt"
)

type Point struct {
	x, y int
}

// Compiler allocates on stack
func createPoint() Point {
	return Point{x: 10, y: 20}
}

func main() {
	p := createPoint()
	fmt.Println(p)
}

Heap Allocation

package main

import (
	"fmt"
)

type Point struct {
	x, y int
}

// Compiler allocates on heap
func createPointPointer() *Point {
	p := Point{x: 10, y: 20}
	return &p // Escapes to heap
}

func main() {
	p := createPointPointer()
	fmt.Println(p)
}

Build Optimization Flags

Optimization Levels

# Default build (with optimizations)
go build main.go

# Disable optimizations (useful for debugging)
go build -gcflags="-N -l" main.go
# -N: disable optimizations
# -l: disable inlining

# Enable more aggressive optimizations
go build -gcflags="-B" main.go
# -B: disable bounds checking

Build Tags

// +build debug

package main

import (
	"fmt"
)

func debugMode() {
	fmt.Println("Debug build")
}

Build with: go build -tags debug main.go

Profiling Compiler Optimizations

Measuring Impact

# Build with optimizations
go build -o optimized main.go

# Build without optimizations
go build -gcflags="-N -l" -o unoptimized main.go

# Compare performance
time ./optimized
time ./unoptimized

Practical Optimization Example

Before Optimization

package main

import (
	"fmt"
)

func fibonacci(n int) int {
	if n <= 1 {
		return n
	}
	return fibonacci(n-1) + fibonacci(n-2)
}

func main() {
	result := fibonacci(35)
	fmt.Println(result)
}

After Optimization

package main

import (
	"fmt"
)

// Memoization with inline-friendly function
func fibonacci(n int) int {
	cache := make(map[int]int)
	var fib func(int) int
	fib = func(x int) int {
		if x <= 1 {
			return x
		}
		if val, ok := cache[x]; ok {
			return val
		}
		result := fib(x-1) + fib(x-2)
		cache[x] = result
		return result
	}
	return fib(n)
}

func main() {
	result := fibonacci(35)
	fmt.Println(result)
}

Best Practices

Write Simple Functions: Small, simple functions are more likely to be inlined
Avoid Defer in Hot Paths: Defer prevents inlining
Use Compiler Flags: Analyze inlining with -m flag
Profile Before Optimizing: Use profiling to identify bottlenecks
Understand Trade-offs: Inlining increases code size
Use Build Tags: Optimize for different platforms
Leverage Constants: Use const for compile-time evaluation
Measure Impact: Always measure optimization impact

Common Pitfalls

Over-Inlining: Inlining increases binary size
Premature Optimization: Optimize based on profiling, not assumptions
Ignoring Compiler Warnings: Pay attention to compiler messages
Platform-Specific Issues: Test on target platforms
Disabling Optimizations: Don’t disable optimizations without reason

Resources

Summary

Go’s compiler performs automatic optimizations including inlining, dead code elimination, and escape analysis. Write simple, focused functions to enable inlining. Use compiler flags to analyze optimization decisions. Profile your code to identify actual bottlenecks before optimizing. Remember that compiler optimizations are most effective when combined with good algorithmic design.