2 * This file is part of the GROMACS molecular simulation package.
4 * Copyright (c) 2018,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.
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.
38 * Implements PmeGpuProgramImpl, which stores permanent PME GPU context-derived data,
39 * such as (compiled) kernel handles.
41 * \author Aleksei Iupinov <a.yupinov@gmail.com>
42 * \ingroup module_ewald
46 #include "gromacs/gpu_utils/gmxopencl.h"
47 #include "gromacs/gpu_utils/ocl_compiler.h"
48 #include "gromacs/utility/stringutil.h"
50 #include "pme_gpu_constants.h"
51 #include "pme_gpu_internal.h" // for GridOrdering enum
52 #include "pme_gpu_program_impl.h"
53 #include "pme_gpu_types_host.h"
56 PmeGpuProgramImpl::PmeGpuProgramImpl(const DeviceContext
& deviceContext
) :
57 deviceContext_(deviceContext
)
59 const DeviceInformation
& deviceInfo
= deviceContext
.deviceInfo();
61 warpSize_
= gmx::ocl::getDeviceWarpSize(deviceContext_
.context(), deviceInfo
.oclDeviceId
);
62 // TODO: for Intel ideally we'd want to set these based on the compiler warp size
63 // but given that we've done no tuning for Intel iGPU, this is as good as anything.
64 spreadWorkGroupSize
= std::min(c_spreadMaxWarpsPerBlock
* warpSize_
, deviceInfo
.maxWorkGroupSize
);
65 solveMaxWorkGroupSize
= std::min(c_solveMaxWarpsPerBlock
* warpSize_
, deviceInfo
.maxWorkGroupSize
);
66 gatherWorkGroupSize
= std::min(c_gatherMaxWarpsPerBlock
* warpSize_
, deviceInfo
.maxWorkGroupSize
);
68 compileKernels(deviceInfo
);
71 PmeGpuProgramImpl::~PmeGpuProgramImpl()
73 // TODO: log releasing errors
74 cl_int gmx_used_in_debug stat
= 0;
75 stat
|= clReleaseKernel(splineAndSpreadKernel
);
76 stat
|= clReleaseKernel(splineKernel
);
77 stat
|= clReleaseKernel(spreadKernel
);
78 stat
|= clReleaseKernel(gatherKernel
);
79 stat
|= clReleaseKernel(solveXYZKernel
);
80 stat
|= clReleaseKernel(solveXYZEnergyKernel
);
81 stat
|= clReleaseKernel(solveYZXKernel
);
82 stat
|= clReleaseKernel(solveYZXEnergyKernel
);
83 GMX_ASSERT(stat
== CL_SUCCESS
,
84 gmx::formatString("Failed to release PME OpenCL resources %d: %s", stat
,
85 ocl_get_error_string(stat
).c_str())
89 /*! \brief Ensure that spread/gather kernels have been compiled to a suitable warp size
91 * On Intel the exec width/warp is decided at compile-time and can be
92 * smaller than the minimum order^2 required in spread/gather ATM which
93 * we need to check for.
95 * Due to the one thread per atom and order=4 implementation
96 * constraints, order^2 threads should execute without synchronization
99 static void checkRequiredWarpSize(cl_kernel kernel
, const char* kernelName
, const DeviceInformation
& deviceInfo
)
101 if (deviceInfo
.deviceVendor
== DeviceVendor::Intel
)
103 int kernelWarpSize
= gmx::ocl::getKernelWarpSize(kernel
, deviceInfo
.oclDeviceId
);
104 const int minKernelWarpSize
= c_pmeGpuOrder
* c_pmeGpuOrder
;
105 if (kernelWarpSize
< minKernelWarpSize
)
107 const std::string errorString
= gmx::formatString(
108 "PME OpenCL kernels require >=%d execution width, but the %s kernel "
109 "has been compiled for the device %s to a %d width and therefore it can not "
110 "execute correctly.",
111 minKernelWarpSize
, kernelName
, deviceInfo
.device_name
, kernelWarpSize
);
112 GMX_THROW(gmx::InternalError(errorString
));
117 void PmeGpuProgramImpl::compileKernels(const DeviceInformation
& deviceInfo
)
119 // We might consider storing program as a member variable if it's needed later
120 cl_program program
= nullptr;
121 /* Need to catch std::bad_alloc here and during compilation string handling. */
124 /* Here we pass macros and static const int variables defined in include
125 * files outside as macros, to avoid including those files
126 * in the JIT compilation that happens at runtime.
128 const std::string commonDefines
= gmx::formatString(
131 "-DthreadsPerAtom=%d "
132 // forwarding from pme_grid.h, used for spline computation table sizes only
133 "-Dc_pmeMaxUnitcellShift=%f "
134 // forwarding PME behavior constants from pme_gpu_constants.h
135 "-Dc_skipNeutralAtoms=%d "
136 "-Dc_virialAndEnergyCount=%d "
137 // forwarding kernel work sizes
138 "-Dc_spreadWorkGroupSize=%zd "
139 "-Dc_solveMaxWorkGroupSize=%zd "
140 "-Dc_gatherWorkGroupSize=%zd "
141 // forwarding from vectypes.h
142 "-DDIM=%d -DXX=%d -DYY=%d -DZZ=%d "
143 // decomposition parameter placeholders
144 "-DwrapX=true -DwrapY=true ",
145 warpSize_
, c_pmeGpuOrder
, c_pmeGpuOrder
* c_pmeGpuOrder
,
146 static_cast<float>(c_pmeMaxUnitcellShift
), static_cast<int>(c_skipNeutralAtoms
),
147 c_virialAndEnergyCount
, spreadWorkGroupSize
, solveMaxWorkGroupSize
,
148 gatherWorkGroupSize
, DIM
, XX
, YY
, ZZ
);
151 /* TODO when we have a proper MPI-aware logging module,
152 the log output here should be written there */
153 program
= gmx::ocl::compileProgram(stderr
, "gromacs/ewald", "pme_program.cl",
154 commonDefines
, deviceContext_
.context(),
155 deviceInfo
.oclDeviceId
, deviceInfo
.deviceVendor
);
157 catch (gmx::GromacsException
& e
)
159 e
.prependContext(gmx::formatString("Failed to compile PME kernels for GPU #%s\n",
160 deviceInfo
.device_name
));
164 GMX_CATCH_ALL_AND_EXIT_WITH_FATAL_ERROR
;
166 constexpr cl_uint expectedKernelCount
= 9;
167 // Has to be equal or larger than the number of kernel instances.
168 // If it is not, CL_INVALID_VALUE will be thrown.
169 std::vector
<cl_kernel
> kernels(expectedKernelCount
, nullptr);
170 cl_uint actualKernelCount
= 0;
171 cl_int clError
= clCreateKernelsInProgram(program
, kernels
.size(), kernels
.data(), &actualKernelCount
);
172 if (clError
!= CL_SUCCESS
)
174 const std::string errorString
= gmx::formatString(
175 "Failed to create kernels for PME on GPU #%s:\n OpenCL error %d: %s",
176 deviceInfo
.device_name
, clError
, ocl_get_error_string(clError
).c_str());
177 GMX_THROW(gmx::InternalError(errorString
));
179 kernels
.resize(actualKernelCount
);
181 std::array
<char, 100> kernelNamesBuffer
;
182 for (const auto& kernel
: kernels
)
184 clError
= clGetKernelInfo(kernel
, CL_KERNEL_FUNCTION_NAME
, kernelNamesBuffer
.size(),
185 kernelNamesBuffer
.data(), nullptr);
186 if (clError
!= CL_SUCCESS
)
188 const std::string errorString
= gmx::formatString(
189 "Failed to parse kernels for PME on GPU #%s:\n OpenCL error %d: %s",
190 deviceInfo
.device_name
, clError
, ocl_get_error_string(clError
).c_str());
191 GMX_THROW(gmx::InternalError(errorString
));
194 // The names below must correspond to those defined in pme_program.cl
195 // TODO use a map with string key instead?
196 if (!strcmp(kernelNamesBuffer
.data(), "pmeSplineKernel"))
198 splineKernel
= kernel
;
200 else if (!strcmp(kernelNamesBuffer
.data(), "pmeSplineAndSpreadKernel"))
202 splineAndSpreadKernel
= kernel
;
203 splineAndSpreadKernelWriteSplines
= kernel
;
204 checkRequiredWarpSize(splineAndSpreadKernel
, kernelNamesBuffer
.data(), deviceInfo
);
206 else if (!strcmp(kernelNamesBuffer
.data(), "pmeSpreadKernel"))
208 spreadKernel
= kernel
;
209 checkRequiredWarpSize(spreadKernel
, kernelNamesBuffer
.data(), deviceInfo
);
211 else if (!strcmp(kernelNamesBuffer
.data(), "pmeGatherKernel"))
213 gatherKernel
= kernel
;
214 gatherKernelReadSplines
= kernel
;
215 checkRequiredWarpSize(gatherKernel
, kernelNamesBuffer
.data(), deviceInfo
);
217 else if (!strcmp(kernelNamesBuffer
.data(), "pmeSolveYZXKernel"))
219 solveYZXKernel
= kernel
;
221 else if (!strcmp(kernelNamesBuffer
.data(), "pmeSolveYZXEnergyKernel"))
223 solveYZXEnergyKernel
= kernel
;
225 else if (!strcmp(kernelNamesBuffer
.data(), "pmeSolveXYZKernel"))
227 solveXYZKernel
= kernel
;
229 else if (!strcmp(kernelNamesBuffer
.data(), "pmeSolveXYZEnergyKernel"))
231 solveXYZEnergyKernel
= kernel
;
234 clReleaseProgram(program
);