Challenges of Translating HPC codes to Workflows for Heterogeneous and Dynamic Environments

Fayssal Benkhaldoun, Christophe Cérin, Imad Kissami, Walid SaadHPCS 2017 · DOI · OpenReview

TL;DR

This paper tackles the challenge of converting traditional High-Performance Computing (HPC) codes, like those used for Computational Fluid Dynamics (CFD), into dynamic scientific workflows. They propose a method to represent these codes as task graphs and execute them on the RedisDG workflow engine, which is designed for heterogeneous and dynamic environments, paving the way for "HPC as a Service."

What Problem Does This Paper Address?

Modern scientific simulations, particularly in fields like Computational Fluid Dynamics (CFD), often rely on complex, parallel HPC codes. These codes are typically developed using standards like MPI or OpenMP and can be computationally intensive, requiring significant time to run. The challenge lies in making these existing, often monolithic, HPC applications more adaptable and accessible within the emerging paradigms of cloud computing and "HPC as a Service." Specifically, the authors aim to transform these parallel codes into scientific workflows that can be executed on heterogeneous and dynamic environments, where resources are not always predictable. This involves bridging the gap between traditional HPC programming and the more flexible, service-oriented approach of workflow management systems.

Methods

The core of the paper's methodology involves transforming a parallel HPC code into a workflow represented as a Directed Acyclic Graph (DAG). They use a CFD application, ADAPT, as a case study. The process involves:

  1. Code to DAG Transformation: The parallel ADAPT algorithm, originally described in pseudo-code, is converted into a DAG where each node represents a step or a parallelizable component of the algorithm (e.g., mesh splitting, linear system solving, iterative computations). Dependencies between these nodes are explicitly defined, forming the workflow structure.
  2. Workflow Engine: RedisDG: The transformed DAG is then executed by the RedisDG workflow engine. RedisDG is designed to handle heterogeneous and dynamic environments by employing opportunistic scheduling strategies and a publish-subscribe mechanism for resource discovery and allocation.
  3. Dynamic Task Graph Unfolding: A key aspect is the ability to "unfold" the task graph dynamically. This means that a single node in the workflow might represent a task that can be executed using different runtime models or further decomposed into sub-tasks depending on the available resources and system conditions. This dynamic unfolding is crucial for optimizing performance in unpredictable environments.

Datasets

Not discussed in the paper. The paper focuses on transforming an existing HPC code (ADAPT) into a workflow rather than training on or evaluating against specific datasets.

Key Insights and Ideas

  • "HPC as a Service" Potential: The paper strongly advocates for the potential of "HPC as a Service" by demonstrating how existing HPC codes can be adapted to run on dynamic, heterogeneous platforms through workflows.
  • Dynamic Unfolding is Key: The ability to dynamically unfold task graphs is presented as a critical feature for achieving performance gains in dynamic environments. This allows the workflow engine to adapt its execution strategy on the fly.
  • Bridging Paradigms: The work highlights the necessity of revisiting traditional HPC thinking to embrace new paradigms like cloud and edge computing, moving from tightly coupled parallel codes to more service-oriented, workflow-based approaches.
  • Challenges in Heterogeneity: The paper acknowledges the significant challenges in managing and executing workflows across diverse and unpredictable computing environments, emphasizing the need for flexible scheduling and resource management.

Key Results

The paper presents a methodology and a case study demonstrating the transformation of a parallel CFD code into a scientific workflow executable on the RedisDG engine. While specific quantitative results (e.g., speedup percentages) are not detailed, the paper successfully illustrates:

  • The feasibility of representing complex parallel HPC codes as DAGs.
  • The integration of these workflows with the RedisDG engine, which supports dynamic and heterogeneous environments.
  • The conceptual framework for dynamically unfolding task graphs to adapt to varying resource availability and execution models.

Limitations and Future Work

  • Dynamic Unfolding Complexity: The paper acknowledges that the dynamic unfolding of task graphs introduces significant challenges for the workflow engine's architecture and coordination mechanisms.
  • Formalizing Business Rules: The authors suggest that future work could involve formalizing the "business rules" for task decomposition and execution model selection, potentially using guarded attribute grammars.
  • New Communication Channels: To fully support Data Life Cycle (DLC) and Execution Model (EM) requirements, new communication channels within the RedisDG protocol are proposed to be added for better interaction between components.
  • Formal Model for Task Decomposition: The paper hints at the need for a more formal model to describe how tasks can be decomposed and executed, moving beyond programmer experience.
  • Quantitative Performance Evaluation: While the methodology is presented, a detailed quantitative analysis of performance improvements achieved through this workflow approach compared to the original HPC code is not provided.

Summary updated

Abstract

In this paper we would like to share our experience for transforming a parallel code for a Computational Fluid Dynamics (CFD) problem into a parallel version for the RedisDG workflow engine. This system is able to capture heterogeneous and highly dynamic environments, thanks to opportunistic scheduling strategies. We show how to move to the field of "HPC as a Service" in order to use heterogeneous platforms. We mainly explain, through the CFD use case, how to transform the parallel code and we exhibit challenges to 'unfold' the task graph dynamically in order to improve the overall performance (in a broad sense) of the workflow engine. We discuss in particular of the impact on the workflow engine of such dynamic feature. This paper states that new models for High Performance Computing are possible, under the condition we revisit our mind in the direction of the potential of new paradigms such as cloud, edge computing.
BibTeX
@inproceedings{benkhaldoun2017challenges,
  author = {Fayssal Benkhaldoun and Christophe Cérin and Imad Kissami and Walid Saad},
  title = {{Challenges of Translating HPC codes to Workflows for Heterogeneous and Dynamic Environments}},
  booktitle = {HPCS},
  year = {2017},
  doi = {10.1109/hpcs.2017.130},
}
Figure