Function compileModule

src/backend/opencl/compile_module.cpp:156–221

namespace common {

Module compileModule(const string &moduleKey, span<const string> sources,
                     span<const string> options, span<const string> kInstances,
                     const bool isJIT) {
    UNUSED(kInstances);
    UNUSED(isJIT);

    auto compileBegin = high_resolution_clock::now();
    auto program      = arrayfire::opencl::buildProgram(sources, options);
    auto compileEnd   = high_resolution_clock::now();

#ifdef AF_CACHE_KERNELS_TO_DISK
    const int device             = arrayfire::opencl::getActiveDeviceId();
    const string &cacheDirectory = getCacheDirectory();
    if (!cacheDirectory.empty()) {
        const string cacheFile =
            cacheDirectory + AF_PATH_SEPARATOR +
            opencl::getKernelCacheFilename(device, moduleKey);
        const string tempFile =
            cacheDirectory + AF_PATH_SEPARATOR + makeTempFilename();
        try {
            auto binaries = program.getInfo<CL_PROGRAM_BINARIES>();

            // TODO Handle cases where program objects are created from contexts
            // having multiple devices
            const size_t clbinSize = binaries[0].size();
            const char *clbin =
                reinterpret_cast<const char *>(binaries[0].data());
            const size_t clbinHash = deterministicHash(clbin, clbinSize);

            // write module hash and binary data to file
            ofstream out(tempFile, std::ios::binary);

            out.write(reinterpret_cast<const char *>(&clbinHash),
                      sizeof(clbinHash));
            out.write(reinterpret_cast<const char *>(&clbinSize),
                      sizeof(clbinSize));
            out.write(static_cast<const char *>(clbin), clbinSize);
            out.close();

            // try to rename temporary file into final cache file, if this fails
            // this means another thread has finished compiling this kernel
            // before the current thread.
            if (!renameFile(tempFile, cacheFile)) { removeFile(tempFile); }
        } catch (const cl::Error &e) {
            AF_TRACE(
                "{{{:<20} : Failed to fetch opencl binary for {}, {}}}",
                moduleKey,
                arrayfire::opencl::getDevice(device).getInfo<CL_DEVICE_NAME>(),
                e.what());
        } catch (const std::ios_base::failure &e) {
            AF_TRACE(
                "{{{:<20} : Failed writing binary to {} for {}, {}}}",
                moduleKey, cacheFile,
                arrayfire::opencl::getDevice(device).getInfo<CL_DEVICE_NAME>(),
                e.what());
        }
    }
#endif