NEStridedSliceKernel Class Reference

Interface for the kernel to perform tensor strided slicing. More...

#include <NEStridedSliceKernel.h>

Collaboration diagram for NEStridedSliceKernel:

Public Member Functions
const char *	name () const override
	Name of the kernel. More...
	NEStridedSliceKernel ()
	Default constructor. More...
	NEStridedSliceKernel (const NEStridedSliceKernel &)=delete
	Prevent instances of this class from being copied (As this class contains pointers) More...
NEStridedSliceKernel &	operator= (const NEStridedSliceKernel &)=delete
	Prevent instances of this class from being copied (As this class contains pointers) More...
	NEStridedSliceKernel (NEStridedSliceKernel &&)=default
	Allow instances of this class to be moved. More...
NEStridedSliceKernel &	operator= (NEStridedSliceKernel &&)=default
	Allow instances of this class to be moved. More...
	~NEStridedSliceKernel ()=default
	Default destructor. More...
void	configure (const ITensorInfo *input, ITensorInfo *output, const Coordinates &starts, const Coordinates &ends, const BiStrides &strides, int32_t begin_mask, int32_t end_mask, int32_t shrink_axis_mask)
	Configure kernel. More...
void	run_op (ITensorPack &tensors, const Window &window, const ThreadInfo &info) override
	Execute the kernel on the passed window. More...
Public Member Functions inherited from ICPPKernel
virtual	~ICPPKernel ()=default
	Default destructor. More...
virtual void	run (const Window &window, const ThreadInfo &info)
	Execute the kernel on the passed window. More...
virtual void	run_nd (const Window &window, const ThreadInfo &info, const Window &thread_locator)
	legacy compatibility layer for implemantions which do not support thread_locator In these cases we simply narrow the interface down the legacy version More...
virtual size_t	get_mws (const CPUInfo &platform, size_t thread_count) const
	Return minimum workload size of the relevant kernel. More...
Public Member Functions inherited from IKernel
	IKernel ()
	Constructor. More...
virtual	~IKernel ()=default
	Destructor. More...
virtual bool	is_parallelisable () const
	Indicates whether or not the kernel is parallelisable. More...
virtual BorderSize	border_size () const
	The size of the border for that kernel. More...
const Window &	window () const
	The maximum window the kernel can be executed on. More...
bool	is_window_configured () const
	Function to check if the embedded window of this kernel has been configured. More...

Static Public Member Functions
static Status	validate (const ITensorInfo *input, const ITensorInfo *output, const Coordinates &starts, const Coordinates &ends, const BiStrides &strides, int32_t begin_mask, int32_t end_mask, int32_t shrink_axis_mask)
	Static function to check if given info will lead to a valid configuration of NEStridedSliceKernel. More...

Additional Inherited Members
Static Public Attributes inherited from ICPPKernel
static constexpr size_t	default_mws = 1

Detailed Description

Interface for the kernel to perform tensor strided slicing.

Definition at line 38 of file NEStridedSliceKernel.h.

Constructor & Destructor Documentation

NEStridedSliceKernel() [1/3]

NEStridedSliceKernel

(

)

Default constructor.

Definition at line 91 of file NEStridedSliceKernel.cpp.

    : _starts_abs(), _final_strides(), _shrink_mask()
{
}

NEStridedSliceKernel() [2/3]

NEStridedSliceKernel ( const NEStridedSliceKernel &  )

delete

Prevent instances of this class from being copied (As this class contains pointers)

NEStridedSliceKernel() [3/3]

NEStridedSliceKernel ( NEStridedSliceKernel &&  )

default

Allow instances of this class to be moved.

~NEStridedSliceKernel()

~NEStridedSliceKernel ( )

default

Default destructor.

Member Function Documentation

configure()

void configure	(	const ITensorInfo *	input,
		ITensorInfo *	output,
		const Coordinates &	starts,
		const Coordinates &	ends,
		const BiStrides &	strides,
		int32_t	begin_mask,
		int32_t	end_mask,
		int32_t	shrink_axis_mask
	)

Configure kernel.

Note

Supported tensor rank: up to 4

Parameters

