void Game::playNextLevel()
{
// qDebug() << "nextlevel";
level++;
create_level();
current_level->play();
}
/**
* \brief Do post creation actions.
*/
void rp::level_generator::on_enters_layer()
{
super::on_enters_layer();
srand(time(NULL));
create_level();
} // rp::level_generator::on_enters_layer()
void
EditorLevelSelectMenu::menu_action(MenuItem* item)
{
if (item->id >= 0)
{
Editor::current()->set_level(m_levelset->get_level_filename(item->id));
Editor::current()->set_worldmap_mode(false);
if (!reinit_world) {
Editor::current()->world = std::move(m_world);
}
MenuManager::instance().clear_menu_stack();
} else {
switch (item->id) {
case -1:
Editor::current()->world = std::move(m_world);
reinit_world = false;
create_level();
break;
case -2:
MenuManager::instance().pop_menu();
break;
case -3: {
std::unique_ptr<Menu> menu = std::unique_ptr<Menu>(new EditorLevelsetMenu(m_world.get()));
MenuManager::instance().push_menu(std::move(menu));
} break;
default:
break;
}
}
}
void Game::start(int lives, int level)
{
clearGfxObjectsFromScene();
this->global_lives = lives;
gamerounds_completed = 0;
this->level = level;
create_level();
current_level->play();
}
// TODO: null checks for game objects
game_level_p megamaniac_create_level2(game_p megamaniac) {
assert(NULL != megamaniac);
game_level_p level2 = create_level(14);
if (NULL == level2) {
return NULL;
}
level2->load = megamaniac_level2_load;
level2->resize = megamaniac_level_default_resize;
level2->unload = level_default_unload;
return level2;
}
// TODO: null checks for game objects
game_level_p megamaniac_create_level5(game_p megamaniac) {
assert(NULL != megamaniac);
game_level_p level5 = create_level(17);
if (NULL == level5) {
return NULL;
}
level5->load = megamaniac_level5_load;
// level5->resize = megamaniac_level5_resize;
level5->resize = megamaniac_level_default_resize;
level5->unload = level_default_unload;
return level5;
}
void Play_State_Base::on_push() {
get_Window().mouse_hide(true);
get_Window().mouse_grab(true);
get_Video().set_clear_Color(Color(0,.1,.1,.1));
get_Game().joy_mouse.enabled = false;
Game_Model::get().change_level(create_level(level.std_str()));
Game_Model::get().start_up(*player_info);
if(!isLocal)
Game_Model::get().initialize_peer(isServer, host_addr);
for(int i = 0; i < Game_Model::get().num_players_here() ; i++) {
controllers.push_back(new Controls(false, i));
if(player_info->at(i)->controls_ == 1)
controllers[i]->set_inverted(true);
controllers[i]->set_input_sensitivity(player_info->at(i)->sensitivities_);
}
}
static void create_levels(Image *image, char *type, unsigned long width,
unsigned long height)
{
unsigned int max_level;
int level;
/* How many times can we half the image in size? */
max_level = ceil(log2(MAX(width, height)));
for (level = max_level; level >= 0; level--) {
unsigned int columns = ceil((float)width / TILE_SZ);
unsigned int rows = ceil((float)height / TILE_SZ);
printf("level %d is %lu x %lu (%u columns, %u rows)\n",
level, width, height, columns, rows);
create_level(image, type, level, width, height, columns, rows);
width = (width + 1) >> 1; /* +1 for the effects of ceil */
height = (height + 1) >> 1;
}
}
int map_init(World* world, const char *file_map, const char *file_tiles) {
FILE *fp_map;
FILE *fp_tiles;
int width, height;
int x, y, i;
int **collision_map;
int **map;
char *entity_type = (char*)malloc(sizeof(char) * 128);
int entity_count;
SDL_Surface **tiles;
int *collision;
int num_tiles;
int pos = 0;
char *tile_filename = (char*)malloc(sizeof(char) * 128);
SDL_Rect tile_rect;
if (map_surface != 0) {
SDL_FreeSurface(map_surface);
}
//load tiles
if ((fp_tiles = fopen(file_tiles, "r")) == 0) {
printf("Error opening tile set %s\n", file_tiles);
return -1;
}
if (fscanf(fp_tiles, "%d", &num_tiles) != 1) {
printf("Cannot find tile number\n");
return -1;
}
if ((tiles = (SDL_Surface**)malloc(sizeof(SDL_Surface*) * num_tiles)) == 0) {
printf("Error mallocing tile surfaces\n");
return -1;
}
if ((collision = (int*)malloc(sizeof(int) * num_tiles)) == 0) {
printf("Error mallocing tile surfaces\n");
return -1;
}
for(i = 0; i < num_tiles; i++) {
if (fscanf(fp_tiles, "%d", &pos) != 1) {
printf("Error reading tile map index.\n");
return -1;
}
if (pos >= num_tiles) {
printf("Trying to write to tiles outside of memory\n");
return -1;
}
if (fscanf(fp_tiles, "%s", (char*)tile_filename) != 1) {
printf("Error reading tile map filename.\n");
return -1;
}
if (fscanf(fp_tiles, "%d", &collision[pos]) != 1){
printf("Error reading tile map collision.\n");
return -1;
}
tiles[pos] = IMG_Load(tile_filename);
if (tiles[pos] == NULL) {
printf("Error loading tile: %s\n", tile_filename);
return -1;
}
}
fclose(fp_tiles);
//LOAD MAP
if ((fp_map = fopen(file_map, "r")) == 0) {
printf("Error opening map %s\n", file_map);
return -1;
}
if (fscanf(fp_map, "%d %d %d", &level, &width, &height) != 3) {
return -1;
}
if ((map = (int**)malloc(sizeof(int*) * width)) == NULL) {
printf("malloc failed\n");
}
if ((collision_map = (int**)malloc(sizeof(int*) * width)) == NULL) {
printf("malloc failed\n");
}
for (i = 0; i < width; i++) {
if ((map[i] = (int*)malloc(sizeof(int) * height)) == NULL) {
printf("malloc failed\n");
}
if ((collision_map[i] = (int*)malloc(sizeof(int) * height)) == NULL) {
printf("malloc failed\n");
}
}
printf("Map load size %d %d\n", width, height);
for(y = 0; y < height; y++) {
for(x = 0; x < width; x++) {
if (fscanf(fp_map, "%d", &map[x][y]) != 1) {
printf("Expected more map.\n");
return -1;
}
if (map[x][y] >= num_tiles) {
printf("Using tile %u that is bigger than %d\n", map[x][y], num_tiles);
}
collision_map[x][y] = collision[map[x][y]];
}
}
if (fscanf(fp_map, "%d", &entity_count) == 1) {
for(i = 0; i < entity_count; i++) {
if (fscanf(fp_map, "%s", (char*)entity_type) != 1) {
printf("Entity type error: %s\n", file_map);
return -1;
}
//printf("Found entity: %s\n", entity_type);
if (strcmp(entity_type, "stair") == 0 || strcmp(entity_type, "stairs") == 0) { //stairs
//stair x y targetX targetY 2
int x, y, floor;
float targetX, targetY;
char dir;
if (fscanf(fp_map, "%d %d %f %f %d %c", &x, &y, &targetX, &targetY, &floor, &dir) != 6) {
printf("Error loading stair\n");
return -1;
}
switch (dir) { // make the hitboxes for the stairs
case 'l':
create_stair(world, floor, targetX * TILE_WIDTH + TILE_WIDTH / 2, targetY * TILE_HEIGHT + TILE_HEIGHT / 2, x * TILE_WIDTH + TILE_WIDTH / 2 - 5, y * TILE_HEIGHT + TILE_HEIGHT / 2, 4, 4, level);
create_block(world, x * TILE_WIDTH + 7, y * TILE_HEIGHT + TILE_HEIGHT / 2, 10, TILE_HEIGHT - 4, floor);
break;
case 'r':
create_stair(world, floor, targetX * TILE_WIDTH + TILE_WIDTH / 2, targetY * TILE_HEIGHT + TILE_HEIGHT / 2, x * TILE_WIDTH + TILE_WIDTH / 2 + 5, y * TILE_HEIGHT + TILE_HEIGHT / 2, 4, 4, level);
create_block(world, x * TILE_WIDTH + TILE_WIDTH - 7, y * TILE_HEIGHT + TILE_HEIGHT / 2, 10, TILE_HEIGHT - 4, floor);
break;
case 'u':
create_stair(world, floor, targetX * TILE_WIDTH + TILE_WIDTH / 2, targetY * TILE_HEIGHT + TILE_HEIGHT / 2, x * TILE_WIDTH + TILE_WIDTH / 2, y * TILE_HEIGHT + TILE_HEIGHT / 2 - 5, 4, 4, level);
create_block(world, x * TILE_WIDTH + TILE_WIDTH / 2, y * TILE_HEIGHT + 7, TILE_WIDTH - 4, 10, floor);
break;
case 'd':
create_stair(world, floor, targetX * TILE_WIDTH + TILE_WIDTH / 2, targetY * TILE_HEIGHT + TILE_HEIGHT / 2, x * TILE_WIDTH + TILE_WIDTH / 2, y * TILE_HEIGHT + TILE_HEIGHT / 2 + 5, 4, 4, level);
create_block(world, x * TILE_WIDTH + TILE_WIDTH / 2, y * TILE_HEIGHT + TILE_HEIGHT - 7, TILE_WIDTH - 4, 10, floor);
break;
}
}
else if (strcmp(entity_type, "object") == 0) { //animated objects
unsigned int entity;
float x, y;
int w, h;
char *animation_name = (char*)malloc(sizeof(char) * 64);
char *animation_filename = (char*)malloc(sizeof(char) * 64);
if (fscanf(fp_map, "%f %f %d %d %s %s", &x, &y, &w, &h, animation_filename, animation_name) != 6) {
printf("Error loading object!\n");
return -1;
}
entity = create_entity(world, COMPONENT_RENDER_PLAYER | COMPONENT_POSITION | COMPONENT_ANIMATION | COMPONENT_COLLISION);
//printf("Loading object %d (%f, %f) [%s] %s\n", entity, x, y, animation_name, animation_filename);
world->position[entity].x = x * TILE_WIDTH + TILE_WIDTH / 2;
world->position[entity].y = y * TILE_HEIGHT + TILE_HEIGHT / 2;
world->position[entity].width = w;
world->position[entity].height = h;
world->renderPlayer[entity].width = w;
world->renderPlayer[entity].height = h;
world->collision[entity].id = 0;
world->collision[entity].type = COLLISION_SOLID;
world->collision[entity].timer = 0;
world->collision[entity].timerMax = 0;
world->collision[entity].active = true;
world->collision[entity].radius = 0;
load_animation(animation_filename, world, entity);
play_animation(world, entity, animation_name);
free(animation_name);
free(animation_filename);
}
else if (strcmp(entity_type, "sound") == 0) {
int sound_id;
if (fscanf(fp_map, "%d", &sound_id) != 1) {
printf("Error loading sound!\n");
return -1;
}
play_music(sound_id);
//printf("Playing sound %d\n", sound_id);
}
else if (strcmp(entity_type, "objective") == 0) {
float x, y;
int w, h;
unsigned int id, entity = -1;
char *animation_filename = (char*)malloc(sizeof(char) * 64);
if (fscanf(fp_map, "%f %f %d %d %u %s", &x, &y, &w, &h, &id, animation_filename) != 6) {
printf("Error loading objective!\n");
return -1;
}
entity = create_objective(world, x * TILE_WIDTH + TILE_WIDTH / 2, y * TILE_HEIGHT + TILE_HEIGHT / 2, w, h, id, level);
if (entity >= MAX_ENTITIES) {
printf("exceeded max entities.\n");
return -1;
}
world->mask[entity] |= COMPONENT_ANIMATION | COMPONENT_RENDER_PLAYER;
world->renderPlayer[entity].width = w;
world->renderPlayer[entity].height = h;
load_animation(animation_filename, world, entity);
play_animation(world, entity, "not_captured");
//printf("Loaded objective: %u\n", entity);
free(animation_filename);
}
else if (strcmp(entity_type, "powerup") == 0) {
float x, y;
int w, h, type;
unsigned int entity = -1;
char *animation_filename = (char*)malloc(sizeof(char) * 128);
if (fscanf(fp_map, "%f %f %d %d %d %s", &x, &y, &w, &h, &type, animation_filename) != 6) {
printf("Error loading powerup!\n");
return -1;
}
entity = create_powerup(world, x * TILE_WIDTH + TILE_WIDTH / 2, y * TILE_HEIGHT + TILE_HEIGHT / 2, w, h, type, level);
if (entity >= MAX_ENTITIES) {
printf("exceeded max entities.\n");
return -1;
}
world->mask[entity] |= COMPONENT_ANIMATION | COMPONENT_RENDER_PLAYER;
world->renderPlayer[entity].width = w;
world->renderPlayer[entity].height = h;
load_animation(animation_filename, world, entity);
play_animation(world, entity, "bounce");
free(animation_filename);
}
else if (strcmp(entity_type, "chair") == 0) { //animated objects
unsigned int entity;
float x, y;
int w, h;
char *animation_name = (char*)malloc(sizeof(char) * 64);
char *animation_filename = (char*)malloc(sizeof(char) * 64);
if (fscanf(fp_map, "%f %f %d %d %s %s", &x, &y, &w, &h, animation_filename, animation_name) != 6) {
printf("Error loading chair!\n");
return -1;
}
entity = create_entity(world, COMPONENT_RENDER_PLAYER | COMPONENT_POSITION | COMPONENT_ANIMATION);
//printf("Loading object %d (%f, %f) [%s] %s\n", entity, x, y, animation_name, animation_filename);
world->position[entity].x = x * TILE_WIDTH;
world->position[entity].y = y * TILE_HEIGHT;
world->position[entity].width = w;
world->position[entity].height = h;
world->renderPlayer[entity].width = w;
world->renderPlayer[entity].height = h;
load_animation(animation_filename, world, entity);
play_animation(world, entity, animation_name);
free(animation_name);
free(animation_filename);
}
else {
printf("Did not deal with the entity type: %s\n", entity_type);
break;
}
}
}
fclose(fp_map);
//cleanup_map();
map_surface = SDL_CreateRGBSurface(0, width * TILE_WIDTH, height * TILE_HEIGHT, 32, 0, 0, 0, 0);
if (map_surface == 0) {
printf("error making map surface.\n");
return -1;
}
SDL_FillRect(map_surface, NULL, 0xFF0000);
tile_rect.w = TILE_WIDTH;
tile_rect.h = TILE_HEIGHT;
for(y = 0; y < height; y++) {
for(x = 0; x < width; x++) {
tile_rect.x = x * TILE_WIDTH;
tile_rect.y = y * TILE_HEIGHT;
SDL_BlitSurface(tiles[map[x][y]], NULL, map_surface, &tile_rect);
}
}
for(i = 0; i < num_tiles; i++) {
SDL_FreeSurface(tiles[i]);
}
map_rect.x = 0;
map_rect.y = 0;
w = map_rect.w = width * TILE_WIDTH;
h = map_rect.h = height * TILE_HEIGHT;
create_level(world, collision_map, width, height, TILE_WIDTH, level);
for (i = 0; i < width; i++) {
free(map[i]);
free(collision_map[i]);
}
free(map);
free(collision_map);
free(tiles);
free(collision);
free(entity_type);
free(tile_filename);
return 0;
}
//------------------------------------------------------------------------------------------------------------------------------
void hpgmg_setup(const int log2_box_dim,
const int target_boxes_per_rank,
const int OMP_Threads,
const int OMP_Nested,
const int requested_threading_model,
const int actual_threading_model) {
int my_rank=0;
int num_tasks=1;
#ifdef USE_MPI
MPI_Comm_size(MPI_COMM_WORLD, &num_tasks);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
//if(actual_threading_model>requested_threading_model)actual_threading_model=requested_threading_model;
if(my_rank==0){
if(requested_threading_model == MPI_THREAD_MULTIPLE )printf("Requested MPI_THREAD_MULTIPLE, ");
else if(requested_threading_model == MPI_THREAD_SINGLE )printf("Requested MPI_THREAD_SINGLE, ");
else if(requested_threading_model == MPI_THREAD_FUNNELED )printf("Requested MPI_THREAD_FUNNELED, ");
else if(requested_threading_model == MPI_THREAD_SERIALIZED)printf("Requested MPI_THREAD_SERIALIZED, ");
else if(requested_threading_model == MPI_THREAD_MULTIPLE )printf("Requested MPI_THREAD_MULTIPLE, ");
else printf("Requested Unknown MPI Threading Model (%d), ",requested_threading_model);
if(actual_threading_model == MPI_THREAD_MULTIPLE )printf("got MPI_THREAD_MULTIPLE\n");
else if(actual_threading_model == MPI_THREAD_SINGLE )printf("got MPI_THREAD_SINGLE\n");
else if(actual_threading_model == MPI_THREAD_FUNNELED )printf("got MPI_THREAD_FUNNELED\n");
else if(actual_threading_model == MPI_THREAD_SERIALIZED)printf("got MPI_THREAD_SERIALIZED\n");
else if(actual_threading_model == MPI_THREAD_MULTIPLE )printf("got MPI_THREAD_MULTIPLE\n");
else printf("got Unknown MPI Threading Model (%d)\n",actual_threading_model);
}
#endif
if(log2_box_dim<4){
if(my_rank==0){printf("log2_box_dim must be at least 4\n");}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
if(target_boxes_per_rank<1){
if(my_rank==0){printf("target_boxes_per_rank must be at least 1\n");}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
if(my_rank==0){
if(OMP_Nested)fprintf(stdout,"%d MPI Tasks of %d threads (OMP_NESTED=TRUE)\n\n" ,num_tasks,OMP_Threads);
else fprintf(stdout,"%d MPI Tasks of %d threads (OMP_NESTED=FALSE)\n\n",num_tasks,OMP_Threads);
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// calculate the problem size...
#ifndef MAX_COARSE_DIM
#define MAX_COARSE_DIM 11
#endif
int64_t box_dim=1<<log2_box_dim;
int64_t target_boxes = (int64_t)target_boxes_per_rank*(int64_t)num_tasks;
int64_t boxes_in_i = -1;
int64_t bi;
for(bi=1;bi<1000;bi++){ // all possible problem sizes
int64_t total_boxes = bi*bi*bi;
if(total_boxes<=target_boxes){
int64_t coarse_grid_dim = box_dim*bi;
while( (coarse_grid_dim%2) == 0){coarse_grid_dim=coarse_grid_dim/2;}
if(coarse_grid_dim<=MAX_COARSE_DIM){
boxes_in_i = bi;
}
}
}
if(boxes_in_i<1){
if(my_rank==0){printf("failed to find an acceptable problem size\n");}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// create the fine level...
#ifdef USE_PERIODIC_BC
int bc = BC_PERIODIC;
#else
int bc = BC_DIRICHLET;
#endif
level_type fine_grid;
int ghosts=stencil_get_radius();
create_level(&fine_grid,boxes_in_i,box_dim,ghosts,VECTORS_RESERVED,bc,my_rank,num_tasks);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifdef USE_HELMHOLTZ
double a=1.0;double b=1.0; // Helmholtz
if(my_rank==0)fprintf(stdout," Creating Helmholtz (a=%f, b=%f) test problem\n",a,b);
#else
double a=0.0;double b=1.0; // Poisson
if(my_rank==0)fprintf(stdout," Creating Poisson (a=%f, b=%f) test problem\n",a,b);
#endif
double h0=1.0/( (double)boxes_in_i*(double)box_dim );
initialize_problem(&fine_grid,h0,a,b); // calculate VECTOR_ALPHA, VECTOR_BETA, and VECTOR_UTRUE
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if( ((a==0.0)||(dot(&fine_grid,VECTOR_ALPHA,VECTOR_ALPHA)==0.0)) && (fine_grid.boundary_condition.type == BC_PERIODIC) ){
// Poisson w/ periodic BC's...
// nominally, u shifted by any constant is still a valid solution.
// However, by convention, we assume u sums to zero.
double average_value_of_u = mean(&fine_grid,VECTOR_UTRUE);
if(my_rank==0){fprintf(stdout," average value of u_true = %20.12e... shifting u_true to ensure it sums to zero...\n",average_value_of_u);}
shift_vector(&fine_grid,VECTOR_UTRUE,VECTOR_UTRUE,-average_value_of_u);
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//apply_op(&fine_grid,VECTOR_F,VECTOR_UTRUE,a,b); // by construction, f = A(u_true)
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if(fine_grid.boundary_condition.type == BC_PERIODIC){
double average_value_of_f = mean(&fine_grid,VECTOR_F);
if(average_value_of_f!=0.0){
if(my_rank==0){fprintf(stderr," WARNING... Periodic boundary conditions, but f does not sum to zero... mean(f)=%e\n",average_value_of_f);}
//shift_vector(&fine_grid,VECTOR_F,VECTOR_F,-average_value_of_f);
}
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
mg_type all_grids;
int minCoarseDim = 1;
rebuild_operator(&fine_grid,NULL,a,b); // i.e. calculate Dinv and lambda_max
MGBuild(&all_grids,&fine_grid,a,b,minCoarseDim); // build the Multigrid Hierarchy
double dtol= 0.0;double rtol=1e-10; // converged if ||b-Ax|| / ||b|| < rtol
//double dtol=1e-15;double rtol= 0.0; // converged if ||D^{-1}(b-Ax)|| < dtol
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int doTiming;
int minSolves = 10; // do at least minSolves MGSolves
double timePerSolve = 0;
for(doTiming=0;doTiming<=1;doTiming++){ // first pass warms up, second pass times
#ifdef USE_HPM // IBM performance counters for BGQ...
if(doTiming)HPM_Start("FMGSolve()");
#endif
#ifdef USE_MPI
double minTime = 30.0; // minimum time in seconds that the benchmark should run
double startTime = MPI_Wtime();
if(doTiming==1){
if((minTime/timePerSolve)>minSolves)minSolves=(minTime/timePerSolve); // if one needs to do more than minSolves to run for minTime, change minSolves
}
#endif
if(my_rank==0){
if(doTiming==0){fprintf(stdout,"\n\n===== warming up by running %d solves ===============================\n",minSolves);}
else{fprintf(stdout,"\n\n===== running %d solves =============================================\n",minSolves);}
fflush(stdout);
}
int numSolves = 0; // solves completed
MGResetTimers(&all_grids);
while( (numSolves<minSolves) ){
zero_vector(all_grids.levels[0],VECTOR_U);
#ifdef USE_FCYCLES
FMGSolve(&all_grids,0,VECTOR_U,VECTOR_F,a,b,dtol,rtol);
#else
MGSolve(&all_grids,0,VECTOR_U,VECTOR_F,a,b,dtol,rtol);
#endif
numSolves++;
}
#ifdef USE_MPI
if(doTiming==0){
double endTime = MPI_Wtime();
timePerSolve = (endTime-startTime)/numSolves;
MPI_Bcast(&timePerSolve,1,MPI_DOUBLE,0,MPI_COMM_WORLD); // after warmup, process 0 broadcasts the average time per solve (consensus)
}
#endif
#ifdef USE_HPM // IBM performance counters for BGQ...
if(doTiming)HPM_Stop("FMGSolve()");
#endif
}
MGPrintTiming(&all_grids); // don't include the error check in the timing results
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if(my_rank==0){fprintf(stdout,"calculating error... ");}
double fine_error = error(&fine_grid,VECTOR_U,VECTOR_UTRUE);
if(my_rank==0){fprintf(stdout,"h = %22.15e ||error|| = %22.15e\n\n",h0,fine_error);fflush(stdout);}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// MGDestroy()
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifdef USE_MPI
#ifdef USE_HPM // IBM performance counters for BGQ...
HPM_Print();
#endif
MPI_Finalize();
#endif
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
return;
}
void Game::resetLevel()
{
create_level();
current_level->play();
}
void game_loop(void)
{
bool redraw = true;
al_start_timer(timer);
int windowWidth = al_get_display_width(display);
int windowHeight = al_get_display_height(display);
User user{};
user.user_x = windowWidth/2;
int level_nr = 1;
LevelData level(create_level(60, level_nr, true));
ALLEGRO_KEYBOARD_STATE kbd_state;
double start_time = 0;
double time_last = 0;
double time_curr = 0;
double elapsed_time = 0;
double elapsed_time_unadjusted = 0;
bool death = false;
int finished_level = 5;
int num_kills = 0;
while (!done)
{
auto& opponents = level.opponents;
ALLEGRO_EVENT event;
al_wait_for_event(event_queue, &event);
if (event.type == ALLEGRO_EVENT_TIMER)
{
//done = main_loop.tick();
redraw = true;
time_curr = al_get_time();
double dt = time_curr - time_last;
dt = std::min(dt, 0.2);
elapsed_time_unadjusted += dt;
elapsed_time = elapsed_time_unadjusted - start_time;
for (auto& opponent : opponents)
{
if (!opponent.active && elapsed_time >= opponent.time)
{
opponent.active = true;
opponent.x = opponent.direction == Direction::LEFT ? windowWidth - 100 : 100;
}
else if (opponent.active)
{
int sign = opponent.direction == Direction::LEFT ? -1 : 1;
opponent.x += sign*opponent.speed*dt;
}
}
for (int i = 0; i < opponents.size(); i++)
{
auto& opponent = opponents[i];
if (opponent.active && overlaps(user.user_x, opponent.x, user.rect_size))
{
user.user_shape = opponent.is_shapeshifter ? opponent.shape : user.user_shape;
if (opponent.shape != user.user_shape)
{
death = true;
}
else
{
num_kills++;
}
opponents.erase(opponents.begin() + i);
i--;
}
}
al_get_keyboard_state(&kbd_state);
bool left = al_key_down(&kbd_state,ALLEGRO_KEY_LEFT) || al_key_down(&kbd_state, ALLEGRO_KEY_A);
bool right = al_key_down(&kbd_state,ALLEGRO_KEY_RIGHT) || al_key_down(&kbd_state, ALLEGRO_KEY_D);
if (left && !right)
{
user.user_x = user.user_x - user.user_speed*dt;
}
else if (!left && right)
{
user.user_x = user.user_x + user.user_speed*dt;
}
user.user_x = std::max(100.0 + 2*user.rect_size, user.user_x);
user.user_x = std::min(static_cast<double>(windowWidth) - 100.0 -(2*user.rect_size), user.user_x);
time_last = time_curr;
}
else if (event.type == ALLEGRO_EVENT_KEY_DOWN) {
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
done = true;
}
{
//main_loop.key_pressed(event.keyboard.keycode);
}
}
else if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
done = true;
}
if (redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
al_clear_to_color(ColorScheme::color_bg());
Drawing::draw_all(windowWidth, windowHeight, user, opponents);
if (level.first_level)
{
Drawing::draw_tutorial_texts(font, ColorScheme::color1(), windowWidth/2 , windowHeight/5, elapsed_time);
}
else if (level_nr != finished_level)
{
Drawing::draw_level_texts(font, ColorScheme::color1(), windowWidth/2, windowHeight/5, level_nr, elapsed_time);
}
else
{
Drawing::draw_credits(font, ColorScheme::color1(), windowWidth/2, windowHeight/5);
}
al_flip_display();
}
if (death)
{
if (level_nr == 1)
level = create_level(60, level_nr, false);
else
level = create_level(60, level_nr, false);
user = User{};
user.user_x = windowWidth/2;
start_time = al_get_time();
death = false;
num_kills = 0;
}
else if (opponents.empty())
{
level_nr++;
level = create_level(60, level_nr, false);
user = User{};
user.user_x = windowWidth/2;
start_time = al_get_time();
death = false;
num_kills = 0;
}
}
}
//------------------------------------------------------------------------------------------------------------------------------
int main(int argc, char **argv){
int my_rank=0;
int num_tasks=1;
int OMP_Threads = 1;
int OMP_Nested = 0;
#ifdef _OPENMP
#pragma omp parallel
{
#pragma omp master
{
OMP_Threads = omp_get_num_threads();
OMP_Nested = omp_get_nested();
}
}
#endif
#ifdef USE_MPI
int actual_threading_model = -1;
int requested_threading_model = -1;
requested_threading_model = MPI_THREAD_SINGLE;
//requested_threading_model = MPI_THREAD_FUNNELED;
//requested_threading_model = MPI_THREAD_SERIALIZED;
//requested_threading_model = MPI_THREAD_MULTIPLE;
//MPI_Init(&argc, &argv);
#ifdef _OPENMP
requested_threading_model = MPI_THREAD_FUNNELED;
//requested_threading_model = MPI_THREAD_SERIALIZED;
//requested_threading_model = MPI_THREAD_MULTIPLE;
//MPI_Init_thread(&argc, &argv, requested_threading_model, &actual_threading_model);
#endif
MPI_Init_thread(&argc, &argv, requested_threading_model, &actual_threading_model);
MPI_Comm_size(MPI_COMM_WORLD, &num_tasks);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
//if(actual_threading_model>requested_threading_model)actual_threading_model=requested_threading_model;
if(my_rank==0){
if(requested_threading_model == MPI_THREAD_MULTIPLE )printf("Requested MPI_THREAD_MULTIPLE, ");
else if(requested_threading_model == MPI_THREAD_SINGLE )printf("Requested MPI_THREAD_SINGLE, ");
else if(requested_threading_model == MPI_THREAD_FUNNELED )printf("Requested MPI_THREAD_FUNNELED, ");
else if(requested_threading_model == MPI_THREAD_SERIALIZED)printf("Requested MPI_THREAD_SERIALIZED, ");
else if(requested_threading_model == MPI_THREAD_MULTIPLE )printf("Requested MPI_THREAD_MULTIPLE, ");
else printf("Requested Unknown MPI Threading Model (%d), ",requested_threading_model);
if(actual_threading_model == MPI_THREAD_MULTIPLE )printf("got MPI_THREAD_MULTIPLE\n");
else if(actual_threading_model == MPI_THREAD_SINGLE )printf("got MPI_THREAD_SINGLE\n");
else if(actual_threading_model == MPI_THREAD_FUNNELED )printf("got MPI_THREAD_FUNNELED\n");
else if(actual_threading_model == MPI_THREAD_SERIALIZED)printf("got MPI_THREAD_SERIALIZED\n");
else if(actual_threading_model == MPI_THREAD_MULTIPLE )printf("got MPI_THREAD_MULTIPLE\n");
else printf("got Unknown MPI Threading Model (%d)\n",actual_threading_model);
}
#ifdef USE_HPM // IBM HPM counters for BGQ...
HPM_Init();
#endif
#endif // USE_MPI
int log2_box_dim = 6;
int target_boxes_per_rank = 1;
if(argc==3){
log2_box_dim=atoi(argv[1]);
target_boxes_per_rank=atoi(argv[2]);
}else{
if(my_rank==0){printf("usage: ./a.out [log2_box_dim] [target_boxes_per_rank]\n");}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
if(log2_box_dim<4){
if(my_rank==0){printf("log2_box_dim must be at least 4\n");}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
if(target_boxes_per_rank<1){
if(my_rank==0){printf("target_boxes_per_rank must be at least 1\n");}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
if(my_rank==0){
if(OMP_Nested)fprintf(stdout,"%d MPI Tasks of %d threads (OMP_NESTED=TRUE)\n\n" ,num_tasks,OMP_Threads);
else fprintf(stdout,"%d MPI Tasks of %d threads (OMP_NESTED=FALSE)\n\n",num_tasks,OMP_Threads);
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// calculate the problem size...
#ifndef MAX_COARSE_DIM
#define MAX_COARSE_DIM 11
#endif
int64_t box_dim=1<<log2_box_dim;
int64_t target_boxes = (int64_t)target_boxes_per_rank*(int64_t)num_tasks;
int64_t boxes_in_i = -1;
int64_t bi;
for(bi=1;bi<1000;bi++){ // all possible problem sizes
int64_t total_boxes = bi*bi*bi;
if(total_boxes<=target_boxes){
int64_t coarse_grid_dim = box_dim*bi;
while( (coarse_grid_dim%2) == 0){coarse_grid_dim=coarse_grid_dim/2;}
if(coarse_grid_dim<=MAX_COARSE_DIM){
boxes_in_i = bi;
}
}
}
if(boxes_in_i<1){
if(my_rank==0){printf("failed to find an acceptable problem size\n");}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// create the fine level...
#ifdef USE_PERIODIC_BC
int bc = BC_PERIODIC;
#else
int bc = BC_DIRICHLET;
#endif
level_type fine_grid;
int ghosts=stencil_get_radius();
create_level(&fine_grid,boxes_in_i,box_dim,ghosts,VECTORS_RESERVED,bc,my_rank,num_tasks);
//create_level(&fine_grid,boxes_in_i,box_dim,ghosts,VECTORS_RESERVED,BC_PERIODIC ,my_rank,num_tasks);double h0=1.0/( (double)boxes_in_i*(double)box_dim );double a=2.0;double b=1.0; // Helmholtz w/Periodic
//create_level(&fine_grid,boxes_in_i,box_dim,ghosts,VECTORS_RESERVED,BC_PERIODIC ,my_rank,num_tasks);double h0=1.0/( (double)boxes_in_i*(double)box_dim );double a=0.0;double b=1.0; // Poisson w/Periodic
//create_level(&fine_grid,boxes_in_i,box_dim,ghosts,VECTORS_RESERVED,BC_DIRICHLET,my_rank,num_tasks);double h0=1.0/( (double)boxes_in_i*(double)box_dim );double a=2.0;double b=1.0; // Helmholtz w/Dirichlet
//create_level(&fine_grid,boxes_in_i,box_dim,ghosts,VECTORS_RESERVED,BC_DIRICHLET,my_rank,num_tasks);double h0=1.0/( (double)boxes_in_i*(double)box_dim );double a=0.0;double b=1.0; // Poisson w/Dirichlet
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifdef USE_HELMHOLTZ
double a=2.0;double b=1.0; // Helmholtz
if(my_rank==0)fprintf(stdout," Creating Helmholtz (a=%f, b=%f) test problem\n",a,b);
#else
double a=0.0;double b=1.0; // Poisson
if(my_rank==0)fprintf(stdout," Creating Poisson (a=%f, b=%f) test problem\n",a,b);
#endif
double h0=1.0/( (double)boxes_in_i*(double)box_dim );
initialize_problem(&fine_grid,h0,a,b);
rebuild_operator(&fine_grid,NULL,a,b); // i.e. calculate Dinv and lambda_max
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
mg_type all_grids;
int minCoarseDim = 1;
MGBuild(&all_grids,&fine_grid,a,b,minCoarseDim); // build the Multigrid Hierarchy
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int doTiming;
int minSolves = 10; // do at least minSolves MGSolves
double timePerSolve = 0;
for(doTiming=0;doTiming<=1;doTiming++){ // first pass warms up, second pass times
#ifdef USE_HPM // IBM performance counters for BGQ...
if(doTiming)HPM_Start("FMGSolve()");
#endif
#ifdef USE_MPI
double minTime = 20.0; // minimum time in seconds that the benchmark should run
double startTime = MPI_Wtime();
if(doTiming==1){
if((minTime/timePerSolve)>minSolves)minSolves=(minTime/timePerSolve); // if one needs to do more than minSolves to run for minTime, change minSolves
}
#endif
if(my_rank==0){
if(doTiming==0){fprintf(stdout,"\n\n===== warming up by running %d solves ===============================\n",minSolves);}
else{fprintf(stdout,"\n\n===== running %d solves =============================================\n",minSolves);}
fflush(stdout);
}
int numSolves = 0; // solves completed
MGResetTimers(&all_grids);
while( (numSolves<minSolves) ){
zero_vector(all_grids.levels[0],VECTOR_U);
#ifdef USE_FCYCLES
FMGSolve(&all_grids,VECTOR_U,VECTOR_F,a,b,1e-15);
#else
MGSolve(&all_grids,VECTOR_U,VECTOR_F,a,b,1e-15);
#endif
numSolves++;
}
#ifdef USE_MPI
if(doTiming==0){
double endTime = MPI_Wtime();
timePerSolve = (endTime-startTime)/numSolves;
MPI_Bcast(&timePerSolve,1,MPI_DOUBLE,0,MPI_COMM_WORLD); // after warmup, process 0 broadcasts the average time per solve (consensus)
}
#endif
#ifdef USE_HPM // IBM performance counters for BGQ...
if(doTiming)HPM_Stop("FMGSolve()");
#endif
}
MGPrintTiming(&all_grids); // don't include the error check in the timing results
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if(my_rank==0){fprintf(stdout,"calculating error... ");}
double fine_error = error(&fine_grid,VECTOR_U,VECTOR_UTRUE);
if(my_rank==0){fprintf(stdout,"h = %22.15e ||error|| = %22.15e\n\n",h0,fine_error);fflush(stdout);}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// MGDestroy()
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifdef USE_MPI
#ifdef USE_HPM // IBM performance counters for BGQ...
HPM_Print();
#endif
MPI_Finalize();
#endif
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
return(0);
}
//------------------------------------------------------------------------------------------------------------------------------
int main(int argc, char **argv){
int my_rank=0;
int num_tasks=1;
int OMP_Threads = 1;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifdef _OPENMP
#pragma omp parallel
{
#pragma omp master
{
OMP_Threads = omp_get_num_threads();
}
}
#endif
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// initialize MPI and HPM
#ifdef USE_MPI
int actual_threading_model = -1;
int requested_threading_model = -1;
requested_threading_model = MPI_THREAD_SINGLE;
//requested_threading_model = MPI_THREAD_FUNNELED;
//requested_threading_model = MPI_THREAD_SERIALIZED;
//requested_threading_model = MPI_THREAD_MULTIPLE;
#ifdef _OPENMP
requested_threading_model = MPI_THREAD_FUNNELED;
//requested_threading_model = MPI_THREAD_SERIALIZED;
//requested_threading_model = MPI_THREAD_MULTIPLE;
#endif
MPI_Init_thread(&argc, &argv, requested_threading_model, &actual_threading_model);
MPI_Comm_size(MPI_COMM_WORLD, &num_tasks);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
#ifdef USE_HPM // IBM HPM counters for BGQ...
HPM_Init();
#endif
#endif // USE_MPI
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// parse the arguments...
int log2_box_dim = 6; // 64^3
int target_boxes_per_rank = 1;
//int64_t target_memory_per_rank = -1; // not specified
int64_t box_dim = -1;
int64_t boxes_in_i = -1;
int64_t target_boxes = -1;
if(argc==3){
log2_box_dim=atoi(argv[1]);
target_boxes_per_rank=atoi(argv[2]);
if(log2_box_dim>9){
// NOTE, in order to use 32b int's for array indexing, box volumes must be less than 2^31 doubles
if(my_rank==0){fprintf(stderr,"log2_box_dim must be less than 10\n");}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
if(log2_box_dim<4){
if(my_rank==0){fprintf(stderr,"log2_box_dim must be at least 4\n");}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
if(target_boxes_per_rank<1){
if(my_rank==0){fprintf(stderr,"target_boxes_per_rank must be at least 1\n");}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
#ifndef MAX_COARSE_DIM
#define MAX_COARSE_DIM 11
#endif
box_dim=1<<log2_box_dim;
target_boxes = (int64_t)target_boxes_per_rank*(int64_t)num_tasks;
boxes_in_i = -1;
int64_t bi;
for(bi=1;bi<1000;bi++){ // search all possible problem sizes to find acceptable boxes_in_i
int64_t total_boxes = bi*bi*bi;
if(total_boxes<=target_boxes){
int64_t coarse_grid_dim = box_dim*bi;
while( (coarse_grid_dim%2) == 0){coarse_grid_dim=coarse_grid_dim/2;}
if(coarse_grid_dim<=MAX_COARSE_DIM){
boxes_in_i = bi;
}
}
}
if(boxes_in_i<1){
if(my_rank==0){fprintf(stderr,"failed to find an acceptable problem size\n");}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
} // argc==3
#if 0
else if(argc==2){ // interpret argv[1] as target_memory_per_rank
char *ptr = argv[1];
char *tmp;
target_memory_per_rank = strtol(ptr,&ptr,10);
if(target_memory_per_rank<1){
if(my_rank==0){fprintf(stderr,"unrecognized target_memory_per_rank... '%s'\n",argv[1]);}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
tmp=strstr(ptr,"TB");if(tmp){ptr=tmp+2;target_memory_per_rank *= (uint64_t)(1<<30)*(1<<10);}
tmp=strstr(ptr,"GB");if(tmp){ptr=tmp+2;target_memory_per_rank *= (uint64_t)(1<<30);}
tmp=strstr(ptr,"MB");if(tmp){ptr=tmp+2;target_memory_per_rank *= (uint64_t)(1<<20);}
tmp=strstr(ptr,"tb");if(tmp){ptr=tmp+2;target_memory_per_rank *= (uint64_t)(1<<30)*(1<<10);}
tmp=strstr(ptr,"gb");if(tmp){ptr=tmp+2;target_memory_per_rank *= (uint64_t)(1<<30);}
tmp=strstr(ptr,"mb");if(tmp){ptr=tmp+2;target_memory_per_rank *= (uint64_t)(1<<20);}
if( (ptr) && (*ptr != '\0') ){
if(my_rank==0){fprintf(stderr,"unrecognized units... '%s'\n",ptr);}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
// FIX, now search for an 'acceptable' box_dim and boxes_in_i constrained by target_memory_per_rank, num_tasks, and MAX_COARSE_DIM
} // argc==2
#endif
else{
if(my_rank==0){fprintf(stderr,"usage: ./hpgmg-fv [log2_box_dim] [target_boxes_per_rank]\n");}
//fprintf(stderr," ./hpgmg-fv [target_memory_per_rank[MB,GB,TB]]\n");}
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(0);
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if(my_rank==0){
fprintf(stdout,"\n\n");
fprintf(stdout,"********************************************************************************\n");
fprintf(stdout,"*** HPGMG-FV Benchmark ***\n");
fprintf(stdout,"********************************************************************************\n");
#ifdef USE_MPI
if(requested_threading_model == MPI_THREAD_MULTIPLE )fprintf(stdout,"Requested MPI_THREAD_MULTIPLE, ");
else if(requested_threading_model == MPI_THREAD_SINGLE )fprintf(stdout,"Requested MPI_THREAD_SINGLE, ");
else if(requested_threading_model == MPI_THREAD_FUNNELED )fprintf(stdout,"Requested MPI_THREAD_FUNNELED, ");
else if(requested_threading_model == MPI_THREAD_SERIALIZED)fprintf(stdout,"Requested MPI_THREAD_SERIALIZED, ");
else if(requested_threading_model == MPI_THREAD_MULTIPLE )fprintf(stdout,"Requested MPI_THREAD_MULTIPLE, ");
else fprintf(stdout,"Requested Unknown MPI Threading Model (%d), ",requested_threading_model);
if(actual_threading_model == MPI_THREAD_MULTIPLE )fprintf(stdout,"got MPI_THREAD_MULTIPLE\n");
else if(actual_threading_model == MPI_THREAD_SINGLE )fprintf(stdout,"got MPI_THREAD_SINGLE\n");
else if(actual_threading_model == MPI_THREAD_FUNNELED )fprintf(stdout,"got MPI_THREAD_FUNNELED\n");
else if(actual_threading_model == MPI_THREAD_SERIALIZED)fprintf(stdout,"got MPI_THREAD_SERIALIZED\n");
else if(actual_threading_model == MPI_THREAD_MULTIPLE )fprintf(stdout,"got MPI_THREAD_MULTIPLE\n");
else fprintf(stdout,"got Unknown MPI Threading Model (%d)\n",actual_threading_model);
#endif
fprintf(stdout,"%d MPI Tasks of %d threads\n",num_tasks,OMP_Threads);
fprintf(stdout,"\n\n===== Benchmark setup ==========================================================\n");
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// create the fine level...
#ifdef USE_PERIODIC_BC
int bc = BC_PERIODIC;
int minCoarseDim = 2; // avoid problems with black box calculation of D^{-1} for poisson with periodic BC's on a 1^3 grid
#else
int bc = BC_DIRICHLET;
int minCoarseDim = 1; // assumes you can drop order on the boundaries
#endif
level_type level_h;
int ghosts=stencil_get_radius();
create_level(&level_h,boxes_in_i,box_dim,ghosts,VECTORS_RESERVED,bc,my_rank,num_tasks);
#ifdef USE_HELMHOLTZ
double a=1.0;double b=1.0; // Helmholtz
if(my_rank==0)fprintf(stdout," Creating Helmholtz (a=%f, b=%f) test problem\n",a,b);
#else
double a=0.0;double b=1.0; // Poisson
if(my_rank==0)fprintf(stdout," Creating Poisson (a=%f, b=%f) test problem\n",a,b);
#endif
double h=1.0/( (double)boxes_in_i*(double)box_dim ); // [0,1]^3 problem
initialize_problem(&level_h,h,a,b); // initialize VECTOR_ALPHA, VECTOR_BETA*, and VECTOR_F
rebuild_operator(&level_h,NULL,a,b); // calculate Dinv and lambda_max
if(level_h.boundary_condition.type == BC_PERIODIC){ // remove any constants from the RHS for periodic problems
double average_value_of_f = mean(&level_h,VECTOR_F);
if(average_value_of_f!=0.0){
if(my_rank==0){fprintf(stderr," WARNING... Periodic boundary conditions, but f does not sum to zero... mean(f)=%e\n",average_value_of_f);}
shift_vector(&level_h,VECTOR_F,VECTOR_F,-average_value_of_f);
}
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// create the MG hierarchy...
mg_type MG_h;
MGBuild(&MG_h,&level_h,a,b,minCoarseDim); // build the Multigrid Hierarchy
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// HPGMG-500 benchmark proper
// evaluate performance on problem sizes of h, 2h, and 4h
// (i.e. examine dynamic range for problem sizes N, N/8, and N/64)
//double dtol=1e-15;double rtol= 0.0; // converged if ||D^{-1}(b-Ax)|| < dtol
double dtol= 0.0;double rtol=1e-10; // converged if ||b-Ax|| / ||b|| < rtol
int l;
#ifndef TEST_ERROR
double AverageSolveTime[3];
for(l=0;l<3;l++){
if(l>0)restriction(MG_h.levels[l],VECTOR_F,MG_h.levels[l-1],VECTOR_F,RESTRICT_CELL);
bench_hpgmg(&MG_h,l,a,b,dtol,rtol);
AverageSolveTime[l] = (double)MG_h.timers.MGSolve / (double)MG_h.MGSolves_performed;
if(my_rank==0){fprintf(stdout,"\n\n===== Timing Breakdown =========================================================\n");}
MGPrintTiming(&MG_h,l);
}
if(my_rank==0){
#ifdef CALIBRATE_TIMER
double _timeStart=getTime();sleep(1);double _timeEnd=getTime();
double SecondsPerCycle = (double)1.0/(double)(_timeEnd-_timeStart);
#else
double SecondsPerCycle = 1.0;
#endif
fprintf(stdout,"\n\n===== Performance Summary ======================================================\n");
for(l=0;l<3;l++){
double DOF = (double)MG_h.levels[l]->dim.i*(double)MG_h.levels[l]->dim.j*(double)MG_h.levels[l]->dim.k;
double seconds = SecondsPerCycle*(double)AverageSolveTime[l];
double DOFs = DOF / seconds;
fprintf(stdout," h=%0.15e DOF=%0.15e time=%0.6f DOF/s=%0.3e MPI=%d OMP=%d\n",MG_h.levels[l]->h,DOF,seconds,DOFs,num_tasks,OMP_Threads);
}
}
#endif
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if(my_rank==0){fprintf(stdout,"\n\n===== Richardson error analysis ================================================\n");}
// solve A^h u^h = f^h
// solve A^2h u^2h = f^2h
// solve A^4h u^4h = f^4h
// error analysis...
MGResetTimers(&MG_h);
for(l=0;l<3;l++){
if(l>0)restriction(MG_h.levels[l],VECTOR_F,MG_h.levels[l-1],VECTOR_F,RESTRICT_CELL);
zero_vector(MG_h.levels[l],VECTOR_U);
#ifdef USE_FCYCLES
FMGSolve(&MG_h,l,VECTOR_U,VECTOR_F,a,b,dtol,rtol);
#else
MGSolve(&MG_h,l,VECTOR_U,VECTOR_F,a,b,dtol,rtol);
#endif
}
richardson_error(&MG_h,0,VECTOR_U);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if(my_rank==0){fprintf(stdout,"\n\n===== Deallocating memory ======================================================\n");}
MGDestroy(&MG_h);
destroy_level(&level_h);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if(my_rank==0){fprintf(stdout,"\n\n===== Done =====================================================================\n");}
#ifdef USE_MPI
#ifdef USE_HPM // IBM performance counters for BGQ...
HPM_Print();
#endif
MPI_Finalize();
#endif
return(0);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
}
int init_panel(window_t *win)
{
button_t *btn;
progress_t *prg;
level_t *lvl;
slider_t *sld;
panel_t *panel = &win->panel;
ctx_t *ctx = &panel->ctx;
link_initialize(&panel->ctrl.link);
list_initialize(&panel->ctrl.child);
panel->ctrl.handler = panel_proc;
panel->ctrl.parent = (ctrl_t*)win;
panel->layout = 0;
panel->bitmap.width = 1920;
panel->bitmap.height = PANEL_HEIGHT;
panel->bitmap.flags = 0;
if( create_bitmap(&panel->bitmap) )
{
printf("not enough memory for panel bitmap\n");
return 0;
}
ctx->pixmap = &panel->bitmap;
ctx->offset_x = 0;
ctx->offset_y = 0;
panel->ctrl.ctx = ctx;
btn = create_button(NULL, ID_PLAY,0,19,32,32,&panel->ctrl);
panel->play_btn = btn;
btn->img_default = res_pause_btn;
btn->img_hilite = res_pause_btn;
btn->img_pressed = res_pause_btn_pressed;
btn = create_button(NULL, ID_STOP,0,19,24,24,&panel->ctrl);
panel->stop_btn = btn;
btn->img_default = res_stop_btn;
btn->img_hilite = res_stop_btn;
btn->img_pressed = res_stop_btn_pressed;
prg = create_progress(NULL,ID_PROGRESS,0,4,0,10,&panel->ctrl);
panel->prg = prg;
lvl = create_level(NULL, ID_VOL_LEVEL, 0, 20, 96, 10, &panel->ctrl);
lvl->vol = -1875;
panel->lvl = lvl;
sld = create_slider(NULL, ID_VOL_CTRL, 0, 20, 96+12, 12, &panel->ctrl);
panel->sld = sld;
// btn = create_button(NULL, ID_MINIMIZE,0,5,16,18,(ctrl_t*)cpt);
// cpt->minimize_btn = btn;
// btn->img_default = res_minimize_btn;
// btn->img_hilite = res_minimize_btn_hl;
// btn->img_pressed = res_minimize_btn_pressed;
update_panel_size(win);
return 1;
};