Benchmark of a Matrix Multiplication with Mekong's automatic partitioning workflow

mat_mul_2016-08-03.csv

Matrix Multiplication Benchmark

The kernel's analysis was done by hand, as polly fails on a
matrix multiplication kernel written in openCL.
The data file contains the following columns:

gpus = number of used GPUs

N = width of the matrix (N^2 elements in total)

app_htod_time[s] = time the user measures for the host to device
memory copy in his single GPU code. The user copied 2N^2 floating point
numbers to the GPU.

double timestamp = Clock::now();  
cuMemcpyHtoD(..., N*N*sizeof(float));  
cuMemcpyHtoD(..., N*N*sizeof(float));  
double app_htod_time = Clock::now() timestamp;

app_kernel_time[s] = time the user measures for the kernel launch
in his single GPU code.

double timestamp = Clock::now();  
for (int i = 0; i < 1000; ++i) {  
  cuLaunchKernel(...);  
  ...  
}  
double app_kernel_time = Clock::now() timestamp;  

app_dtoh_time[s] = time the user measures for the device to host
memory copy in his single GPU code. The user copied N^2 floating point
numbers from device to the host.

double timestamp = Clock::now();  
cuMemcpyDtoH(..., N*N*sizeof(float));  
double app_dtoh_time = Clock::now() timestamp;

dependency_resolution_calculation_time[s] = time to calculate the accessed intervals
and create the memory copies, which are mandatory to resolve inter kernel dependencies.
A dependency resolution is not necessary for this application, thus the measured time
is a small overhead. This time is a subset of app_kernel_time.

dependency_resolution_memcpy_time[s] = zero as there are no inter kernel dependencies.

linearization_time[s] = time to linearize the 2D access patterns. This time is a
subset of app_dtoh_time.