Testing Concurrent Programs COMP 402 Production Programming Mathias

Testing Concurrent Programs COMP 402 - Production Programming Mathias Ricken Rice University Spring 2009

Moore’s Law *

Timeliness CPU clock frequencies stagnate Multi-Core CPUs provide additional processing power – Multiple threads needed to use multiple cores Writing concurrent programs is difficult!

Programming Examples

Unit Testing Unit tests… – Test a part, not the whole program – Occur earlier – Automate testing – Serve as documentation – Prevent bugs from reoccurring – Help keep the shared repository clean Effective with a single thread of control

Foundation of Unit Testing Unit tests depend on deterministic behavior Known input, expected output… Success correct behavior Failure flawed code Outcome of test is meaningful

Problems Due to Concurrency Thread scheduling is nondeterministic and machine-dependent – Code may be executed under different schedules – Different schedules may produce different results Known input, expected output… Success Failure correct behavior in this schedule, may be flawed in other schedule flawed code Success of unit test is meaningless

Possible Solutions Programming Language Features – Ensuring that bad things cannot happen – May restrict programmers Lock-Free Algorithms – Ensuring that if bad things happen, it’s ok – May limit data structures available Comprehensive Testing – Testing if bad things happen in any schedule – Does not prevent problems, but does not limit solutions either

Contributions Improvements to JUnit – Detect exceptions and failed assertions in threads other than the main thread Annotations for Concurrency Invariants – Express complicated requirements about locks and threads Tools for Schedule-Based Execution – Record, deadlock monitor – Random delays, random yields

Improvements to JUnit Uncaught exceptions and failed assertions – Not caught in child threads

Sample JUnit Tests public class Test extends Test. Case { public void test. Exception() { throw new Runtime. Exception("booh!"); } } public void test. Assertion() { Both tests assert. Equals(0, 1); fail. } } if (0!=1) throw new Assertion. Failed. Error();

Problematic JUnit Tests Main thread public class Test extends Test. Case { public void test. Exception() { new Thread(new Runnable() { public void run() { throw new Runtime. Exception("booh!"); } }). start(); Child thread } } end of Main thread spawns Child thread test uncaught! success!

Problematic JUnit Tests Main thread public class Test extends Test. Case { public void test. Exception() { new Thread(new Runnable() { public void run() { throw new Runtime. Exception("booh!"); } }). start(); Child Uncaught exception, thread } test should fail but } does not!

Improvements to JUnit Uncaught exceptions and failed assertions – Not caught in child threads Thread group with exception handler – JUnit test runs in a separate thread, not main thread – Child threads are created in same thread group – When test ends, check if handler was invoked

Thread Group for JUnit Tests Test thread public class Test extends Test. Case { public void test. Exception() { new Thread(new Runnable() { public void run() { throw new Runtime. Exception("booh!"); } }). start(); Child thread } invokes } checks Test. Group’s Uncaught Exception Handler

Thread Group for JUnit Tests Test thread public class Test extends Test. Case { public void test. Exception() { new Thread(new Runnable() { public void run() { throw new Runtime. Exception("booh!"); } }). start(); Child thread } spawns and waits resumes } Main failure! thread Test thread spawns Child thread end of test uncaught! invokes group’s handler check group’s handler

Improvements to JUnit Uncaught exceptions and failed assertions – Not caught in child threads Thread group with exception handler – JUnit test runs in a separate thread, not main thread – Child threads are created in same thread group – When test ends, check if handler was invoked Detection of uncaught exceptions and failed assertions in child threads that occurred before test’s end Past tense: occurred!

Child Thread Outlives Parent Test thread public class Test extends Test. Case { public void test. Exception() { new Thread(new Runnable() { public void run() { throw new Runtime. Exception("booh!"); } }). start(); Child thread } spawns and waits resumes } Main failure! thread Test thread spawns Child thread end of test uncaught! invokes group’s handler check group’s handler

Child Thread Outlives Parent Test thread public class Test extends Test. Case { public void test. Exception() { new Thread(new Runnable() { public void run() { throw new Runtime. Exception("booh!"); } }). start(); Child thread } check group’s resumes handler } Main spawns and waits success! thread Test thread spawns Too late! end of test Child thread uncaught! invokes group’s handler

