Function evalMultiple

src/backend/cpu/kernel/Array.hpp:126–205

template<typename T>
void evalMultiple(std::vector<Param<T>> arrays,
                  std::vector<common::Node_ptr> output_nodes_) {
    using arrayfire::common::ModdimNode;
    using arrayfire::common::Node;
    using arrayfire::common::Node_map_t;
    using arrayfire::common::NodeIterator;

    af::dim4 odims = arrays[0].dims();
    af::dim4 ostrs = arrays[0].strides();

    Node_map_t node_index_map;
    std::vector<T *> ptrs;
    std::vector<common::Node *> full_nodes;
    std::vector<common::Node_ids> ids;

    int narrays = static_cast<int>(arrays.size());
    ptrs.reserve(narrays);
    for (int i = 0; i < narrays; i++) {
        ptrs.push_back(arrays[i].get());
        output_nodes_[i]->getNodesMap(node_index_map, full_nodes, ids);
    }
    auto node_clones = cloneNodes(full_nodes, ids);

    std::vector<TNode<T> *> cloned_output_nodes =
        getClonedOutputNodes<T>(node_index_map, node_clones, output_nodes_);
    propagateModdimsShape(node_clones);
    removeNodeOfOperation(node_clones, af_moddims_t);

    bool is_linear = true;
    for (auto &node : node_clones) { is_linear &= node->isLinear(odims.get()); }

    int num_nodes        = node_clones.size();
    int num_output_nodes = cloned_output_nodes.size();
    if (is_linear) {
        int num = arrays[0].dims().elements();
        int cnum =
            jit::VECTOR_LENGTH * std::ceil(double(num) / jit::VECTOR_LENGTH);
        for (int i = 0; i < cnum; i += jit::VECTOR_LENGTH) {
            int lim = std::min(jit::VECTOR_LENGTH, num - i);
            for (int n = 0; n < num_nodes; n++) {
                node_clones[n]->calc(i, lim);
            }
            for (int n = 0; n < num_output_nodes; n++) {
                std::copy(cloned_output_nodes[n]->m_val.begin(),
                          cloned_output_nodes[n]->m_val.begin() + lim,
                          ptrs[n] + i);
            }
        }
    } else {
        for (int w = 0; w < (int)odims[3]; w++) {
            dim_t offw = w * ostrs[3];

            for (int z = 0; z < (int)odims[2]; z++) {
                dim_t offz = z * ostrs[2] + offw;

                for (int y = 0; y < (int)odims[1]; y++) {
                    dim_t offy = y * ostrs[1] + offz;