Function loadModuleFromDisk

src/backend/cuda/compile_module.cpp:413–495

}

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

    const string cacheFile = cacheDirectory + AF_PATH_SEPARATOR +
                             getKernelCacheFilename(device, moduleKey);

    CUmodule modOut = nullptr;
    Module retVal{nullptr};
    try {
        std::ifstream in(cacheFile, std::ios::binary);
        if (!in) {
            AF_TRACE("{{{:<20} : Unable to open {} for {}}}", moduleKey,
                     cacheFile, getDeviceProp(device).name);
            removeFile(cacheFile);  // Remove if exists
            return Module{nullptr};
        }
        in.exceptions(std::ios::failbit | std::ios::badbit);

        if (!isJIT) {
            size_t mangledListSize = 0;
            in.read(reinterpret_cast<char *>(&mangledListSize),
                    sizeof(mangledListSize));
            for (size_t i = 0; i < mangledListSize; ++i) {
                size_t keySize = 0;
                in.read(reinterpret_cast<char *>(&keySize), sizeof(keySize));
                vector<char> key;
                key.reserve(keySize);
                in.read(key.data(), keySize);

                size_t itemSize = 0;
                in.read(reinterpret_cast<char *>(&itemSize), sizeof(itemSize));
                vector<char> item;
                item.reserve(itemSize);
                in.read(item.data(), itemSize);

                retVal.add(string(key.data(), keySize),
                           string(item.data(), itemSize));
            }
        }

        size_t cubinHash = 0;
        in.read(reinterpret_cast<char *>(&cubinHash), sizeof(cubinHash));
        size_t cubinSize = 0;
        in.read(reinterpret_cast<char *>(&cubinSize), sizeof(cubinSize));
        vector<char> cubin(cubinSize);
        in.read(cubin.data(), cubinSize);
        in.close();

        // check CUBIN binary data has not been corrupted
        const size_t recomputedHash =
            deterministicHash(cubin.data(), cubinSize);
        if (recomputedHash != cubinHash) {
            AF_ERROR("Module on disk seems to be corrupted", AF_ERR_LOAD_SYM);
        }

        CU_CHECK(cuModuleLoadData(&modOut, cubin.data()));