Method operator()

src/backend/oneapi/kernel/sparse_arith.hpp:478–521

        , rColIdx_(rColIdx) {}

    void operator()(sycl::nd_item<1> it) const {
        common::Binary<T, op> binOP;

        const uint row = it.get_global_id(0);

        const bool valid  = row < M_;
        const uint lEnd   = (valid ? lRowIdx_[row + 1] : 0);
        const uint rEnd   = (valid ? rRowIdx_[row + 1] : 0);
        const uint offset = (valid ? oRowIdx_[row] : 0);

        T *ovPtr   = oVals_.get_pointer() + offset;
        int *ocPtr = oColIdx_.get_pointer() + offset;

        uint l = (valid ? lRowIdx_[row] : 0);
        uint r = (valid ? rRowIdx_[row] : 0);

        uint nnz = 0;
        while (l < lEnd && r < rEnd) {
            uint lci = lColIdx_[l];
            uint rci = rColIdx_[r];

            T lhs = (lci <= rci ? lVals_[l] : common::Binary<T, op>::init());
            T rhs = (lci >= rci ? rVals_[r] : common::Binary<T, op>::init());

            ovPtr[nnz] = binOP(lhs, rhs);
            ocPtr[nnz] = (lci <= rci) ? lci : rci;

            l += (lci <= rci);
            r += (lci >= rci);
            nnz++;
        }
        while (l < lEnd) {
            ovPtr[nnz] = binOP(lVals_[l], common::Binary<T, op>::init());
            ocPtr[nnz] = lColIdx_[l];
            l++;
            nnz++;
        }
        while (r < rEnd) {
            ovPtr[nnz] = binOP(common::Binary<T, op>::init(), rVals_[r]);
            ocPtr[nnz] = rColIdx_[r];
            r++;
            nnz++;
        }
    }

   private:
    write_accessor<T> oVals_;