ARCADE: An Architectural Basis for Distributed Systems

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

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.

Oops Messenger, 1993

Modern computer hardware technology allows a single architecture to be used for a range of machines from supercomputers to toasters. Hardware designers have recognized that an architecture should be scalable and system software developers must address the same issue. Scalability means that the architecture must be flexible enough to satisfy diverse hardware and application needs. The key to operating system flexibility is to base the architecture on a high-level graph model and to use the generalized object model and metacomputing. The resulting framework is a uniform object model for application and system software. Classically, operating system flexibility means that the architecture must handle various processor capabilities, differing memory and disk sizes and a vast range of peripheral devices. Today, it also includes dealing with multiprocessor systems, diverse network topologies and multimedia input/output. In the future, as radio-based networking becomes common, changes will be dynamic, requiring the flexible operating system to adapt as elements of a distributed system move into and out of range. Different classes of applications have different requirements. The valuable data managed by an OODB must be maintained over long periods of time while a multimedia application requires guaranteed bandwidth. The necessary services and the relative emphasis on different functionalities vary drastically.

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.

Operating Systems Review, 1990

Many aspects of parallel software were discussed at the first USENIX/SERC Workshop on Distributed and Multiprocessor Systems, held October 5-6 in Fort Lauderdale, Florida. The workshop was sponsored by the USENIX Association and the Purdue/Florida Software Engineering Research Center (SERC). The IEEE-CS Technical Committees on Operating Systems (TCOS) and Distributed Computing (TCDC) and the ACM Special Interest Groups on Operating Systems (SIGOPS) and Software Engineering (SIGSOFT) were sponsors-incooperation. Gene Spafford of Purdue University was program chair and George Leach of AT&T Paradyne served as general chair. At the workshop, researchers from industry and academia presented 25 papers in eight sessions. The papers were selected through a refereeing process from over 50 submissions. In addition, a Work in Progress session featured six short reports and an informal session was organized to discuss topics raised in one of the early sessions. At the "Objects and Virtual Memory" session, Franz Kaashoek of Vrije Universiteit, Yousef Khalidi, formerly of Georgia Tech, and Gary Johnston of the University of Illinois reported on three research projects implementing shared virtual memory in a distributed environment. Their approaches differed in details, but the basic thrust of all three projects was to encapsulate data in objects and use those objects as the basic unit to be shared among machines. Although nobody disputed the results of these projects, there was a significant group of attendees who claimed that distributed shared memory was the wrong way to go. At a specially-organized rebuttal session that night (entitled "Distributed Memory Is Easy ... but Wrong"), those critics argued that such systems hid the cost of data sharing from the user, thus either encouraging inefficient programming or making performance tuning impossible. Several alternatives were offered, many of which were included in other workshop papers. The point was made by several speakers that the model of programming in a system should be tied closely to both the system architecture and to the application under consideration. By that standard, distributed memory was considered a definite advantage for some systems but less valuable for others.

New Trends in Industrial Automation [Working Title]

New age programming languages highlight the mobility of objects and on-the-fly communication mechanism even being available on nodes with intermittent connections. We are breathing in the era where the working framework enables the procedures to oversee imparted information and arrangement to a domain where distinctive procedures are executing on discrete frameworks that essentially makes use of message-based correspondence or mobile communication architecture. The highlight that has been conceived for the years has spawned the remote administration and remote access in distributed computing framework and was outlined as an approach to digest the strategy call component to use between frameworks associated through a system. These frameworks contains the stub and skeleton on client and server side respectively which behaves as remote proxies and deals with marshaling and unmarshalling of the incoming and outgoing data. This has incurred the need of more distributed and platform independent communication mechanisms, that can not only make intercalling of functions but also support features like platform independency from various object oriented based programming languages. The distinctions in the programming model prompt higher state of abilities and more implicit customer side mechanisms for simple and hands-on interaction with the code that actualizes and implements the distributed frameworks.

1993

CITATIONS 36 READS 23 4 AUTHORS, INCLUDING:

IEEE Transactions on Software Engineering, 1989

This paper presents a retrospective view of the Charlotte distributed operating system, a testbed for developing techniques and tools to solve computation-intensive problems with large-grain parallelism. The final version of Charlotte runs on the Crystal multicomputer, a collection of VAX-111750 computers connected by a local-area network. The kernellprocess interface is unique in its support for symmetric, bidirectional communication paths (called links), and synchronous nonblocking communication.

Proceedings of the 2000 ACM symposium on Applied computing - Volume 2, 2000

The Virtual Interface Architecture (VIA) has been recently introduced as a portable interface for high performance communication on system area networks (SAN). We show that it is difficult to use the VI Architecture directly as a building block for distributed, multithreaded runtime systems, and that an additional medium-level layer is needed to fill the gap with the applications. This layer should be carefully designed so as to preserve the definite qualities of VIA, and yet hide its low-level aspect to the user. As a case study, we present an implementation of our Madeleine programming interface for high performance networking on top of VIA, and we demonstrate the benefits of this approach through some preliminary experiments.

Parallel Computing, 1989

This paper presents a spe, cification-methodology for distributed computer architectures based on the axiomatic architecture description language AADL. AADL allows for a modular and concise specification of multiprocessor architectures at levels of abstraction ranging from compiler/operating-system interface down to chip-level. The specification method is illustrated by several examples taken from an AADL-definition of an abstract view of DOOM, a distributed object oriented machine, currently developed at Philips Research Laboratories, Eindhoven within ESPRIT-project 415.