Function loadModuleFromDisk

src/backend/opencl/compile_module.cpp:223–281

}

Module loadModuleFromDisk(const int device, const string &moduleKey,
                          const bool isJIT) {
    const string &cacheDirectory = getCacheDirectory();
    if (cacheDirectory.empty()) return Module{};

    auto &dev              = arrayfire::opencl::getDevice(device);
    const string cacheFile = cacheDirectory + AF_PATH_SEPARATOR +
                             opencl::getKernelCacheFilename(device, moduleKey);
    Program program;
    Module retVal{};
    try {
        std::ifstream in(cacheFile, std::ios::binary);
        if (!in.is_open()) {
            AF_TRACE("{{{:<20} : Unable to open {} for {}}}", moduleKey,
                     cacheFile, dev.getInfo<CL_DEVICE_NAME>());
            removeFile(cacheFile);
            return retVal;
        }
        in.exceptions(std::ios::failbit | std::ios::badbit);

        // TODO Handle cases where program objects are created from contexts
        // having multiple devices
        size_t clbinHash = 0;
        in.read(reinterpret_cast<char *>(&clbinHash), sizeof(clbinHash));
        size_t clbinSize = 0;
        in.read(reinterpret_cast<char *>(&clbinSize), sizeof(clbinSize));
        vector<unsigned char> clbin(clbinSize);
        in.read(reinterpret_cast<char *>(clbin.data()), clbinSize);
        in.close();

        const size_t recomputedHash =
            deterministicHash(clbin.data(), clbinSize);
        if (recomputedHash != clbinHash) {
            AF_TRACE(
                "{{{:<20} : Corrupt binary({}) found on disk for {}, removed}}",
                moduleKey, cacheFile, dev.getInfo<CL_DEVICE_NAME>());
            removeFile(cacheFile);
            return retVal;
        }
        program = Program(arrayfire::opencl::getContext(), {dev}, {clbin});
        program.build();

        AF_TRACE("{{{:<20} : loaded from {} for {} }}", moduleKey, cacheFile,
                 dev.getInfo<CL_DEVICE_NAME>());
        retVal.set(program);
    } catch (const std::ios_base::failure &e) {
        AF_TRACE("{{{:<20} : IO failure while loading {} for {}; {}}}",
                 moduleKey, cacheFile, dev.getInfo<CL_DEVICE_NAME>(), e.what());
        removeFile(cacheFile);
    } catch (const cl::Error &e) {
        AF_TRACE(
            "{{{:<20} : Loading OpenCL binary({}) failed for {}; {}, Build "
            "Log: {}}}",
            moduleKey, cacheFile, dev.getInfo<CL_DEVICE_NAME>(), e.what(),
            opencl::getProgramBuildLog(program));
        removeFile(cacheFile);
    }
    return retVal;