A configuration approach to parallel programming

This paper advocates a configuration approach to parallel programming for distributed memory multicomputers, in particular, arrays of transputers. The configuration approach prescribes the rigorous separation of the logical structure of a program from its component parts. In the context of parallel programs, components are processes which communicate by exchanging messages. The configuration defines the instances of these processes which exist in the program and the paths by which they are interconnected.

The approach is demonstrated by a toolset (Tonic) which embodies the configuration paradigm. A separate configuration language is used to describe both the logical structure of the parallel program and the physical structure of the target multicomputer. Different logical to physical mappings can be obtained by applying different physical configurations to the same logical configuration. The toolset has been developed from the Conic system for distributed programming. The use of the toolset is illustrated through its application to the development of a parallel program to compute Mandelbrot sets.     

基于XML的具有性能约束构件的组装技术

采用在软总线TAO(The ACE ORB)上利用XML文档中所包含的语义化的抽象数据类型对构件对象进行操作,从而实现语义化的性能约束构件组装。建构的XML模式描述了构件组装相关的构件接口、交互及配置规约,并通过接口显式地表达构件对环境的依赖,使得能在一个分布式的网络环境里,将多个处于不同节点、提供紧密相关服务的构件在运行时动态地组装成功能系统。在给出的示例中,实现了将三个分布在不同节点的性能约束构件通过它们接口的交互及配置,实现在运行时开放的松散式组装。最后给出了下一步研究工作的重点及方向。     

ES-Kit: An object-oriented distributed system

This paper describes the design, implementation, and performance of ES-Kit, a distributed object-oriented system being developed by the Experimental Systems Project at the Microelectronics and Computer Technology Corporation. The operating system consists of a kernel and a set of Public Service Objects which dynamically extend the functionality of the kernel by providing several traditional operating system services when required by application objects. Applications for the ES-Kit environment are written in GNU C++ and do not require additional language primitives for distributed execution. Initial performance results from a representative set of applications indicate that the object-oriented paradigm provides a powerful solution to distributed programming.     

Primitives for distributed computing in a heterogeneous local areanetwork environment

Epsilon is a testbed for monitoring distributed applications involving heterogeneous computers, including microcomputers, interconnected by a local area network. Such a hardware configuration is usual but raises difficulties for the programmer. First, the interprocess communication mechanisms provided by the operating systems are rather cumbersome to use. Second, they are different from one system to another. Third, the programmer of distributed applications should not worry about system and/or network aspects that are not relevant for the application level. The authors present the solution chosen in Epsilon. A set of high-level communication primitives has been designed and implemented to provide the programmer with an interface independent of the operating system and of the underlying interprocess communications facilities. A program participating in a distributed application can be executed on any host without any change in the source code except for host names     

An open framework for translating portable applications into operating system‐specific wireless sensor networks applications

Wireless sensor networks (WSNs) are distributed systems integrated by tiny devices, called sensor nodes, with capabilities to monitor the environment and forward their measurements to a special node, the sink, where the results can be collected and further processed. The trend in WSN is moving towards heterogeneous networks that will contain different sensor nodes running different instances of custom operating systems. Given the growing demand of new hardware platforms and operating systems specifically designed for sensor nodes, the applications programming for sensor nodes is becoming a challenging process that needs to be alleviated. Currently, application programming for sensor nodes is a complex, ad hoc, and error‐prone process where the portability among different platforms has been sacrificed. In this paper, we propose an open framework aimed to achieve application portability in heterogeneous sensor networks. Our approach provides the programming abstractions needed to support the application development process for sensor nodes. We have implemented an open framework that provides a set of tools on top of the most popular WSN operating systems to translate portable applications to the native operating system in an automatic, simple, and transparent way for developers. We have also evaluated the applications thus generated in terms of productivity and overhead, by comparing their footprint to those originally developed in each specific operating system. The results show that the overhead is minimal—4% in the worst case—and in some cases, it was even possible to reduce the footprint by using code optimizations. Copyright © 2012 John Wiley & Sons, Ltd.     

IMDAS—An integrated manufacturing data administration system

