int init_data(void) //returns code of error { int error=0; int i,j,k,l,tmpr; char fstr[256], pos; float tmpf; char tmpc; double Re1; // priority for parameter in snap-file FILE *inp; pos = strcspn(NameInitFile,"*"); NameInitFile[pos]=0; sprintf(fstr,"%s%d%s",NameInitFile,rank+0*size,NameInitFile+pos+1); inp = fileopen(fstr,-1); read_tilleq(inp,'=','n'); if(fscanf(inp,"%lf",&t_cur)==0) error=1; read_tilleq(inp,'=','n'); if(fscanf(inp,"%ld",&count)==0) error=1; read_tilleq(inp,'=','n'); if(fscanf(inp,"%c%d%c%d%c%d%c",&tmpc,&pp[0],&tmpc,&pp[1],&tmpc,&pp[2],&tmpc)<7) error=1; //no need unless process distribution is written if(pp[0]*pp[1]*pp[2]!=size) nrerror("Wrong number of processors in data file. Can't read data.",-1,-1); read_tilleq(inp,'=','n'); if(fscanf(inp,"%d",&N1)==0) error=1; read_tilleq(inp,'=','n'); if(fscanf(inp,"%d",&N2)==0) error=1; read_tilleq(inp,'=','n'); if(fscanf(inp,"%d",&N3)==0) error=1; read_tilleq(inp,'=','n'); if(fscanf(inp,"%lf",&Re1)==0) error=1; // fgetc(inp); fgetc(inp); read_tilleq(inp,0x0A,'n'); init_parallel(); operate_memory(1); // creating arrays // for(tmpr=0;tmpr<=rank;tmpr++) //reading until arrays of this process // { for(l=0;l<nvar;l++) // reading f for(i=0;i<m1;i++) for(j=0;j<m2;j++) for(k=0;k<m3;k++) { if(fread(&tmpf,sizeof(float),1,inp)<1) error=2*(k+100*(j+100*i)); f[l][i][j][k] = tmpf; } for(i=0;i<m1;i++) for(j=0;j<m2;j++) for(k=0;k<m3;k++) { if(fread(&tmpf,sizeof(float),1,inp)<1) error=3*(k+100*(j+100*i)); nut[i][j][k] = tmpf; } // } fileclose(inp); if(error) nrerror("Data couldn't have been read from file!!!",-1,error); else Master nmessage("Data has been read from file",t_cur,count); return(error); }
int init_data(void) //returns code of error { int error=0; int i,j,k,l,tmpr; float tmpd; char tmpc; FILE *inp = fileopen(NameInitFile,-1); read_tilleq(inp,'n'); if(fscanf(inp,"%lf",&t_cur)==0) error=1; read_tilleq(inp,'n'); if(fscanf(inp,"%ld",&count)==0) error=1; read_tilleq(inp,'n'); if(fscanf(inp,"%c%d%c%d%c%d%c",&tmpc,&pp[0],&tmpc,&pp[1],&tmpc,&pp[2],&tmpc)<7) error=1; //no need unless process distribution is written if(pp[0]*pp[1]*pp[2]!=size) nrerror("Wrong number of processors in data file. Can't read data.",0,0); read_tilleq(inp,'n'); if(fscanf(inp,"%d",&N1)==0) error=1; read_tilleq(inp,'n'); if(fscanf(inp,"%d",&N2)==0) error=1; read_tilleq(inp,'n'); if(fscanf(inp,"%d",&N3)==0) error=1; read_tilleq(inp,'n'); if(fscanf(inp,"%lf",&Re)==0) error=1; init_parallel(); operate_memory(1); // creating arrays for(tmpr=0;tmpr<=rank;tmpr++) //reading until arrays of this process { for(l=0;l<nvar;l++) // reading f { do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); for(i=0;i<m1;i++) { do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); for(j=0;j<m2;j++) { do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); for(k=0;k<m3;k++) { if(fscanf(inp,"%g",&tmpd)==0) error=2; fscanf(inp,"%c",&tmpc); f[l][i][j][k]=tmpd; } fscanf(inp,"%c",&tmpc); } fscanf(inp,"%c",&tmpc); } fscanf(inp,"%c",&tmpc); } for(l=0;l<6;l++) // reading B and j { do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); for(i=0;i<m1;i++) { do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); for(j=0;j<m2;j++) { do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); for(k=0;k<m3;k++) { if(fscanf(inp,"%g",&tmpd)==0) error=2; fscanf(inp,"%c",&tmpc); B[l%3][i][j][k]=tmpd; } fscanf(inp,"%c",&tmpc); } fscanf(inp,"%c",&tmpc); } fscanf(inp,"%c",&tmpc); } do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); //reading nut for(i=0;i<m1;i++) { do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); for(j=0;j<m2;j++) { do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); for(k=0;k<m3;k++) { if(fscanf(inp,"%g",&tmpd)==0) error=3; fscanf(inp,"%c",&tmpc); nut[i][j][k]=tmpd; } fscanf(inp,"%c",&tmpc); } fscanf(inp,"%c",&tmpc); } fscanf(inp,"%c",&tmpc); } fclose(inp); if(error) nrerror("Data couldn't have been read from file!!!",0,0); else Master nmessage("Data has been read from file",t_cur,count); return(error); }
int main (int argc, char* argv[]) { init_parallel(argc, argv); load_data(argc, argv); start_serial_pearson(); parallel.err = MPI_Barrier(MPI_COMM_WORLD); parallel.start_time = MPI_Wtime(); clock_t pstart, pend; pstart = clock(); double sum_a, sum_b; double start = MPI_Wtime(); if (USE_PARALLEL_INDICES) { parallel_mean2(input_data.a, &sum_a); parallel_mean2(input_data.b, &sum_b); } else { parallel_mean(input_data.a, &sum_a); parallel_mean(input_data.b, &sum_b); } parallel.err = MPI_Barrier(MPI_COMM_WORLD); double end = MPI_Wtime(); double d = (end * 1000) - (start * 1000); if (parallel.rank == ROOT_PROC) printf("\tParallel mean computed in %.*f ms\n", FLOAT_PRECISION, d); start = MPI_Wtime(); if (USE_BROADCAST) { parallel.mean_x = sum_a / INPUT_LENGTH; parallel.mean_y = sum_b / INPUT_LENGTH; MPI_Bcast(¶llel.mean_x, 1, MPI_DOUBLE, ROOT_PROC, MPI_COMM_WORLD); MPI_Bcast(¶llel.mean_y, 1, MPI_DOUBLE, ROOT_PROC, MPI_COMM_WORLD); if (parallel.rank == ROOT_PROC) { printf("\tMean X: %*.*f\n", RESULT_LENGTH, FLOAT_PRECISION, parallel.mean_x); printf("\tMean Y: %*.*f\n", RESULT_LENGTH, FLOAT_PRECISION, parallel.mean_y); } } else { broadcast_parallel_mean(sum_a, sum_b); } parallel.err = MPI_Barrier(MPI_COMM_WORLD); end = MPI_Wtime(); d = (end * 1000) - (start * 1000); if (parallel.rank == ROOT_PROC) printf("\tBroadcasting mean took %.*f ms\n", FLOAT_PRECISION, d); start = MPI_Wtime(); double nom_a, nom_b; if (USE_PARALLEL_INDICES) { parallel_stddev2(input_data.a, &nom_a); parallel_stddev2(input_data.b, &nom_b); } else { parallel_stddev(input_data.a, &nom_a); parallel_stddev(input_data.b, &nom_b); } parallel.err = MPI_Barrier(MPI_COMM_WORLD); end = MPI_Wtime(); d = (end * 1000) - (start * 1000); if (parallel.rank == ROOT_PROC) printf("\tParallel stddev computed in %.*f ms\n", FLOAT_PRECISION, d); start = MPI_Wtime(); if (USE_BROADCAST) { parallel.stddev_x = sqrt(nom_a / INPUT_LENGTH); parallel.stddev_y = sqrt(nom_b / INPUT_LENGTH); MPI_Bcast(¶llel.stddev_x, 1, MPI_DOUBLE, ROOT_PROC, MPI_COMM_WORLD); MPI_Bcast(¶llel.stddev_y, 1, MPI_DOUBLE, ROOT_PROC, MPI_COMM_WORLD); if (parallel.rank == ROOT_PROC) { printf("\tStd dev X: %*.*f\n", RESULT_LENGTH, FLOAT_PRECISION, parallel.stddev_x); printf("\tStd dev Y: %*.*f\n", RESULT_LENGTH, FLOAT_PRECISION, parallel.stddev_y); } } else { broadcast_parallel_stddev(nom_a, nom_b); } parallel.err = MPI_Barrier(MPI_COMM_WORLD); end = MPI_Wtime(); d = (end * 1000) - (start * 1000); if (parallel.rank == ROOT_PROC) printf("\tBroadcasting stddev took %.*f ms\n", FLOAT_PRECISION, d); start = MPI_Wtime(); double pearson_nominator; parallel_pearson(&pearson_nominator); parallel.err = MPI_Barrier(MPI_COMM_WORLD); end = MPI_Wtime(); d = (end * 1000) - (start * 1000); if (parallel.rank == ROOT_PROC) printf("\tParallel Pearson coefficient computed in %.*f ms\n", FLOAT_PRECISION, d); finish_parallel_pearson(pearson_nominator); pend = clock(); double diff = (((double)pend * 1000 - (double)pstart * 1000) / CLOCKS_PER_SEC); parallel.err = MPI_Finalize(); return 0; }
int main(int argn, char** args){ double **U, **V, **P, **F, **G, **RS; int **Flag; char problem[60]; char parameters_filename[60]; char pgm[60]; char output_dirname[60]; double Re, UI, VI, PI, GX, GY, t_end, xlength, ylength, dt, dx, dy, alpha, omg, tau, eps, dt_value, dp; double res = 0, t = 0, n = 0; int imax, jmax, itermax, it; int wl, wr, wt, wb; int timestepsPerPlotting; char old_output_filename[128]; struct dirent *old_outputfile; DIR *output_dir; /* Variables for parallel program */ int iproc, jproc, myrank, il, ir, jb, jt, rank_l, rank_r, rank_b, rank_t, omg_i, omg_j, num_proc; double min_dt; double *bufSend, *bufRecv; double totalTime = 0; struct timespec previousTime, currentTime; MPI_Init(&argn, &args); MPI_Comm_size(MPI_COMM_WORLD, &num_proc); /* Read name of the problem from the command line arguments */ if(argn > 1) { strcpy(problem, args[1]); } else { printf("\n=== ERROR: Please provide the name of the problem\n=== e.g. Run ./sim problem_name if there is a problem_name.dat file.\n\n"); MPI_Finalize(); return 1; } /* Generate input filename based on problem name */ strcpy(parameters_filename, problem); strcat(parameters_filename, ".dat"); /* Read the program configuration file using read_parameters() */ read_parameters(parameters_filename, pgm, &Re, &UI, &VI, &PI, &GX, &GY, &t_end, &xlength, &ylength, &dt, &dx, &dy, &imax, &jmax, &alpha, &omg, &tau, &itermax, &eps, &dt_value, problem, &dp, &wl, &wr, &wt, &wb, ×tepsPerPlotting, &iproc, &jproc); printf("%s\n", pgm); /* Check if the number of processes is correct */ if(iproc * jproc != num_proc) { printf("\n=== ERROR: Number of processes is incorrect (iproc=%d, jproc=%d, -np=%d) ===\n\n", iproc, jproc, num_proc); MPI_Finalize(); return 1; } /* Create folder with the name of the problem */ strcpy(output_dirname, problem); strcat(output_dirname, "/"); strcat(output_dirname, problem); mkdir(problem, 0777); output_dir = opendir(problem); /* Delete existing files in output folder*/ while((old_outputfile = readdir(output_dir))) { sprintf(old_output_filename, "%s/%s", problem, old_outputfile->d_name); remove(old_output_filename); } /* Determine subdomain and neighbours for each process */ init_parallel(iproc, jproc, imax, jmax, &myrank, &il, &ir, &jb, &jt, &rank_l, &rank_r, &rank_b, &rank_t, &omg_i, &omg_j, num_proc); /* Set up the matrices (arrays) needed using the matrix() command */ U = matrix(il-2, ir+1, jb-1, jt+1); V = matrix(il-1, ir+1, jb-2, jt+1); P = matrix(il-1, ir+1, jb-1, jt+1); F = matrix(il-2, ir+1, jb-1, jt+1); G = matrix(il-1, ir+1, jb-2, jt+1); RS= matrix(il, ir, jb, jt); Flag = imatrix(il-1, ir+1, jb-1, jt+1); /* Assign initial values to u, v, p */ init_uvp(UI, VI, PI, il, ir, jb, jt, U, V, P); /* Allocate memory for buffers */ bufSend = malloc(max(ir-il+3, jt-jb+3) * sizeof(double)); bufRecv = malloc(max(ir-il+3, jt-jb+3) * sizeof(double)); /* Initialize lower part of the domain with UI = 0 for the flow_over_step problem */ /* (this code might be moved to somewhere else later) */ if(strcmp(problem, "flow_over_step") == 0) { init_matrix(U, il, ir, jb, min(jmax/2, jt), 0); } /* Initialization of flag field */ init_flag(pgm, imax, jmax, il, ir, jb, jt, Flag, dp); if(myrank == 0) { clock_gettime(CLOCK_MONOTONIC, ¤tTime); } while(t <= t_end){ /* Select δt */ calculate_dt(Re, tau, &dt, dx, dy, il, ir, jb, jt, U, V); MPI_Allreduce(&dt, &min_dt, 1, MPI_DOUBLE, MPI_MIN, MPI_COMM_WORLD); dt = min_dt; /* Set boundary values for u and v */ boundaryvalues(il, ir, jb, jt, imax, jmax, U, V, wl, wr, wt, wb, Flag); /* Set special boundary values */ spec_boundary_val(problem, il, ir, jb, jt, imax, jmax, U, V, P, Re, xlength, ylength, dp); /* Compute F(n) and G(n) */ calculate_fg(Re, GX, GY, alpha, dt, dx, dy, il, ir, jb, jt, imax, jmax, U, V, F, G, Flag); /* Compute the right-hand side rs of the pressure equation */ calculate_rs(dt, dx, dy, il, ir, jb, jt, imax, jmax, F, G, RS); /* Perform SOR iterations */ it = 0; res = 1e6; while(it < itermax && res > eps){ sor(omg, dx, dy, dp, il, ir, jb, jt, imax, jmax, rank_l, rank_r, rank_b, rank_t, P, RS, &res, Flag, bufSend, bufRecv); it++; } /* Compute u(n+1) and v(n+1) */ calculate_uv(dt, dx, dy, il, ir, jb, jt, imax, jmax, U, V, F, G, P, Flag); /* Exchange velocity strips */ uv_com(U, V, il, ir, jb, jt, rank_l, rank_r, rank_b, rank_t, bufSend, bufRecv); t = t + dt; n++; /* Generate snapshot for current timestep */ if((int) n % timestepsPerPlotting == 0) { write_vtkFile(output_dirname, myrank, n, xlength, ylength, il, ir, jb, jt, imax, jmax, dx, dy, U, V, P); } /* Print out simulation time and whether the SOR converged */ if(myrank == 0) { /* Print simulation time */ printf("Time: %.4f", t); /* Print runtime */ previousTime = currentTime; clock_gettime(CLOCK_MONOTONIC, ¤tTime); totalTime += (double)currentTime.tv_sec + 1e-9 * currentTime.tv_nsec - (double)previousTime.tv_sec - 1e-9 * previousTime.tv_nsec; printf("\tRuntime: %.3f s (avg runtime/step: %.3f s)", totalTime, totalTime/n); if(res > eps) printf("\tDid not converge (res=%f, eps=%f)", res, eps); printf("\n"); } } /* Close the output folder */ closedir(output_dir); /* Tell user where to find the output */ if(myrank == 0) { printf("Please find the output in the folder \"%s\".\n", problem); } /* Free allocated memory */ free_matrix(U, il-2, ir+1, jb-1, jt+1); free_matrix(V, il-1, ir+1, jb-2, jt+1); free_matrix(P, il-1, ir+1, jb-1, jt+1); free_matrix(F, il-2, ir+1, jb-1, jt+1); free_matrix(G, il-1, ir+1, jb-2, jt+1); free_matrix(RS, il, ir, jb, jt); free_imatrix(Flag, il-1, ir+1, jb-1, jt+1); free(bufSend); free(bufRecv); MPI_Barrier(MPI_COMM_WORLD); MPI_Finalize(); return 0; }
int mdrunner(gmx_hw_opt_t *hw_opt, FILE *fplog, t_commrec *cr, int nfile, const t_filenm fnm[], const output_env_t oenv, gmx_bool bVerbose, gmx_bool bCompact, int nstglobalcomm, ivec ddxyz, int dd_node_order, real rdd, real rconstr, const char *dddlb_opt, real dlb_scale, const char *ddcsx, const char *ddcsy, const char *ddcsz, const char *nbpu_opt, int nstlist_cmdline, gmx_int64_t nsteps_cmdline, int nstepout, int resetstep, int gmx_unused nmultisim, int repl_ex_nst, int repl_ex_nex, int repl_ex_seed, real pforce, real cpt_period, real max_hours, int imdport, unsigned long Flags) { gmx_bool bForceUseGPU, bTryUseGPU, bRerunMD; t_inputrec *inputrec; t_state *state = NULL; matrix box; gmx_ddbox_t ddbox = {0}; int npme_major, npme_minor; t_nrnb *nrnb; gmx_mtop_t *mtop = NULL; t_mdatoms *mdatoms = NULL; t_forcerec *fr = NULL; t_fcdata *fcd = NULL; real ewaldcoeff_q = 0; real ewaldcoeff_lj = 0; struct gmx_pme_t **pmedata = NULL; gmx_vsite_t *vsite = NULL; gmx_constr_t constr; int nChargePerturbed = -1, nTypePerturbed = 0, status; gmx_wallcycle_t wcycle; gmx_bool bReadEkin; gmx_walltime_accounting_t walltime_accounting = NULL; int rc; gmx_int64_t reset_counters; gmx_edsam_t ed = NULL; int nthreads_pme = 1; int nthreads_pp = 1; gmx_membed_t membed = NULL; gmx_hw_info_t *hwinfo = NULL; /* The master rank decides early on bUseGPU and broadcasts this later */ gmx_bool bUseGPU = FALSE; /* CAUTION: threads may be started later on in this function, so cr doesn't reflect the final parallel state right now */ snew(inputrec, 1); snew(mtop, 1); if (Flags & MD_APPENDFILES) { fplog = NULL; } bRerunMD = (Flags & MD_RERUN); bForceUseGPU = (strncmp(nbpu_opt, "gpu", 3) == 0); bTryUseGPU = (strncmp(nbpu_opt, "auto", 4) == 0) || bForceUseGPU; /* Detect hardware, gather information. This is an operation that is * global for this process (MPI rank). */ hwinfo = gmx_detect_hardware(fplog, cr, bTryUseGPU); gmx_print_detected_hardware(fplog, cr, hwinfo); if (fplog != NULL) { /* Print references after all software/hardware printing */ please_cite(fplog, "Abraham2015"); please_cite(fplog, "Pall2015"); please_cite(fplog, "Pronk2013"); please_cite(fplog, "Hess2008b"); please_cite(fplog, "Spoel2005a"); please_cite(fplog, "Lindahl2001a"); please_cite(fplog, "Berendsen95a"); } snew(state, 1); if (SIMMASTER(cr)) { /* Read (nearly) all data required for the simulation */ read_tpx_state(ftp2fn(efTPR, nfile, fnm), inputrec, state, NULL, mtop); if (inputrec->cutoff_scheme == ecutsVERLET) { /* Here the master rank decides if all ranks will use GPUs */ bUseGPU = (hwinfo->gpu_info.n_dev_compatible > 0 || getenv("GMX_EMULATE_GPU") != NULL); /* TODO add GPU kernels for this and replace this check by: * (bUseGPU && (ir->vdwtype == evdwPME && * ir->ljpme_combination_rule == eljpmeLB)) * update the message text and the content of nbnxn_acceleration_supported. */ if (bUseGPU && !nbnxn_gpu_acceleration_supported(fplog, cr, inputrec, bRerunMD)) { /* Fallback message printed by nbnxn_acceleration_supported */ if (bForceUseGPU) { gmx_fatal(FARGS, "GPU acceleration requested, but not supported with the given input settings"); } bUseGPU = FALSE; } prepare_verlet_scheme(fplog, cr, inputrec, nstlist_cmdline, mtop, state->box, bUseGPU); } else { if (nstlist_cmdline > 0) { gmx_fatal(FARGS, "Can not set nstlist with the group cut-off scheme"); } if (hwinfo->gpu_info.n_dev_compatible > 0) { md_print_warn(cr, fplog, "NOTE: GPU(s) found, but the current simulation can not use GPUs\n" " To use a GPU, set the mdp option: cutoff-scheme = Verlet\n"); } if (bForceUseGPU) { gmx_fatal(FARGS, "GPU requested, but can't be used without cutoff-scheme=Verlet"); } #ifdef GMX_TARGET_BGQ md_print_warn(cr, fplog, "NOTE: There is no SIMD implementation of the group scheme kernels on\n" " BlueGene/Q. You will observe better performance from using the\n" " Verlet cut-off scheme.\n"); #endif } if (inputrec->eI == eiSD2) { md_print_warn(cr, fplog, "The stochastic dynamics integrator %s is deprecated, since\n" "it is slower than integrator %s and is slightly less accurate\n" "with constraints. Use the %s integrator.", ei_names[inputrec->eI], ei_names[eiSD1], ei_names[eiSD1]); } } /* Check and update the hardware options for internal consistency */ check_and_update_hw_opt_1(hw_opt, cr); /* Early check for externally set process affinity. */ gmx_check_thread_affinity_set(fplog, cr, hw_opt, hwinfo->nthreads_hw_avail, FALSE); #ifdef GMX_THREAD_MPI if (SIMMASTER(cr)) { if (cr->npmenodes > 0 && hw_opt->nthreads_tmpi <= 0) { gmx_fatal(FARGS, "You need to explicitly specify the number of MPI threads (-ntmpi) when using separate PME ranks"); } /* Since the master knows the cut-off scheme, update hw_opt for this. * This is done later for normal MPI and also once more with tMPI * for all tMPI ranks. */ check_and_update_hw_opt_2(hw_opt, inputrec->cutoff_scheme); /* NOW the threads will be started: */ hw_opt->nthreads_tmpi = get_nthreads_mpi(hwinfo, hw_opt, inputrec, mtop, cr, fplog, bUseGPU); if (hw_opt->nthreads_tmpi > 1) { t_commrec *cr_old = cr; /* now start the threads. */ cr = mdrunner_start_threads(hw_opt, fplog, cr_old, nfile, fnm, oenv, bVerbose, bCompact, nstglobalcomm, ddxyz, dd_node_order, rdd, rconstr, dddlb_opt, dlb_scale, ddcsx, ddcsy, ddcsz, nbpu_opt, nstlist_cmdline, nsteps_cmdline, nstepout, resetstep, nmultisim, repl_ex_nst, repl_ex_nex, repl_ex_seed, pforce, cpt_period, max_hours, Flags); /* the main thread continues here with a new cr. We don't deallocate the old cr because other threads may still be reading it. */ if (cr == NULL) { gmx_comm("Failed to spawn threads"); } } } #endif /* END OF CAUTION: cr is now reliable */ /* g_membed initialisation * * Because we change the mtop, init_membed is called before the init_parallel * * (in case we ever want to make it run in parallel) */ if (opt2bSet("-membed", nfile, fnm)) { if (MASTER(cr)) { fprintf(stderr, "Initializing membed"); } membed = init_membed(fplog, nfile, fnm, mtop, inputrec, state, cr, &cpt_period); } if (PAR(cr)) { /* now broadcast everything to the non-master nodes/threads: */ init_parallel(cr, inputrec, mtop); /* The master rank decided on the use of GPUs, * broadcast this information to all ranks. */ gmx_bcast_sim(sizeof(bUseGPU), &bUseGPU, cr); } if (fplog != NULL) { pr_inputrec(fplog, 0, "Input Parameters", inputrec, FALSE); fprintf(fplog, "\n"); } /* now make sure the state is initialized and propagated */ set_state_entries(state, inputrec); /* A parallel command line option consistency check that we can only do after any threads have started. */ if (!PAR(cr) && (ddxyz[XX] > 1 || ddxyz[YY] > 1 || ddxyz[ZZ] > 1 || cr->npmenodes > 0)) { gmx_fatal(FARGS, "The -dd or -npme option request a parallel simulation, " #ifndef GMX_MPI "but %s was compiled without threads or MPI enabled" #else #ifdef GMX_THREAD_MPI "but the number of threads (option -nt) is 1" #else "but %s was not started through mpirun/mpiexec or only one rank was requested through mpirun/mpiexec" #endif #endif , output_env_get_program_display_name(oenv) ); } if (bRerunMD && (EI_ENERGY_MINIMIZATION(inputrec->eI) || eiNM == inputrec->eI)) { gmx_fatal(FARGS, "The .mdp file specified an energy mininization or normal mode algorithm, and these are not compatible with mdrun -rerun"); } if (can_use_allvsall(inputrec, TRUE, cr, fplog) && DOMAINDECOMP(cr)) { gmx_fatal(FARGS, "All-vs-all loops do not work with domain decomposition, use a single MPI rank"); } if (!(EEL_PME(inputrec->coulombtype) || EVDW_PME(inputrec->vdwtype))) { if (cr->npmenodes > 0) { gmx_fatal_collective(FARGS, cr, NULL, "PME-only ranks are requested, but the system does not use PME for electrostatics or LJ"); } cr->npmenodes = 0; } if (bUseGPU && cr->npmenodes < 0) { /* With GPUs we don't automatically use PME-only ranks. PME ranks can * improve performance with many threads per GPU, since our OpenMP * scaling is bad, but it's difficult to automate the setup. */ cr->npmenodes = 0; } #ifdef GMX_FAHCORE if (MASTER(cr)) { fcRegisterSteps(inputrec->nsteps, inputrec->init_step); } #endif /* NMR restraints must be initialized before load_checkpoint, * since with time averaging the history is added to t_state. * For proper consistency check we therefore need to extend * t_state here. * So the PME-only nodes (if present) will also initialize * the distance restraints. */ snew(fcd, 1); /* This needs to be called before read_checkpoint to extend the state */ init_disres(fplog, mtop, inputrec, cr, fcd, state, repl_ex_nst > 0); init_orires(fplog, mtop, state->x, inputrec, cr, &(fcd->orires), state); if (DEFORM(*inputrec)) { /* Store the deform reference box before reading the checkpoint */ if (SIMMASTER(cr)) { copy_mat(state->box, box); } if (PAR(cr)) { gmx_bcast(sizeof(box), box, cr); } /* Because we do not have the update struct available yet * in which the reference values should be stored, * we store them temporarily in static variables. * This should be thread safe, since they are only written once * and with identical values. */ tMPI_Thread_mutex_lock(&deform_init_box_mutex); deform_init_init_step_tpx = inputrec->init_step; copy_mat(box, deform_init_box_tpx); tMPI_Thread_mutex_unlock(&deform_init_box_mutex); } if (opt2bSet("-cpi", nfile, fnm)) { /* Check if checkpoint file exists before doing continuation. * This way we can use identical input options for the first and subsequent runs... */ if (gmx_fexist_master(opt2fn_master("-cpi", nfile, fnm, cr), cr) ) { load_checkpoint(opt2fn_master("-cpi", nfile, fnm, cr), &fplog, cr, ddxyz, inputrec, state, &bReadEkin, (Flags & MD_APPENDFILES), (Flags & MD_APPENDFILESSET)); if (bReadEkin) { Flags |= MD_READ_EKIN; } } } if (MASTER(cr) && (Flags & MD_APPENDFILES)) { gmx_log_open(ftp2fn(efLOG, nfile, fnm), cr, Flags, &fplog); } /* override nsteps with value from cmdline */ override_nsteps_cmdline(fplog, nsteps_cmdline, inputrec, cr); if (SIMMASTER(cr)) { copy_mat(state->box, box); } if (PAR(cr)) { gmx_bcast(sizeof(box), box, cr); } /* Essential dynamics */ if (opt2bSet("-ei", nfile, fnm)) { /* Open input and output files, allocate space for ED data structure */ ed = ed_open(mtop->natoms, &state->edsamstate, nfile, fnm, Flags, oenv, cr); } if (PAR(cr) && !(EI_TPI(inputrec->eI) || inputrec->eI == eiNM)) { cr->dd = init_domain_decomposition(fplog, cr, Flags, ddxyz, rdd, rconstr, dddlb_opt, dlb_scale, ddcsx, ddcsy, ddcsz, mtop, inputrec, box, state->x, &ddbox, &npme_major, &npme_minor); make_dd_communicators(fplog, cr, dd_node_order); /* Set overallocation to avoid frequent reallocation of arrays */ set_over_alloc_dd(TRUE); } else { /* PME, if used, is done on all nodes with 1D decomposition */ cr->npmenodes = 0; cr->duty = (DUTY_PP | DUTY_PME); npme_major = 1; npme_minor = 1; if (inputrec->ePBC == epbcSCREW) { gmx_fatal(FARGS, "pbc=%s is only implemented with domain decomposition", epbc_names[inputrec->ePBC]); } } if (PAR(cr)) { /* After possible communicator splitting in make_dd_communicators. * we can set up the intra/inter node communication. */ gmx_setup_nodecomm(fplog, cr); } /* Initialize per-physical-node MPI process/thread ID and counters. */ gmx_init_intranode_counters(cr); #ifdef GMX_MPI if (MULTISIM(cr)) { md_print_info(cr, fplog, "This is simulation %d out of %d running as a composite GROMACS\n" "multi-simulation job. Setup for this simulation:\n\n", cr->ms->sim, cr->ms->nsim); } md_print_info(cr, fplog, "Using %d MPI %s\n", cr->nnodes, #ifdef GMX_THREAD_MPI cr->nnodes == 1 ? "thread" : "threads" #else cr->nnodes == 1 ? "process" : "processes" #endif ); fflush(stderr); #endif /* Check and update hw_opt for the cut-off scheme */ check_and_update_hw_opt_2(hw_opt, inputrec->cutoff_scheme); /* Check and update hw_opt for the number of MPI ranks */ check_and_update_hw_opt_3(hw_opt); gmx_omp_nthreads_init(fplog, cr, hwinfo->nthreads_hw_avail, hw_opt->nthreads_omp, hw_opt->nthreads_omp_pme, (cr->duty & DUTY_PP) == 0, inputrec->cutoff_scheme == ecutsVERLET); #ifndef NDEBUG if (integrator[inputrec->eI].func != do_tpi && inputrec->cutoff_scheme == ecutsVERLET) { gmx_feenableexcept(); } #endif if (bUseGPU) { /* Select GPU id's to use */ gmx_select_gpu_ids(fplog, cr, &hwinfo->gpu_info, bForceUseGPU, &hw_opt->gpu_opt); } else { /* Ignore (potentially) manually selected GPUs */ hw_opt->gpu_opt.n_dev_use = 0; } /* check consistency across ranks of things like SIMD * support and number of GPUs selected */ gmx_check_hw_runconf_consistency(fplog, hwinfo, cr, hw_opt, bUseGPU); /* Now that we know the setup is consistent, check for efficiency */ check_resource_division_efficiency(hwinfo, hw_opt, Flags & MD_NTOMPSET, cr, fplog); if (DOMAINDECOMP(cr)) { /* When we share GPUs over ranks, we need to know this for the DLB */ dd_setup_dlb_resource_sharing(cr, hwinfo, hw_opt); } /* getting number of PP/PME threads PME: env variable should be read only on one node to make sure it is identical everywhere; */ /* TODO nthreads_pp is only used for pinning threads. * This is a temporary solution until we have a hw topology library. */ nthreads_pp = gmx_omp_nthreads_get(emntNonbonded); nthreads_pme = gmx_omp_nthreads_get(emntPME); wcycle = wallcycle_init(fplog, resetstep, cr, nthreads_pp, nthreads_pme); if (PAR(cr)) { /* Master synchronizes its value of reset_counters with all nodes * including PME only nodes */ reset_counters = wcycle_get_reset_counters(wcycle); gmx_bcast_sim(sizeof(reset_counters), &reset_counters, cr); wcycle_set_reset_counters(wcycle, reset_counters); } snew(nrnb, 1); if (cr->duty & DUTY_PP) { bcast_state(cr, state); /* Initiate forcerecord */ fr = mk_forcerec(); fr->hwinfo = hwinfo; fr->gpu_opt = &hw_opt->gpu_opt; init_forcerec(fplog, oenv, fr, fcd, inputrec, mtop, cr, box, opt2fn("-table", nfile, fnm), opt2fn("-tabletf", nfile, fnm), opt2fn("-tablep", nfile, fnm), opt2fn("-tableb", nfile, fnm), nbpu_opt, FALSE, pforce); /* version for PCA_NOT_READ_NODE (see md.c) */ /*init_forcerec(fplog,fr,fcd,inputrec,mtop,cr,box,FALSE, "nofile","nofile","nofile","nofile",FALSE,pforce); */ /* Initialize QM-MM */ if (fr->bQMMM) { init_QMMMrec(cr, mtop, inputrec, fr); } /* Initialize the mdatoms structure. * mdatoms is not filled with atom data, * as this can not be done now with domain decomposition. */ mdatoms = init_mdatoms(fplog, mtop, inputrec->efep != efepNO); /* Initialize the virtual site communication */ vsite = init_vsite(mtop, cr, FALSE); calc_shifts(box, fr->shift_vec); /* With periodic molecules the charge groups should be whole at start up * and the virtual sites should not be far from their proper positions. */ if (!inputrec->bContinuation && MASTER(cr) && !(inputrec->ePBC != epbcNONE && inputrec->bPeriodicMols)) { /* Make molecules whole at start of run */ if (fr->ePBC != epbcNONE) { do_pbc_first_mtop(fplog, inputrec->ePBC, box, mtop, state->x); } if (vsite) { /* Correct initial vsite positions are required * for the initial distribution in the domain decomposition * and for the initial shell prediction. */ construct_vsites_mtop(vsite, mtop, state->x); } } if (EEL_PME(fr->eeltype) || EVDW_PME(fr->vdwtype)) { ewaldcoeff_q = fr->ewaldcoeff_q; ewaldcoeff_lj = fr->ewaldcoeff_lj; pmedata = &fr->pmedata; } else { pmedata = NULL; } } else { /* This is a PME only node */ /* We don't need the state */ done_state(state); ewaldcoeff_q = calc_ewaldcoeff_q(inputrec->rcoulomb, inputrec->ewald_rtol); ewaldcoeff_lj = calc_ewaldcoeff_lj(inputrec->rvdw, inputrec->ewald_rtol_lj); snew(pmedata, 1); } if (hw_opt->thread_affinity != threadaffOFF) { /* Before setting affinity, check whether the affinity has changed * - which indicates that probably the OpenMP library has changed it * since we first checked). */ gmx_check_thread_affinity_set(fplog, cr, hw_opt, hwinfo->nthreads_hw_avail, TRUE); /* Set the CPU affinity */ gmx_set_thread_affinity(fplog, cr, hw_opt, hwinfo); } /* Initiate PME if necessary, * either on all nodes or on dedicated PME nodes only. */ if (EEL_PME(inputrec->coulombtype) || EVDW_PME(inputrec->vdwtype)) { if (mdatoms) { nChargePerturbed = mdatoms->nChargePerturbed; if (EVDW_PME(inputrec->vdwtype)) { nTypePerturbed = mdatoms->nTypePerturbed; } } if (cr->npmenodes > 0) { /* The PME only nodes need to know nChargePerturbed(FEP on Q) and nTypePerturbed(FEP on LJ)*/ gmx_bcast_sim(sizeof(nChargePerturbed), &nChargePerturbed, cr); gmx_bcast_sim(sizeof(nTypePerturbed), &nTypePerturbed, cr); } if (cr->duty & DUTY_PME) { status = gmx_pme_init(pmedata, cr, npme_major, npme_minor, inputrec, mtop ? mtop->natoms : 0, nChargePerturbed, nTypePerturbed, (Flags & MD_REPRODUCIBLE), nthreads_pme); if (status != 0) { gmx_fatal(FARGS, "Error %d initializing PME", status); } } } if (integrator[inputrec->eI].func == do_md) { /* Turn on signal handling on all nodes */ /* * (A user signal from the PME nodes (if any) * is communicated to the PP nodes. */ signal_handler_install(); } if (cr->duty & DUTY_PP) { /* Assumes uniform use of the number of OpenMP threads */ walltime_accounting = walltime_accounting_init(gmx_omp_nthreads_get(emntDefault)); if (inputrec->bPull) { /* Initialize pull code */ inputrec->pull_work = init_pull(fplog, inputrec->pull, inputrec, nfile, fnm, mtop, cr, oenv, inputrec->fepvals->init_lambda, EI_DYNAMICS(inputrec->eI) && MASTER(cr), Flags); } if (inputrec->bRot) { /* Initialize enforced rotation code */ init_rot(fplog, inputrec, nfile, fnm, cr, state->x, box, mtop, oenv, bVerbose, Flags); } if (inputrec->eSwapCoords != eswapNO) { /* Initialize ion swapping code */ init_swapcoords(fplog, bVerbose, inputrec, opt2fn_master("-swap", nfile, fnm, cr), mtop, state->x, state->box, &state->swapstate, cr, oenv, Flags); } constr = init_constraints(fplog, mtop, inputrec, ed, state, cr); if (DOMAINDECOMP(cr)) { GMX_RELEASE_ASSERT(fr, "fr was NULL while cr->duty was DUTY_PP"); dd_init_bondeds(fplog, cr->dd, mtop, vsite, inputrec, Flags & MD_DDBONDCHECK, fr->cginfo_mb); set_dd_parameters(fplog, cr->dd, dlb_scale, inputrec, &ddbox); setup_dd_grid(fplog, cr->dd); } /* Now do whatever the user wants us to do (how flexible...) */ integrator[inputrec->eI].func(fplog, cr, nfile, fnm, oenv, bVerbose, bCompact, nstglobalcomm, vsite, constr, nstepout, inputrec, mtop, fcd, state, mdatoms, nrnb, wcycle, ed, fr, repl_ex_nst, repl_ex_nex, repl_ex_seed, membed, cpt_period, max_hours, imdport, Flags, walltime_accounting); if (inputrec->bPull) { finish_pull(inputrec->pull_work); } if (inputrec->bRot) { finish_rot(inputrec->rot); } } else { GMX_RELEASE_ASSERT(pmedata, "pmedata was NULL while cr->duty was not DUTY_PP"); /* do PME only */ walltime_accounting = walltime_accounting_init(gmx_omp_nthreads_get(emntPME)); gmx_pmeonly(*pmedata, cr, nrnb, wcycle, walltime_accounting, ewaldcoeff_q, ewaldcoeff_lj, inputrec); } wallcycle_stop(wcycle, ewcRUN); /* Finish up, write some stuff * if rerunMD, don't write last frame again */ finish_run(fplog, cr, inputrec, nrnb, wcycle, walltime_accounting, fr ? fr->nbv : NULL, EI_DYNAMICS(inputrec->eI) && !MULTISIM(cr)); /* Free GPU memory and context */ free_gpu_resources(fr, cr, &hwinfo->gpu_info, fr ? fr->gpu_opt : NULL); if (opt2bSet("-membed", nfile, fnm)) { sfree(membed); } gmx_hardware_info_free(hwinfo); /* Does what it says */ print_date_and_time(fplog, cr->nodeid, "Finished mdrun", gmx_gettime()); walltime_accounting_destroy(walltime_accounting); /* PLUMED */ if(plumedswitch){ plumed_finalize(plumedmain); } /* END PLUMED */ /* Close logfile already here if we were appending to it */ if (MASTER(cr) && (Flags & MD_APPENDFILES)) { gmx_log_close(fplog); } rc = (int)gmx_get_stop_condition(); done_ed(&ed); #ifdef GMX_THREAD_MPI /* we need to join all threads. The sub-threads join when they exit this function, but the master thread needs to be told to wait for that. */ if (PAR(cr) && MASTER(cr)) { tMPI_Finalize(); } #endif return rc; }
int init_data(void) //returns code of error { int error=0; int i,k,l,tmpr; int rank1=rank; char fstr[256], pos; float tmpd; char tmpc; double Re1; // priority for parameter in snap-file FILE *inp; pos = strcspn(NameInitFile,"*"); if(pos<strlen(NameInitFile)) { NameInitFile[pos]=0; sprintf(fstr,"%s%d%s",NameInitFile,rank,NameInitFile+pos+1); inp = fileopen(fstr,-1); rank1 = 0; } else inp = fileopen(NameInitFile,-1); read_tilleq(inp,'=','n'); if(fscanf(inp,"%lf",&t_cur)==0) error=1; read_tilleq(inp,'=','n'); if(fscanf(inp,"%ld",&count)==0) error=1; read_tilleq(inp,'=','n'); if(fscanf(inp,"%c%d%c%d%c",&tmpc,&pp[0],&tmpc,&pp[2],&tmpc)<5) error=1; //no need unless process distribution is written if(pp[0]*pp[2]!=size) nrerror("Wrong number of processors in data file. Can't read data.",-1,-1); read_tilleq(inp,'=','n'); if(fscanf(inp,"%d",&N1)==0) error=1; read_tilleq(inp,'=','n'); if(fscanf(inp,"%d",&N3)==0) error=1; read_tilleq(inp,'=','n'); if(fscanf(inp,"%lf",&Re1)==0) error=1; init_parallel(); operate_memory(1); // creating arrays for(tmpr=0;tmpr<=rank1;tmpr++) //reading until arrays of this process { for(l=0;l<nvar;l++) // reading f { do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); for(i=0;i<m1;i++) { do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); for(k=0;k<m3;k++) { if(fscanf(inp,"%g",&tmpd)==0) error=2; fscanf(inp,"%c",&tmpc); f[l][i][k]=tmpd; } fscanf(inp,"%c",&tmpc); } fscanf(inp,"%c",&tmpc); } // смысла нет do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); //reading nut for(i=0;i<m1;i++) { do fscanf(inp,"%c",&tmpc); while (tmpc!='{'); for(k=0;k<m3;k++) { if(fscanf(inp,"%g",&tmpd)==0) error=3; fscanf(inp,"%c",&tmpc); nut[i][k]=tmpd; } fscanf(inp,"%c",&tmpc); } fscanf(inp,"%c",&tmpc); } fileclose(inp); if(error) nrerror("Data couldn't have been read from file!!!",-1,error); else nmessage("Data has been read from file",t_cur,count); return(error); }