#include <cmath>
#include <cstring>
+#include "gromacs/domdec/dlbtiming.h"
#include "gromacs/domdec/domdec.h"
#include "gromacs/domdec/domdec_struct.h"
#include "gromacs/ewald/ewald.h"
}
}
-void do_force_lowlevel(t_forcerec *fr,
- const t_inputrec *ir,
- const t_idef *idef,
- const t_commrec *cr,
- const gmx_multisim_t *ms,
- t_nrnb *nrnb,
- gmx_wallcycle_t wcycle,
- const t_mdatoms *md,
- rvec x[],
- history_t *hist,
- rvec *forceForUseWithShiftForces,
- gmx::ForceWithVirial *forceWithVirial,
- gmx_enerdata_t *enerd,
- t_fcdata *fcd,
- matrix box,
- t_lambda *fepvals,
- real *lambda,
- const t_graph *graph,
- const t_blocka *excl,
- rvec mu_tot[],
- int flags,
- float *cycles_pme)
+void do_force_lowlevel(t_forcerec *fr,
+ const t_inputrec *ir,
+ const t_idef *idef,
+ const t_commrec *cr,
+ const gmx_multisim_t *ms,
+ t_nrnb *nrnb,
+ gmx_wallcycle_t wcycle,
+ const t_mdatoms *md,
+ rvec x[],
+ history_t *hist,
+ rvec *forceForUseWithShiftForces,
+ gmx::ForceWithVirial *forceWithVirial,
+ gmx_enerdata_t *enerd,
+ t_fcdata *fcd,
+ matrix box,
+ t_lambda *fepvals,
+ real *lambda,
+ const t_graph *graph,
+ const t_blocka *excl,
+ rvec mu_tot[],
+ int flags,
+ float *cycles_pme,
+ const DDBalanceRegionHandler &ddBalanceRegionHandler)
{
int i, j;
int donb_flags;
* balancing region here, because PME does global
* communication that acts as a global barrier.
*/
- if (DOMAINDECOMP(cr))
- {
- ddCloseBalanceRegionCpu(cr->dd);
- }
+ ddBalanceRegionHandler.closeAfterForceComputationCpu();
wallcycle_start(wcycle, ewcPMEMESH);
status = gmx_pme_do(fr->pmedata,
enerpart_lambda += dlam*enerd->term[F_DVDL_CONSTR];
}
- if (j == efptMASS)
+ if (j == efptMASS && !fepvals->separate_dvdl[j])
{
enerpart_lambda += dlam*enerd->term[F_DKDL];
}
double t,
gmx_edsam *ed,
const int flags,
- DdOpenBalanceRegionBeforeForceComputation ddOpenBalanceRegion,
- DdCloseBalanceRegionAfterForceComputation ddCloseBalanceRegion)
+ const DDBalanceRegionHandler &ddBalanceRegionHandler)
{
int cg1, i, j;
double mu[2*DIM];
* somewhere early inside the step after communication during domain
* decomposition (and not during the previous step as usual).
*/
- if (bNS &&
- ddOpenBalanceRegion == DdOpenBalanceRegionBeforeForceComputation::yes)
+ if (bNS)
{
- ddOpenBalanceRegionCpu(cr->dd, DdAllowBalanceRegionReopen::yes);
+ ddBalanceRegionHandler.openBeforeForceComputationCpu(DdAllowBalanceRegionReopen::yes);
}
cycles_wait_gpu = 0;
if (bUseGPU)
{
- if (DOMAINDECOMP(cr))
- {
- ddOpenBalanceRegionGpu(cr->dd);
- }
+ ddBalanceRegionHandler.openBeforeForceComputationGpu();
wallcycle_start(wcycle, ewcLAUNCH_GPU);
}
/* launch local nonbonded work on GPU */
- wallcycle_sub_start(wcycle, ewcsLAUNCH_GPU_NONBONDED);
+ wallcycle_sub_start_nocount(wcycle, ewcsLAUNCH_GPU_NONBONDED);
do_nb_verlet(fr, ic, enerd, flags, Nbnxm::InteractionLocality::Local, enbvClearFNo,
step, nrnb, wcycle);
wallcycle_sub_stop(wcycle, ewcsLAUNCH_GPU_NONBONDED);
wallcycle_start(wcycle, ewcLAUNCH_GPU);
/* launch non-local nonbonded tasks on GPU */
- wallcycle_sub_start(wcycle, ewcsLAUNCH_GPU_NONBONDED);
+ wallcycle_sub_start_nocount(wcycle, ewcsLAUNCH_GPU_NONBONDED);
Nbnxm::gpu_copy_xq_to_gpu(nbv->gpu_nbv, nbv->nbat, Nbnxm::AtomLocality::NonLocal, ppForceWorkload->haveGpuBondedWork);
wallcycle_sub_stop(wcycle, ewcsLAUNCH_GPU_NONBONDED);
if (PAR(cr))
{
gmx_sumd(2*DIM, mu, cr);
- ddReopenBalanceRegionCpu(cr->dd);
+
+ ddBalanceRegionHandler.reopenRegionCpu();
}
for (i = 0; i < 2; i++)
cr, ms, nrnb, wcycle, mdatoms,
as_rvec_array(x.unpaddedArrayRef().data()), hist, f, &forceWithVirial, enerd, fcd,
box, inputrec->fepvals, lambda, graph, &(top->excls), fr->mu_tot,
- flags, &cycles_pme);
+ flags,
+ &cycles_pme, ddBalanceRegionHandler);
wallcycle_stop(wcycle, ewcFORCE);
* If we use a GPU this will overlap with GPU work, so in that case
* we do not close the DD force balancing region here.
*/
- if (ddCloseBalanceRegion == DdCloseBalanceRegionAfterForceComputation::yes)
- {
- ddCloseBalanceRegionCpu(cr->dd);
- }
+ ddBalanceRegionHandler.closeAfterForceComputationCpu();
+
if (bDoForces)
{
dd_move_f(cr->dd, force.unpaddedArrayRef(), fr->fshift, wcycle);
fr->fshift);
float cycles_tmp = wallcycle_stop(wcycle, ewcWAIT_GPU_NB_L);
- if (ddCloseBalanceRegion == DdCloseBalanceRegionAfterForceComputation::yes)
+ if (ddBalanceRegionHandler.useBalancingRegion())
{
DdBalanceRegionWaitedForGpu waitedForGpu = DdBalanceRegionWaitedForGpu::yes;
if (bDoForces && cycles_tmp <= gpuWaitApiOverheadMargin)
*/
waitedForGpu = DdBalanceRegionWaitedForGpu::no;
}
- ddCloseBalanceRegionGpu(cr->dd, cycles_wait_gpu, waitedForGpu);
+ ddBalanceRegionHandler.closeAfterForceComputationGpu(cycles_wait_gpu, waitedForGpu);
}
}
double t,
gmx_edsam *ed,
int flags,
- DdOpenBalanceRegionBeforeForceComputation ddOpenBalanceRegion,
- DdCloseBalanceRegionAfterForceComputation ddCloseBalanceRegion)
+ const DDBalanceRegionHandler &ddBalanceRegionHandler)
{
int cg0, cg1, i, j;
double mu[2*DIM];
dd_move_x(cr->dd, box, x.unpaddedArrayRef(), wcycle);
/* No GPU support, no move_x overlap, so reopen the balance region here */
- if (ddOpenBalanceRegion == DdOpenBalanceRegionBeforeForceComputation::yes)
- {
- ddReopenBalanceRegionCpu(cr->dd);
- }
+ ddBalanceRegionHandler.reopenRegionCpu();
}
if (inputrecNeedMutot(inputrec))
if (PAR(cr))
{
gmx_sumd(2*DIM, mu, cr);
- ddReopenBalanceRegionCpu(cr->dd);
+
+ ddBalanceRegionHandler.reopenRegionCpu();
}
for (i = 0; i < 2; i++)
{
box, inputrec->fepvals, lambda,
graph, &(top->excls), fr->mu_tot,
flags,
- &cycles_pme);
+ &cycles_pme, ddBalanceRegionHandler);
wallcycle_stop(wcycle, ewcFORCE);
{
dd_force_flop_stop(cr->dd, nrnb);
- if (ddCloseBalanceRegion == DdCloseBalanceRegionAfterForceComputation::yes)
- {
- ddCloseBalanceRegionCpu(cr->dd);
- }
+ ddBalanceRegionHandler.closeAfterForceComputationCpu();
}
computeSpecialForces(fplog, cr, inputrec, awh, enforcedRotation,
double t,
gmx_edsam *ed,
int flags,
- DdOpenBalanceRegionBeforeForceComputation ddOpenBalanceRegion,
- DdCloseBalanceRegionAfterForceComputation ddCloseBalanceRegion)
+ const DDBalanceRegionHandler &ddBalanceRegionHandler)
{
/* modify force flag if not doing nonbonded */
if (!fr->bNonbonded)
vsite, mu_tot,
t, ed,
flags,
- ddOpenBalanceRegion,
- ddCloseBalanceRegion);
+ ddBalanceRegionHandler);
break;
case ecutsGROUP:
do_force_cutsGROUP(fplog, cr, ms, inputrec,
fr, vsite, mu_tot,
t, ed,
flags,
- ddOpenBalanceRegion,
- ddCloseBalanceRegion);
+ ddBalanceRegionHandler);
break;
default:
gmx_incons("Invalid cut-off scheme passed!");
* virial calculation and COM pulling, is not thus not included in
* the balance timing, which is ok as most tasks do communication.
*/
- if (ddOpenBalanceRegion == DdOpenBalanceRegionBeforeForceComputation::yes)
- {
- ddOpenBalanceRegionCpu(cr->dd, DdAllowBalanceRegionReopen::no);
- }
+ ddBalanceRegionHandler.openBeforeForceComputationCpu(DdAllowBalanceRegionReopen::no);
}
#include "gromacs/awh/awh.h"
#include "gromacs/commandline/filenm.h"
#include "gromacs/domdec/collect.h"
+#include "gromacs/domdec/dlbtiming.h"
#include "gromacs/domdec/domdec.h"
#include "gromacs/domdec/domdec_network.h"
#include "gromacs/domdec/domdec_struct.h"
"be available in a different form in a future version of GROMACS, "
"e.g. gmx rerun -f.");
+ if (ir->efep != efepNO && (mdAtoms->mdatoms()->nMassPerturbed > 0 ||
+ (constr && constr->havePerturbedConstraints())))
+ {
+ gmx_fatal(FARGS, "Perturbed masses or constraints are not supported by rerun. "
+ "Either make a .tpr without mass and constraint perturbation, "
+ "or use GROMACS 2018.4, 2018.5 or later 2018 version.");
+ }
if (ir->bExpanded)
{
gmx_fatal(FARGS, "Expanded ensemble not supported by rerun.");
// we don't do counter resetting in rerun - finish will always be valid
walltime_accounting_set_valid_finish(walltime_accounting);
- DdOpenBalanceRegionBeforeForceComputation ddOpenBalanceRegion = (DOMAINDECOMP(cr) ? DdOpenBalanceRegionBeforeForceComputation::yes : DdOpenBalanceRegionBeforeForceComputation::no);
- DdCloseBalanceRegionAfterForceComputation ddCloseBalanceRegion = (DOMAINDECOMP(cr) ? DdCloseBalanceRegionAfterForceComputation::yes : DdCloseBalanceRegionAfterForceComputation::no);
+ const DDBalanceRegionHandler ddBalanceRegionHandler(cr);
step = ir->init_step;
step_rel = 0;
nrnb, wcycle, graph, groups,
shellfc, fr, ppForceWorkload, t, mu_tot,
vsite,
- ddOpenBalanceRegion, ddCloseBalanceRegion);
+ ddBalanceRegionHandler);
}
else
{
state->lambda, graph,
fr, ppForceWorkload, vsite, mu_tot, t, ed,
GMX_FORCE_NS | force_flags,
- ddOpenBalanceRegion, ddCloseBalanceRegion);
+ ddBalanceRegionHandler);
}
/* Now we have the energies and forces corresponding to the
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff