Function getKernel

src/backend/opencl/jit.cpp:272–307

}

cl::Kernel getKernel(const vector<Node*>& output_nodes,
                     const vector<int>& output_ids,
                     const vector<Node*>& full_nodes,
                     const vector<Node_ids>& full_ids, const bool is_linear,
                     const bool loop0, const bool loop1, const bool loop3) {
    const string funcName{getFuncName(output_nodes, output_ids, full_nodes,
                                      full_ids, is_linear, loop0, loop1, false,
                                      loop3)};
    // A forward lookup in module cache helps avoid recompiling the JIT
    // source generated from identical JIT-trees.
    const auto entry{
        findModule(getActiveDeviceId(), deterministicHash(funcName))};

    if (!entry) {
        const string jitKer{getKernelString(funcName, full_nodes, full_ids,
                                            output_ids, is_linear, loop0, loop1,
                                            loop3)};
        saveKernel(funcName, jitKer, ".cl");

        const common::Source jitKer_cl_src{
            jitKer.data(), jitKer.size(),
            deterministicHash(jitKer.data(), jitKer.size())};
        const cl::Device device{getDevice()};
        vector<string> options;
        if (isDoubleSupported(device)) {
            options.emplace_back(DefineKey(USE_DOUBLE));
        }
        if (isHalfSupported(device)) {
            options.emplace_back(DefineKey(USE_HALF));
        }
        return common::getKernel(funcName, {{jit_cl_src, jitKer_cl_src}}, {},
                                 options, true)
            .get();
    }
    return common::getKernel(entry, funcName, true).get();
}

void evalNodes(vector<Param>& outputs, const vector<Node*>& output_nodes) {
    const unsigned nrOutputs{static_cast<unsigned>(outputs.size())};