SUMMARY: Complex computational experiments in Systems Biology, such as fitting model parameters to experimental data, can be challenging to perform. Not only do they frequently require a high level of computational power, but the software needed to run the experiment needs to be usable by scientists with varying levels of computational expertise, and modellers need to be able to obtain up-to-date experimental data resources easily. We have developed a software suite, the Systems Biology Software Infrastructure (SBSI), to facilitate the parameter-fitting process. SBSI is a modular software suite composed of three major components: SBSINumerics, a high-performance library containing parallelized algorithms for performing parameter fitting; SBSIDispatcher, a middleware application to track experiments and submit jobs to back-end servers; and SBSIVisual, an extensible client application used to configure optimization experiments and view results. Furthermore, we have created a plugin infrastructure to enable project-specific modules to be easily installed. Plugin developers can take advantage of the existing user-interface and application framework to customize SBSI for their own uses, facilitated by SBSI's use of standard data formats. AVAILABILITY AND IMPLEMENTATION: All SBSI binaries and source-code are freely available from http://sourceforge.net/projects/sbsi under an Apache 2 open-source license. The server-side SBSINumerics runs on any Unix-based operating system; both SBSIVisual and SBSIDispatcher are written in Java and are platform independent, allowing use on Windows, Linux and Mac OS X. The SBSI project website at http://www.sbsi.ed.ac.uk provides documentation and tutorials.

In this paper we report on progress in the use of stochastic process algebras for representing systems which contain many replications of components such as clients, servers and devices. Such systems have traditionally been difficult to analyse even when using high-level models because of the need to represent the vast range of their potential behaviour. Models of concurrent systems with many components very quickly exceed the storage capacity of computing devices even when efficient data structures are used to minimize the cost of representing each state. Here, we show how population-based models that make use of a continuous approximation of the discrete behaviour can be used to efficiently analyse the temporal behaviour of very large systems via their collective dynamics. This approach enables modellers to study problems that cannot be tackled with traditional discrete-state techniques such as continuous-time Markov chains.

Reasoning about the performance of models of software systems typically entails the derivation of metrics such as throughput, utilization, and response time. If the model is a Markov chain, these are expressed as real functions of the chain, called reward models. The computational complexity of reward-based metrics is of the same order as the solution of the Markov chain, making the analysis infeasible when evaluating large-scale systems. In the context of the stochastic process algebra PEPA, the underlying continuous-time Markov chain has been shown to admit a deterministic (fluid) approximation as a solution of an ordinary differential equation, which effectively circumvents state-space explosion. This paper is concerned with approximating Markovian reward models for PEPA with fluid rewards, i.e., functions of the solution of the differential equation problem. It shows that (1) the Markovian reward models for typical metrics of performance enjoy asymptotic convergence to their fluid analogues, and that (2) via numerical tests, the approximation yields satisfactory accuracy in practice.

The exact performance analysis of large-scale software systems with discrete-state approaches is difficult because of the well-known problem of state-space explosion. This paper considers this problem with regard to the stochastic process algebra PEPA, presenting a deterministic approximation to the underlying Markov chain model based on ordinary differential equations. The accuracy of the approximation is assessed by means of a substantial case study of a distributed multithreaded application.

We propose a model-based approach to analysing the performance of mobile applications where physical mobility and state changes are modelled by graph transformations from which a model in the Performance Evaluation Process Algebra (PEPA) is derived. To fight scalability problems with state space generation we adopt a modular solution where the graph transformation system is decomposed into views, for which labelled transition systems (LTS) are generated separately and later synchronised in PEPA. We demonstrate that the result of this modular analysis is equivalent to that of the monolithic approach and evaluate practicality and scalability by means of a case study.

Erol Gelenbe, Stephen Gilmore; Discussants’ Comments on the Computer Journal Lecture by Peter Harrison presented at the British Computer Society on 24th Fe

In this paper we show how high-level UML models of mobile computing applications can be analysed for classical performance measures such as throughput. The approach proceeds by compiling the UML model into a representation in the formally-defined modelling language of PEPA nets. The compilation process and subsequent performance analysis based on numerical solution of a continuous-time Markov chain is supported by a software tool, the Choreographer design platform. Choreographer interoperates with popular UML tools by reading and writing UML models in the XML Metadata Interchange format (XMI).

