Active networks explore the idea of allowing routing elements to be extensively programmed by the packets passing through them. This allows computation previously possible only at endpoints to be carried out within the network itself, thus enabling optimizations and extensions of current protocols as well as the development of fundamentally new protocols. I will describe some of these opportunities and some of the impediments to making practical and scalable active networks. I will then relate some of these issues to the Penn SwitchWare (www.cis.upenn.edu/~switchware) project, which I will overview.
PLAN is a new language for programs that are carried in the packets of a programmable network. PLAN programs replace the packet headers (which can be viewed as `dumb' programs) used in current networks; these programs are executed on routers as the packet progresses through the network. This talk describes how our approach to this sort of active networking balances the competing concerns of flexibility, performance, security, and usability.
PLAN is a strict functional language providing a limited set of primitives and datatypes. The limited expressibility is mitigated by allowing PLAN code to call ``service routines'' written in other, more powerful languages. PLAN defines primitives for remotely executing PLAN programs on other nodes, and these primitives are used to provide basic data transport in the network. Because remote execution makes debugging difficult, PLAN provides strong static guarantees to the programmer, such as type safety. A more novel property aimed at protecting network availability is a guarantee that PLAN programs use a bounded amount of space and time on active routers and bandwidth in the network.
The language Esterel is an imperative language for programming reactive systems. It has a notion of time, signals for communicating changes in/to the outside world, and preemption for modularity of code. Nevertheless, it has no notion of functions or complex data types: these must be typically programmed in a host language. Also, the primary form of abstraction, called a "module", is quite limited.
In this talk I will describe work-in-progress to meld Esterel with call-by-value functional programming. All expressions in the language, including higher-order functions, take on a notion of "time". The language is powerful enough to encode the preemption constructs of Esterel, as well as other features. I will briefly discuss some outstanding issues, such as causality checking and whether signals are the right communication mechanism.
This is joint work with Lalita Jategaonkar Jagadeesan and Radha Jagadeesan.
In this talk, I will present our experience with Teapot, a domain-specific language (DSL) for writing coherence protocols. I will first introduce coherence protocols, and describe why they are hard to implement. I will then present the key features of Teapot that assist in this task. Teapot has been used in writing a variety of coherence protocols. I will discuss the strengths and shortcomings of Teapot in the context of two very different distributed systems: the LCM distributed shared memory system at Wisconsin, and xFS distributed file system at Berkeley. I will conclude with the lessons that we learned from building a DSL for use in systems software.
This is joint work with Jim Larus (Wisconsin), Brad Richards (Vassar), Mike Dahlin (UT-Austin), Randy Wang (Berkeley), and Tom Anderson (Washington), and recently appeared in the USENIX Conference on Domain-Specific Languages.
While most object-oriented programming is done in class-based languages, the trend in theoretical study has been to develop formal systems that are object-based, without classes and often without explicit inheritance mechanisms. This talk studies the correspondence between class constructs of the form found in C++, Eiffel, and Java and object primitives of the form used in recent type-theoretic studies. One insight is that classes require both an extensible aggregate, to serve as the basis for inheritance, and a non-extensible form of object to support subtyping; typed object calculi without extensible objects or extensible records do not seem adequate for conventional class-based programming. We develop our analysis by comparing two approaches to class-based programming, the first using records of object components called ``premethods'' and the second using an extensible form of object called a ``prototype.'' While the first approach is simplest, using fewer primitive operations on objects, it does not seem to accurately provide several features of conventional class-based languages. In the second approach, we give a more comprehensive treatment of classes by combining prototypes with standard abstraction mechanisms. Both treatments of classes are based on typed translations into provably sound object calculi.
Joint work with John Mitchell.
Writing native code generators for modern processors with increasing hardware support for instruction level parallelism is a significant investment. Unfortunately it is difficult to reuse this investment for other architectures, and even more difficult to reuse for other source language compilers. The MLRISC framework has been successfully retargeted to multiple architectures, and deals elegantly with the special requirements imposed by the execution model of different source languages. Nearly all aspects of back end code generation and advanced superscalar optimizations come for free.