resources

References - Performance

Manuals
Books
- Performance Analysis and Tuning on Modern CPUs - https://github.com/dendibakh/perf-book/releases
- The Art of Writing Efficient Programs - https://www.packtpub.com/product/the-art-of-writing-efficient-programs
- Algorithms for Modern Hardware - https://en.algorithmica.org/hpc
- Computer Architecture - https://dl.acm.org/doi/book/10.5555/1999263
- The Art of Assembly Language - https://www.plantation-productions.com/Webster/www.artofasm.com/Linux/HTML/AoATOC.html
- SIMD for C++ Developers - http://const.me/articles/simd/simd.pdf
- Memory Models - https://research.swtch.com/mm
- Rust Atomics and Locks - https://marabos.nl/atomics
- Data-Oriented Design - https://www.dataorienteddesign.com/dodbook
- Hackers Delight - https://doc.lagout.org/security/Hackers%20Delight.pdf
- A Primer on Memory Consistency and Cache Coherence, Second Edition - https://link.springer.com/content/pdf/10.1007/978-3-031-01764-3.pdf
Publications
- What Every Programmer Should Know About Memory - https://www.akkadia.org/drepper/cpumemory.pdf
- The Microarchitecture of Superscalar Processors - https://courses.cs.washington.edu/courses/cse471/01au/ss_cgi.pdf
- Producing wrong data without doing anything obviously wrong! - https://dl.acm.org/doi/10.1145/1508284.1508275
- STABILIZER: Statistically Sound Performance Evaluation - https://people.cs.umass.edu/~emery/pubs/stabilizer-asplos13.pdf
- Robust benchmarking in noisy environments - https://arxiv.org/abs/1608.04295
- nanoBench: A Low-Overhead Tool for Running Microbenchmarks on x86 Systems - https://arxiv.org/abs/1911.03282
- The Linux Scheduler: a Decade of Wasted Cores - https://people.ece.ubc.ca/sasha/papers/eurosys16-final29.pdf
- The Tail At Scale - https://www.barroso.org/publications/TheTailAtScale.pdf
- Can Seqlocks Get Along With Programming Language Memory Models - https://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf
- Cache-Oblivious Algorithms and Data Structures - https://erikdemaine.org/papers/BRICS2002
- Memory-Centric Computing: Solving Computing`s Memory Problem - https://arxiv.org/abs/2505.00458
- High-Precision Branch Target Injection Attacks Exploiting the Indirect Branch Predictor - https://indirector.cpusec.org
- A CPU research kernel with minimal noise for cycle-by-cycle micro-architectural introspection - https://gamozolabs.github.io/metrology/2019/08/19/sushi_roll.html
- A Top-Down method for performance analysis and counters architecture - https://www.researchgate.net/publication/269302126_A_Top-Down_method_for_performance_analysis_and_counters_architecture
Metrics
- Latency, Throughput, and Port Usage Information - https://uops.info
- Latency, Memory Latency and CPUID dumps - http://instlatx64.atw.hu
- Memory Latency Data - https://chipsandcheese.com/memory-latency-data
- Core To Core Latency - https://github.com/nviennot/core-to-core-latency
- Operation Costs in CPU Clock Cycles - http://ithare.com/infographics-operation-costs-in-cpu-clock-cycles
- Microprocessor Trend Data - https://github.com/karlrupp/microprocessor-trend-data
- Microarchitecture Metrics - https://dougallj.github.io/applecpu/firestorm.html
- Top-Down Metrics - https://github.com/intel/perfmon/blob/main/TMA_Metrics-full.xlsx
- Performance Monitoring Events - https://perfmon-events.intel.com
- Performance Monitor Counters - https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/programmer-references/58550-0.01.pdf
- Instruction Reference - https://www.felixcloutier.com/x86
- Instruction Matrix - https://github.com/google/highway/blob/master/g3doc/instruction_matrix.pdf
- Instruction Tables: Lists of instruction latencies, throughputs and micro-operation breakdowns for Intel, AMD and VIA CPUs - https://www.agner.org/optimize/instruction_tables.pdf
- Intel Intrinsics - https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html
- "RDNA4" Instruction Set Architecture - https://www.amd.com/content/dam/amd/en/documents/radeon-tech-docs/instruction-set-architectures/rdna4-instruction-set-architecture.pdf
- Opcode and Instruction Reference - http://ref.x86asm.net
- CPUID data repository - https://x86-cpuid.org
- Intrinsics Cheatsheet - https://db.in.tum.de/~finis/x86-intrin-cheatsheet-v2.1.pdf
- Cardyak’s Microarchitecture Cheatsheet - https://docs.google.com/spreadsheets/d/18ln8SKIGRK5_6NymgdB9oLbTJCFwx0iFI-vUs6WFyuE
- Cardyak’s Microarchitecture diagrams - https://drive.google.com/drive/u/0/folders/1W4CIRKtNML74BKjSbXerRsIzAUk3ppSG
- Processor Information - https://sandpile.org
- SIMD.info - https://simd.info
- SIMD Instruction List - https://www.officedaytime.com/simd512e
- Instruction Discovery And Analysis - https://explore.liblisa.nl
- ```
Speed of light ......................... ~1 foot/ns
1 cycle execution (4Gz).................... 0.25 ns
L1 cache reference ......................... 0.5 ns
L2 cache reference ........................... 3 ns
Branch mispredict ............................ 3 ns
L3 cache reference .......................... 10 ns
Mutex lock/unlock ........................... 25 ns
Main memory reference ......................  70 ns
Send 2K bytes over 1 Gbps network ....... 20,000 ns  =  20 µs
SSD random read ........................ 150,000 ns  = 150 µs
Read 1 MB sequentially from memory ..... 250,000 ns  = 250 µs
Round trip within same data-center ..... 500,000 ns  = 0.5 ms
Read 1 MB sequentially from SSD .....  1,000,000 ns  =   1 ms
Read 1 MB sequentially from disk .... 20,000,000 ns  =  20 ms
Send packet CA->UK->CA ....          150,000,000 ns  = 150 ms
```
Methodologies
- Performance Analysis Methodology - https://www.brendangregg.com/methodology.html
- Top-Down Microarchitecture Analysis Method - https://www.intel.com/content/www/us/en/docs/vtune-profiler/cookbook/2023-0/top-down-microarchitecture-analysis-method.html
- Active Benchmarking - https://www.brendangregg.com/activebenchmarking.html
- Micro Benchmarking - https://hpc-wiki.info/hpc/Micro_benchmarking
- Recording Inferior’s Execution and Replaying It - https://sourceware.org/gdb/current/onlinedocs/gdb.html/Process-Record-and-Replay.html
- Measuring Workloads With TopLev - https://github.com/andikleen/pmu-tools/wiki/toplev-manual
Guides
- Low Latency Tuning Guide - https://rigtorp.se/low-latency-guide
- Optimizing Software in C++: An Optimization Guide for Windows, Linux and Mac platforms - https://www.agner.org/optimize/optimizing_cpp.pdf
- Optimizing Subroutines in Assembly Language: An Optimization Guide for x86 platforms - https://www.agner.org/optimize/optimizing_assembly.pdf
- Calling Conventions for different C++ compilers and operating systems - https://www.agner.org/optimize/calling_conventions.pdf
- The Microarchitecture of Intel, AMD and VIA CPUs: An Optimization Guide for Assembly programmers and compiler makers - https://www.agner.org/optimize/microarchitecture.pdf
- Is Parallel Programming Hard, And, If So, What Can You Do About It? - https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html
- RHEL Performance Guide - https://myllynen.github.io/rhel-performance-guide
- Measuring Workloads with Top-down Microarchitecture Analysis - https://github.com/andikleen/pmu-tools/wiki/toplev-manual
- Memory stabilizer - https://emeryberger.com/research/stabilizer/
- Apple Silicon Guide - https://github.com/mikeroyal/Apple-Silicon-Guide
- Envisioning a Simplified Intel Architecture - https://www.intel.com/content/www/us/en/developer/articles/technical/envisioning-future-simplified-architecture.html
- Monitoring and Managing System Status and Performance - https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/8/html/monitoring_and_managing_system_status_and_performance
- Modern Microprocessors A 90-Minute Guide! - https://www.lighterra.com/papers/modernmicroprocessors
- X3 Low Latency Quickstart - https://docs.amd.com/r/en-US/ug1586-onload-user/X3-Low-Latency-Quickstart
- Bit Twiddling Hacks - https://graphics.stanford.edu/~seander/bithacks.html
- C/C++11 mappings to processors - https://www.cl.cam.ac.uk/~pes20/cpp/cpp0xmappings.html
- ELF Format - https://gist.github.com/x0nu11byt3/bcb35c3de461e5fb66173071a2379779
- ```
# System topology (apt install hwloc)
lstopo # lstopo-no-graphics

