int main(int argc, char* argv[]) {
SDL_Surface* screen;
SDL_Event event;
if(SDL_Init(SDL_INIT_VIDEO) == -1) {
return 1;
}
SDL_WM_SetCaption("Game of Life", NULL);
screen = SDL_SetVideoMode(SCR_WIDTH, SCR_HEIGHT, 32, SDL_SWSURFACE);
Uint32 bg_color = SDL_MapRGB(screen->format, 0xFF, 0xFF, 0xFF);
Uint32 live_color = SDL_MapRGB(screen->format, 0x33, 0x33, 0x33);
int board1[BOARD_SIZE];
int board2[BOARD_SIZE];
initialize_board(board1);
memcpy(board2, board1, BOARD_SIZE * sizeof(int));
Uint64 generation = 0;
next_time = SDL_GetTicks() + TICK_INTERVAL;
while(1) {
int quit = 0;
int* current;
int* next;
if (generation++ % 2) {
current = board2;
next = board1;
} else {
current = board1;
next = board2;
}
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
quit = 1;
break;
case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_LEFT) {
if (event.button.y > (ROWS * CELL_SIZE)) break;
int tx = floor(event.button.x / CELL_SIZE);
int ty = floor(event.button.y / CELL_SIZE);
add_glider(current, tx, ty);
}
break;
default: continue;
}
}
if (quit) {
break;
}
draw_board(screen, current, bg_color, live_color);
SDL_Delay(time_left());
next_time += TICK_INTERVAL;
tick(current, next);
}
SDL_Quit();
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;
}