Concurrency by Modularity: Design Patterns, a Case in Point

By: Hridesh Rajan, Steven M. Kautz, and Wayne Rowcliffe

Abstract

General purpose object-oriented programs typically aren’t embarrassingly parallel. For these applications, finding enough concurrency remains a challenge in program design. To address this challenge, in the Panini project we are looking at reconciling concurrent program design goals with modular program design goals. The main idea is that if programmers improve the modularity of their programs they should get concurrency for free. In this work we describe one of our directions to reconcile these two goals by enhancing Gang-of-Four (GOF) object-oriented design patterns. GOF patterns are commonly used to improve the modularity of object-oriented software. These patterns describe strategies to decouple components in design space and specify how these components should interact. Our hypothesis is that if these patterns are enhanced to also decouple components in execution space applying them will concomitantly improve the design and potentially available concurrency in software systems. To evaluate our hypothesis we have studied all 23 GOF patterns. For 18 patterns out of 23, our hypothesis has held true. Another interesting preliminary result reported here is that for 17 out of these 18 studied patterns, concurrency and synchronization concerns were completely encapsulated in our concurrent design pattern framework.

ACM Reference

Rajan, H. et al. 2010. Concurrency by Modularity: Design Patterns, a Case in Point. 2010 Onward! Conference (Oct. 2010).

BibTeX Reference

@inproceedings{rajan2010concurrency,
  author = {Hridesh Rajan and Steven M. Kautz and Wayne Rowcliffe},
  title = {Concurrency by Modularity: Design Patterns, a Case in Point},
  booktitle = {2010 Onward! Conference},
  location = {Reno, USA},
  month = {October},
  year = {2010},
  entrysubtype = {conference},
  abstract = {
    General purpose object-oriented programs typically aren't embarrassingly
    parallel. For these applications, finding enough concurrency remains a
    challenge in program design. To address this challenge, in the Panini project
    we are looking at reconciling concurrent program design goals with modular
    program design goals. The main idea is that if programmers improve the
    modularity of their programs they should get concurrency for free. In this
    work we describe one of our directions to reconcile these two goals by
    enhancing Gang-of-Four (GOF) object-oriented design patterns. GOF patterns are
    commonly used to improve the modularity of object-oriented software. These
    patterns describe strategies to decouple components in design space and
    specify how these components should interact. Our hypothesis is that if these
    patterns are enhanced to also decouple components in execution space applying
    them will concomitantly improve the design and potentially available
    concurrency in software systems. To evaluate our hypothesis we have studied
    all 23 GOF patterns. For 18 patterns out of 23, our hypothesis has held true.
    Another interesting preliminary result reported here is that for 17 out of
    these 18 studied patterns, concurrency and synchronization concerns were
    completely encapsulated in our concurrent design pattern framework.
  }
}