In this paper we describe the design of a QoS driven communications stack in a microkernel operating system environment. The paper focuses on resource management aspects of the design and in particular we deal with CPU scheduling, network resource management and memory management issues. We describe an API at which QoS parameters are supplied by users and present an architecture able to guarantee these QoS requirements with varying degrees of commitment. The architecture includes modules to translate user level QoS parameters into representations usable by the scheduling, network and memory management subsystem. It also incorporates admission tests which determine whether or not a new connection can be accepted given a particular QoS requirement and resource availability. In addition to predictable resource allocation the architecture also incorporates dynamic QoS management which ensures that ongoing commitments continue to be met in the face of variable loading.

The ESPRIT project DiVAN (EP 24956) aims at the building of a distributed audio-visual library system for TV broadcasters and video archives owners. The DiVAN system provides facilities to effectively, digitize, annotate, organize, store and access raw material in a coherent content-based manner, on top of high-speed wide area communication networks. Also, the project aims to demonstrate and assess the applicability and acceptability of the proposed system, through field trials on a DiVAN-based infrastructure interconnecting the archives of the users of the partnership, i.e. INA, RAI, and ERT. The consortium consists of industrial partners (i.e. INTRACOM, TECMATH), research institutes (i.e. ICS-FORTH, INRIA, Tech. Un. of Darmstadt) and users (i.e. Institut National de l'Audiovisuel-INA, Radiotelevisione Italiana-RAI and Greek National Broadcaster-ERT).

Object-oriented mechanisms, such as classes and inher- itance, and concurrency mechanisms, such as threads and locks, provide two separate software structuring dimensions. The development of concurrent object- oriented software requires both dimensions to be taken into account simultaneously. Previous research has identified that substantial effort is required by program- mers to avoid clashes in structuring software along these separate dimensions. This has led to the design of con- current object-oriented programming models that inte- grate object-oriented features with concurrent execu- tion and synchronization, eliminating the need to con- sider two separate dimensions when developing concur- rent object-oriented software. Although several issues that have to be addressed by such programming models have been identified, there is no consent on a program- ming model that addresses all these issues simultane- ously. In addition, little experience has been gained from the use of proposals addressing these issues. We have used Python to prototype and experiment with the use of a novel concurrent object-oriented programming model called ATOM. In this paper we present the model's main features and illustrate their use for concurrent program- ming in Python. We also provide information on a free prototype implementation of the model. Taking advan- tage of Python's extensibility we were able to prototype the model without undergoing a lengthy development ef- fort and with no need to change the Python language or its interpreter.

Aspect oriented programming (AOP) is a recent programming paradigm where programmers express and reason separately about the different concerns that affect the basic object behavior. Although it has been successfully applied to deal with concerns such as synchronization and real-time in the area of object-oriented concurrent and real-time programming, the coordination aspect presents more difficulties than may appear at first glance because multi-object coordination involves synchronized interaction among several active objects. Consequently, the coordination algorithm is spread among sets of objects making them more difficult not only to extend and reuse but also to reason about the coordination algorithm by itself. In this position paper we propose several question about how AOP can deal with the coordination aspect. We present two modeling problems related with this aspect to be discussed during this workshop and we provide a solution in order to cope with this issue. Our solution relies on the novel concept of state notification. State notification makes use of abstract state information and it provides a higher level of abstraction for the specification of object coordination than the interception of messages.

r esum e. abstract. Early research and experience in the area of Concurrent Object-Oriented Programming (COOP) has demonstrated diiculties in integrating concurrency and object-oriented features, and more particularly inheritance. Since then, most research has focused on support for inheritance and the speciication and reuse of synchronization constraints on message acceptance. Although there have been several promising proposals for coping with this issue they are based on oversimpliied models of COOP. Such models fail to provide adequate expressive power for coping with other issues such as intra-object concurrency and providing exibility for processing messages. We present a novel COOP model, ATOM, designed to address simultaneously the issues of expressive power, reuse through inheritance and object coordination and concentrate in showing how this model supports inheritance inheritance without sacriicing expressive power.

Substantial research activity in the past few years concentrated on the design of languages and models for integrating concurrency and object-oriented features with the intention to enhance the potential for software reuse in the development of concurrent systems. Most of the work in the area has focused on the problem of specifying and reusing through inheritance synchronization constraints on the invocation of object methods. Currently, this is a widely recognized problem and several approaches have been proposed. More recent and far fewer research has addressed the issue of coordinating the execution of several objects and specifying and reusing coordination algorithms among objects. However, most proposals have addressed these problems in isolation. Furthermore, few languages supporting the proposed features are widely available and relatively little experience has been gained from their use. In this paper we present an active object model that aims at a more comprehensive approach in integrating concurrent programming and objectoriented features. The model incorporates a number of previously proposed features with the novel features of abstract states , state predicates and state notification . Its features address the problems for integrating concurrency and object-oriented programming identified by previous research as well as other problems that we discuss in the paper. In addition, a prototype of our model has been implemented in the programming language Python which is freely available and runs on a large number of systems. This will allow us and other researchers to gain more experience with concurrent object-oriented features and their support for software reuse through its use for the development of concurrent applications.

The integration of concurrent and object-oriented programming, although promising, presents problems that have not yet been fully explored. In this paper we attempt to identify issues in the design of concurrent object-oriented languages that must be addressed to achieve a satisfactory integration of concurrency in the object-oriented framework. We consider the approaches followed by object-oriented languages for supporting concurrency and identify six categories of concurrent object-oriented languages. Then, we review several concurrent object-oriented languages and examine the interaction of their concurrency features with their object-oriented features and with object-oriented software construction.

There is currently considerable interest in developing multimedia applications in open distributed systems. However, it is now becoming clear that existing architectures for open distributed systems do not support the particular requirements of continuous media types such as digital audio and video. This is particularly the case in the important areas of quality of service support and real-time synchronization. This paper presents results from the Sumo project which aims at supporting continuous media types within the framework defined by the draft Open Distributed Processing standard. The paper advocates the use of synchronous languages within this framework for specifying and implementing real-time synchronization and QoS monitoring. A computational model and the realization of an infrastructure supporting this view are presented.

An essential motivation behind concurrent object-oriented programming is to exploit the software reuse potential of object-oriented features in the development of concurrent systems. Early attempts to introduce concurrency to object-oriented languages uncovered interferences between object-oriented and concurrency features that limited the extent to which the benefits of object-oriented programming could be realized for developing concurrent systems. This has fostered considerable research into languages and approaches aiming at a graceful integration of object-oriented and concurrent programming. We will examine the issues underlying concurrent object-oriented programming, examine and compare how different approaches for language design address these issues. Although it is not our intention to make an exhaustive survey of concurrent object-oriented languages, we provide a broad coverage of the research in the area.

We describe the design of an application platform able to run distributed real-time and multimedia applications alongside conventional UNIX programs. The platform is embedded in a micro-kernel/ PC environment and supported by an ATM based, QoS driven communications stack. We focus in particular on resource management aspects of the design and deal with CPU scheduling, network resource management and memory management issues. An architecture is presented which guarantees QoS levels of both communications and processing with varying degrees of commitment as specified by user level QoS parameters. The architecture uses admission tests to determine whether or not new activities can be accepted and includes modules to translate user level QoS parameters into representations usable by the scheduling, network and memory management subsystems.

Article Free Access Share on Video widgets and video actors Authors: Simon Gibbs Centre Universitaire d'Informatique, Université de Genève, 24 rue Général-Dufour, CH-1211 Genève 4, Switzerland Centre Universitaire d'Informatique, Université de Genève, 24 rue Général-Dufour, CH-1211 Genève 4, SwitzerlandView Profile , Christian Breiteneder Centre Universitaire d'Informatique, Université de Genève, 24 rue Général-Dufour, CH-1211 Genève 4, Switzerland Centre Universitaire d'Informatique, Université de Genève, 24 rue Général-Dufour, CH-1211 Genève 4, SwitzerlandView Profile , Vicki de Mey Centre Universitaire d'Informatique, Université de Genève, 24 rue Général-Dufour, CH-1211 Genève 4, Switzerland Centre Universitaire d'Informatique, Université de Genève, 24 rue Général-Dufour, CH-1211 Genève 4, SwitzerlandSearch about this author , Michael Papathomas Centre Universitaire d'Informatique, Université de Genève, 24 rue Général-Dufour, CH-1211 Genève 4, Switzerland Centre Universitaire d'Informatique, Université de Genève, 24 rue Général-Dufour, CH-1211 Genève 4, SwitzerlandView Profile Authors Info & Claims UIST '93: Proceedings of the 6th annual ACM symposium on User interface software and technologyDecember 1993Pages 179–185https://doi.org/10.1145/168642.168660Published:01 December 1993Publication History 18citation417DownloadsMetricsTotal Citations18Total Downloads417Last 12 Months29Last 6 weeks4 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Specification of behaviour A test in a suitable language could be used as a way to abstractly specify the behaviour of an object. Although most experiments could eventually be expressed as a CCS experimenter interacting with the agent representing the behaviour of a class, a higher level language would be desirable. In order to be useful a test language should subsume high level features such as algebraic specifications of ADT. Also modal logic formulas may provide a more compact and clear way to specify allowed execution sequences than the CCS agents that implement the test. 5 Conclusions and Future Work We have argued that for effectively taking advantage of the potential of COOPLs for reusing concurrent software it is essential to have a precise understanding of compatibility of the behaviours expressed by class definitions. For investigating these issues we proposed to use a model of object behaviour based on process calculus and examined how to take advantage of related work on behavioural equivalence and specification of concurrent systems based on process calculi. In order to use the work on process calculi, we need models for the description of the behaviour of classes that capture more aspects that are of importance to object-oriented programming such as method execution, passing arguments and comparing operation results passed both on the equality of object identifiers and behavioural compatibility. We have discussed some aspects of object-oriented programming that should be captured by models of object behaviour and behaviour compatibility notions. We suggested that a testing methodology appears to be appealing for the further investigation of these aspects. This approach provides both a conceptual framework and a setting for further formal investigation of behavioural compatibility issues.

A key property of object-oriented languages is that they promote software reuse through inter-changeability or plug compatibility of software components that conform to the same message-passing interface. A characterization of such an interface is a type, and can be viewed as a constraint on the behaviour of an object. An object that conforms to the type meets the constraint. A subtype, in this view, is simply a stronger constraint: all objects that conform to a subtype also conform to the supertype. The nature of these constraints may vary, however, as may the rules for determining when one type is a subtype of another. The choice of characterization will depend on the computational model of a particular language and the way in which objects interact. We seek to develop a notion of type that will serve to characterize concurrent, active objects whose behaviour may not conform to a strict client/server model of interaction and communication.

The design of programming languages that cleanly integrate concurrency constructs and objectoriented features that promote software reuse is an open problem. We describe a design space that characterizes approaches to object-oriented concurrency in terms of a number of language design choices concerning the relationship between objects and concurrency. We identify requirements for software reuse and, with the help of an example that illustrates several of these requirements, explore the design space in order to evaluate which design choices interfere with reuse and which appear to adequately support it. We conclude by highlighting open research issues which, we believe, are essential for achieving effective reuse of concurrent software.

In this paper we address the effective use of the object-oriented programming approach for concurrentprogramming from a language design viewpoint. We present a set of requirements for thedesign of concurrent object-oriented languages. We then use a particular language, Hybrid, as aconcrete example and examine to what extent its features meet these requirements. We identifythe solutions offered by Hybrid and its shortcomings and we underline both the difficulties andpromising directions for ...

This paper is a report on a prototype implementation of Hybrid, a strongly-typed, concurrent, object-oriented language. The implementation we describe features a compile-time system for translating Hybrid object type definitions into C, a run-time system for supporting communication, concurrency and object persistence, and a type manager that mediates between the two.