Efficient Go

Spis treści książki

• 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!
  • OReilly 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 Arent 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 dont 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
  • Dont 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

pokaż cały spis treści

ukryj recenzje