A tool based approach to conquering concurrent programming

A Tool-based Approach to Conquering Concurrent Programming Thomas Ball Microsoft Research July 2011

Thanks• Sebastian Burckhardt, MSR• Joe Mayo, Univ. Utah -> Microsoft• Madan Musuvathi, MSR• Shaz Qadeer, MSR• PPCP team members

Shared Memory Multi-threading: Alive and Well• Lingua franca of multi-core computing• Supplemented by work-stealing scheduling – Boost – Intel’s Thread Building Blocks – java.util.concurrent – Microsoft’s .NET 4.0

.NET 4 Librariesfor Parallelism and Concurrency

Sequential Ray Tracingvoid Render(Scene scene, Color[,] rgb){ for (int y = 0; y < screenHeight; y++) { for (int x = 0; x < screenWidth; x++) { rgb[x,y] = TraceRay(new Ray(scene,x,y)); } }}

Parallel Ray Tracing withParallel.For and Lambdavoid Render(Scene scene, Color[,] rgb){ Parallel.For(0, screenHeight, (y) => { for (int x = 0; x < screenWidth; x++) { rgb[x,y] = TraceRay(new Ray(scene,x,y)); } } );}

JavaScript async• “Probably the most significant inclusion for Web developers is support for the Web Worker API. Conventionally, browser JavaScript has been strictly single-threaded, with no facility to perform computations in the background or use multicore processors. Web Workers change this, by allowing multiple scripts to execute simultaneously, opening the door to pages that are both more responsive and contain more complex scripting than is possible without Web Workers.” http://arstechnica.com/microsoft/news/2011/06/internet-explorer-10-platform-preview-2-shows-strong-progress.ars

Mind Your P’s and C’s P&C P&C Parallelism ConcurrencyPerformance Speedup Responsiveness Data race freedom,Correctness Determinism, Deadlock, Livelock, Linearizability, …

Tools for Sequential Programming (1)• The debugger is essential: – Set breakpoints – Single step the execution – Examine program state• Perform experiments: – If I change this variable’s value, will I reach the breakpoint?

Tools for Sequential Programming (2)• Assertions• Contracts• Unit tests

http://www.pex4fun.com/ Parameterized unit tests

State of Concurrency• Consider debugging a multi-threaded program• Set breakpoints B1, B2 in threads T1, T2 – Which will be hit first? – Can depend on thread schedule!• Can you do experiments in such a situation?

A Concurrency Unit Test Pattern: Fork-Joinvoid ForkJoinTest() { var t1 = new Thread(() => { S1 }); var t2 = new Thread(() => { S2 }); t1.Start(); t2.Start(); t1.Join(); t2.Join(); Debug.Assert(...);}

Tools for TeachingConcurrent Programming?

http://chesstool.codeplex.com/alpaca user User interface mcut user Concurrency unit testing CHESS Analysis engine

CHESS• A user-mode scheduler• Controls all scheduling nondeterminism – “Hijacks” scheduling control from the OS• Guarantees: – Every run takes a different thread schedule – Reproduce the schedule for every run• Gives user control over scheduling

CHESS• Preemption bounding [PLDI07] • Best-first search [PPoPP10] – speed search for bugs • Automatic linearizability – simple counterexamples checking [PLDI10]• Fair stateless exploration [PLDI08] • Concurrency unit testing – scales to large programs [IEEE Software 2011]• Architecture [OSDI08] • More features – Tasks and SyncVars – Data race detection – API wrappers – Partial order reduction• Store buffer simulation [CAV08] – More monitors…• Preemption sealing [TACAS10] – orthogonal to preemption bounding – where (not) to search for bugs

mcut: attribute-based concurrency unit testing• [UnitTestMethod] – simply run this method normally, and report failed assertions or uncaught exceptions• [DataRaceTestMethod] – Run a few schedules (using CHESS) and detect data races• [ScheduleTestMethod] – Run all possible schedules of this method (using CHESS)• [ConflictSerializabikityTestMethod]• . . .

Alpaca

Practical Parallel and Concurrent Programming: Courseware http://ppcp.codeplex.com/• What: 16 weeks (8 units) of material – Slides – Lecture notes – Quizzes, labs – Sample programs and applications – Tests and tools• Prerequisites – OO programming, data structures, operating systems• Dependencies: – Visual Studio 2010 (includes .NET 4.0, C#, F#)

