Allan Heydon

Caching function calls using precise dependencies

This paper describes the implementation of a purely functionalprogramming language for building software systems. In this language,external tools like compilers and linkers are invoked by function calls. Because some function calls are extremely expensive, it is obviously important to reuse the results of previous function calls whenever possible. Caching a function call requires the language interpreter to record all values on which the function call depends. For optimal caching, it is important to record precise dependencies that are both dynamic and fine-grained. The paper sketches how we compute such dependencies, describes the implementation of an efficient function cache, and evaluates our implementations performance.

System Description Language

There are two inputs to the construction of a software system: the sources and the instructions for producing the system from those sources. For small code bases, simple instructions generally suffice. However, for even moderately large systems, the build instructions become complex and subtle, and the simple, script-like facilities of conventional build “languages” such as Make therefore become inadequate. For this reason, Vesta’s system description language (SDL) supports complete, hierarchical build instructions, which enable all the details of a build to be specified in a modular form consistent with the overall system structure. Moreover, SDL supports functional abstraction, which makes it possible to encapsulate low-level building. As a result, complex details can be hidden from the view of end users, simplifying the system descriptions they write.

Building Systems in Vesta

The preceding chapter provided the motivation behind Vesta’s system description language and presented its primary constructs. This chapter focuses on the use of SDL to express complex build instructions. Of course, there are many ways to do this and, as noted in the preceding chapter, SDL strives to be “methodology-neutral”. This chapter presents a particular set of choices — a methodology, or a style — that has worked well in practice. Before getting into the details, however, we need to examine some of the considerations that motivated the specific choices this methodology embodies.

Managing Sources and Versions

The Vesta repository provides long-term storage of source and derived files. The repository has two kinds of clients — users and the evaluator — who require distinct sets of services. Users are mainly concerned with sources. They read existing source files and create new ones. The evaluator is concerned with both sources and deriveds. It reads system models, and it invokes tools that both read sources and deriveds and write out new deriveds. This chapter examines the repository services as they appear to software developers who use Vesta. The evaluator-specific facilities are covered later in Section 7.1.

Inside the Repository

Chapter 4 described the functionality of the Vesta repository as seen by a developer. This chapter examines additional features of the repository, including those used by other components of the Vesta system, and the way in which notable aspects of the repository functionality are implemented.

The Architecture of Vesta

Chapter 1 briefly introduced the central SCM problems of building and versioning. This chapter and those in Part II describe how Vesta is designed to solve these problems and show how the Vesta system creates a development environment in which software builds are repeatable, consistent, incremental, and scalable.