1. The Scalable 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 EECS 582 – W1611/27/16

2. Outline Introduce the problem Contributions Define the rule Commuter Evaluation Conclusion EECS 582 – W162

3. What is the usual way to evaluate the scalability of multicore software? Workload Plot Scalability Fix bottleneck Differential profile Any drawbacks?

4. Drawbacks New workloads expose new bottlenecks More cores expose new bottlenecks The real bottlenecks may be in the interface design

5. Question: Can scalability opportunities be identified even before any implementation exists, simply by considering interface specifications? Yes!

6. The Scalable Commutativity Rule Whenever interface operations commute, they can be implemented in a way that scales.

7. Outline Introduce the problem Contributions Define the rule Commuter Evaluation Conclusion EECS 582 – W167

8. Contributions The scalable commutativity rule Formalization of the rule and proof of its correctness State-dependent, interface-based commutativity Commuter: An automated scalability testing tool Sv6: A scalable POSIX-like kernel

9. 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 || P

10. Outline Introduce the problem Contributions Define the rule Commuter Evaluation Conclusion EECS 582 – W1610

11. What scales on today’s multicore? We say two or more operations are scalable if they are conflict-free

12. 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

13. Outline Introduce the problem Contributions Define the rule Commuter Evaluation Conclusion EECS 582 – W1613

14. Commuter Interface specification (e.g., POSIX) All scalability bottlenecks Implementation (e.g., Linux)

15. Components of Commuter

16. Outline Introduce the problem Contributions Define the rule Commuter Evaluation Conclusion EECS 582 – W1616

17. Commuter finds non-scalable cases in Linux

18. Sv6: A scalable OS POSIX-like operating system File system and virtual memory system follow commutativity rule Implementing using standard parallel programming techniques, but guided by Commuter

19. Commutative operations can be made to scale

20. Benchmark throughput in operations per second per core with varying core counts on sv6

21. Outline Introduce the problem Contributions Define the rule Commuter Evaluation Conclusion EECS 582 – W1621

22. 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.

23. Q&A