[Paper Review] Task parallel implementation of a solver for electromagnetic scattering problems

Afshin Zafari, Elisabeth Larsson+5 more|arXiv (Cornell University)|Jan 10, 2018

Electromagnetic Scattering and Analysis23 references3 citations

TL;DR

This paper presents a task-parallel implementation of a nested equivalent source approximation (NESA) solver for electromagnetic scattering problems using a task-based programming model. By leveraging asynchronous task execution and dynamic load balancing, the approach achieves near-optimal performance on shared-memory systems when task sizes are sufficiently large, demonstrating excellent scalability for 3D problems with millions of unknowns.

ABSTRACT

Electromagnetic computations, where the wavelength is small in relation to the geometry of interest, become computationally demanding. In order to manage computations for realistic problems like electromagnetic scattering from aircraft, the use of parallel computing is essential. In this paper, we describe how a solver based on a hierarchical nested equivalent source approximation can be implemented in parallel using a task based programming model. We show that the effort for moving from the serial implementation to a parallel implementation is modest due to the task based programming paradigm, and that the performance achieved on a multicore system is excellent provided that the task size, depending on the method parameters, is large enough.

Motivation & Objective

• Address the computational challenges of solving large-scale electromagnetic scattering problems involving millions to billions of unknowns.
• Overcome the limitations of serial and traditional MPI-based parallel implementations by exploiting shared-memory multicore architectures.
• Enable efficient parallelization of the NESA algorithm, which relies on hierarchical matrix structures and low-rank approximations for far-field interactions.
• Evaluate the performance of task-based parallelization using SuperGlue and compare it with OpenMP for varying task sizes and thread counts.
• Demonstrate that task-based models can effectively manage the complex dependencies and load imbalances inherent in hierarchical solvers like NESA.

Proposed method

• Adopt a task-based programming model using the SuperGlue runtime system to express parallelism in the NESA algorithm.
• Structure computations into independent tasks for near-field and far-field matrix-vector products (MVP), enabling asynchronous execution.
• Use protected shared data types (e.g., SGMatrix) with dependency tracking to safely share matrices across tasks.
• Implement MVP tasks via BLAS-3 calls (cblas_dgemv) with read/write access tracking to support task reordering and load balancing.
• Apply hierarchical tree decomposition of the geometry to partition interactions into near-field (dense) and far-field (low-rank) components.
• Ensure load balancing by dynamically scheduling tasks based on computational cost, particularly for unbalanced tree structures.

Experimental results

Research questions

• RQ1 Can a task-based parallel model effectively scale the NESA solver on shared-memory systems for large 3D electromagnetic scattering problems?
• RQ2 How does task size impact performance and scalability in a task-parallel NESA implementation?
• RQ3 What is the performance trade-off between SuperGlue and OpenMP for task-parallel MVP computations in hierarchical solvers?
• RQ4 To what extent does the asynchronous nature of task execution improve load balancing and utilization in the presence of irregular workloads?
• RQ5 Can the task-based approach achieve near-optimal speedup without requiring extensive code refactoring from a serial implementation?

Key findings

• The task-based approach enabled a highly efficient parallel implementation with minimal changes to the original serial code, demonstrating the model's practicality.
• Performance is excellent when task sizes are large enough—achieving near-optimal speedup on multicore systems for 3D problems with millions of unknowns.
• For small task sizes typical in 2D problems, scaling is limited to just a few threads due to task overhead, but this limitation disappears in 3D problems with larger tasks.
• SuperGlue outperforms OpenMP in handling small task sizes and higher thread counts, particularly due to better support for fine-grained task dependencies and dynamic scheduling.
• The performance of both SuperGlue and OpenMP converges for large task sizes, indicating that OpenMP can achieve comparable performance with careful tuning.
• Asynchronous task execution and commutative access semantics for output vectors significantly improved load balancing and enabled efficient mixing of near-field and far-field computations.