Effects of OpenCL-Based Parallelization Methods on Explicit Numerical Methods to Solve the Heat Equation

Abstract

In recent years, the need for high-performance computing solutions has increased due to the growing complexity of computational tasks. The use of parallel processing techniques has become essential to address this demand. In this study, an Open Computing Language (OpenCL)-based parallelization algorithm is implemented for the Constant Neighbors (CNe) and CNe with Predictor–Corrector (CpC) numerical methods, which are recently developed explicit and stable numerical algorithms to solve the heat conduction equation. The CPU time and error rate performance of these two methods are compared with the sequential implementation and Euler’s explicit method. The results demonstrate that the parallel version’s CPU time remains nearly constant under the examined circumstances, regardless of the number of spatial mesh points. This leads to a remarkable speed advantage over the sequential version for larger data point counts. Furthermore, the impact of the number of timesteps on the crossover point where the parallel version becomes faster than the sequential one is investigated.

1. Introduction

Parallel computing has emerged as a key approach to meet the increasing demand for high-performance computing solutions. By dividing computational tasks into smaller sub-tasks that can be executed simultaneously, parallel computing offers the potential to significantly improve the speed and efficiency of numerical methods [1]. One popular framework for parallel computing is OpenCL, which allows the utilization of heterogeneous computing platforms, including CPUs, GPUs, and FPGAs.

Several methods are used and processed for solving the equations related to heat transfer and diffusion, e.g., semi-analytical methods [2], domain-decomposition methods [3], and finite-element solvers [4].

The most frequent approach may be the spatial discretization of the equation by the central difference formula and then the solution of the obtained ODE (ordinary differential equation) system by either an explicit or an implicit finite difference [5] algorithm. The most well-known explicit methods, however, such as the Runge–Kutta family, are only conditionally stable, and the solution is expected to diverge whenever the timestep size is above a threshold [6], which is called the CFL (Courant–Friedrichs–Lewy) limit. The advantage of the explicit schemes is that they can execute a timestep quite quickly and they can be easily coded and parallelized.

Implicit methods have much fewer problems with stability; thus, they are commonly used by many scientists and software [7,8,9]. However, the unknown values cannot be expressed explicitly; hence, a system of algebraic equations must be solved in each timestep. This is computationally challenging, especially in multiple space dimensions, where the matrix is enormous and non-tridiagonal. Semi-explicit or semi-implicit algorithms, as combinations of explicit and implicit algorithms, are also developed [10,11,12,13].

However, we believe that the trend toward increasing parallelization can be followed using explicit schemes, which can be more efficient even if short timesteps have to be used. For example, Essongue et al. showed that the explicit Euler time integration can be faster than the implicit one for 3D thermal simulations [14]. Moreover, not all explicit methods suffer from severe stability issues. A new suite of robust techniques has been created by our group for addressing the non-stationary heat equation, which is explicit and unconditionally stable at the same time. In our original works [15,16], the new algorithms were theoretically examined, verified, and tested. Most importantly, it has been analytically proven that when using these schemes, the temperature values at the new time level are the convex combination of those at the old time level, which implies the stability of the arbitrary time step size and arbitrary space discretization. The main weakness of these explicit and stable schemes is that their accuracy does not always match the standard methods with the same order of convergence. Even with this, these non-conventional methods can severely outperform the standard ones, see, e.g., [17]. In those papers, we frequently mentioned that they are easily parallelizable. The novelty of this research is that this is the first occasion the implementation is completed, which delves into examining how OpenCL-based parallelization affects two of these methods, namely, the Constant Neighbors and the CNe with Predictor–Corrector (which is a two-stage version of the CNe similar to second-order Runge–Kutta schemes).

In this study, the methods being investigated are tested with a couple of initial conditions using various temporal and spatial scales. For each test, a reference solution is used to measure the error. The error is collected as a function of the CPU time required to run the algorithm. The error–runtime functions of the parallel versions of CNe and CpC are compared with the sequential counterparts, as well as with Euler’s explicit time integration. Additionally, we aim to investigate the impact of the number of timesteps on the crossover point where the parallel version becomes faster than the sequential one. The crossover point typically occurs due to the overhead associated with parallelization, which can be higher for small problem sizes but becomes advantageous as the problem size increases [18,19]. By analyzing the performance characteristics of these parallel implementations, we can gain insights into the benefits and limitations of utilizing OpenCL-based parallelization in numerical methods for solving heat equations.

2. Equation and Methods

2.1. The Numerical Methods Being Investigated

This work focuses on the heat conduction equation. It is mathematically analogous to the diffusion equation. The homogenous version of them is as follows:

$${\displaystyle \frac{\partial f\left(\mathit{r},t\right)}{\partial t}}=D·∆f\left(\mathit{r},t\right),$$

