dgryski/go-perfbook
Go Perfbook
This project is a collection of educational resources and technical guides focused on Go performance optimization. It provides instruction on improving execution speed and reducing memory usage through code and architectural refinements.
The guides cover advanced strategies for low-level programming, including the use of assembly for SIMD instructions and unsafe pointers for direct memory manipulation. It also details concurrency optimization techniques such as lock sharding and cache-line padding to reduce contention and improve hardware utilization.
The material encompasses broad capability areas including memory management to reduce garbage collection pressure, runtime execution optimization to minimize interface overhead, and the use of profiling and benchmarking to identify system bottlenecks. It also addresses algorithmic efficiency and the reduction of overhead when integrating with C libraries.
Features
- Go Performance Optimization - A comprehensive guide for improving execution speed and resource efficiency in Go applications.
- SIMD Implementations - Guides the implementation of critical paths using manual assembly and SIMD instructions to bypass compiler limits.
- High-Level Language Assembly Integration - Provides instructions for implementing critical paths in assembly to utilize SIMD instructions and hardware capabilities.
- Context Reuse Strategies - Provides strategies for reusing buffers and state structures to minimize allocation overhead and garbage collection pressure.
- Low-Level Systems Programming - Covers the implementation of critical paths using assembly and unsafe memory operations for maximum throughput.
- Contention-Minimizing Locking Strategies - Describes strategies to reduce lock contention using mutex sharding and padding to prevent false sharing.
- Cache Locality Optimizations - Guides the alignment of data structures with CPU cache lines to reduce pointer chasing and maximize throughput.
- Execution Optimizations - Implements runtime execution optimizations such as reducing interface call overhead and eliminating bounds checks.
- Go Memory Optimization - Guides the reduction of garbage collection pressure through optimized allocations and struct layouts in Go.
- Pointer-Free Allocations - Details the use of pointer-free memory allocations to allow the garbage collector to bypass object scanning.
- Algorithmic Performance Optimizations - Offers techniques for analyzing and improving the time and space complexity of algorithms to prevent degradation.
- Data Structure Optimizations - Demonstrates how to improve performance by adding redundant fields, search indices, or caches to data structures.
- Memory Manipulation - Instruction on using unsafe pointers for direct memory access and high-speed deserialization.
- Lock-Striped Sharding - Demonstrates lock-striped sharding to fragment global locks and reduce mutex contention in concurrent data structures.
- Cache-Line Padding - Implements cache-line padding to prevent false sharing and reduce CPU cache coherence traffic.
- General Resource Bottleneck Detection - Implements techniques for identifying performance bottlenecks and resource shortages across CPU, memory, and storage.
- Application Performance Profiling - Teaches how to identify execution bottlenecks and hot paths using CPU and memory profiling tools.
- GC Pressure Reduction - Provides strategies for reducing garbage collector pressure through buffer reuse and avoiding heap allocations.
- Performance Analysis - Provides methods and tools for interpreting performance data to identify system bottlenecks and evaluate efficiency.
- Profiling and Benchmarking - Provides methods for identifying bottlenecks using CPU/memory profiling and flame graphs.
- Memory Footprint Optimizers - Offers techniques for lowering memory consumption by eliminating structure padding and using smaller data types.
- Memory Management Guides - Educational resources for minimizing garbage collection pressure via buffer reuse and pointer-free structures.
- Go-C Bridges - Provides guidance on minimizing transitions between Go and C to reduce Cgo call overhead.
- Method Call Specialization - Explains how to specialize method calls to reduce the overhead of virtual interface dispatch.
- Concurrency Optimization - Guides the use of mutex sharding and cache line padding to reduce lock contention.
- High-Concurrency Runtimes - Provides architectural patterns for scaling Go services through reduced lock contention and CPU cache locality.
- Performance Optimization Libraries - Recommends specialized high-performance libraries as alternatives to standard library packages for JSON and HTTP.
- Low-Level Hardware Optimization - Provides advanced strategies for using unsafe pointers and assembly to optimize hardware cache and SIMD usage.
- Space-Time Trade-off Strategies - Explains how to balance memory and CPU usage by storing precalculated data or calculating on-the-fly.
- Application Runtime Profilers - Analyzes CPU and memory usage using sampling tools to identify hot paths and allocation bottlenecks.
- Performance Benchmarkers - Creates reproducible performance measurements using representative workloads and statistical tests.
- Real-World Workload Benchmarking - Provides methods for benchmarking using data distributions that simulate real-world production traffic patterns.
- Performance Optimization - Detailed guide to writing high-performance Go code.
