gpu performance

Dragan Djuric presents Clojure libraries for GPU and numerical computing, including ClojureCL, ClojureCUDA and Neanderthal. He shows how a dynamic REPL workflow can be combined with low-level hardware acceleration for machine learning and data science.

A Netflix performance engineer presents how Netflix tunes EC2 instances, covering instance type choice, Xen modes, SR-IOV and kernel tuning. The goal is near bare-metal performance in the cloud.

Chandler Carruth's CppCon 2014 talk on writing fast C++, explaining why data structure choice and memory layout matter more than clever algorithms. It covers why standard containers like unordered_map perform poorly on modern CPUs.

Malte Skarupke's C++Now 2018 talk on hash table performance, explaining why std::unordered_map is slow and memory hungry and presenting faster designs, including his bytell hash map.

SpaceX engineers present at NVIDIA's GPU Technology Conference on a multi-physics code that simulates the full-scale Raptor methane engine. It covers GPU-based turbulent combustion modeling with adaptive grids and wavelet compression.

An excerpt from a Bay Area Rust meetup on Servo's WebRender, which renders CSS display lists on the GPU at very high frame rates. It explains the approach and demos rendering at around 500 FPS.

Emery Berger explains why performance is hard to measure and deliver on modern hardware, showing how code layout and alignment can swamp optimization effects. He presents Stabilizer for statistically sound evaluation and Coz, a causal profiler.

Alex Russell's Chrome Dev Summit 2016 talk on building web experiences that work on slow, flaky networks and low-power devices. It argues developers should focus on the performance of real-world mobile hardware rather than desktop machines.

Chandler Carruth walks through tuning C++ performance, from writing benchmarks to analyzing results on real CPUs and compilers. It focuses on small-scale problems such as loop kernels, data structures and algorithms, and on keeping compilers from optimizing benchmarks away.

Cliff Click walks through a small performance example on a modern out-of-order CPU. He covers pipelining, ILP, CISC vs RISC, multicore, and why cache misses and the memory subsystem dominate performance.

Louis Rossmann argues that reballing flip-chip GPUs is not a real fix for dead laptop GPUs. He explains why such repairs and oven reflow tricks fail and what is actually happening with failing hardware.

Chandler Carruth's CppCon 2016 talk on designing hybrid data structures for performance. He covers cache locality, working-set size and allocation overhead, and why standard C++ containers fall short.

Linus Tech Tips tests a Chinese mining-only Nvidia card, hacked with a modified driver so it can render games and output video through an integrated GPU.

Louis Rossmann examines a 2012 MacBook Pro logic board that Apple refurbished for GPU failures and that failed again. He criticizes the quality of Apple's authorized repair work and argues for right to repair.

A demo excerpt from a 2016 Bay Area Rust meetup showing Servo's WebRender drawing CSS on the GPU at very high frame rates. It presents the promise of GPU-based browser rendering.

A short side-by-side recording by Jake Archibald of the same animation demo running in Chrome, Firefox, Safari and Servo WebRender nightlies on a 60Hz display. It shows the smoothness difference of GPU-based rendering.

Optiver's Carl Cook explains how to build high-frequency trading systems in C++, where the critical path runs rarely but must be extremely fast. He covers techniques for low and predictable latency, including avoiding main memory and cache misses.

Jack Moffitt presents the architecture of Servo, Mozilla's experimental browser engine written in Rust, focusing on parallelism across cores, GPUs and SIMD and the safety properties gained from Rust.

Aaron Hsu shows how to manipulate and transform tree data in APL using arrays and inverted tables instead of pointers. He claims much smaller code, better performance and easier parallelisation.

A Tiny Desk concert in which pianist Dan Tepfer plays with a Disklavier player piano driven by a program he wrote that responds to his playing. He performs four pieces from his Natural Machines project.

A solo performance of Steve Reich's Piano Phase, with one pianist playing both parts, recorded in 2004 with Reich in attendance. It is a 15-minute minimalist phasing piece.

The Who performing Won't Get Fooled Again at Shepperton Studios in 1978, filmed for The Kids Are Alright. It was Keith Moon's last performance with the band.

A one-minute NVIDIA research demo of foveated rendering for VR using SMI eye tracking. It renders at full detail only where the eye is looking, matching the physiology of human vision.

Mike Acton of Insomniac Games argues that a program's purpose is transforming data, and shows how common C++ approaches work against that in performance-critical game development. He covers cache behavior, data layout and the limits of compilers.

A full performance of Steve Reich's Music for 18 Musicians by eighth blackbird with Third Coast Percussion and others, recorded in Chicago in 2011. It is an hour-long minimalist piece built on phasing and repeating patterns.

Chandler Carruth shows how to squeeze more performance out of already-optimized C++ code, covering how the CPU executes it. The talk goes into pipelining, branch prediction and speculative execution using benchmarks.

A CppCon 2018 talk arguing that OOP has failed to deliver on reuse and performance, and presenting data-oriented design for C++ with practical worked examples from real systems.

Dave Chinner's linux.conf.au 2012 talk on XFS scalability, covering pain points with large numbers of files and complex metadata, and the work to fix XFS metadata performance.

Matt Godbolt builds a toy path tracer in C++ in three different styles and compares them on clarity, testability, compile time and run-time performance. The talk was given at CppCon 2019.

A one-minute clip of Rochus Keller performing as a one-man band: slap bass with the left hand, Rhodes and lead guitar with the right, and drums with the feet.

David Ditzel of Esperanto Technologies presents their massively parallel, energy-efficient RISC-V processors at the 7th RISC-V Workshop in 2017. It covers the high-performance many-core design aimed at machine learning.

Aaron Patterson's RailsConf 2011 talk on Rails 3.1 performance, showing why deeper Rack middleware stacks slow Rails and how a shallower pipeline helps. It also touches on Rack API design.

Linus Tech Tips tests whether chaining many PCIe riser extensions causes loss of GPU performance. They keep adding extensions to see how far the signal will go.

A very short clip from Star Trek: The Next Generation's 'Peak Performance' in which Picard says it is possible to commit no mistakes and still lose. It is a single quotable moment about how outcomes are not fully in your control.

Ilya Grigorik of Google's Make the Web Fast team explains how to build a mobile site that appears on screen within one second. He covers the network and rendering constraints on mobile.

Olivier Giroux's CppCon 2019 talk recounts the roughly ten-year effort to bring std::atomic and the C++ memory model to CUDA GPUs, through ten stories from that work.

A short scene from Star Trek TNG season 2, episode 'Peak Performance', in which Picard tells Data that it is possible to commit no mistakes and still lose. He says that is not a weakness but life.

Andrei Alexandrescu's CppCon 2019 talk revisits sorting, showing how branchless tricks, hybrid strategies and a cost metric can speed up std::sort-style algorithms on modern hardware.

Admiral Grace Hopper holds up a length of wire to show how far light travels in a nanosecond, about 11.8 inches. She explains how she made the idea concrete to people who could not picture a billionth of a second.

Cliff Click, author of HotSpot's JIT compiler, shares hard-won advice for people writing virtual machines at the VMSS16 workshop. Topics include interpreters, JITs and performance lessons.