Specialization has been recognized as a powerful technique for optimizing operating systems. However, specialization has not been broadly applied beyond the research community because current techniques, based on manual specialization, are time-consuming and error-prone. The goal of the work described in this paper is to help operating system tuners perform specialization more easily. We have built a specialization toolkit that assists the major tasks of specializing operating systems. We demonstrate the effectiveness of the toolkit by applying it to three diverse operating system components. We show that using tools to assist specialization enables significant performance optimizations without errorprone manual modifications. Our experience with the toolkit suggests new ways of designing systems that combine high performance and clean structure. 1

Compile-time meta-programming allows programs to be constructed by the user at compile-time. Although LISP derived languages have long had such facilities, few modern languages are capable of compile-time meta-programming, and of those that do many of the most powerful are statically typed functional languages. In this paper I present the dynamically typed object orientated language Converge which allows compile-time meta-programming in the spirit of Template Haskell. Converge demonstrates that integrating powerful, safe compile-time meta-programming features into a dynamic language requires few restrictions to the flexible development style facilitated by the paradigm. In this paper I detail Converge’s compile-time meta-programming facilities, much of which is adapted from Template Haskell, contain several features new to the paradigm. Finally I explain how such a facility might be integrated into similar languages. 1.

We introduce a new kind of Binding Time Analysis (BTA) based on search rather than constraint solving or abstract interpretation. The search is guided by type information which significantly prunes the size of the search space, making the algorithm practical. We also point out, that higher order multi-stage types are a rich and expressive medium for the expression of binding-time specifications. A goal of our work is to demonstrate that a single unified system which seamlessly integrates both manual staging and automatic BTA based staging can be built.

Abstract. Powerful, safe macro systems allow programs to be programatically constructed by the user at compile-time. Such systems have traditionally been largely confined to LISP-like languages and their successors. In this paper we describe and compare two modern, dynamically typed languages Converge and Metalua, which both have macro-like systems. We show how, in different ways, they build upon traditional macro systems to explore new ways of constructing programs. 1

Compile-time meta-programming allows programs to be constructed by the user at compile-time. Few modern languages are capable of compile-time meta-programming, and of those that do, many of the most powerful are statically typed functional languages. In this paper I present the dynamically typed, object orientated language Converge which allows compile-time meta-programming in the spirit of Template Haskell. Converge demonstrates that integrating powerful, safe compiletime meta-programming features into a dynamic language requires few restrictions to the flexible development style facilitated by the paradigm.

Machine Operations ***** datatype Value = code of <Value M> | Z of int | Void; push : int -> Value M branch : Label -> Label -> Value M pop : Value M read,store : Addr -> Value M ADD,LEQ,NEG : Value M pushReg,loadReg : Value M jump : Label -> Value M newSeg,endlabel : Label->Value M->Value M #### ## Source, Static & Abstract Machine Operations for the Reference Compiler Figure 1 presents the source language for our compiler. Wehave deliberately kept this language quite simple, because we wish to keep our metacomputationbased compiler as simple as possible. ### is a simple imperative language with while loops. A program is represented as ######## ###############, where ####### are the globally-dened integer program variables with command #### of type ###. #### is either an assignment #############,aloop##############, or a sequence of such statements ############.Variables are dened only in the declarations in the top-level ####### phrase. ### has integer expressions ####### #...

Abstract. Recent research has shown how the formal modeling of concurrent systems can benefit from monadic structuring. With this approach, a formal system model is really a program in a domain specific language defined by a monad for shared-state concurrency. Can these models be compiled into efficient implementations? This paper addresses this question and presents an overview of techniques for compiling monadic concurrency models directly into reasonably efficient software and hardware implementations. The implementation techniques described in this article form the basis of a semantics-directed approach to model-driven engineering. 1

syntax as an MetaMLdatatype declare x = 10 in -- x := x - 1; print x Sample program in concrete Syntax val S1 = Declare("x",Constant 10, Seq(Assign("x",Minus(Variable "x", Constant 1)), Print(Variable "y"))); Datatype encoding of sample program. !Do %mswo -- %push 10 ; a !- %read 1 ; b !- Return %mswo a %- 1 ; c !- %write 1 b ; d !- %read 1 ; e !- %output d ; Return %mswo () ; %pop ? Residual result of staging example program. (* interpret2 : Com -? index -? !unit M? *) fun interpret2 stmt index = case stmt of Assign(name,e) =? let val loc = position name index in !Do mswo -- n !- ~(eval2 e index) ; write ~(lift loc) n ? end --- Seq(s1,s2) =? !Do mswo -- x !- ~(interpret2 s1 index) ; y !- ~(interpret2 s2 index) ; Return mswo () ? --- Cond(e,s1,s2) =? !Do mswo -- x !- ~(eval2 e index) ; if x=1 then ~(interpret2 s1 index) else ~(interpret2 s2 index)? --- While(e,b) =? !let fun loop () = Do mswo -- v !- ~(eval2 e index) ; if v=0 then Return mswo...

cted from embedded implementations in a semi automated way, further blending the distinction between the two approaches. This bodes well for lessening the cost of deploying a DSL since its suggests several strategies for evolving an embedded implementation to a stand-alone one in a cost e#ective way. The proposed research would investigate applying meta-programming tools to DSL evolution, in several di#erent dimensions: . Extending the capabilities of host languages for embedded implementations. . Exploring automated techniques for converting embedded implementations to stand-alone implementations. . Automating the generation of stand-alone implementations. Broader Impact: The opportunity costs of being unable to utilize computers e#ectively has a large cost: projects that are never attempted, or whose scope is significantly reduced, because the cost of developing software is too high to contemplate, or too complex to write. DSLs can play a large role in mitigating these costs,

This paper was particularly useful as it explained in practical terms how to build such a type checker -- in particular how to set up the subsumption relation that describes which types are more polymorphic than others