Function evalNodes

src/backend/oneapi/jit.cpp:388–631

template<typename T>
void evalNodes(vector<Param<T>>& outputs, const vector<Node*>& output_nodes) {
    if (outputs.empty()) return;
    Node_map_t nodes;
    vector<Node*> full_nodes;
    vector<Node_ids> full_ids;
    vector<int> output_ids;
    vector<Node_ptr> node_clones;

    bool is_linear{true};
    dim_t numOutElems{1};
    assert(outputs.size() == output_nodes.size());
    KParam& out_info{outputs[0].info};
    dim_t* outDims{out_info.dims};
    dim_t* outStrides{out_info.strides};
    // unsigned nrInputs{0};

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

    for (Node* node : output_nodes) {
        const int id{node->getNodesMap(nodes, full_nodes, full_ids)};
        output_ids.push_back(id);
    }

    node_clones.clear();
    node_clones.reserve(full_nodes.size());
    for (Node* node : full_nodes) { node_clones.emplace_back(node->clone()); }

    bool moddimsFound{false};
    for (const Node* node : full_nodes) {
        is_linear &= node->isLinear(outDims);
        moddimsFound |= (node->getOp() == af_moddims_t);
        // if (node->isBuffer()) { ++nrInputs; }
    }

    bool emptyColumnsFound{false};
    if (is_linear) {
        outDims[0]    = numOutElems;
        outDims[1]    = 1;
        outDims[2]    = 1;
        outDims[3]    = 1;
        outStrides[0] = 1;
        outStrides[1] = numOutElems;
        outStrides[2] = numOutElems;
        outStrides[3] = numOutElems;
        ndims         = 1;
    } else {
        emptyColumnsFound = ndims > (outDims[0] == 1   ? 1
                                     : outDims[1] == 1 ? 2
                                     : outDims[2] == 1 ? 3