int main(int argc, char **argv) {
// Needed for code to compile correctly on the Mac
int mype=0;
int numpe=-1;
// Process command-line arguments, if any.
parseInput(argc, argv);
struct timeval tstart_setup;
cpu_timer_start(&tstart_setup);
numpe = 16;
double circ_radius = 6.0;
// Scale the circle appropriately for the mesh size.
circ_radius = circ_radius * (double) nx / 128.0;
int boundary = 1;
int parallel_in = 0;
mesh = new Mesh(nx, ny, levmx, ndim, boundary, parallel_in, do_gpu_calc);
if (DEBUG) {
//if (mype == 0) mesh->print();
char filename[10];
sprintf(filename,"out%1d",mype);
mesh->fp=fopen(filename,"w");
//mesh->print_local();
}
mesh->init(nx, ny, circ_radius, initial_order, do_gpu_calc);
size_t &ncells = mesh->ncells;
state = new State(mesh);
state->init(do_gpu_calc);
mesh->proc.resize(ncells);
mesh->calc_distribution(numpe);
state->fill_circle(circ_radius, 100.0, 5.0);
mesh->nlft = NULL;
mesh->nrht = NULL;
mesh->nbot = NULL;
mesh->ntop = NULL;
// Kahan-type enhanced precision sum implementation.
double H_sum = state->mass_sum(enhanced_precision_sum);
printf ("Mass of initialized cells equal to %14.12lg\n", H_sum);
H_sum_initial = H_sum;
double cpu_time_main_setup = cpu_timer_stop(tstart_setup);
state->parallel_timer_output(numpe,mype,"CPU: setup time time was",cpu_time_main_setup);
long long mem_used = memstats_memused();
if (mem_used > 0) {
printf("Memory used in startup %lld kB\n",mem_used);
printf("Memory peak in startup %lld kB\n",memstats_mempeak());
printf("Memory free at startup %lld kB\n",memstats_memfree());
printf("Memory available at startup %lld kB\n",memstats_memtotal());
}
printf("Iteration 0 timestep n/a Sim Time 0.0 cells %ld Mass Sum %14.12lg\n", ncells, H_sum);
mesh->cpu_calc_neigh_counter=0;
mesh->cpu_time_calc_neighbors=0.0;
mesh->cpu_rezone_counter=0;
mesh->cpu_time_rezone_all=0.0;
mesh->cpu_refine_smooth_counter=0;
// Set up grid.
#ifdef GRAPHICS_OUTPUT
mesh->write_grid(n);
#endif
#ifdef HAVE_GRAPHICS
set_mysize(ncells);
set_viewmode(view_mode);
set_window(mesh->xmin, mesh->xmax, mesh->ymin, mesh->ymax);
set_outline((int)outline);
init_display(&argc, argv, "Shallow Water", mype);
set_cell_coordinates(&mesh->x[0], &mesh->dx[0], &mesh->y[0], &mesh->dy[0]);
set_cell_data(&state->H[0]);
set_cell_proc(&mesh->proc[0]);
set_circle_radius(circle_radius);
draw_scene();
//if (verbose) sleep(5);
sleep(2);
// Set flag to show mesh results rather than domain decomposition.
view_mode = 1;
// Clear superposition of circle on grid output.
circle_radius = -1.0;
cpu_timer_start(&tstart);
set_idle_function(&do_calc);
start_main_loop();
#else
cpu_timer_start(&tstart);
for (int it = 0; it < 10000000; it++) {
do_calc();
}
#endif
return 0;
}
int main(int argc, char **argv) {
// Process command-line arguments, if any.
int mype=0;
int numpe=0;
parseInput(argc, argv);
L7_Init(&mype, &numpe, &argc, argv);
#if 1 // SKG make things sane for debugging
signal(SIGSEGV, SIG_DFL);
#endif
struct timeval tstart_setup;
cpu_timer_start(&tstart_setup);
real_t circ_radius = 6.0;
// Scale the circle appropriately for the mesh size.
circ_radius = circ_radius * (real_t) nx / 128.0;
int boundary = 1;
int parallel_in = 1;
// figure out the max number of threads that can be spawned
if (0 == mype) {
int nt = omp_get_max_threads();
printf("--- num openmp threads: %d\n", nt);
fflush(stdout);
}
mesh = new Mesh(nx, ny, levmx, ndim, boundary, parallel_in, do_gpu_calc);
if (DEBUG) {
//if (mype == 0) mesh->print();
char filename[10];
sprintf(filename,"out%1d",mype);
mesh->fp=fopen(filename,"w");
//mesh->print_local();
}
mesh->init(nx, ny, circ_radius, initial_order, do_gpu_calc);
size_t &ncells = mesh->ncells;
size_t &ncells_global = mesh->ncells_global;
int &noffset = mesh->noffset;
state = new State(mesh);
state->init(do_gpu_calc);
vector<int> &nsizes = mesh->nsizes;
vector<int> &ndispl = mesh->ndispl;
vector<spatial_t> &x = mesh->x;
vector<spatial_t> &dx = mesh->dx;
vector<spatial_t> &y = mesh->y;
vector<spatial_t> &dy = mesh->dy;
nsizes.resize(numpe);
ndispl.resize(numpe);
int ncells_int = ncells;
MPI_Allgather(&ncells_int, 1, MPI_INT, &nsizes[0], 1, MPI_INT, MPI_COMM_WORLD);
ndispl[0]=0;
for (int ip=1; ip<numpe; ip++){
ndispl[ip] = ndispl[ip-1] + nsizes[ip-1];
}
noffset = ndispl[mype];
state->resize(ncells);
state->fill_circle(circ_radius, 100.0, 7.0);
x.clear();
dx.clear();
y.clear();
dy.clear();
// Kahan-type enhanced precision sum implementation.
double H_sum = state->mass_sum(enhanced_precision_sum);
if (mype == 0) printf ("Mass of initialized cells equal to %14.12lg\n", H_sum);
H_sum_initial = H_sum;
double cpu_time_main_setup = cpu_timer_stop(tstart_setup);
mesh->parallel_timer_output("CPU: setup time time was",cpu_time_main_setup, 0);
long long mem_used = memstats_memused();
if (mem_used > 0) {
mesh->parallel_memory_output("Memory used in startup ",mem_used, 0);
mesh->parallel_memory_output("Memory peak in startup ",memstats_mempeak(), 0);
mesh->parallel_memory_output("Memory free at startup ",memstats_memfree(), 0);
mesh->parallel_memory_output("Memory available at startup ",memstats_memtotal(), 0);
}
if (mype == 0) {
printf("Iteration 0 timestep n/a Sim Time 0.0 cells %ld Mass Sum %14.12lg\n", ncells_global, H_sum);
}
for (int i = 0; i < MESH_COUNTER_SIZE; i++){
mesh->cpu_counters[i]=0;
}
for (int i = 0; i < MESH_TIMER_SIZE; i++){
mesh->cpu_timers[i]=0.0;
}
#ifdef HAVE_GRAPHICS
#ifdef HAVE_OPENGL
set_mysize(ncells_global);
//vector<state_t> H_global;
//vector<spatial_t> x_global;
//vector<spatial_t> dx_global;
//vector<spatial_t> y_global;
//vector<spatial_t> dy_global;
//vector<int> proc_global;
if (mype == 0){
H_global.resize(ncells_global);
x_global.resize(ncells_global);
dx_global.resize(ncells_global);
y_global.resize(ncells_global);
dy_global.resize(ncells_global);
proc_global.resize(ncells_global);
}
MPI_Gatherv(&x[0], nsizes[mype], MPI_SPATIAL_T, &x_global[0], &nsizes[0], &ndispl[0], MPI_SPATIAL_T, 0, MPI_COMM_WORLD);
MPI_Gatherv(&dx[0], nsizes[mype], MPI_SPATIAL_T, &dx_global[0], &nsizes[0], &ndispl[0], MPI_SPATIAL_T, 0, MPI_COMM_WORLD);
MPI_Gatherv(&y[0], nsizes[mype], MPI_SPATIAL_T, &y_global[0], &nsizes[0], &ndispl[0], MPI_SPATIAL_T, 0, MPI_COMM_WORLD);
MPI_Gatherv(&dy[0], nsizes[mype], MPI_SPATIAL_T, &dy_global[0], &nsizes[0], &ndispl[0], MPI_SPATIAL_T, 0, MPI_COMM_WORLD);
MPI_Gatherv(&state->H[0], nsizes[mype], MPI_STATE_T, &H_global[0], &nsizes[0], &ndispl[0], MPI_STATE_T, 0, MPI_COMM_WORLD);
set_cell_data(&H_global[0]);
set_cell_coordinates(&x_global[0], &dx_global[0], &y_global[0], &dy_global[0]);
if (view_mode == 0) {
mesh->proc.resize(ncells);
for (size_t ii = 0; ii<ncells; ii++){
mesh->proc[ii] = mesh->mype;
}
MPI_Gatherv(&mesh->proc[0], nsizes[mype], MPI_INT, &proc_global[0], &nsizes[0], &ndispl[0], MPI_C_REAL, 0, MPI_COMM_WORLD);
}
set_cell_proc(&proc_global[0]);
#endif
#ifdef HAVE_MPE
set_mysize(ncells);
set_cell_data(&state->H[0]);
set_cell_coordinates(&mesh->x[0], &mesh->dx[0], &mesh->y[0], &mesh->dy[0]);
set_cell_proc(&mesh->proc[0]);
#endif
set_window((float)mesh->xmin, (float)mesh->xmax, (float)mesh->ymin, (float)mesh->ymax);
set_viewmode(view_mode);
set_outline((int)outline);
init_display(&argc, argv, "Shallow Water");
set_circle_radius(circle_radius);
draw_scene();
if (verbose) sleep(5);
sleep(2);
// Set flag to show mesh results rather than domain decomposition.
view_mode = 1;
// Clear superposition of circle on grid output.
circle_radius = -1.0;
MPI_Barrier(MPI_COMM_WORLD);
cpu_timer_start(&tstart);
set_idle_function(&do_calc);
start_main_loop();
#else
MPI_Barrier(MPI_COMM_WORLD);
cpu_timer_start(&tstart);
for (int it = 0; it < 10000000; it++) {
do_calc();
}
#endif
return 0;
}
gint
main (gint argc,
gchar **argv)
{
EBookClient *book_client;
EBookQuery *query;
EBookClientView *view;
gchar *sexp;
GError *error = NULL;
main_initialize ();
/*
* Sync version
*/
if (!setup_book (&book_client))
return 1;
query = e_book_query_any_field_contains ("");
sexp = e_book_query_to_string (query);
e_book_query_unref (query);
if (!e_book_client_get_view_sync (book_client, sexp, &view, NULL, &error)) {
report_error ("get book view sync", &error);
g_free (sexp);
g_object_unref (book_client);
return 1;
}
g_free (sexp);
setup_and_start_view (view);
start_main_loop (NULL, NULL);
if (!e_client_remove_sync (E_CLIENT (book_client), NULL, &error)) {
report_error ("client remove sync", &error);
g_object_unref (book_client);
return 1;
}
g_object_unref (book_client);
/*
* Async version uids only
*/
if (!setup_book (&book_client))
return 1;
start_in_idle_with_main_loop (call_get_view, book_client);
if (!e_client_remove_sync (E_CLIENT (book_client), NULL, &error)) {
report_error ("client remove sync", &error);
g_object_unref (book_client);
return 1;
}
g_object_unref (book_client);
return get_main_loop_stop_result ();
}
int main(int argc, char **argv) {
int ierr;
// Needed for code to compile correctly on the Mac
int mype=0;
int numpe=-1;
// Process command-line arguments, if any.
parseInput(argc, argv);
numpe = 16;
ierr = ezcl_devtype_init(CL_DEVICE_TYPE_GPU, 0);
if (ierr == EZCL_NODEVICE) {
ierr = ezcl_devtype_init(CL_DEVICE_TYPE_CPU, 0);
}
if (ierr != EZCL_SUCCESS) {
printf("No opencl device available -- aborting\n");
exit(-1);
}
real_t circ_radius = 6.0;
// Scale the circle appropriately for the mesh size.
circ_radius = circ_radius * (real_t) nx / 128.0;
int boundary = 1;
int parallel_in = 0;
mesh = new Mesh(nx, ny, levmx, ndim, boundary, parallel_in, do_gpu_calc);
if (DEBUG) {
//if (mype == 0) mesh->print();
char filename[10];
sprintf(filename,"out%1d",mype);
mesh->fp=fopen(filename,"w");
//mesh->print_local();
}
mesh->init(nx, ny, circ_radius, initial_order, do_gpu_calc);
size_t &ncells = mesh->ncells;
state = new State(mesh);
state->init(do_gpu_calc);
mesh->proc.resize(ncells);
mesh->calc_distribution(numpe);
state->fill_circle(circ_radius, 100.0, 7.0);
cl_mem &dev_celltype = mesh->dev_celltype;
cl_mem &dev_i = mesh->dev_i;
cl_mem &dev_j = mesh->dev_j;
cl_mem &dev_level = mesh->dev_level;
cl_mem &dev_H = state->dev_H;
cl_mem &dev_U = state->dev_U;
cl_mem &dev_V = state->dev_V;
state_t *H = state->H;
state_t *U = state->U;
state_t *V = state->V;
state->allocate_device_memory(ncells);
size_t one = 1;
state->dev_deltaT = ezcl_malloc(NULL, const_cast<char *>("dev_deltaT"), &one, sizeof(cl_real_t), CL_MEM_READ_WRITE, 0);
size_t mem_request = (int)((float)ncells*mesh->mem_factor);
dev_celltype = ezcl_malloc(NULL, const_cast<char *>("dev_celltype"), &mem_request, sizeof(cl_int), CL_MEM_READ_ONLY, 0);
dev_i = ezcl_malloc(NULL, const_cast<char *>("dev_i"), &mem_request, sizeof(cl_int), CL_MEM_READ_ONLY, 0);
dev_j = ezcl_malloc(NULL, const_cast<char *>("dev_j"), &mem_request, sizeof(cl_int), CL_MEM_READ_ONLY, 0);
dev_level = ezcl_malloc(NULL, const_cast<char *>("dev_level"), &mem_request, sizeof(cl_int), CL_MEM_READ_ONLY, 0);
cl_command_queue command_queue = ezcl_get_command_queue();
ezcl_enqueue_write_buffer(command_queue, dev_celltype, CL_FALSE, 0, ncells*sizeof(cl_int), (void *)&mesh->celltype[0], &start_write_event);
ezcl_enqueue_write_buffer(command_queue, dev_i, CL_FALSE, 0, ncells*sizeof(cl_int), (void *)&mesh->i[0], NULL );
ezcl_enqueue_write_buffer(command_queue, dev_j, CL_FALSE, 0, ncells*sizeof(cl_int), (void *)&mesh->j[0], NULL );
ezcl_enqueue_write_buffer(command_queue, dev_level, CL_FALSE, 0, ncells*sizeof(cl_int), (void *)&mesh->level[0], NULL );
ezcl_enqueue_write_buffer(command_queue, dev_H, CL_FALSE, 0, ncells*sizeof(cl_state_t), (void *)&H[0], NULL );
ezcl_enqueue_write_buffer(command_queue, dev_U, CL_FALSE, 0, ncells*sizeof(cl_state_t), (void *)&U[0], NULL );
ezcl_enqueue_write_buffer(command_queue, dev_V, CL_TRUE, 0, ncells*sizeof(cl_state_t), (void *)&V[0], &end_write_event );
state->gpu_time_write += ezcl_timer_calc(&start_write_event, &end_write_event);
mesh->nlft = NULL;
mesh->nrht = NULL;
mesh->nbot = NULL;
mesh->ntop = NULL;
mesh->dev_nlft = NULL;
mesh->dev_nrht = NULL;
mesh->dev_nbot = NULL;
mesh->dev_ntop = NULL;
if (ezcl_get_compute_device() == COMPUTE_DEVICE_ATI) enhanced_precision_sum = false;
// Kahan-type enhanced precision sum implementation.
double H_sum = state->mass_sum(enhanced_precision_sum);
printf ("Mass of initialized cells equal to %14.12lg\n", H_sum);
H_sum_initial = H_sum;
printf("Iteration 0 timestep n/a Sim Time 0.0 cells %ld Mass Sum %14.12lg\n", ncells, H_sum);
mesh->cpu_calc_neigh_counter=0;
mesh->cpu_time_calc_neighbors=0.0;
mesh->cpu_rezone_counter=0;
mesh->cpu_time_rezone_all=0.0;
mesh->cpu_refine_smooth_counter=0;
// Set up grid.
#ifdef GRAPHICS_OUTPUT
mesh->write_grid(n);
#endif
#ifdef HAVE_GRAPHICS
set_mysize(ncells);
set_viewmode(view_mode);
set_window((float)mesh->xmin, (float)mesh->xmax, (float)mesh->ymin, (float)mesh->ymax);
set_outline((int)outline);
init_display(&argc, argv, "Shallow Water", mype);
set_cell_coordinates(&mesh->x[0], &mesh->dx[0], &mesh->y[0], &mesh->dy[0]);
set_cell_data(&H[0]);
set_cell_proc(&mesh->proc[0]);
set_circle_radius(circle_radius);
draw_scene();
//if (verbose) sleep(5);
sleep(2);
// Set flag to show mesh results rather than domain decomposition.
view_mode = 1;
// Clear superposition of circle on grid output.
circle_radius = -1.0;
cpu_timer_start(&tstart);
set_idle_function(&do_calc);
start_main_loop();
#else
cpu_timer_start(&tstart);
for (int it = 0; it < 10000000; it++) {
do_calc();
}
#endif
return 0;
}
gint
main (gint argc,
gchar **argv)
{
EBookClient *book_client;
GError *error = NULL;
EContact *contact;
gchar *vcard;
main_initialize ();
/*
* Setup
*/
book_client = new_temp_client (NULL);
g_return_val_if_fail (book_client != NULL, 1);
if (!e_client_open_sync (E_CLIENT (book_client), FALSE, NULL, &error)) {
report_error ("client open sync", &error);
g_object_unref (book_client);
return 1;
}
/*
* Sync version
*/
if (!add_contact_from_test_case_verify (book_client, "simple-1", &contact)) {
g_object_unref (book_client);
return 1;
}
g_object_unref (contact);
if (!e_client_remove_sync (E_CLIENT (book_client), NULL, &error)) {
report_error ("client remove sync", &error);
g_object_unref (book_client);
return 1;
}
g_object_unref (book_client);
/*
* Async version
*/
book_client = new_temp_client (NULL);
g_return_val_if_fail (book_client != NULL, 1);
if (!e_client_open_sync (E_CLIENT (book_client), FALSE, NULL, &error)) {
report_error ("client open sync", &error);
g_object_unref (book_client);
return 1;
}
vcard = new_vcard_from_test_case ("simple-1");
contact = e_contact_new_from_vcard (vcard);
g_free (vcard);
e_book_client_add_contact (book_client, contact, NULL, add_contact_cb, NULL);
g_object_unref (contact);
start_main_loop (NULL, NULL);
if (!e_client_remove_sync (E_CLIENT (book_client), NULL, &error)) {
report_error ("client remove sync", &error);
g_object_unref (book_client);
return 1;
}
g_object_unref (book_client);
return get_main_loop_stop_result ();
}
gint
main (gint argc,
gchar **argv)
{
EBookClient *book_client;
GError *error = NULL;
EContact *contact;
gchar *uid;
main_initialize ();
/*
* Setup
*/
book_client = new_temp_client (NULL);
g_return_val_if_fail (book_client != NULL, 1);
if (!e_client_open_sync (E_CLIENT (book_client), FALSE, NULL, &error)) {
report_error ("client open sync", &error);
g_object_unref (book_client);
return 1;
}
/*
* Sync version
*/
if (!add_contact_from_test_case_verify (book_client, "simple-1", &contact)) {
g_object_unref (book_client);
return 1;
}
uid = e_contact_get (contact, E_CONTACT_UID);
g_object_unref (contact);
if (!e_book_client_remove_contact_by_uid_sync (book_client, uid, NULL, &error)) {
report_error ("remove contact sync", &error);
g_object_unref (book_client);
g_free (uid);
return 1;
}
if (!e_book_client_get_contact_sync (book_client, uid, &contact, NULL, &error) &&
g_error_matches (error, E_BOOK_CLIENT_ERROR, E_BOOK_CLIENT_ERROR_CONTACT_NOT_FOUND)) {
g_clear_error (&error);
} else {
report_error ("fail with get contact sync on removed contact", &error);
g_object_unref (book_client);
g_free (uid);
return 1;
}
g_free (uid);
if (!e_client_remove_sync (E_CLIENT (book_client), NULL, &error)) {
report_error ("client remove sync", &error);
g_object_unref (book_client);
return 1;
}
g_object_unref (book_client);
/*
* Async version
*/
book_client = new_temp_client (NULL);
g_return_val_if_fail (book_client != NULL, 1);
if (!e_client_open_sync (E_CLIENT (book_client), FALSE, NULL, &error)) {
report_error ("client open sync", &error);
g_object_unref (book_client);
return 1;
}
contact = NULL;
if (!add_contact_from_test_case_verify (book_client, "simple-1", &contact)) {
g_object_unref (book_client);
return 1;
}
uid = e_contact_get (contact, E_CONTACT_UID);
g_object_unref (contact);
e_book_client_remove_contact_by_uid (book_client, uid, NULL, remove_contact_by_uid_cb, uid);
start_main_loop (NULL, NULL);
g_free (uid);
if (!e_client_remove_sync (E_CLIENT (book_client), NULL, &error)) {
report_error ("client remove sync", &error);
g_object_unref (book_client);
return 1;
}
g_object_unref (book_client);
return 0;
}
gboolean start_new_game (gchar *game_filename, gchar *graphics_filename,
gchar *splash_filename, gchar *music_filename,
gchar *hints_filename)
{
const gchar *filters[] =
{
"Magnetic Scrolls data file (*.mag)", "*.mag",
NULL
};
if (!game_filename)
game_filename = file_selector (FALSE, NULL, filters, "Open game file");
if (!game_filename)
return TRUE;
stop_main_loop ();
if (ms_is_running ())
{
ms_stop ();
ms_freemem ();
}
stop_recording (TRUE);
stop_scripting (TRUE);
stop_replaying (TRUE);
if (!graphics_filename)
graphics_filename = change_file_extension (game_filename, "gfx");
if (!splash_filename)
splash_filename = change_file_extension (game_filename, "png");
if (!music_filename)
music_filename = change_file_extension (game_filename, "mp3");
if (!hints_filename)
hints_filename = change_file_extension (game_filename, "hnt");
display_splash_screen (splash_filename, music_filename);
text_clear ();
graphics_clear ();
hints_clear ();
if (applicationExiting)
return FALSE;
if (!ms_init ((type8s *) game_filename, (type8s *) graphics_filename, (type8s *) hints_filename), NULL)
{
GtkWidget *error;
gchar *basename;
basename = g_path_get_basename (game_filename);
error = gtk_message_dialog_new (
GTK_WINDOW (Gui.main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"Could not start the game! The most likely cause is\n"
"that '%s' is not a valid game file.",
basename);
gtk_dialog_run (GTK_DIALOG (error));
g_free (basename);
gtk_widget_destroy (error);
} else
start_main_loop ();
g_free (game_filename);
g_free (graphics_filename);
g_free (splash_filename);
g_free (music_filename);
g_free (hints_filename);
gtk_widget_grab_focus (Gui.text_view);
return TRUE;
}
