## 4 Experimental Results
An experimental result for differences between chipsets is shown in Table 5. The experiment is conducted using Intel Generation 9 based integrated GPU and NVIDIA GTX960 based on Maxwell architecture. When compiling the SYCL program, we utilized ComputeCpp SYCL implementation, since ComputeCpp supports the largest number of platforms. The result show that Intel GPU has limited computing power compared to NVIDIA chipsets. For operations not using local memory, operations with small data sizes took up to 46 times longer than NVIDIA chipset. Operations with large size of data take at most 2 times longer than NVIDIA chipset. For Intel GPU, the execution time of matrix multiplication with local memory takes longer than operations without using local memory. The tendency of performance reduction is a result of two factors. The first reason is the architecture of chipset, as Intel chipset has fewer physical threads (execution unit) that can be launched simultaneously. As the number of execution units are small, multiple context switching is inevitable to execute large logical work-group items, which shares local memory. Another reason for decreased performance is the absence of dedicated GPU memory. In this \begin{table}
\begin{tabular}{c c c c} \hline \hline
**Size** & **CUDA** & **HipSYCL** & **ComputeCpp** \\ \hline
32 & 0.1 ms & 2 ms & 3 ms \\ \hline
256 & 0.4 ms & 25 ms & 15 ms \\ \hline
1024 & 7.6 ms & 1100 ms & 59 ms \\ \hline
2048 & 60 ms & 8765 ms & 285 ms \\ \hline \hline \end{tabular}
\end{table} 
Table 4: Execution time of local memory matrix multiplication. \begin{table}
\begin{tabular}{c c c c c} \hline \hline
**Size** & **CUDA** & **HipSYCL** & **ComputeCpp** & **TriSYCL** \\ \hline
32 & 0.1 ms & 2 ms & 3 ms & 5 ms \\ \hline
256 & 0.5 ms & 14 ms & 18 ms & 1437 ms \\ \hline
1024 & 19 ms & 730 ms & 80 ms & - \\ \hline
2048 & 149 ms & 5634 ms & 584 ms & - \\ \hline \hline \end{tabular}
\end{table} 
Table 3: Execution time of global memory matrix multiplication. case, shared video memory should be utilized to store data. Since shared video memory should be shared with CPU, the data cannot be fetched as fast as dedicated memory, which leads to a slowdown of overall performance. During experiments, we collected the profiled data for API calls of detailed execution of CUDA and hipSYCL with the NVIDIA profiler. The NVIDIA profiler provided fine information about runtime of CUDA, however, it did not provide a capability to profile OpenCL applications. On the other hand, CodeXL developed by AMD provided an OpenCL profiler, but profiling technology was limited to AMD GPU. Therefore, since the majority of our experiments were conducted with NVIDIA GPU, we could profile only two implementations run on CUDA. For profiling, we conducted matrix multiplications with the size of 1024, using shared memory. Memory copy operation for hipSYCL was generated to utilize the asynchronous memory copy functionality of CUDA. Asynchronous memory copy allows programs to run another code during memory copy operations. However, according to Table 6, hipSYCL which utilized the asynchronous copy took longer than the synchronous copy. We can assume that when we execute only a single parallel task, asynchronous copy causes more overhead than sequential copy. However, when we have to launch multiple parallel task for large data, the synchronous copy will cause more overhead for each launch. Additionally, by comparing Table 4; Table 6, we can see that total execution time of a parallel task increased when we enabled profiling functions. That is, to achieve the best performance, profile functions must be disabled. Table 7 shows detailed parameters during launch of the kernel and parallel computation. The result of Tables 6 and 7 show the importance of optimization in parallel task launch dimensions. SYCL implementations do not provide directives to control parallel task launch dimensions. Therefore, the launch dimensions are automatically selected by the implementation.