(1)

which is to be used with an $f\left(\mathit{r},T_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}}\right)\equiv f_{\mathrm{init}}\left(\mathit{r}\right)$ initial condition, and where

• f is the temperature [°C, K] —or, in the case of diffusion, concentration,
• t is the simulated time [s],
• $\mathit{r}=\left[\begin{array}{c}x\\ y\\ z\end{array}\right]$ is the position vector [m],
• D is the diffusion coefficient [m²/s], and
• $∆\equiv {\displaystyle \frac{{\partial }^2}{{\partial x}^2}}+{\displaystyle \frac{{\partial }^2}{{\partial y}^2}}+{\displaystyle \frac{{\partial }^2}{{\partial z}^2}}$ is the Laplacian operator.

As for the $f$ concentration term, one should note that the mass concentration [kg/m³], molar concentration [mol/m³], and particle count concentration [m⁻³] are all applicable as long as the same type of concentration is used consistently on both side of the equation.

After expanding the Laplacian, we have the following equation:

$${\displaystyle \frac{\partial f\left(\mathit{r},t\right)}{\partial t}}=D·\left({\displaystyle \frac{{\partial }^{2}f\left(\mathit{r},t\right)}{{\partial x}^2}}+{\displaystyle \frac{{\partial }^{2}f\left(\mathit{r},t\right)}{{\partial y}^2}}+{\displaystyle \frac{{\partial }^{2}f\left(\mathit{r},t\right)}{{\partial z}^2}}\right).$$

In this study, the equations are applied to simple, rectangle-like domains and a fixed Dirichlet’s condition is used at the boundaries (see Equations (12) and (13) in Section 2.3).

The algorithms mentioned in Section 1 belong to the family of finite difference methods, which makes spatial and temporal discretization necessary. The spatial discretization divides the domain into a grid (with initial points X_init, Y_init, and Z_init and endpoints X_fin, Y_fin, and Z_fin):

$${\mathit{r}}_{i,j,k}=\left[\begin{array}{c}{X}_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}}+i·∆x\\ Y_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}}+j·∆y\\ Z_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}}+k·∆z\end{array}\right]=\left[\begin{array}{c}{X}_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}}\\ Y_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}}\\ Z_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}}\end{array}\right]+\left[\begin{array}{ccc}∆x& ∆y& ∆z\end{array}\right]·\left[\begin{array}{c}i-1\\ j-1\\ k-1\end{array}\right],$$

(2)

where the spatial step sizes are

$$∆x=\left(X_{\mathrm{f}\mathrm{i}\mathrm{n}}-X_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}}\right)/\left(N_{\mathrm{x}}-1\right),$$

$$∆y=\left(Y_{\mathrm{f}\mathrm{i}\mathrm{n}}-Y_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}}\right)/\left(N_{\mathrm{y}}-1\right),$$

$$∆z=\left(Z_{\mathrm{f}\mathrm{i}\mathrm{n}}-Z_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}}\right)/\left(N_{\mathrm{z}}-1\right);$$

the index ranges are

$$i\in \left\{\mathrm{1,2}\dots N_{\mathrm{x}}\right\},$$

$$j\in \left\{\mathrm{1,2}\dots N_{\mathrm{y}}\right\},$$

$$k\in \left\{\mathrm{1,2}\dots N_{\mathrm{z}}\right\};$$

and N_x, N_y, and N_z are the number of nodes along the spatial mesh, i.e., the data point counts. It should be mentioned that in Section 3.1, the notation N_r is used as the total number of spatial grid-points, which is

$$N_{\mathrm{r}}=N_{\mathrm{x}}$$

(3)

for a 1-dimensional measurement and

$$N_{\mathrm{r}}=N_{\mathrm{x}}·N_{\mathrm{y}}$$

(4)

for 2-dimensional data.

Similarly, the temporal discretization divides the time interval into smaller timesteps as follows:

$$t_n=T_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}}+n·∆t,$$

(5)

where the step size and index range are

$$∆t=\left(T_{\mathrm{f}\mathrm{i}\mathrm{n}}-T_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}}\right)/N_{\mathrm{t}},$$

$$n\in \left\{\mathrm{0,1},2\dots N_{\mathrm{t}}\right\}.$$

Euler’s method, which serves as a reference in this paper, uses a straightforward conception to produce the data point values of timestep n + 1 as an explicit function of the values of timestep n. Approximating the Laplacian operator with the central difference formula, the stepper formula is (for ease of understanding, in 2 dimensions) as follows:

$$f_{i,j}^{\left(n+1\right)}\cong f_{i,j}^{\left(n\right)}+D·∆t·\left({\displaystyle \frac{f_{i+1,j}^{\left(n\right)}-2·f_{i,j}^{\left(n\right)}+f_{i-1,j}^{\left(n\right)}}{{∆x}^2}}+{\displaystyle \frac{f_{i,j+1}^{\left(n\right)}-2·f_{i,j}^{\left(n\right)}+f_{i,j-1}^{\left(n\right)}}{{∆y}^2}}\right),$$