Rest of Talk: Demos1. Basic concurrency unit testing and data races2. Checking student assignments3. Conflict serializability4. Linearizability

Example: Data Race Free Discipline• Data-Race-Free (DRF) Discipline means we write programs that have NO data races (not even “benign” ones).• Already “best practice” for many, but not all programmers.

Student Assignment• Madan Musuvathi – http://www.cs.washington.edu/education/courses /csep506/11sp/Home.html – Assignment 4.1

Atomic Method, Informally A method M is atomic ifM’s effects appear to other threads as if M executed without interruption Atomicity Violation: An error caused by unexpected lack of atomicity.

Method-level Atomicity via Conflict Serializability• Two operations conflict if – issued by different methods in different threads – they access the same memory location – at least one is a write• Conflicting operations are ordered and impose order on containing methods• M atomic w.r.t N iff for all executions: – not (M ordered-before N and N ordered-before M)

Linearizability • The correctness notion closest to “thread safety” • A concurrent component behaves as if only one thread can enter the component at a time Correctness Criteria for Parallelism &6/16/2010 29 Concurrency

Example: Linearizability [Herlihy & Wing ‘90] ConcurrentQueue behaves like a queue Concurrent are a sequential behaviors of consistent specificationConcurrentQueue with of a queue Every operation appears to occur atomically at some point between the call and return

Linearizability • Component is linearizable if all operations – Appear to take effect atomically at a single temporal point – And that point is between the call and the return • “As if the requests went to the queue one at a time”Client 1 Add 10 return Add 20 returnClient 2 TryTake return10Client 3 TryTake return “empty”

Linearizability vs Serializability?• Serializability – All operations (transactions) appear to take effect atomically at a single temporal point• Linearizability – All operations to take effect atomically at a single temporal point – That point is between the call and return – return -> call ordering observed across threads

6/16/2010 Correctness Criteria for Parallelism & Concurrency 33 Serializable behavior that is not LinearizableThread 1 Add 10 returnThread 2 TryTake return “empty” • Linearizability assumes that there is a global observer that can observe that Thread 1 finished before Thread 2 started

Formalizing Linearizability• Define the set of observables for each operation – Call operation: value of all the arugments – Return operation:• An event: Add 10 return – Thread Id, Object Id, Call/Return, Operation, Observables

A Concurrent History• Sequence of Events – <T1, q, Call, Add, 10> – <T2, q, Call, TryTake, void> – <T1, q, Ret, Add, void> – <T2, q, Ret, TryTake, “empty”>Thread 1 Add 10 returnThread 2 TryTake return “empty”

6/16/2010 Correctness Criteria for Parallelism & Concurrency 36 Equivalent Histories • Two concurrent histories are equivalent if • Each thread performs operations in the same order • And sees the same observationsClient 1 Add 10 return Add 20 returnClient 2 TryTake return10Client 1 Add 10 return Add 20 returnClient 2 TryTake return10

6/16/2010 Correctness Criteria for Parallelism & Concurrency 37Concurrent Operations in a History• Two operations p and q are concurrent in a history if their durations overlap • ! (p.ret < q.call || q.ret < p.call) Thread 1 Add 10 return Thread 2 return “empty” TryTake

6/16/2010 Correctness Criteria for Parallelism & Concurrency 38 Concurrent Operations in a History • Two operations p and q are concurrent in a history if their duration overlap • ! (p.ret < q.call || q.ret < p.call) • Non-Concurrent operations define a “performed- before” orderClient 1 Add 10 return Add 20 returnClient 2 TryTake return10

6/16/2010 Correctness Criteria for Parallelism & Concurrency 39Linearizability• A concurrent history is linearizable if it is equivalent to a (serial) history in the sequential specification, and• all operations that are “performed before” in the concurrent history are also “performed before” in the serial history

Conclusion: Concurrency Correctness• Important for students to understand• Supported by tools• For experimentation• And learning

http://ecoop11.comp.lancs.ac.uk	44
http://scc-sentinel.lancs.ac.uk	7
http://twitter.com	1

A tool based approach to conquering concurrent programming

by Raffi Khatchadourian on Jul 25, 2011

Accessibility

Categories

Upload Details

Usage Rights

3 Embeds 52

Statistics

A tool based approach to conquering concurrent programming — Presentation Transcript