• Home
  • Search
  • Rosette: An object-oriented concurrent systems architecture
  • Cite Icon20
  • https://doi.org/10.1145/67387.67410Copy DOI Icon

Rosette: An object-oriented concurrent systems architecture

Show More
  • Abstract
  • Literature Map
  • References
  • Citations
  • Similar Papers
Abstract

A number of concurrent computers have been designed, such as [Ametek 1988] and [NCUBE 1986]. Taking advantage of concurrency on these computers will require new languages, operating systems, and environments to support the programming, monitoring and control of applications. The Rosette project at MCC is developing a system architecture for general-purpose concurrent computation based on the Actor model [Agha 1986]. The aim of the Rosette architecture is to support the use of concurrent computers in solving computationally intensive problems whose structure is not statically determined. The architecture will support variable grain size, dynamic resource management, reflection, and heterogeneity. A number of concurrent language proposals have employed computational models that are limited in their applicability because of assumptions such as granularity of concurrency, static process topology, or inherent communications cost. Others, for example, functional programming, cannot be used to model shared, modifiable objects. The Actor model addresses these issues directly. However, the difficulties of using concurrent computers cannot be addressed solely through programming languages. Traditional operating systems treat each process as an independent entity for the purposes of resource management (i.e., for the run-time allocation of processor, storage, and communication resources.) In the context of concurrent applications, effective operation on a concurrent computer requires that communities of processes be managed together, taking into account the ways in which they interact, and providing for the application itself to guide resource management. For example, consider that programming systems often provide only limited support for the control of resource consumption in search problems in the face of combinatorial explosion; further, it is generally recognized that to optimize search performance, it is useful to vary the resources provided depending on how promising intermediate results of a given path are judged to be. The Rosette architecture will allow the programmer to integrate high-level algorithms within the application for dividing resources dynamically among the sub-computations that are spawned. These algorithms will provide an assessment of the progress of the sub-computations, and will be used to make the large number of low-level resource management decisions that are necessary in carrying out the computation. Thus, operating system functionality will be folded into the application. The Rosette architecture has two major components: an interface layer and a system environment . The interface layer provides mechanisms for the monitoring and control of concurrent applications. It supports a uniform view of the system resources and applications through the use of actors and message-passing semantics. The interface layer includes a set of actors that represent the processing, storage and communication resources across the hardware base. The system environment contains actor communities which implement resource management policies , and support for programming concurrent applications. The environment consists of an extensible set of actors that are organized via a class-based object model. These actors provide monitoring, debugging, resource management system simulation, and compilation/transformation facilities. To demonstrate the effectiveness of the Rosette architecture, as well as to drive its development, two classes of applications are being used. The first class is the Rosette system itself: all of the system components necessary for resource management, monitoring, debugging, and program development are being constructed in the Rosette language and will take full advantage of both concurrency and object-oriented programming support. The second category of applications is chosen to be somewhat independent of the Rosette system so as to ensure adequate feed-back concerning applicability to domains other than software engineering. These applications are in the general area of knowledge-based signal interpretation. The Rosette architecture is implemented via a concurrent object-oriented programming language that provides the following features: Inherent concurrency : A declarative approach is needed which allows fine-grained concurrency to arise naturally from the program. If the programmer is forced to express all of the details of the concurrent execution of an application, it becomes difficult to re-map a given program to different concurrent computers which have varying concurrency characteristics. Dynamic creation/modification of objects : This allows the system to be extensible and reconfigurable. Sharing : The language should support mechanisms such as inheritance so that code, structure, and values need not be replicated. Classes : Objects can be organized into classes to permit more effective management of resources, as for example in a very large database. Classes should be first-class objects and hence it should be possible to create classes dynamically. The Rosette language is a high-level language that is translated into a base language that directly expresses concurrent computations in terms of the semantics of the Actor model. The Rosette language extends the base language with data abstraction facilities and a library of classes, and is used to implement the non-built-in actors of the interface layer, components of the system environment, and applications. Using data abstraction extensions to the base language, the Rosette language organizes actors into classes according to common sets of behaviors and local state. Inheritance is used as a means of sharing code and structure that is common among classes. There is considerable evidence, for example [LaLonde 1986] and [Snyder 1987], that a robust class system should support separate hierarchies that represent what is modeled by a class and how some class of objects are actually implemented. Our approach is to use three different kinds of classes to organize the various kinds of actors in a system and information about these actors: abstract classes specify observable requests, responses, and actions; representation classes specify resource management characteristics of implementations; and behavior classes contain the actual implementations. Associated with an abstract class is the set of representations that are available to implement the particular abstraction. Each representation is associated with the behavior class that contains the corresponding implementation. The power of this separation is that each of the three kinds of class may be related to others in a class hierarchy. This means that the relationships between abstract classes are not forced to have the same structure as the relationships among implementations. Sharing via inheritance among behavior classes is related to engineering concerns; relations among abstract classes are dictated by external/observable behavior. As an example, an abstract class might specify the operations available over real-matrices . There are several ways of representing a matrix as a community of actors, and each of these would be specified with appropriate representation and behavior classes. There is a well-defined abstract hierarchy of matrices such as invertible, positive , etc. These abstract kinds of matrices are independent of the various implementations, which may be chosen according to application and hardware resource constraints. The Rosette language embodies a reflective model of the interface layer that is similar to that used in ABCL/R, [Watanabe and Yonezawa 1988]. This model is t

