PL Papers You Might Love

Archive

Benchmarking with Stabilizer: Begone eyeball statistics!

Hello! 🦆 I’ve been busy working on an international move, so this issue has been quite delayed even though I started working on at the start of May. So apologies if you were expecting it to come out sooner; if it’s any consolation, I made the same mistake.

This issue covers Stabilizer: Statistically Sound Performance Evaluation (PDF) (ASPLOS 2013) by Charlie Curtsinger and Emery Berger. You can also check out the code for the paper, although, that has bit-rotted by this point. The code targets LLVM 3, whereas the latest LLVM release is LLVM 14. For context, the paper came out in 2013, so the bit-rot is not surprising. The pace of LLVM development is relentless, and industrial users of LLVM have enough engineering power to keep up with breaking changes. Academics on the other hand, perhaps not so much.

Getting back to the main topic, the paper covers a few things:

  • It discusses why accounting for the positions in memory of code and objects is important for robust benchmarking.
  • It describes Stabilizer, which is a compiler pass plus a runtime library developed by the authors that randomizes the positions of code and objects in memory.
  • It describes how powerful statistical tests can be used to analyze the results after benchmarking code with Stabilizer.
  • It delivers a spicy result: the performance benefits of LLVM 3’s -O3 optimizations over -O2 on the SPEC CPU2006 benchmarks are indistinguishable from random noise.
#3
June 5, 2022
Read more

Fearless concurrency at a discount?

Hello! 👋🏽 Welcome to the first proper issue of PL Papers You Might Love. Today, I’ll be taking a look at A Flexible Type System for Fearless Concurrency (PLDI 2022) by Mae Milano, Joshua Turcotti, and Andrew C. Myers (paper PDF).

Background

Over the past decade or so, Rust has popularized the notion of “fearless concurrency.” The Rust compiler prevents data races1 at compile-time by maintaining an ownership-and-borrowing system that is integrated with its type system. In doing so, Rust has carved out a niche of its own amongst mainstream languages:2

  1. Data races are possible, anything can happen in the presence of a data race: Go, C++.
  2. Data races are possible, try to have “reasonable” behavior in the presence of data races: Java, Multicore OCaml.
  3. Data races are prevented at compile-time: safe Rust, and more recently Swift (with full safety-checking).
#2
May 1, 2022
Read more

Introducing "PL Papers You Might Love"

Hello! 👋🏽

I’m starting a newsletter “PL Papers You Might Love.” It’s an attempt to share my thoughts on PL and PL-adjacent research papers that I find interesting/valuable/exciting/<insert positive adjective> in some way.

This is my first time writing a newsletter; I don’t have everything figured out yet. I’ve tried to frame my current thinking in a Q&A format below. If you’d like to provide feedback on any of these points (or something not covered here), feel free to send me an email or DM me on Twitter.

Q: What is the cadence going to be?

#1
April 10, 2022
Read more
Brought to you by Buttondown, the easiest way to start and grow your newsletter.