Function run_reverse

src/core/NEON/kernels/NEReverseKernel.cpp:104–185

template <typename T>
void run_reverse(
    const Window &window, const ITensor *input, const ITensor *axis, ITensor *output, bool use_inverted_axis)
{
    unsigned int axis_bit = 0;
    const int    rank     = input->info()->num_dimensions();

    for (unsigned int i = 0; i < axis->info()->dimension(0); ++i)
    {
        int axis_i = *(reinterpret_cast<const int *>(axis->buffer()) + i);

        // The values of axis tensor must be between [-rank, rank-1].
        if ((axis_i < -rank) || (axis_i >= rank))
        {
            ARM_COMPUTE_ERROR("the values of the axis tensor must be within [-rank, rank-1].");
        }

        // In case of negative axis value i.e targeted axis(i) = rank + axis(i)
        if (axis_i < 0)
        {
            axis_i = rank + axis_i;
        }

        // Reverse ACL axis indices convention i.e. (inverted)axis = (tensor_rank - 1) - axis
        if (use_inverted_axis)
        {
            axis_i = (rank - 1) - axis_i;
        }

        axis_bit |= 1 << axis_i;
    }

    // Check if we need a left-over loop for the y dimension
    const int window_step_x  = 16 / input->info()->element_size();
    const int window_start_x = window.x().start();
    const int window_end_x   = window.x().end();

    Window win(window);
    win.set(Window::DimX, Window::Dimension(0, 1, 1));

    Iterator input_it(input, win);
    execute_window_loop(
        win,
        [&](const Coordinates &id)
        {
            int x = window_start_x;
            for (; x <= (window_end_x - window_step_x); x += window_step_x)
            {
                auto in = wrapper::vloadq(reinterpret_cast<T *>(input_it.ptr()) + x);

                // Reverse 0 axis
                if (axis_bit & 0x1)
                {
                    in = wrapper::vrev64(in);
                    in = wrapper::vcombine(wrapper::vgethigh(in), wrapper::vgetlow(in));
                }

                const int offset_x = (axis_bit & 0x1) ? output->info()->dimension(0) - x - window_step_x : x;
                const int offset_y = (axis_bit & 0x2) ? output->info()->dimension(1) - id.y() - 1 : id.y();