dgryski/go-perfbook

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.

Star history