# CPU info (apt install util-linux)
lscpu | grep -E ^CPU|^Model|^Core|^Socket|^Thread

# Cache info
lscpu | grep cache
getconf -a | grep CACHE_LINESIZE

# Numa nodes
lscpu | grep -E ^NUMA

# Huge pages
cat /proc/meminfo | grep -i huge
```
News / Docs
- Linux News - https://lwn.net
- Chips and Cheese - https://chipsandcheese.com
- WikiChip - https://wikichip.org
- CPUID - https://www.cpuid.com/news.html
- CPU-World - https://www.cpu-world.com/index.html
- Real World Tech - https://www.realworldtech.com
- Tom`s Hardware - https://www.tomshardware.com
- Phoronix - https://www.phoronix.com
- comp.lang.asm.x86 - https://groups.google.com/g/comp.lang.asm.x86
- C++ Links - https://github.com/MattPD/cpplinks
- Awesome Performance C++ - https://github.com/fenbf/AwesomePerfCpp
- Awesome Lock Free - https://github.com/rigtorp/awesome-lockfree
- Awesome SIMD - https://github.com/awesome-simd/awesome-simd
- Computer, Enhance! - https://www.computerenhance.com
- Low Latency Trading Insights - https://lucisqr.substack.com
- The Linux Kernel - https://www.kernel.org/doc/html/latest/index.html
- perf-probe - https://www.man7.org/linux/man-pages/man1/perf-probe.1.html
- gcc Optimization - https://wiki.gentoo.org/wiki/GCC_optimization
- gcc Assembler Syntax - https://www.felixcloutier.com/documents/gcc-asm
- llvm Scheduling Models - https://github.com/llvm/llvm-project/tree/main/llvm/lib/Target
- llvm Optimization Passes - https://llvm.org/docs/Passes.html
- llvm Vectorizers - https://llvm.org/docs/Vectorizers.html
- linux Referencer - https://elixir.bootlin.com/linux
Blogs
- Agner Fog - https://www.agner.org
- Denis Bakhvalov - https://easyperf.net/blog
- Daniel Lemire - https://lemire.me/blog
- Wojciech Mula - http://0x80.pl/articles/index.html
- Erik Rigtorp - https://rigtorp.se
- Brendan Gregg - https://brendangregg.com/blog
- Geoff Langdale - https://branchfree.org
- Ragnar Groot Koerkamp - https://curiouscoding.nl/posts/cpu-benchmarks
- Travis Downs - https://travisdowns.github.io
- Stefanos Baziotis - https://sbaziotis.com/#blog
- Dmitry Vyukov - https://www.1024cores.net
- John Farrier - https://johnfarrier.com
- Tanel Poder - https://tanelpoder.com
- Arseny Kapoulkine - https://zeux.io
- Chris Feilbach Blog - https://chrisfeilbach.com
- Johnny Software Blog - https://johnnysswlab.com
- Sarthak Sehgal - https://sartech.substack.com
- JabPerf - https://jabperf.com/blog
- Xoranth - https://xoranth.net
- My Octopress - https://joemario.github.io
- Number World - http://www.numberworld.org
- Gamozo Labs - https://gamozolabs.github.io
- Mechanical Sympathy - https://mechanical-sympathy.blogspot.com
- Performance Engineering - https://pramodkumbhar.com
- Performance Matters - https://thume.ca/archive.html
- Performance Tricks - https://www.performetriks.com/blog
- Coding Confessions - https://blog.codingconfessions.com
- The Netflix Tech - https://netflixtechblog.com
- Cloudflare - https://blog.cloudflare.com
Twitter
- @Cardyak
- @InstLatX64
Tutorials
- Performance Ninja Class - https://github.com/dendibakh/perf-ninja
- Hardware Effects - https://github.com/Kobzol/hardware-effects
- Performance Speed Limits - https://travisdowns.github.io/blog/2019/06/11/speed-limits.html
- Performance Tuning - https://github.com/NAThompson/performance_tuning_tutorial
- Mastering C++ with Google Benchmark - https://ashvardanian.com/posts/google-benchmark
- Learning to Write Less Slow C, C++, and Assembly Code - https://github.com/ashvardanian/less_slow.cpp
- Hunting a NUMA Performance Bug - https://www.scylladb.com/2021/09/28/hunting-a-numa-performance-bug/
- Performance Roulette: The Luck of Code Alignment - https://www.bazhenov.me/posts/2024-02-performance-roulette
- Bits Of Architecture - https://github.com/CoffeeBeforeArch/bits_of_architecture
Benchmarks
- Open Benchmarking - https://openbenchmarking.org
- Microbenchmarks - https://github.com/clamchowder/Microbenchmarks
- Phoronix Test Suite - https://www.phoronix-test-suite.com
- SPEC CPU Benchmark Suites - https://www.spec.org/cpu
- CPU Benchmark - https://www.cpubenchmark.net
- Geekbench Benchmark - https://browser.geekbench.com
- CPU Benchmarks - https://curiouscoding.nl/posts/cpu-benchmarks
- 7-Zip LZMA Benchmark - https://www.7-cpu.com
Videos
- Computer Architecture - Onur Mutlu - https://www.youtube.com/@OnurMutluLectures
- Computer, Enhance - Casey Muratori - https://www.youtube.com/@MollyRocket
- Assembly - Creel - https://www.youtube.com/c/WhatsACreel
- CSE142 - Prof Usagi - https://www.youtube.com/@ProfUsagi
- CPU uArch - Fabian Giesen - https://www.youtube.com/watch?v=JpQ6QVgtyGE
- EasyPerf - Denis Bakhvalov - https://www.youtube.com/@easyperf3992
- SIMD algorithms - Denis Yaroshevskiy - https://www.youtube.com/playlist?list=PLYCMvilhmuPEM8DUvY6Wg_jaSFHpmlSBD
- Computerphile - https://www.youtube.com/playlist?list=PLzH6n4zXuckpwdGMHgRH5N9xNHzVGCxwf
- Design - https://www.youtube.com/@ByteMonk
- Tuning C++: Benchmarks, and CPUs, and Compilers! Oh My! - Chandler Carruth - https://www.youtube.com/watch?v=nXaxk27zwlk
- Counting Nanoseconds Microbenchmarking C++ Code - David Gross - https://www.youtube.com/watch?v=Czr5dBfs72U
- Benchmarking C++ Code - Bryce Adelstein-Lelbach - https://www.youtube.com/watch?v=zWxSZcpeS8Q
- Benchmarking C++, From video games to algorithmic trading - Alexander Radchenko - https://www.youtube.com/watch?v=7YVMC5v4qCA
- Popcount as an Example Of Microbenchmarking in C - Bart Massey - https://www.youtube.com/watch?v=opJvsJk1B68
- Tuning C++: Benchmarks, and CPUs, and Compilers! Oh My! - Chandler Carruth - https://www.youtube.com/watch?v=nXaxk27zwlk
- Going Nowhere Faster - Chandler Carruth - https://www.youtube.com/watch?v=2EWejmkKlxs
- Measurement and Timing - Performance suiteering of Software Systems - https://www.youtube.com/watch?v=LvX3g45ynu8
- Causes of Performance Instability due to Code Placement in IA - https://www.youtube.com/watch?v=IX16gcX4vDQ
- Towards ameliorating measurement bias - https://www.youtube.com/watch?v=COmfRpnujF8
- How NOT to Measure Latency - Gil Tene - https://www.youtube.com/watch?v=lJ8ydIuPFeU
- From Top-down Microarchitecture Analysis to Structured Performance Optimizationsa - https://cassyni.com/events/YKbqoE4axHCgvQ9vuQq7Cy
- Coz: finding code that counts with causal profiling - ACM - https://www.youtube.com/watch?v=jE0V-p1odPg
- Take Advantage for Intel Instrumentation and Tracing Technology for Performance Analysis - https://www.youtube.com/watch?v=1zdVFLajewM&list=PLg-UKERBljNw3_6Q598CS3DE7KqDXjP-d
- LIKWID Performance Tools - https://www.youtube.com/playlist?list=PLxVedhmuwLq2CqJpAABDMbZG8Whi7pKsk
- Introduction to the Tracy Profiler - Bartosz Taudul - https://youtu.be/fB5B46lbapc
- Performance Matters - Emery Berger - https://www.youtube.com/watch?v=r-TLSBdHe1A
- Understanding the Performance of code using LLVM-MCA - A. Biagio & M. Davis - https://www.youtube.com/watch?v=Ku2D8bjEGXk
- LLVM Optimization Remarks - Ofek Shilon - https://www.youtube.com/watch?v=qmEsx4MbKoc
- Understanding Compiler Optimization - Chandler Carruth - https://www.youtube.com/watch?v=haQ2cijhvhE
- Efficiency with Algorithms, Performance with Data Structures - Chandler Carruth - https://www.youtube.com/watch?v=fHNmRkzxHWs
- Design for Performance - Fedor Pikus - https://www.youtube.com/watch?v=m25p3EtBua4
- Unlocking Modern CPU Power - Next-Gen C++ Optimization Techniques - https://www.youtube.com/watch?v=wGSSUSeaLgA
- Branchless Programming in C++ - Fedor Pikus - https://www.youtube.com/watch?v=g-WPhYREFjk
- Out-of-order execution - What can it do for me? - Patrick Schittekat - NDC TechTown 2023
- CPU design effects - Jakub Beranek - youtube.com/watch?v=ICKIMHCw--Y
- Fastware - Andrei Alexandrescu - https://www.youtube.com/watch?v=o4-CwDo2zpg
- Performance Tuning - Matt Godbolt - https://www.youtube.com/watch?v=fV6qYho-XVs
- Memory & Caches - Matt Godbolt - https://www.youtube.com/watch?v=4_smHyqgDTU
- What Every Programmer Should Know about How CPUs Work - Matt Godbolt - https://www.youtube.com/watch?v=-HNpim5x-IE
- C++ switch statements under the hood in LLVM - Hans Wennborg - https://www.youtube.com/watch?v=nfy51jenN3M
- There Are No Zero-cost Abstractions - Chandler Carruth - https://www.youtube.com/watch?v=rHIkrotSwcc&
- Understanding Optimizers: Helping the Compiler Help You - Nir Friedman - https://www.youtube.com/watch?v=8nyq8SNUTSc
- C++ Algorithmic Complexity, Data Locality, Parallelism, Compiler Optimizations, & Some Concurrency - Avi Lachmish - https://www.youtube.com/watch?v=0iXRRCnurvo
- Software Optimizations Become Simple with Top-Down Analysis on Intel Skylake - Ahmad Yasin - https://www.youtube.com/watch?v=kjufVhyuV_A
- Being Friendly to Your Computer Hardware in Software Development - Ignas Bagdonas - https://www.youtube.com/watch?v=eceFgsiPPmk
- Want fast C++? Know your hardware - Timur Doumler - https://www.youtube.com/watch?v=BP6NxVxDQIs
- What is Low Latency C++ - Timur Doumler - https://www.youtube.com/watch?v=EzmNeAhWqVs, https://www.youtube.com/watch?v=5uIsadq-nyk
- Where Have All the Cycles Gone? - Sean Parent - https://www.youtube.com/watch?v=B-aDBB34o6Y
- Understanding CPU Microarchitecture to Increase Performance - https://www.youtube.com/watch?v=rglmJ6Xyj1c
- Performance Analysis & Tuning on Modern CPU - Denis Bakhvalov - https://www.youtube.com/watch?v=Ho3bCIJcMcc
- Comparison of C++ Performance Optimization Techniques for C++ Programmers - Eduardo Madrid - https://www.youtube.com/watch?v=4DQqcRwFXOI
- Simple Code, High Performance - Molly Rocket - https://www.youtube.com/watch?v=Ge3aKEmZcqY
- Assembly, System Calls, and Hardware in C++ - David Sankel - https://www.youtube.com/watch?v=7xwjjolDnwg
- Optimizing Binary Search - Sergey Slotin - https://www.youtube.com/watch?v=1RIPMQQRBWk
- A Deep Dive Into Dispatching Techniques in C++ - Jonathan Muller - https://www.youtube.com/watch?v=vUwsfmVkKtY
- Dive into the general purpose GPU programming - Ashot Vardanian - https://www.youtube.com/watch?v=AA4RI6o0h1U
- C++ Memory Model: from C++11 to C++23 - Alex Dathskovsky - https://www.youtube.com/watch?v=SVEYNEWZLo4
- Abusing Your Memory Model for Fun and Profit - Samy Al Bahra, Paul Khuong - https://www.youtube.com/watch?v=N07tM7xWF1U&t=1s
- The speed of concurrency (is lock-free faster?) - Fedor Pikus - https://www.youtube.com/watch?v=9hJkWwHDDxs
- Read, Copy, Update, then what? RCU for non-kernel programmers - Fedor Pikus - https://www.youtube.com/watch?v=rxQ5K9lo034
- Single Producer Single Consumer Lock-free FIFO From the Ground Up - Charles Frasch - https://www.youtube.com/watch?v=K3P_Lmq6pw0
- Introduction to Hardware Efficiency in Cpp - Ivica Bogosavljevic - https://www.youtube.com/watch?v=Fs_T070H9C8
- OptView2 - Helping the Compiler Generate Better Code - Ofek Shilon - https://www.youtube.com/watch?v=6HbyacS5eZQ
- The Performance Price of Dynamic Memory in C++ - Ivica Bogosavljevic - https://www.youtube.com/watch?v=LC4jOs6z-ZI
- Kernel Bypass HFT Optimization - https://www.youtube.com/watch?v=FFI9IAy5ZaE
- The Hidden Performance Price of C++ Virtual Functions - Ivica Bogosavljevic - https://www.youtube.com/watch?v=n6PvvE_tEPk
- Why do Programs Get Slower with Time? - Ivica Bogosavljevic - https://www.youtube.com/watch?v=nS5vjnPKX0I
- CPU Cache Effects - Sergey Slotin - https://www.youtube.com/watch?v=mQWuX_KgH00
- Cpu Caches and Why You Care - Scott Meyers - https://www.youtube.com/watch?v=WDIkqP4JbkE
- CPU vs FPGA - https://www.youtube.com/watch?v=BML1YHZpx2o
- Designing for Efficient Cache Usage - Scott McMillan - https://www.youtube.com/watch?v=3-ityWN-FdE
- Cache consistency and the C++ memory model - Yossi Moale - https://www.youtube.com/watch?v=Sa08x_NMZIg
- std::simd: How to Express Inherent Parallelism Efficiently Via Data-parallel Types - Matthias Kretz - https://www.youtube.com/watch?v=LAJ_hywLtMA
- The Art of SIMD Programming - Sergey Slotin - https://www.youtube.com/watch?v=vIRjSdTCIEU
- Advanced SIMD Algorithms in Pictures - Denis Yaroshevskiy - https://www.youtube.com/watch?v=vGcH40rkLdA
- Performance Optimization, SIMD and Cache - Sergiy Migdalskiy - https://www.youtube.com/watch?v=Nsf2_Au6KxU
- You Can Do Better than std::unordered_map - Malte Skarupke - https://www.youtube.com/watch?v=M2fKMP47slQ
- Designing a Fast, Efficient, Cache-friendly Hash Table, Step by Step - Matt Kulukundis - https://www.youtube.com/watch?v=ncHmEUmJZf4
- Faster than Rust and C++: the PERFECT hash table - https://www.youtube.com/watch?v=DMQ_HcNSOAI
- C++ Run-Time Optimizations for Compile-Time Reflection - Kris Jusiak - https://www.youtube.com/watch?v=ncHmEUmJZf4 - https://www.youtube.com/watch?v=kCATOctR0BA
- Data-Oriented Design and C++ - Mike Acton - https://www.youtube.com/watch?v=rX0ItVEVjHc
- Data-Oriented Design Revisited - https://www.youtube.com/watch?v=KOZcJwGdQok
- Data-Oriented Design and Modern C++ - https://www.youtube.com/watch?v=GoIOnQEmXbs
- Data-Oriented Design and Entity Component System Explained - https://www.youtube.com/watch?v=xm4AQj5PHT4
- Data-Oriented Design in Practice - https://www.youtube.com/watch?v=NWMx1Q66c14
- Data-Oriented Design Story - https://www.youtube.com/watch?v=fv43GuesjuM
- Data-Oriented Demo: SOA, composition - https://www.youtube.com/watch?v=ZHqFrNyLlpA
- Data-Oriented Approach to Using Component Systems - https://www.youtube.com/watch?v=p65Yt20pw0g
- Data-Orientation For The Win - Eduardo Madrid - https://www.youtube.com/watch?v=QbffGSgsCcQ
- Practical Data-Oriented Design (DoD) - Andrew Kelley - https://www.youtube.com/watch?v=IroPQ150F6c
- When Nanoseconds Matter: Ultrafast Trading Systems in C++ - David Gross - https://www.youtube.com/watch?v=sX2nF1fW7kI
- When a Microsecond Is an Eternity: High Performance Trading Systems in C++ - Carl Cook - https://www.youtube.com/watch?v=NH1Tta7purM
- The Speed Game: Automated Trading Systems in C++ - Carl Cook - https://www.youtube.com/watch?v=ulOLGX3HNCI
- Low-Latency Trading Systems in C++ - Jason McGuiness - https://www.youtube.com/watch?v=FnMfhWiSweo
- High Frequency Trading and Ultra Low Latency development techniques - Nimrod Sapir - https://www.youtube.com/watch?v=_0aU8S-hFQI
- Trading at light speed: designing low latency systems in C++ - David Gross - https://www.youtube.com/watch?v=8uAW5FQtcvE&list=PLSkBiuVO9yj1MvDkYJ5WOnPeKsoRi3eiW&index=2
- Optimizing Trading Strategies for FPGAs in C/C++ - https://www.youtube.com/watch?v=4Wklh0XS5i0
- C++ Electronic Trading for Cpp Programmers - Mathias Gaunard - https://www.youtube.com/watch?v=ltT2fDqBCEo
- Achieving performance in financial data processing through compile time introspection - Eduardo Madrid - https://www.youtube.com/watch?v=z6fo90R8q5U
- How to Simulate a Low Latency Exchange in C++ - Benjamin Catterall - https://www.youtube.com/watch?v=QQrTE4YLkSE
- Building Low Latency Trading Systems - https://www.youtube.com/watch?v=yBNpSqOOoRk
- Cache Warming: Warm Up The Code - Jonathan Keinan - https://www.youtube.com/watch?v=XzRxikGgaHI
- How Linux Took Over the World of Finance - Christoph H Lameter - https://www.youtube.com/watch?v=UUOM4KdaHkY
Miscellaneous
- Conferences - https://www.p99conf.io, https://supercomputing.org, https://hotchips.org, https://microarch.org
- Podcasts - https://signals-threads.simplecast.com, https://microarch.club, https://tlbh.it, https://twoscomplement.org
- C++ Low Latency Group (SG14) - https://github.com/WG21-SG14/SG14

