Low-contention depth-first scheduling of parallel computations with write-once synchronization variables

• Authors: Panagiota Fatourou
• Venue: Proceedings of the thirteenth annual ACM symposium on Parallel algorithms and architectures
• Year: 2001

We present an efficient, randomized, online, scheduling algorithm for a large class of programs with write-once synchronization variables. The algorithm combines the work-stealing paradigm with the depth-first scheduling technique, resulting in high space efficiency and good time complexity. By automatically increasing the granularity of the work scheduled on each processor, our algorithm achieves good locality, low contention and low scheduling overhead, improving upon a previous depth-first scheduling algorithm [6] published in SPAA '97. Moreover, it is probably efficient for the general class of multithreaded computations with write-once synchronization variables (as studied in [6]), improving upon algorithm DFDeques (published in SPAA'99 [24]), which is only for the more restricted class of nested parallel computations.More specifically, consider such a computation with work T 1, depth T ∞ and &sgr; synchronizations, and suppose that space S 1 suffices to execute the computation on a single-processor computer. Then, on a P-processor shared-memory parallel machine, the expected space complexity of our algorithm is at most S 1 + &Ogr;(PT∞ log (PT∞)), and its expected time complexity is &Ogr;(T 1/P + &sgr; log (PT∞)/P + T∞ log (PT∞)). Moreover, for any ∈ 0, the space complexity of our algorithm is S 1 + &Ogr;(P(T∞ + ln(1/∈)) log(P(T∞ + ln(P(T∞(1/∈))/∈)))) with probability at least 1 — ∈. Thus, even for values of ∈ as small ∈ —T∞, the space complexity of our algorithm is at most S 1 + &Ogr;(PT∞ log(PT∞)) with probability at least 1 — ∈ —T∞. These bounds include all time and space costs for both the computation and the scheduler.