C. Van Reeuwijk

Spar: a set of extensions to Java for scientific computation

We present a set of language extensions that improve the expressiveness and performance of Java for scientific computation. The language extensions allow the manipulation of multi‐dimensional arrays to be expressed more naturally, and to be implemented more efficiently. Furthermore, data‐parallel programming is supported, allowing efficient parallelization of a large class of operations on arrays. We also provide language extensions to construct specialized array representations, such as symmetric, block, and sparse matrices. These extensions are: tuples, parameterized types, array subscript overloading, and the inline modifier. These extensions are not only useful in the construction of special array representations, but are also useful in their own right. Finally, we add complex numbers as a primitive type to the language. We evaluate our language extensions using performance results. We also compare relevant code fragments of our extended language with standard Java implementations and language extensions proposed by others. Copyright

Rapid and robust compiler construction using template-based metacompilation

We have developed Tm, a template-based metacompiler. Given a set of data-structure definitions and a template, Tm generates files that instantiate the template for the given data structures. With this process, Tm is able to generate program code to manipulate these data structures. Since it uses templates, the generated code is not restricted to a specific programming language: any sufficiently powerful programming language can be targeted. Tm has been used for a wide variety of tasks and languages. However, it was designed to support compiler construction, and most applications have been in that area. In this paper we outline Tm, and describe our experiences with using it to construct a static compiler for Java. As we will show, it has significantly accelerated implementation of the compiler. Almost 75% of its source code is generated by Tm, allowing us to rapidly implement a much more robust and sophisticated compiler than would have been possible otherwise.

Tm: a code generator for recursive data structures

The transfer of data structures between programs is often carried out using binary or ad‐hoc textual formats. However, this can result in ambiguous and non‐portable file formats. The program ‘Tm’ (for ‘template manager’) prevents these problems by using a textual representation of the data structures and generating the code to read and write this representation from an abstract definition of the data structures. The same program is used to generate code for the simple data‐structure manipulations that are necessary in almost every program. At the moment, code can be generated for the programming languages C, Pascal, Lisp and Miranda. Support for other languages is easily added.

Ampdes: a program for the synthesis of high-performance amplifiers

A circuit synthesis program for high-performance small-signal amplifiers, called Ampdes is described. The synthesis can be done with minimal interaction from the user: only the essential information must be given, and the program will produce a Spice net list and a TEX design report. For a typical design, this takes 30 minutes on a mini-computer. Unlike other synthesis programs, it searches in an extremely large set of possible circuits (over 1,000,000 configurations), and is not restricted to one device technology. To ensure a high rate of success in the designs, it uses mathematically sound search rules instead of heuristic ones, and accurate approximations of the circuit behavior. These features require considerable computational effort, and therefore it is necessary to use a refined search strategy to reduce the time for a design run. This strategy is also described.<<ETX>>

Glass, a language for analog and digital circuit description, and its environment

Abstract The implementation of the principle of systems semantics on a computer done in Esprit project 881, “Forfun” is described. This includes defining a computer understandable system description language, executable semantic functions, some computer assistance for transformational design, and a multi-user environment.

Adding tuples to Java: a study in lightweight data structures

Java classes are very flexible, but this comes at a price. The main cost is that every class instance must be dynamically allocated. Their access by reference introduces pointer dereferences and complicates program analysis. These costs are particularly burdensome for small, ubiquitous data structures such as coordinates and state vectors. For such data structures a lightweight representation is desirable, allowing such data to be handled directly, similar to primitive types. A number of proposals introduce restricted or mutated variants of standard Java classes that could serve as lightweight representation, but the impact of these proposals has never been studied.Since we have implemented a Java compiler with lightweight data structures we are in a good position to do this evaluation. Our lightweight data structures are tuples. As we will show, their use can result in significant performance gains: for a number of existing benchmark programs using tuples we gain more than 50% in performance relative to our own compiler, and more than 20% relative to Suns Hotspot 1.4 compiler. We expect similar performance gains for other implementations of lightweight data structures.With respect to the expressiveness of Java, lightweight variants of standard Java classes have little impact. In contrast, tuples add a different language construct that, as we will show, can lead to substantially more concise program code.

Spar: a set of extensions Java for scientific computation

In this paper we present a set of language extensions that improve the expressiveness and performance of Java for scientific computation. First of all, the language extensions allow the manipulation of multi-dimensional arrays to be expressed more naturally, and to be implemented more efficiently. Furthermore, data-parallel programming is supported, allowing efficient parallelization of a large class of operations on arrays. We also provide language extensions to construct specialized array representations, such as symmetric, block, and sparse matrices. These extensions are: tuples, parameterized types, array subscript overloading, and the inline modifier. These extensions are not only useful to construct special array representations, but are also useful in their own right. Finally, we add complex numbers as a primitive type to the language. We evaluate our language extensions using performance results. We also compare relevant code fragments of our extended language with standard Java implementations and language extensions proposed by others.