Abstract In scientific applications, physical quantities, and units of measurement are used regularly. If the inherent incompatibility between these units is not handled properly it can lead to potentially catastrophic problems. Although the risk of a miscalculation is high and the cost equally so, almost none of the major programming languages has support for physical quantities. We employed a systematic approach to examine and analyse available units of measurement (UoM) libraries. The search results were condensed into 38 libraries. These were the most comprehensive and well‐developed, open‐source libraries, chosen from approximately 3700 search results across seven repository hosting sites. Most libraries are implemented in a similar manner, but with varying features and evaluation strategies. Three developers and a scientist were interviewed and 91 practitioners of varying experiences from on‐line forums were surveyed to explain their impressions of UoM libraries and their suitability. Our findings show several reasons for nonadoption, including insufficient awareness of UoM libraries, cumbersome in practice, specific performance concerns, and usage of development processes that exclude unit information We conclude with recommendations to UoM library creators derived from these observations. We also argue that so long as units are not part of the language, or not supported through an IDE extension, their use will be limited. Native language support allows for efficient unit conversion and static checking. While lightweight methods provide many benefits of UoM libraries with minimal overheads. Libraries are perhaps best suited to applications in which unit of measurement checking is desirable at run‐time.

In scientific applications, physical quantities and units of measurement are used regularly. If the inherent incompatibility between these units is not handled properly it can lead to major, sometimes catastrophic, problems. Although the risk of a miscalculation is high and the cost equally so, almost none of the major programming languages has support for physical quantities. Instead, scientific code developers often make their own tools or rely on external libraries to help them spot or prevent these mistakes.

Mathematical models are frequently used to model biological process, such as cardiac electrophysiological systems. In order to separate the models from the implementations, and to facilitate curation, domain specific languages (DSLs) have become a popular and effective means of specifying models (Lloyd et al., 2004; Hucka et al., 2004). In previous papers (Gill et al., 2012a; Gill et al., 2012b; McKeever et al., 2013) we have argued for including parameterised modules as part of such DSLs. We presented our Ode language and showed how models could be created in a generic fashion. In this paper we extend our work with concrete examples and simulation results. We show how complex heart models can be constructed by aggregation, encapsulation and subtyping. Our use-case retraces the steps taken by (Niederer et al., 2009), which investigated the common history between cardiac models, and shows how they can be cast in our language to be reused and extended. Our DSL enables ‘physiological model engineering’ through the development of generic modules exploiting high cohesion and low coupling.

Significant Virtual Physiological Human efforts and projects have been concerned with cancer modeling, especially in the European Commission Seventh Framework research program, with the ambitious goal to approach personalized cancer simulation based on patient-specific data and thereby optimize therapy decisions in the clinical setting. However, building realistic in silico predictive models targeting the clinical practice requires interactive, synergetic approaches to integrate the currently fragmented efforts emanating from the systems biology and computational oncology communities all around the globe. To further this goal, we propose an intelligent graphical workflow planning system that exploits the multiscale and modular nature of cancer and allows building complex cancer models by intuitively linking/interchanging highly specialized models. The system adopts and extends current standardization efforts, key tools, and infrastructure in view of building a pool of reliable and reproducible models capable of improving current therapies and demonstrating the potential for clinical translation of these technologies.

Abstract When physical quantities are used in programs they are typically represented as raw numbers, with the units in which they were measured only being given in comments, if at all. This can lead to errors from the use of dimensionally inconsistent expressions, or the comparison of two quantities of the same dimension but measured in different units, which are not discovered until run time. Any program working with the physical world has this issue, with scientific modelling being a major application. Implementors of models have the time‐consuming and error‐prone task of adding in dynamic units checks and conversions manually. Most existing programming languages do not provide support for representing units explicitly (although extensions to some have been proposed). With the advent of domain‐specific modelling languages, incorporating code generation techniques, we propose checking physical units at the level of the modelling language, removing the need for such a support in the underlying implementation language. We present our work in the context of one such modelling language: CellML, developed at the University of Auckland with a focus on modelling biological systems. We have developed an intuitive algorithm for performing automatic conversions between quantities measured in different units. It both requires fewer conversion operations than current approaches and makes more sensible choices about which quantities to convert. Uniquely, by using partial evaluation techniques it is also capable of dealing robustly with quantities raised to arbitrary powers, even where the exponent is given by an expression. We demonstrate our algorithm on various examples. Copyright © 2007 John Wiley & Sons, Ltd.

Biomolecular simulations have been particularly useful in providing atomic-level insights into biological processes. The simulations can be conducted at atomistic or coarse grained resolution. An atomistic simulation can model atomic details of a biological process but is computationally expensive. A coarse-grained simulation is time-efficient but cannot fully expose atomic details. In order to support efficient simulations of complex biomolecular processes, we have developed a multiscale simulation model that dynamically integrates both atomistic and coarse-grained simulations. The model has been used to simulate a membrane bound viral fusion peptide associating with a phospholipid bilayer. The simulation provides an important pre-requisite in understanding the viral fusion mechanism that can aid the design of better drugs against infectious viruses. The simulation has achieved a high performance with a minimum 8-fold speedup.

