Efficient go index (CloudMonk.io)
Efficient Go Index
Return to Efficient Go by Bartlomiej Plotka, Golang Bibliography, Golang
" (EffGo, 2023)
A
* A/B testing, Microbenchmarks
* accessibility, efficiency and, Faster execution is more energy efficient
* accuracy, in performance context, Behind Performnce
* Adamczewski, Bartosz, on optimizations/pessimizations, Optimization Examples
* Alexandrescu, Andrei
* on code that “leans to the left”, Pipelining and Out-of-Order Execution
* on efficient design, Optimized Code Is Not Readable
* on speed versus correctness, Functionality Phase
* algorithm and data structure optimization level, Optimization Design Levels
* Allen, Arnold O., on performance, Behind Performnce
* alloc (heap) profile, Heap-Heap
* Allocator (see Go Allocator)
* Amazon, cost of latency to, Time to Market Is More Important
* Andreessen, Marc, on democratization of software, Software gets slower more rapidly than hardware becomes faster
* anonymous file mapping, OS Memory Mapping
* arrays
* lined lists versus, Pipelining and Out-of-Order Execution
* overusing memory with, Overusing Memory with Arrays-Overusing Memory with Arrays
* Assembly language
* CPU time and, Assembly-Assembly
* machine code and, Assembly
* asymptotic complexity with Big O notation, Asymptotic Complexity with Big O Notation-Asymptotic Complexity with Big O Notation
* asymptotic complexity, “estimated” efficiency complexity versus, “Estimated” Efficiency Complexity
* averages, percentiles versus, Latency-Latency
B
* background threads, as source of noise, Performnce Nondeterminism
* backward compatibility, Backward Compatibility and Portability
* benchmarks/benchmarking, Benchmarking-Summary
* (see also efficiency assessment)
* avoiding efficiency comparisons with older experiment results, Performnce Nondeterminism
* cheating/lying stereotype, Benchmarks Lie
* choosing test data and conditions, Go Benchmarks
* compiler optimization countermeasures, Compiler Optimizations Versus Benchmark
* data-driven efficiency assessment and, The Art of Benchmarking-Benchmarks Lie
* determining appropriate level, What Level Should You Use?
* functional testing versus, Comparison to Functional Testing-Comparison to Functional Testing
* human error and, Human Errors-Human Errors
* implementation, Benchmarking-Summary
* levels of, Benchmarking Levels-What Level Should You Use?
* macrobenchmarks (see macrobenchmarks/macrobenchmarking)
* microbenchmarks (see microbenchmarks/microbenchmarking)
* misinterpretation of results, Benchmarks Lie
* noise problems, Performnce Nondeterminism-Performnce Nondeterminism
* in production, Benchmarking in Production
* relevance, Reproducing Production-Reproducing Production
* stress/load tests versus, The Art of Benchmarking
* benchstat tool, Understanding the Results-Understanding the Results
* Bentley, Jon Louis
* list of levels in software execution, Optimization Design Levels
* on Pascal running time, Practical Applications
* on primary concerns of programmer, Efficiency-Aware Development Flow
* on primary task of software engineers, Software Efficiency Matters
* on programmers’ assessment of resource consumption, Data-Driven Bottleneck Analysis
* on test data choices, Comparison to Functional Testing
* biases, in optimization, Optimization Design Levels
* Big O asymptotic complexity, Asymptotic Complexity with Big O Notation-Asymptotic Complexity with Big O Notation
* “estimated” efficiency complexity versus, “Estimated” Efficiency Complexity
* Big Theta, Asymptotic Complexity with Big O Notation
* binary file, Understanding Go Compiler
* blameless culture, efficiency problems and, Got an Efficiency Problem? Keep Calm!
* block starting symbol (.bss), Go Memory Management
* bottleneck analysis, Data-Driven Bottleneck Analysis-Summary
* capturing the profiling signal, Capturing the Profiling Signal-Capturing the Profiling Signal
* comparing/aggregating profiles, Comparing and Aggregating Profiles
* continuous profiling, Continuous Profiling-Continuous Profiling
* in off-CPU time, Off-CPU Time
* profiling in Go, Profiling in Go-Peek, Source, and Disassemble
* (see also profiling)
* as root cause analysis for efficiency, Root Cause Analysis, but for Efficiency
* sharing profiles, Sharing Profiles
* tips and tricks, Tips and Tricks-Comparing and Aggregating Profiles
* branch predictions, Pipelining and Out-of-Order Execution
* Branczyk, Frederic
* on continuous profiling, Continuous Profiling
* bufio.Scanner, optimizing, Optimizing bufio.Scanner-Optimizing bufio.Scanner
* build errors due to unused import/variable, Unused Import or Variable Causes Build Error
* Burks, Arthur W., on general-purpose computers, CPU in a Modern Computer Architecture
* byte (definition), Physical Memory
* bytes.Split, optimizing, Optimizing bytes.Split-Optimizing bytes.Split
C
* cache, hierarchical, Hierarchical Cache System
* cardinality, Metrics
* Carlton, Alexander, on performance benchmarks, Benchmarks Lie
* Carruth, Chandler
* on energy-efficient software, Faster execution is more energy efficient
* on time spent waiting for data, CPU and Memory Wall Problem
* CD Projekt, Time to Market Is More Important
* CFS (Completely Fair Scheduler), Operating System Scheduler
* channels, Go Runtime Scheduler-Go Runtime Scheduler
* Cheney, Dave
* on goroutines, Control the Lifecycle of Your Goroutines
* on variables, Values, Pointers, and Memory Blocks
* CI (Continuous Integration) pipeline, noise problems and, Performnce Nondeterminism
* code coverage, What Level Should You Use?
* code level optimization, Optimization Design Levels
* Communicating Sequential Processes (CSP), Go Runtime Scheduler
* compilation (see Go compiler)
* compiler optimizations, microbenchmarks versus, Compiler Optimizations Versus Benchmark-Compiler Optimizations Versus Benchmark
* Completely Fair Scheduler (CFS), Operating System Scheduler
* complexity analysis, Complexity Analysis-It tells us where the bottleneck is and what part of the algorithm is critical
* asymptotic complexity with Big O notation, Asymptotic Complexity with Big O Notation-Asymptotic Complexity with Big O Notation
* “estimated” efficiency complexity, “Estimated” Efficiency Complexity-“Estimated” Efficiency Complexity
* practical applications, Practical Applications-It tells us where the bottleneck is and what part of the algorithm is critical
* complexity, in RAER context, Resource-Aware Efficiency Requirements, Example of Defining RAER
* compressible resources, Performnce Nondeterminism
* concurrency
* advantages, When to Use Concurrency
* CPU resource and, When to Use Concurrency-When to Use Concurrency
* disadvantages, When to Use Concurrency
* optimizing latency using, Optimizing Latency Using Concurrency-A Streamed, Sharded Worker Approach
* containers
* Go e2e framework and, Go e2e Framework-Go e2e Framework
* macrobenchmarking in, Go e2e Framework, Go e2e Framework
* versioning of images, Go e2e Framework
* context switch, Pipelining and Out-of-Order Execution
* Continuous Integration (CI) pipeline, noise problems and, Performnce Nondeterminism
* continuous profiling, Continuous Profiling-Continuous Profiling
* Cox, Russ
* on generics, Generics
* and Go team, Designed to Improve Serious Codebases
* on sinks, Compiler Optimizations Versus Benchmark
* CPU overloading, Operating System Scheduler
* CPU resource, How Go Uses the CPU Resource (or Two)-Summary
* Assembly language, Assembly-Assembly
* concurrency and, When to Use Concurrency-When to Use Concurrency
* contiguous memory structure and, Pipelining and Out-of-Order Execution
* efficiency metrics semantics, CPU Usage-CPU Usage
* Go compiler and, Understanding Go Compiler-Understanding Go Compiler
* hierarchical cache system, Hierarchical Cache System
* Hyper-Threading and, Hyper-Threading-Hyper-Threading
* macrobenchmarking and, CPU time-CPU time
* memory wall problem, CPU and Memory Wall Problem-Hyper-Threading
* modern computer architecture and, CPU in a Modern Computer Architecture-CPU in a Modern Computer Architecture
* on overloaded machine, Operating System Scheduler
* pipelining and out-of-order CPU execution, Pipelining and Out-of-Order Execution-Pipelining and Out-of-Order Execution
* profiling CPU usage, CPU-CPU
* profiling off-CPU time, Off-CPU Time-Off-CPU Time
* schedulers, Schedulers-When to Use Concurrency
* Cramblitt, Bob, on repeatability, Comparison to Functional Testing
* Cyberpunk 2077 game, Time to Market Is More Important
D
* data-driven bottleneck analysis (see bottleneck analysis)
* data-driven efficiency assessment (see efficiency assessment)
* data-driven optimization level, Optimization Design Levels
* dead code elimination, Compiler Optimizations Versus Benchmark
* deliberate optimizations, Deliberate Optimizations
* Dennard, Robert H., on power efficiency of transistors, Technological limits
* Dennard's Rule, Moore's Law versus, Technological limits
* dependencies, transparency of, Dependencies Transparency by Default-Dependencies Transparency by Default
* development, efficiency-aware flow, Efficiency-Aware Development Flow-9. Release and enjoy!
* Disassemble view, Peek, Source, and Disassemble
* Docker containers, Go e2e framework and, Go e2e Framework-Go e2e Framework
* documentation, as first citizen, Code Documentation as a First Citizen-Code Documentation as a First Citizen
* dogfooding, Acquiring and Assessing Efficiency Goals
* dynamic random-access memory (DRAM), Physical Memory
E
* e2e framework, Go e2e Framework-Go e2e Framework
* ecosystem, Go, Strong Ecosystem
* efficiency (generally), Conquering Efficiency-Summary
* acquiring/assessing goals, Acquiring and Assessing Efficiency Goals
* common misconceptions about, Common Efficiency Misconceptions-Time to Market Is More Important
* (see also misconceptions about efficiency)
* conquering, Conquering Efficiency-Summary
* in context of performance, Behind Performnce
* defining/assessing requirements, Example of Defining RAER-Example of Defining RAER
* efficiency-aware development flow, Efficiency-Aware Development Flow-9. Release and enjoy!
* features versus, Time to Market Is More Important
* formalizing of requirements, Efficiency Requirements Should Be Formalized-Efficiency Requirements Should Be Formalized
* importance of, Software Efficiency Matters-Summary
* key to pragmatic code performance, The Key to Pragmatic Code Performnce-The Key to Pragmatic Code Performnce
* optimization and (see optimization)
* performance definitions, Behind Performnce-Behind Performnce
* reacting to efficiency problems, Got an Efficiency Problem? Keep Calm!-Got an Efficiency Problem? Keep Calm!
* speed versus, The Key to Pragmatic Code Performnce-The Key to Pragmatic Code Performnce
* understanding goals, Understand Your Goals-Example of Defining RAER
* efficiency assessment, Data-Driven Efficiency Assessment-Summary
* avoiding comparisons with older experiment results, Performnce Nondeterminism
* benchmarking, The Art of Benchmarking-Benchmarks Lie
* benchmarking levels, Benchmarking Levels-What Level Should You Use?
* complexity analysis, Complexity Analysis-It tells us where the bottleneck is and what part of the algorithm is critical
* reliability of experiments, Reliability of Experiments-Performnce Nondeterminism
* efficiency metrics semantics, Efficiency Metrics Semantics-OS memory pages statistics
* CPU usage, CPU Usage-CPU Usage
* latency, Latency-Latency
* memory usage, Memory Usage-OS memory pages statistics
* efficiency observability (see observability)
* efficiency phase of TFBO, Efficiency Phase-9. Release and enjoy!
* efficiency-aware development flow, Efficiency-Aware Development Flow-9. Release and enjoy!
* efficiency phase, Efficiency Phase-9. Release and enjoy!
* functionality phase, Functionality Phase-3. If the tests fail, we have to fix, implement, or design the missing parts
* emotions, in reaction to efficiency problems, Got an Efficiency Problem? Keep Calm!
* energy consumption, execution speed and, Faster execution is more energy efficient
* Erdogmu, Hakan, on YAGNI, You Aren’t Going to Need It
* error handling
* Go's approach to, Single Way of Handling Errors-Single Way of Handling Errors
* importance of not ignoring, Single Way of Handling Errors
* wrapping errors, Single Way of Handling Errors
* errors due to unused import/variable, Unused Import or Variable Causes Build Error
* “estimated” efficiency complexity, “Estimated” Efficiency Complexity-“Estimated” Efficiency Complexity
* experiment (definition), The Art of Benchmarking
F
* fat software, Software gets slower more rapidly than hardware becomes faster
* Favaro, John, on YAGNI, You Aren’t Going to Need It
* features, efficiency versus, Time to Market Is More Important
* feedback loops, Benchmarking Levels
* file-based memory page, OS Memory Mapping
* First Rule of Efficient Code, Go Runtime Scheduler
* Flake, Halvar, on GC, Garbage Collection
* Flame Graph view, Flame Graph-Flame Graph
* Fowler, Susan J., on resources, How Go Uses the CPU Resource (or Two)
* FR (functional requirements) stage, Efficiency Requirements Should Be Formalized-Efficiency Requirements Should Be Formalized
* frames, Virtual Memory
* Full Go Profiler, Off-CPU Time
* function inlining, Understanding Go Compiler
* function stack, Go Memory Management
* functional requirements (FR) stage, Efficiency Requirements Should Be Formalized-Efficiency Requirements Should Be Formalized
* functional testing, benchmarking versus, Comparison to Functional Testing-Comparison to Functional Testing
* functionality phase of TFBO, Functionality Phase-3. If the tests fail, we have to fix, implement, or design the missing parts
G
* garbage collection (GC), Garbage Collection-Garbage Collection
* heap management and, Garbage Collection-Garbage Collection
* memory inefficiency and, Memory Relevance
* recycling and, Recycle-Recycle
* Geisendörfer, Felix, on original pprof tool, pprof Format
* general-purpose computers, CPU in a Modern Computer Architecture
* generic implementations, drawbacks of, Do Less Work
* generics
* about, Generics-Generics
* speed/efficiency issues, Generics
* Go (generally)
* advanced language elements, Advanced Language Elements-Generics
* backward compatibility and portability, Backward Compatibility and Portability
* basics, Basics You Should Know About Go-Unit Testing and Table Tests
* code documentation as first citizen, Code Documentation as a First Citizen-Code Documentation as a First Citizen
* consistent tooling, Consistent Tooling
* dependencies as transparent by default, Dependencies Transparency by Default-Dependencies Transparency by Default
* ecosystem, Strong Ecosystem
* error handling, Single Way of Handling Errors-Single Way of Handling Errors
* genealogy, Is Go “Fast”?
* generics, Generics-Generics
* Go runtime, Go Runtime
* Golang versus, Imperative, Compiled, and Statically Typed Language
* language: imperative, compiled, statically typed, Imperative, Compiled, and Statically Typed Language
* memory management, Go Memory Management-Garbage Collection
* memory usage problems, Is Go “Fast”?
* object-oriented programming, Object-Oriented Programming-Object-Oriented Programming
* open source/governed by Google, Governed by Google, Yet Open Source
* overview, Efficient Introduction to Go-Summary
* packaging and modules, Packaging and Modules
* simplicity, safety, and readability, Simplicity, Safety, and Readability Are Paramount
* speed issues, Is Go “Fast”?
* unit testing/table tests, Unit Testing and Table Tests
* unused import/variable as cause of build error, Unused Import or Variable Causes Build Error
* Go advanced features, Advanced Language Elements-Generics
* backward compatibility and portability, Backward Compatibility and Portability
* code documentation as first citizen, Code Documentation as a First Citizen-Code Documentation as a First Citizen
* generics, Generics-Generics
* Go runtime, Go Runtime
* object-oriented programming, Object-Oriented Programming-Object-Oriented Programming
* Go Allocator, Go Allocator-Go Allocator
* internal Go runtime knowledge versus OS knowledge, Go Allocator
* Go Assembly language
* CPU time and, Assembly-Assembly
* machine code and, Assembly
* Go benchmarks
* average latency calculations, Logging
* microbenchmarks, Go Benchmarks-Go Benchmarks
* naming convention, Go Benchmarks
* running through IDE, Go Benchmarks
* understanding results, Understanding the Results-Understanding the Results
* go build command, Understanding Go Compiler-Understanding Go Compiler
* Go compiler, Understanding Go Compiler-Understanding Go Compiler
* Go e2e framework, Go e2e Framework-Go e2e Framework
* Go memory management, Go Memory Management-Garbage Collection
* garbage collection, Garbage Collection-Garbage Collection
* Go Allocator, Go Allocator-Go Allocator
* Go Playground, Strong Ecosystem
* Go runtime scheduler, Go Runtime Scheduler-Go Runtime Scheduler
* Go slice, memory structure for, Values, Pointers, and Memory Blocks
* Go templates, Strong Ecosystem
* go tool pprof reports, go tool pprof Reports-Peek, Source, and Disassemble
* Disassemble view, Peek, Source, and Disassemble
* Flame Graph view, Flame Graph-Flame Graph
* function granularity flags, Top
* goroutines and, Top
* Graph view, Graph-Graph
* Peek view, Peek, Source, and Disassemble
* Source view, Peek, Source, and Disassemble
* Top report, Top-Top
* goals, understanding of, Understand Your Goals-Example of Defining RAER
* acquiring/assessing efficiency goals, Acquiring and Assessing Efficiency Goals
* formalizing of efficiency requirements, Efficiency Requirements Should Be Formalized-Efficiency Requirements Should Be Formalized
* Resource-Aware Efficiency Requirements, Resource-Aware Efficiency Requirements-Resource-Aware Efficiency Requirements
* godoc tool, Code Documentation as a First Citizen-Code Documentation as a First Citizen
* GOGC option, Garbage Collection, Recycle
* Golang
* design to improve serious codebases, Designed to Improve Serious Codebases-Designed to Improve Serious Codebases
* Go versus, Imperative, Compiled, and Statically Typed Language
* Goldstine, Herman H., on general-purpose computers, CPU in a Modern Computer Architecture
* GOMAXPROCS environmental variable, Go Runtime Scheduler
* GOMEMLIMIT option, Garbage Collection, Recycle
* Google, Go governance and, Governed by Google, Yet Open Source
* goroutine
* common functions found in, Goroutine
* controlling lifecycle of, Control the Lifecycle of Your Goroutines-Control the Lifecycle of Your Goroutines
* Go runtime scheduler and, Go Runtime Scheduler-Go Runtime Scheduler
* goroutine profiler, Goroutine-Goroutine
* granularity, Efficiency Metrics Semantics, Latency-Latency
* Graph view, Graph-Graph
* Gregg, Brendan, on Flame Graph, Flame Graph
* Griesemer, Robert
* Algol 60 development, Is Go “Fast”?
* Go origins, Designed to Improve Serious Codebases, Simplicity, Safety, and Readability Are Paramount
* Gryski, Damian, on GC and cost of memory allocation, Garbage Collection
H
* hardware
* execution speed and energy efficiency, Faster execution is more energy efficient
* misconceptions about increasing speed and decreasing cost, Hardware Is Getting Faster and Cheaper-Faster execution is more energy efficient
* software speed versus hardware speed, Software expands to fill the available memory-Software gets slower more rapidly than hardware becomes faster
* stability best practices, Performnce Nondeterminism
* technological limits of speed, Technological limits-Technological limits
* hardware level of optimization design, Optimization Design Levels
* heap
* Go Allocator and, Go Allocator-Go Allocator
* Go memory management and, Go Memory Management
* optimizing usage, Go Memory Management
* profile, Heap-Heap
* runtime heap statistics, runtime heap statistics
* stack versus, Go Memory Management
* Hoare, C. A. R., on CSP paradigm, Go Runtime Scheduler
* Honnef, Dominik, on sync.Pool, Memory Reuse and Pooling
* horizontal scalability, We Can Scale Horizontally Instead-We Can Scale Horizontally Instead
* House, Charles H., on time to market, Time to Market Is More Important
* Hsieh, Paul, on cost of optimization, Understand Your Goals
* human error, experiment reliability and, Human Errors-Human Errors
* Hungarian Notation, Readability now versus past
* Hyde, Randall, on premature optimization, Time to Market Is More Important
* Hyper-Threading, Hyper-Threading-Hyper-Threading
I
* Icicle (Flame) Graph view, Flame Graph-Flame Graph
* IDE (Integrated Development Environment), running Go benchmarks through, Go Benchmarks
* idiomatic coding style, Simplicity, Safety, and Readability Are Paramount
* ILP (Instruction-Level Parallelism), Pipelining and Out-of-Order Execution
* implementation (code) level of optimization design, Optimization Design Levels
* import statement, Unused Import or Variable Causes Build Error
* inclusiveness, efficiency and, Faster execution is more energy efficient
* inheritance, Object-Oriented Programming
* inlining
* function, Understanding Go Compiler
* manual, Understanding Go Compiler
* Instruction Set Architecture (ISA), Assembly
* Instruction-Level Parallelism (ILP), Pipelining and Out-of-Order Execution
* instrumentation
* common profile instrumentation, Common Profile Instrumentation-Off-CPU Time
* forms of, Observability
* granularity-based classification, Observability
* hiding under abstractions, Tracing
* instrumentation (definition), Observability
* Integrated Development Environment (IDE), running Go benchmarks through, Go Benchmarks
* internal packages, Packaging and Modules
* Internet of Things (IoT), Software gets slower more rapidly than hardware becomes faster
* ISA (Instruction Set Architecture), Assembly
J
* Java, benchmarking in, Compiler Optimizations Versus Benchmark
* Jones, C., on thinking of metrics as distributions, Latency
K
* Kennedy, William
* on context switching, Go Runtime Scheduler
* on GC, Reduce Allocations
* on mechanical sympathy, Understanding Go Compiler
* Kernighan, Brian W.
* on readability of code, Optimized Code Is Not Readable
* on true definition of efficiency, Software Efficiency Matters
* Kleppmann, Martin, on scalability, We Can Scale Horizontally Instead
* Knuth, Donald
* complexity notations, Asymptotic Complexity with Big O Notation
* on premature optimization, Readability now versus past
* Kubernetes with GOMEMLIMIT option, Recycle
L
* L-caches, Hierarchical Cache System
* latency
* difficulty of measuring shorter latencies, Latency
* efficiency metrics semantics, Latency-Latency
* efficiency versus, The Key to Pragmatic Code Performnce-The Key to Pragmatic Code Performnce
* instrumenting for, Example: Instrumenting for Latency-Metrics
* limitations of time/duration measurements, Latency
* macrobenchmarking and, Server-side latency-Server-side latency
* napkin math calculations, Latencies for Napkin Math Calculations
* optimization, Optimizing Latency-Optimizing strconv.Parse
* optimizing bytes.Split, Optimizing bytes.Split-Optimizing bytes.Split
* optimizing runtime.slicebytetostring, Optimizing runtime.slicebytetostring-Optimizing runtime.slicebytetostring
* optimizing strconv.Parse, Optimizing strconv.Parse-Optimizing strconv.Parse
* optimizing using concurrency, Optimizing Latency Using Concurrency-A Streamed, Sharded Worker Approach
* percentiles versus averages, Latency-Latency
* in RAER, Example of Defining RAER
* latency optimization
* naive concurrency, A Naive Concurrency-A Naive Concurrency
* streamed, sharded worker approach, A Streamed, Sharded Worker Approach-A Streamed, Sharded Worker Approach
* using concurrency, Optimizing Latency Using Concurrency-A Streamed, Sharded Worker Approach
* worker approach with distribution, A Worker Approach with Distribution-A Worker Approach with Distribution
* worker approach without coordination, A Worker Approach Without Coordination (Sharding)-A Worker Approach Without Coordination (Sharding)
* leak (see resource leaks)
* lined lists, arrays versus, Pipelining and Out-of-Order Execution
* logger pattern, Logging
* logging, Logging-Logging
* Lozi, J. P., on OS thread scheduler, Operating System Scheduler
M
* machine code, Assembly
* macrobenchmarks/macrobenchmarking
* about, Macrobenchmarks
* basics, Basics-Basics
* common workflows, Common Macrobenchmarking Workflows-Common Macrobenchmarking Workflows
* containers for, Go e2e Framework
* CPU time and, CPU time-CPU time
* Go e2e framework, Go e2e Framework-Go e2e Framework
* implementation, Macrobenchmarks-Memory
* memory and, Memory-Memory
* server-side latency, Server-side latency-Server-side latency
* understanding results/observations, Understanding Results and Observations
* mapping, OS memory, OS Memory Mapping-OS Memory Mapping
* measuring (definition), Data-Driven Efficiency Assessment
* mechanical sympathy, How Go Uses the CPU Resource (or Two)
* Bill Kennedy on, Understanding Go Compiler
* memory blocks, Values, Pointers, and Memory Blocks-Values, Pointers, and Memory Blocks
* memory cells, Physical Memory
* memory leak, Overusing Memory with Arrays-Overusing Memory with Arrays
* memory management
* Go Allocator, Go Allocator-Go Allocator
* Go memory management, Go Memory Management-Garbage Collection
* microbenchmarks versus, Microbenchmarks Versus Memory Management-Microbenchmarks Versus Memory Management
* OS memory management, OS Memory Management-OS Memory Mapping
* values, pointers, and memory blocks, Values, Pointers, and Memory Blocks-Values, Pointers, and Memory Blocks
* Memory Management Unit (MMU), Virtual Memory
* memory mapping, OS Memory Mapping-OS Memory Mapping
* memory overcommitment, Virtual Memory
* memory pooling, Memory Reuse and Pooling-Memory Reuse and Pooling
* memory resource, How Go Uses Memory Resource-Summary
* efficiency metrics semantics, Memory Usage-OS memory pages statistics
* Go memory management, Go Memory Management-Garbage Collection
* Go's use of, How Go Uses Memory Resource-Summary
* identifying problems with, Do We Have a Memory Problem?
* macrobenchmarking and, Memory-Memory
* moving to streaming algorithm, Moving to Streaming Algorithm-Moving to Streaming Algorithm
* optimization examples, Optimizing Memory Usage-Optimizing bufio.Scanner
* optimizing bufio.Scanner, Optimizing bufio.Scanner-Optimizing bufio.Scanner
* OS memory management, OS Memory Management-OS Memory Mapping
* OS memory mapping, OS Memory Mapping-OS Memory Mapping
* OS memory pages statistics, OS memory pages statistics
* overusing with arrays, Overusing Memory with Arrays-Overusing Memory with Arrays
* physical, Physical Memory-Physical Memory
* relevance of, Memory Relevance-Memory Relevance
* runtime heap statistics, runtime heap statistics
* virtual memory, Virtual Memory-mmap Syscall
* waste indications, It tells us if there is any easy optimization to our code
* when to debug/optimize, Do We Have a Memory Problem?
* memory reuse, Memory Reuse and Pooling-Memory Reuse and Pooling
* memory wall, CPU and Memory Wall Problem-Hyper-Threading
* CPU resource and, CPU and Memory Wall Problem-Hyper-Threading
* hierarchical cache system, Hierarchical Cache System
* Hyper-Threading, Hyper-Threading-Hyper-Threading
* pipelining and out-of-order CPU execution, Pipelining and Out-of-Order Execution-Pipelining and Out-of-Order Execution
* methods, Go, Object-Oriented Programming
* metrics, Metrics-Metrics
* cardinality, Metrics
* definition, Metrics
* documentation of, Latency
* efficiency metrics semantics, Efficiency Metrics Semantics-OS memory pages statistics
* numeric value versus metric observability signal, Efficiency Metrics Semantics
* Meyers, Scott, on optimization, Reasonable Optimizations
* microbenchmarks/microbenchmarking, Microbenchmarks-Microbenchmarks
* compiler optimizations versus, Compiler Optimizations Versus Benchmark-Compiler Optimizations Versus Benchmark
* finding your workflow, Find Your Workflow-Find Your Workflow
* implementation, Microbenchmarks-Understanding the Results
* memory management versus, Microbenchmarks Versus Memory Management-Microbenchmarks Versus Memory Management
* running for different inputs, Running Benchmarks for Different Inputs-Running Benchmarks for Different Inputs
* sharing with team, Sharing Benchmarks with the Team (and Your Future Self)-Sharing Benchmarks with the Team (and Your Future Self)
* testing for correctness, Test Your Benchmark for Correctness!-Test Your Benchmark for Correctness!
* tips and tricks for, Understanding the Results-Understanding the Results
* too-high variance, Too-High Variance
* understanding results, Understanding the Results-Understanding the Results
* misconceptions about efficiency, Common Efficiency Misconceptions-Time to Market Is More Important
* hardware speed/cost, Hardware Is Getting Faster and Cheaper-Faster execution is more energy efficient
* horizontal scaling versus vertical scaling, We Can Scale Horizontally Instead-We Can Scale Horizontally Instead
* time to market versus features, Time to Market Is More Important-Time to Market Is More Important
* unreadability of optimized code, Optimized Code Is Not Readable-Readability now versus past
* YAGNI rule, You Aren’t Going to Need It-You Aren’t Going to Need It
* mmap syscall, Virtual Memory-Virtual Memory
* MMU (Memory Management Unit), Virtual Memory
* modules, Go source code and, Packaging and Modules
* monitoring, observability versus, Observability
* Moore, Gordon, on IC component costs, Technological limits
* Moore's Law, Technological limits
N
* napkin math, Example of Defining RAER, Latencies for Napkin Math Calculations
* noise (performance nondeterminism), Performnce Nondeterminism-Performnce Nondeterminism
* non-functional requirement (NFR) documentation, Efficiency Requirements Should Be Formalized
* noncompressible resources, Performnce Nondeterminism
* nondeterministic performance (noise), Performnce Nondeterminism-Performnce Nondeterminism
O
* object-oriented programming (OOP), Object-Oriented Programming-Object-Oriented Programming
* observability, Efficiency Observability-Summary
* basics, Observability-Observability
* definition, Observability
* efficiency metrics semantics, Efficiency Metrics Semantics-OS memory pages statistics
* instrumenting for latency, Example: Instrumenting for Latency-Metrics
* internal Go runtime knowledge versus OS knowledge, Go Allocator
* logging, Logging-Logging
* metrics, Metrics-Metrics
* monitoring versus, Observability
* tracing, Tracing-Tracing
* off-CPU time
* bottleneck analysis in, Off-CPU Time
* profiling, Off-CPU Time-Off-CPU Time
* on demand paging, mmap Syscall
* OOM (out-of-memory), mmap Syscall
* OOP (object-oriented programming), Object-Oriented Programming-Object-Oriented Programming
* open source versus Go, Governed by Google, Yet Open Source
* operating system (OS) memory management, OS Memory Management-OS Memory Mapping
* goals for, OS Memory Management-OS Memory Management
* memory pages statistics, OS memory pages statistics
* mmap syscall, Virtual Memory-Virtual Memory
* OS memory mapping, OS Memory Mapping-OS Memory Mapping
* virtual memory, Virtual Memory-mmap Syscall
* operating system (OS) optimization level, Optimization Design Levels
* operating system (OS) schedulers, Operating System Scheduler-Operating System Scheduler
* optimization
* acquiring/assessing efficiency goals, Acquiring and Assessing Efficiency Goals
* computer science definition, Beyond Waste, Optimization Is a Zero-Sum Game
* deliberate, Deliberate Optimizations
* design levels, Optimization Design Levels-Optimization Design Levels
* engineering definition, Beyond Waste, Optimization Is a Zero-Sum Game
* examples (see optimization examples)
* formalizing of efficiency requirements, Efficiency Requirements Should Be Formalized-Efficiency Requirements Should Be Formalized
* fundamental problems/challenges, Optimization Challenges-Optimization Challenges
* general definition, Beyond Waste, Optimization Is a Zero-Sum Game
* guarding against biases, Optimization Design Levels
* patterns (see optimization patterns)
* reasonable, Reasonable Optimizations-Reasonable Optimizations
* Resource-Aware Efficiency Requirements, Resource-Aware Efficiency Requirements-Resource-Aware Efficiency Requirements
* stakeholders and, Understand Your Goals
* understanding goals, Understand Your Goals-Example of Defining RAER
* as zero-sum game, Beyond Waste, Optimization Is a Zero-Sum Game-Deliberate Optimizations
* optimization examples, Optimization Examples-Summary
* alternative methods, Bonus: Thinking Out of the Box
* latency optimization, Optimizing Latency-Optimizing strconv.Parse
* moving to streaming algorithm, Moving to Streaming Algorithm-Moving to Streaming Algorithm
* optimizing bufio.Scanner, Optimizing bufio.Scanner-Optimizing bufio.Scanner
* optimizing bytes.Split, Optimizing bytes.Split-Optimizing bytes.Split
* optimizing latency using concurrency, Optimizing Latency Using Concurrency-A Streamed, Sharded Worker Approach
* optimizing memory usage, Optimizing Memory Usage-Optimizing bufio.Scanner
* optimizing runtime.slicebytetostring, Optimizing runtime.slicebytetostring-Optimizing runtime.slicebytetostring
* optimizing strconv.Parse, Optimizing strconv.Parse-Optimizing strconv.Parse
* Sum examples, Sum Examples-Sum Examples
* optimization patterns, Optimization Patterns-Memory Reuse and Pooling
* avoiding resource leak, Don’t Leak Resources-Exhaust Things
* avoiding unnecessary work, Do Less Work-Do Less Work
* common patterns, Common Patterns-Trading Time for Space
* memory reuse/pooling, Memory Reuse and Pooling-Memory Reuse and Pooling
* overusing memory with arrays, Overusing Memory with Arrays-Overusing Memory with Arrays
* pre-allocation, Pre-Allocate If You Can-Pre-Allocate If You Can
* three Rs method, The Three Rs Optimization Method-Recycle
* trading functionality for efficiency, Trading Functionality for Efficiency
* trading space for time, Trading Space for Time
* trading time for space, Trading Time for Space
* optimized code (see readability/unreadability of optimized code)
* OS (see operating system entries)
* out-of-memory (OOM), mmap Syscall
* out-of-order CPU execution, Pipelining and Out-of-Order Execution-Pipelining and Out-of-Order Execution
* overcommitment, Virtual Memory
* overloading, Operating System Scheduler
P
* packages
* Go source code and, Packaging and Modules
* internal directory and, Packaging and Modules
* padding, Values, Pointers, and Memory Blocks
* page fault, mmap Syscall
* page size, importance of, Virtual Memory
* pages, Virtual Memory
* paging, Virtual Memory, OS memory pages statistics
* panics (exception mechanism), Single Way of Handling Errors
* parametric polymorphism (generics), Generics-Generics
* Parca project, Continuous Profiling-Continuous Profiling
* Parkinson's Law, Software expands to fill the available memory
* Peek view, Peek, Source, and Disassemble
* percentiles, averages versus, Latency-Latency
* performance
* basics, Behind Performnce-Behind Performnce
* need to specify meaning, Behind Performnce
* three core execution elements, Behind Performnce
* performance nondeterminism (noise), Performnce Nondeterminism-Performnce Nondeterminism
* pessimization, Optimized Code Is Not Readable
* physical memory, Physical Memory-Physical Memory
* PID (Process Identification Number), Operating System Scheduler
* Pike, Rob
* on dependencies, Dependencies Transparency by Default
* on Go, Efficient Introduction to Go
* on Go origins, Designed to Improve Serious Codebases
* pipelining, out-of-order CPU execution and, Pipelining and Out-of-Order Execution-Pipelining and Out-of-Order Execution
* Plauger, P. J.
* on readability of code, Optimized Code Is Not Readable
* on true definition of efficiency, Software Efficiency Matters
* pointer receiver, Object-Oriented Programming
* pointers, Values, Pointers, and Memory Blocks-Values, Pointers, and Memory Blocks
* power consumption, Faster execution is more energy efficient
* pprof format, pprof Format-pprof Format
* (see also profiling)
* go tool pprof reports, go tool pprof Reports-Peek, Source, and Disassemble
* Profile child objects, pprof Format-pprof Format
* pre-allocation, Pre-Allocate If You Can-Pre-Allocate If You Can
* premature optimization, Reasonable Optimizations
* premature pessimization, Optimized Code Is Not Readable
* Price, Raymond L., on time to market, Time to Market Is More Important
* Process Identification Number (PID), Operating System Scheduler
* production
* benchmarking in, Benchmarking in Production
* reproducing in experiments, Reproducing Production-Reproducing Production
* profiler (definition), Profiling in Go
* profiling, Profiling in Go-Peek, Source, and Disassemble
* capturing the profiling signal, Capturing the Profiling Signal-Capturing the Profiling Signal
* common profile instrumentation, Common Profile Instrumentation-Off-CPU Time
* comparing/aggregating profiles, Comparing and Aggregating Profiles
* continuous, Continuous Profiling-Continuous Profiling
* CPU usage, CPU-CPU
* go tool pprof reports, go tool pprof Reports-Peek, Source, and Disassemble
* goroutine profiler, Goroutine-Goroutine
* heap profile, Heap-Heap
* off-CPU time, Off-CPU Time-Off-CPU Time
* pprof format, pprof Format-pprof Format
* sharing profiles, Sharing Profiles
* Prometheus
* benchmarking suites, What Level Should You Use?
* gauge metric problems, Memory
* metric instrumentation, CPU Usage-CPU Usage
* pre-aggregated instrumentation, Metrics-Metrics
* rate duration, Server-side latency
* psychological safety, efficiency problems and, Got an Efficiency Problem? Keep Calm!
* pull-based collection model, Observability
* push-based collection model, Observability
R
* RAER (see Resource-Aware Efficiency Requirements)
* random-access memory (RAM), Physical Memory-Physical Memory
* readability/unreadability of optimized code
* code after optimization as more readable, Code after optimization can be more readable-Code after optimization can be more readable
* misconceptions about, Optimized Code Is Not Readable-Readability now versus past
* now versus past, Readability now versus past
* readability as dynamic, Code after optimization can be more readable
* waste reduction versus readability reduction, Reasonable Optimizations
* reasonable optimizations, Reasonable Optimizations-Reasonable Optimizations
* reliability of experiments
* human error and, Human Errors-Human Errors
* performance nondeterminism (noise), Performnce Nondeterminism-Performnce Nondeterminism
* reproducing production, Reproducing Production-Reproducing Production
* repeatability (definition), Comparison to Functional Testing
* resource leaks, avoiding, Don’t Leak Resources-Exhaust Things
* closing objects, Reliably Close Things-Reliably Close Things
* controlling goroutine lifecycle, Control the Lifecycle of Your Goroutines-Control the Lifecycle of Your Goroutines
* definition, Don’t Leak Resources
* exhausting things, Exhaust Things-Exhaust Things
* Resource-Aware Efficiency Requirements (RAER)
* about, Resource-Aware Efficiency Requirements-Resource-Aware Efficiency Requirements
* defining/assessment example, Example of Defining RAER-Example of Defining RAER
* EADF and, 5. Are we within RAERs?
* resources, compressible versus noncompressible, Performnce Nondeterminism
* runtime heap statistics, runtime heap statistics
* runtime scheduler, Go Runtime Scheduler-Go Runtime Scheduler
* runtime.slicebytetostring, Optimizing runtime.slicebytetostring-Optimizing runtime.slicebytetostring
S
* scalability
* horizontal, We Can Scale Horizontally Instead-We Can Scale Horizontally Instead
* misconceptions about efficiency, We Can Scale Horizontally Instead-We Can Scale Horizontally Instead
* vertical, We Can Scale Horizontally Instead
* schedulers, Schedulers-Go Runtime Scheduler
* Go runtime scheduler, Go Runtime Scheduler-Go Runtime Scheduler
* operating system schedulers, Operating System Scheduler-Operating System Scheduler
* script (using Go code), Designed to Improve Serious Codebases
* semantic diffusion, Behind Performnce
* server-side latency, macrobenchmarking and, Server-side latency-Server-side latency
* sharding
* streamed, sharded worker approach, A Streamed, Sharded Worker Approach-A Streamed, Sharded Worker Approach
* worker approach without coordination, A Worker Approach Without Coordination (Sharding)-A Worker Approach Without Coordination (Sharding)
* shared infrastructure, Performnce Nondeterminism
* Simonov, Valentin, on hardware speed, Hardware Is Getting Faster and Cheaper
* simultaneous multithreading (SMT), Hyper-Threading-Hyper-Threading
* Single Instruction Multiple Data (SIMD), CPU and Memory Wall Problem
* Single Instruction Single Data (SISD), CPU and Memory Wall Problem
* Sink pattern, Compiler Optimizations Versus Benchmark-Compiler Optimizations Versus Benchmark
* Site Reliability Engineering (SRE), Efficiency Requirements Should Be Formalized
* slice, memory structure for, Values, Pointers, and Memory Blocks
* SMT (simultaneous multithreading), Hyper-Threading-Hyper-Threading
* software speed, hardware speed versus, Software expands to fill the available memory-Software gets slower more rapidly than hardware becomes faster
* Source view, Peek, Source, and Disassemble
* speculative execution, Pipelining and Out-of-Order Execution
* speed
* in context of performance, Behind Performnce
* efficiency versus, The Key to Pragmatic Code Performnce-The Key to Pragmatic Code Performnce
* Go (generally), Is Go “Fast”?
* software versus hardware, Software expands to fill the available memory-Software gets slower more rapidly than hardware becomes faster
* SRAM (static random-access memory), Hierarchical Cache System
* Sridharan, Cindy, on observability signals, Observability
* stack (function stack), Go Memory Management
* stakeholders, optimization requests from, Understand Your Goals
* static random-access memory (SRAM), Hierarchical Cache System
* statistics, risks in overusing, Performnce Nondeterminism
* strconv.Parse, Optimizing strconv.Parse-Optimizing strconv.Parse
* streaming algorithm, moving to, Moving to Streaming Algorithm-Moving to Streaming Algorithm
* structure padding, Values, Pointers, and Memory Blocks
* structures, as class equivalent, Object-Oriented Programming
* Sutter, H.
* on efficient design, Optimized Code Is Not Readable
* on speed versus correctness, Functionality Phase
* sync.Pool structure, Memory Reuse and Pooling
* system level of optimization design, Optimization Design Levels
T
* table tests, Unit Testing and Table Tests
* Taylor, Ian, and Go team, Designed to Improve Serious Codebases
* team, sharing microbenchmarks with, Sharing Benchmarks with the Team (and Your Future Self)-Sharing Benchmarks with the Team (and Your Future Self)
* test-driven development (TDD), 1. Test functionality first
* testing
* microbenchmarks, Test Your Benchmark for Correctness!-Test Your Benchmark for Correctness!
* unit testing/table tests, Unit Testing and Table Tests
* TFBO (test, fix, benchmark, optimize) development flow, Efficiency-Aware Development Flow-9. Release and enjoy!
* Thanos project, We Can Scale Horizontally Instead
* thermal scaling, as source of noise, Performnce Nondeterminism
* Thompson, Ken, and Go origins, Designed to Improve Serious Codebases
* three Rs optimization method, The Three Rs Optimization Method-Recycle
* recycling, Recycle-Recycle
* reducing allocations, Reduce Allocations
* reusing memory, Reuse Memory
* time to market (financial impact), Time to Market Is More Important-Time to Market Is More Important
* TLB (Translation Lookaside Buffer), Virtual Memory
* tooling, consistency of, Consistent Tooling
* tracing
* basics, Tracing-Tracing
* downsides of, Tracing-Tracing
* Translation Lookaside Buffer (TLB), Virtual Memory
* types, embedding multiple, Object-Oriented Programming
U
* unit testing, Unit Testing and Table Tests
* unreadability of optimized code (see readability/unreadability of optimized code)
V
* value receiver, Object-Oriented Programming
* values, Values, Pointers, and Memory Blocks-Values, Pointers, and Memory Blocks
* variables
* build errors from unused variable, Unused Import or Variable Causes Build Error
* heap versus stack allocation, Go Memory Management
* variance, microbenchmarking and, Too-High Variance
* vertical scalability, We Can Scale Horizontally Instead
* virtual memory, Virtual Memory-Virtual Memory
* Vitess project, What Level Should You Use?
* von Neumann, John, and general-purpose computers, CPU in a Modern Computer Architecture
W
* waste, Reasonable Optimizations-Reasonable Optimizations
* Wirth, Niklaus
* on fat software, Software gets slower more rapidly than hardware becomes faster
* and Go origins, Designed to Improve Serious Codebases
* workflow, microbenchmarking, Find Your Workflow-Find Your Workflow
Fair Use Sources
Fair Use Sources:
* 1098105710 (EffGo, 2023)
{{navbar_golang}}
{{navbar_footer}}