Garbage collection and the case for high-level low-level programming

Abstract

Modern high-level programming languages have helped to raise the level of abstraction at which software is written, increasing reliability and security, while also reducing development costs. Despite the benefits afforded by high-level languages, low-level applications—such as real-time applications and systems programs—have bucked the general trend and continue to be overwhelmingly written in low-level languages such as C. Software complexity is continuing to escalate, reliability and security are now first-order concerns, and hardware is increasingly turning to more radical designs to deliver performance increases. In this environment, the use of low-level languages as the rule for low-level programming is becoming increasingly questionable. These trends raise the question: what is holding back the use of high-level languages for low-level applications? Two key technical barriers are: 1) the limited expressiveness of high-level languages, which often intentionally abstract over detail required to implement needed low-level functionality; and 2) the unique performance requirements of low-level applications, which often demand a combination of throughput, responsiveness, and predictability. My thesis is that high-level languages can and should be used for low-level applications, improving security and reliability, reducing development cost, and combating increasing hardware complexity. I have addressed this challenge of high-level low-level programming through: 1) the development of high-performance garbage collection mechanisms and algorithms, in particular those that deliver on the performance requirements of low-level applications; and 2) the use and refinement of a suitably expressive high-level lowlevel programming approach in the development of garbage collection techniques. This thesis describes techniques to improve garbage collection performance and introduces two novel garbage collection approaches—Cycle Tracing and Generational Metronome—that provide the combination of throughput and responsiveness demanded by low-level applications. This thesis presents a framework for high-level low-level programming that provides tools to construct new abstractions around relevant low-level features. This thesis also draws on experience gained through engineering garbage collectors, and shows how visualization can be an invaluable tool in understanding, debugging, and evaluating complex software systems. These contributions are reinforced through case studies, showing that high-level low-level applications can meet strict performance requirements while maintaining the benefits in design afforded by high-level languages. This work demonstrates that highlevel low-level programming is both possible and beneficial, leaving the most significant roadblock to adoption a cultural one, not a technical one.