Efficient Go: Data-Driven Performance Optimization 9781098105716

With technological advancements, fast markets, and higher complexity of systems, software engineers tend to skip the unc

138 38 8MB

English Pages 495 Year 2023

Report DMCA / Copyright

DOWNLOAD EPUB FILE

Table of contents :
Preface
Why I Wrote This Book
How I Gathered This Knowledge
Who This Book Is For
How This Book Is Organized
Conventions Used in This Book
Using Code Examples
Acknowledgments
Feedback Is Welcome!
O’Reilly Online Learning
How to Contact Us
1. Software Efficiency Matters
Behind Performance
Common Efficiency Misconceptions
Optimized Code Is Not Readable
Code after optimization can be more readable
Readability now versus past
You Aren’t Going to Need It
Hardware Is Getting Faster and Cheaper
Software expands to fill the available memory
Software gets slower more rapidly than hardware becomes faster
Technological limits
Faster execution is more energy efficient
We Can Scale Horizontally Instead
Time to Market Is More Important
The Key to Pragmatic Code Performance
Summary
2. Efficient Introduction to Go
Basics You Should Know About Go
Imperative, Compiled, and Statically Typed Language
Designed to Improve Serious Codebases
Governed by Google, Yet Open Source
Simplicity, Safety, and Readability Are Paramount
Packaging and Modules
Dependencies Transparency by Default
Consistent Tooling
Single Way of Handling Errors
Strong Ecosystem
Unused Import or Variable Causes Build Error
Unit Testing and Table Tests
Advanced Language Elements
Code Documentation as a First Citizen
Backward Compatibility and Portability
Go Runtime
Object-Oriented Programming
Generics
Is Go “Fast”?
Summary
3. Conquering Efficiency
Beyond Waste, Optimization Is a Zero-Sum Game
Reasonable Optimizations
Deliberate Optimizations
Optimization Challenges
Understand Your Goals
Efficiency Requirements Should Be Formalized
Resource-Aware Efficiency Requirements
Acquiring and Assessing Efficiency Goals
Example of Defining RAER
Got an Efficiency Problem? Keep Calm!
Optimization Design Levels
Efficiency-Aware Development Flow
Functionality Phase
1. Test functionality first
2. Do we pass the functional tests?
3. If the tests fail, we have to fix, implement, or design the missing parts
Efficiency Phase
4. Efficiency assessment
5. Are we within RAERs?
6. Find the main bottleneck
7. Choice of level
8. Optimize!
9. Release and enjoy!
Summary
4. How Go Uses the CPU Resource (or Two)
CPU in a Modern Computer Architecture
Assembly
Understanding Go Compiler
CPU and Memory Wall Problem
Hierachical Cache System
Pipelining and Out-of-Order Execution
Hyper-Threading
Schedulers
Operating System Scheduler
Go Runtime Scheduler
When to Use Concurrency
Summary
5. How Go Uses Memory Resource
Memory Relevance
Do We Have a Memory Problem?
Physical Memory
OS Memory Management
Virtual Memory
mmap Syscall
OS Memory Mapping
Go Memory Management
Values, Pointers, and Memory Blocks
Go Allocator
Garbage Collection
Summary
6. Efficiency Observability
Observability
Example: Instrumenting for Latency
Logging
Tracing
Metrics
Efficiency Metrics Semantics
Latency
CPU Usage
Memory Usage
runtime heap statistics
OS memory pages statistics
Summary
7. Data-Driven Efficiency Assessment
Complexity Analysis
“Estimated” Efficiency Complexity
Asymptotic Complexity with Big O Notation
Practical Applications
If you know precise complexity, you don’t need to measure to know expected resource requirements
It tells us if there is any easy optimization to our code
It helps us assess ideas for a better algorithm as an optimization
It tells us where the bottleneck is and what part of the algorithm is critical
The Art of Benchmarking
Comparison to Functional Testing
Benchmarks Lie
Reliability of Experiments
Human Errors
Reproducing Production
Performance Nondeterminism
Benchmarking Levels
Benchmarking in Production
Macrobenchmarks
Microbenchmarks
What Level Should You Use?
Summary
8. Benchmarking
Microbenchmarks
Go Benchmarks
Understanding the Results
Tips and Tricks for Microbenchmarking
Too-High Variance
Find Your Workflow
Test Your Benchmark for Correctness!
Sharing Benchmarks with the Team (and Your Future Self)
Running Benchmarks for Different Inputs
Microbenchmarks Versus Memory Management
Compiler Optimizations Versus Benchmark
Macrobenchmarks
Basics
Go e2e Framework
Understanding Results and Observations
Server-side latency
CPU time
Memory
Common Macrobenchmarking Workflows
Summary
9. Data-Driven Bottleneck Analysis
Root Cause Analysis, but for Efficiency
Profiling in Go
pprof Format
go tool pprof Reports
Top
Graph
Flame Graph
Peek, Source, and Disassemble
Capturing the Profiling Signal
Common Profile Instrumentation
Heap
Goroutine
CPU
Off-CPU Time
Tips and Tricks
Sharing Profiles
Continuous Profiling
Comparing and Aggregating Profiles
Summary
10. Optimization Examples
Sum Examples
Optimizing Latency
Optimizing bytes.Split
Optimizing runtime.slicebytetostring
Optimizing strconv.Parse
Optimizing Memory Usage
Moving to Streaming Algorithm
Optimizing bufio.Scanner
Optimizing Latency Using Concurrency
A Naive Concurrency
A Worker Approach with Distribution
A Worker Approach Without Coordination (Sharding)
A Streamed, Sharded Worker Approach
Bonus: Thinking Out of the Box
Summary
11. Optimization Patterns
Common Patterns
Do Less Work
Trading Functionality for Efficiency
Trading Space for Time
Trading Time for Space
The Three Rs Optimization Method
Reduce Allocations
Reuse Memory
Recycle
Don’t Leak Resources
Control the Lifecycle of Your Goroutines
Reliably Close Things
Exhaust Things
Pre-Allocate If You Can
Overusing Memory with Arrays
Memory Reuse and Pooling
Summary
Next Steps
A. Latencies for Napkin Math Calculations
Index

Efficient Go: Data-Driven Performance Optimization
 9781098105716

  • 0 0 0
  • Like this paper and download? You can publish your own PDF file online for free in a few minutes! Sign Up
Recommend Papers