Function evalNodes

src/backend/opencl/jit.cpp:309–490

}

void evalNodes(vector<Param>& outputs, const vector<Node*>& output_nodes) {
    const unsigned nrOutputs{static_cast<unsigned>(outputs.size())};
    if (nrOutputs == 0) { return; }
    assert(outputs.size() == output_nodes.size());
    KParam& out_info{outputs[0].info};
    dim_t* outDims{out_info.dims};
    dim_t* outStrides{out_info.strides};
#ifndef NDEBUG
    for_each(begin(outputs)++, end(outputs),
             [outDims, outStrides](Param& output) {
                 assert(equal(output.info.dims, output.info.dims + AF_MAX_DIMS,
                              outDims) &&
                        equal(output.info.strides,
                              output.info.strides + AF_MAX_DIMS, outStrides));
             });
#endif

    dim_t ndims{outDims[3] > 1   ? 4
                : outDims[2] > 1 ? 3
                : outDims[1] > 1 ? 2
                : outDims[0] > 0 ? 1
                                 : 0};
    bool is_linear{true};
    dim_t numOutElems{1};
    for (dim_t dim{0}; dim < ndims; ++dim) {
        is_linear &= (numOutElems == outStrides[dim]);
        numOutElems *= outDims[dim];
    }
    if (numOutElems == 0) { return; }

    // Use thread local to reuse the memory every time you are here.
    thread_local Node_map_t nodes;
    thread_local vector<Node*> full_nodes;
    thread_local vector<Node_ids> full_ids;
    thread_local vector<int> output_ids;

    // Reserve some space to improve performance at smaller sizes
    constexpr size_t CAP{1024};
    if (full_nodes.capacity() < CAP) {
        nodes.reserve(CAP);
        output_ids.reserve(10);
        full_nodes.reserve(CAP);
        full_ids.reserve(CAP);
    }

    const af::dtype outputType{output_nodes[0]->getType()};
    const size_t outputSizeofType{size_of(outputType)};
    for (Node* node : output_nodes) {
        assert(node->getType() == outputType);
        const int id{node->getNodesMap(nodes, full_nodes, full_ids)};
        output_ids.push_back(id);
    }

    const size_t outputSize{numOutElems * outputSizeofType * nrOutputs};
    size_t inputSize{0};
    unsigned nrInputs{0};
    bool moddimsFound{false};
    for (const Node* node : full_nodes) {