Complexity of Data Dependence problems for Program Schemas with Concurrency

The problem of deciding whether one point in a program is data dependent upon another is fundamental to program analysis and has been widely studied. In this paper we consider this problem at the abstraction level of program schemas in which computations occur in the Herbrand domain of terms and predicate symbols, which represent arbitrary predicate functions, are allowed. Given a vertex l in the flowchart of a schema S having only equality (variable copying) assignments and variables v,w, we show that it is PSPACE-hard to decide whether there exists an execution of a program defined by S in which v holds the initial value of w at at least one occurrence of l on the path of execution, with membership in PSPACE holding provided there is a constant upper bound on the arity of any predicate in S. We also consider the `dual’ problem in which v is required to hold the initial value of w at every occurrence of l, for which the analogous results hold. Additionally, the former problem for programs with non-deterministic branching (in effect, free schemas) in which assignments with functions are allowed is proved to be polynomial-time decidable provided a constant upper bound is placed upon the number of occurrences of the concurrency operator in the schemas being considered. This result is promising since many concurrent systems have a relatively small number of threads (concurrent processes), especially when compared with the number of statements they have.

💡 Research Summary

The paper investigates the computational complexity of data‑dependence questions formulated at the level of program schemas, a highly abstract representation in which statements are expressed as assignments over the Herbrand domain of terms and arbitrary predicate symbols may appear. Two fundamental decision problems are defined. The first, an “existential” dependence query, asks whether there exists an execution of a program defined by a given schema S such that at a designated flow‑graph vertex ℓ a variable v holds the initial value of another variable w at least once along the execution path. The second, a “universal” dependence query, requires that v hold w’s initial value at every occurrence of ℓ in the execution.

The authors first restrict attention to schemas that contain only equality (copy) assignments and involve exactly two variables, v and w. Under this restriction they prove that both the existential and universal dependence problems are PSPACE‑hard. The hardness proof encodes the computation of a space‑bounded nondeterministic Turing machine into the control‑flow graph of the schema, using predicate symbols to simulate the machine’s transition relation. When the arity of every predicate symbol is bounded by a constant, the number of distinct Herbrand terms that can appear during any execution is polynomially bounded, which yields membership in PSPACE. Consequently, the problems are PSPACE‑complete under a constant‑arity assumption.

The paper then turns to “free” schemas, which allow nondeterministic branching and arbitrary functional assignments. In this richer setting the authors show that if the number of occurrences of the concurrency operator (∥) is bounded by a constant k, the existential dependence problem becomes solvable in polynomial time. The key insight is that a constant bound on concurrent threads limits the size of the global state space: each thread’s local data‑flow can be analyzed independently, and only the k synchronization points introduced by the ∥ operators need to be examined for cross‑thread interactions. By constructing a product of the k local flow graphs and checking the reachability of a configuration where v equals the initial w, the algorithm runs in time polynomial in the size of the schema.

These results have several important implications. First, they demonstrate that adding concurrency to program schemas dramatically raises the worst‑case complexity of data‑dependence analysis—from P or NP in sequential settings to PSPACE in the general concurrent case. Second, they identify concrete structural restrictions (constant predicate arity, a constant number of concurrent threads) that bring the problem back into tractable classes, offering a theoretical justification for the design of static analysis tools that target systems with a small, fixed number of threads (e.g., embedded controllers, real‑time applications). Third, the work clarifies the trade‑off between abstraction power and algorithmic feasibility: while schemas provide a clean, language‑independent model for reasoning about data flow, unrestricted use of predicates and unbounded concurrency quickly leads to intractability.

In summary, the paper contributes a detailed complexity landscape for data‑dependence problems on concurrent program schemas. It establishes PSPACE‑hardness for the general case, PSPACE‑completeness under a constant‑arity bound, and polynomial‑time decidability when the concurrency operator is used only a constant number of times. These findings guide both theoreticians, who seek tight complexity bounds for program‑analysis problems, and practitioners, who must decide which abstractions and restrictions are acceptable for building efficient, sound static analysis tools.