Function evalNodes

src/backend/cuda/jit.cpp:350–539

template<typename T>
void evalNodes(vector<Param<T>>& outputs, const vector<Node*>& output_nodes) {
    const unsigned nrOutputs{static_cast<unsigned>(output_nodes.size())};
    if (nrOutputs == 0) { return; }
    assert(outputs.size() == output_nodes.size());
    dim_t* outDims{outputs[0].dims};
    dim_t* outStrides{outputs[0].strides};
#ifndef NDEBUG
    for_each(
        begin(outputs)++, end(outputs),
        [outDims, outStrides](Param<T>& output) {
            assert(equal(output.dims, output.dims + AF_MAX_DIMS, outDims) &&
                   equal(output.strides, output.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;

    try {
        // 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);
        }

        size_t inputSize{0};
        unsigned nrInputs{0};
        bool moddimsFound{false};