Programming languages with algorithmically parallelizing problem

The study consists of two parts. Objective of the first part is modern language constructions responsible for algorithmically insolvability of parallelizing problem. Second part contains several ways to modify the constructions to make the problem algorithmically solvable

💡 Research Summary

The paper is divided into two complementary parts that together address the fundamental difficulty of automatically detecting parallelism in programs that manipulate arrays. In the first part the author analyses why modern programming language constructs make the “Dependency In Loop Detection” (DILD) problem algorithmically unsolvable for a wide class of programs. By modeling a program as a set of functions and control flow, the study shows that the data dependencies between loop iterations can be expressed as integer “connection equations”. When the index expressions are linear or at most cubic, these equations can be solved algorithmically, but as soon as the index expressions become higher‑degree polynomials (degree ≥ 4) the existence of a solution to the connection equations becomes undecidable. This result is proved by reduction to the halting problem and demonstrates that for such “complex” loops no general algorithm can decide whether two iterations are independent, and therefore no compiler can guarantee automatic parallelisation.

The second part proposes a language‑design solution that sidesteps the undecidability. The author introduces a modified index semantics and a “separated form” of loops, where the loop body is split into a chain of special sub‑programs: controllers that compute index values and a kernel that performs the actual data manipulation. Because the index calculations are made explicit and restricted to simple equality checks, the connection equations become trivial, and the DILD problem collapses to a polynomial‑time decision. The resulting language is both data‑full (any data set can be defined by the language’s set‑definition constructs) and algorithm‑full (any algorithm can be expressed using the same constructs).

To demonstrate practical relevance, the paper describes a prototype system called “Dictionary Driven Reports” that implements the proposed non‑procedural language for business data processing. The system defines data sets through formal logical definitions and automatically generates parallel execution plans for a torus‑shaped multiprocessor network where each node communicates only with its left and right neighbours. Experiments show that the locally controlled execution model achieves the same throughput as a centralized controller while offering superior fault tolerance.

The author also classifies parallelisation levels (operator‑internal, operator‑level, block/segment level, and task level) and argues that the feasibility of levels 2 and 3 hinges on the solvability of DILD. For the “LI class” (linear index expressions) existing algorithms such as Lamport’s Do‑loop parallelisation work well, but they cannot be extended to more complex index forms. The paper therefore establishes a clear theoretical boundary between parallelisable and non‑parallelisable program classes and provides a concrete language‑level mechanism to move programs from the latter into the former.

In summary, the study makes three major contributions: (1) a rigorous proof that detecting loop‑iteration dependencies is undecidable for programs with high‑degree index expressions; (2) a formal redesign of loop syntax and index semantics that renders the dependency problem tractable; and (3) an implementation prototype that validates the approach in a real‑world business‑data scenario. The work bridges theoretical computer science and practical parallel‑programming language design, offering a pathway toward fully automatic parallelisation for a broad class of data‑intensive applications.