In grid applications the heterogeneity and potential failures of the computing infrastructure poses significant challenges to efficient scheduling. Performance models have been shown to be useful in providing predictions on which schedules can be based (N. Furmento et al., 2002) and most such techniques can also take account of failures and degraded service. However, when several alternative schedules are to be compared it is vital that the analysis of the models does not become so costly as to outweigh the potential gain of choosing the best schedule. Moreover, it is vital that the modelling approach can scale to match the size and complexity of realistic applications. In this paper, we present a novel method of modelling job execution on grid compute clusters. As previously we use performance evaluation process algebra (PEPA) (J. Hillston, 1996) as the system description formalism, capturing both workload and computing fabric. The novel feature is that we make a continuous approximation of the state space underlying the PEPA model and represent it as a set of ordinary differential equations (ODEs) for solution, rather than a continuous time, but discrete state space, Markov chain.

Any scheduling scheme for grid applications must make implicit or explicit assumptions about both the future behaviour of the application and the future availability and performance of grid resources. This paper describes an approach in which the future application behaviour is constrained by the use of algorithmic skeletons, facilitating modelling with a performance oriented process algebra, and future grid resource performance is predicted by the Network Weather Service (NWS) tool. The concept is illustrated through a case study involving Pipeline and Deal skeletons. A tool is presented which automatically generates and solves a set of models which are parameterised with information obtained from NWS. Some numerical results and timing information on the use of the tool are provided, illustrating the efficacy of this approach.

The Java programming language and its environment are highly regarded as suitable choices for the development and deployment of distributed applications. Portability, an object oriented approach, support for multi-threading programming and a special set of libraries for remote procedure calls, are some of the features that make Java an excellent choice for the implementation of distributed applications. A considerable number of projects on Java distributed systems have already been completed. Here we can list Charlotte, SuperWeb, Javelin, Javelin++, Java/DSM, Voyager and Babylon. Based on Java, the Babylon package [1] was designed to integrate into a single comprehensive system both new and previously researched ideas in Java distributed computing. It retains parts of the underlying mechanisms used in Ajents [2], a previous project from which Babylon took part of its source code. Babylon also has some innovative additions that are not currently supported by Java, such as remote object creation, remote class loading, asynchronous remote method invocation and object migration. From the point of view of application designers, Babylon can be deployed as a layer of middleware which facilitates the use of clusters of computational resources allowing selective migration of code-containing objects from one computational environment to another. From the point of view of programmers, Babylon can be seen as a collection of Java class libraries that provides the necessary software infrastructure to support straightforward access to information that is distributed, within organisations and all around the world. It is relevant to note that all of the Babylon class libraries are written in pure Java. Among other things, this means that Babylon can be executed on any standard Java Virtual Machine (JVM), and it is potentially open to a vast audience of programmers. Besides, the Babylon package contains some useful features that are not currently supported by Java. Consequently, it reduces the difficulty of writing distributed programs. Babylon is implemented using Java RMI. It has been shown, however, that Java RMI is very slow for high performance computing [4]. Most of the researchers in the field agree that it is inappropriate for interactive applications [3]. Given that the key features of Babylon are principally based on Java RMI, all the drawbacks and limitations of Java RMI are inherited by Babylon. The motivation behind this work is the submission of a contribution that eventually helps Babylon to become a better tool in the field of Java distributed object applications. To this end, we have developed graphical components to provide monitoring and management capabilities for a Babylon application. We have also made a number of technical extensions to the existing Babylon system, including upgrading it to the Java 2 security model, and we have adapted it to use a better implementation of RMI, because we believe that its dependency on Sun’s RMI represents a drawback. Due to space limitations, we cannot state in this document all the details of our work, but readers may wish to take a look at [5] for a comprehensive description of our investigation.

Performance Evaluation Process Algebra (PEPA) is a formal language for performance modeling based on process algebra. It has previously been shown that, by using the process algebra apparatus, compact performance models can be derived which retain the essential behavioral characteristics of the modeled system. However, no efficient algorithm for this derivation was given. We present an efficient algorithm which recognizes and takes advantage of symmetries within the model and avoids unnecessary computation. The algorithm is illustrated by a multiprocessor example.

S. Gilmore, J. Hillston; Process Algebras and Their Application to Performance Modelling: Proceedings of the Third Workshop on Process Algebra and Performance M