research-article

Open access

Æminium: A Permission-Based Concurrent-by-Default Programming Language Approach

Authors:

Joshua Sunshine,

Alcides Fonseca,

Jonathan AldrichAuthors Info & Claims

ACM Transactions on Programming Languages and Systems (TOPLAS), Volume 36, Issue 1

Article No.: 2, Pages 1 - 42

https://doi.org/10.1145/2543920

Published: 01 March 2014 Publication History

Abstract

Writing concurrent applications is extremely challenging, not only in terms of producing bug-free and maintainable software, but also for enabling developer productivity. In this article we present the Æminium concurrent-by-default programming language. Using Æminium programmers express data dependencies rather than control flow between instructions. Dependencies are expressed using permissions, which are used by the type system to automatically parallelize the application. The Æminium approach provides a modular and composable mechanism for writing concurrent applications, preventing data races in a provable way. This allows programmers to shift their attention from low-level, error-prone reasoning about thread interleaving and synchronization to focus on the core functionality of their applications. We study the semantics of Æminium through μÆminium, a sound core calculus that leverages permission flow to enable concurrent-by-default execution. After discussing our prototype implementation we present several case studies of our system. Our case studies show up to 6.5X speedup on an eight-core machine when leveraging data group permissions to manage access to shared state, and more than 70% higher throughput in a Web server application.

References

[1]

Acar, U. A., Charguéraud, A., and Rainey, M. 2011. Oracle scheduling: Controlling granularity in implicitly parallel languages. In Proceedings of the ACM International Conference on Object Oriented Programming Systems, Languages, and Applications (OOPSLA’11).

Digital Library

[2]

Adve, S. V. and Boehm, H.-J. 2010. Memory models: A case for rethinking parallel languages and hardware. Comm. ACM 53, 8, 90--101.

Digital Library

[3]

Aldrich, J., Sunshine, J., Saini, D., and Sparks, Z. 2009. Typestate-oriented programming. In Proceedings of the ACM International Conference on Object Oriented Programming Systems, Languages, and Applications (OOPSLA’09).

Digital Library

[4]

Aldrich, J., Beckman, N. E., Bocchino, R., Naden, K., Saini, D., Stork, S., and Sunshine, J. 2012. The plaid language: Typed core specification. Tech. rep. CMU-ISR-12-103, Carnegie Mellon University.

[5]

Allen, E., Chase, D., Hallett, J., Luchangco, V., Maessen, J., Ryu, S., Steele Jr, G., and Tobinhochstadt, S. 2008. The fortress language specification version 1.0. Tech. rep., Sun Microsystems.

[6]

Anderson, Z., Gay, D., Ennals, R., and Brewer, E. 2008. Sharc: Checking data sharing strategies for multithreaded C. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’08). ACM Press, New York, 149--158.

Digital Library

[7]

Beckman, N. E., Bierhoff, K., and Aldrich, J. 2008. Verifying correct usage of atomic blocks and typestate. In Proceedings of the ACM International Conference on Object Oriented Programming Systems, Languages and Applications (OOPSLA’08).

Digital Library

[8]

Blelloch, G. E. and Greiner, J. 1996. A provable time and space efficient implementation of NESL. In Proceedings of the 1st ACM SIGPLAN International Conference on Functional Programming (ICFP’96). 213--225.

Digital Library

[9]

Blumofe, R. D., Joerg, C. F., Kuszmaul, B. C., Leiserson, C. E., Randall, K. H., and Zhou, Y. 1995. Cilk: An efficient multithreaded runtime system. In Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP’95).

Digital Library

[10]

Bocchino, Jr., R. L., Adve, V. S., Dig, D., Adve, S. V., Heumann, S., Komuravelli, R., Overbey, J., Simmons, P., Sung, H., and Vakilian, M. 2009. A type and effect system for deterministic parallel Java. In Proceedings of the ACM International Conference on Object Oriented Programming Systems, Languages and Applications (OOPSLA’09).

Digital Library

[11]

