In the context of the dynamically typed concurrent functional programming language ERLANG, we describe a simple static analysis for identifying variables containing floating point numbers, how this information is used by the BEAM compiler, and a scheme for efficient (just-in-time) compilation of floating point bytecode instructions to native code. The attractiveness of the scheme lies in its implementation simplicity. It has been fully incorporated in Erlang/OTP R9, and improves the performance of ERLANG programs manipulating floats considerably.

We describe problems that have arisen when combining the proposed design for generics for the Microsoft .NET Common Language Runtime (CLR) with two resource-related features supported by the Microsoft CLR implementation: application domains and pre-compilation. Application domains are "software based processes" and the interaction between application domains and generics stems from the fact that code and descriptors are generated on a pergeneric -instantiation basis, and thus instantiations consume resources which are preferably both shareable and recoverable. Pre-compilation runs at install-time to reduce startup overheads. This interacts with application domain unloading: compilation units may contain shareable generated instantiations. The paper describes these interactions and the di#erent approaches that can be used to avoid or ameliorate the problems.

Most programming languages are equipped with a type system that detects type errors in the program, such as using a variable or result of a given type in a context that expects data of a different, incompatible type. Such type checking can take place either statically (at compile-time) or dynamically (at run-time). Type checking has proved to be very effective in catching a wide class of programming errors, from the trivial (misspelled identifiers) to the fairly deep (violations of data structure invariants). It makes program considerably safer, ensuring integrity of data structures and type-correct interconnection of program components. Safety is not the only motivation for equipping programming languages with type systems, however. Another motivation, which came first historically, is to facilitate the efficient compilation of programs. Static typing restricts the set of programs to be compiled, possibly eliminating programs containing constructs that are difficult to compile efficiently or even to compile correctly at all. Also, static typing guarantees certain properties and invariants on the data manipulated by the program; the compiler can take advantage of these semantic guarantees to generate better code. The “Types in Compilation ” workshops are dedicated to the study of these interactions between type systems and the compilation process. 2 Exploiting type information for code generation and optimization An early example of a type system directed towards efficient compilation is that of Fortran. The Fortran type system introduces a strict separation between integers numbers and floating-point numbers at compile-time. The main motivation for this separation, according to Fortran’s designers, was to avoid the difficulties of handling mixed arithmetic at run-time [2, chapter 6]. Thanks to the type system, the compiler “knows ” when to generate integer arithmetic operations, floating-point arithmetic operations, and conversions between integers and floats.

FISh is an array-based programming language that combines imperative and functional programming styles. Static shape analysis uses partial evaluation to convert arbitrary programs into simple, efficient imperative programs.

This chapter reviews the many sources that I have relied upon in designing MIN,

This document describes the areas of research I am interested in, and highlights the aims and scope of work that I intend to pursue. This proposal supercedes the interim statement I wrote in February --- it includes more detail in the discussion of virtual types for genericity, and further detail on lightweight classes. Comments and suggestions are welcome, as are pointers to important literature I have overlooked.

Local CPS conversion is a compiler transformation for improving the code generated for nested loops by a direct-style compiler. The transformation consists of a combination of CPS conversion and light-weight closure conversion, which allows the compiler to merge the environments of nested recursive functions. This merging, in turn, allows the backend to use a single machine-level procedure to implement the nested loops. Preliminary experiments with the Moby compiler show the potential for significant reductions in loop overhead as a result of Local CPS conversion. An earlier version of this paper was presented at the Third ACM SIGPLAN Workshop on Continuations [Sab01]. 1

Quality of service (QoS) architectures have been required in recent years to support a wide range of distributed applications, particularly in wide-area systems. In the context of QoS information management associated with QoS activities, QoS information modeling and mapping enable QoS architectures to be developed independently of the underlying environment and/or application. This paper provides a review of existing QoS architectures on these aspects and presents our current framework.

ABSTRACT The goal of the TIL project was to explore the use of Typed Intermediate Languages to produce high-performance native code from Standard ML (SML). We believed that existing SML compilers were doing a good job of conventional functional language optimizations, as one might find in a LISP compiler, but that inadequate use was made of the rich type information present in the source language. Our goal was to show that we could get much greater performance by propagating type information through to the back end of the compiler, without sacrificing the advantages afforded by loop-oriented and other optimizations. We also confirmed that using typed intermediate languages dramatically improved the reliability and maintainability of the compiler itself. In particular, we were able to use the type system to express critical invariants, and enforce those invariants through type checking. In this respect, TIL introduced and popularized the notion of a certifying compiler, which attaches a checkable certificate of safety to its generated code. In turn, this led directly to the idea of certified object code, inspiring the development of Proof-Carrying Code and Typed Assembly Language as certified object code formats.

Abstract. Compilers for polymorphic languages are required to treat values in programs in an abstract and generic way at the source level. The challenges of optimizing the boxing of raw values, flattening of argument tuples, and raising the arity of functions that handle complex structures to reduce memory usage are old ones, but take on newfound import with processors that have twice as many registers. We present a novel strategy that uses both control-flow and type information to provide an arity raising implementation addressing these problems. This strategy is conservative — no matter the execution path, the transformed program will not perform extra operations. 1