Similar Papers
  • Research Article
  • Citations12

The design and implementation of a concurrent circuit simulation program for multicomputers

  • Jul 01, 1993
  • IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
  • L Peterson +1
  • Book Chapter
  • Citations1

Concurrent Computer and Human Information Processing

  • Jan 01, 1987
  • H. L. Resnikoff
  • Conference Article
  • Citations18

A concurrent computer architecture and a ring based implementation

  • Jan 01, 1979
  • Edward P Farrell +2
  • Book Chapter
  • Citations17

Supporting multiparadigm programming on actor architectures

  • Jan 01, 1989
  • Gul Agha
  • Research Article
  • Citations4

Improving the Performance of Actors on Multi-cores with Parallel Patterns

  • Jun 04, 2020
  • International Journal of Parallel Programming
  • Luca Rinaldi +4
  • Research Article
  • Citations14

Evaluating the impact of internet communication quality in human resource management on the productivity of construction projects

  • Mar 26, 2024
  • Heliyon
  • Khaldoon Faris Qani Al-Aloosy +2
  • Research Article
  • Citations15

Enabling time‐based strategy through logistics ‐ using time to competitive advantage

  • Feb 01, 1996
  • Logistics Information Management
  • Richard D Wilding +1
  • Conference Article
  • Citations1

An object-based approach to the specification of applications for office support systems

  • Jan 01, 1992
  • H Saiedian +1
  • Research Article

Multi scale analysis of social-ecological system of lobster (Panulirus spp.) fisheries in the Gunungkidul waters, Yogyakarta

  • Sep 01, 2024
  • IOP Conference Series: Earth and Environmental Science
  • E C P Nugraha +4
  • Research Article

Accountability and Resource Management: Building Blocks towards National Prosperity

  • Jan 27, 2022
  • Asian Journal of Economics, Business and Accounting
  • Orajekwe Jerry Chukwuebuka +2
  • Research Article
  • Citations135

An integrated information system for snowmelt flood early-warning based on internet of things

  • Oct 09, 2013
  • Information Systems Frontiers
  • Shifeng Fang +7
  • Conference Article

Resource Authentication Management Model Based on CA and DHT in Internet of Things

  • Jul 17, 2017
  • Fufang Li +4
  • Research Article
  • Citations44

A formal model for reasoning about adaptive QoS-enabled middleware

  • Jan 01, 2004
  • ACM Transactions on Software Engineering and Methodology
  • Nalini Venkatasubramanian +2
  • Research Article
  • Citations27

The comparative importance of human resource management practices in the context of business to business (B2B) electronic commerce

  • Dec 01, 2004
  • Information Technology & People
  • Damien Power
  • Research Article

ENCODING RESTRICTIONS AS AN OBJECT OF CADASTRAL SYSTEMS IN UKRAINE

  • Sep 06, 2024
  • Municipal economy of cities
  • O Petrakovska +1
Cactus Communications logo

Copyright 2026 Cactus Communications. All rights reserved.