(6)

where the index ranges are

$$i\in \left\{\mathrm{1,2}\dots N_{\mathrm{x}}\right\},$$

$$j\in \left\{\mathrm{1,2}\dots N_{\mathrm{y}}\right\}.$$

This method is susceptible to numerical instability and requires a small timestep size for accuracy. To eliminate stability problems, CNe method uses a convex combination of the function values to calculate the values of the next timestep. First, an average temperature value $f_{i,j}^{\left(\mathrm{n}\mathrm{e}\mathrm{b},n\right)}$ of the neighboring datapoints is calculated, and then this value is used as an ambient or terminal temperature to apply Newton’s law of heat transfer (i.e., to calculate the exponentially converging value after the timestep has elapsed):

$$f_{i,j}^{\left(n+1\right)}\cong \exp \left\{-{\displaystyle \frac{∆t}{\tau }}\right\}·f_{i,j}^{\left(n\right)}+\left(1-\exp \left\{-{\displaystyle \frac{∆t}{\tau }}\right\}\right)·f_{i,j}^{\left(\mathrm{n}\mathrm{e}\mathrm{b},n\right)},$$

(7)

where

$$\tau =1/\left[2D·\left({\displaystyle \frac{1}{{∆x}^2}}+{\displaystyle \frac{1}{{∆y}^2}}\right)\right]$$

is the time constant of the node and

$$f_{i,j}^{\left(\mathrm{n}\mathrm{e}\mathrm{b},n\right)}={\displaystyle \frac{1}{2}}·\left({\displaystyle \frac{f_{i+1,j}^{\left(n\right)}+f_{i-1,j}^{\left(n\right)}}{{∆x}^2}}+{\displaystyle \frac{f_{i,j+1}^{\left(n\right)}+f_{i,j-1}^{\left(n\right)}}{{∆y}^2}}\right)/\left({\displaystyle \frac{1}{{∆x}^2}}+{\displaystyle \frac{1}{{∆y}^2}}\right)$$

is the asymptotic value to which the node temperature tends.

The bottleneck of this method is its relatively poor accuracy. To mitigate this problem, CpC method combines it with a predictor–corrector approach, namely the second-order Runge–Kutta scheme. In the first stage, an approximating value is calculated at a fractional timestep using the CNe formula. In the second stage, a linear combination of the original value and the result of the first stage is used as the terminal temperature for CNe to calculate the full-timestep value as follows:

$$f_{i,j}^{\left(n+p\right)}=\exp \left\{-{\displaystyle \frac{∆t}{\tau }}\right\}·f_{i,j}^{\left(n\right)}+\left(1-\exp \left\{-{\displaystyle \frac{∆t}{\tau }}\right\}\right)·f_{i,j}^{\left(n\right)\infty },$$

(8)

$$f_{i,j}^{\left(n+1\right)}=\exp \left\{-{\displaystyle \frac{∆t}{\tau }}\right\}·f_{i,j}^{\left(n\right)}+\left(1-\exp \left\{-{\displaystyle \frac{∆t}{\tau }}\right\}\right)·\left[\left(1-{\displaystyle \frac{1}{2p}}\right)·f_{i,j}^{\left(n\right)\infty }+{\displaystyle \frac{1}{2p}}{f}_{i,j}^{\left(n+p\right)\infty }\right];$$

(9)

where 0 < p ≤ 1 is the step fraction.

It is mathematically proven in [15] that the above algorithm with coefficients 1 – 1/2p and 1/2p indeed yields to a second-order error term. The results of [15] also show that the accuracy does not depend significantly on the value of parameter p; hence, p = 1/2 is a good choice to simplify calculations. By doing so, the coefficient of the pre-step value becomes zero, enabling the result of the first stage to be used directly in the second stage without having to calculate the linear combination:

$$f_{i,j}^{\left(n+1/2\right)}=\exp \left\{-{\displaystyle \frac{∆t}{\tau }}\right\}·f_{i,j}^{\left(n\right)}+\left(1-\exp \left\{-{\displaystyle \frac{∆t}{\tau }}\right\}\right)·f_{i,j}^{\left(n\right)\infty },$$

(10)

$$f_{i,j}^{\left(n+1\right)}=\exp \left\{-{\displaystyle \frac{∆t}{\tau }}\right\}·f_{i,j}^{\left(n\right)}+\left(1-\exp \left\{-{\displaystyle \frac{∆t}{\tau }}\right\}\right)·f_{i,j}^{\left(n+1/2\right)\infty },$$

