Here, "phase one" refers to the 2009Q1 release; "phase two" refers to all work after that release. This list is by no means complete.

Phase One Papers:

• The behaviour of efficient virtual machine interpreters on modern architectures (Ertl & Gregg, 2001) Argues for using some variation of direct threading for opcode dispatch, rather than a switch statement.
• Virtual Machine Showdown: Stack Versus Registers (Shi, Gregg, Beatty & Ertl, 2005) Experiment in converting the JVM from a stack-based design to a register architecture. They observed a 32% speed-up in their benchmarks due to this change.
• The Structure and Performance of Interpreters (Romer et al, 1996) Comparison of a variety of high- and low-level interpreters. May be somewhat out of date.
• Context Threading: A Flexible and Efficient Dispatch Technique for Virtual Machine Interpreters (Berndl et al, 2005) An enhancement to the direct threading approach advocated by Ertl.
• The Implementation of Lua 5.0 (Ierusalimschy, Henrique de Figueiredo & Celes, 2005) Interesting notes on moving from a stack-based VM to a register-based VM, including benchmarks comparing just the stack vs register aspect.
• The Effect of Unrolling and Inlining for Python Bytecode Optimizations (Ben Asher & Rotem, 2009) Applies a lot of traditional optimizations to Python bytecode, with some good results. Complementary to the approach we're taking. Their source code is available from our Downloads page.

Phase Two Papers:

• http://lambda-the-ultimate.org/node/3159: Verifying Compiler Transformations for Concurrent Programs: When we start really optimizing Python programs, we'll want to verify that our optimizations preserve our memory model.
• The Design and Implementation of the SELF Compiler, an Optimizing Compiler for Object-Oriented Programming Languages (Chambers, 1992)
• Making the Compilation “Pipeline” Explicit: Dynamic Compilation Using Trace Tree Serialization (Gal et al, 2007)
• Efficient Just-In-Time Execution of Dynamically Typed Languages Via Code Specialization Using Precise Runtime Type Inference (Chang et al, 2007)
• One Method at a Time is Quite a Waste of Time (Gal, Bebenita & Franz, 2007)
• Iterative type analysis and extended message splitting: Optimizing dynamically-typed object-oriented programs (Chambers & Ungar, 1990)
• Efficient implementation of the smalltalk-80 system (Deutsch & Schiffman, 1984)
• Adaptive optimization for Self: Reconciling High Performance with Exploratory Programming (Hölzle, 1994)
• Optimizing Dynamically-Typed Object-Oriented Languages With Polymorphic Inline Caches (Hölzle, Chambers & Ungar, 1991) Long-form paper that originally introduced the type feedback system in Hölzle, 1994.
• Debugging Optimized Code with Dynamic Deoptimization (Hölzle, Chambers & Ungar, 1992) Long-form paper of the section of Hölzle, 1994 that deals with dynamically deoptimizing SELF code for debugging purposes.
• Type Feedback vs. Concrete Type Inference - A Comparison of Optimization Techniques for Object-Oriented Languages (Agesen & Hölzle, 1995) A comparison of type inference and type feedback, and analyzing how they can be mutually beneficial.
• Measurement and Application of Dynamic Receiver Class Distributions (Garrett et al, 1994) "We apply dynamic profile information to determine the dynamic execution frequency distributions of the classes of receivers at call sites. We show that these distributions are heavily skewed towards the most commonly occurring receiver class across several different languages. Moreover, we show that the distributions are stable across program inputs, from one version of a program to another, and even to some extent across programs that share library code."
• Towards Better Inlining Decisions Using Inlining Trials (Dean & Chambers, 1994) Improving compile time by keeping a database of which inlining operations actually produced a benefit.
• Strongtalk: Typechecking Smalltalk for a Production Environment (Bracha & Griswold, 1993)
• Optimization of Object-Oriented Programs Using Static Class Hierarchy Analysis (Dean, Grove & Chambers, 1994)
• The Cartesian Product Algorithm: Simple and Precise Type Inference Of Parametric Polymorphism (Agesen, 1995)
• Localized Type Inference of Atomic Types in Python (Cannon, 2005) A cautionary tale of an attempt at type inference in Python. Things to think about once/if we start looking at type inference for Python.

Garbage Collection:

• Java without the coffee breaks: A nonintrusive multiprocessor garbage collector (Bacon et al, 2001) Presents Recycler, a reference counting GC system we might reuse for Python.
• MMTk: The Memory Management Toolkit (Blackburn et al, 2006) The garbage collector used by JikesRVM.
• MC2: high-performance garbage collection for memory-constrained environments (Sachindran et al, 2004) Describes "Memory-Constrained Copying" technique.
• The Compressor: concurrent, incremental, and parallel compaction (Kermany & Petrank, 2006) Another algorithm implemented on JikesRVM, claims to be "the most efficient compactor known today".
• An on-the-fly mark and sweep garbage collector based on sliding views (Azatchi et al, 2003) A collector designed to minimize pause times. This one is worth reading if you are interested in the details of the sliding window technique, mutator synchronization, and write barriers.
• A generational mostly-concurrent garbage collector (Printezis & Detlefs, 2000) Worth reading for its description of card marking algorithms.

Regular Expressions:

• Overview of Chrome's new regex engine
• Pointer to Squirrelfish Extreme's regex JIT
• Article advocating the use of Thompson NFAs for regex implementations
• Insecure Context Switching: Inoculating Regular Expressions for Survivability (Drewry & Ormandy, 2008)

Related Work, Related Results:

• Results from the TraceMonkey JIT. Includes comparison with the previous non-JIT version.
• Results from the SquirrelFish JIT. Includes comparison with the previous non-JIT version.
• Recent work to improve V8 performance. Only JIT/JIT comparisons, no non-JIT/JIT comparison.