[in]	input	Source tensor info. Data type supported: All
[out]	output	Destination tensor info. Data type supported: Same as input
[in]	starts	The starts of the dimensions of the input tensor to be sliced. The length must be of rank(input).
[in]	ends	The ends of the dimensions of the input tensor to be sliced. The length must be of rank(input).
[in]	strides	The strides of the dimensions of the input tensor to be sliced. The length must be of rank(input).
[in]	begin_mask	If the ith bit of begin_mask is set, starts[i] is ignored and the fullest possible range in that dimension is used instead.
[in]	end_mask	If the ith bit of end_mask is set, ends[i] is ignored and the fullest possible range in that dimension is used instead.
[in]	shrink_axis_mask	If the ith bit of shrink_axis_mask is set, it implies that the ith specification shrinks the dimensionality by 1. A slice of size 1 starting from starts[i] in the dimension must be preserved.

Definition at line 96 of file NEStridedSliceKernel.cpp.

{
    ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
    ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input, output, starts, ends, strides, begin_mask, end_mask, shrink_axis_mask));
    _shrink_mask                   = shrink_axis_mask;
    const TensorShape &input_shape = input->tensor_shape();
    Coordinates        ends_abs;
    std::tie(_starts_abs, ends_abs, _final_strides) = arm_compute::helpers::tensor_transform::calculate_strided_slice_coords(
                                                          input_shape,
                                                          starts, ends, strides,
                                                          begin_mask, end_mask, shrink_axis_mask);
    // Configure kernel window
    auto win_config = validate_and_configure_window(input, output, starts, ends, strides, begin_mask, end_mask, shrink_axis_mask);
    ARM_COMPUTE_ERROR_THROW_ON(win_config.first);
    INEKernel::configure(win_config.second);
}

References ARM_COMPUTE_ERROR_ON_NULLPTR, ARM_COMPUTE_ERROR_THROW_ON, arm_compute::helpers::tensor_transform::calculate_strided_slice_coords(), arm_compute::test::validation::input, arm_compute::test::validation::input_shape, arm_compute::cpu::kernels::validate_and_configure_window(), and arm_compute::cpu::kernels::validate_arguments().

name()

const char* name ( ) const

inlineoverridevirtual

Name of the kernel.

Returns

Kernel name

Implements ICPPKernel.

Definition at line 41 of file NEStridedSliceKernel.h.

    {
        return "NEStridedSliceKernel";
    }

operator=() [1/2]

NEStridedSliceKernel& operator= ( const NEStridedSliceKernel &  )

delete

Prevent instances of this class from being copied (As this class contains pointers)

operator=() [2/2]

NEStridedSliceKernel& operator= ( NEStridedSliceKernel &&  )

default

Allow instances of this class to be moved.

run_op()

void run_op ( ITensorPack &  tensors, const Window &  window, const ThreadInfo &  info  )

overridevirtual

Execute the kernel on the passed window.

Warning

If is_parallelisable() returns false then the passed window must be equal to window()

Note

The window has to be a region within the window returned by the window() method

The width of the window has to be a multiple of num_elems_processed_per_iteration().

Parameters

[in]	tensors	A vector containing the tensors to operate on.
[in]	window	Region on which to execute the kernel. (Must be a region of the window returned by window())
[in]	info	Info about executing thread and CPU.

Reimplemented from ICPPKernel.

Definition at line 127 of file NEStridedSliceKernel.cpp.

