Innes Jelly

Software engineering for parallel systems

Abstract Current approaches to software engineering practice for parallel systems are reviewed. The parallel software designer has not only to address the issues involved in the characterization of the application domain and the underlying hardware platform, but, in many instances, the production of portable, scalable software is desirable. In order to accommodate these requirements, a number of specific techniques and tools have been proposed, and these are discussed in this review in the framework of the parallel software life-cycle. The paper outlines the role of formal methods in the practical production of parallel software, but its main focus is the emergence of development methodologies and environments. These include CASE tools and run-time support systems, as well as the use of methods taken from experience of conventional software development. Because of the particular emphasis on performance of parallel systems, work on performance evaluation and monitoring systems is considered.

Object-based modeling of parallel programs

The Parse Project has been investigating software development issues covering a range of parallel applications. Parse itself is an object-based design methodology that incorporates design management strategies based on data and function encapsulation, hierarchical decomposition, and staged refinement. Parse represents parallel software designs with a graphical notation called process graphs. After capturing a designs important structural features, this notation systematically derives the designs skeletal dynamic properties. For this, it can use either a behavioral specification language or formal methods such as CSP (Communicating Sequential Processes) or Petri nets. Parse builds on existing parallel software design techniques that are based on dataflow and object-oriented approaches. Parse attempts to capture precise object interactions and synchronization in an abstract, architecture-independent notation. To do so, it combines the strengths of various object-oriented techniques and extends the abilities of real-time design methodologies. The Parse project has tried to promote recognized software engineering techniques and extend them to incorporate high-level abstractions for parallel software design. Using systematic transformation techniques, system designers then can methodically refine their designs into formal notations to promote verification and into programming languages for easy implementation. >

Modelling test data for performance evaluation of large parallel database machines

Parallel servers offer improved processing power for relational database systems and provide system scalability. In order to support the users of these systems, new ways of assessing the performance of such machines are required. If these assessments are to show how the machines perform under commercial workloads they need to be based upon models which have a real commercial basis. This paper shows how a realistic model of a financial application has been developed and how a set of tools has been created which allow the implementation of the model on any commercial database system. The tools allow the generation of large quantities of test data in a manner which renders it amenable to subsequent independent analysis. The test data thus generated forms the basis for the performance tuning of parallel database machines.

Engineering High Quality Parallel Software Using PARSE

The PARSE design methodology provides a hierarchical, object-based approach to the development of high quality, reliable parallel software systems. A system design is initially structured into a collection of concurrently executing objects which communicate via message-passing. A graphical notation known as process graphs is then used to capture the structural and important dynamic properties of the system. Process graph designs can then be semi-mechanically transformed into complete Petri nets to give a detailed, executable and formally verifiable design specification.

Parallel software engineering with PARSE

The aims of the PARSE methodology are described, and the process graph design notation is summarised. Process graphs are a new graphical notation for describing systems comprising a collection of parallel processes in a language- and architecture-independent fashion. Further, process graph designs can be mechanically transformed into Petri nets to give a more detailed, executable design specification. Some simple process graphs and their corresponding Petri nets are described in order to demonstrate this transformation process. A more extensive example then illustrates the initial stages of the design process in practice.<<ETX>>

The PARSE project

Within the PARSE project, issues relating to the development of parallel and distributed software are being researched. These include analysis and design techniques, verification of system behaviour, performance evaluation and tool support. This paper reviews the work undertaken in the project, indicates future directions for research and provides a bibliography of key publications.

Software Engineering For Parallel And Distributed systems: challenges and opportunities

B software for parallel and distributed systems is notoriously difficult, and ultimately expensive.1 The additional challenges introduced by physical component distribution and dynamic, concurrent behavior can push existing software-engineering methods and tools to— and often beyond—their limits.2 This breeds systems that contain faults, are difficult to maintain and enhance, and fail to scale as workloads inevitably increase. Until recently, however, the development of parallel and distributed systems was very much a niche area within the software profession. This is no longer the case: distributed systems are now ubiquitous, the most obvious example being the World Wide Web. Less obviously, commercial organizations as diverse as banks and gambling agencies are now deploying and developing distributed, high-performance systems based on distributed object technology. These systems scale to thousands of simultaneous users, are widely distributed, are fault-tolerant, and employ multithreaded servers and multi-CPU workstations to achieve the required performance. Not surprisingly, these are business-critical systems, where failures are not tolerated. Software Engineering for Parallel and Distributed Systems: Challenges and Opportunities

Distributed logic circuit simulation on a network of workstations

The implementation of a distributed digital logic simulation algorithm on a network of workstations is presented. The simulation of digital circuits is done using a demand driven approach. The simulation is performed on a network of workstations using the Parallel Virtual Machine (PVM) software. The use of the PVM as a platform for parallel and distributed applications is assessed in the light of the test results. The feasibility of running parallel logical simulation algorithms on such platform is considered.<<ETX>>

Designing parallel database programs using PARSE

The problems of constructing parallel programs are considered and the aims of the PARSE parallel software engineering methodology are introduced. PARSE is a multi-stage methodology that covers logical and physical design, design verification, and implementation strategy. The first stage in the methodology involves the use of process graphs which provide a language and architecture independent notation for partitioning the problem into processes and specifying the communication relationships between them. This paper gives an outline of the PARSE methodology and describes the process graph notation. The use of the notation is illustrated with an example of a design for a parallel database system.<<ETX>>

Petri Net Modelling of PARSE Designs

PARSE is a staged object-based design methodology for parallel and distributed software systems. In the highest stage, a graphical notation is used to describe the system components (objects) and their interconnections. In the subsequent stage, the designer introduces the behaviour of the objects, by means of a textual notation. This paper shows a mechanical transformation of the textual representation of a PARSE design into a complete Petri net model. This supports the integration of formal analysis techniques into the early stage of the software development process, and provides a formal semantics for the design notation.