[Paper Review] Parallel Implementations of the Split-Step Fourier Method for Solving Nonlinear Schrödinger Systems

Scott M. Zoldi, V. P. Ruban+2 more|ArXiv.org|Nov 14, 1997

Optical Network Technologies12 references20 citations

TL;DR

This paper presents a parallel implementation of the Split-Step Fourier (SSF) method for solving the Nonlinear Schrödinger Equation (NLSE) on shared and distributed memory architectures using a 2D matrix decomposition of the 1D FFT. It achieves near-perfect speedup on the SGI/Cray Origin 200 by minimizing communication overhead and optimizing data locality, with speedups up to 3.4× for large problem sizes using four processors.

ABSTRACT

We present a parallel version of the well-known Split-Step Fourier method (SSF) for solving the Nonlinear Schrödinger equation, a mathematical model describing wave packet propagation in fiber optic lines. The algorithm is implemented under both distributed and shared memory programming paradigms on the Silicon Graphics/Cray Research Origin 200. The 1D Fast-Fourier Transform (FFT) is parallelized by writing the 1D FFT as a 2D matrix and performing independent 1D sequential FFTs on the rows and columns of this matrix. We can attain almost perfect speedup in SSF for small numbers of processors depending on both problem size and communication contention. The parallel algorithm is applicable to other computational problems constrained by the speed of the 1D FFT.

Motivation & Objective

• Address the computational bottleneck of large-scale NLSE simulations in fiber optics, particularly for WDM and dispersion-managed systems.
• Overcome the limitations of serial SSF implementations that become too slow for high-resolution simulations requiring large numbers of Fourier modes.
• Develop a scalable parallel SSF algorithm applicable to systems constrained by 1D FFT performance, not limited to NLSE.
• Optimize performance on multiprocessor workstations by minimizing communication costs and improving data locality in shared and distributed memory models.

Proposed method

• Reformulate the 1D FFT as a 2D matrix operation, enabling independent 1D FFTs on rows and columns for parallelization.
• Implement the SSF algorithm using both shared memory (OpenMP-style directives) and distributed memory (MPI) paradigms on the SGI/Cray Origin 200.
• Use static data distribution in distributed memory to reduce communication contention and improve cache locality during computation stages.
• Apply load balancing by dividing the 1D array into subarrays assigned to processors, with explicit data redistribution in MPI to maintain data independence.
• Optimize performance by tuning problem size and number of processors to balance computational gain against communication cost.
• Leverage vendor-optimized 1D FFT libraries and subarray processing to improve L1 cache utilization and reduce transposition overhead.

Experimental results

Research questions

• RQ1 Can the 1D FFT, the computational bottleneck in SSF, be effectively parallelized using a 2D matrix decomposition to achieve high speedup?
• RQ2 How does performance scale with problem size and number of processors in shared versus distributed memory implementations of the parallel SSF?
• RQ3 What is the impact of communication volume and data contention on speedup in shared memory SSF versus static data distribution in distributed memory SSF?
• RQ4 To what extent can the parallel SSF algorithm achieve near-perfect speedup for large-scale NLSE simulations?
• RQ5 Can the proposed parallelization strategy be generalized to other numerical algorithms dependent on fast 1D FFTs?

Key findings

• The distributed memory (MPI) implementation achieved a maximum speedup of 3.4× for N=2^18 and S=125 steps using four processors, with T_4pr = 26.8 seconds compared to T_1pr = 92.4 seconds.
• The shared memory implementation achieved a maximum speedup of 2.7× for N=2^16 and S=500 steps using four processors, with T_4pr = 20.1 seconds compared to T_1pr = 59.4 seconds.
• Speedup in the distributed model increases with problem size due to reduced communication volume per processor and better data locality from static distribution.
• The shared memory model suffers from increased contention due to dynamic subarray assignment and data sharing across processors, limiting scalability.
• The parallel SSF algorithm achieves 10–20% speedup over optimized sequential 1D FFTs even on single processors due to improved cache utilization and elimination of transposition stages.
• Nearly perfect speedup is attainable by tuning problem size and number of processors, especially in the distributed memory model, where communication cost is minimized through static data partitioning.