[Paper Review] Parallelizing Bisection Root-Finding: A Case for Accelerating Serial Algorithms in Multicore Substrates

Mohammad Bakhshalipour, Hamid Sarbazi‐Azad|arXiv (Cornell University)|May 11, 2018

Parallel Computing and Optimization Techniques43 references3 citations

TL;DR

This paper proposes Runahead Computing, a software-only technique that accelerates inherently serial algorithms like bisection root-finding by utilizing idle threads in multicore and GPU architectures to speculatively execute ahead of the main thread. The method achieves up to 9x speedup on CPU and GPU platforms by reducing execution latency through speculative pre-computation, especially when the input function's computation time exceeds thread creation overhead.

ABSTRACT

Multicore architectures dominate today's processor market. Even though the number of cores and threads are pretty high and continues to grow, inherently serial algorithms do not benefit from the abundance of cores and threads. In this paper, we propose Runahead Computing, a technique which uses idle threads in a multi-threaded architecture for accelerating the execution time of serial algorithms. Through detailed evaluations targeting both CPU and GPU platforms and a specific serial algorithm, our approach reduces the execution latency up to 9x in our experiments.

Motivation & Objective

• To address the performance bottleneck of inherently serial algorithms on multicore and manycore systems, where only one core is utilized despite abundant idle threads.
• To explore software-based techniques that exploit idle threads for accelerating single-threaded workloads without requiring hardware modifications.
• To evaluate the effectiveness of Runahead Computing on both CPU and GPU platforms using bisection root-finding as a case study.
• To analyze the sensitivity of speedup to input function latency and thread creation overhead in different architectures.

Proposed method

• Runahead Computing uses idle threads to speculatively execute code ahead of the main thread, aiming to reduce the main thread's execution time when it reaches the same computational point.
• The technique involves creating multiple threads that compute values in parallel, with the main thread later using the precomputed results to skip redundant computation.
• For bisection root-finding, the method splits the search interval and uses idle threads to compute function values at intermediate points in advance.
• The approach relies on software-level thread creation and synchronization, avoiding hardware modifications, making it deployable on commercial off-the-shelf processors.
• Performance is evaluated by measuring execution time reduction across varying numbers of threads and input function latencies.
• The method is applied to both CPU (CMP) and GPU platforms, with different thread creation and synchronization overheads influencing scalability.

Experimental results

Research questions

• RQ1 Can idle threads in multicore and manycore systems be effectively used to accelerate inherently serial algorithms without hardware modifications?
• RQ2 How does the performance of Runahead Computing scale with increasing thread count on CPU and GPU platforms?
• RQ3 What is the impact of input function computation latency on the effectiveness of Runahead Computing?
• RQ4 How do thread creation and synchronization overheads affect speedup, especially in CPU versus GPU environments?

Key findings

• Runahead Computing achieved up to 9x speedup in execution time reduction on the GPU platform when using 1023 threads, with near-perfect scaling due to low thread creation overhead.
• On the CPU, the method reduced execution latency to 38% of the baseline using seven threads, demonstrating strong scalability despite higher thread management overhead.
• When the input function's computation latency was low (e.g., 10 iterations of Taylor series), Runahead Computing degraded performance by up to 86% on CPU due to thread creation overhead, but improved performance by 97% when latency exceeded 10,000 iterations.
• On GPU, even with minimal function latency (10 iterations), Runahead Computing achieved a 19% performance improvement, reaching 99% of ideal speedup at 500+ iterations, due to low synchronization costs.
• The method showed that performance scaling is limited by thread creation and synchronization overhead on CPU, while GPU’s fine-grained multithreading enables near-ideal scalability.
• The results confirm that Runahead Computing is most effective when the computational cost of the input function exceeds the cost of thread management, making it suitable for compute-intensive serial workloads.