The PVM system is a programming environment for the development and execution of large concurrent or parallel applications that consist of many interacting, but relatively independent, components. It is intended to operate on a collection of heterogeneous computing elements interconnected by one or more networks. The participating processors may be scalar machines, multiprocessors, or special-purpose computers, enabling application components to execute on the architecture most appropriate to the algorithm. PVM provides a straightforward and general interface that permits the description of various types of algorithms (and their interactions), while the underlying infrastructure permits the execution of applications on a virtual computing environment that supports multiple parallel computation models. PVM contains facilities for concurrent, sequential, or conditional execution of application components, is portable to a variety of architectures, and supports certain forms of error detection and recovery.

PVM: a framework for parallel distributed computing

Busy-wait techniques are heavily used for mutual exclusion and barrier synchronization in shared-memory parallel programs. Unfortunately, typical implementations of busy-waiting tend to produce large amounts of memory and interconnect contention, introducing performance bottlenecks that become markedly more pronounced as applications scale. We argue that this problem is not fundamental, and that one can in fact construct busy-wait synchronization algorithms that induce no memory or interconnect contention. The key to these algorithms is for every processor to spin on separate locally-accessible flag variables, and for some other processor to terminate the spin with a single remote write operation at an appropriate time. Flag variables may be locally-accessible as a result of coherent caching, or by virtue of allocation in the local portion of physically distributed shared memory.We present a new scalable algorithm for spin locks that generates 0(1) remote references per lock acquisition, independent of the number of processors attempting to acquire the lock. Our algorithm provides reasonable latency in the absence of contention, requires only a constant amount of space per lock, and requires no hardware support other than a swap-with-memory instruction. We also present a new scalable barrier algorithm that generates 0(1) remote references per processor reaching the barrier, and observe that two previously-known barriers can likewise be cast in a form that spins only on locally-accessible flag variables. None of these barrier algorithms requires hardware support beyond the usual atomicity of memory reads and writes.We compare the performance of our scalable algorithms with other software approaches to busy-wait synchronization on both a Sequent Symmetry and a BBN Butterfly. Our principal conclusion is that contention due to synchronization need not be a problem in large-scale shared-memory multiprocessors. The existence of scalable algorithms greatly weakens the case for costly special-purpose hardware support for synchronization, and provides a case against so-called “dance hall” architectures, in which shared memory locations are equally far from all processors. —From the Authors' Abstract

/pdf/algorithms-for-scalable-synchronization-on-shared-memory-2fqah2bkze.pdf

Algorithms for scalable synchronization on shared-memory multiprocessors

Model transformations are touted to play a key role in Model Driven DevelopmentTM. Although well-established standards for creating metamodels such as the Meta-Object Facility exist, there is currently no mature foundation for specifying transformations among models. We propose a framework for the classification of several existing and proposed model transformation approaches. The classification framework is given as a feature model that makes explicit the different design choices for model transformations. Based on our analysis of model transformation approaches, we propose a few major categories in which most approaches fit.

/pdf/feature-based-survey-of-model-transformation-approaches-2hq9yv60ag.pdf

Feature-based survey of model transformation approaches

This article proposes a taxonomy of model transformation, based on the discussions of a working group on model transformation of the Dagstuhl seminar on Language Engineering for Model-Driven Software Development. This taxonomy can be used, among others, to help developers in deciding which model transformation language or tool is best suited to carry out a particular model transformation activity.

/pdf/a-taxonomy-of-model-transformation-3cyk0bxs24.pdf

A Taxonomy of Model Transformation

We present an algorithm for distributed mutual exclusion in a computer network of N nodes that communicate by messages rather than shared memory. The algorithm uses a spanning tree of the computer network, and the number of messages exchanged per critical section depends on the topology of this tree. However, typically the number of messages exchanged is O(log N) under light demand, and reduces to approximately four messages under saturated demand.Each node holds information only about its immediate neighbors in the spanning tree rather than information about all nodes, and failed nodes can recover necessary information from their neighbors. The algorithm does not require sequence numbers as it operates correctly despite message overtaking.

/pdf/a-tree-based-algorithm-for-distributed-mutual-exclusion-4mourl8jol.pdf

A tree-based algorithm for distributed mutual exclusion

In this paper we explore the issue of transforming models to models, an essential part of the OMG's Model Driven Architecture (MDA) vision. Drawing from the literature and our experiences implementing a number of transformations using different technologies, we explore the strengths and weaknesses of the different technologies and identify requirements for a transformation language for performing the kind of model-to-model transformations required to realise the MDA vision.

/pdf/transformation-the-missing-link-of-mda-1bcjmrp07r.pdf

Transformation: The Missing Link of MDA

Model transformations are an integral part of model-driven development. Incremental updates are a key execution scenario for transformations in model-based systems, and are especially important for the evolution of such systems. This paper presents a strategy for the incremental maintenance of declarative, rule-based transformation executions. The strategy involves recording dependencies of the transformation execution on information from source models and from the transformation definition. Changes to the source models or the transformation itself can then be directly mapped to their effects on transformation execution, allowing changes to target models to be computed efficiently. This particular approach has many benefits. It supports changes to both source models and transformation definitions, it can be applied to incomplete transformation executions, and a priori knowledge of volatility can be used to further increase the efficiency of change propagation.

/pdf/incremental-model-transformation-for-the-evolution-of-model-4933zzi0wn.pdf

Incremental model transformation for the evolution of model-driven systems

The Reference Model of Open Distributed Processing (RM-ODP) was a joint effort by the international standards bodies ISO and ITU-T to develop a coordinating framework for the standardisation of open distributed processing (ODP). The model describes an architecture within which support of distribution, interworking, interoperability and portability can be integrated. The RM-ODP framework defines ODP concerns using five “viewpoints” (abstractions), namely enterprise, information, computational, engineering, and technology. This tutorial introduces the reference model, describing the viewpoints and some of the ODP functions and transparencies.

/pdf/reference-model-of-open-distributed-processing-rm-odp-4zotge5kdd.pdf

Reference Model of Open Distributed Processing (RM-ODP): Introduction

While developments in distributed object computing environments, such as the Common Object Request Broker Architecture (CORBA) by the Object Management Group (2000) and the Telecommunication Intelligent Network Architecture (TINA) by H. Mulder (2002), have enabled interoperability between domains in large open distributed systems, managing the resources within such systems has become an increasingly complex task. This challenge has been considered for several years within the distributed systems management research community and policy-based management has recently emerged as a promising solution. Large evolving enterprises present a significant challenge for policy-based management partly due to the requirement to support both mutual transparency and individual autonomy between domains according to C. Bidan and V. Issarny (1998), but also because the fluidity and complexity of interactions occurring within such environments requires an ability to cope with the existence of multiple, potentially inconsistent policies. This paper discusses the need for providing both dynamic (run-time) and static (compile-time) conflict detection and resolution for policies in such systems and builds on our earlier conflict detection work (Dunlop et al., 2001, 2002) to introduce the methods for conflict resolution in large open distributed systems.

Kerry Raymond

Papers

A tree-based algorithm for distributed mutual exclusion

Transformation: The Missing Link of MDA

Incremental model transformation for the evolution of model-driven systems

Reference Model of Open Distributed Processing (RM-ODP): Introduction

Methods for conflict resolution in policy-based management systems