src/gromacs/gpu_utils/cudautils.cuh

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2012,2014,2015,2016,2017, 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 #ifndef GMX_GPU_UTILS_CUDAUTILS_CUH
  36 #define GMX_GPU_UTILS_CUDAUTILS_CUH
  37
  38 #include "config.h"
  39
  40 #include <stdio.h>
  41 #if HAVE_NVML
  42 #include <nvml.h>
  43 #endif /* HAVE_NVML */
  44
  45 #include "gromacs/utility/fatalerror.h"
  46
  47 /* TODO error checking needs to be rewritten. We have 2 types of error checks needed
  48    based on where they occur in the code:
  49    - non performance-critical: these errors are unsafe to be ignored and must be
  50      _always_ checked for, e.g. initializations
  51    - performance critical: handling errors might hurt performance so care need to be taken
  52      when/if we should check for them at all, e.g. in cu_upload_X. However, we should be
  53      able to turn the check for these errors on!
  54
  55    Probably we'll need two sets of the macros below...
  56
  57  */
  58 #define CHECK_CUDA_ERRORS
  59
  60 #ifdef CHECK_CUDA_ERRORS
  61
  62 /*! Check for CUDA error on the return status of a CUDA RT API call. */
  63 #define CU_RET_ERR(status, msg) \
  64     do { \
  65         if (status != cudaSuccess) \
  66         { \
  67             gmx_fatal(FARGS, "%s: %s\n", msg, cudaGetErrorString(status)); \
  68         } \
  69     } while (0)
  70
  71 /*! Check for any previously occurred uncaught CUDA error. */
  72 #define CU_CHECK_PREV_ERR() \
  73     do { \
  74         cudaError_t _CU_CHECK_PREV_ERR_status = cudaGetLastError(); \
  75         if (_CU_CHECK_PREV_ERR_status != cudaSuccess) { \
  76             gmx_warning("Just caught a previously occurred CUDA error (%s), will try to continue.", cudaGetErrorString(_CU_CHECK_PREV_ERR_status)); \
  77         } \
  78     } while (0)
  79
  80 /*! Check for any previously occurred uncaught CUDA error
  81    -- aimed at use after kernel calls. */
  82 #define CU_LAUNCH_ERR(msg) \
  83     do { \
  84         cudaError_t _CU_LAUNCH_ERR_status = cudaGetLastError(); \
  85         if (_CU_LAUNCH_ERR_status != cudaSuccess) { \
  86             gmx_fatal(FARGS, "Error while launching kernel %s: %s\n", msg, cudaGetErrorString(_CU_LAUNCH_ERR_status)); \
  87         } \
  88     } while (0)
  89
  90 /*! Synchronize with GPU and check for any previously occurred uncaught CUDA error
  91    -- aimed at use after kernel calls. */
  92 #define CU_LAUNCH_ERR_SYNC(msg) \
  93     do { \
  94         cudaError_t _CU_SYNC_LAUNCH_ERR_status = cudaThreadSynchronize(); \
  95         if (_CU_SYNC_LAUNCH_ERR_status != cudaSuccess) { \
  96             gmx_fatal(FARGS, "Error while launching kernel %s: %s\n", msg, cudaGetErrorString(_CU_SYNC_LAUNCH_ERR_status)); \
  97         } \
  98     } while (0)
  99
 100 #else /* CHECK_CUDA_ERRORS */
 101
 102 #define CU_RET_ERR(status, msg) do { } while (0)
 103 #define CU_CHECK_PREV_ERR()     do { } while (0)
 104 #define CU_LAUNCH_ERR(msg)      do { } while (0)
 105 #define CU_LAUNCH_ERR_SYNC(msg) do { } while (0)
 106 #define HANDLE_NVML_RET_ERR(status, msg) do { } while (0)
 107
 108 #endif /* CHECK_CUDA_ERRORS */
 109
 110 /*! \brief CUDA device information.
 111  *
 112  * The CUDA device information is queried and set at detection and contains
 113  * both information about the device/hardware returned by the runtime as well
 114  * as additional data like support status.
 115  *
 116  * \todo extract an object to manage NVML details
 117  */
 118 struct gmx_device_info_t
 119 {
 120     int                 id;                      /* id of the CUDA device */
 121     cudaDeviceProp      prop;                    /* CUDA device properties */
 122     int                 stat;                    /* result of the device check */
 123     unsigned int        nvml_orig_app_sm_clock;  /* The original SM clock before we changed it */
 124     unsigned int        nvml_orig_app_mem_clock; /* The original memory clock before we changed it */
 125     gmx_bool            nvml_app_clocks_changed; /* If application clocks have been changed */
 126     unsigned int        nvml_set_app_sm_clock;   /* The SM clock we set */
 127     unsigned int        nvml_set_app_mem_clock;  /* The memory clock we set */
 128 #if HAVE_NVML
 129     nvmlDevice_t        nvml_device_id;          /* NVML device id */
 130     // TODO This can become a bool with a more useful name
 131     nvmlEnableState_t   nvml_is_restricted;      /* Status of application clocks permission */
 132 #endif                                           /* HAVE_NVML */
 133 };
 134
 135
 136 /*! Launches asynchronous host to device memory copy in stream 0. */
 137 int cu_copy_D2H(void * /*h_dest*/, void * /*d_src*/, size_t /*bytes*/);
 138
 139 /*! Launches asynchronous host to device memory copy in stream s. */
 140 int cu_copy_D2H_async(void * /*h_dest*/, void * /*d_src*/, size_t /*bytes*/, cudaStream_t /*s = 0*/);
 141
 142 /*! Launches synchronous host to device memory copy. */
 143 int cu_copy_H2D(void * /*d_dest*/, void * /*h_src*/, size_t /*bytes*/);
 144
 145 /*! Launches asynchronous host to device memory copy in stream s. */
 146 int cu_copy_H2D_async(void * /*d_dest*/, void * /*h_src*/, size_t /*bytes*/, cudaStream_t /*s = 0*/);
 147
 148 /*! Frees device memory and resets the size and allocation size to -1. */
 149 void cu_free_buffered(void *d_ptr, int *n = NULL, int *nalloc = NULL);
 150
 151 /*! Reallocates the device memory and copies data from the host. */
 152 void cu_realloc_buffered(void **d_dest, void *h_src,
 153                          size_t type_size,
 154                          int *curr_size, int *curr_alloc_size,
 155                          int req_size,
 156                          cudaStream_t s,
 157                          bool bAsync);
 158
 159 // TODO: the 2 functions below are pretty much a constructor/destructor of a simple
 160 // GPU table object. There is also almost self-contained fetchFromParamLookupTable()
 161 // in cuda_kernel_utils.cuh. They could all live in a separate class/struct file,
 162 // granted storing static texture references in there does not pose problems.
 163
 164 /*! \brief Initialize parameter lookup table.
 165  *
 166  * Initializes device memory, copies data from host and binds
 167  * a texture to allocated device memory to be used for parameter lookup.
 168  *
 169  * \tparam[in] T         Raw data type
 170  * \param[out] d_ptr     device pointer to the memory to be allocated
 171  * \param[out] texObj    texture object to be initialized
 172  * \param[out] texRef    texture reference to be initialized
 173  * \param[in]  h_ptr     pointer to the host memory to be uploaded to the device
 174  * \param[in]  numElem   number of elements in the h_ptr
 175  * \param[in]  devInfo   pointer to the info struct of the device in use
 176  */
 177 template <typename T>
 178 void initParamLookupTable(T                        * &d_ptr,
 179                           cudaTextureObject_t       &texObj,
 180                           const struct texture<T, 1, cudaReadModeElementType> *texRef,
 181                           const T                   *h_ptr,
 182                           int                        numElem,
 183                           const gmx_device_info_t   *devInfo);
 184
 185 /*! \brief Destroy parameter lookup table.
 186  *
 187  * Unbinds texture reference/object, deallocates device memory.
 188  *
 189  * \tparam[in] T         Raw data type
 190  * \param[in]  d_ptr     Device pointer to the memory to be deallocated
 191  * \param[in]  texObj    Texture object to be deinitialized
 192  * \param[in]  texRef    Texture reference to be deinitialized
 193  * \param[in]  devInfo   Pointer to the info struct of the device in use
 194  */
 195 template <typename T>
 196 void destroyParamLookupTable(T                         *d_ptr,
 197                              cudaTextureObject_t        texObj,
 198                              const struct texture<T, 1, cudaReadModeElementType> *texRef,
 199                              const gmx_device_info_t   *devInfo);
 200
 201 #endif