(11)

which yields an algorithm analog to the midpoint method.

2.2. Parallelization and Applying OpenCL

Both the CNe and CpC methods are parallelizable, and the same applies to the Euler’s method. When determining whether an algorithm is parallelizable, several key criteria must be considered. One important criterion is the independence of tasks, often referred to as data parallelism. This refers to the extent to which tasks or operations can be performed independently of each other. If the algorithm’s tasks do not depend on the results of other tasks, they can be executed in parallel. Another crucial factor is task granularity, which refers to the size of the tasks being parallelized. Fine-grained tasks, which involve small and fast operations, can create overhead in managing parallel tasks, whereas coarse-grained tasks, involving larger and more complex operations, may reduce overhead but require careful balancing. Communication overhead is also a key consideration. This involves the amount of data exchange or synchronization required between parallel tasks. Algorithms that require minimal communication between tasks are easier to parallelize. Load balancing, which is the ability to distribute the workload evenly across all available computing units, is another important criterion. For effective parallelization, the workload should be balanced to avoid situations where some processors are idle while others are overloaded. Scalability is another critical factor, referring to how well the algorithm’s performance improves with the addition of more processing units. An algorithm is considered scalable if its performance continues to improve as more cores or processors are added. A scalable algorithm might demonstrate near-linear speedup as the number of processors increases, such as in parallel matrix multiplication. Synchronization needs must also be considered. These involve the need for synchronization between tasks during execution. Memory access patterns are also important. The way an algorithm accesses memory can affect parallelization, with algorithms that have predictable and non-conflicting memory access patterns being easier to parallelize. For example, algorithms with regular, sequential memory access patterns, such as matrix operations, are easier to optimize for parallel execution compared to those with irregular access patterns that may cause contention. In this research, a cell-by-cell parallelization is carried out, which means that each kernel invocation calculates one cell value.

In this paper, OpenCL [20] was used. Open Computing Language is a framework for writing programs that execute across heterogeneous platforms, including CPUs, GPUs, DSPs, and FPGAs. Its primary purpose is to facilitate parallel computing by allowing developers to harness the computational power of diverse hardware architectures within a unified programming model. By leveraging parallelization, OpenCL aims to significantly enhance performance in various computational tasks, from scientific simulations to real-time data processing. OpenCL is widely used for high-performance computing [21]. Its cross-platform nature [22] makes it useful in various domains of application. Parallelization was used in [23] for solving nonlinear ordinary differential equations. A sparse matrix-vector multiplication is presented in [24]. Parallel computing in the modeling of fractional-order state–space systems is presented by [25]. The Smith–Waterman implementation is shown in [26].

The kernel function for Euler’s method, as well as for the CNe method, can be found in Listing 1 (in 2 dimensions, supposing a GPU supports Khronos-style 64-bit floating point arithmetic [27]):

Listing 1: Kernel of CNe and the 1st stage of CpC.

#pragma OPENCL EXTENSION cl_khr_fp64 : enable

__kernel void calc_cell_2D(

__global const double *before, __global double *after,

double2 coeffs, uint2 size, long4 neighbours) {

const size_t index = get_global_id(0) + size.x * get_global_id(1);

__global const double *old_cell = before + index;

after[index] = (1 − 2 * (coeffs.x + coeffs.y)) * *old_cell

+ coeffs.x *

(old_cell[neighbours.even.x] +

old_cell[neighbours.odd.x])

+ coeffs.y *

(old_cell[neighbours.even.y] +

old_cell[neighbours.odd.y]);

}

where

• before, after are pointers to the array containing data before and after the timestep;
• coeffs is a vector containing numerical coefficients for computation;
• size is a vector containing the [N_x, N_y] number of datapoints;
• neighbours is a vector containing pointer differences between the current datapoint and its neighbours (introduced to simplify handling boundary conditions).

During each timestep, the calculation uses the value of the neighboring cells. To ensure that none of these neighboring values has been updated by parallel cell computation—i.e., the before-step value of all the neighbors is used—two memory buffers are necessary [28]. During odd timestep computations, buffer 1 is read while buffer 2 is written to. During even timestep computations, buffer 2 is read while buffer 1 is written to, as follows (Figure 1):

This is an explicit buffer parallelization technique [29]. Its advantage is that the programmer controls when and how data are moved, optimizing the data transfer to minimize latency and maximize throughput. It allows the use of device-specific features and capabilities, potentially enabling hardware-specific optimizations [30] that are not possible with a more abstracted approach. The first stage of the CpC method can also use the same kernel as shown in Listing 1, but this algorithm also needs a second-stage kernel, as well (Listing 2):

Listing 2: Kernel of the 2nd stage of CpC.