{
    ARM_COMPUTE_UNUSED(info);
    ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
    ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(INEKernel::window(), window);
 
    const ITensor *input  = tensors.get_const_tensor(TensorType::ACL_SRC_0);
    const ITensor *output = tensors.get_tensor(TensorType::ACL_DST);
 
    size_t width_size = input->info()->element_size();
 
    const bool is_shrink_x = arm_compute::helpers::bit_ops::is_bit_set(_shrink_mask, 0);
    const bool is_shrink_y = arm_compute::helpers::bit_ops::is_bit_set(_shrink_mask, 1);
    const bool is_shrink_z = arm_compute::helpers::bit_ops::is_bit_set(_shrink_mask, 2);
    const bool is_shrink_w = arm_compute::helpers::bit_ops::is_bit_set(_shrink_mask, 3);
 
    unsigned int index = 0;
    const int    idx_x = is_shrink_x ? 0 : index++;
    const int    idx_y = is_shrink_y ? 0 : index++;
    const int    idx_z = is_shrink_z ? 0 : index++;
    const int    idx_w = is_shrink_w ? 0 : index;
 
    BiStrides shrinked_strides;
    shrinked_strides.set(0, is_shrink_x ? 0 : _final_strides[0]);
    shrinked_strides.set(1, is_shrink_y ? 0 : _final_strides[1]);
    shrinked_strides.set(2, is_shrink_z ? 0 : _final_strides[2]);
    shrinked_strides.set(3, is_shrink_w ? 0 : _final_strides[3]);
 
    Window win = window;
 
    size_t length_x = win.shape()[0];
 
    if(_final_strides[0] == 1 && !is_shrink_x)
    {
        win.set(Window::DimX, Window::Dimension(0, 1, 1));
        width_size = width_size * length_x;
    }
 
    Iterator output_it(output, win);
 
    const int start_0 = _starts_abs[0];
    const int start_1 = _starts_abs[1];
    const int start_2 = _starts_abs[2];
    const int start_3 = _starts_abs[3];
 
    const int shrinked_stride_0 = shrinked_strides[0];
    const int shrinked_stride_1 = shrinked_strides[1];
    const int shrinked_stride_2 = shrinked_strides[2];
    const int shrinked_stride_3 = shrinked_strides[3];
 
    const int byte_increment_0 = static_cast<int>(input->info()->strides_in_bytes()[0]);
    const int byte_increment_1 = static_cast<int>(input->info()->strides_in_bytes()[1]);
    const int byte_increment_2 = static_cast<int>(input->info()->strides_in_bytes()[2]);
    const int byte_increment_3 = static_cast<int>(input->info()->strides_in_bytes()[3]);
 
    uint8_t *input_base = input->ptr_to_element(Coordinates(0, 0, 0, 0));
    uint8_t *cur_ptr;
 
    execute_window_loop(
        win, [&](const Coordinates & id)
    {
        cur_ptr = input_base;
        cur_ptr += (start_0 + (id[idx_x] * shrinked_stride_0)) * byte_increment_0;
        cur_ptr += (start_1 + (id[idx_y] * shrinked_stride_1)) * byte_increment_1;
        cur_ptr += (start_2 + (id[idx_z] * shrinked_stride_2)) * byte_increment_2;
        cur_ptr += (start_3 + (id[idx_w] * shrinked_stride_3)) * byte_increment_3;
 
        std::copy_n(cur_ptr, width_size, output_it.ptr());
    },
    output_it);
}

References arm_compute::ACL_DST, arm_compute::ACL_SRC_0, ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW, ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL, ARM_COMPUTE_UNUSED, Window::DimX, arm_compute::execute_window_loop(), ITensorPack::get_const_tensor(), ITensorPack::get_tensor(), arm_compute::test::validation::info, arm_compute::test::validation::input, arm_compute::helpers::bit_ops::is_bit_set(), Iterator::ptr(), Dimensions< T >::set(), Window::set(), Window::shape(), and IKernel::window().

validate()

Status validate ( const ITensorInfo *  input, const ITensorInfo *  output, const Coordinates &  starts, const Coordinates &  ends, const BiStrides &  strides, int32_t  begin_mask, int32_t  end_mask, int32_t  shrink_axis_mask  )

static

Static function to check if given info will lead to a valid configuration of NEStridedSliceKernel.

Note

Supported tensor rank: up to 4

Parameters

[in]	input	Source tensor info. Data type supported: All
[in]	output	Destination tensor info. Data type supported: Same as input
[in]	starts	The starts of the dimensions of the input tensor to be sliced. The length must be of rank(input).
[in]	ends	The ends of the dimensions of the input tensor to be sliced. The length must be of rank(input).
[in]	strides	The strides of the dimensions of the input tensor to be sliced. The length must be of rank(input).
[in]	begin_mask	If the ith bit of begin_mask is set, starts[i] is ignored and the fullest possible range in that dimension is used instead.
[in]	end_mask	If the ith bit of end_mask is set, ends[i] is ignored and the fullest possible range in that dimension is used instead.
[in]	shrink_axis_mask	If the ith bit of shrink_axis_mask is set, it implies that the ith specification shrinks the dimensionality by 1. A slice of size 1 starting from starts[i] in the dimension must be preserved.

Definition at line 115 of file NEStridedSliceKernel.cpp.

{
    ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, output, starts, ends, strides, begin_mask, end_mask, shrink_axis_mask));
    ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window(input->clone().get(), output->clone().get(),
                                                              starts, ends, strides, begin_mask, end_mask, shrink_axis_mask)
                                .first);
 
    return Status{};
}

References ARM_COMPUTE_RETURN_ON_ERROR, ICloneable< T >::clone(), arm_compute::test::validation::input, arm_compute::cpu::kernels::validate_and_configure_window(), and arm_compute::cpu::kernels::validate_arguments().

Referenced by NESlice::validate(), and NEStridedSlice::validate().

---

The documentation for this class was generated from the following files:

• src/core/NEON/kernels/NEStridedSliceKernel.h
• src/core/NEON/kernels/NEStridedSliceKernel.cpp