Campus Units

Computer Science

Document Type

Conference Proceeding

Conference

GPCE Generative Programming and Component Engineering

Publication Version

Accepted Manuscript

Link to Published Version

http://dx.doi.org/10.1145/1942788.1868304

Publication Date

10-10-2011

Volume

46

Issue

2

First Page

63

Last Page

72

DOI

10.1145/1942788.1868304

Conference Title

GPCE '10 The ninth international conference on Generative programming and component engineering

Conference Date

Oct. 10-13, 2010

City

Eindhoven, The Netherlands

Abstract

Writing correct and efficient concurrent programs still remains a challenge. Explicit concurrency is difficult, error prone, and creates code which is hard to maintain and debug. This type of concurrency also treats modular program design and concurrency as separate goals, where modularity often suffers. To solve these problems, we are designing a new language that we call Panini. In this paper, we focus on Panini's asynchronous, typed events which reconcile the modularity goal promoted by the implicit invocation design style with the concurrency goal of exposing potential concurrency between the execution of subjects and observers.

Since modularity is improved and concurrency is implicit in Panini, programs are easier to reason about and maintain. The language incorporates a static analysis to determine potential conflicts between handlers and a dynamic analysis which uses the conflict information to determine a safe order for handler invocation. This mechanism avoids races and deadlocks entirely, yielding programs with a guaranteed deterministic semantics. To evaluate our language design and implementation we show several examples of its usage as well as an empirical study of program performance. We found that not only is developing and understanding Panini programs significantly easier compared to standard concurrent object-oriented programs, butt also performance of Panini programs is comparable to their equivalent hand-tuned versions written using Java's fork-join framework.

Comments

This article is published as Long, Yuheng, Sean L. Mooney, Tyler Sondag, and Hridesh Rajan. Implicit invocation meets safe, implicit concurrency. In ACM Sigplan Notices, Vol. 46, no. 2. ACM, 2010. doi:10.1145/1868294.1868304. Posted with permission.

Rights

© ACM, 2010. This is the author's version of the work. It is posted here by permission of ACM for your personal use. Not for redistribution. The definitive version was published in ACM Sigplan Notices, vol. 46, no. 2, pp. 63-72. ACM, 2010. https://doi.org/10.1145/1942788.1868304

Copyright Owner

Association for Computing Machinery

Language

en

File Format

application/pdf

Published Version

Share

Article Location

 
COinS