randomascii.md

• Please Restore Our Registers When You’re Done With Them

• Why Modern Software is Slow–Windows Voice Recorder

• Slower Memory Zeroing Through Parallelism

• 11 mm in 1.25 nanoseconds

• Determinism Bugs, Part Two, Kernel32.dll

• Two Deterministic Build Bugs

• Windows Performance Analyzer, From Store or SDK

• Finding Windows HANDLE leaks, in Chromium and others

• Arranging Invisible Icons in Quadratic Time

• Windows Timer Resolution: The Great Rule Change

• Ditching WhatsApp

• ARM and Lock-Free Programming

• Floating Point in the Browser, Part 3: When x+y=x (y != 0)

• Floating Point in the Browser, Part 2: Bad Epsilon

• Windows Timer Resolution: The Great Rule Change

• Floating Point in the Browser, Part 1: Impossible Expectations

• The Easy Ones – Three Bugs Hiding in the Open

• GDI leaks and the importance of luck

• What Outranks Thread Priority?

• Big Project Build Times–Chromium

• Creating a Public Symbol Server, Easily

• Bulk ETW Trace Analysis in C#

• O(n^2), again, now in WMI

• Heap Snapshots–Tracing All Heap Allocations

• 63 Cores Blocked by Seven Instructions

• We Need a Carbon Tax, Now, That Goes Up Over Time

• Taskbar Latency and Kernel Calls

• O(n^2) in CreateProcess

• Exercises in Emulation: Xbox 360’s FMA Instruction

• When Your Profiler Lies

• A Not-Called Function Can Cause a 5X Slowdown

• Making Windows Slower Part 2: Process Creation

• Commute Challenge 2018

• 24-core CPU and I can’t type an email (part two)

• 24-core CPU and I can’t type an email (part one)

• Making Windows Slower Part 1: File Access

• Compiler bug? Linker bug? Windows Kernel bug.

• Zombie Processes are Eating your Memory

• What We Talk About When We Talk About Performance

• What Would Jesus’s Resume Say?

• Finding a CPU Design Bug in the Xbox 360

• Analyzing a Confusing Crash–Stack Walks Gone Bad

• Hey Synaptics, Can You Please Stop Polling!

• What is Windows doing while hogging that lock

• 24-core CPU and I can’t move my mouse

• The Spoils of Law (Moore’s Law)–a New Laptop

• Sometimes Floating Point Math is Perfect

• Commute Challenge 2017

• Traveling in Iran

• Delete an inline function, save 794 kB

• Add a const here, delete a const there…

• Seattle to Portland on a Unicycle

• VC++ /arch:AVX option – unsafe at any speed

• CPU Performance Counters on Windows

• WPA Symbol Loading is Much Faster, but Broken for Chrome

• Vestibular Dysfunction, or, How I Went Half Deaf

• Everything Old is New Again, and a Compiler Bug

• ETW Flame Graphs Made Easy

• Zeroing Memory is Hard (VC++ 2015 arrays)

• DNA-Free Dining Made Easy

• UIforETW is No Longer a CPU Hog

• Compiler Bugs Found When Porting Chromium to VC++ 2015

• A modest proposal for a more natural KB

• Power Wastage On An Idle Laptop

• Cars in Canada Get Better Mileage than in the US

• Base Ten For (Almost) Everything

• Making a 4K Fractal Movie with Fractal eXtreme

• Thread Naming in Windows: Time for Something Better

• ETW Central

• Xperf Basics: Recording a Trace (the ultimate easy way)

• New Xperf and new WPA in the new WPT

• Graph All the Things (Using WPT 10)

• Programming is Puzzles

• ETW Heap Tracing–Every Allocation Recorded

• UIforETW – Windows Performance Made Easier

• Profiling the profiler: working around a six minute xperf hang

• ETW Trace Compression (and xperf syntax refresher)

• Knowing Where to Type ‘Zero’

• Home Network Printer Setup That Works

• Hidden Costs of Memory Allocation

• Slow Symbol Loading in Microsoft’s Profiler, Take Two

• Intel Underestimates Error Bounds by 1.3 quintillion

• A Crash of Great Opportunity

• ETW Training Videos Available Now

• Please Calculate This Circle’s Circumference

• Undefined Behavior Can Format Your Drive

• Buggy Security Guidance from Apple

• Self Inflicted Denial of Service in Visual Studio Search

• You Got Your Web Browser in my Compiler!

• Make VC++ Compiles Fast Through Parallel Compilation

• Making Compiles Slow Through Abuse of Templates

• Exercise Regimen for a 94 Year Old

• Process Tree from an Xperf Trace

• There are Only Four Billion Floats–So Test Them All!

• Bugs I Got Other Companies to Fix in 2013

• Warm Weather Snowmen

• VC++ 2013 class Layout Change and Wasted Space

• std::min Causing Three-Times Slowdown on VC++

• Exporting Arbitrary Data from xperf ETL files

• New Version of Xperf–Upgrade Now

• Riding Fast on One Wheel–Ignite Talk

• Hard Drive Upgrade

• How to Report a VC++ Code-Gen Bug

• Debugging Optimized Code–New in Visual Studio 2012

• Vote for the VC++ Improvements That Matter

• Developers Rejoice Again

• Developers Rejoice–Windows 7 Stack Corruption Fixed!

• Geared Unicycle Engineering Challenges

• 50 Bytes of Code That Took 4 GB to Compile

• Defective Heat Sinks Causing Garbage Gaming

• The New WPA Xperf Trace Viewer–New Bugs and Old

• Floating-Point Determinism