__kernel void stage2p05_calc_cell_2D(

__global const double *stage0,

__global const double *stage1,

__global double *after,

double2 coeffs, uint2 size, long4 neighbours) {

const size_t index = get_global_id(0) + size.x * get_global_id(1);

__global const double *old_cell = stage0 + index;

__global const double *midpoint = stage1 + index;

after[index] = (1 − 2 * (coeffs.x + coeffs.y)) * *old_cell

+ coeffs.x *

(midpoint[neighbours.even.x] +

midpoint[neighbours.odd.x])

+ coeffs.y *

(midpoint[neighbours.even.y] +

midpoint[neighbours.odd.y]);

}

where

• stage0 is a pointer to the array containing data before stage 1;
• stage1 is a pointer to the array containing the result of stage 1;
• after is a pointer to the array containing data after all the stages;
• coeffs is a vector containing numerical coefficients for computation;
• size is a vector containing the [N_x, N_y] number of datapoints;
• neighbours is a vector containing pointer differences between the current datapoint and its neighbours (introduced to possibly simplify handling boundary conditions).

Method CpC also requires 2 memory buffers, but they are used in a different way. The computation of each step uses both buffers. The first stage reads buffer 1 and writes the result to buffer 2. The second stage reads both buffer 1 (stage0) and buffer 2 (stage1) and stores the result in buffer 1 (after), as shown in Figure 2.

2.3. Initial and Boundary Conditions, Scale Parameters, and the Method of Investigation

In this study, fixed Dirichlet boundaries [31] are assumed, meaning that the initial value of the boundaries is kept constant during the calculation, and no calculation is involved on these boundaries, as follows:

$$f_1^n=f_1^{n-1}=\cdots =f_1^0,$$

$$f_{N_{\mathrm{x}}}^n=f_{N_{\mathrm{x}}}^{n-1}=\cdots =f_{N_{\mathrm{x}}}^0$$

(12)

in 1 dimension, and

$$\left\{f_{1,j}^n=f_{1,j}^{n-1}=\cdots =f_{1,j}^0|j\in \left\{1,\dots N_{\mathrm{y}}\right\}\right\},$$

$$\left\{f_{N_{\mathrm{x}},j}^n=f_{N_{\mathrm{x}},j}^{n-1}=\cdots =f_{N_{\mathrm{x}},j}^0|j\in \left\{1,\dots N_{\mathrm{y}}\right\}\right\},$$

$$\left\{f_{i,1}^n=f_{i,1}^{n-1}=\cdots =f_{i,1}^0|i\in \left\{1,\dots N_{\mathrm{x}}\right\}\right\},$$

$$\left\{f_{{i,N}_{\mathrm{x}}}^n=f_{i,N_{\mathrm{x}}}^{n-1}=\cdots =f_{{i,N}_{\mathrm{x}}}^0|i\in \left\{1,\dots N_{\mathrm{x}}\right\}\right\}$$

(13)

in 2 dimensions.

To deal with the initial values, four different problems are created using two initial condition functions for both 1- and 2-dimensional measurements. In the case of one type of the initial function, we have the analytical solution, which is used as a reference. The other problem does not have an analytical solution; hence, a numerical reference solution is used instead. This reference solution is generated using the built-in ode15s function of MATLAB [32]. These initial value functions are the following (assuming X_init = 0, Y_init = 0 and T_init = 0):

• A 1D sine with nodes at the boundaries is

  $$f\left(x,t=0\right)=A·\sin \left(\pi ·{\displaystyle \frac{x}{X_{fin}}}\right)+C,$$

  (14)

  where

  $$A=0.8,$$

  $$C=1$$

  are arbitrarily chosen parameters and the analytical solution is

  $$f\left(x,t\right)=A·\exp \left\{-{\pi }^2·{\displaystyle \frac{D·t}{{X_{fin}}^2}}\right\}·\sin \left(\pi ·{\displaystyle \frac{x}{X_{fin}}}\right)+C.$$

  (15)
• A 1D Gaussian function [33] is

  $$f\left(x,t=0\right)={\displaystyle \frac{A}{\sqrt{2\pi }·\sigma }}·\exp \left\{-{\displaystyle \frac{{\left(x-\mu \right)}^2}{2{\sigma }^2}}\right\},$$

  (16)

  where

  $$A=1,$$

  $$\mu =3.4,$$

  $$\sigma =4.2$$

  are arbitrarily chosen parameters. In this case, a numerical reference solution is used.