Bocchino, Jr., R., Heumann, S., Honarmand, N., Adve, S., Adve, V., Welc, A., and Shpeisman, T. 2011. Safe nondeterminism in a deterministic-by-default parallel language. In Proceedings of the 38th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’11). 535--548.

Digital Library

[12]

Boehm, H.-J. 2009. Transactional memory should be an implementation technique, not a programming interface. Tech. rep. HPL-2009-45, HP Laboratories.

[13]

Boyapati, C., Lee, R., and Rinard, M. 2002. Ownership types for safe programming: Preventing data races and deadlocks. In Proceedings of the ACM International Conference on Object Oriented Programming Systems, Languages and Applications (OOPSLA’02). 211--230.

Digital Library

[14]

Boyland, J. 2003. Checking interference with fractional permissions. In Proceedings of the 10th International Symposium on Static Analysis.

Digital Library

[15]

Clarke, D. G., Potter, J. M., and Noble, J. 1998. Ownership types for flexible alias protection. In Proceedings of the ACM International Conference on Object Oriented Programming Systems, Languages and Applications (OOPSLA’98). 48--64.

Digital Library

[16]

Click, C. and Paleczny, M. 1995. A simple graph-based intermediate representation. In Papers from the ACM SIGPLAN Workshop on Intermediate Representations (IR’95). ACM Press, New York, 35--49.

Digital Library

[17]

Craik, A. and Kelly, W. 2010. Using ownership to reason about inherent parallelism in object-oriented programs. In Proceedings of the 19th Joint European Conference on Theory and Practice of Software, and the International Conference on Compiler Construction (CC’10/ETAPS’10). 145--164.

Digital Library

[18]

Fahndrich, M. and Deline, R. 2002. Adoption and focus: Practical linear types for imperative programming. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’02). Vol. 37, ACM Press, New York, 13--24.

Digital Library

[19]

Galilée, F., Cavalheiro, G. G., Louis Roch, J., and Doreille, M. 1998. Athapascan-1: On-line building data flow graph in a parallel language. In Proceedings of the International Conference on Parallel Architectures and Compilation Techniques. 88.

Digital Library

[20]

Gifford, D. K. and Lucassen, J. M. 1986. Integrating functional and imperative programming. In Proceedings of the ACM Conference on LISP and Functional Programming (LFP’86). 28--38.

Digital Library

[21]

Girard, J.-Y. 1987. Linear logic. Theor. Comput. Sci. 50, 1.

Digital Library

[22]

Goldberg, A. and Robson, D. 1983. Smalltalk-80: The Language and its Implementation. Addison-Wesley Longman Publishing, Boston, MA.

Digital Library

[23]

Hindman, B. and Grossman, D. 2006. Atomicity via source-to-source translation. In Proceedings of the Workshop on Memory System Performance and Correctness (MSPC’06). ACM Press, New York, 82--91.

Digital Library

[24]

Igarashi, A., Pierce, B. C., and Wadler, P. 2001. Featherweight Java: A minimal core calculus for Java and GJ. In Proceedings of the ACM International Conference on Object Oriented Programming Systems, Languages and Applications (OOPSLA’01).

Digital Library

[25]

Leino, K. R. M. 1998. Data groups: Specifying the modification of extended state. In Proceedings of the ACM International Conference on Object Oriented Programming Systems, Languages and Applications (OOPSLA’98).

Digital Library

[26]

Leino, K. R. M., Poetzsch-Heffter, A., and Zhou, Y. 2002. Using data groups to specify and check side effects. ACM SIGPLAN Not. 37, 5, 246--257.

Digital Library

[27]

McKeeman, W. M. 1965. Peephole optimization. Comm. ACM 8, 443--444.

Digital Library

[28]

Microsoft Corporation 2009. Axum programmer’s guide. http://msdn.microsoft.com/en-us/devlabs/dd795202.aspx.

[29]

Moggi, E. 1991. Notions of computation and monads. Inf. Comput. 93, 1, 55--92.

Digital Library

[30]

Moore, K. F. and Grossman, D. 2008. High-level small-step operational semantics for transactions. In Proceedings of the 35th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’08).

Digital Library