This paper discusses the mapping of arrays in a high-level SystemC description to hardware. Normally, arrays are implemented as register files using general purpose logic. Modern FPGAs however contain a large number of RAM blocks which can used to implement arrays instead. Memories have a limited number of ports and mapping arrays to multiport memories involves assigning each array access to a port. Whilst in RTL synthesis this choice is made by the designer, hardware compilation does not offer this level of control. In this paper, an algorithm is presented that automatically assigns accesses to ports such that no memory port is ever accessed more than once in a clock cycle. Unlike previous methods, the proposed algorithm assigns accesses to read/write-only ports and read-write ports concurrently, solving the assignment problem more efficiently for a wider range of memories. The method has been implemented in a commercial SystemC hardware compiler and results show a significant reduction in logic when implementing arrays in memory.

In this paper we present our use of functional programming (FP), specifically Haskell, to provide an operational semantics for a domain-specific language, CellML, that describes mathematical models of biological processes. We analyse the benefits and shortcomings of this approach, in comparison with other semantic definitions for CellML.

Simulating the human heart is a challenging problem, with simulations being very time consuming---some can take days to compute even on high performance computing resources. There is considerable interest in optimisation techniques, with a view to making whole-heart simulations tractable. Reliability of heart model simulations is also of great concern, particularly considering clinical applications. Simulation software should be easily testable (against empirical data) and maintainable, which is often not the case with extensively hand-optimised software. Automating any optimisations will greatly improve this situation. This paper presents a framework for automatically optimising cardiac ionic cell models. An abstract format for such models, CellML [9], has been developed at Auckland University and is gaining in popularity. We utilise this format and investigate robust transformations of models that lead to reduced simulation times. In particular, we demonstrate that partial evaluation [13] is a promising technique for this purpose, and that it combines well with a lookup table technique, commonly used in cardiac modelling, which we have automated. In our tests, the technique of partial evaluation gives a speedup of 1.2 times. Further, applying such transformations prior to the lookup table optimisation results in additional speedups from the latter technique. When both optimisations are used we obtain nearly a 5-fold speedup, compared with a speedup of 1.7 times when lookup tables alone are used.

Abstract This paper presents a framework for verifying compilation tools for parametrised hardware designs with placement information. The framework involves Pebble, a simple declarative language based on Structural VHDL which supports the use of placement information to guide circuit layout; such information often leads to efficient designs that are particularly important for hardware libraries. Relative placement information enables control of circuit layout at a higher level of abstraction than placement information in the form of explicit coordinates. An approach based on pass separation techniques is adopted for specifying and verifying two Pebble abstraction mechanisms: a flattening procedure and a relative placement method. For the flattening procedure, which takes a set of parametrised blocks and unfolds the circuit description into a netlist, we provide semantic descriptions of both the hierarchical and the flattened Pebble languages to prove its functional correctness. For the relative placement method, we specify the compilation procedure from Pebble programs with relative placement information to Pebble programs with explicit coordinate expressions, often in the form of symbolic placement constraints. This compilation procedure can be used in conjunction with partial evaluation to optimise the size and speed of parametrised circuit descriptions using relative placement, without flattening the original hierarchical descriptions. Our approach has been used for optimising a pattern matcher design, which results in a 33% reduction in resource usage. For DES encryption, our method can reduce the size of a DES design by 60%.

In heterogeneous and dynamic distributed systems like the grid, detailed monitoring of workload and its resulting system performance (e.g. response time) is required to facilitate performance diagnosis and adaptive performance tuning. In this paper, we present a workload monitoring infrastructure for this purpose. The infrastructure classifies and monitors workload across components in grids based on the open grid service architecture (OGSA) in an end-to-end manner. It provides the abilities to assess what components are involved in processing a work unit, to report time elapsed at these components, and to capture concurrency and isolate which components are critical to overall performance observed. These are enclosed in an automatically constructed Response Time Service Petri Net (RT-SPN) model. A tool is provided to accept queries about work units and visualise corresponding RTSPNs. The infrastructure is also designed and implemented so as to be portable, scalable and lightweight.

This paper describes existing practices in the supervision and assessment of projects undertaken by part-time, postgraduate students in Software Engineering. It considers this aspect of the learning experience, and the educational issues raised, in the context of existing literature-much of which is focussed upon the experience of full-time, undergraduate students. The importance of these issues will increase with the popularity of part-time study at a postgraduate level; the paper presents a set of guidelines for project supervision and assessment.

Field Programmable Gate Arrays (FPGAs) are usually programmed using languages and methods inherited from the domain of VLSI synthesis. These methods, however, have not always been adapted to the new possibilities opened by FPGAs, nor to the new constraints they impose on a design. This paper addresses in particular the issue of laying out the various components of an architecture on an FPGA. The problem is to embed placement information in FPGA-oriented hardware description languages, in a way that is both expressive enough to be useful, and abstract enough to be portable from one FPGA architecture to the other. A generic placement framework is defined to address this problem, and two prototype implementations of this framework are presented, for Xilinx 6200 and Xilinx 4000 devices, on the example of a bit-serial complex multiplier.