• In 2D, the product of sinewaves for each dimension with nodes at the boundaries is

  $$f\left(x,y,t=0\right)=A·\sin \left(\pi ·{\displaystyle \frac{x}{X_{fin}}}\right)·\sin \left(\pi ·{\displaystyle \frac{y}{Y_{fin}}}\right)+C,$$

  (17)

  where

  $$A=0.8,$$

  $$C=1$$

  are arbitrarily chosen parameters and the analytical solution is

  $$f\left(x,y,t\right)=A·\exp \left\{-{\pi }^{2}Dt·\left({\displaystyle \frac{1}{X_{fin}^2}}+{\displaystyle \frac{1}{Y_{fin}^2}}\right)\right\}·\sin \left(\pi ·{\displaystyle \frac{x}{X_{fin}}}\right)·\sin \left(\pi ·{\displaystyle \frac{y}{Y_{fin}}}\right)+C.$$

  (18)
• A 2D planar wave, propagating at an angle [34] is

  $$f\left(x,y,t=0\right)=A·\cos \left(2\pi ·\left[\begin{array}{cc}{k}_{\mathrm{x}}& k_{\mathrm{y}}\end{array}\right]·\left[\begin{array}{c}x\\ y\end{array}\right]-\phi \right).$$

  (19)

  where

  $$A=0.8,$$

  $$\left[\begin{array}{cc}{k}_{\mathrm{x}}& k_{\mathrm{y}}\end{array}\right]=\left[\begin{array}{cc}2.2& 0.5\end{array}\right],$$

  $$\phi =1$$

  are arbitrarily chosen parameters. In this case, a numerical reference solution is used.

The timescales and data grids used together with these functions are listed in

Table 1. The timescales used with 1D data.

Nt	∆t
9	1.1111 × 10−1
15	6.6667 × 10−2
30	3.3333 × 10−2
50	2.0000 × 10−2
90	1.1111 × 10−2
150	6.6667 × 10−3
300	3.3333 × 10−3
500	2.0040 × 10−3
900	1.1111 × 10−3
1500	6.6667 × 10−4
3000	3.3333 × 10−4
5000	2.0000 × 10−4
9000	1.1111 × 10−4
15,000	6.6667 × 10−5
30,000	3.3333 × 10−5
50,000	2.0000 × 10−5
90,000	1.1111 × 10−5
150,000	6.6667 × 10−6
300,000	3.3333 × 10−6
500,000	2.0000 × 10−6
900,000	1.1111 × 10−6
1,500,000	6.6667 × 10−7
3,000,000	3.3333 × 10−7
5,000,000	2.0000 × 10−7
9,000,000	1.1111 × 10−7

All scales start at T_init = 0 and finish at T_fin = 1.

,

Table 2. The 1D spatial grids.

Nx	∆x
50	2.0408 × 10−1
100	1.0101 × 10−1
200	5.0251 × 10−2
400	2.5063 × 10−2
800	1.2516 × 10−2
1200	8.3403 × 10−3
2000	5.0025 × 10−3
4000	2.5006 × 10−3
8000	1.2502 × 10−3
12,000	8.3340 × 10−4

All grids start at X_init = 0 and finish at X_fin = 10.

,

Table 3. The timescales used with 2D data.

Nt	∆t
9	1.1111 × 10−2
15	6.6667 × 10−3
30	3.3333 × 10−3
50	2.0000 × 10−3
90	1.1111 × 10−3
150	6.6667 × 10−4
300	3.3333 × 10−4
500	2.0000 × 10−4
900	1.1111 × 10−4
1500	6.6667 × 10−5
3000	3.3333 × 10−5
5000	2.0000 × 10−5
9000	1.1111 × 10−5
15,000	6.6667 × 10−6
30,000	3.3333 × 10−6
50,000	2.0000 × 10−6
90,000	1.1111 × 10−6
150,000	6.6667 × 10−7
300,000	3.3333 × 10−7
500,000	2.0000 × 10−7
900,000	1.1111 × 10−7

All scales start at T_init = 0 and finish at T_fin = 0.1.

and

Table 4. The 2D spatial grids.

Nx	Ny	NxNy	∆x	∆y	∆x∆y
25	25	625	4.1667 × 10−2	4.1667 × 10−2	1.7361 × 10−3
25	50	1250	4.1667 × 10−2	2.0408 × 10−2	8.5034 × 10−4
50	50	2500	2.0408 × 10−2	2.0408 × 10−2	4.1649 × 10−4
50	75	3750	2.0408 × 10−2	1.3514 × 10−2	2.7579 × 10−4
75	75	5625	1.3514 × 10−2	1.3514 × 10−2	1.8262 × 10−4
75	100	7500	1.3514 × 10−2	1.0101 × 10−2	1.3650 × 10−4
100	100	10,000	1.0101 × 10−2	1.0101 × 10−2	1.0203 × 10−4
100	150	15,000	1.0101 × 10−2	6.7114 × 10−3	6.7792 × 10−5
150	150	22,500	6.711 × 10−3	6.7114 × 10−3	4.5043 × 10−5
150	200	30,000	6.7114 × 10−3	5.0251 × 10−3	3.3726 × 10−5
200	200	40,000	5.0251 × 10−3	5.0251 × 10−3	2.5252 × 10−5

