Method operator()

src/backend/oneapi/kernel/index.hpp:56–110

    }

    void operator()(sycl::nd_item<3> it) const {
        // retrieve index pointers
        // these can be 0 where af_array index is not used
        sycl::group g    = it.get_group();
        const uint* ptr0 = p.ptr[0].get_pointer();
        const uint* ptr1 = p.ptr[1].get_pointer();
        const uint* ptr2 = p.ptr[2].get_pointer();
        const uint* ptr3 = p.ptr[3].get_pointer();
        // retrive booleans that tell us which index to use
        const bool s0 = p.isSeq[0];
        const bool s1 = p.isSeq[1];
        const bool s2 = p.isSeq[2];
        const bool s3 = p.isSeq[3];

        const int gz = g.get_group_id(0) / nBBS0;
        const int gx = g.get_local_range(0) * (g.get_group_id(0) - gz * nBBS0) +
                       it.get_local_id(0);

        const int gw =
            (g.get_group_id(1) + g.get_group_id(2) * g.get_group_range(1)) /
            nBBS1;
        const int gy =
            g.get_local_range(1) * ((g.get_group_id(1) +
                                     g.get_group_id(2) * g.get_group_range(1)) -
                                    gw * nBBS1) +
            it.get_local_id(1);

        size_t odims0 = outp.dims[0];
        size_t odims1 = outp.dims[1];
        size_t odims2 = outp.dims[2];
        size_t odims3 = outp.dims[3];

        if (gx < odims0 && gy < odims1 && gz < odims2 && gw < odims3) {
            // calculate pointer offsets for input
            int i = p.strds[0] *
                    trimIndex(s0 ? gx * p.steps[0] + p.offs[0] : ptr0[gx],
                              inp.dims[0]);
            int j = p.strds[1] *
                    trimIndex(s1 ? gy * p.steps[1] + p.offs[1] : ptr1[gy],
                              inp.dims[1]);
            int k = p.strds[2] *
                    trimIndex(s2 ? gz * p.steps[2] + p.offs[2] : ptr2[gz],
                              inp.dims[2]);
            int l = p.strds[3] *
                    trimIndex(s3 ? gw * p.steps[3] + p.offs[3] : ptr3[gw],
                              inp.dims[3]);
            // offset input and output pointers
            const T* src = (const T*)in.get_pointer() + (i + j + k + l);
            T* dst       = (T*)out.get_pointer() +
                     (gx * outp.strides[0] + gy * outp.strides[1] +
                      gz * outp.strides[2] + gw * outp.strides[3]);
            // set the output
            dst[0] = src[0];
        }
    }
};

template<typename T>