Abstract not found

Building correct and efficient concurrent algorithms is known to be a difficult problem of fundamental importance. To achieve efficiency, designers try to remove unnecessary and costly synchronization. However, not only is this manual trial-and-error process ad-hoc, time consuming and error-prone, but it often leaves designers pondering the question of: is it inherently impossible to eliminate certain synchronization, or is it that I was unable to eliminate it on this attempt and I should keep trying? In this paper we respond to this question. We prove that it is impossible to build concurrent implementations of classic and ubiquitous specifications such as sets, queues, stacks, mutual exclusion and read-modify-write operations, that completely eliminate the use of expensive synchronization. We prove that one cannot avoid the use of either: i) read-afterwrite

Software tools for program debugging, software testing, software maintenance, and program understanding have all effectively utilized static program slicing techniques. In this paper, we present an approach to extend this capability to explicitly parallel shared memory programs written using the OpenMP standard. In particular, interprocedural static program slicing of OpenMP programs is enabled by extending standard program representations for control flow and program dependences to support OpenMP parallel, data, and synchronization constructs. The slicing algorithm builds on the algorithms for interprocedural slicing of sequential programs and an algorithm for intraprocedural slicing of parallel programs. Keywords – shared memory parallel programming,

t a = 1 a=0,t=0,k=0 output t=0, k=0 t=1, k=1 output t=0, k=0 t=1, k=1 t=0, k=1 Thread 1 Thread 2 a b g t = a k = a a = 1 a=0,t=0,k=0 Thread 1 Thread 2 a b g 8 Incorrect Loop Invariant Code Motion . t = a + 1 is a loop invariant in classical sense, but moving it outside makes the loop infinite. a = 0 x = 0 y = 0 cobegin || a = 1 coend t = a + 1 do while (x <> 2) x = t end do do while (x <> 2) t = a + 1 x = t end do 9 Incorrect Dead Code Elimination . An instruction I is dead if it computes values that are not used in any executable path starting at I. . Eliminating flag = 1 in Thread 1 makes the while loop in Thread 2 infinite. flag = 1 do While (flag==0) end do Thread 1 Thread 2 a 10 Program vseq integer a,b,c,d,e a = 0 b = 0 c = 0 d = 0 e = 0

c ○ Jun Chen 2009I hereby declare that I am the sole author of this thesis. This is a true copy of the thesis, including any required final revisions, as accepted by my examiners. I understand that my thesis may be made electronically available to the public. Testing concurrent programs remains a difficult task due to the non-deterministic nature of concurrent execution. Many approaches have been proposed to tackle the complexity of uncovering potential concurrency bugs. Static analysis tackles the problem by analyzing a concurrent program looking for situations/patterns that might lead to possible errors during execution. In general, static analysis cannot precisely locate all possible concurrent errors. Dynamic testing examines and controls a program during its execution also looking for situations/patterns that might lead to possible errors during execution. In general, dynamic testing needs to examine all possible execution paths to detect all errors, which is intractable. Motivated by these observation, a new testing technique is developed that uses a collaboration between static analysis and dynamic testing to find the first potential error