1 // Copyright (c) 2017-2018, Lawrence Livermore National Security, LLC. 2 // Produced at the Lawrence Livermore National Laboratory. LLNL-CODE-734707. 3 // All Rights reserved. See files LICENSE and NOTICE for details. 4 // 5 // This file is part of CEED, a collection of benchmarks, miniapps, software 6 // libraries and APIs for efficient high-order finite element and spectral 7 // element discretizations for exascale applications. For more information and 8 // source code availability see http://github.com/ceed. 9 // 10 // The CEED research is supported by the Exascale Computing Project 17-SC-20-SC, 11 // a collaborative effort of two U.S. Department of Energy organizations (Office 12 // of Science and the National Nuclear Security Administration) responsible for 13 // the planning and preparation of a capable exascale ecosystem, including 14 // software, applications, hardware, advanced system engineering and early 15 // testbed platforms, in support of the nation's exascale computing imperative. 16 17 #include <ceed/ceed.h> 18 #include <ceed/backend.h> 19 #include <sstream> 20 #include <stdarg.h> 21 #include <string.h> 22 #include <hip/hiprtc.h> 23 #include "ceed-hip.h" 24 #include "ceed-hip-compile.h" 25 26 #define CeedChk_hiprtc(ceed, x) \ 27 do { \ 28 hiprtcResult result = static_cast<hiprtcResult>(x); \ 29 if (result != HIPRTC_SUCCESS) \ 30 return CeedError((ceed), CEED_ERROR_BACKEND, hiprtcGetErrorString(result)); \ 31 } while (0) 32 33 //------------------------------------------------------------------------------ 34 // Compile HIP kernel 35 //------------------------------------------------------------------------------ 36 int CeedCompileHip(Ceed ceed, const char *source, hipModule_t *module, 37 const CeedInt numopts, ...) { 38 int ierr; 39 hipFree(0); // Make sure a Context exists for hiprtc 40 hiprtcProgram prog; 41 42 // Add hip runtime include to string for generation 43 std::ostringstream code; 44 code << "\n#include <hip/hip_runtime.h>\n"; 45 46 // Macro definitions 47 // Get kernel specific options, such as kernel constants 48 const int optslen = 32; 49 const int optssize = 2; 50 const char *opts[optssize]; 51 if (numopts > 0) { 52 va_list args; 53 va_start(args, numopts); 54 char *name; 55 int val; 56 for (int i = 0; i < numopts; i++) { 57 name = va_arg(args, char *); 58 val = va_arg(args, int); 59 code << "#define " << name << " " << val << "\n"; 60 } 61 va_end(args); 62 } 63 64 // Standard backend options 65 code << "#define CeedScalar double\n"; 66 code << "#define CeedInt int\n"; 67 code << "#define CEED_ERROR_SUCCESS 0\n\n"; 68 69 // Non-macro options 70 opts[0] = "-default-device"; 71 struct hipDeviceProp_t prop; 72 Ceed_Hip *ceed_data; 73 ierr = CeedGetData(ceed, (void **)&ceed_data); CeedChkBackend(ierr); 74 CeedChk_Hip(ceed, hipGetDeviceProperties(&prop, ceed_data->deviceId)); 75 char buff[optslen]; 76 std::string archArg = "--gpu-architecture=" + std::string(prop.gcnArchName); 77 snprintf(buff, optslen, "%s", archArg.c_str()); 78 opts[1] = buff; 79 80 // Add string source argument provided in call 81 code << source; 82 83 // Create Program 84 CeedChk_hiprtc(ceed, hiprtcCreateProgram(&prog, code.str().c_str(), NULL, 0, NULL, NULL)); 85 86 // Compile kernel 87 hiprtcResult result = hiprtcCompileProgram(prog, optssize, opts); 88 if (result != HIPRTC_SUCCESS) { 89 size_t logsize; 90 CeedChk_hiprtc(ceed, hiprtcGetProgramLogSize(prog, &logsize)); 91 char *log; 92 ierr = CeedMalloc(logsize, &log); CeedChkBackend(ierr); 93 CeedChk_hiprtc(ceed, hiprtcGetProgramLog(prog, log)); 94 return CeedError(ceed, CEED_ERROR_BACKEND, "%s\n%s", hiprtcGetErrorString(result), log); 95 } 96 97 size_t ptxsize; 98 CeedChk_hiprtc(ceed, hiprtcGetCodeSize(prog, &ptxsize)); 99 char *ptx; 100 ierr = CeedMalloc(ptxsize, &ptx); CeedChkBackend(ierr); 101 CeedChk_hiprtc(ceed, hiprtcGetCode(prog, ptx)); 102 CeedChk_hiprtc(ceed, hiprtcDestroyProgram(&prog)); 103 104 CeedChk_Hip(ceed, hipModuleLoadData(module, ptx)); 105 ierr = CeedFree(&ptx); CeedChkBackend(ierr); 106 107 return CEED_ERROR_SUCCESS; 108 } 109 110 //------------------------------------------------------------------------------ 111 // Get HIP kernel 112 //------------------------------------------------------------------------------ 113 int CeedGetKernelHip(Ceed ceed, hipModule_t module, const char *name, 114 hipFunction_t *kernel) { 115 116 CeedChk_Hip(ceed, hipModuleGetFunction(kernel, module, name)); 117 return CEED_ERROR_SUCCESS; 118 } 119 120 //------------------------------------------------------------------------------ 121 // Run HIP kernel 122 //------------------------------------------------------------------------------ 123 int CeedRunKernelHip(Ceed ceed, hipFunction_t kernel, const int gridSize, 124 const int blockSize, void **args) { 125 CeedChk_Hip(ceed, hipModuleLaunchKernel(kernel, gridSize, 1, 1, blockSize, 1, 126 1, 0, NULL, args, NULL)); 127 return CEED_ERROR_SUCCESS; 128 } 129 130 //------------------------------------------------------------------------------ 131 // Run HIP kernel for spatial dimension 132 //------------------------------------------------------------------------------ 133 int CeedRunKernelDimHip(Ceed ceed, hipFunction_t kernel, const int gridSize, 134 const int blockSizeX, const int blockSizeY, 135 const int blockSizeZ, void **args) { 136 CeedChk_Hip(ceed, hipModuleLaunchKernel(kernel, gridSize, 1, 1, 137 blockSizeX, blockSizeY, blockSizeZ, 138 0, NULL, args, NULL)); 139 return CEED_ERROR_SUCCESS; 140 } 141 142 //------------------------------------------------------------------------------ 143 // Run HIP kernel for spatial dimension with shared memory 144 //------------------------------------------------------------------------------ 145 int CeedRunKernelDimSharedHip(Ceed ceed, hipFunction_t kernel, const int gridSize, 146 const int blockSizeX, const int blockSizeY, 147 const int blockSizeZ, const int sharedMemSize, 148 void **args) { 149 CeedChk_Hip(ceed, hipModuleLaunchKernel(kernel, gridSize, 1, 1, 150 blockSizeX, blockSizeY, blockSizeZ, 151 sharedMemSize, NULL, args, NULL)); 152 return CEED_ERROR_SUCCESS; 153 } 154