Tools

Benchmarking
- google-benchmark - https://github.com/google/benchmark / https://quick-bench.com
- nanobench - https://github.com/martinus/nanobench
- celero - https://github.com/DigitalInBlue/Celero
- folly-benchmark - https://github.com/facebook/folly/blob/main/folly/docs/Benchmark.md
- benchmark-gui -https://github.com/skarupke/benchmark-gui
- nanoBench - https://github.com/andreas-abel/nanoBench
- uarch-bench - https://github.com/travisdowns/uarch-bench
- llvm-exegesis - https://llvm.org/docs/CommandGuide/llvm-exegesis.html
- nvbench - https://github.com/NVIDIA/nvbench
Profilers
- linux-perf - https://perf.wiki.kernel.org
- intel-vtune - https://www.intel.com/content/www/us/en/docs/vtune-profiler
- amd-uprof - https://www.amd.com/en/developer/uprof.html
- pmu-tools - https://github.com/andikleen/pmu-tools
- perf-tools - https://github.com/brendangregg/perf-tools
- magictrace - https://github.com/janestreet/magic-trace
- tracy - https://github.com/wolfpld/tracy
- likwid - https://github.com/RRZE-HPC/likwid
- coz - https://github.com/plasma-umass/coz
- ebpf - https://ebpf.io
- callgrind - https://valgrind.org/docs/manual/cl-manual.html
- yperf - https://github.com/aayasin/perf-tools
- dtrace - https://www.oracle.com/linux/downloads/linux-dtrace.html
- ftrace - https://www.kernel.org/doc/html/latest/trace/ftrace.html
- utrace - https://github.com/Gui774ume/utrace
- strace - https://strace.io
- omnitrace - https://github.com/ROCm/omnitrace
- optick - https://github.com/bombomby/optick
- easy_profiler - https://github.com/yse/easy_profiler
- gprof - https://ftp.gnu.org/old-gnu/Manuals/gprof-2.9.1/html_mono/gprof.html
- gperftools - https://github.com/gperftools/gperftools
- oprofile - https://oprofile.sourceforge.io
- optview2 - https://github.com/OfekShilon/optview2
- llvm-xray - https://llvm.org/docs/XRay.html
- lttng - https://lttng.org
- bcc - https://github.com/iovisor/bcc
- sysprof - https://www.sysprof.com
Analyzers
- llvm-mca - https://llvm.org/docs/CommandGuide/llvm-mca.html
- osaca - https://github.com/RRZE-HPC/OSACA
- uica - https://uica.uops.info
- kcachegrind - https://kcachegrind.sourceforge.net/html/Home.html
- llvm-opt-report - https://llvm.org/docs/CommandGuide/llvm-opt-report.html
- compiler-explorer - https://compiler-explorer.com ^1
- flamegraph - https://github.com/brendangregg/FlameGraph, https://flamegraph.com ^1
- asm control-flow-graph - https://marioslab.io/projects/cfg ^1
- flamelens - https://github.com/YS-L/flamelens
- perfetto - https://perfetto.dev ^1
- speedscope - https://github.com/jlfwong/speedscope ^1
- jupyter - https://jupyter.org
Optimizers
- clang-pgo - https://clang.llvm.org/docs/UsersManual.html#profile-guided-optimization
- gcc-pgo - https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html
- llvm-bolt - https://github.com/llvm/llvm-project/blob/main/bolt/README.md
- llvm-propelleer - https://github.com/google/llvm-propeller
- autofdo - https://github.com/google/autofdo
- e-graphs - https://egraphs-good.github.io
Utilities
- pyperf - https://github.com/psf/pyperf
- stabilizer - https://github.com/ccurtsinger/stabilizer
- numatop - https://github.com/intel/numatop
- bpftop - https://github.com/Netflix/bpftop
- hotspot - https://github.com/KDAB/hotspot
- hyperfine - https://github.com/sharkdp/hyperfine
- pahole - https://github.com/acmel/dwarves
- bloaty - https://github.com/google/bloaty

Libraries

Core
- perf-event-open - https://man7.org/linux/man-pages/man2/perf_event_open.2.html
- perfomon - https://github.com/intel/perfmon
- perfmon2 - https://perfmon2.sourceforge.net
- papi - https://github.com/icl-utk-edu/papi
- PMU - https://github.com/ARM-software/PMUv3_plugin
- libpfc - https://github.com/obilaniu/libpfc
- intel-pt - https://github.com/intel/libipt
- llvm-dev - https://llvm.org
- zydis - https://github.com/zyantific/zydis
Others
- simd - https://github.com/google/highway
- json - https://github.com/simdjson/simdjson
- logging - https://github.com/odygrd/quill
- string - https://github.com/ashvardanian/StringZilla
- lockfree queue - https://github.com/rigtorp/SPSCQueue
- hash map - https://github.com/boostorg/unordered
- perfect hashing - https://github.com/qlibs/mph
- static branching - https://github.com/qlibs/jmp

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

resources

Uh oh!

Clone this wiki locally