This paper presents a novel interprocedural, flow-sensitive, and context-sensitive pointer analysis algorithm for multithreaded programs that may concurrently update shared pointers. For each pointer and each program point, the algorithm computes a conservative approximation of the memory locations to which that pointer may point. The algorithm correctly handles a full range of constructs in multithreaded programs, including recursive functions, function pointers, structures, arrays, nested structures and arrays, pointer arithmetic, casts between pointer variables of different types, heap and stack allocated memory, shared global variables, and thread-private global variables. We have implemented the algorithm in the SUIF compiler system and used the implementation to analyze a sizable set of multithreaded programs written in the Cilk multithreaded programming language. Our experimental results show that the analysis has good precision and converges quickly for our set of Cilk programs.

This paper presents a novel framework for the symbolic bounds analysis of pointers, array indices, and accessed memory regions. Our framework formulates each analysis problem as a system of inequality constraints between symbolic bound polynomials. It then reduces the constraint system to a linear program. The solution to the linear program provides symbolic lower and upper bounds for the values of pointer and array index variables and for the regions of memory that each statement and procedure accesses. This approach eliminates fundamental problems associated with applying standard xed-point approaches to symbolic analysis problems. Experimental results from our implemented compiler show that the analysis can solve several important problems, including static race detection, automatic parallelization, static detection of array bounds violations, elimination of array bounds checks, and reduction of the number of bits used to store computed values.

A compiler for multi-threaded object-oriented programs needs information about the sharing of objects for a variety of reasons: to implement optimizations, to issue warnings, to add instrumentation to detect access violations that occur at runtime. An Object Use Graph (OUG) statically captures accesses from different threads to objects. An OUG extends the Heap Shape Graph (HSG), which is a compile-time abstraction for runtime objects (nodes) and their reference relations (edges). An OUG specifies for a specific node in the HSG a partial order of events relevant to the corresponding runtime object(s). Relevant events include read and write access, object escape, thread start and join. OUGs have been implemented...

One of the important issues in parallel program debugging is an efficient detection of access anomalies caused by uncoordinated access to shared variables. On-the-fly detection of access anomalies has the major advantage that it reports only actual anomalies during execution while static analysis methods report all the potential anomalies, many of which cannot actually materialize during execution. It also has the advantage that shorter traces are produced for post-mortem analysis purposes if an anomaly is detected. The reason for this is that after an anomaly occurs, further trace information is of dubious value because the first anomaly may have affected subsequent program behavior. So, once the first anomaly occurs, no further trace information need be generated. Existing methods for on-the-fly access anomaly detection suffer from performance penalties since the execution of the program being debugged has to be interrupted on every access to shared variables. In this paper, we propo...

Understanding synchronization is important for a parallel programming tool that uses dependence analysis as the basis for advising programmers on the correctness of parallel constructs. This paper discusses static analysis methods that can be applied to parallel programs with event variable synchronization. The objective is to be able to predict potential data races in a parallel program. The focus is on how dependences and synchronization statements inside loops can be used to analyze complete programs with parallel loop and parallel case style parallelism. 1 Introduction Parallel programming is an intellectually demanding task. One of the most difficult challenges in the development of parallel programs for asynchronous sharedmemory systems is avoiding errors caused by inadvertent data sharing, often referred to as data races, which can lead to unpredictable results. These races correspond to data dependences [AK87, Wol82], where a data dependence links a pair of accesses to the sam...

Model-Checking R'egis Cridlig Laboratoire d'Informatique de l'Ecole Normale Sup'erieure (URA CNRS 1327) Abstract In this article we present a true-concurrent operational semantics of a Pascal-like language with a parallel operator and shared memory. This semantics is based on a higherdimensional transition system that is able to model the asynchronous execution of concurrent operations. We show how it can be usefully abstracted to finite automata via abstract interpretation using folding of states and appropriate widening operators. Then we compute static properties relevant to the standard concurrent execution of the program by means of modelchecking on the abstract automata that were previously derived; for instance, approximations of the values of shared variables and temporal properties about standard execution paths can be obtained effectively with a high degree of accuracy. 1 Introduction In the area of static analysis of concurrent programs, that is the effective computat...

Unified Modeling Language (UML) is gaining acceptance to describe the behaviour of systems. It has attracted the attention of researchers that are interested in deriving, automatically, performance evaluation models from system’s descriptions. A required step to automatically produce a performance model (as any executable model) is that the semantics of the description language is formally defined. Among the UML diagrams, we concentrate on States Machines (SMs) and we build a semantics for a significant subset of them in terms of Generalized Stochastic Petri Nets (GSPNs). The paper shows how to derive an executable GSPN model from a description of a system, expressed as a set of SMs. The semantics is compositional since the executable GSPN model is obtained by composing, using standard Petri net operators, the GSPN models of the single SMs, and each GSPN model is obtained by composition of submodels for SM basic features. 1

Performance is often a key factor in determining the success of a parallel software system. Performance evaluation...

This paper presents a novel interprocedural, ow-sensitive, and context-sensitive pointer analysis algorithm for multithreaded programs that may concurrently update shared pointers. The algorithm is designed to handle programs with structured parallel constructs, including fork-join constructs, parallel loops, and conditionally spawned threads. For each pointer and each program point, the algorithm computes a conservative approximation of the memory locations to which that pointer may point. The algorithm correctly handles a wide range of programming language constructs, including recursive functions, recursively generated parallelism, function pointers, structures, arrays, nested structures and arrays, pointer arithmetic, casts between dierent pointer types, heap and stack allocated memory, shared global variables, and thread-private global variables. We have implemented the algorithm in the SUIF compiler system and used the implementation to analyze a set of multithreaded programs written in the Cilk programming language. Our experimental results show that the analysis has good precision and converges quickly for our set of Cilk programs

Phred is a visual parallel programming language in which programs can be statically analyzed for deterministic behavior. This paper presents the Phred language, techniques for analyzing the language, and a programming environment which supports Phred programming. There are many methods for specifying synchronization and data sharing in parallel programs. The Phred programmer uses graph constructs for describing parallelism, synchronization and data sharing. These graphs are formally described in this paper as a graph grammar. The use of graphs in Phred provides an intuitive and visual representation for parallel computations. The inadvertent specification of nondeterministic computations is a common error in parallel programming. Phred addresses the issue of determinacy by visually indicating regions of a program where nondeterminacy may exist. This analysis and its integration into a programming environment is presented here. The Phred programming environment supports the specificatio...