Implementing Declarative Concurrency in Java

Authors:
Rafael Ramirez;Andrew E. Santosa;Lee Wei Hong
Affiliations:
-;-;-
Venue:
Euro-Par '00 Proceedings from the 6th International Euro-Par Conference on Parallel Processing
Year:
2000

Citing 10
Cited 0

A logic-based calculus of events

New Generation Computing
Modeling concurrency with partial orders

International Journal of Parallel Programming
Parallel logic programming in PARLOG: the language and its implementation

Parallel logic programming in PARLOG: the language and its implementation
PROCOL: a parallel object language with protocols

OOPSLA '89 Conference proceedings on Object-oriented programming systems, languages and applications
Concurrent constraint programming

POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Design and implementation of an object-oriented strongly typed language for distributed applications

Journal of Object-Oriented Programming
Design of the kernel language for the parallel inference machine

The Computer Journal - On concurrent logic programming
Object-oriented reuse, concurrency and distribution: an ADA-based approach

Object-oriented reuse, concurrency and distribution: an ADA-based approach
Declarative Concurrency in Java

IPDPS '00 Proceedings of the 15 IPDPS 2000 Workshops on Parallel and Distributed Processing
Derivation of Concurrent Algorithms in Tempo

LOPSTR '95 Proceedings of the 5th International Workshop on Logic Programming Synthesis and Transformation

Quantified Score

Hi-index	0.00

Visualization

Abstract

We describe the implementation of a high-level language based on first order logic for expressing synchronization in multithreaded Java programs. The language allows the programmer to declaratively state the system safety properties as temporal constraints on specific program points of interest (events). The constraints are enforced by the run-time environment, i.e. the program points of interest are traversed only in the order specified by the constraints. The implementation is based on the incremental and lazy generation of partial orders among events. Although the implementation reported in this paper is concerned only with the synchronization of Java programs, the general underlying synchronization model we present is language independent in that it allows the programmer to glue together separate concurrent threads regardless of their implementation language and application code.