A typical manufacturing facility uses a set of heterogeneous computer systems to support various design, planning, and manufacturing activities. These systems usually consist of different hardware (computers, NC machines, robots and workstations), software (operating systems, programming languages) and application systems (analysis packages, simulators, database management systems, file management systems). The databases of these systems are often different in their logical and physical structures since they are established using different data management facilities and their structures are tailored to support the various design and manufacturing activities. In Computer Integrated Manufacturing (CIM), these systems need to be interconnected to allow sharing of hardware and software resources and the timely delivery of data to these component systems. This paper describes the architecture of an Integrated Manufacturing Data Administration System (IMDAS) which provides the users and application software with a unified view of the global database that is physically distributed among dissimilar component systems. The IMDAS provides a high-level semantic view of the global database using a semantic association model OSAM¹ and a high-level language for global data manipulation to enable the user or the application software to access the global database easily and meaningfully.     

The newcastle connection or UNIXes of the world unite!

In this paper we describe a software subsystem that can be added to each of a set of physically interconnected UNIX or UNIX look-alike systems, so as to construct a distributed system which is functionally indistinguishable at both the user and the program level from a conventional single-processor UNIX system. The techniques used are applicable to a variety and multiplicity of both local and wide area networks, and enable all issues of inter-processor communication, network protocols, etc., to be hidden. A brief account is given of experience with such a distributed system, which is currently operational on a set of PDPlls connected by a Cambridge Ring. The final sections compare our scheme to various precursor schemes and discuss its potential relevance to other operating systems.     

Genetic algorithm based approach for file allocation on distributed systems

One of the important features of distributed computing systems (DCSs) is the potential of high reliability. When the hardware configuration of a DCS is fixed, the system reliability mainly depends on the allocation of various resources. One of the important resources used in a DCS are various files. In this paper, we have developed a reliability oriented file allocation scheme for distributed systems. In this scheme various files are allocated to different nodes of a DCS so that the reliability of executing a program which requires files from remote node(s) is maximized. Several variations of this problem are solved to illustrate the Genetic Algorithm based solution approach. The paper also provides the relation between degree of redundancy of files and the maximum achievable reliability of executing a program. The proposed method is compared with optimal solutions to demonstrate the accuracy of the solution obtained from Genetic Algorithm based methodology.     

LVT: a layered verification technique for distributed computing systems

This paper presents a layered verification technique, called LVT, for the verification of distributed computing systems with multiple component layers. Each lower layer in such a system provides services in support of functionality of the higher layer. By taking a very general view of programming languages as interfaces of systems, LVT treats each layer in a distributed computing system as a distributed programming language. Each relatively higher‐level language in the computing system is implemented in terms of a lower‐level language. The verification of each layer in a distributed computing system can then be viewed as the verification of implementation correctness for a distributed language. This paper also presents the application of LVT to the verification of a distributed computing system, which has three layers: a small high‐level distributed programming language; a multiple processor architecture consisting of an instruction set and system calls for inter‐process message passing; and a network interface. Programs in the high‐level language are implemented by a compiler mapping from the language layer to the multiprocessor layer. System calls are implemented by network services. LVT and its application demonstrate that the correct execution of a distributed program, most notably its inter‐process communication, is verifiable through layers. The verified layers guarantee the correctness of (1) the compiled code that makes reference to operating system calls, (2) the operating system calls in terms of network calls, and (3) the network calls in terms of network transmission steps. The specification and verification involved are carried out by using the Cambridge Higher Order Logic (HOL) theorem proving system. Copyright © 1999 John Wiley & Sons, Ltd.     

Timed-pNets: a communication behavioural semantic model for distributed systems

This paper presents an approach to build a communication behavioural semantic model for heterogeneous distributed systems that include synchronous and asynchronous communications. Since each node of such system has its own physical clock, it brings the challenges of correctly specifying the system time constraints. Based on the logical clocks proposed by Lamport, and CCSL proposed by Aoste team in INRIA, as well as pNets from Oasis team in INRIA, we develop timed-pNets to model communication behaviours for distributed systems. Timed-pNets are tree style hierarchical structures. Each node is associated with a timed specification which consists of a set of logical clocks and some relations on clocks. The leaves are represented by timed-pLTSs. Non-leaf nodes (called timed-pNets nodes) are synchronisation devices that synchronize the behaviours of subnets (these subnets can be leaves or non-leaf nodes). Both timed-pLTSs and timed-pNets nodes can be translated to timed specifications. All these notions and methods are illustrated on a simple use-case of car insertion from the area of intelligent transportation systems (ITS). In the end the TimeSquare tool is used to simulate and check the validity of our model.     

A software architecture for distributed computer control systems

