Capsules: a shared memory access mechanism for Concurrent C/C++

Gehani, Narain

doi:10.1109/71.238301

Cited by 18 publications

(7 citation statements)

References 29 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The second problem concerns the execution order among the synchronized methods or synchronized blocks becoming more difficult to control. This may complicate the design of scheduling programs, where ordering is important [3,5,6]. For example, the above Semaphore class cannot guarantee the FIFO ordering of completing the P() method.…”

Section: No-priority Monitormentioning

confidence: 99%

An enhanced thread synchronization mechanism for Java

Chiao

Yuan

2001

Softw Pract Exp

View full text Add to dashboard Cite

The thread synchronization mechanism of Java is derived from Hoare's monitor concept. In the authors' view, however, it is over simplified and suffers the following four drawbacks. First, it belongs to a category of no-priority monitor, the design of which, as reported in the literature on concurrent programming, is not well rated. Second, it offers only one condition queue. Where more than one long-term synchronization event is required, this restriction both degrades performance and further complicates the ordering problems that a no-priority monitor presents. Third, it lacks the support for building more elaborate scheduling programs. Fourth, during nested monitor invocations, deadlock may occur. In this paper, we first analyze these drawbacks in depth before proceeding to present our own proposal, which is a new monitor-based thread synchronization mechanism that we term EMonitor. This mechanism is implemented solely by Java, thus avoiding the need for any modification to the underlying Java Virtual Machine. A preprocessor is employed to translate the EMonitor syntax into the pure Java codes that invoke the EMonitor class libraries. We conclude with a comparison of the performance of the two monitors and allow the experimental results to demonstrate that, in most cases, replacing the Java version with the EMonitor version for developing concurrent Java objects is perfectly feasible. THE JAVA MONITOR AND ITS DRAWBACKSThe thread synchronization mechanism of Java [1] is a simplification of Hoare's original monitor concept [2]. To implement the monitor, each Java object contains a monitor lock and a condition queue. The keyword synchronized can be inserted into the definition of a method for the purpose of specifying the method as a synchronized method. In a Java object, only one synchronized method

show abstract

Section: No-priority Monitormentioning

confidence: 99%

An enhanced thread synchronization mechanism for Java

Chiao

Yuan

2001

Softw Pract Exp

View full text Add to dashboard Cite

show abstract

“…In many cases, these systems must be designed to monitor and control complex systems in dynamic, sometimes hazardous, settings. Extensive studies [1,2, 6,7,8,9,121 have been done in the area of providing linguistic supports for software developers to specify synchronization requirements for concurrent object-oriented system. Issues such as the difficulty in achieving reuse of synchronization constraint also has been extensively scrutinized [8,11,12,14].…”

Section: Introductionmentioning

confidence: 99%

Scheduling control mechanisms for managing indeterminate object behavior

Huang¹,

Elrad

1998

Proceedings of the 1998 ACM Symposium on Applied Computing - SAC '98

View full text Add to dashboard Cite

This paper presents a general framework for addressing scheduling control mechanisms that assist concurrent systems in reaching a proper and fair (starvation-free) scheduling decision. An adaptive scheduling mechanism equips an object entity to process conflicting requests based on some preference information and possibly on feedback from its immediate surroundings. It will also enable system components to intelligently manage and control indeterminate object behavior. Such capability is critical to the successful implementation of today's complex systems (e.g., realtime and reactive systems). These systems usually consist of interacting entities that exhibit traits such as intelligence, adaptability, and a highly reactive and dynamic behavior within their environment. This approach differs from most previous attempts in: 1) enforcing the notion of separation of concerns: race scheduling specification can be stated in a declarative manner and isolated from its implementation codes; 2) promoting the reuse and extensmn of existing scheduling strategies; and 3) the localization of scheduling policies as modular and reusable entities.

show abstract

“…-A concurrent shared resource, which can be seen as a concurrent abstract data type whose operations implement changes to some object state (which can, therefore, be used to communicate processes) and take care of synchronization by means of suspending the caller process. In some sense, they resemble some of the characteristics of the classical capsules for C++ [Gehani 1993]. Resources act as the unique communication and synchronization point between processes.…”

Section: Architectural Componentsmentioning

confidence: 99%

A model-driven approach to teaching concurrency

Carro

Herranz

Mariño

2013

ACM Trans. Comput. Educ.

View full text Add to dashboard Cite

We present an undergraduate course on concurrent programming where formal models are used in different stages of the learning process. The main practical difference with other approaches lies in the fact that the ability to develop correct concurrent software relies on a systematic transformation of formal models of interprocess interaction (so called shared resources), rather than on the specific constructs of some programming language. Using a resource-centric rather than a language-centric approach has some benefits for both teachers and students. Besides the obvious advantage of being independent of the programming language, the models help in the early validation of concurrent software design, provide students and teachers with a lingua franca that greatly simplifies communication at the classroom and during supervision, and help in the automatic generation of tests for the practical assignments. This method has been in use, with slight variations, for some 15 years, surviving changes in the programming language and course length. In this article, we describe the components and structure of the current incarnation of the course-which uses Java as target language-and some tools used to support our method. We provide a detailed description of the different outcomes that the model-driven approach delivers (validation of the initial design, automatic generation of tests, and mechanical generation of code) from a teaching perspective. A critical discussion on the perceived advantages and risks of our approach follows, including some proposals on how these risks can be minimized. We include a statistical analysis to show that our method has a positive impact in the student ability to understand concurrency and to generate correct code.

show abstract

Capsules: a shared memory access mechanism for Concurrent C/C++

Cited by 18 publications

References 29 publications

An enhanced thread synchronization mechanism for Java

An enhanced thread synchronization mechanism for Java

Scheduling control mechanisms for managing indeterminate object behavior

A model-driven approach to teaching concurrency

Contact Info

Product

Resources

About