void report_can_do(const char *param)
{
bench_problem *p;
p = problem_parse(param);
ovtpvt("#%c\n", can_do(p) ? 't' : 'f');
problem_destroy(p);
}
int main(int argc, char *argv[])
{
PetscErrorCode ierr;
int i;
grid *grd;
MPI_Init(&argc,&argv);
option options = parse_options(argc, argv);
if (options.problem == JUMP) {
grd = grid_create(-1, 1, options.nx,
-1, 1, options.ny,
-1, 1, options.nz);
} else {
grd = grid_create(0, 1, options.nx,
0, 1, options.ny,
0, 1, options.nz);
}
if (options.periodic > -1) grd->periodic[options.periodic] = 1;
int rank;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (rank == 0) print_intro(&options);
map *mp = map_create(options.map);
grid_apply_map(grd, mp);
problem *pb = problem_create(options.problem, grd->nd, mp->id);
solver *sol = solver_create(grd, pb);
ierr = solver_init(sol, grd);CHKERRQ(ierr);
ierr = solver_run(sol);CHKERRQ(ierr);
double *u = (double*) malloc(grd->num_pts*sizeof(double));
double *diff = (double*) malloc(grd->num_pts*sizeof(double));
grid_eval(grd, pb->sol, u);
for (i = 0; i < grd->num_pts; i++)
diff[i] = sol->state->phi[i] - u[i];
print_norm(diff, grd->num_pts);
free(u); free(diff);
grid_destroy(grd); free(grd);
map_destroy(mp); free(mp);
problem_destroy(pb); free(pb);
ierr = solver_destroy(sol);CHKERRQ(ierr); free(sol);
if (options.eig && rank == 0) {
system("./python/plot.py");
}
MPI_Finalize();
return 0;
}
void speed(const char *param)
{
double *t;
int iter, k;
bench_problem *p;
double tmin, y;
t = (double *) bench_malloc(time_repeat * sizeof(double));
p = problem_parse(param);
BENCH_ASSERT(can_do(p));
problem_alloc(p);
problem_zero(p);
timer_start();
setup(p);
p->setup_time = timer_stop();
start_over:
for (iter = 1; iter < (1<<30); iter *= 2) {
tmin = 1.0e20;
for (k = 0; k < time_repeat; ++k) {
timer_start();
doit(iter, p);
y = timer_stop();
if (y < 0) /* yes, it happens */
goto start_over;
t[k] = y;
if (y < tmin)
tmin = y;
}
if (tmin >= time_min)
goto done;
}
goto start_over; /* this also happens */
done:
done(p);
for (k = 0; k < time_repeat; ++k) {
t[k] /= iter;
}
report(p, t, time_repeat);
problem_destroy(p);
bench_free(t);
return;
}
int main(int argv, char ** argc) {
problem_t problem = problem_create(201, 270);
material_t ice = {
.alpha = 1.1965*pow(10.0, -6.0),
.rho = 917.3,
.L = 334000.0,
.kappa = 2.246
};
material_t snow = {
.alpha = 6.6671*pow(10.0, -7.0),
.rho = 584,
.L = 334000.0,
.kappa = 0.8048
};
problem.borders[0].position = 0.0;
problem.borders[1].position = 2.5;
problem.borders[2].position = 199.5;
problem.materials[0] = ice;
problem.materials[1] = snow;
problem.beta = 0.3;
// Read and create dataset
FILE * datafile = fopen("data.csv", "r");
if (datafile == NULL) {
error_warning("Could not open input file. Using fake values.");
problem.dataset = dataset_create(4);
} else {
problem.dataset = dataset_read(datafile, 4);
fclose(datafile);
}
problem_print_header(&problem);
problem_iterate(&problem, (unsigned)(24*8.64*pow(10.0, 7.0))); // 24 dag
problem_destroy(&problem);
return EXIT_SUCCESS;
}
void speed(const char *param, int setup_only)
{
double *t;
int iter = 0, k;
bench_problem *p;
double tmin, y;
t = (double *) bench_malloc(time_repeat * sizeof(double));
for (k = 0; k < time_repeat; ++k)
t[k] = 0;
p = problem_parse(param);
BENCH_ASSERT(can_do(p));
if (!no_speed_allocation) {
problem_alloc(p);
problem_zero(p);
}
timer_start(LIBBENCH_TIMER);
setup(p);
p->setup_time = bench_cost_postprocess(timer_stop(LIBBENCH_TIMER));
/* reset the input to zero again, because the planner in paranoid
mode sets it to random values, thus making the benchmark
diverge. */
if (!no_speed_allocation)
problem_zero(p);
if (setup_only)
goto done;
start_over:
for (iter = 1; iter < (1<<30); iter *= 2) {
tmin = 1.0e20;
for (k = 0; k < time_repeat; ++k) {
timer_start(LIBBENCH_TIMER);
doit(iter, p);
y = bench_cost_postprocess(timer_stop(LIBBENCH_TIMER));
if (y < 0) /* yes, it happens */
goto start_over;
t[k] = y;
if (y < tmin)
tmin = y;
}
if (tmin >= time_min)
goto done;
}
goto start_over; /* this also happens */
done:
done(p);
if (iter)
for (k = 0; k < time_repeat; ++k)
t[k] /= iter;
else
for (k = 0; k < time_repeat; ++k)
t[k] = 0;
report(p, t, time_repeat);
if (!no_speed_allocation)
problem_destroy(p);
bench_free(t);
return;
}