Distributed computer control systems have a number of potential advantages over centralized systems, especially where the application is itself physically distributed. A computer station can be placed close to the plant being controlled, and a communications network used to enable the stations to communicate to coordinate their actions. However, the software must be carefully designed to exploit the potential advantages of distribution. This paper describes the software architecture of CONIC, a system to support distributed computer control applications. This architecture emphasizes the distinction between the writing of individual software components and the construction and configuration of a system from a set of components. A modular structure is used to separate programming from configuration. Typed entry and exit ports are used to clearly define module interfaces. Ports, analagous to the plugs and sockets of hardware components, permit modules to be interconnected in different ways. On-line modification and extension of the system is supported by permitting the dynamic creation and interconnection of modules. Message passing primitives are provided to permit modules to coordinate and synchronize control actions.     

A Message-Based Approach to Discrete-Event Simulation

This paper develops a message-based approach to discrete-event simulation. Although message-based simulators have the same expressive power as traditional discrete-event simulation lanuages, they provide a more natural environment for simulating distributed systems. In message-based simulations, a physical system is modeled by a set of message-communicating processes. The events in the system are modeled by message-communications. The paper proposes the entity construct to represent a message-communicating process operating in simulated time. A general wait until construct is used for process scheduling and message-communication. Based on these two notions, the paper proposes a language fragment comprising a small set of primitives. The language fragment can be implemented in any general-purpose, sequential programming language to construct a message-based simulator. We give an example of a message-based simulation language, called MAY, developed by implementing the language fragment in Fortran. MAY is in the public domain and is available on request.     

An implementation of disk objects in the logical machine monitor

User or program mobility in distributed computing systems is becoming increasingly significant, since users may sometimes change their working locations. This paper proposes a Logical Machine (LM) system that can effectively support software environment migration and resource mapping. The LM partitions the conventional operating systems into two parts: the Logical Machine Operating System (LMOS) and the Logical Machine Monitor (LMM). They are responsible for user service and system resource management, respectively. The LMM provides a machine independent appearance, called the Logical Machine Interface (LMI), for the upper operating system layers to provide the resources they need. In our experimental system, the LMM contains some disk objects that can be bound dynamically. By varying the binds, the users get different disk characteristics. A mobile disk object with the mechanism of block migration on demand is implemented. It can be incorporated with a logical machine migration facility to achieve job migration, i.e., the user can migrate the operating system and disk blocks to the place he or she desires. The mobile disk also simplifies the mechanism of parallel processing when each server reads and processes its data portion locally. With this approach, the system resources can be mapped more flexibly, while transparency to the operating system is retained. © 1997 John Wiley & Sons, Ltd.     

Rendezvous Facilities in a Distributed Computer System

The distributed computer system described in this paper is a set of computer nodes interconnected in an interconnection network via packet-switching interfaces.The nodes communicate with each other by means of message-passing protocols.This paper presents the implementation of rendezvous facilities as high-level primitives provided by a parallel programming language to support interprocess communication and synchronization.     

Communication and Synchronization Primitives for Distributed Programs

A distributed program is a collection of several processes which execute concurrently, possibly in different nodes of a distributed system, and which cooperate with each other to realize a common goal. In this paper, we present a design of communication and synchronization primitives for distributed programs. The primitives are designed such that they can be provided by a kernel of a distributed operating system. An important feature of the design is that the configuration of a process, i.e., identities of processes with which the process communicates, is specified separately from the computation performed by the process. This permits easy configuration and reconfiguration of processes. We identify different kinds of communication failures, and provide distinct mechanisms for handling them. The communication primitives are not atomic actions. To enable the construction of atomic actions, two new program components, atomic agent and manager are introduced. These are devoid of policy decisions regarding concurrency control and atomic commitment. We introduce the notion of conflicts relation using which a designer can construct either an optimistic or a pessimistic concurrency control scheme. The design also incorporates primitives for constructing nested atomic actions.     

Ada program partitioning language: a notion for distributing Adaprograms

Ada Program Partitioning Language (APPL) has been designed as part of Honeywell's Distributed Ada project. The goal of the project is to develop an approach for reducing the complexity of building distributed applications in Ada. In the proposed approach, an application is written as a single Ada program using the full capabilities of the Ada language. It is not necessary to factor the underlying hardware configuration into the program design. Once the program has been completed and tested in the host development environment, it is partitioned into fragments and mapped onto the distributed hardware. The partitioning and mapping are expressed in APPL and do not require changes to the Ada source. The main thrusts of the project include the design of APPL and the development of language translation tools and the run-time system to support Ada and APPL for a distributed target. The authors present an overview of APPL, the goals considered in the design, and issues that impact its implementation