2008
This article evaluates several possible approaches for integrating concurrency into object-oriented programming languages, presenting afterwards, a new language named MP-Eiffel. MP-Eiffel was designed attempting to include all the essential properties of both concurrent and object-oriented programming with simplicity and safety. A special care was taken to achieve the orthogonality of all the language mechanisms, allowing their joint use without unsafe side-effects (such as inheritance anomalies). 1
Cited by 0
Karamcheti, Chien · 1993
Inefficient implementations of global namespaces, message passing, and thread scheduling on stock multicomputers have prevented concurrent object-oriented programming (COOP) languages from gaining widespread acceptance. Recognizing that the architectures of stock multicomputers impose a hierarchy of costs for these operations, the authors describe a runtime system which provides different versions of each primitive, exposing performance distinctions for optimization. They confirm the advantages of a cost-hierarchy based runtime system organization by showing a variation of two orders of magnitude in version costs for a CM5 implementation. Frequency measurements based on COOP application programs demonstrate that a 39% invocation cost reduction is feasible by simply selecting cheaper versions of runtime operations.
Cited by 3
Andrew A. Chien, Vijay Karamcheti, John Plevyak et al. · 9th Computing in Aerospace Conference · 1993
Concurrent object-oriented languages, particularly fine-grained approaches, reduce the difficulty of large scale concurrent programming by providing modularity through encapsulation while exposing large degrees of concurrency. Despite these programmability advantages, such languages have historically suffered from poor efficiency. This paper describes the Concert project whose goal is to develop portable, efficient implementations of fine-grained concurrent object-oriented languages. Our approach incorporates aggressive program analysis and program transformation with careful information management at every stage from the compiler to the runtime system. The paper discusses the basic elements of the Concert approach along with a description of the potential payoffs. Initial performance results and specific plans for system development are also detailed.
Cited by 10
R. Greg Lavender, Dennis G. Kafura · 2008
A "future" is a typed synchronization mechanism used to represent avalue that will come into existence at some point in time after the creation of the future. In this paper, a polymorphic future type is introduced that differs from previous mechanisms in that it provides a first-class, extensible facility for expressing synchronized access to the typed result value of a concurrent computation. The proposed mechanism requires write-once/read-many synchronization, which is implemented in terms of common thread synchronization primitives, thereby ensuring a high-degree of efficiency. The type definition and type specialization features of C++ are used to illustrate how one would implement a polymorphic future type in a strongly typed object-oriented language supporting polymorphic type definitions.
Cited by 0
Richard Banach, George Α. Papadopoulos · 2002
The usefulness of the generalised computational model of Term Graph Rewriting Systems (TGRS) for designing and implementing concurrent object-oriented languages, and also for specifying and reasoning about the interaction between concurrency and object-orientation (such as concurrent synchronisation of methods or interference problems between concurrency and inheritance), is examined in this paper by mapping a state-of-the-art functional object-oriented language onto the MONSTR computational model, a restricted form of TGRS specifically designed to act as a point of reference in the design and implementation of declarative and semi-declarative programming languages especially suited for distributed architectures.
Cited by 3
Masahiro Yasugi, Masahiro Yasugi · 1994
With recent developments of highly parallel computers, practical methods for developing programs on such machines become urgent. In this study, we regard our practical concurrent object-oriented programming language as a basic language for highly parallel machines and pursue necessary software approaches to achieving high performance by implementing the language system and developing application programs /parallel algorithms. As for the language system, we propose a language design suitable for parallel execution and implementation schemes that achieve high performance. Our implementation target is a fine-grained data-driven parallel computer, EM-4, developed at Electrotechnical Laboratories. We present and discuss the design of our runtime architecture and optimizing compiler, including reactive representations of objects, efficient management of message buffers with freelists, interruptible pipelined message sends, plan-do style intermediate code, an efficient implementation scheme f...
Cited by 0
Alexei A. Morozov, Abhishek Vaish, Alexander F. Polupanov et al. · Communications in computer and information science · 2015
Cited by 17
Microsoft Research · Bulletin of Miscellaneous Information (Royal Gardens Kew) · 2005
Cited by 0
Naoki Kobayashi, Akinori Yonezawa · ACM SIGPLAN Notices · 1994
A number of attempts have been made to obtain type systems for object-oriented programming. The view that lies common is “ object-oriented programming = λ-calculus + record .” Based on an analogous view “ concurrent object-oriented programming = concurrent calculus + record ,” we develop a static type system for concurrent object-oriented programming. We choose our own Higher-Order ACL as a basic concurrent calculus, and show that a concurrent object-oriented language can be easily encoded in the Higher-Order ACL extended with record operations. Since Higher-Order ACL has a strong type system with a polymorphic type inference mechanism, programs of the concurrent object-oriented language can be automatically type-checked by the encoding in Higher-Order ACL. Our approach can give clear accounts for complex mechanisms such as inheritance and method overriding within a simple framework.
Cited by 13
Papathomas, Michael · Archive ouverte UNIGE (University of Geneva) · 1989
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. 1 Introduction Object-oriented programming and object-oriented programming languages (OOPLs) are becoming increasingly popular for the construction of computer software. OOPLs integrate a host of techniques that have proven useful for the development and maintenance of software and that...
Cited by 6Open access
Wellings, Andy J., Brian K. Johnson, Bo I. Sandén et al. · 2000
4 Integrating concurrent and object-oriented programming has been an 5 active research topic since the late 1980s. There is now a plethora of 6 methods for achieving this integration. The majority of approaches have 7 taken a sequential object-oriented language and made it concurrent. A few 8 approaches have taken a concurrent language and made it object-oriented. 9 The most important of this latter class is the Ada 95 language which is 10 an extension to the object-based concurrent programming language Ada 11 83. 12 Arguably, Ada 95 does not fully integrate its models of concurrency 13 and object-oriented programming. For example, neither tasks nor pro- 14 tected objects are extensible. This paper discusses ways in which pro- 15 tected objects can be made more extensible. 16 Keywords: concurrent object-oriented programming, inheritance ano- 17 maly, Ada 95. 18 This paper extends and unifies the approaches described in (Kiddle and Wellings, 1998) and (Michell and Lundqvist, to appear)....
Cited by 0
Using Smalltalk, Trevor P. Hopkins, Mario I. Wolczko · 1989
This paper considers a number of ways in which concurrent programs may be expressed within an object-oriented framework. It goes on to describe work investigating the expression of highly parallel programs in a conventional object-oriented language (Smalltalk-80). The relevance of this work to a new parallel object-oriented system is discussed. An implementation of an ‘eager ’ evaluator is described, together with a ‘throttling ’ mechanism capable of limiting the generation of concurrent processes. A system for suspending all processes performing a parallel computation is discussed. Finally, further work in investigating debugging environments for concurrent objectoriented systems is outlined. Concurrent Object-Oriented Systems There has been an increasing interest in recent years in what is called object-oriented programming, accompanied by a diversification of opinion. There seems to be little agreement about what is meant by the term ‘object’, or whether a particular programming language or programming style is truly ‘object-oriented’. There has also been an increased interest in using object-oriented programming techniques as the basis for expressing concurrent solutions to a wide range of problems, with the aim of harnessing highly parallel computers [YT87b]. Object-Oriented Programming Some general principles about object-oriented programming can be observed. At least some of the computation is expressed in terms of objects sending messages from one to another. Objects encapsulate some ‘state ’ or a ‘data structure’, together with the only available mechanisms for
Cited by 0
Andy Wellings, B. B. Johnson, Bo I. Sandén et al. · ACM Transactions on Programming Languages and Systems · 2000
Integrating concurrent and object-oriented programming has been an active research topic since the late 1980's. There is a now a plethora of methods for achieving this integration. The majority of approaches have taken a sequential object-oriented language and made it concurrent. A few approaches have taken a concurrent language and made it object-oriented. The most important of this latter class is the Ada 95 language, which is an extension to the object-based concurrent programming language Ada 83. Arguably, Ada 95 does not fully integrate its models of concurrency and object-oriented programming. For example, neither tasks nor protected objects are extensible. This article discusses ways in which protected objects can be made more extensible.
Cited by 16Open access
Hideaki Okamura, Mario Tokoro · 2007
ConcurrentSmalltalk-90 is the concurrent object oriented programming language, which supports sufficiently the facilities of meta-level programming with meta objects. CST90 succeeds the features of the concurrent programming of ConcurrentSmalltalk. Its specification for meta-level programming is changed and improved. CST90 introduces the feature of meta-level programming from Orient84/K. The implementation of CST90 is done without changing Virtual Machine(VM) of Smalltalk-80, in order to realize high portability and high extensibility. Thus, it is achieved on Virtual Image of Smalltalk-80. 1 Introduction Recently, concurrent programming become more important. Object-oriented programming has proved to be effective, as it is highly productive, reliable, easily maintained, and is suitable for creating concurrent programming efficiently. Among object-oriented programming languages, Smalltalk80 [Goldberg 83] is the most complete one. However, Smalltalk-80 does not consider concurrent prog...
Cited by 0
Bishwaroop Ganguly · 1998
With the recent development of large-scaled shared memory machines, it is clear that programming environments must be developed to harness the functionality of the underlying hardware of such machines. We believe that a dynamic model of parallelism is well suited to utilize hardware cache-coherent architecture. We have ported the Illinois Concert System, a dynamic multi-threaded object oriented programming system, to the SGI-Cray Origin 2000 CC-NUMA architecture. In this work, we demonstrate the use of this dynamic multi-threaded execution model to get high-performance on an important class of applications, namely Structured Adaptive Mesh Refinement Methods. We have developed an SAMR application, and run it on the Origin system, using the Illinois Concert system. The results have been promising, with good speedups up to 32 processors on the system. Our results demonstrate that a large-scale irregular code such as SAMR can be parallelized well on large-scale shared memory machines usin...
Cited by 0
Joana Campos, Vasco T. Vasconcelos · 2016
There is often a sort of a protocol associated to each class, stating when and how certain methods should be called. Given that this protocol is, if at all, described in the documentation accompanying the class, current mainstream object-oriented languages cannot provide for the verification of client code adherence against the sought class behaviour. We have defined a class-based concurrent object-oriented language that formalises such protocols in the form of usage types. Usage types are attached to class definitions, allowing for the specification of (1) the available methods, (2) the tests clients must perform on the result of methods, and (3) the object status — linear or shared — all of which depend on the object’s state. Our work extends the recent approach on modular session types by eliminating channel operations, and defining the method call as the single communication primitive in both sequential and concurrent settings. In contrast to previous works, we define a single category for objects, instead of distinct categories for linear and for shared objects, and let linear objects evolve into shared ones. We introduce a standard sync qualifier to prevent thread interference in certain operations on shared objects. We formalise the language syntax, the operational semantics, and a type system that enforces by static typing that methods are called only when available, and by a single client if so specified in the usage type. We illustrate the language via a complete example. 1
Cited by 0
Yokote, Yasuhiko
This book focuses on object-oriented concurrent computing, which can be considered a model of concurrent programming, and proposes a new programming language, ConcurrentSmalltalk, which is based on object-oriented concurrent computing. The book also shows the efficiency of object-oriented concurrent computing through the design, implementation, and evaluation of ConcurrentSmalltalk. ConcurrentSmalltalk is designed to be upwardly compatible with Smalltalk-80. In the book, the ConcurrentSmalltalk object model is first proposed. Next, issues which arise from maintaining compatibility with Smalltalk-80 are discussed. Finally, the ConcurrentSmalltalk virtual machine which executes the ConcurrentSmalltalk programs is proposed
Cited by 0
Qian Zhang, Weihua Li, Chen Shi-hong · 2002
Research in concurrent object-oriented programming languages has suffered from the lack of a widely accepted formal foundation for describing the semantics of concurrent object systems. Based on the /spl pi/-calculus and the actor model respectively, people have tried to define a common semantic framework for concurrent object-oriented programming. In this paper, we try to compromise these two approaches. We define a formalism that enjoys a clean formal definition which allows the reuse of standard results of the theory of concurrency while preserving a high-level object-oriented programming style. We propose an actor algebra and a concurrent object calculus, and then we give the translation relationship between the two.
Cited by 0
Smolka, G., Henz, M., Wuertz, J. et al. · OpenGrey (Institut de l'Information Scientifique et Technique) · 1996
The report describes the O_z Programming Model (OPM), which has been developed together with the concurrent high-level programming language O_z. OPM is an extension of the basic concurrent constraint model, adding first-class procedures and stateful data structures. OPM is a concurrent programming model that subsumes high-order functional and object-oriented programming especially suited for concurrent object-oriented programming, for which no comprehensive formal model existed until now. There is a conservative extension of OPM providing the problem-solving capabilities of constraint logic programming. The resulting problem solvers appear as concurrent agents encapsulating search and speculative computation with constraints. (WEN)
Cited by 0
Arthur Peters, David Kitchin, John A. Thywissen et al. · 2016
The majority of modern programming languages provide concurrency and object-orientation in some form. However, object-oriented concurrency remains cumbersome in many situations. We introduce the language OrcO, Orc with concurrent Objects, which enables a flexible style of concurrent object-oriented programming. OrcO extends the Orc programming language by adding abstractions for programming-in-the-large; namely objects, classes, and inheritance. OrcO objects are designed to be orthogonal to concurrency, allowing the concurrent structure and object structure of a program to evolve independently. This paper describes OrcO's goals and design and provides examples of how OrcO can be used to deftly handle events, object management, and object composition.
Cited by 5