2 * This file is part of the GROMACS molecular simulation package.
4 * Copyright (c) 2012,2013,2014,2015,2016 by the GROMACS development team.
5 * Copyright (c) 2017,2018,2019,2020,2021, by the GROMACS development team, led by
6 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
7 * and including many others, as listed in the AUTHORS file in the
8 * top-level source directory and at http://www.gromacs.org.
10 * GROMACS is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public License
12 * as published by the Free Software Foundation; either version 2.1
13 * of the License, or (at your option) any later version.
15 * GROMACS is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with GROMACS; if not, see
22 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
23 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 * If you want to redistribute modifications to GROMACS, please
26 * consider that scientific software is very special. Version
27 * control is crucial - bugs must be traceable. We will be happy to
28 * consider code for inclusion in the official distribution, but
29 * derived work must not be called official GROMACS. Details are found
30 * in the README & COPYING files - if they are missing, get the
31 * official version at http://www.gromacs.org.
33 * To help us fund GROMACS development, we humbly ask that you cite
34 * the research papers on the package. Check out http://www.gromacs.org.
37 * \brief Define infrastructure for OpenCL JIT compilation for Gromacs
39 * \author Dimitrios Karkoulis <dimitris.karkoulis@gmail.com>
40 * \author Anca Hamuraru <anca@streamcomputing.eu>
41 * \author Teemu Virolainen <teemu@streamcomputing.eu>
42 * \author Mark Abraham <mark.j.abraham@gmail.com>
47 #include "ocl_compiler.h"
57 #include "gromacs/gpu_utils/oclutils.h"
58 #include "gromacs/utility/cstringutil.h"
59 #include "gromacs/utility/exceptions.h"
60 #include "gromacs/utility/gmxassert.h"
61 #include "gromacs/utility/path.h"
62 #include "gromacs/utility/programcontext.h"
63 #include "gromacs/utility/smalloc.h"
64 #include "gromacs/utility/stringutil.h"
65 #include "gromacs/utility/textreader.h"
66 #include "gromacs/utility/unique_cptr.h"
68 #include "ocl_caching.h"
75 /*! \brief True if OpenCL binary caching is enabled.
77 * Currently caching is disabled by default unless the env var override
78 * is used until we resolve concurrency issues. */
79 static bool useBuildCache = getenv("GMX_OCL_GENCACHE") != nullptr;
81 /*! \brief Handles writing the OpenCL JIT compilation log to \c fplog.
83 * If \c fplog is non-null and either the \c GMX_OCL_DUMP_LOG environment
84 * variable is set or the compilation failed, then the OpenCL
85 * compilation log is written.
87 * \param fplog Open file pointer to log file
88 * \param program OpenCL program that was compiled
89 * \param deviceId Id of the device for which compilation took place
90 * \param kernelFilename File name containing the kernel
91 * \param preprocessorOptions String containing the preprocessor command-line options used for the
93 * \param buildFailed Whether the OpenCL build succeeded
95 * \throws std::bad_alloc if out of memory */
96 static void writeOclBuildLog(FILE* fplog,
98 cl_device_id deviceId,
99 const std::string& kernelFilename,
100 const std::string& preprocessorOptions,
103 bool writeOutput = ((fplog != nullptr) && (buildFailed || (getenv("GMX_OCL_DUMP_LOG") != nullptr)));
110 // Get build log string size
113 clGetProgramBuildInfo(program, deviceId, CL_PROGRAM_BUILD_LOG, 0, nullptr, &buildLogSize);
114 if (cl_error != CL_SUCCESS)
116 GMX_THROW(InternalError("Could not get OpenCL program build log size, error was "
117 + ocl_get_error_string(cl_error)));
120 char* buildLog = nullptr;
121 unique_cptr<char> buildLogGuard;
122 if (buildLogSize != 0)
124 /* Allocate memory to fit the build log,
125 it can be very large in case of errors */
126 snew(buildLog, buildLogSize);
127 buildLogGuard.reset(buildLog);
129 /* Get the actual compilation log */
130 cl_error = clGetProgramBuildInfo(
131 program, deviceId, CL_PROGRAM_BUILD_LOG, buildLogSize, buildLog, nullptr);
132 if (cl_error != CL_SUCCESS)
134 GMX_THROW(InternalError("Could not get OpenCL program build log, error was "
135 + ocl_get_error_string(cl_error)));
142 message += "Compilation of source file " + kernelFilename + " failed!\n";
146 message += "Compilation of source file " + kernelFilename + " was successful!\n";
148 message += "-- Used build options: " + preprocessorOptions + "\n";
149 message += "--------------LOG START---------------\n";
151 message += "---------------LOG END----------------\n";
154 fputs(message.c_str(), fplog);
157 /*! \brief Construct compiler options string
159 * \param deviceVendor Device vendor. Used to automatically enable some
160 * vendor-specific options.
161 * \return The string with the compiler options
163 static std::string selectCompilerOptions(DeviceVendor deviceVendor)
165 std::string compilerOptions;
167 if (getenv("GMX_OCL_NOOPT"))
169 compilerOptions += " -cl-opt-disable";
172 /* Fastmath improves performance on all supported arch,
173 * but is tends to cause problems on Intel (Issue #3898) */
174 if ((deviceVendor != DeviceVendor::Intel) && (getenv("GMX_OCL_DISABLE_FASTMATH") == nullptr))
176 compilerOptions += " -cl-fast-relaxed-math";
178 // Hint to the compiler that it can flush denorms to zero.
179 // In CUDA this is triggered by the -use_fast_math flag, equivalent with
180 // -cl-fast-relaxed-math, hence the inclusion on the conditional block.
181 compilerOptions += " -cl-denorms-are-zero";
184 if ((deviceVendor == DeviceVendor::Nvidia) && getenv("GMX_OCL_VERBOSE"))
186 compilerOptions += " -cl-nv-verbose";
189 if ((deviceVendor == DeviceVendor::Amd) && getenv("GMX_OCL_DUMP_INTERM_FILES"))
191 /* To dump OpenCL build intermediate files, caching must be off */
194 compilerOptions += " -save-temps";
198 if (getenv("GMX_OCL_DEBUG"))
200 compilerOptions += " -g";
203 return compilerOptions;
206 /*! \brief Get the path to the folder storing an OpenCL source file.
208 * By default, this function constructs the full path to the OpenCL from
209 * the known location of the binary that is running, so that we handle
210 * both in-source and installed builds. The user can override this
211 * behavior by defining GMX_OCL_FILE_PATH environment variable.
213 * \param[in] sourceRelativePath Relative path to the kernel or other file in the source tree,
214 * from src, e.g. "gromacs/mdlib/nbnxn_ocl" for NB kernels.
215 * \return OS-normalized path string to the folder storing OpenCL source file
217 * \throws std::bad_alloc if out of memory.
218 * FileIOError if GMX_OCL_FILE_PATH does not specify a readable path
220 static std::string getSourceRootPath(const std::string& sourceRelativePath)
222 std::string sourceRootPath;
223 /* Use GMX_OCL_FILE_PATH if the user has defined it */
224 const char* gmxOclFilePath = getenv("GMX_OCL_FILE_PATH");
226 if (gmxOclFilePath == nullptr)
228 /* Normal way of getting ocl_root_dir. First get the right
229 root path from the path to the binary that is running. */
230 InstallationPrefixInfo info = getProgramContext().installationPrefix();
231 std::string dataPathSuffix = (info.bSourceLayout ? "src" : GMX_INSTALL_OCLDIR);
232 sourceRootPath = Path::join(info.path, dataPathSuffix, sourceRelativePath);
236 if (!Directory::exists(gmxOclFilePath))
238 GMX_THROW(FileIOError(
239 formatString("GMX_OCL_FILE_PATH must point to the directory where OpenCL"
240 "kernels are found, but '%s' does not exist",
243 sourceRootPath = Path::join(gmxOclFilePath, sourceRelativePath);
246 // Make sure we return an OS-correct path format
247 return Path::normalize(sourceRootPath);
250 size_t getKernelWarpSize(cl_kernel kernel, cl_device_id deviceId)
253 cl_int cl_error = clGetKernelWorkGroupInfo(
254 kernel, deviceId, CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, sizeof(warpSize), &warpSize, nullptr);
255 if (cl_error != CL_SUCCESS)
257 GMX_THROW(InternalError("Could not query OpenCL preferred workgroup size, error was "
258 + ocl_get_error_string(cl_error)));
262 GMX_THROW(InternalError(formatString("Invalid OpenCL warp size encountered")));
267 size_t getDeviceWarpSize(cl_context context, cl_device_id deviceId)
270 const char* warpSizeKernel =
271 "__kernel void test(__global int* test){test[get_local_id(0)] = 0;}";
272 cl_program program = clCreateProgramWithSource(context, 1, &warpSizeKernel, nullptr, &cl_error);
273 if (cl_error != CL_SUCCESS)
275 GMX_THROW(InternalError("Could not create OpenCL program to determine warp size, error was "
276 + ocl_get_error_string(cl_error)));
279 cl_error = clBuildProgram(program, 0, nullptr, nullptr, nullptr, nullptr);
280 if (cl_error != CL_SUCCESS)
282 GMX_THROW(InternalError("Could not build OpenCL program to determine warp size, error was "
283 + ocl_get_error_string(cl_error)));
286 cl_kernel kernel = clCreateKernel(program, "test", &cl_error);
287 if (cl_error != CL_SUCCESS)
289 GMX_THROW(InternalError("Could not create OpenCL kernel to determine warp size, error was "
290 + ocl_get_error_string(cl_error)));
293 size_t warpSize = getKernelWarpSize(kernel, deviceId);
295 cl_error = clReleaseKernel(kernel);
296 if (cl_error != CL_SUCCESS)
298 GMX_THROW(InternalError("Could not release OpenCL warp-size kernel, error was "
299 + ocl_get_error_string(cl_error)));
301 cl_error = clReleaseProgram(program);
302 if (cl_error != CL_SUCCESS)
304 GMX_THROW(InternalError("Could not release OpenCL warp-size program, error was "
305 + ocl_get_error_string(cl_error)));
311 /*! \brief Select a compilation-line define for a vendor-specific kernel choice from vendor id
313 * \param[in] deviceVendor Vendor id enumerator
315 * \return The appropriate compilation-line define
317 static std::string makeVendorFlavorChoice(DeviceVendor deviceVendor)
319 switch (deviceVendor)
321 case DeviceVendor::Amd: return "-D_AMD_SOURCE_";
322 case DeviceVendor::Nvidia: return "-D_NVIDIA_SOURCE_";
323 case DeviceVendor::Intel: return "-D_INTEL_SOURCE_";
328 /*! \brief Create include paths for kernel sources.
330 * All OpenCL kernel files are expected to be stored in one single folder.
332 * \throws std::bad_alloc if out of memory.
334 static std::string makeKernelIncludePathOption(const std::string& unescapedKernelRootPath)
336 std::string includePathOption;
338 /* Apple does not seem to accept the quoted include paths other
339 * OpenCL implementations are happy with. Since the standard still says
340 * it should be quoted, we handle Apple as a special case.
343 includePathOption += "-I";
345 // Prepend all the spaces with a backslash
346 for (std::string::size_type i = 0; i < unescapedKernelRootPath.length(); i++)
348 if (unescapedKernelRootPath[i] == ' ')
350 includePathOption.push_back('\\');
352 includePathOption.push_back(unescapedKernelRootPath[i]);
355 includePathOption += "-I\"" + unescapedKernelRootPath + "\"";
358 return includePathOption;
361 /*! \brief Replace duplicated spaces with a single one in string
363 * Only the first character will be kept for multiple adjacent characters that
364 * are both identical and where the first one returns true for isspace().
366 * \param str String that will be modified.
368 static void removeExtraSpaces(std::string* str)
370 GMX_RELEASE_ASSERT(str != nullptr, "A pointer to an actual string must be provided");
371 std::string::iterator newEnd = std::unique(
372 str->begin(), str->end(), [=](char a, char b) { return isspace(a) != 0 && (a == b); });
373 str->erase(newEnd, str->end());
376 /*! \brief Builds a string with build options for the OpenCL kernels
378 * \throws std::bad_alloc if out of memory. */
379 static std::string makePreprocessorOptions(const std::string& kernelRootPath,
380 const std::string& includeRootPath,
382 DeviceVendor deviceVendor,
383 const std::string& extraDefines)
385 std::string preprocessorOptions;
387 /* Compose the complete build options */
388 preprocessorOptions = formatString("-DWARP_SIZE_TEST=%d", static_cast<int>(warpSize));
389 preprocessorOptions += ' ';
390 preprocessorOptions += makeVendorFlavorChoice(deviceVendor);
391 preprocessorOptions += ' ';
392 preprocessorOptions += extraDefines;
393 preprocessorOptions += ' ';
394 preprocessorOptions += selectCompilerOptions(deviceVendor);
395 preprocessorOptions += ' ';
396 preprocessorOptions += makeKernelIncludePathOption(kernelRootPath);
397 preprocessorOptions += ' ';
398 preprocessorOptions += makeKernelIncludePathOption(includeRootPath);
400 // Mac OS (and maybe some other implementations) does not accept double spaces in options
401 removeExtraSpaces(&preprocessorOptions);
403 return preprocessorOptions;
406 cl_program compileProgram(FILE* fplog,
407 const std::string& kernelRelativePath,
408 const std::string& kernelBaseFilename,
409 const std::string& extraDefines,
411 cl_device_id deviceId,
412 DeviceVendor deviceVendor)
415 // Let the kernel find include files from its module.
416 std::string kernelRootPath = getSourceRootPath(kernelRelativePath);
417 // Let the kernel find include files from other modules.
418 std::string rootPath = getSourceRootPath("");
420 GMX_RELEASE_ASSERT(fplog != nullptr, "Need a valid log file for building OpenCL programs");
422 /* Load OpenCL source files */
423 std::string kernelFilename = Path::join(kernelRootPath, kernelBaseFilename);
425 /* Make the build options */
426 std::string preprocessorOptions = makePreprocessorOptions(
427 kernelRootPath, rootPath, getDeviceWarpSize(context, deviceId), deviceVendor, extraDefines);
429 bool buildCacheWasRead = false;
431 std::string cacheFilename;
434 cacheFilename = makeBinaryCacheFilename(kernelBaseFilename, deviceId);
437 /* Create OpenCL program */
438 cl_program program = nullptr;
441 if (File::exists(cacheFilename, File::returnFalseOnError))
443 /* Check if there's a valid cache available */
446 program = makeProgramFromCache(cacheFilename, context, deviceId);
447 buildCacheWasRead = true;
449 catch (FileIOError& e)
451 // Failing to read from the cache is not a critical error
452 formatExceptionMessageToFile(fplog, e);
455 "OpenCL binary cache file %s is present, will load kernels.\n",
456 cacheFilename.c_str());
461 "No OpenCL binary cache file was present for %s, so will compile kernels "
463 kernelBaseFilename.c_str());
466 if (program == nullptr)
468 // Compile OpenCL program from source
469 std::string kernelSource = TextReader::readFileToString(kernelFilename);
470 if (kernelSource.empty())
472 GMX_THROW(FileIOError("Error loading OpenCL code " + kernelFilename));
474 const char* kernelSourcePtr = kernelSource.c_str();
475 size_t kernelSourceSize = kernelSource.size();
476 /* Create program from source code */
477 program = clCreateProgramWithSource(context, 1, &kernelSourcePtr, &kernelSourceSize, &cl_error);
478 if (cl_error != CL_SUCCESS)
480 GMX_THROW(InternalError("Could not create OpenCL program, error was "
481 + ocl_get_error_string(cl_error)));
485 /* Build the OpenCL program, keeping the status to potentially
486 write to the simulation log file. */
488 clBuildProgram(program, 0, nullptr, preprocessorOptions.c_str(), nullptr, nullptr);
490 /* Write log first, and then throw exception that the user know what is
491 the issue even if the build fails. */
492 writeOclBuildLog(fplog, program, deviceId, kernelFilename, preprocessorOptions, buildStatus != CL_SUCCESS);
494 if (buildStatus != CL_SUCCESS)
496 GMX_THROW(InternalError("Could not build OpenCL program, error was "
497 + ocl_get_error_string(buildStatus)));
502 if (!buildCacheWasRead)
504 /* If OpenCL caching is ON, but the current cache is not
505 valid => update it */
508 writeBinaryToCache(program, cacheFilename);
510 catch (GromacsException& e)
512 // Failing to write the cache is not a critical error
513 formatExceptionMessageToFile(fplog, e);
517 if ((deviceVendor == DeviceVendor::Nvidia) && getenv("GMX_OCL_DUMP_INTERM_FILES"))
519 /* If dumping intermediate files has been requested and this is an NVIDIA card
520 => write PTX to file */
523 cl_error = clGetDeviceInfo(deviceId, CL_DEVICE_NAME, sizeof(buffer), buffer, nullptr);
524 if (cl_error != CL_SUCCESS)
526 GMX_THROW(InternalError("Could not get OpenCL device info, error was "
527 + ocl_get_error_string(cl_error)));
529 std::string ptxFilename = buffer;
530 ptxFilename += ".ptx";
534 writeBinaryToCache(program, ptxFilename);
536 catch (GromacsException& e)
538 // Failing to write the cache is not a critical error
539 formatExceptionMessageToFile(fplog, e);