gpu performance

A Gamers Nexus investigative documentary on the black market for Nvidia AI GPUs, following smugglers, middlemen, and buyers, including reporting from China. It examines how export-restricted chips reach their users.

Linus Tech Tips looks at whether buying a used GPU that was previously used for crypto mining is a good idea, as miners prepare to sell off cards. The video discusses how mining affects wear on cards and what to watch for.

Emery Berger's CppCon 2020 plenary on why performance is hard on modern hardware after the end of Dennard scaling. It covers benchmarking pitfalls and introduces new profiling tools for finding real bottlenecks.

Casey Muratori shows how typical 'clean code' object-oriented patterns can cost large factors in performance. He benchmarks them against simpler data-oriented code.

Casey Muratori follows up his refterm proof-of-concept, a GPU-based terminal renderer, with a second part covering memory usage, glyph sizing and correct Unicode and VT handling. It is built to show that a terminal can be fast and correct without heroic effort.

A Remedy engineer explains how Alan Wake 2 moved to a GPU-driven rendering pipeline built on mesh shaders, culling and rendering meshlets for dense vegetation on PS5 and Xbox Series consoles.

Gamers Nexus benchmarks GPU gaming performance on Linux using the Bazzite OS, an exploratory first step toward establishing a Linux testing methodology. It compares results against Windows and notes where Linux still falls short.

Level1Techs' Wendell shows Intel's Flex 170 GPU providing GPU-accelerated virtual desktops on Proxmox 8.1 without subscription licensing, using SR-IOV, and demonstrates many desktop instances running at once.

Kaze Emanuar explains how he rewrote and optimized the Super Mario 64 source code so it runs far faster on real N64 hardware. He covers performance bottlenecks and fixes in detail for his ROM hacks.

Casey Muratori's University of Twente guest lecture is a case study in how straightforward code can cut thousands of lines and tens of seconds of runtime down to a few dozen lines running in under a second. It uses concrete examples to show why software is often an order of magnitude slower than it should be.

Emery Berger argues that performance is hard to measure and deliver on modern systems, showing how code layout and link order can swamp optimization effects. He presents tools that evaluate performance more reliably.

Digital Foundry investigates why Resident Evil Village on PC runs worse with Capcom's Denuvo DRM than a cracked version. They benchmark and confirm performance and frame-pacing differences.

Casey Muratori responds on-stream to a dismissive Twitter post by demonstrating how slow Visual Studio's startup and debugger watch window are, comparing it to much older software and machines. It is a long rant about software performance and bloat.

Leptos creator Greg Johnston examines Rust/WebAssembly frontend frameworks against JavaScript frameworks using the JS framework benchmark. He argues that WASM is no longer too slow for DOM-heavy rendering.

Developer Voices interviews Chris Lattner about Mojo, a Python-compatible language aimed at CPU/GPU performance built on LLVM and MLIR. It covers performance features, the type system and why Mojo uses Python syntax.

Charlie Marsh of Astral explains how uv, a Rust Python package manager, got so fast. He covers allocators, concurrency, zero-copy tricks and the challenges of Python packaging.

Robert Collins explains why rustup installs were painfully slow on Windows and how changes to rustup and Windows cut install time from 3m30s to 14s. The talk covers NTFS, small files and the cost of antivirus hooks on file close.

Rik Arends presents Makepad, a Rust UI framework, at RustNL 2023. The talk covers designing modern, GPU-fast UIs with Rust and includes live-coded demos of an IDE and a synthesizer.

Allan Jude of Klara presents work on making ZFS scale on fast NVMe storage, covering fixes to the TaskQueue interface and removal of bottlenecks. The talk was given at EuroBSDcon 2022 and describes raising write throughput from about 3 to over 7 GB/sec.

A long George Hotz live-stream from June 2023 in which he works on tinygrad and rants about AMD's drivers, ultimately declaring he is giving up on AMD. It also touches on hardware and compiler topics.

Casey Muratori's first refterm lecture lays out philosophies of optimization, distinguishing optimization from non-pessimization, which means avoiding needless work. It uses his fast terminal renderer project to show how fast computers really are.

Casey Muratori shows how fast a terminal renderer can run, building a simple reference renderer that handles Unicode and colored text far quicker than Windows Terminal. He argues that common excuses for slow terminals do not hold up.

A ten-minute card-magic act by Dani DaOrtiz performed on Penn & Teller: Fool Us in 2022. It is built on timing, misdirection and psychology, and the method defeated the show's hosts.

Richard Feldman explains how pure functional languages can match or beat imperative ones on performance. Compilers can turn immutable code into in-place mutation, avoiding naive copying. The talk draws on his work on the Roc language.

A hobbyist compares vertical bifacial solar panels against south-facing angled panels using winter production results. It tests whether the usual mounting approach is actually best.

Alexis King's ZuriHac 2020 talk on how effect systems in Haskell can be implemented efficiently. It looks at the performance cost of effect libraries and how to reduce it.

Bill Dally of NVIDIA gives a Hot Chips 2023 keynote on the challenges of building hardware for deep learning. He traces how GPUs have been adapted for machine learning, especially training.

Brandt Bucher presents his prototype JIT compiler for CPython at the 2023 Core Developer Sprint. He explains the copy-and-patch approach, the implementation and its performance.

Chandler Carruth's CppNow 2023 talk on modernizing compiler design for the Carbon toolchain, using data-oriented design and modern hardware assumptions. It covers lexing, parsing and compact data structures aimed at compiler performance.

Matt Parker follows the community effort to speed up his slow Wordle-solving code, which ended up running hundreds of millions of times faster. He walks through the techniques contributors used.

A Graphics Programming Conference talk on how the game Tiny Glade renders meadows, trees and player-built castles. It covers real-time global illumination, tilt-shift depth of field, stable shadows with continuous time of day, ray marching and GPU-driven rendering on old hardware.

Netflix engineer Drew Gallatin explains why the company runs FreeBSD-current on its CDN. He describes the team, how they track upstream, their contributions and performance milestones, and a bug causing a 20% performance regression.

Geekerwan's Chinese-language review of Intel's Lunar Lake lightweight laptop chip, covering performance, perf-per-watt curves and battery life benchmarks. It tests whether x86 can compete on efficiency.

Apple's November 10, 2020 event introducing the Apple M1 chip and the new MacBook Air, 13-inch MacBook Pro and Mac mini, along with macOS Big Sur.

A short Microsoft promo comparing classic Teams with the rewritten new Teams side by side, claiming faster startup and better performance. The new version is shown taking around nine seconds to launch.

Brian Karis's SIGGRAPH 2021 talk explains how Unreal Engine 5's Nanite virtualized geometry works. It covers mesh import, the data structures, streaming, decompression, culling, software and hardware rasterization, and shading.

Andrew Kelley, creator of Zig, presents practical data-oriented design techniques for shrinking memory footprint and making programs cache friendly. He ends with a case study of how these ideas sped up the Zig compiler.

Drummer Danny Carey performs Tool's 'Pneuma' live in Boston, in a Vic Firth session with close views of his playing.

Wes Bos breaks down the techniques behind the McMaster-Carr website's speed: server-rendered HTML, prefetching, CDN and service worker caching, preloading, critical CSS and fixed-size images. He also notes its old-school jQuery and YUI JavaScript.

Matthias Wandel tests old and new code on a range of PCs, including a new mini PC, to measure how much faster modern hardware really is. He also shows optimization techniques such as branchless code, with benchmark programs on GitHub.