Processor Allocation for Optimistic Parallelization of Irregular Programs

Optimistic parallelization is a promising approach for the parallelization of irregular algorithms: potentially interfering tasks are launched dynamically, and the runtime system detects conflicts between concurrent activities, aborting and rolling back conflicting tasks. However, parallelism in irregular algorithms is very complex. In a regular algorithm like dense matrix multiplication, the amount of parallelism can usually be expressed as a function of the problem size, so it is reasonably straightforward to determine how many processors should be allocated to execute a regular algorithm of a certain size (this is called the processor allocation problem). In contrast, parallelism in irregular algorithms can be a function of input parameters, and the amount of parallelism can vary dramatically during the execution of the irregular algorithm. Therefore, the processor allocation problem for irregular algorithms is very difficult. In this paper, we describe the first systematic strategy for addressing this problem. Our approach is based on a construct called the conflict graph, which (i) provides insight into the amount of parallelism that can be extracted from an irregular algorithm, and (ii) can be used to address the processor allocation problem for irregular algorithms. We show that this problem is related to a generalization of the unfriendly seating problem and, by extending Tur'an’s theorem, we obtain a worst-case class of problems for optimistic parallelization, which we use to derive a lower bound on the exploitable parallelism. Finally, using some theoretically derived properties and some experimental facts, we design a quick and stable control strategy for solving the processor allocation problem heuristically.

💡 Research Summary

This paper tackles the long‑standing processor‑allocation problem that arises when applying optimistic parallelization to irregular algorithms. Unlike regular kernels such as dense matrix multiplication, where parallelism can be expressed as a simple function of problem size, irregular programs exhibit data dependencies that vary with input parameters and even change dramatically during execution. Consequently, determining the appropriate number of processors to allocate at any moment is non‑trivial.

The authors introduce the conflict graph as a formal model of potential data conflicts. Each task is represented by a vertex, and an edge connects two vertices if the corresponding tasks may interfere when executed concurrently. The size of a maximum independent set in this graph exactly equals the number of tasks that can safely run in parallel, linking processor allocation directly to a classic combinatorial property. However, computing a maximum independent set is NP‑hard, and the conflict graph itself evolves dynamically, making exact calculation infeasible at runtime.

To obtain a tractable bound, the paper draws an analogy to the unfriendly seating problem, a variant of graph coloring where adjacent vertices must be placed on different “seats.” By extending Turán’s theorem, the authors derive a new inequality that provides a worst‑case lower bound on the size of an independent set for graphs whose degree distribution may change over time. This bound is expressed in terms of the average degree and a parameter that captures the variability of conflicts, offering a theoretical guarantee on the minimal exploitable parallelism regardless of how the conflict graph evolves.

Armed with this theoretical insight, the authors propose a two‑phase allocation strategy. In the pre‑analysis phase, static information about the input (e.g., expected average degree of the conflict graph) is used to set an initial processor count. During the runtime phase, the system continuously monitors two key metrics: the commit success rate (the fraction of launched tasks that complete without abort) and the observed conflict rate. A feedback controller adjusts the processor count incrementally—reducing it when conflicts are frequent and increasing it when the success rate rises—while applying damping and hard limits to avoid oscillations. This heuristic, history‑based control loop requires only lightweight measurements and no expensive graph‑theoretic computations.

Experimental evaluation on a suite of irregular benchmarks—including graph traversal, dynamic programming on irregular data structures, and unstructured mesh computations—demonstrates that the adaptive scheme consistently outperforms static allocations. On average, the adaptive approach yields a 30 % improvement in throughput and reduces total execution time, especially in phases where conflict density spikes. Moreover, the controller remains stable even when the underlying conflict graph undergoes abrupt degree changes, confirming the robustness of the design.

In summary, the paper makes three principal contributions: (1) a conflict‑graph model that quantifies parallelism in irregular programs; (2) an extension of Turán’s theorem that supplies a worst‑case lower bound on exploitable parallelism; and (3) a practical, low‑overhead feedback controller that solves the processor‑allocation problem heuristically. Together, these advances provide the first systematic, theoretically grounded, and experimentally validated solution for allocating processors in optimistic parallelization of irregular workloads, opening new avenues for dynamic scheduling and resource management in future multicore systems.