static void
new_game (void)
{
fill_board ();
set_score (0);
gtk_widget_draw (draw_area, NULL);
}
int main(int argc, char const *argv[]) {
printf("Computing Game Of Life On %d x %d Board.\n", DIM_X, DIM_Y);
int *host_current, *host_future, *host_gpu_results;
int *gpu_current, *gpu_future;
cudaMallocHost((void**) &host_current, DIM_X * DIM_Y * sizeof(int));
cudaMallocHost((void**) &host_future, DIM_X * DIM_Y * sizeof(int));
cudaMallocHost((void**) &host_gpu_results, DIM_X * DIM_Y * sizeof(int));
cudaMalloc((void**) &gpu_current, DIM_X * DIM_Y * sizeof(int));
cudaMalloc((void**) &gpu_future, DIM_X * DIM_Y * sizeof(int));
assert(cudaGetLastError() == cudaSuccess);
fill_board(host_current, 40);
cudaMemcpy(gpu_current, host_current, DIM_X * DIM_Y * sizeof(int), cudaMemcpyHostToDevice);
setup_textures(gpu_current, gpu_future);
assert(cudaGetLastError() == cudaSuccess);
clock_t start, stop;
int current_is_a = 1;
printf("START!\n");
for(int i = 1; i < 10; i++) {
start = clock();
int *output = current_is_a ? gpu_future : gpu_current;
kernel_wrapper(current_is_a, output);
current_is_a = current_is_a ? 0 : 1;
cudaMemcpy(host_gpu_results, output, DIM_X * DIM_Y * sizeof(int), cudaMemcpyDeviceToHost);
assert(cudaGetLastError() == cudaSuccess);
stop = clock();
printf("Time for Textured GPU To Compute Next Phase: %.5f s\n", (float)(stop - start)/CLOCKS_PER_SEC);
start = clock();
update_board(host_current, host_future);
stop = clock();
printf("Time for CPU To Compute Next Phase: %.5f s\n", (float)(stop - start)/CLOCKS_PER_SEC);
printf("======\n");
check_boards(host_gpu_results, host_future);
int *temp;
temp = host_current;
host_current = host_future;
host_future = temp;
}
cudaFree(host_future);
cudaFree(host_current);
cudaFree(host_gpu_results);
cudaFree(gpu_current);
cudaFree(gpu_future);
return 0;
}
int main(int argc, char **argv) {
printf("Computing Game Of Life On %d x %d Board.\n", DIM_X, DIM_Y);
int *host_current, *host_future, *host_future_naive, *host_future_cached;
int *gpu_current, *gpu_future;
clock_t start, stop;
cudaMallocHost((void**) &host_current, DIM_X * DIM_Y * sizeof(int));
cudaMallocHost((void**) &host_future, DIM_X * DIM_Y * sizeof(int));
cudaMallocHost((void**) &host_future_naive, DIM_X * DIM_Y * sizeof(int));
cudaMallocHost((void**) &host_future_cached, DIM_X * DIM_Y * sizeof(int));
assert(cudaGetLastError() == cudaSuccess);
cudaMalloc((void**) &gpu_current, DIM_X * DIM_Y * sizeof(int));
cudaMalloc((void**) &gpu_future, DIM_X * DIM_Y * sizeof(int));
printf("%s\n", cudaGetErrorString(cudaGetLastError()));
assert(cudaGetLastError() == cudaSuccess);
fill_board(host_current, 40);
add_glider(host_current);
cudaMemcpy(gpu_current, host_current, DIM_X * DIM_Y * sizeof(int), cudaMemcpyHostToDevice);
// print_board(host_current);
float time_naive, time_cached, time_cpu;
for(int i = 1; i < STEPS; i++) {
printf("=========\n");
start = clock();
naive_game_of_life_wrapper(gpu_current, gpu_future);
cudaMemcpy(host_future_naive, gpu_future, DIM_X * DIM_Y * sizeof(int), cudaMemcpyDeviceToHost);
stop = clock();
time_naive = (float)(stop - start)/CLOCKS_PER_SEC;
printf("Time for Naive GPU To Compute Next Phase: %.5f s\n", time_naive);
start = clock();
cached_game_of_life_wrapper(gpu_current, gpu_future);
cudaMemcpy(host_future_cached, gpu_future, DIM_X * DIM_Y * sizeof(int), cudaMemcpyDeviceToHost);
stop = clock();
time_cached = (float)(stop - start)/CLOCKS_PER_SEC;
printf("Time for Cached GPU To Compute Next Phase: %.5f s\n", time_cached);
start = clock();
update_board(host_current, host_future);
stop = clock();
time_cpu = (float)(stop - start)/CLOCKS_PER_SEC;
printf("Time for CPU To Compute Next Phase: %.5f s\n", time_cpu);
printf("speedup for naive = %.2f; speedup for cached = %.2f; speedup for cached over naive = %.2f\n", time_cpu/time_naive, time_cpu/time_cached, time_naive/time_cached);
check_boards(host_future, host_future_naive);
check_boards(host_future, host_future_cached);
int *temp;
temp = host_current;
host_current = host_future;
host_future = temp;
temp = gpu_current;
gpu_current = gpu_future;
gpu_future = temp;
}
cudaFree(host_future);
cudaFree(host_future_naive);
cudaFree(host_future_cached);
cudaFree(host_current);
cudaFree(gpu_current);
cudaFree(gpu_future);
return 0;
}
static void create_same_board (const char *fname)
{
load_scenario (fname);
fill_board ();
}
static void new_game (HWND hwnd)
{
fill_board ();
set_score (0);
InvalidateRect (hwnd, &rcBoard, FALSE);
}
