The Programmers' Playground: I/O abstraction for heterogeneous distributed systems (original) (raw)

High-level language support for programming distributed systems

1992

This paper presents a strategy to simplify the programming of heterogeneous distributed systems. Our approach is based on integrating a high-level distributed programming model, called the process model, directly into programming languages. Distributed applications written in such languages are portable across di erent e n vironments, are shorter, and are simpler to develop than similar applications developed using conventional approaches.

DIPC : A Heterogeneous Distributed Programming System

2003

Distributed Inter-Process Communication (DIPC) is a software-only solution to enable people to build and program Multi-Computers. Among other things, DIPC provides the programmers with Transparent Distributed Shared Memory. DIPC is not concerned with the incompatible executable code problem. It also does not change user’s data, but DIPC has to understand data produced by its own peer processes in different machines. This paper briefly describes the efforts done to make it a heterogeneous system by enabling it to function under the Linux operating system running on both Intel x86 and Motorola 680x0 processors. Here, different parts of the same application could execute in machines with different architectures

Separation of concerns and operating systems for highly heterogeneous distributed computing

1994

Highly heterogeneous distributed computing applications present a tremendous chap lenge for operating system implementors. These applicati0hs present an extremely wide range of demands and must run in an extremely wide range of environments. In order to recognize the wide range of environments, without losing the benefits of traditional modularity, we propose a separation of concerns approach to the design of operating systems for this domain. In this paper, we first discuss importance of separation of concerns particularly in highly heterogeneous distributed computing. The discussion is based on the issues we encounter when programming of distributed applications such as for networked copiers, settop boxes for cablenets, networked analyzers/oscilloscopes, or palmtop computers. We then propose a way to solve them without sacrifice of performance. This paper contributes to this workshop in the sense that it addresses frustrations of programmers, particularly of embedded systems, and demonstrates our technology to solve their frustration from an operating systems' perspective.

SPACE: a new approach to operating system abstraction

Proceedings 1991 International Workshop on Object Orientation in Operating Systems, 1991

Object-oriented operating systems, as well as conventional O/S designs, present an overly restrictive level of abstraction to the programmer. Models of objects, processes, concurrency, etc., are embedded within the system in such a way that they are dicult to extend or replace.

Heterogeneous distributed computing based on high‐level abstractions

Concurrency and Computation: Practice and Experience, 2018

SummaryThe rise of heterogeneous systems has given place to great challenges for users as they involve new concepts, restrictions, and frameworks. Their exploitation is further complicated in the context of distributed memory systems, which require the usage of additional different programming paradigms and tools. In this paper, we propose a novel approach to program heterogeneous clusters that is based on high‐level abstractions such as tiles and hierarchical decomposition combined with the powerful APIs that data types and embedded languages can provide in languages such as C++. Rather than building our proposal from scratch, we have implemented it as a natural integration of the existing Hierarchically Tiled Arrays (HTA) and Heterogeneous Programming Library (HPL) projects, ie, the first one being focused on distributed computing and the second one on heterogeneous processing. The result, called Heterogeneous Hierarchically Tiled Arrays (H2TA), is very intuitive and easy to use t...

Volta: Developing Distributed Applications by Recompiling

IEEE Software, 2000

This tool suite recompiles nondistributed executables into functionally equivalent distributed form, inserting remoting and synchronization boilerplate code and facilitating post hoc instrumentation. C ontemporary programming languages and tool suites are designed for quick and easy construction of sequential, nondistributed applications. To write distributed applications, programmers must learn and use a large variety of lower-level libraries for cross-tier communication, data marshaling, synchronization, and security. The libraries' sole purpose is to support distributed execution of application logic that could just as well be executed sequentially. In fact, programmers often create prototype applications that run in simplified, streamlined, sequential environments so that they can test and debug their code. Then they manually break up the prototype, inserting communication and synchronization code and distributing the pieces among multiple execution tiers.

EC : A Language for Distributed Computing

Computer Networks, Architecture and Applications, 1995

Computation intensive programs can utilise idle workstations in a cluster by exploiting the parallelism inherent in the problem being solved. A programming language for distributed computing offers advantages like early detection of type mismatch in communication and offers structured mechanisms to specify possible overlap in communication and computation, and exception handling for catching run time errors. Success of a language depends on its ease of use, expressibility and efficient implementation of its constructs. EC is a super set of C supporting process creation, a message passing mechanism, and exception handling. The pipelined communication constructs and multiple process instances help in expressing concurrency between computation and communication. Data driven activation of EC processes is used for scheduling. EC has been implemented in a Sun-3 workstation cluster. An inter-node message passing mechanism has been built on top of the socket interface using the TCP protocol, and intra-node message passing is done by passing pointers to improve efficiency. However, message_type variables hide the implementation details, improve type safety and location transparency of a program.

NUTS: a Distributed Object-oriented Platform with High Level Communication Functions

Computing and Informatics / Computers and Artificial Intelligence, 1998

An extensible object-oriented platform NUTS for distributed computing is described which is based on an object-oriented programming environment NUT, is built on top of the Parallel Virtual Machine (PVM), and hides all low-level features of the latter. The language of NUTS is a concurrent object-oriented programming language with coarse- grained parallelism and distributed shared memory communication model imple- mented on

A Distributed Object-Oriented Language for Heterogeneous Computer Networks

1999

This paper presents an object-oriented distributed language, called CUBLqq, that is a powerful tool for developing distributed applications on heterogeneous computer networks. CUBLqq is based on objects, called c units, that communicate through synchronous and asynchronous message Ž . Ž . passing. A c unit is an active object composed of data state and procedures as traditional passive objects, together with the capability of queueing incoming messages, when needed. C units allow a programmer to implement an application on a heterogeneous architecture, as they communicate with each other without taking into account the physical characteristics of the actual node where they are located. We have experimented CUBLqq on a network where UNIX workstations, WindowsNT personal computers and transputers cooperate in order to perform a given task. In particular, this paper gives a brief description of a distributed system for image processing that has been implemented by using CUBLqq.