https://blog.turboawesome.win/tags/performance/ Recent content in Performance on Bits, Trades & Systems Hugo en-us Wed, 09 Oct 2024 13:00:00 +0000 https://blog.turboawesome.win/2024/10/tail-based-trace-sampling-why-head-sampling-is-usually-wrong/ Wed, 09 Oct 2024 13:00:00 +0000 https://blog.turboawesome.win/2024/10/tail-based-trace-sampling-why-head-sampling-is-usually-wrong/ Head-based sampling decides whether to trace a request at the start. Tail-based sampling decides after the request completes. For finding latency outliers and errors, tail-based sampling is almost always what you want — and almost never what gets implemented. https://blog.turboawesome.win/2023/07/gos-net/http-building-production-http-servers-without-a-framework/ Wed, 05 Jul 2023 10:44:00 +0000 https://blog.turboawesome.win/2023/07/gos-net/http-building-production-http-servers-without-a-framework/ Go's standard net/http package is capable enough for most production workloads without a framework. What 'capable enough' means in practice, and the patterns for middleware, graceful shutdown, and observability. https://blog.turboawesome.win/2022/08/memory-layout-in-go-structs-alignment-and-cache-performance/ Wed, 17 Aug 2022 10:03:00 +0000 https://blog.turboawesome.win/2022/08/memory-layout-in-go-structs-alignment-and-cache-performance/ Go's struct layout follows alignment rules that affect both memory consumption and cache performance. Understanding them matters more than most Go developers realise. https://blog.turboawesome.win/2020/08/gos-scheduler-gomaxprocs-work-stealing-and-why-it-matters/ Wed, 12 Aug 2020 10:27:00 +0000 https://blog.turboawesome.win/2020/08/gos-scheduler-gomaxprocs-work-stealing-and-why-it-matters/ Go's M:N scheduler is one of the reasons goroutines are cheap enough to use liberally. Understanding how it works changes how you reason about concurrency bugs and performance anomalies. https://blog.turboawesome.win/2020/07/building-a-high-throughput-event-pipeline-in-go-without-losing-your-mind/ Wed, 01 Jul 2020 14:30:00 +0000 https://blog.turboawesome.win/2020/07/building-a-high-throughput-event-pipeline-in-go-without-losing-your-mind/ Channels are Go's concurrency primitive, but a naive pipeline of goroutines and channels won't survive high throughput. The patterns that scale: batching, backpressure, worker pools, and knowing when to abandon channels entirely. https://blog.turboawesome.win/2020/04/profiling-go-services-in-production-with-pprof/ Wed, 01 Apr 2020 10:18:00 +0000 https://blog.turboawesome.win/2020/04/profiling-go-services-in-production-with-pprof/ Go's pprof tooling is built in, low-overhead, and more useful than most engineers realise. Here's how to capture CPU and memory profiles from production services and actually read what they tell you. https://blog.turboawesome.win/2020/03/go-benchmarks-writing-ones-that-actually-tell-you-something/ Tue, 17 Mar 2020 09:29:00 +0000 https://blog.turboawesome.win/2020/03/go-benchmarks-writing-ones-that-actually-tell-you-something/ Go's built-in benchmark framework is excellent, but it's easy to write benchmarks that measure the wrong thing — compiler optimisations, cache warming artifacts, or benchmark overhead rather than the code under test. https://blog.turboawesome.win/2019/04/goroutines-are-not-threads-the-mental-model-shift/ Mon, 22 Apr 2019 13:07:00 +0000 https://blog.turboawesome.win/2019/04/goroutines-are-not-threads-the-mental-model-shift/ Coming from Java, I initially modelled goroutines as lightweight threads. That model is mostly right but subtly wrong in ways that matter — understanding the Go scheduler changes how you think about goroutine lifecycle and blocking. https://blog.turboawesome.win/2018/06/backpressure-in-practice-keeping-fast-producers-from-killing-slow-consumers/ Thu, 14 Jun 2018 10:33:00 +0000 https://blog.turboawesome.win/2018/06/backpressure-in-practice-keeping-fast-producers-from-killing-slow-consumers/ Every system has components that produce faster than consumers can handle under some conditions. Backpressure is the mechanism by which fast producers are slowed rather than dropping data or consuming unbounded memory. Here's what the options look like in practice. https://blog.turboawesome.win/2018/05/project-loom-preview-virtual-threads-and-what-they-mean-for-server-code/ Thu, 24 May 2018 09:38:00 +0000 https://blog.turboawesome.win/2018/05/project-loom-preview-virtual-threads-and-what-they-mean-for-server-code/ Project Loom's virtual threads promise to fix Java's thread-per-request scalability problem by making millions of lightweight threads practical. Here's what the early design looked like and why it matters for server-side Java. https://blog.turboawesome.win/2017/04/reading-gc-logs-like-a-detective/ Tue, 18 Apr 2017 09:11:00 +0000 https://blog.turboawesome.win/2017/04/reading-gc-logs-like-a-detective/ GC logs are the most information-dense diagnostic output the JVM produces, and most engineers never learn to read them properly. A guide to interpreting G1GC logs and using them to diagnose real production problems. https://blog.turboawesome.win/2016/11/clojure-data-pipelines-transducers-in-production-risk-processing/ Wed, 23 Nov 2016 13:55:00 +0000 https://blog.turboawesome.win/2016/11/clojure-data-pipelines-transducers-in-production-risk-processing/ Transducers are Clojure's answer to pipeline composition that works without creating intermediate collections. For production data processing where allocation matters, they're not a theoretical nicety — they're genuinely useful. https://blog.turboawesome.win/2016/11/threading-models-in-java-which-one-does-your-system-actually-need/ Wed, 09 Nov 2016 10:22:00 +0000 https://blog.turboawesome.win/2016/11/threading-models-in-java-which-one-does-your-system-actually-need/ Thread-per-request, event-loop, work-stealing, single-threaded with message passing — Java supports all of them, but each optimises for different things. Choosing the wrong model means fighting the runtime rather than working with it. https://blog.turboawesome.win/2015/11/five-years-in-high-frequency-trading-what-i-actually-learned/ Thu, 12 Nov 2015 16:03:00 +0000 https://blog.turboawesome.win/2015/11/five-years-in-high-frequency-trading-what-i-actually-learned/ Looking back at five years of low-latency systems work: what the environment teaches you that you can't learn elsewhere, and what habits it instils that don't always transfer cleanly to other domains. https://blog.turboawesome.win/2015/10/zgc-and-shenandoah-what-low-pause-gc-means-for-trading-systems/ Thu, 01 Oct 2015 09:44:00 +0000 https://blog.turboawesome.win/2015/10/zgc-and-shenandoah-what-low-pause-gc-means-for-trading-systems/ In 2015 the JVM GC landscape was about to change significantly. ZGC and Shenandoah were in development, promising sub-millisecond GC pauses regardless of heap size. Here's what the previews looked like and what they meant for latency-sensitive Java. https://blog.turboawesome.win/2015/05/understanding-safepoints-the-jvm-pauses-nobody-talks-about/ Wed, 27 May 2015 14:38:00 +0000 https://blog.turboawesome.win/2015/05/understanding-safepoints-the-jvm-pauses-nobody-talks-about/ GC pauses get all the attention, but safepoints are a broader category of JVM stop-the-world events that affect latency in ways GC tuning can't fix. https://blog.turboawesome.win/2015/04/memory-mapped-files-in-java-chronicle-and-the-art-of-zero-copy-i/o/ Wed, 15 Apr 2015 09:53:00 +0000 https://blog.turboawesome.win/2015/04/memory-mapped-files-in-java-chronicle-and-the-art-of-zero-copy-i/o/ Memory-mapped files let you treat disk storage as if it's RAM — the OS handles the mapping and caching transparently. Chronicle Queue uses this to give you a persistent ordered log with throughput approaching raw memory bandwidth. https://blog.turboawesome.win/2015/03/building-a-trade-blotter-that-doesnt-lie-under-load/ Wed, 04 Mar 2015 10:12:00 +0000 https://blog.turboawesome.win/2015/03/building-a-trade-blotter-that-doesnt-lie-under-load/ A trade blotter shows traders their current positions and recent executions. When the system is under load, naive implementations show stale, inconsistent, or missing data. Here's the design that kept our blotter honest. https://blog.turboawesome.win/2015/01/chronicle-queue-vs-kafka-choosing-a-persistent-journal-at-nanosecond-scale/ Wed, 21 Jan 2015 10:44:00 +0000 https://blog.turboawesome.win/2015/01/chronicle-queue-vs-kafka-choosing-a-persistent-journal-at-nanosecond-scale/ Both Chronicle Queue and Kafka provide persistent, ordered message logs. Their performance profiles, operational models, and use cases are almost completely different. https://blog.turboawesome.win/2014/10/benchmarking-without-lying-jmh-coordinated-omission-and-honest-numbers/ Wed, 29 Oct 2014 10:14:00 +0000 https://blog.turboawesome.win/2014/10/benchmarking-without-lying-jmh-coordinated-omission-and-honest-numbers/ Most latency benchmarks are wrong in the same ways. JMH solves the JVM measurement problems; coordinated omission is the harder issue that lives above it.