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, 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 == GMX_GPU_NONE
  50 namespace gmx
  51 {
  52
  53 class StatePropagatorDataGpu::Impl
  54 {
  55 };
  56
  57 StatePropagatorDataGpu::StatePropagatorDataGpu(const DeviceStream* /* pmeStream       */,
  58                                                const DeviceStream* /* localStream     */,
  59                                                const DeviceStream* /* nonLocalStream  */,
  60                                                const DeviceContext& /* deviceContext   */,
  61                                                GpuApiCallBehavior /* transferKind    */,
  62                                                int /* paddingSize     */,
  63                                                gmx_wallcycle* /*   wcycle */) :
  64     impl_(nullptr)
  65 {
  66 }
  67
  68 StatePropagatorDataGpu::StatePropagatorDataGpu(const DeviceStream* /* pmeStream       */,
  69                                                const DeviceContext& /* deviceContext   */,
  70                                                GpuApiCallBehavior /* transferKind    */,
  71                                                int /* paddingSize     */,
  72                                                gmx_wallcycle* /*   wcycle */) :
  73     impl_(nullptr)
  74 {
  75 }
  76
  77 StatePropagatorDataGpu::StatePropagatorDataGpu(StatePropagatorDataGpu&& /* other */) noexcept = default;
  78
  79 StatePropagatorDataGpu& StatePropagatorDataGpu::operator=(StatePropagatorDataGpu&& /* other */) noexcept = default;
  80
  81 StatePropagatorDataGpu::~StatePropagatorDataGpu() = default;
  82
  83 void StatePropagatorDataGpu::reinit(int /* numAtomsLocal */, int /* numAtomsAll   */)
  84 {
  85     GMX_ASSERT(false,
  86                "A CPU stub method from GPU state propagator data was called instead of one from "
  87                "GPU implementation.");
  88 }
  89
  90 std::tuple<int, int> StatePropagatorDataGpu::getAtomRangesFromAtomLocality(AtomLocality /* atomLocality */)
  91 {
  92     GMX_ASSERT(false,
  93                "A CPU stub method from GPU state propagator data was called instead of one from "
  94                "GPU implementation.");
  95     return std::make_tuple(0, 0);
  96 }
  97
  98 DeviceBuffer<RVec> StatePropagatorDataGpu::getCoordinates()
  99 {
 100     GMX_ASSERT(false,
 101                "A CPU stub method from GPU state propagator data was called instead of one from "
 102                "GPU implementation.");
 103     return {};
 104 }
 105
 106 GpuEventSynchronizer* StatePropagatorDataGpu::getCoordinatesReadyOnDeviceEvent(
 107         AtomLocality /* atomLocality */,
 108         const SimulationWorkload& /* simulationWork */,
 109         const StepWorkload& /* stepWork       */)
 110 {
 111     GMX_ASSERT(false,
 112                "A CPU stub method from GPU state propagator data was called instead of one from "
 113                "GPU implementation.");
 114     return nullptr;
 115 }
 116
 117 void StatePropagatorDataGpu::waitCoordinatesCopiedToDevice(AtomLocality /* atomLocality */)
 118 {
 119     GMX_ASSERT(false,
 120                "A CPU stub method from GPU state propagator data was called instead of one from "
 121                "GPU implementation.");
 122 }
 123
 124 GpuEventSynchronizer* StatePropagatorDataGpu::xUpdatedOnDevice()
 125 {
 126     GMX_ASSERT(false,
 127                "A CPU stub method from GPU state propagator data was called instead of one from "
 128                "GPU implementation.");
 129     return nullptr;
 130 }
 131
 132 void StatePropagatorDataGpu::copyCoordinatesToGpu(const gmx::ArrayRef<const gmx::RVec> /* h_x */,
 133                                                   AtomLocality /* atomLocality */)
 134 {
 135     GMX_ASSERT(false,
 136                "A CPU stub method from GPU state propagator data was called instead of one from "
 137                "GPU implementation.");
 138 }
 139
 140 void StatePropagatorDataGpu::waitCoordinatesReadyOnHost(AtomLocality /* atomLocality */)
 141 {
 142     GMX_ASSERT(false,
 143                "A CPU stub method from GPU state propagator data was called instead of one from "
 144                "GPU implementation.");
 145 }
 146
 147 void StatePropagatorDataGpu::copyCoordinatesFromGpu(gmx::ArrayRef<gmx::RVec> /* h_x          */,
 148                                                     AtomLocality /* atomLocality */)
 149 {
 150     GMX_ASSERT(false,
 151                "A CPU stub method from GPU state propagator data was called instead of one from "
 152                "GPU implementation.");
 153 }
 154
 155
 156 DeviceBuffer<RVec> StatePropagatorDataGpu::getVelocities()
 157 {
 158     GMX_ASSERT(false,
 159                "A CPU stub method from GPU state propagator data was called instead of one from "
 160                "GPU implementation.");
 161     return {};
 162 }
 163
 164 void StatePropagatorDataGpu::copyVelocitiesToGpu(const gmx::ArrayRef<const gmx::RVec> /* h_v */,
 165                                                  AtomLocality /* atomLocality */)
 166 {
 167     GMX_ASSERT(false,
 168                "A CPU stub method from GPU state propagator data was called instead of one from "
 169                "GPU implementation.");
 170 }
 171
 172 GpuEventSynchronizer* StatePropagatorDataGpu::getVelocitiesReadyOnDeviceEvent(AtomLocality /* atomLocality */)
 173 {
 174     GMX_ASSERT(false,
 175                "A CPU stub method from GPU state propagator data was called instead of one from "
 176                "GPU implementation.");
 177     return nullptr;
 178 }
 179
 180 void StatePropagatorDataGpu::copyVelocitiesFromGpu(gmx::ArrayRef<gmx::RVec> /* h_v          */,
 181                                                    AtomLocality /* atomLocality */)
 182 {
 183     GMX_ASSERT(false,
 184                "A CPU stub method from GPU state propagator data was called instead of one from "
 185                "GPU implementation.");
 186 }
 187
 188 void StatePropagatorDataGpu::waitVelocitiesReadyOnHost(AtomLocality /* atomLocality */)
 189 {
 190     GMX_ASSERT(false,
 191                "A CPU stub method from GPU state propagator data was called instead of one from "
 192                "GPU implementation.");
 193 }
 194
 195
 196 DeviceBuffer<RVec> StatePropagatorDataGpu::getForces()
 197 {
 198     GMX_ASSERT(false,
 199                "A CPU stub method from GPU state propagator data was called instead of one from "
 200                "GPU implementation.");
 201     return {};
 202 }
 203
 204 void StatePropagatorDataGpu::copyForcesToGpu(const gmx::ArrayRef<const gmx::RVec> /* h_f          */,
 205                                              AtomLocality /* atomLocality */)
 206 {
 207     GMX_ASSERT(false,
 208                "A CPU stub method from GPU state propagator data was called instead of one from "
 209                "GPU implementation.");
 210 }
 211
 212 GpuEventSynchronizer* StatePropagatorDataGpu::getForcesReadyOnDeviceEvent(AtomLocality /* atomLocality */,
 213                                                                           bool /* useGpuFBufferOps */)
 214 {
 215     GMX_ASSERT(false,
 216                "A CPU stub method from GPU state propagator data was called instead of one from "
 217                "GPU implementation.");
 218     return nullptr;
 219 }
 220
 221 GpuEventSynchronizer* StatePropagatorDataGpu::fReducedOnDevice()
 222 {
 223     GMX_ASSERT(false,
 224                "A CPU stub method from GPU state propagator data was called instead of one from "
 225                "GPU implementation.");
 226     return nullptr;
 227 }
 228
 229 void StatePropagatorDataGpu::copyForcesFromGpu(gmx::ArrayRef<gmx::RVec> /* h_f          */,
 230                                                AtomLocality /* atomLocality */)
 231 {
 232     GMX_ASSERT(false,
 233                "A CPU stub method from GPU state propagator data was called instead of one from "
 234                "GPU implementation.");
 235 }
 236
 237 void StatePropagatorDataGpu::waitForcesReadyOnHost(AtomLocality /* atomLocality */)
 238 {
 239     GMX_ASSERT(false,
 240                "A CPU stub method from GPU state propagator data was called instead of one from "
 241                "GPU implementation.");
 242 }
 243
 244
 245 const DeviceStream* StatePropagatorDataGpu::getUpdateStream()
 246 {
 247     GMX_ASSERT(false,
 248                "A CPU stub method from GPU state propagator data was called instead of one from "
 249                "GPU implementation.");
 250     return nullptr;
 251 }
 252
 253 int StatePropagatorDataGpu::numAtomsLocal()
 254 {
 255     GMX_ASSERT(false,
 256                "A CPU stub method from GPU state propagator data was called instead of one from "
 257                "GPU implementation.");
 258     return 0;
 259 }
 260
 261 int StatePropagatorDataGpu::numAtomsAll()
 262 {
 263     GMX_ASSERT(false,
 264                "A CPU stub method from GPU state propagator data was called instead of one from "
 265                "GPU implementation.");
 266     return 0;
 267 }
 268
 269 } // namespace gmx
 270
 271 #endif // GMX_GPU == GMX_GPU_NONE