All grids start at (X_init,Y_init) = (0,0) and finish at (X_fin,Y_fin) = (1,1).

. During the measurement, each row of the timescale tables is combined with each row of the appropriate spatial mesh–grid table (i.e., the rows of Table 1 with the rows of Table 2 and the rows of Table 3 with the rows of Table 4) and one of the 2 appropriate initial functions. For each combination, the measurement is repeated 4 times, and the mean value along with the standard deviation of the CPU time is calculated. The maximal absolute value of the difference between the output data points and the reference solution values (mathematically spoken, the l_∞ distance of the output vector and the reference vector) is considered as the error of the algorithm as follows:

$${Err}_{Max}=\underset{i\in \left\{\mathrm{1,2}\dots N_{\mathrm{x}}\right\}}{\max }\left|f_i^{N_{\mathrm{t}},\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{c}}-f_i^{N_{\mathrm{t}},\mathrm{r}\mathrm{e}\mathrm{f}}\right|$$

(20)

for 1 dimensional calculations and

$${Err}_{Max}=\underset{\begin{array}{c}i\in \left\{\mathrm{1,2}\dots N_{\mathrm{x}}\right\}\\ j\in \left\{\mathrm{1,2}\dots N_{\mathrm{y}}\right\}\end{array}}{\max }\left|f_{i,j}^{N_{\mathrm{t}},\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{c}}-f_{i,j}^{N_{\mathrm{t}},\mathrm{r}\mathrm{e}\mathrm{f}}\right|$$

(21)

for 2 dimensional calculations. (This value is expected to be the same for all the 4 repetitions, since the examined algorithms are deterministic.)

2.4 The Specifications of the Applied Computer, Further Circuimstances of the Investigation

The aforementioned algorithms can be found at the repository mentioned in Supplementary Materials. These were executed on a personal computer (PC) to validate their performance and functionality. The specifications of the PC used for this purpose are as follows:

• CPU—Gen11 Intel Core i7-11700F, 2.5 GHz;
• RAM—64 GB;
• OS—Windows 10 Professional (22H2), ×64;
• GPU—NVIDIA;
• Open CL—Intel v2020.3.494.

3. Results

The results presented in this section refer to the cases described in Section 2.3.

In this examination, the problem sizes had to be limited to the size that can be practically calculated during the experiments, given the computational resources available, such as the GPU and CPU used. These circumstances include the number of spatial mesh points and the scale of the computational task that the hardware could handle efficiently. In traditional, sequential algorithms, the CPU time typically increases as the number of spatial mesh points grows because more calculations are required. However, in the parallel version of the algorithm studied, the CPU time remained nearly constant across the range of mesh points tested. This means that within the practical limits of the problem sizes tested, the parallel implementation was able to efficiently distribute the workload across multiple processing units (like GPU cores), allowing it to handle larger problem sizes without a corresponding increase in computation time.

3.1. The Dependency of CPU Time on the Number of Data Points

In the following subsections, the CPU time of the given implementation (i.e., CNe in Section 3.1.1 and CpC in Section 3.1.2) is plotted as the function of the total number of spatial grid points (see Equations (3) and (4) for a definition of N_r) for a fixed number of timesteps, along with the CPU time of Euler’s method. For ease of comparison, the 1-dimensional and 2-dimensional data are plotted on the same graph. Each data point in Figure 3, Figure 4, Figure 5 and Figure 6 contains both the problems with analytical and numerical reference solutions, meaning that the average of eight CPU time values is used instead of four values.

On Figure 3, Figure 4, Figure 5 and Figure 6, one can observe, that in the parallel case, the CPU time remains unaffected by the data point count (presumably due to no depletion of the GPU capability in these measurements), whereas in the sequential case, it increases with the data point number. For most cases under examination at two-dimensional levels and all one-dimensional instances, the system size consistently falls below a critical cross-over point threshold, and hence finer space grids (i.e., greater datapoint count) are required.

The position of the cross-over point shifts towards lower data point counts as timestep numbers rise. With 500 timesteps, OpenCL demonstrates greater efficiency within a range of 6000–8000 data points; meanwhile, with 900,000 timesteps, the transition happens at around 3000 data points.

3.1.1. The CNe Method Compared to Euler’s Method

See Figure 3 and Figure 4 below.

Figure 3. The CPU time of CNe and Euler’s methods as a function of the number of spatial mesh points for 500 timesteps.

Figure 3. The CPU time of CNe and Euler’s methods as a function of the number of spatial mesh points for 500 timesteps.

Figure 4. The CPU time of CNe and Euler’s methods as a function of the number of spatial mesh points for 900,000 timesteps.

