Results 1 - 10
of
13
Aspects of Synchronisation
, 1997
"... Aspect oriented programming promotes the separation of the different aspects of a system into their natural form, and synchronisation is an important aspect of concurrent object oriented systems. Treating synchronisation as a single monolithic aspect leads to inflexibility and limited possibiliti ..."
Abstract
-
Cited by 8 (5 self)
- Add to MetaCart
Aspect oriented programming promotes the separation of the different aspects of a system into their natural form, and synchronisation is an important aspect of concurrent object oriented systems. Treating synchronisation as a single monolithic aspect leads to inflexibility and limited possibilities for reuse. We suggest that synchronisation has a number of different aspects, and introduce the `synchronisation rings' model which allows the aspects of a synchronised object to be specified independently. By separating the different aspects of synchronisation we can provide flexible, generic implementations of common synchronisation constraints, which can be re-used in many different contexts.
Concurrency Annotations in C++
, 1994
"... This paper describes CA/C++, Concurrency Annotations in C++, a language extension that regulates method invocations from multiple threads of execution in a shared-memory multiprocessor system. This system provides threads as an orthogonal element to the language, allowing them to travel through mor ..."
Abstract
-
Cited by 5 (2 self)
- Add to MetaCart
(Show Context)
This paper describes CA/C++, Concurrency Annotations in C++, a language extension that regulates method invocations from multiple threads of execution in a shared-memory multiprocessor system. This system provides threads as an orthogonal element to the language, allowing them to travel through more than one object. Statically type-ckecked synchronous and asynchronous method invocations are supported, with return values from asynchronous invocations accessed through first class future-like objects. Method invocations are regulated with synchronization code defined in a separate class hierarchy, allowing separate definition and inheritance of synchronization mechanisms. Each method is protected by an access flag that can be switched in pre and post-actions, and by a predicate. Both must evaluate to true in order to enable a thread to animate the method code. Flags and method predicates are independently redefinable along the inheritance chain, thus avoiding the inheritance anomaly. ...
Synchronisation Rings -- Composable Synchronisation for Object-Oriented Systems
- HUM. BRAIN MAPP
, 1999
"... The integration of concurrent and object-oriented programming has been a challenge for over two decades. In this thesis we explore synchronisation in concurrent object-oriented programming and present a clear perspective on the problems in terms of five aspects of synchronisation: exclusion, state ..."
Abstract
-
Cited by 3 (0 self)
- Add to MetaCart
The integration of concurrent and object-oriented programming has been a challenge for over two decades. In this thesis we explore synchronisation in concurrent object-oriented programming and present a clear perspective on the problems in terms of five aspects of synchronisation: exclusion, state, coordination, response and scheduling. These aspects show synchronisation as the multi-faceted concern that it is, rather than the monolithic concern it is normally presented as. For each aspect we identify a set of goals that a concurrent object-oriented programming system should meet for effective support of synchronisation, and for the reuse of synchronisation and functional code. We present the Synchronisation Rings model, a compositional approach to enforcing synchronisation constraints that layers synchronisation controls around a functional core. This composition of different layers of synchronisation control maps neatly onto the different aspects of synchronisation. Using this app...
Parallelism in mupad
- In Electronic Proceedings of the 1st International IMACS Conference on Applications of Computer Algebra
, 1995
"... ..."
(Show Context)
Support for Extensibility and Reusability in a Concurrent Object-Oriented Programming Language
- In Proceedings of the International Parallel Processing Symposium
, 1996
"... In many concurrent programming languages programs are difficult to extend and modify. This is because changes in a concurrent program (either through modification or extension) require re-implementation of some or all components. This paper presents the design of a concurrent object-oriented program ..."
Abstract
-
Cited by 2 (1 self)
- Add to MetaCart
(Show Context)
In many concurrent programming languages programs are difficult to extend and modify. This is because changes in a concurrent program (either through modification or extension) require re-implementation of some or all components. This paper presents the design of a concurrent object-oriented programming language based upon separate specifications of computations and interactions of programs. Separate specification of computations and interactions allows each to be separately modified and extended. We show that separation also facilitates extension of other language composition mechanisms such as class, inheritance, and template in order to define concurrent program abstractions. The resulting language supports extensibility and modifiability of concurrent programs as well as reusability of specifications of computations and interactions. 1
A Prototype-based Approach to Distributed Applications
, 2004
"... With the advent of ever cheaper, more stable and more powerful mobile devices and their integration via wireless networks, a new branch of applications is emerging. The construction of such mobile, flexible and distributed applications place an enormous burden of complexity on the programmer’s shoul ..."
Abstract
-
Cited by 2 (1 self)
- Add to MetaCart
With the advent of ever cheaper, more stable and more powerful mobile devices and their integration via wireless networks, a new branch of applications is emerging. The construction of such mobile, flexible and distributed applications place an enormous burden of complexity on the programmer’s shoulders. To keep such software maintainable and robust, the programming language in which it is written should introduce the necessary abstractions to master this complexity. Most of the contemporary programming languages fail in providing the necessary language constructs. These languages fall short in their task of making it feasible to create such extensible applications that run in an open, dynamically determined distributed topology. This dissertation proposes an object-oriented distributed programming language which allows objects to be structured in a flexible and distributed way. The language is prototype-based yielding a more flexible programming medium than its class-based alternatives. The proposed language, called dPico, allows for software to be structured by applying the principle of inheritance in prototype-based
Support for Implementation of Evolutionary Concurrent Systems in Concurrent Programming Languages
- International Journal of Parallel Programming
, 2001
"... . In many concurrent programming languages, concurrent programs are difficult to extend and modify: small changes in a concurrent program may require re-implementations of a large number of its components. In this paper a novel concurrent program composition mechanism is presented in which implement ..."
Abstract
-
Cited by 1 (0 self)
- Add to MetaCart
. In many concurrent programming languages, concurrent programs are difficult to extend and modify: small changes in a concurrent program may require re-implementations of a large number of its components. In this paper a novel concurrent program composition mechanism is presented in which implementations of computations and synchronizations are completely separated. Separation of implementations facilitates extensions and modifications of programs by allowing one to change implementations of both computations and synchronizations. The paper also describes a concurrent programming model and a programming language that support the proposed approach. 1 Introduction Complex software systems are evolutionary in general. They change during the initial development stage, and often after they have been deployed. These changes may occur due to changes in the requirements, in the hardware configuration, and/or in the execution environment. Programming languages must support methodologies that ...
Improving Polymorphism and Concurrency in Common Object Models
, 1998
"... Most common object models of distributed object systems have a limited set of object-oriented features, lacking the advanced features of ‘polymorphism ’ (an abstrac-tion mechanism that represents a quality or state of being able to assume different forms) and ‘concurrency ’ (the ability to have more ..."
Abstract
- Add to MetaCart
(Show Context)
Most common object models of distributed object systems have a limited set of object-oriented features, lacking the advanced features of ‘polymorphism ’ (an abstrac-tion mechanism that represents a quality or state of being able to assume different forms) and ‘concurrency ’ (the ability to have more than one thread of execution in an object simultaneously). The lack of support for advanced features is a serious limitation because it restricts the development of new components and limits reuse of existing of components that use these advanced features. As a result, wrappers must be used that hide the advanced features or components must be re-implemented using only the features of the common object model. In this dissertation, a new direction of research centered on a subset of object-oriented languages, specifically statically typed languages, is considered. One of the major drawbacks of existing distributed object systems is that they cater to a broad domain of programming languages including both object-oriented as well as non object-oriented languages. Mapping an object model into a non object-oriented language is a complex task and it does not appear natural to a native language user.
Effective Synchronisation of Concurrent Objects: Laying the Inheritance Anomaly to Rest
, 1998
"... The integration of concurrency and object-oriented programming has been a goal of researchers for over a decade. To date, attempts to address reuse conflicts, known as "inheritance anomalies", have been limited in applicability and have not addressed all the issues that synchronisation rai ..."
Abstract
- Add to MetaCart
(Show Context)
The integration of concurrency and object-oriented programming has been a goal of researchers for over a decade. To date, attempts to address reuse conflicts, known as "inheritance anomalies", have been limited in applicability and have not addressed all the issues that synchronisation raises. In this paper we take a detailed look at synchronisation by investigating five different aspects which must be considered. We investigate the different forms of the inheritance anomaly which can arise and look at how they can be avoided, either through the use of specific features of concurrent object-oriented languages, or common techniques of object-oriented programming. Finally we present a set of requirements for a concurrent object-oriented language to support a flexible concurrency model with an emphasis on the reuse of both synchronisation and functional code. 1. Introduction Objects and concurrency started off together back in the late sixties with Simula [Dah70], but they tended to go ...