• Windows Timer Resolution: Megawatts Wasted

• Verizon’s Poor Customer Service

• Two Years (and Thousands of Bugs) of Static Analysis

• Other Causes of Alt+Tab Problems

• Twitter

• VC++ /analyze Bug Finder Bug Fixed

• Basics of Digital Photo Organization

• Alt+Tab Bug Worsened by IE 10, But Fix Found

• timeGetTime versus GetTickCount

• Energy Drinks: With None Of That Pesky Energy

• Xperf for Excess CPU Consumption: WPA edition

• Xperf Basics: Recording a Trace (the easy way)

• Python Debugger Update

• Techniques for Zooming in Xperf Trace Viewers

• Stop using strncpy already!

• Sleep Variation Investigated

• Summarizing Xperf CPU Usage with Flame Graphs

• Counting to Ten on Linux

• Should This Windows 7 Bug be Fixed?

• Symbols the Microsoft Way

• Symbols on Linux update: Fedora Fixes

• Visual Studio Single Step Performance Fixes

• Symbols on Linux Part Three: Linux versus Windows

• Float Precision Revisited: Nine Digit Float Portability

• Symbols on Linux Part Two: Symbols for Other Versions

• Symbols on Linux Part One: g++ Library Symbols

• For the Wages of Blogging is…

• Top Eight Entertaining Blog Facts for 2012

• The Surprising Subtleties of Zeroing a Register

• Windows Slowdown, Investigated, Identified, and Now Fixed

• Another Bug in Your Bug (Finder): __offsetof

• Riding Faster on One Wheel: Geared Unicycles

• The Lost Xperf Documentation–Disk Usage

• Comparing Memory is Still Tricky

• Out of Order Benefits

• Xperf Symbol Loading Pitfalls

• You’ve Got a Bug in Your Bug (Finder)

• Backin’ Up is Hard to Do

• Game Developer Magazine Floating Point

• Fractal eXtreme, now cheaper

• Windows Slowdown, Investigated and Identified

• Forgetfulness in Computers

• What the heck is amd64?

• Fixing another Photo Gallery performance bug

• Jetpacks and flying cars

• Gin and Tonic == Summer in a Glass

• More Adventures in Failing to Crash Properly

• When Even Crashing Doesn’t Work

• Doubles are not floats, so don’t compare them

• WPA–Xperf Trace Analysis Reimagined

• Myth: Mythbusters Can Do Math

• In Praise of Idleness

• Floating-Point Poetry

• Windows Live Photo Gallery—Poor Performance Peculiarities

• That’s Not Normal–the Performance of Odd Floats

• The Lost Xperf Documentation–CPU Usage (Precise)

• The Lost Xperf Documentation–CPU sampling

• The New Xperf is Here!

• Xperf Wait Analysis–Finding Idle Time

• Exceptional Floating Point

• iTunes, Fixed

• Floating-point complexities

• iTunes, iTunes, Why Hast Thou Forsaken Me?

• Fractal and Crypto Performance

• Population Estimation Through Murder Statistics

• Intermediate Floating-Point Precision

• C++ 11 std::async for Fast Float Format Finding

• Float Precision–From Zero to 100+ Digits

• Comparing Floating Point Numbers, 2012 Edition

• 64-Bit Made Easy

• Don’t Store That in a Float

• They sure look equal…

• Stupid Float Tricks

• SSOPA

• Tricks With the Floating-Point Format

• Top Ten Technologies of 2011

• Fractal eXtreme New Version–Better Zoom Movies

• Increased Reliability Through More Crashes

• Really Deep Fractal Zoom Movie – Much Faster

• Faster Fractals Again

• A Tale of Two Call Stacks

• Source Indexing is Underused Awesomeness

• Alt+Tab Depth Inversion Bug

• Try /analyze for Free

• Dangerous Documentation Part 2–Printing Strings

• Dangerous Documentation Part 1–Copying Strings

• /analyze–Command Line Options

• Then and Now–Performance Improvements

• /analyze for Visual Studio-the Ugly (part 5)

• Faster Fractals Through Better Scheduling

• Xperf for Excess CPU Consumption

• Zune EULA Window Size Fail

• PowerPoint Poor Performance Problem

• Xperf Analysis Basics

• Xperf Resources

• /analyze for Visual Studio—the Ugly (part 4), False Negatives

• Xperf Basics: Recording a Trace

• Visual C++ Code-gen Deficiencies

• Faster Fractals Through Algebra

• /analyze for Visual Studio—the Ugly (part 3), False Positives

• Making VirtualAlloc Arbitrarily Slower

• rdtsc in the Age of Sandybridge

• /analyze for Visual Studio–the Ugly (part 2), False Negatives

• More Confusion with Percentages

• /analyze for Visual Studio–the Ugly (part 1)

• Visual C++ Debug Builds–”Fast Checks” Cause 5x Slowdowns

• Adventures with /analyze for Visual Studio–the Good

• Visual Studio Hangs “Occasionally”

• Percentages are Confusing

• Xperf and Visual Studio: The Case of the Breakpoint Hangs

• Remote Desktop Multimon – Just Kidding!

• “Performance Analyzer doesn’t process traces while elevated”

• Sandybridge and Scaling (of Performance)

• Source Control – Unable to Access Database

• x64 Instructions for Four Times Faster Math

• Poorly Designed LED Lamps Waste Power

• Photo Tagging Update

• MythBusters Math Mix-up

• Photo Tagging with Windows Live Photo Gallery

• Bit-field Packing with Visual C++

• A shout out to my Xbox 360

• Hello world

• Perfect Pikmin Video, Day 9