Commutativity Rule Designing Scalable Software for Multicore Processors Austin T Clements M Frans Kaashoek Nickolai Zeldovich Robert T Morris and Eddie Kohler MIT CSAIL and Harvard University ID: 461136
Download Presentation The PPT/PDF document "The Scalable" is the property of its rightful owner. Permission is granted to download and print the materials on this web site for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.
Slide1
The Scalable Commutativity Rule: Designing Scalable Software for Multicore Processors
Austin T. Clements, M. Frans Kaashoek, Nickolai Zeldovich, Robert T. Morris, and Eddie KohlerMIT CSAIL and Harvard University
EECS 582 – W16
1
1/27/16Slide2
OutlineIntroduce the problemContributions
Define the ruleCommuterEvaluationConclusionEECS 582 – W162Slide3
What is the usual way to evaluate the scalability of multicore software?
WorkloadPlot Scalability
Fix bottleneck
Differential profile
Any drawbacks?Slide4
DrawbacksNew workloads expose new bottlenecks
More cores expose new bottlenecksThe real bottlenecks may be in the interface designSlide5
Question:
Can scalability opportunities be identified even before any implementation exists, simply by considering interface specifications?Yes!Slide6
The Scalable Commutativity Rule
Whenever interface operations commute, they can be implemented in a way that scales.Slide7
OutlineIntroduce the problemContributions
Define the ruleCommuterEvaluationConclusionEECS 582 – W167Slide8
ContributionsThe scalable
commutativity rule Formalization of the rule and proof of its correctness State-dependent, interface-based commutativityCommuter: An automated scalability testing toolSv6: A scalable POSIX-like kernelSlide9
SIM Commutativity
The formalism of the rule relies on SIM commutativity Consider a history H = X || Y (where || concatenates action sequences) * Y SI-commutes in H when given any reordering Y’ of Y, and any action sequence Z, X || Y || Z is a well-formed histories
iff X || Y’ || Z is also well formed
* Y SIM-commutes in H when for any prefix P of some reordering of Y, P SI-commutes in X || PSlide10
OutlineIntroduce the problemContributions
Define the ruleCommuterEvaluationConclusionEECS 582 – W1610Slide11
What scales on today’s multicore?We say two or more operations are scalable if they are conflict-freeSlide12
The intuition behind the rule
Whenever interface operations commute, they can be implemented in a way that scales.Operations commute => results independent of order => communication is unnecessary => without communication, no conflicts
Slide13
OutlineIntroduce the problemContributions
Define the ruleCommuterEvaluationConclusionEECS 582 – W1613Slide14
Commuter
CommuterInterface specification(e.g., POSIX)
All scalability bottlenecks
Implementation (e.g., Linux)Slide15
Components of CommuterSlide16
OutlineIntroduce the problemContributions
Define the ruleCommuterEvaluationConclusionEECS 582 – W1616Slide17
Commuter finds non-scalable cases in LinuxSlide18
Sv6: A scalable OSPOSIX-like operating system
File system and virtual memory system follow commutativity ruleImplementing using standard parallel programming techniques, but guided by CommuterSlide19
Commutative operations can be made to scaleSlide20
Benchmark throughput in operations per second per core with varying core counts on sv6Slide21
OutlineIntroduce the problemContributions
Define the ruleCommuterEvaluationConclusionEECS 582 – W1621Slide22
Conclusion
Whenever interface operations commute, they can be implemented in a way that scales.This rule helps developers in building more scalable software starting from interface design and carrying on through implementation, testing, and evaluation.Slide23
Q&A