Implicit Invocation Meets Safe, Implicit Concurrency

By: Yuheng Long

Download Paper

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 work, 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 programs significantly easier compared to standard concurrent object-oriented programs, but also performance of Panini programs is comparable to their equivalent hand-tuned versions written using Java’s fork-join framework.

ACM Reference

Long, Y. 2010. Implicit invocation meets safe, implicit concurrency. Iowa State University.

BibTeX Reference

@mastersthesis{long2010implicit-a,
  title = {Implicit invocation meets safe, implicit concurrency},
  author = {Long, Yuheng},
  year = {2010},
  school = {Iowa State University},
  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 work, 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 programs significantly
    easier compared to standard concurrent object-oriented programs, but also
    performance of Panini programs is comparable to their equivalent hand-tuned
    versions written using Java's fork-join framework.
  }
}