## 4 Experimental Result and Discussion
### Kernel Optimization and Evaluation
The _CUDA_optimized_ shows a 2.38 ms computation time, which is 2.93 times faster than the _CUDA_baseline_. This result indicates that the instruction efficiency has more effect on computation time than thread-level parallelism because a configuration with higher efficiency shows shorter computation time regardless of occupancy. After the CUDA optimization, we also compared the computation time of our _CUDA_optimized_ implementation with sequential CPU, multi-threaded CPU using OpenMP, and the _CUDA_baseline_ for various mesh sizes ranging from \(100\times 100\) to \(1000\times 1000\). We generated 2D meshes by calculating grid coordinates from the reference point and the pixel size mentioned in Section 3.1. Figure 9 shows that the _CUDA_optimized_ has the shortest computation time, followed by the _CUDA_baseline_, \(16/8/4/2\) threads CPU, and sequential CPU implementations. We also observe that utilizing more threads improves the performance in multi-threaded CPU implementations. However, the performance gap between 8 and 16 threads is relatively small due to the limitation of CPU cores. Furthermore, in our experiments, using 32 and 64 threads showed almost the same performance as the 16 threads implementation. Table 6 summarizes the speedup ratios achieved by the _CUDA_optimized_ over CPU-based and the _CUDA_baseline_ implementations. According to Table 6, the _CUDA_optimized_ greatly improves the computation time of target objective functions compared with other implementations. For instance, it achieves up to \(134.94\times\), \(14.01\times\), and \(2.99\times\) speedups over sequential CPU, 16 threads CPU, and the _CUDA_baseline_ for the \(1000\times 1000\) mesh size. Significantly, the performance gap between the _CUDA_baseline_ and the _CUDA_optimized_ is noteworthy. From the result, we can state that it is crucial to use the application-specific, hand-crafted optimization of CUDA kernel code to improve the performance, not merely write parallel code. We also compared the results with previous work by [PERSON] et al. [42]. Although they used a different source parameter estimation algorithm from our study, they also used the Okada model and evaluated the GPU acceleration effect with the OpenMP implementation. The GPU implementation by [PERSON] et al. [42] achieves about \(32\times\) and \(145\times\) speedups over OpenMP-8 threads and sequential CPU implementations, respectively. To summarize the comparison result of performance evaluation, speedups over sequential CPU are similar. However, the speedup achieved over OpenMP-8 threads in [42] is about twice compared with our result in Table 6. We consider that this is because our study used the Intel(r) CoreTM i9-10900K @ 3.70 GHz processor with 10 CPU cores and 20 threads that is roughly two times  
Figure 9: Average objective function computation time of sequential CPU, multi-threaded CPU, and parallel GPU implementations. faster than the platform used in [42], i.e., Intel\({}^{\circledR}\) Core\({}^{\text{TM}}\) i7-3770K @ 3.50 GHz with 4 CPU cores and 8 threads. On the other hand, for the mesh sizes from \(100\times 100\) to \(400\times 400\), the speedup ratio increases considerably, but in the mesh sizes from \(500\times 500\) to \(1000\times 1000\), the speedup ratio no longer increases noticeably. As shown in Figure 10, we can also observe that the Giga floating-point operations per second (GFLOPS) of the _CUDA_optimized_ code for different mesh sizes changes in agreement with the results in Table 6. Therefore, it is considered that the GFLOPS of the target application represents the throughput achievable on the GPU, which limits the degree of performance improvement. In summary, the CSE technique that enhances the instruction efficiency is the most effective optimization technique for parallel implementation of the Okada model. Our _CUDA_optimized_ implementation achieves more than an order of magnitude speedup compared to traditional multi-threaded CPU-based implementations.