src/gromacs/mdtypes/state_propagator_data_gpu_impl.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2019,2020,2021, by the GROMACS development team, led by
   5  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   6  * and including many others, as listed in the AUTHORS file in the
   7  * top-level source directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 /*! \internal \file
  36  *
  37  * \brief The CPU stub for the state propagator data class.
  38  *
  39  * \author Artem Zhmurov <zhmurov@gmail.com>
  40  *
  41  * \ingroup module_mdtypes
  42  */
  43 #include "gmxpre.h"
  44
  45 #include "config.h"
  46
  47 #include "gromacs/mdtypes/state_propagator_data_gpu.h"
  48
  49 #if !GMX_GPU
  50 namespace gmx
  51 {
  52
  53 class StatePropagatorDataGpu::Impl
  54 {
  55 };
  56
  57 StatePropagatorDataGpu::StatePropagatorDataGpu(const DeviceStreamManager& /* deviceStreamManager */,
  58                                                GpuApiCallBehavior /* transferKind    */,
  59                                                int /* allocationBlockSizeDivisor */,
  60                                                gmx_wallcycle* /*   wcycle */) :
  61     impl_(nullptr)
  62 {
  63 }
  64
  65 StatePropagatorDataGpu::StatePropagatorDataGpu(const DeviceStream* /* pmeStream       */,
  66                                                const DeviceContext& /* deviceContext   */,
  67                                                GpuApiCallBehavior /* transferKind    */,
  68                                                int /* allocationBlockSizeDivisor */,
  69                                                gmx_wallcycle* /*   wcycle */) :
  70     impl_(nullptr)
  71 {
  72 }
  73
  74 StatePropagatorDataGpu::StatePropagatorDataGpu(StatePropagatorDataGpu&& /* other */) noexcept = default;
  75
  76 StatePropagatorDataGpu& StatePropagatorDataGpu::operator=(StatePropagatorDataGpu&& /* other */) noexcept = default;
  77
  78 StatePropagatorDataGpu::~StatePropagatorDataGpu() = default;
  79
  80 void StatePropagatorDataGpu::reinit(int /* numAtomsLocal */, int /* numAtomsAll   */)
  81 {
  82     GMX_ASSERT(!impl_,
  83                "A CPU stub method from GPU state propagator data was called instead of one from "
  84                "GPU implementation.");
  85 }
  86
  87 std::tuple<int, int> StatePropagatorDataGpu::getAtomRangesFromAtomLocality(AtomLocality /* atomLocality */) const
  88 {
  89     GMX_ASSERT(!impl_,
  90                "A CPU stub method from GPU state propagator data was called instead of one from "
  91                "GPU implementation.");
  92     return std::make_tuple(0, 0);
  93 }
  94
  95 DeviceBuffer<RVec> StatePropagatorDataGpu::getCoordinates()
  96 {
  97     GMX_ASSERT(!impl_,
  98                "A CPU stub method from GPU state propagator data was called instead of one from "
  99                "GPU implementation.");
 100     return {};
 101 }
 102
 103 GpuEventSynchronizer* StatePropagatorDataGpu::getCoordinatesReadyOnDeviceEvent(
 104         AtomLocality /* atomLocality */,
 105         const SimulationWorkload& /* simulationWork */,
 106         const StepWorkload& /* stepWork       */,
 107         GpuEventSynchronizer* /* gpuCoordinateHaloLaunched */)
 108 {
 109     GMX_ASSERT(!impl_,
 110                "A CPU stub method from GPU state propagator data was called instead of one from "
 111                "GPU implementation.");
 112     return nullptr;
 113 }
 114
 115 void StatePropagatorDataGpu::waitCoordinatesCopiedToDevice(AtomLocality /* atomLocality */)
 116 {
 117     GMX_ASSERT(!impl_,
 118                "A CPU stub method from GPU state propagator data was called instead of one from "
 119                "GPU implementation.");
 120 }
 121
 122 void StatePropagatorDataGpu::consumeCoordinatesCopiedToDeviceEvent(AtomLocality /* atomLocality */)
 123 {
 124     GMX_ASSERT(!impl_,
 125                "A CPU stub method from GPU state propagator data was called instead of one from "
 126                "GPU implementation.");
 127 }
 128
 129 void StatePropagatorDataGpu::resetCoordinatesCopiedToDeviceEvent(AtomLocality /* atomLocality */)
 130 {
 131     GMX_ASSERT(!impl_,
 132                "A CPU stub method from GPU state propagator data was called instead of one from "
 133                "GPU implementation.");
 134 }
 135
 136 void StatePropagatorDataGpu::setXUpdatedOnDeviceEvent(GpuEventSynchronizer* /* xUpdatedOnDeviceEvent */)
 137 {
 138     GMX_ASSERT(!impl_,
 139                "A CPU stub method from GPU state propagator data was called instead of one from "
 140                "GPU implementation.");
 141 }
 142
 143 void StatePropagatorDataGpu::copyCoordinatesToGpu(const gmx::ArrayRef<const gmx::RVec> /* h_x */,
 144                                                   AtomLocality /* atomLocality */)
 145 {
 146     GMX_ASSERT(!impl_,
 147                "A CPU stub method from GPU state propagator data was called instead of one from "
 148                "GPU implementation.");
 149 }
 150
 151 void StatePropagatorDataGpu::waitCoordinatesReadyOnHost(AtomLocality /* atomLocality */)
 152 {
 153     GMX_ASSERT(!impl_,
 154                "A CPU stub method from GPU state propagator data was called instead of one from "
 155                "GPU implementation.");
 156 }
 157
 158 void StatePropagatorDataGpu::copyCoordinatesFromGpu(gmx::ArrayRef<gmx::RVec> /* h_x          */,
 159                                                     AtomLocality /* atomLocality */,
 160                                                     GpuEventSynchronizer* /*dependency */)
 161 {
 162     GMX_ASSERT(!impl_,
 163                "A CPU stub method from GPU state propagator data was called instead of one from "
 164                "GPU implementation.");
 165 }
 166
 167 DeviceBuffer<RVec> StatePropagatorDataGpu::getVelocities()
 168 {
 169     GMX_ASSERT(!impl_,
 170                "A CPU stub method from GPU state propagator data was called instead of one from "
 171                "GPU implementation.");
 172     return {};
 173 }
 174
 175 void StatePropagatorDataGpu::copyVelocitiesToGpu(const gmx::ArrayRef<const gmx::RVec> /* h_v */,
 176                                                  AtomLocality /* atomLocality */)
 177 {
 178     GMX_ASSERT(!impl_,
 179                "A CPU stub method from GPU state propagator data was called instead of one from "
 180                "GPU implementation.");
 181 }
 182
 183 void StatePropagatorDataGpu::copyVelocitiesFromGpu(gmx::ArrayRef<gmx::RVec> /* h_v          */,
 184                                                    AtomLocality /* atomLocality */)
 185 {
 186     GMX_ASSERT(!impl_,
 187                "A CPU stub method from GPU state propagator data was called instead of one from "
 188                "GPU implementation.");
 189 }
 190
 191 void StatePropagatorDataGpu::waitVelocitiesReadyOnHost(AtomLocality /* atomLocality */)
 192 {
 193     GMX_ASSERT(!impl_,
 194                "A CPU stub method from GPU state propagator data was called instead of one from "
 195                "GPU implementation.");
 196 }
 197
 198
 199 DeviceBuffer<RVec> StatePropagatorDataGpu::getForces()
 200 {
 201     GMX_ASSERT(!impl_,
 202                "A CPU stub method from GPU state propagator data was called instead of one from "
 203                "GPU implementation.");
 204     return {};
 205 }
 206
 207 void StatePropagatorDataGpu::copyForcesToGpu(const gmx::ArrayRef<const gmx::RVec> /* h_f          */,
 208                                              AtomLocality /* atomLocality */)
 209 {
 210     GMX_ASSERT(!impl_,
 211                "A CPU stub method from GPU state propagator data was called instead of one from "
 212                "GPU implementation.");
 213 }
 214
 215 void StatePropagatorDataGpu::clearForcesOnGpu(AtomLocality /* atomLocality */,
 216                                               GpuEventSynchronizer* /* dependency */)
 217 {
 218     GMX_ASSERT(!impl_,
 219                "A CPU stub method from GPU state propagator data was called instead of one from "
 220                "GPU implementation.");
 221 }
 222
 223 GpuEventSynchronizer* StatePropagatorDataGpu::getLocalForcesReadyOnDeviceEvent(StepWorkload /* stepWork */,
 224                                                                                SimulationWorkload /* simulationWork */)
 225 {
 226     GMX_ASSERT(!impl_,
 227                "A CPU stub method from GPU state propagator data was called instead of one from "
 228                "GPU implementation.");
 229     return nullptr;
 230 }
 231
 232 GpuEventSynchronizer* StatePropagatorDataGpu::fReducedOnDevice(AtomLocality /*atomLocality*/)
 233 {
 234     GMX_ASSERT(!impl_,
 235                "A CPU stub method from GPU state propagator data was called instead of one from "
 236                "GPU implementation.");
 237     return nullptr;
 238 }
 239
 240 void StatePropagatorDataGpu::consumeForcesReducedOnDeviceEvent(AtomLocality /*atomLocality*/)
 241 {
 242     GMX_ASSERT(!impl_,
 243                "A CPU stub method from GPU state propagator data was called instead of one from "
 244                "GPU implementation.");
 245 }
 246
 247 GpuEventSynchronizer* StatePropagatorDataGpu::fReadyOnDevice(AtomLocality /*atomLocality*/)
 248 {
 249     GMX_ASSERT(!impl_,
 250                "A CPU stub method from GPU state propagator data was called instead of one from "
 251                "GPU implementation.");
 252     return nullptr;
 253 }
 254
 255 void StatePropagatorDataGpu::copyForcesFromGpu(gmx::ArrayRef<gmx::RVec> /* h_f          */,
 256                                                AtomLocality /* atomLocality */)
 257 {
 258     GMX_ASSERT(!impl_,
 259                "A CPU stub method from GPU state propagator data was called instead of one from "
 260                "GPU implementation.");
 261 }
 262
 263 void StatePropagatorDataGpu::waitForcesReadyOnHost(AtomLocality /* atomLocality */)
 264 {
 265     GMX_ASSERT(!impl_,
 266                "A CPU stub method from GPU state propagator data was called instead of one from "
 267                "GPU implementation.");
 268 }
 269
 270
 271 const DeviceStream* StatePropagatorDataGpu::getUpdateStream()
 272 {
 273     GMX_ASSERT(!impl_,
 274                "A CPU stub method from GPU state propagator data was called instead of one from "
 275                "GPU implementation.");
 276     return nullptr;
 277 }
 278
 279 int StatePropagatorDataGpu::numAtomsLocal() const
 280 {
 281     GMX_ASSERT(!impl_,
 282                "A CPU stub method from GPU state propagator data was called instead of one from "
 283                "GPU implementation.");
 284     return 0;
 285 }
 286
 287 int StatePropagatorDataGpu::numAtomsAll() const
 288 {
 289     GMX_ASSERT(!impl_,
 290                "A CPU stub method from GPU state propagator data was called instead of one from "
 291                "GPU implementation.");
 292     return 0;
 293 }
 294
 295 } // namespace gmx
 296
 297 #endif // !GMX_GPU