2 * This file is part of the GROMACS molecular simulation package.
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.
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.
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.
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.
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.
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.
35 #ifndef GMX_GPU_UTILS_CUDAUTILS_CUH
36 #define GMX_GPU_UTILS_CUDAUTILS_CUH
43 #endif /* HAVE_NVML */
45 #include "gromacs/utility/fatalerror.h"
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!
55 Probably we'll need two sets of the macros below...
58 #define CHECK_CUDA_ERRORS
60 #ifdef CHECK_CUDA_ERRORS
62 /*! Check for CUDA error on the return status of a CUDA RT API call. */
63 #define CU_RET_ERR(status, msg) \
65 if (status != cudaSuccess) \
67 gmx_fatal(FARGS, "%s: %s\n", msg, cudaGetErrorString(status)); \
71 /*! Check for any previously occurred uncaught CUDA error. */
72 #define CU_CHECK_PREV_ERR() \
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)); \
80 /*! Check for any previously occurred uncaught CUDA error
81 -- aimed at use after kernel calls. */
82 #define CU_LAUNCH_ERR(msg) \
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)); \
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) \
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)); \
100 #else /* CHECK_CUDA_ERRORS */
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)
108 #endif /* CHECK_CUDA_ERRORS */
110 /*! \brief CUDA device information.
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.
116 struct gmx_device_info_t
118 int id; /* id of the CUDA device */
119 cudaDeviceProp prop; /* CUDA device properties */
120 int stat; /* result of the device check */
121 gmx_bool nvml_initialized; /* If NVML was initialized */
122 unsigned int nvml_orig_app_sm_clock; /* The original SM clock before we changed it */
123 unsigned int nvml_orig_app_mem_clock; /* The original memory clock before we changed it */
124 gmx_bool nvml_app_clocks_changed; /* If application clocks have been changed */
125 unsigned int nvml_set_app_sm_clock; /* The SM clock we set */
126 unsigned int nvml_set_app_mem_clock; /* The memory clock we set */
128 nvmlDevice_t nvml_device_id; /* NVML device id */
129 nvmlEnableState_t nvml_is_restricted; /* Status of application clocks permission */
130 #endif /* HAVE_NVML */
134 /*! Launches asynchronous host to device memory copy in stream 0. */
135 int cu_copy_D2H(void * /*h_dest*/, void * /*d_src*/, size_t /*bytes*/);
137 /*! Launches asynchronous host to device memory copy in stream s. */
138 int cu_copy_D2H_async(void * /*h_dest*/, void * /*d_src*/, size_t /*bytes*/, cudaStream_t /*s = 0*/);
140 /*! Launches synchronous host to device memory copy. */
141 int cu_copy_H2D(void * /*d_dest*/, void * /*h_src*/, size_t /*bytes*/);
143 /*! Launches asynchronous host to device memory copy in stream s. */
144 int cu_copy_H2D_async(void * /*d_dest*/, void * /*h_src*/, size_t /*bytes*/, cudaStream_t /*s = 0*/);
146 /*! Allocates device memory and launches synchronous host to device memory copy. */
147 int cu_copy_H2D_alloc(void ** /*d_dest*/, void * /*h_src*/, size_t /*bytes*/);
149 /*! Frees device memory and resets the size and allocation size to -1. */
150 void cu_free_buffered(void *d_ptr, int *n = NULL, int *nalloc = NULL);
152 /*! Reallocates the device memory and copies data from the host. */
153 void cu_realloc_buffered(void **d_dest, void *h_src,
155 int *curr_size, int *curr_alloc_size,
160 /*! Waits for event e to complete, */
161 int cu_wait_event(cudaEvent_t /*e*/);
163 /*! Calculates and returns the time elapsed between event start and end. */
164 float cu_event_elapsed(cudaEvent_t /*start*/, cudaEvent_t /*end*/);
166 /*! Waits for event end to complete and calculates the time between start and end. */
167 int cu_wait_event_time(cudaEvent_t /*end*/, cudaEvent_t /*begin*/, float * /*time*/);