[31]

Naden, K., Bocchino, R., Aldrich, J., and Bierhoff, K. 2012. A type system for borrowing permissions. In Proceedings of the 39th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’12). ACM Press, New York, 557--570.

Digital Library

[32]

Pierce, B. C. 2002. Types and Programming Languages. MIT Press, Cambridge, MA.

Digital Library

[33]

Rumbaugh, J. 1975. A parallel asynchronous computer architecture for data flow programs. Ph.D. thesis, MIT-LCS-TR-150, MIT.

[34]

Sarkar, V. 1989. Partitioning and Scheduling Parallel Programs for Multiprocessors. MIT Press, Cambridge, MA.

Digital Library

[35]

Stork, S. 2013. ÆMINIUM- Freeing programmers from the shackles of sequentiality. Ph.D. thesis, School of Computer Science, Carnegie Mellon University.

[36]

Stork, S., Aldrich, J., and Marques, P. 2010. Micro-AEmimium language specification. Tech. rep. CMU-ISR-10-125R2, Carnegie Mellon University.

[37]

Stork, S., Marques, P., and Aldrich, J. 2009. Concurrency by default: Using permissions to express dataflow in stateful programs. In Proceedings of the 24th ACM SIGPLAN Conference Companion on Object Oriented Programming Systems Languages and Applications. 933--940.

Digital Library

[38]

Stork, S., Naden, K., and Sunshine, J. 2012. AEminium code repository. http://goo.gl/olbMs.

[39]

Sunshine, J., Naden, K., Stork, S., Aldrich, J., and Tanter, E. 2011. First-class state change in plaid. In Proceedings of the ACM International Conference on Object Oriented Programming Systems, Languages and Applications (OOPSLA’11). ACM Press, New York, 713--732.

Digital Library

[40]

Vaziri, M., Tip, F., Dolby, J., and Vitek, J. 2010. A type system for data-centric synchronization. In Proceedings of the ACM International Conference on Object Oriented Programming Systems, Languages and Applications (OOPSLA’10).

Digital Library

Cited By

Wang HWang ZSun JLiu SSadiq ALi YGrundy JLe Goues CLo D(2020)Towards generating thread-safe classes automaticallyProceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering10.1145/3324884.3416625(943-955)Online publication date: 21-Dec-2020
https://dl.acm.org/doi/10.1145/3324884.3416625
Sadiq ALi YLing S(2020)A survey on the use of access permission-based specifications for program verificationJournal of Systems and Software10.1016/j.jss.2019.110450159:COnline publication date: 1-Jan-2020
https://dl.acm.org/doi/10.1016/j.jss.2019.110450
Costea AZhu APolikarpova NSergey I(2020)Concise Read-Only Specifications for Better Synthesis of Programs with PointersProgramming Languages and Systems10.1007/978-3-030-44914-8_6(141-168)Online publication date: 27-Apr-2020
https://dl.acm.org/doi/10.1007/978-3-030-44914-8_6
Show More Cited By

Index Terms

Æminium: A Permission-Based Concurrent-by-Default Programming Language Approach
1. Computing methodologies
  1. Concurrent computing methodologies
    1. Concurrent programming languages
2. Software and its engineering
  1. Software notations and tools
    1. General programming languages
      1. Language features
      2. Language types
        Concurrent programming languages
        Object oriented languages

Recommendations

Æminium: a permission based concurrent-by-default programming language approach
PLDI '14

The aim of ÆMINIUM is to study the implications of having a concurrent-by-default programming language. This includes language design, runtime system, performance and software engineering considerations.

We conduct our study through the design of the ...
Æminium: a permission based concurrent-by-default programming language approach
PLDI '14: Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation

The aim of ÆMINIUM is to study the implications of having a concurrent-by-default programming language. This includes language design, runtime system, performance and software engineering considerations.

We conduct our study through the design of the ...
Permission accounting in separation logic
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages

A lightweight logical approach to race-free sharing of heap storage between concurrent threads is described, based on the notion of permission to access. Transfer of permission between threads, subdivision and combination of permission is discussed. The ...

Comments

Information & Contributors

Information

Published In

cover image ACM Transactions on Programming Languages and Systems

ACM Transactions on Programming Languages and Systems Volume 36, Issue 1

March 2014

186 pages

ISSN:0164-0925

EISSN:1558-4593

DOI:10.1145/2597180

Editor:
Jens Palsberg
University of California, Los Angeles, USA

Issue’s Table of Contents

Copyright © 2014 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected].

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 01 March 2014

Accepted: 01 October 2013

Revised: 01 June 2013

Received: 01 October 2012

Published in TOPLAS Volume 36, Issue 1

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article
Research
Refereed

Funding Sources

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

20
Total Citations
View Citations
492
Total Downloads

Downloads (Last 12 months)64
Downloads (Last 6 weeks)17

Reflects downloads up to 13 Jan 2025

Other Metrics

View Author Metrics

Citations

Cited By

Wang HWang ZSun JLiu SSadiq ALi YGrundy JLe Goues CLo D(2020)Towards generating thread-safe classes automaticallyProceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering10.1145/3324884.3416625(943-955)Online publication date: 21-Dec-2020
https://dl.acm.org/doi/10.1145/3324884.3416625
Sadiq ALi YLing S(2020)A survey on the use of access permission-based specifications for program verificationJournal of Systems and Software10.1016/j.jss.2019.110450159:COnline publication date: 1-Jan-2020
https://dl.acm.org/doi/10.1016/j.jss.2019.110450
Costea AZhu APolikarpova NSergey I(2020)Concise Read-Only Specifications for Better Synthesis of Programs with PointersProgramming Languages and Systems10.1007/978-3-030-44914-8_6(141-168)Online publication date: 27-Apr-2020
https://dl.acm.org/doi/10.1007/978-3-030-44914-8_6
Astrauskas VMüller PPoli FSummers A(2019)Leveraging rust types for modular specification and verificationProceedings of the ACM on Programming Languages10.1145/33605733:OOPSLA(1-30)Online publication date: 10-Oct-2019
https://dl.acm.org/doi/10.1145/3360573
Sadiq ALi LLi YAhmed ILing SZimmermann TLawall JMarinov D(2019)Sip4JProceedings of the 34th IEEE/ACM International Conference on Automated Software Engineering10.1109/ASE.2019.00111(1098-1101)Online publication date: 10-Nov-2019
https://dl.acm.org/doi/10.1109/ASE.2019.00111
Faes MGross T(2019)Parallel Roles for Practical Deterministic Parallel ProgrammingLanguages and Compilers for Parallel Computing10.1007/978-3-030-35225-7_12(163-181)Online publication date: 15-Nov-2019
https://doi.org/10.1007/978-3-030-35225-7_12
Faes MGross T(2018)Concurrency-aware object-oriented programming with rolesProceedings of the ACM on Programming Languages10.1145/32765002:OOPSLA(1-30)Online publication date: 24-Oct-2018
https://dl.acm.org/doi/10.1145/3276500
Fonseca ACerveira FCabral BBarbosa R(2018)Language-Based Expression of Reliability and Parallelism for Low-Power ComputingIEEE Transactions on Sustainable Computing10.1109/TSUSC.2017.27713763:3(153-166)Online publication date: 1-Jul-2018
https://doi.org/10.1109/TSUSC.2017.2771376
OLARTE CPIMENTEL ERUEDA C(2018)A concurrent constraint programming interpretation of access permissionsTheory and Practice of Logic Programming10.1017/S147106841800001718:2(252-295)Online publication date: 10-Apr-2018
https://doi.org/10.1017/S1471068418000017
Fonseca ACabral B(2018)Overcoming the No Free Lunch Theorem in Cut-off Algorithms for Fork-Join programsParallel Computing10.1016/j.parco.2018.04.00576:C(42-56)Online publication date: 1-Aug-2018
https://dl.acm.org/doi/10.1016/j.parco.2018.04.005
Show More Cited By

View Options

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Article

Media

Figures

Other

Tables

View Issue’s Table of Contents