comm->zones.size[0].bb_x0,
comm->zones.size[0].bb_x1,
comm->updateGroupsCog.get(),
- 0, dd->ncg_home,
+ { 0, dd->ncg_home },
comm->zones.dens_zone0,
fr->cginfo,
state_local->x,
wallcycle_sub_start(wcycle, ewcsNBS_GRID_LOCAL);
nbnxn_put_on_grid(nbv, box,
0, vzero, box_diag,
- nullptr, 0, mdatoms->homenr, -1,
+ nullptr, { 0, mdatoms->homenr }, -1,
fr->cginfo, x.unpaddedArrayRef(),
0, nullptr);
wallcycle_sub_stop(wcycle, ewcsNBS_GRID_LOCAL);
rvec boxDiagonal = { box[XX][XX], box[YY][YY], box[ZZ][ZZ] };
nbnxn_put_on_grid(fr->nbv.get(), box,
0, vzero, boxDiagonal,
- nullptr, 0, a_tp0, -1,
+ nullptr, { 0, a_tp0 }, -1,
fr->cginfo, x,
0, nullptr);
/* Put the inserted molecule on it's own search grid */
nbnxn_put_on_grid(fr->nbv.get(), box,
1, x_init, x_init,
- nullptr, a_tp0, a_tp1, -1,
+ nullptr, { a_tp0, a_tp1 }, -1,
fr->cginfo, x,
0, nullptr);
nbnxn_put_on_grid(nbv.get(),
system.box, 0, lowerCorner, upperCorner,
- nullptr, 0, system.coordinates.size(), atomDensity,
+ nullptr, { 0, int(system.coordinates.size()) }, atomDensity,
atomInfo, system.coordinates,
0, nullptr);
}
}
-void Grid::sortColumnsCpuGeometry(GridSetData *gridSetData,
- int dd_zone,
- int atomStart, int atomEnd,
- const int *atinfo,
+void Grid::sortColumnsCpuGeometry(GridSetData *gridSetData,
+ int dd_zone,
+ const int *atinfo,
gmx::ArrayRef<const gmx::RVec> x,
- nbnxn_atomdata_t *nbat,
- int cxy_start, int cxy_end,
- gmx::ArrayRef<int> sort_work)
+ nbnxn_atomdata_t *nbat,
+ const gmx::Range<int> columnRange,
+ gmx::ArrayRef<int> sort_work)
{
if (debug)
{
- fprintf(debug, "cell_offset %d sorting columns %d - %d, atoms %d - %d\n",
- cellOffset_, cxy_start, cxy_end, atomStart, atomEnd);
+ fprintf(debug, "cell_offset %d sorting columns %d - %d\n",
+ cellOffset_, *columnRange.begin(), *columnRange.end());
}
const bool relevantAtomsAreWithinGridBounds = (dimensions_.maxAtomGroupRadius == 0);
const int numAtomsPerCell = geometry_.numAtomsPerCell;
/* Sort the atoms within each x,y column in 3 dimensions */
- for (int cxy = cxy_start; cxy < cxy_end; cxy++)
+ for (int cxy : columnRange)
{
const int numAtoms = numAtomsInColumn(cxy);
const int numCellsZ = cxy_ind_[cxy + 1] - cxy_ind_[cxy];
}
/* Spatially sort the atoms within one grid column */
-void Grid::sortColumnsGpuGeometry(GridSetData *gridSetData,
- int dd_zone,
- int atomStart, int atomEnd,
- const int *atinfo,
+void Grid::sortColumnsGpuGeometry(GridSetData *gridSetData,
+ int dd_zone,
+ const int *atinfo,
gmx::ArrayRef<const gmx::RVec> x,
- nbnxn_atomdata_t *nbat,
- int cxy_start, int cxy_end,
- gmx::ArrayRef<int> sort_work)
+ nbnxn_atomdata_t *nbat,
+ const gmx::Range<int> columnRange,
+ gmx::ArrayRef<int> sort_work)
{
BoundingBox bb_work_array[2];
BoundingBox *bb_work_aligned = reinterpret_cast<BoundingBox *>((reinterpret_cast<std::size_t>(bb_work_array + 1)) & (~(static_cast<std::size_t>(15))));
if (debug)
{
- fprintf(debug, "cell_offset %d sorting columns %d - %d, atoms %d - %d\n",
- cellOffset_, cxy_start, cxy_end, atomStart, atomEnd);
+ fprintf(debug, "cell_offset %d sorting columns %d - %d\n",
+ cellOffset_, *columnRange.begin(), *columnRange.end());
}
const bool relevantAtomsAreWithinGridBounds = (dimensions_.maxAtomGroupRadius == 0);
/* Sort the atoms within each x,y column in 3 dimensions.
* Loop over all columns on the x/y grid.
*/
- for (int cxy = cxy_start; cxy < cxy_end; cxy++)
+ for (int cxy : columnRange)
{
const int gridX = cxy/dimensions_.numCells[YY];
const int gridY = cxy - gridX*dimensions_.numCells[YY];
void Grid::calcColumnIndices(const Grid::Dimensions &gridDims,
const gmx::UpdateGroupsCog *updateGroupsCog,
- const int atomStart,
- const int atomEnd,
+ const gmx::Range<int> atomRange,
gmx::ArrayRef<const gmx::RVec> x,
const int dd_zone,
const int *move,
cxy_na[i] = 0;
}
- int taskAtomStart = atomStart + static_cast<int>((thread + 0)*(atomEnd - atomStart))/nthread;
- int taskAtomEnd = atomStart + static_cast<int>((thread + 1)*(atomEnd - atomStart))/nthread;
+ int taskAtomStart = *atomRange.begin() + static_cast<int>((thread + 0)*atomRange.size())/nthread;
+ int taskAtomEnd = *atomRange.begin() + static_cast<int>((thread + 1)*atomRange.size())/nthread;
if (dd_zone == 0)
{
int cellOffset,
GridSetData *gridSetData,
gmx::ArrayRef<GridWork> gridWork,
- int atomStart,
- int atomEnd,
+ const gmx::Range<int> atomRange,
const int *atinfo,
gmx::ArrayRef<const gmx::RVec> x,
const int numAtomsMoved,
{
cellOffset_ = cellOffset;
- srcAtomBegin_ = atomStart;
- srcAtomEnd_ = atomEnd;
+ srcAtomBegin_ = *atomRange.begin();
+ srcAtomEnd_ = *atomRange.end();
const int nthread = gmx_omp_nthreads_get(emntPairsearch);
*/
gmx::ArrayRef<int> cells = gridSetData->cells;
gmx::ArrayRef<int> atomIndices = gridSetData->atomIndices;
- for (int i = atomStart; i < atomEnd; i++)
+ for (int i : atomRange)
{
/* At this point nbs->cell contains the local grid x,y indices */
const int cxy = cells[i];
{
try
{
- int columnStart = ((thread + 0)*numColumns())/nthread;
- int columnEnd = ((thread + 1)*numColumns())/nthread;
+ gmx::Range<int> columnRange(((thread + 0)*numColumns())/nthread,
+ ((thread + 1)*numColumns())/nthread);
if (geometry_.isSimple)
{
sortColumnsCpuGeometry(gridSetData, ddZone,
- atomStart, atomEnd, atinfo, x, nbat,
- columnStart, columnEnd,
+ atinfo, x, nbat,
+ columnRange,
gridWork[thread].sortBuffer);
}
else
{
sortColumnsGpuGeometry(gridSetData, ddZone,
- atomStart, atomEnd, atinfo, x, nbat,
- columnStart, columnEnd,
+ atinfo, x, nbat,
+ columnRange,
gridWork[thread].sortBuffer);
}
}
{
fprintf(debug, "ns non-zero sub-cells: %d average atoms %.2f\n",
numClustersTotal_,
- (atomEnd - atomStart)/static_cast<double>(numClustersTotal_));
+ atomRange.size()/static_cast<double>(numClustersTotal_));
print_bbsizes_supersub(debug, *this);
}
#include "gromacs/math/vectypes.h"
#include "gromacs/utility/alignedallocator.h"
#include "gromacs/utility/arrayref.h"
+#include "gromacs/utility/range.h"
struct gmx_domdec_zones_t;
struct nbnxn_atomdata_t;
int cellOffset,
GridSetData *gridSetData,
gmx::ArrayRef<GridWork> gridWork,
- int atomStart,
- int atomEnd,
+ gmx::Range<int> atomRange,
const int *atinfo,
gmx::ArrayRef<const gmx::RVec> x,
int numAtomsMoved,
//! Determine in which grid columns atoms should go, store cells and atom counts in \p cell and \p cxy_na
static void calcColumnIndices(const Grid::Dimensions &gridDims,
const gmx::UpdateGroupsCog *updateGroupsCog,
- int atomStart,
- int atomEnd,
+ gmx::Range<int> atomRange,
gmx::ArrayRef<const gmx::RVec> x,
int dd_zone,
const int *move,
gmx::ArrayRef<const gmx::RVec> x,
BoundingBox gmx_unused *bb_work_aligned);
- //! Spatially sort the atoms within one grid column
- void sortColumnsCpuGeometry(GridSetData *gridSetData,
- int dd_zone,
- int atomStart, int atomEnd,
- const int *atinfo,
+ //! Spatially sort the atoms within the given column range, for CPU geometry
+ void sortColumnsCpuGeometry(GridSetData *gridSetData,
+ int dd_zone,
+ const int *atinfo,
gmx::ArrayRef<const gmx::RVec> x,
- nbnxn_atomdata_t *nbat,
- int cxy_start, int cxy_end,
- gmx::ArrayRef<int> sort_work);
-
- //! Spatially sort the atoms within one grid column
- void sortColumnsGpuGeometry(GridSetData *gridSetData,
- int dd_zone,
- int atomStart, int atomEnd,
- const int *atinfo,
+ nbnxn_atomdata_t *nbat,
+ gmx::Range<int> columnRange,
+ gmx::ArrayRef<int> sort_work);
+
+ //! Spatially sort the atoms within the given column range, for GPU geometry
+ void sortColumnsGpuGeometry(GridSetData *gridSetData,
+ int dd_zone,
+ const int *atinfo,
gmx::ArrayRef<const gmx::RVec> x,
- nbnxn_atomdata_t *nbat,
- int cxy_start, int cxy_end,
- gmx::ArrayRef<int> sort_work);
+ nbnxn_atomdata_t *nbat,
+ gmx::Range<int> columnRange,
+ gmx::ArrayRef<int> sort_work);
/* Data members */
//! The geometry of the grid clusters and cells
const rvec lowerCorner,
const rvec upperCorner,
const gmx::UpdateGroupsCog *updateGroupsCog,
- const int atomStart,
- const int atomEnd,
+ const gmx::Range<int> atomRange,
real atomDensity,
gmx::ArrayRef<const int> atomInfo,
gmx::ArrayRef<const gmx::RVec> x,
cellOffset = previousGrid.atomIndexEnd()/previousGrid.geometry().numAtomsPerCell;
}
- const int n = atomEnd - atomStart;
+ const int n = atomRange.size();
real maxAtomGroupRadius;
if (gridIndex == 0)
{
copy_mat(box, box_);
- numRealAtomsLocal_ = atomEnd - numAtomsMoved;
+ numRealAtomsLocal_ = *atomRange.end() - numAtomsMoved;
/* We assume that nbnxn_put_on_grid is called first
* for the local atoms (gridIndex=0).
*/
- numRealAtomsTotal_ = atomEnd - numAtomsMoved;
+ numRealAtomsTotal_ = *atomRange.end() - numAtomsMoved;
maxAtomGroupRadius = (updateGroupsCog ? updateGroupsCog->maxUpdateGroupRadius() : 0);
atomDensity = dimsGrid0.atomDensity;
maxAtomGroupRadius = dimsGrid0.maxAtomGroupRadius;
- numRealAtomsTotal_ = std::max(numRealAtomsTotal_, atomEnd);
+ numRealAtomsTotal_ = std::max(numRealAtomsTotal_, *atomRange.end());
}
/* We always use the home zone (grid[0]) for setting the cell size,
}
/* Make space for the new cell indices */
- gridSetData_.cells.resize(atomEnd);
+ gridSetData_.cells.resize(*atomRange.end());
const int nthread = gmx_omp_nthreads_get(emntPairsearch);
GMX_ASSERT(nthread > 0, "We expect the OpenMP thread count to be set");
{
Grid::calcColumnIndices(grid.dimensions(),
updateGroupsCog,
- atomStart, atomEnd, x,
+ atomRange, x,
ddZone, move, thread, nthread,
gridSetData_.cells,
gridWork_[thread].numAtomsPerColumn);
/* Copy the already computed cell indices to the grid and sort, when needed */
grid.setCellIndices(ddZone, cellOffset, &gridSetData_, gridWork_,
- atomStart, atomEnd, atomInfo.data(), x, numAtomsMoved, nbat);
+ atomRange, atomInfo.data(), x, numAtomsMoved, nbat);
if (gridIndex == 0)
{
#include "gromacs/math/vectypes.h"
#include "gromacs/utility/alignedallocator.h"
#include "gromacs/utility/arrayref.h"
+#include "gromacs/utility/range.h"
#include "grid.h"
#include "gridsetdata.h"
const rvec lowerCorner,
const rvec upperCorner,
const gmx::UpdateGroupsCog *updateGroupsCog,
- int atomStart,
- int atomEnd,
+ gmx::Range<int> atomRange,
real atomDensity,
gmx::ArrayRef<const int> atomInfo,
gmx::ArrayRef<const gmx::RVec> x,
const rvec lowerCorner,
const rvec upperCorner,
const gmx::UpdateGroupsCog *updateGroupsCog,
- int atomStart,
- int atomEnd,
+ gmx::Range<int> atomRange,
real atomDensity,
gmx::ArrayRef<const int> atomInfo,
gmx::ArrayRef<const gmx::RVec> x,
const int *move)
{
nb_verlet->pairSearch_->putOnGrid(box, gridIndex, lowerCorner, upperCorner,
- updateGroupsCog, atomStart, atomEnd, atomDensity,
+ updateGroupsCog, atomRange, atomDensity,
atomInfo, x, numAtomsMoved, move,
nb_verlet->nbat.get());
}
nbnxn_put_on_grid(nbv, nullptr,
zone, c0, c1,
nullptr,
- zones->cg_range[zone],
- zones->cg_range[zone+1],
+ { zones->cg_range[zone], zones->cg_range[zone+1] },
-1,
atomInfo,
x,
#include "gromacs/math/vectypes.h"
#include "gromacs/utility/arrayref.h"
#include "gromacs/utility/enumerationhelpers.h"
+#include "gromacs/utility/range.h"
#include "gromacs/utility/real.h"
#include "locality.h"
/*! \brief Put the atoms on the pair search grid.
*
- * Only atoms atomStart to atomEnd in x are put on the grid.
+ * Only atoms with indices wihtin \p atomRange in x are put on the grid.
* When \p updateGroupsCog != nullptr, atoms are put on the grid
* based on the center of geometry of the group they belong to.
* Atoms or COGs of groups should be within the bounding box provided,
* \param[in] lowerCorner Atom groups to be gridded should have coordinates >= this corner
* \param[in] upperCorner Atom groups to be gridded should have coordinates <= this corner
* \param[in] updateGroupsCog Centers of geometry for update groups, pass nullptr when not using update groups
- * \param[in] atomStart Start of atom range to grid
- * \param[in] atomEnd End of atom range to grid
+ * \param[in] atomRange Range of atoms to grid
* \param[in] atomDensity An estimate of the atom density, used for peformance optimization and only with \p gridIndex = 0
* \param[in] atomInfo Atom information flags
* \param[in] x Coordinates for atoms to grid
const rvec lowerCorner,
const rvec upperCorner,
const gmx::UpdateGroupsCog *updateGroupsCog,
- int atomStart,
- int atomEnd,
+ gmx::Range<int> atomRange,
real atomDensity,
gmx::ArrayRef<const int> atomInfo,
gmx::ArrayRef<const gmx::RVec> x,
const rvec lowerCorner,
const rvec upperCorner,
const gmx::UpdateGroupsCog *updateGroupsCog,
- int atomStart,
- int atomEnd,
+ gmx::Range<int> atomRange,
real atomDensity,
gmx::ArrayRef<const int> atomInfo,
gmx::ArrayRef<const gmx::RVec> x,
cycleCounting_.start(enbsCCgrid);
gridSet_.putOnGrid(box, ddZone, lowerCorner, upperCorner,
- updateGroupsCog, atomStart, atomEnd, atomDensity,
+ updateGroupsCog, atomRange, atomDensity,
atomInfo, x, numAtomsMoved, move, nbat);
cycleCounting_.stop(enbsCCgrid);
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff