Method operator()

src/backend/oneapi/kernel/mean.hpp:74–188

        , output_weight_(output_weight) {}

    void operator()(sycl::nd_item<2> it) const {
        sycl::group g   = it.get_group();
        const uint lidx = it.get_local_id(0);
        const uint lidy = it.get_local_id(1);
        const uint lid  = lidy * g.get_local_range(0) + lidx;

        const uint zid        = g.get_group_id(0) / groups_x_;
        const uint wid        = g.get_group_id(1) / groups_y_;
        const uint groupIdx_x = g.get_group_id(0) - (groups_x_)*zid;
        const uint groupIdx_y = g.get_group_id(1) - (groups_y_)*wid;
        const uint xid        = groupIdx_x * g.get_local_range(0) + lidx;
        const uint yid =
            groupIdx_y;  // yid  of output. updated for input later.

        uint ids[4] = {xid, yid, zid, wid};

        const Ti *iptr = in_.get_pointer();
        To *optr       = out_.get_pointer();

        uint ooffset = ids[3] * oInfo_.strides[3] + ids[2] * oInfo_.strides[2] +
                       ids[1] * oInfo_.strides[1] + ids[0] + oInfo_.offset;
        // There is only one element per block for out
        // There are blockDim.y elements per block for in
        // Hence increment ids[dim] just after offseting out and before
        // offsetting in
        optr += ooffset;

        const uint blockIdx_dim = ids[dim];
        ids[dim]                = ids[dim] * g.get_local_range(1) + lidy;

        uint ioffset = ids[3] * iInfo_.strides[3] + ids[2] * iInfo_.strides[2] +
                       ids[1] * iInfo_.strides[1] + ids[0] + iInfo_.offset;
        iptr += ioffset;

        const Tw *iwptr = nullptr;
        Tw *owptr       = nullptr;

        if (output_weight_) owptr = owt_.get_pointer() + ooffset;
        if (input_weight_) iwptr = iwt_.get_pointer() + ioffset;

        const uint id_dim_in   = ids[dim];
        const uint istride_dim = iInfo_.strides[dim];

        bool is_valid = (ids[0] < iInfo_.dims[0]) &&
                        (ids[1] < iInfo_.dims[1]) &&
                        (ids[2] < iInfo_.dims[2]) && (ids[3] < iInfo_.dims[3]);

        common::Transform<Ti, compute_t<To>, af_add_t> transform;

        compute_t<To> val    = common::Binary<compute_t<To>, af_add_t>::init();
        compute_t<Tw> weight = common::Binary<compute_t<Tw>, af_add_t>::init();

        if (is_valid && id_dim_in < iInfo_.dims[dim]) {
            val = transform(*iptr);
            if (iwptr) {
                weight = *iwptr;
            } else {
                weight = (Tw)1;