[Paper Review] Speeding up Python-based Lagrangian Fluid-Flow Particle Simulations via Dynamic Collection Data Structures

Christian Kehl, Erik van Sebille+1 more|arXiv (Cornell University)|Apr 30, 2021

Advanced Data Storage Technologies16 references4 citations

TL;DR

This paper proposes using dynamic collection data structures—particularly double-linked lists—within Python-based Lagrangian fluid-flow simulations to overcome performance bottlenecks caused by frequent insertions and deletions in static, array-based collections. By integrating these structures via ctypes-based C-bindings, the authors achieve significant speedups, especially for large particle systems (>2¹⁵ particles), with double-linked lists showing the highest performance gains in dynamic scenarios.

ABSTRACT

Array-like collection data structures are widely established in Python's scientific computing-ecosystem for high-performance computations. The structure maps well to regular, gridded lattice structures that are common to computational problems in physics and geosciences. High performance is, however, only guaranteed for static computations with a fixed computational domain. We show that for dynamic computations within an actively changing computational domain, the array-like collections provided by NumPy and its derivatives are a bottleneck for large computations. In response, we describe the integration of naturally-dynamic collection data structures (e.g. double-linked lists) into NumPy simulations and extit{ctypes}-based C-bindings. Our benchmarks verify and quantify the performance increase attributed to the change of the collection data structure. Our application scenario, a Lagrangian (oceanic) fluid-flow particle simulation within the extit{Parcels} framework, demonstrates the speed-up yield in a realistic setting and demonstrates the novel capabilities that are facilitated by optimised collection data structures.

Motivation & Objective

• To identify and quantify performance bottlenecks in Python-based Lagrangian fluid-flow simulations caused by dynamic data reorganization in array-like collections.
• To evaluate alternative dynamic data structures—such as structure-of-arrays (SoA), list-of-arrays (LoA), and double-linked lists—for improved performance in particle simulations.
• To enable high-performance, JIT-compiled C-kernel execution by designing data structures compatible with ctypes-based interfaces.
• To demonstrate that dynamic data structures can outperform traditional NumPy arrays in simulations with frequent particle insertions and removals.
• To generalize findings to other geophysical and data science applications involving large, dynamically changing datasets.

Proposed method

• Benchmarking five data organization patterns: array-of-structures (AoS), structure-of-arrays (SoA), list-of-arrays (LoA), nodal lists (double-linked lists), and a hybrid LoA with fixed sublist size.
• Implementing dynamic data structures using Python classes with C-compatible memory layouts via ctypes for JIT compilation and low-level performance.
• Using the Parcels framework as a real-world testbed for oceanic Lagrangian particle tracking with adaptive kernel execution via ctypes.
• Measuring runtime, memory consumption, and compute-to-I/O ratios across static, insertion-only, removal-only, and fully dynamic simulation workloads.
• Comparing performance across datasets of increasing size (up to >2¹⁵ particles) to isolate the impact of data structure choice on simulation efficiency.
• Analyzing the computational cost of insertion, deletion, and array reordering operations as primary performance bottlenecks in array-based systems.

Experimental results

Research questions

• RQ1 How do array-based data structures in NumPy limit performance in dynamic particle simulations with frequent insertions and deletions?
• RQ2 To what extent do alternative dynamic data structures—such as SoA, LoA, and double-linked lists—improve performance in large-scale Lagrangian fluid-flow simulations?
• RQ3 What is the performance impact of data locality and memory reorganization overhead in particle simulations with more than 2¹⁵ particles?
• RQ4 Can dynamic data structures be efficiently interfaced with ctypes-based JIT-compiled C kernels to maintain high performance in Python simulations?
• RQ5 How do the performance characteristics of insertion-only, removal-only, and fully dynamic workloads differ across data structure designs?

Key findings

• Array-based collections (e.g., AoS) become a major performance bottleneck in dynamic simulations due to high memory reorganization costs during insertions and deletions.
• Double-linked lists outperform all other data structures in fully dynamic simulations, especially for large particle counts (>2¹⁵), due to efficient O(1) insertion and deletion operations.
• Structure-of-arrays (SoA) provides the best balance of performance improvement and memory efficiency, particularly in static and partially dynamic workloads.
• List-of-arrays (LoA) with fixed sublist size offers only marginal improvements over AoS due to the overhead of merging sublists and limited cache coherence.
• Removal-only and insertion-only experiments confirm that node-based operations in linked lists reduce runtime significantly compared to array reordering, especially in high-dynamic scenarios.
• The performance gain from optimized data structures can be substantial—demonstrated through speed-up metrics relative to AoS—making previously infeasible simulations computationally viable.