Improvements to JUnit Child threads are not required to terminate – A test may pass before an error is reached Detect if any child threads are still alive – Declare failure if test thread has not waited – Ignore daemon threads, system threads (AWT, RMI, garbage collection, etc. ) Previous schedule is a test failure – Should be prevented by using Thread. join()

Enforced Join Test thread public class Test extends Test. Case { public void test. Exception() { Thread t = new Thread(new () { new Thread(new Runnable() Runnable { public void run() { { throw new Runtime. Exception("booh !"); throw new Runtime. Exception("booh!"); } } }); t. start(); … … t. join(); … Child } thread }

Improvements to JUnit Child threads are not required to terminate – A test may pass before an error is reached Detect if any child threads are still alive – Declare failure if test thread has not waited – Ignore daemon threads, system threads (AWT, RMI, garbage collection, etc. ) Previous schedule is a test failure – Should be prevented by using Thread. join()

Testing Conc. JUnit Replacement for junit. jar or as plugin JAR for JUnit 4. 2 – Available as binary and source at http: //www. concutest. org/ Results from Dr. Java’s unit tests – Child thread for communication with slave VM still alive in test – Several reader and writer threads still alive in low level test (calls to join() missing) Dr. Java currently does not use Conc. JUnit – Custom-made Test. Case class – Does not check if join() calls are missing

Conclusion Improved JUnit now detects problems in other threads – Only in chosen schedule – Needs schedule-based execution Annotations ease documentation and checking of concurrency invariants – Open-source library of Java API invariants Support programs for schedule-based execution

Future Work Schedule-Based Execution – Replay given schedule – Generate possible schedules – Dynamic race detection – Probabilities/durations for random yields/sleeps Extend annotations to Floyd-Hoare logic – Preconditions, postconditions – Representation invariants

Extra Slides

Tractability of Comprehensive Testing Test all possible schedules – Concurrent unit tests meaningful again Number of schedules (N) – t: # of threads, s: # of slices per thread detail

Extra: Number of Schedules Product of s-combinations For thread 1: choose s out of ts time slices For thread 2: choose s out of ts-s time slices … For thread t-1: choose s out of 2 s time slices For thread t-1: choose s out of s time slices Writing s-combinations using factorial Cancel out terms in denominator and next numerator Left with (ts)! in numerator and t numerators with s! back

Tractability of Comprehensive Testing If program is race-free, we do not have to simulate all thread switches – Threads interfere only at “critical points”: lock operations, shared or volatile variables, etc. – Code between critical points cannot affect outcome – Simulate all possible arrangements of blocks delimited by critical points Run dynamic race detection in parallel – Lockset algorithm (e. g. Eraser by Savage et al)

Critical Points Example Local Var 1 Thread 1 lock access unlock All lock accesses access unlock protected by lock Shared Var Lock Thread 2 All accesses protected by lock Local Var 1 access unlock All accesses protected by lock Local variables don’t need locking

Fewer Schedules Fewer critical points than thread switches – Reduces number of schedules – Example: Two threads, but no communication N=1 Unit tests are small – Reduces number of schedules Hopefully comprehensive simulation is tractable – If not, heuristics are still better than nothing

Limitations Improvements only check chosen schedule – A different schedule may still fail – Requires comprehensive testing to be meaningful May still miss uncaught exceptions – Specify absolute parent thread group, not relative – Cannot detect uncaught exceptions in a program’s uncaught exception handler (JLS limitation) details

Extra: Limitations May still miss uncaught exceptions – Specify absolute parent thread group, not relative (rare) Koders. com: 913 matches Thread. Group vs. 49, 329 matches for Thread – Cannot detect uncaught exceptions in a program’s uncaught exception handler (JLS limitation) Koders. com: 32 method definitions for uncaught. Exception method back

Extra: Dr. Java Statistics 2004 Unit tests passed failed not run Invariants met failed % failed KLOC “event thread” 736 610 36 90 5116 4161 965 18. 83% 107 1 2006 881 0 0 34412 30616 3796 11. 03% 129 99 back