#include "gromacs/gpu_utils/cudautils.cuh"
#include "gromacs/gpu_utils/device_context.h"
#include "gromacs/gpu_utils/devicebuffer.h"
-#include "gromacs/gpu_utils/gpueventsynchronizer.cuh"
+#include "gromacs/gpu_utils/gpueventsynchronizer.h"
#include "gromacs/gpu_utils/typecasts.cuh"
#include "gromacs/gpu_utils/vectype_ops.cuh"
#include "gromacs/math/vectypes.h"
*gm_dataDest = *gm_dataSrc;
}
}
-
- return;
}
/*! \brief unpack non-local force data buffer on the GPU using pre-populated "map" containing index
- * information \param[out] data full array of force values \param[in] dataPacked packed
- * array of force values to be transferred \param[in] map array of indices defining mapping
- * from full to packed array \param[in] mapSize number of elements in map array
+ * information
+ * \param[out] data full array of force values
+ * \param[in] dataPacked packed array of force values to be transferred
+ * \param[in] map array of indices defining mapping from full to packed array
+ * \param[in] mapSize number of elements in map array
*/
template<bool accumulate>
__global__ void unpackRecvBufKernel(float3* __restrict__ data,
*gm_dataDest = *gm_dataSrc;
}
}
-
- return;
}
void GpuHaloExchange::Impl::reinitHalo(float3* d_coordinatesBuffer, float3* d_forcesBuffer)
{
- wallcycle_start(wcycle_, ewcDOMDEC);
- wallcycle_sub_start(wcycle_, ewcsDD_GPU);
+ wallcycle_start(wcycle_, WallCycleCounter::Domdec);
+ wallcycle_sub_start(wcycle_, WallCycleSubCounter::DDGpu);
d_x_ = d_coordinatesBuffer;
d_f_ = d_forcesBuffer;
const gmx_domdec_comm_dim_t& cd = comm.cd[dimIndex_];
const gmx_domdec_ind_t& ind = cd.ind[pulse_];
- numHomeAtoms_ = comm.atomRanges.numHomeAtoms(); // offset for data recieved by this rank
+ numHomeAtoms_ = comm.atomRanges.numHomeAtoms(); // offset for data received by this rank
// Determine receive offset for the dimension index and pulse of this halo exchange object
int numZoneTemp = 1;
std::copy(ind.index.begin(), ind.index.end(), h_indexMap_.begin());
copyToDeviceBuffer(
- &d_indexMap_, h_indexMap_.data(), 0, newSize, nonLocalStream_, GpuApiCallBehavior::Async, nullptr);
+ &d_indexMap_, h_indexMap_.data(), 0, newSize, *haloStream_, GpuApiCallBehavior::Async, nullptr);
}
#if GMX_MPI
}
#endif
- wallcycle_sub_stop(wcycle_, ewcsDD_GPU);
- wallcycle_stop(wcycle_, ewcDOMDEC);
-
- return;
+ wallcycle_sub_stop(wcycle_, WallCycleSubCounter::DDGpu);
+ wallcycle_stop(wcycle_, WallCycleCounter::Domdec);
}
void GpuHaloExchange::Impl::enqueueWaitRemoteCoordinatesReadyEvent(GpuEventSynchronizer* coordinatesReadyOnDeviceEvent)
// Similarly send event to task that will push data to this task.
GpuEventSynchronizer* remoteCoordinatesReadyOnDeviceEvent;
MPI_Sendrecv(&coordinatesReadyOnDeviceEvent,
- sizeof(GpuEventSynchronizer*),
+ sizeof(GpuEventSynchronizer*), //NOLINT(bugprone-sizeof-expression)
MPI_BYTE,
recvRankX_,
0,
&remoteCoordinatesReadyOnDeviceEvent,
- sizeof(GpuEventSynchronizer*),
+ sizeof(GpuEventSynchronizer*), //NOLINT(bugprone-sizeof-expression)
MPI_BYTE,
sendRankX_,
0,
mpi_comm_mysim_,
MPI_STATUS_IGNORE);
- remoteCoordinatesReadyOnDeviceEvent->enqueueWaitEvent(nonLocalStream_);
+ remoteCoordinatesReadyOnDeviceEvent->enqueueWaitEvent(*haloStream_);
}
-void GpuHaloExchange::Impl::communicateHaloCoordinates(const matrix box,
- GpuEventSynchronizer* coordinatesReadyOnDeviceEvent)
+GpuEventSynchronizer* GpuHaloExchange::Impl::communicateHaloCoordinates(const matrix box,
+ GpuEventSynchronizer* dependencyEvent)
{
+ wallcycle_start(wcycle_, WallCycleCounter::LaunchGpu);
- wallcycle_start(wcycle_, ewcLAUNCH_GPU);
- if (pulse_ == 0)
- {
- // ensure stream waits until coordinate data is available on device
- coordinatesReadyOnDeviceEvent->enqueueWaitEvent(nonLocalStream_);
- }
+ // ensure stream waits until dependency has been satisfied
+ dependencyEvent->enqueueWaitEvent(*haloStream_);
- wallcycle_sub_start(wcycle_, ewcsLAUNCH_GPU_MOVEX);
+ wallcycle_sub_start(wcycle_, WallCycleSubCounter::LaunchGpuMoveX);
// launch kernel to pack send buffer
KernelLaunchConfig config;
const auto kernelArgs = prepareGpuKernelArguments(
kernelFn, config, &sendBuf, &d_x, &indexMap, &size, &coordinateShift);
- launchGpuKernel(
- kernelFn, config, nonLocalStream_, nullptr, "Domdec GPU Apply X Halo Exchange", kernelArgs);
+ launchGpuKernel(kernelFn, config, *haloStream_, nullptr, "Domdec GPU Apply X Halo Exchange", kernelArgs);
}
- wallcycle_sub_stop(wcycle_, ewcsLAUNCH_GPU_MOVEX);
- wallcycle_stop(wcycle_, ewcLAUNCH_GPU);
+ wallcycle_sub_stop(wcycle_, WallCycleSubCounter::LaunchGpuMoveX);
+ wallcycle_stop(wcycle_, WallCycleCounter::LaunchGpu);
// Consider time spent in communicateHaloData as Comm.X counter
// ToDo: We need further refinement here as communicateHaloData includes launch time for cudamemcpyasync
- wallcycle_start(wcycle_, ewcMOVEX);
+ wallcycle_start(wcycle_, WallCycleCounter::MoveX);
// wait for remote co-ordinates is implicit with process-MPI as non-local stream is synchronized before MPI calls
// and MPI_Waitall call makes sure both neighboring ranks' non-local stream is synchronized before data transfer is initiated
- if (GMX_THREAD_MPI && pulse_ == 0)
+ if (GMX_THREAD_MPI && dimIndex_ == 0 && pulse_ == 0)
{
- enqueueWaitRemoteCoordinatesReadyEvent(coordinatesReadyOnDeviceEvent);
+ enqueueWaitRemoteCoordinatesReadyEvent(dependencyEvent);
}
float3* recvPtr = GMX_THREAD_MPI ? remoteXPtr_ : &d_x_[atomOffset_];
communicateHaloData(d_sendBuf_, xSendSize_, sendRankX_, recvPtr, xRecvSize_, recvRankX_);
- wallcycle_stop(wcycle_, ewcMOVEX);
+ coordinateHaloLaunched_.markEvent(*haloStream_);
+
+ wallcycle_stop(wcycle_, WallCycleCounter::MoveX);
- return;
+ return &coordinateHaloLaunched_;
}
// The following method should be called after non-local buffer operations,
-// and before the local buffer operations. It operates in the non-local stream.
-void GpuHaloExchange::Impl::communicateHaloForces(bool accumulateForces)
+// and before the local buffer operations.
+void GpuHaloExchange::Impl::communicateHaloForces(bool accumulateForces,
+ FixedCapacityVector<GpuEventSynchronizer*, 2>* dependencyEvents)
{
+
// Consider time spent in communicateHaloData as Comm.F counter
// ToDo: We need further refinement here as communicateHaloData includes launch time for cudamemcpyasync
- wallcycle_start(wcycle_, ewcMOVEF);
+ wallcycle_start(wcycle_, WallCycleCounter::MoveF);
+
+ while (!dependencyEvents->empty())
+ {
+ auto* dependency = dependencyEvents->back();
+ dependency->enqueueWaitEvent(*haloStream_);
+ dependencyEvents->pop_back();
+ }
float3* recvPtr = GMX_THREAD_MPI ? remoteFPtr_ : d_recvBuf_;
- // Communicate halo data (in non-local stream)
+ // Communicate halo data
communicateHaloData(&(d_f_[atomOffset_]), fSendSize_, sendRankF_, recvPtr, fRecvSize_, recvRankF_);
- wallcycle_stop(wcycle_, ewcMOVEF);
+ wallcycle_stop(wcycle_, WallCycleCounter::MoveF);
- wallcycle_start_nocount(wcycle_, ewcLAUNCH_GPU);
- wallcycle_sub_start(wcycle_, ewcsLAUNCH_GPU_MOVEF);
+ wallcycle_start_nocount(wcycle_, WallCycleCounter::LaunchGpu);
+ wallcycle_sub_start(wcycle_, WallCycleSubCounter::LaunchGpuMoveF);
float3* d_f = d_f_;
- // If this is the last pulse and index (noting the force halo
- // exchanges across multiple pulses and indices are called in
- // reverse order) then perform the following preparation
- // activities
- if ((pulse_ == (dd_->comm->cd[dimIndex_].numPulses() - 1)) && (dimIndex_ == (dd_->ndim - 1)))
- {
- // ensure non-local stream waits for local stream, due to dependence on
- // the previous H2D copy of CPU forces (if accumulateForces is true)
- // or local force clearing.
- GpuEventSynchronizer eventLocal;
- eventLocal.markEvent(localStream_);
- eventLocal.enqueueWaitEvent(nonLocalStream_);
- }
// Unpack halo buffer into force array
const auto kernelArgs =
prepareGpuKernelArguments(kernelFn, config, &d_f, &recvBuf, &indexMap, &size);
- launchGpuKernel(
- kernelFn, config, nonLocalStream_, nullptr, "Domdec GPU Apply F Halo Exchange", kernelArgs);
+ launchGpuKernel(kernelFn, config, *haloStream_, nullptr, "Domdec GPU Apply F Halo Exchange", kernelArgs);
}
- if (pulse_ == 0)
- {
- fReadyOnDevice_.markEvent(nonLocalStream_);
- }
+ fReadyOnDevice_.markEvent(*haloStream_);
- wallcycle_sub_stop(wcycle_, ewcsLAUNCH_GPU_MOVEF);
- wallcycle_stop(wcycle_, ewcLAUNCH_GPU);
+ wallcycle_sub_stop(wcycle_, WallCycleSubCounter::LaunchGpuMoveF);
+ wallcycle_stop(wcycle_, WallCycleCounter::LaunchGpu);
}
void GpuHaloExchange::Impl::communicateHaloData(float3* sendPtr,
// no need to wait for haloDataReadyOnDevice event if this rank is not sending any data
if (sendSize > 0)
{
- // wait for non local stream to complete all outstanding
+ // wait for halo stream to complete all outstanding
// activities, to ensure that buffer is up-to-date in GPU memory
// before transferring to remote rank
// ToDo: Replace stream synchronize with event synchronize
- nonLocalStream_.synchronize();
+ haloStream_->synchronize();
}
// perform halo exchange directly in device buffers
sendPtr,
sendSize * DIM * sizeof(float),
cudaMemcpyDeviceToDevice,
- nonLocalStream_.stream());
+ haloStream_->stream());
CU_RET_ERR(stat, "cudaMemcpyAsync on GPU Domdec CUDA direct data transfer failed");
}
GMX_ASSERT(haloDataTransferLaunched_ != nullptr,
"Halo exchange requires valid event to synchronize data transfer initiated in "
"remote rank");
- haloDataTransferLaunched_->markEvent(nonLocalStream_);
+ haloDataTransferLaunched_->markEvent(*haloStream_);
MPI_Sendrecv(&haloDataTransferLaunched_,
- sizeof(GpuEventSynchronizer*),
+ sizeof(GpuEventSynchronizer*), //NOLINT(bugprone-sizeof-expression)
MPI_BYTE,
sendRank,
0,
&haloDataTransferRemote,
- sizeof(GpuEventSynchronizer*),
+ sizeof(GpuEventSynchronizer*), //NOLINT(bugprone-sizeof-expression)
MPI_BYTE,
recvRank,
0,
mpi_comm_mysim_,
MPI_STATUS_IGNORE);
- haloDataTransferRemote->enqueueWaitEvent(nonLocalStream_);
+ haloDataTransferRemote->enqueueWaitEvent(*haloStream_);
#else
GMX_UNUSED_VALUE(sendRank);
GMX_UNUSED_VALUE(recvRank);
int dimIndex,
MPI_Comm mpi_comm_mysim,
const DeviceContext& deviceContext,
- const DeviceStream& localStream,
- const DeviceStream& nonLocalStream,
int pulse,
gmx_wallcycle* wcycle) :
dd_(dd),
haloDataTransferLaunched_(GMX_THREAD_MPI ? new GpuEventSynchronizer() : nullptr),
mpi_comm_mysim_(mpi_comm_mysim),
deviceContext_(deviceContext),
- localStream_(localStream),
- nonLocalStream_(nonLocalStream),
+ haloStream_(new DeviceStream(deviceContext, DeviceStreamPriority::High, false)),
dimIndex_(dimIndex),
pulse_(pulse),
wcycle_(wcycle)
int dimIndex,
MPI_Comm mpi_comm_mysim,
const DeviceContext& deviceContext,
- const DeviceStream& localStream,
- const DeviceStream& nonLocalStream,
int pulse,
gmx_wallcycle* wcycle) :
- impl_(new Impl(dd, dimIndex, mpi_comm_mysim, deviceContext, localStream, nonLocalStream, pulse, wcycle))
+ impl_(new Impl(dd, dimIndex, mpi_comm_mysim, deviceContext, pulse, wcycle))
{
}
impl_->reinitHalo(asFloat3(d_coordinatesBuffer), asFloat3(d_forcesBuffer));
}
-void GpuHaloExchange::communicateHaloCoordinates(const matrix box,
- GpuEventSynchronizer* coordinatesReadyOnDeviceEvent)
+GpuEventSynchronizer* GpuHaloExchange::communicateHaloCoordinates(const matrix box,
+ GpuEventSynchronizer* dependencyEvent)
{
- impl_->communicateHaloCoordinates(box, coordinatesReadyOnDeviceEvent);
+ return impl_->communicateHaloCoordinates(box, dependencyEvent);
}
-void GpuHaloExchange::communicateHaloForces(bool accumulateForces)
+void GpuHaloExchange::communicateHaloForces(bool accumulateForces,
+ FixedCapacityVector<GpuEventSynchronizer*, 2>* dependencyEvents)
{
- impl_->communicateHaloForces(accumulateForces);
+ impl_->communicateHaloForces(accumulateForces, dependencyEvents);
}
GpuEventSynchronizer* GpuHaloExchange::getForcesReadyOnDeviceEvent()
biod.pnpi.spb.ru / alexxy / gromacs.git / blobdiff