The Scalable Commutativity Rule: Designing Scalable Software for Multicore Processors.

Saved in:

Bibliographic Details
Title:	The Scalable Commutativity Rule: Designing Scalable Software for Multicore Processors.
Authors:	Clements, Austin T.¹ (AUTHOR) aclements@csail.mit.edu, Kaashoek, M. Frans¹ (AUTHOR) kaashoek@csail.mit.edu, Kohler, Eddie² (AUTHOR) kohler@seas.harvard.edu, Morris, Robert T.¹ (AUTHOR) rtm@csail.mit.edu, Zeldovich, Nickolai¹ (AUTHOR) zeldovich@csail.mit.edu
Source:	Communications of the ACM. Aug2017, Vol. 60 Issue 8, p83-90. 8p. 1 Diagram, 2 Graphs.
Subjects:	Scalability, Computer software development, Multicore processors, Computer interfaces software, Computer interface standards
Abstract:	Developing software that scales on multicore processors is an inexact science dominated by guesswork, measurement, and expensive cycles of redesign and reimplementation. Current approaches are workload-driven and, hence, can reveal scalability bottlenecks only for known workloads and available software and hardware. This paper introduces an interface-driven approach to building scalable software. This approach is based on the scalable commutativity rule, which, informally stated, says that whenever interface operations commute, they can be implemented in a way that scales. We formalize this rule and prove it correct for any machine on which conflict-free operations scale, such as current cache-coherent multicore machines. The rule also enables a better design process for scalable software: programmers can now reason about scalability from the earliest stages of interface definition through software design, implementation, and evaluation. [ABSTRACT FROM AUTHOR]
	Copyright of Communications of the ACM is the property of Association for Computing Machinery and its content may not be copied or emailed to multiple sites without the copyright holder's express written permission. Additionally, content may not be used with any artificial intelligence tools or machine learning technologies. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)
Database:	Engineering Source

Description
Abstract:	Developing software that scales on multicore processors is an inexact science dominated by guesswork, measurement, and expensive cycles of redesign and reimplementation. Current approaches are workload-driven and, hence, can reveal scalability bottlenecks only for known workloads and available software and hardware. This paper introduces an interface-driven approach to building scalable software. This approach is based on the scalable commutativity rule, which, informally stated, says that whenever interface operations commute, they can be implemented in a way that scales. We formalize this rule and prove it correct for any machine on which conflict-free operations scale, such as current cache-coherent multicore machines. The rule also enables a better design process for scalable software: programmers can now reason about scalability from the earliest stages of interface definition through software design, implementation, and evaluation. [ABSTRACT FROM AUTHOR]
ISSN:	00010782
DOI:	10.1145/3068914