Figure 4. The CPU time of CNe and Euler’s methods as a function of the number of spatial mesh points for 900,000 timesteps.

3.1.2. The CpC Method Compared to Euler’s Method

See Figure 5 and Figure 6 below.

Figure 5. The CPU time of CpC and Euler’s methods as a function of the number of datapoints for 500 timesteps.

Figure 5. The CPU time of CpC and Euler’s methods as a function of the number of datapoints for 500 timesteps.

Figure 6. The CPU time of CpC and Euler’s methods as a function of the number of data points for 900,000 timesteps.

Figure 6. The CPU time of CpC and Euler’s methods as a function of the number of data points for 900,000 timesteps.

3.2. The Error as a Function of the Timestep Size

In this section, the error is plotted as a function of the CPU time necessary to execute the algorithm. (For the definition of Err_Max, see Equations (20) and (21).) This technique enables a sophisticated comparison of the examined methods (CNe in Section 3.2.1 and CpC in Section 3.2.2) with Euler’s method.

As it can be expected based on Section 3.1, on Figure 7, Figure 8, Figure 9, Figure 10, Figure 11, Figure 12, Figure 13 and Figure 14, it is noticeable that better performance with OpenCL is only achieved in two dimensions for large data grids. It can also be seen that the errors of both the parallel and the sequential algorithms are similar. This confirms that the OpenCL-based and sequential implementations conduct identical mathematical operations, and they differ at most in scheduling.

3.2.1. The CNe Method Compared to Euler’s Method

See Figure 7, Figure 8, Figure 9 and Figure 10 below.

Figure 7. The errors of CNe and Euler’s methods as a function of CPU time, 1D with analytical reference.

Figure 7. The errors of CNe and Euler’s methods as a function of CPU time, 1D with analytical reference.

Figure 8. The errors of CNe and Euler’s methods as a function of CPU time, 1D with numerical reference.

Figure 8. The errors of CNe and Euler’s methods as a function of CPU time, 1D with numerical reference.

Figure 9. The errors of CNe and Euler’s methods as a function of CPU time, 2D with analytical reference.

Figure 9. The errors of CNe and Euler’s methods as a function of CPU time, 2D with analytical reference.

Figure 10. The errors of CNe and Euler’s methods as a function of CPU time, 2D with numerical reference.

Figure 10. The errors of CNe and Euler’s methods as a function of CPU time, 2D with numerical reference.

3.2.2. The CpC Method Compared to Euler’s Method

See Figure 11, Figure 12, Figure 13 and Figure 14 below.

Figure 11. The errors of CpC and Euler’s methods as a function of CPU time, 1D with analytical reference.

Figure 11. The errors of CpC and Euler’s methods as a function of CPU time, 1D with analytical reference.

Figure 12. The errors of CpC and Euler’s methods as a function of CPU time, 1D with numerical reference.

Figure 12. The errors of CpC and Euler’s methods as a function of CPU time, 1D with numerical reference.

Figure 13. The errors of CpC and Euler’s methods as a function of CPU time, 2D with analytical reference.

Figure 13. The errors of CpC and Euler’s methods as a function of CPU time, 2D with analytical reference.

Figure 14. The errors of CpC and Euler’s methods as a function of CPU time, 2D with numerical reference.

Figure 14. The errors of CpC and Euler’s methods as a function of CPU time, 2D with numerical reference.

4. Discussion and Conclusions

According to this research, it can be argued that employing OpenCL has the potential to achieve improved performance; however, whether such enhanced performance is realized depends on certain conditions. The size of the data grids examined in this study is not enough to deplete the parallel computing capacity of the computer used for the calculation. As a result, the CPU time required by OpenCL-based algorithms is determined mostly by the number of timesteps and only to a much smaller extent by the number of data points. Consequently, OpenCL becomes more efficient than its sequential counterpart only when a sufficiently high number of data points is employed (which appears to decrease as the number of timesteps increases). In our investigation, only certain 2-dimensional scenarios meet this criterion; in other cases, it has been demonstrated that sequential calculation outperforms parallel processing.

The constancy in CPU time is likely due to the parallel nature of the algorithm, where the computational load is spread out across multiple processors. However, this effect is observed only up to the point where the problem size is within the capabilities of the hardware. Beyond this point, or with extremely large mesh sizes, the CPU time might increase as the computational resources become a limiting factor. The key takeaway is that for the problem sizes tested, which the hardware could manage effectively, the parallel implementation showed a significant advantage in maintaining a consistent CPU time, making it particularly suitable for larger-scale problems.

Future experiments should utilize finer data grids to illustrate the effectiveness of OpenCL compared to sequential computing. In one dimension, a minimum of 300 to 400 data points is required, while in two dimensions, a grid size of at least 150 × 150 would be suitable for the upper limit of test cases.