Abstract Scientists in many fields rely on computational simulations that are built from a collection of separate, inter‐communicating single models (e.g. Earth System Models often consist of single models of the ocean, atmosphere and land processes); these simulations are called coupled models. Coupled models allow scientists to simulate richer scientific phenomena than is possible by running single models alone. Scientific interest is typically focused on the investigation served by a coupled model, rather than the complex and inadequately supported software engineering activity of constructing it. In response to this lack of support, a coupling methodology called the Flexible Coupling Approach (FCA) has been developed at the University of Manchester together with a tool that implements this approach, the Bespoke Framework Generator (BFG). Whilst being adequate for a large class of coupled models (e.g., many Earth System Models), the BFG is unable to handle coupled models with complex behavioural requirements (in terms of the scheduling and inter‐communication of single models). To capture these more complex expressions of behaviour, this paper introduces NOAH, a domain‐specific language that is implemented in the formalism Communicating Sequential Processes (CSP), and which is used by a new implementation of the FCA, called the CSP‐based Framework Generator (CFG). NOAH is introduced through two example coupled models which have complex behavioural requirements. NOAH represents the first attempt to bring the advantages of using formal descriptions of coupled models to application scientists, providing a language in which to specify coupled model behaviour precisely and the ability to check that a coupled model is deadlock free using tools such as the Failures‐Divergence Refinement (FDR) model checker. Copyright © 2007 John Wiley & Sons, Ltd.

Abstract Coupled modelling is increasingly necessary to make progress in understanding the science of complex physical phenomena and a number of bespoke (‘custom’) coupled solutions to specific scientific challenges have emerged in recent years. These coupled models generally consist of some framework code in which individual models are embedded. The framework code promotes the required interoperation of the models to solve the larger problem being addressed. Bespoke solutions limit the ability of scientists to share models and to couple them together flexibly to produce (efficient) implementations to address new problems. This paper presents an approach, GCF, which addresses several of these limitations. Individual model sharing and flexibility in composition and deployment is achieved by imposing some lightweight development rules for single models and capturing information relating to the models themselves, to their composition into coupled models and to their deployment onto computational resources as machine‐readable metadata. These metadata can be processed to support the generation of an implementation of the coupled model required by the developer. For example, lean and efficient framework code for the specific coupled model and deployment described by the developer can be generated. Alternatively, GCF‐compliant models can be automatically adapted for use within other, existing frameworks. This paper presents the design and implementation of a bespoke framework generator to achieve the former, and the flexibility in the composition of GCF‐compliant models is demonstrated. Copyright © 2005 John Wiley & Sons, Ltd.

Abstract OOLALA is an object‐oriented linear algebra library designed to reduce the effort of software development and maintenance. In contrast with traditional (Fortran‐based) libraries, it provides two high abstraction levels that significantly reduce the number of implementations necessary for particular linear algebra operations. Initial performance evaluations of a Java implementation of OOLALA show that the two high abstraction levels are not competitive with the low abstraction level of traditional libraries. These initial performance results motivate the present contribution—the characterization of a set of storage formats (data structures) and matrix properties (special features) for which implementations at the two high abstraction levels can be transformed into implementations at the low (more efficient) abstraction level. Copyright © 2005 John Wiley & Sons, Ltd.

Abstract The Java language specification states that every access to an array needs to be within the bounds of that array, i.e. between 0 and array length − 1. Different techniques for different programming languages have been proposed to eliminate explicit bounds checks. Some of these techniques are implemented in off‐the‐shelf Java Virtual Machines (JVMs). The underlying principle of these techniques is that bounds checks can be removed when a JVM/compiler has enough information to guarantee that a sequence of accesses (e.g. inside a for‐loop) is safe (within the bounds). Most of the techniques for the elimination of array bounds checks have been developed for programming languages that do not support multi‐threading and/or enable dynamic class loading. These two characteristics make most of these techniques unsuitable for Java. Techniques developed specifically for Java have not addressed the elimination of array bounds checks in the presence of indirection; that is, when the index is stored in another array (indirection array). With the objective of optimizing applications with array indirection, this paper proposes and evaluates three implementation strategies, each implemented as a Java class. The classes provide the functionality of Java arrays of type int so that objects of the classes can be used instead of indirection arrays. Each strategy enables JVMs, when examining only one of these classes at a time, to obtain enough information to remove array bounds checks. Copyright © 2005 John Wiley & Sons, Ltd.

In this paper we review the design of a sequential object oriented linear algebra library, OOLALA. Several designs are proposed and used to classify existing sequential object oriented libraries. The classification is based on the way that matrices and matrix operations are represented. OOLALA's representation of matrices is capable of dealing with certain matrix operations that, although mathematically valid, are not handled correctly by existing libraries. OOLALA also enables implementations of matrix calculations at various abstraction levels ranging from the relatively low-level abstraction of a Fortran BLAS-like implementation to higher-level abstractions that hide many implementation details. OOLALA addresses a wide range of numerical linear algebra functionality while the reviewed object oriented libraries concen trate on parts of such functionality. We include some preliminary performance results for a Java implementation of OOLALA.