CpuAddKernel Class Reference

Interface for the kernel to perform addition between two tensors. More...

#include <CpuAddKernel.h>

Collaboration diagram for CpuAddKernel:

Data Structures
struct	AddKernel

Public Member Functions
	CpuAddKernel ()=default
	ARM_COMPUTE_DISALLOW_COPY_ALLOW_MOVE (CpuAddKernel)
void	configure (const ITensorInfo *src0, const ITensorInfo *src1, ITensorInfo *dst, ConvertPolicy policy)
	Initialise the kernel's input, dst and border mode. More...
void	run_op (ITensorPack &tensors, const Window &window, const ThreadInfo &info) override
	Execute the kernel on the passed window. More...
const char *	name () const override
	Name of the kernel. More...
size_t	get_mws (const CPUInfo &platform, size_t thread_count) const override
	Return minimum workload size of the relevant kernel. More...
size_t	get_split_dimension () const
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...
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 *src0, const ITensorInfo *src1, const ITensorInfo *dst, ConvertPolicy policy)
	Static function to check if given info will lead to a valid configuration. More...
static const std::vector< AddKernel > &	get_available_kernels ()
Static Public Member Functions inherited from ICpuKernel< CpuAddKernel >
static const auto *	get_implementation (const SelectorType &selector, KernelSelectionType selection_type=KernelSelectionType::Supported)
	Micro-kernel selector. 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 addition between two tensors.

Definition at line 37 of file CpuAddKernel.h.

Constructor & Destructor Documentation

CpuAddKernel()

CpuAddKernel ( )

default

Member Function Documentation

ARM_COMPUTE_DISALLOW_COPY_ALLOW_MOVE()

ARM_COMPUTE_DISALLOW_COPY_ALLOW_MOVE

(

CpuAddKernel

)

configure()

void configure	(	const ITensorInfo *	src0,
		const ITensorInfo *	src1,
		ITensorInfo *	dst,
		ConvertPolicy	policy
	)

Initialise the kernel's input, dst and border mode.

Valid configurations (src0,src1) -> dst :

• (U8,U8) -> U8
• (S16,S16) -> S16
• (S32,S32) -> S32
• (F16,F16) -> F16
• (F32,F32) -> F32
• (QASYMM8,QASYMM8) -> QASYMM8
• (QASYMM8_SIGNED,QASYMM8_SIGNED) -> QASYMM8_SIGNED
• (QSYMM16,QSYMM16) -> QSYMM16

Parameters

[in]	src0	First input tensor info. Data types supported: U8/QASYMM8/QASYMM8_SIGNED/S16/QSYMM16/F16/S32/F32
[in]	src1	Second input tensor info. Data types supported: U8/QASYMM8/QASYMM8_SIGNED/S16/QSYMM16/F16/S32/F32
[out]	dst	The dst tensor info. Data types supported: U8/QASYMM8/QASYMM8_SIGNED/S16/QSYMM16/F16/S32/F32.
[in]	policy	Overflow policy.

Definition at line 213 of file CpuAddKernel.cpp.

{
    ARM_COMPUTE_ERROR_ON_NULLPTR(src0, src1, dst);
    ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(*src0, *src1, *dst, policy));
 
    const auto can_use_fixedpoint     = add_q8_neon_fixedpoint_possible(src0, src1, dst);
    const auto uk                     = CpuAddKernel::get_implementation<CpuAddKernelDataTypeISASelectorData>(CpuAddKernelDataTypeISASelectorData{ src0->data_type(),
                                                                                                              CPUInfo::get().get_isa(), can_use_fixedpoint });
 
    ARM_COMPUTE_ERROR_ON_NULLPTR(uk);
 
    _policy     = policy;
    _run_method = uk->ukernel;
    _name       = std::string("CpuAddKernel").append("/").append(uk->name);
 
    // Auto initialize dst if not initialized
    const TensorShape &out_shape = TensorShape::broadcast_shape(src0->tensor_shape(), src1->tensor_shape());
    set_shape_if_empty(*dst, out_shape);
    set_data_type_if_unknown(*dst, src0->data_type());
 
    // Configure kernel window
    Window win;
    std::tie(win, _split_dimension) = calculate_squashed_or_max_window(*src0, *src1);
 
    ICpuKernel::configure(win);
}

References arm_compute::cpu::add_q8_neon_fixedpoint_possible(), ARM_COMPUTE_ERROR_ON_NULLPTR, ARM_COMPUTE_ERROR_THROW_ON, TensorShape::broadcast_shape(), arm_compute::calculate_squashed_or_max_window(), ITensorInfo::data_type(), arm_compute::test::validation::dst, CPUInfo::get(), arm_compute::set_data_type_if_unknown(), arm_compute::set_shape_if_empty(), ITensorInfo::tensor_shape(), and arm_compute::cpu::kernels::validate_arguments().

get_available_kernels()

const std::vector< CpuAddKernel::AddKernel > & get_available_kernels ( )

static

Definition at line 270 of file CpuAddKernel.cpp.

{
    return available_kernels;
}

get_mws()

size_t get_mws ( const CPUInfo &  platform, size_t  thread_count  ) const

overridevirtual

Return minimum workload size of the relevant kernel.

Parameters

[in]	platform	The CPU platform used to create the context.
[in]	thread_count	Number of threads in the execution.

Returns

[out] mws Minimum workload size for requested configuration.

Reimplemented from ICPPKernel.

Definition at line 275 of file CpuAddKernel.cpp.

{
    ARM_COMPUTE_UNUSED(thread_count);
 
#if defined(ENABLE_FP32_KERNELS)
    if(this->_run_method == &add_fp32_neon)
    {
        size_t mws = ICPPKernel::default_mws;
        if(platform.get_cpu_model() == CPUModel::N1)
        {
            mws = default_mws_N1_fp32_neon;
        }
        else if(platform.get_cpu_model() == CPUModel::V1)
        {
            mws = default_mws_V1_fp32_neon;
        }
        else
        {
            return ICPPKernel::default_mws;
        }
 
        // tensor is 1D or was re-interpreted as 1D
        if(this->window().shape().num_dimensions() == 1)
        {
            return mws;
        }
        else
        {
            // scale mws down by the number of elements along all the dimensions (x, z, w, etc) except the one
            // that we parallelize along (the y dimension). This allows for parallelization when the Y_SIZE is small
            // but the other sizes are large, which boosts performance.
            mws = static_cast<size_t>(mws / (this->window().num_iterations_total() / this->window().num_iterations(1)));
            return std::max(static_cast<size_t>(1), mws);
        }
    }
#else /* ENABLE_FP32_KERNELS */
    ARM_COMPUTE_UNUSED(platform);
#endif /* ENABLE_FP32_KERNELS */
    return ICPPKernel::default_mws;
}

References arm_compute::cpu::add_fp32_neon(), ARM_COMPUTE_UNUSED, ICPPKernel::default_mws, CPUInfo::get_cpu_model(), arm_compute::N1, Window::num_iterations(), Window::num_iterations_total(), arm_compute::test::validation::shape, arm_compute::V1, and IKernel::window().

get_split_dimension()

size_t get_split_dimension ( ) const

inline

Definition at line 94 of file CpuAddKernel.h.

    {
        return _split_dimension;
    }

name()

const char * name ( ) const

overridevirtual

Name of the kernel.

Returns

Kernel name

Implements ICPPKernel.

Definition at line 265 of file CpuAddKernel.cpp.

{
    return _name.c_str();
}

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 249 of file CpuAddKernel.cpp.

{
    ARM_COMPUTE_UNUSED(info);
    ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
    ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(ICpuKernel::window(), window);
 
    ARM_COMPUTE_ERROR_ON(tensors.empty());
    ARM_COMPUTE_ERROR_ON(_run_method == nullptr);
 
    const ITensor *src0 = tensors.get_const_tensor(TensorType::ACL_SRC_0);
    const ITensor *src1 = tensors.get_const_tensor(TensorType::ACL_SRC_1);
    ITensor       *dst  = tensors.get_tensor(TensorType::ACL_DST);
 
    _run_method(src0, src1, dst, _policy, window);
}

References arm_compute::ACL_DST, arm_compute::ACL_SRC_0, arm_compute::ACL_SRC_1, ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW, ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL, ARM_COMPUTE_UNUSED, arm_compute::test::validation::dst, ITensorPack::empty(), ITensorPack::get_const_tensor(), ITensorPack::get_tensor(), arm_compute::test::validation::info, and IKernel::window().

validate()

Status validate ( const ITensorInfo *  src0, const ITensorInfo *  src1, const ITensorInfo *  dst, ConvertPolicy  policy  )

static

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

Similar to CpuAddKernel::configure()

Returns

a status

Definition at line 240 of file CpuAddKernel.cpp.

{
    ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(src0, src1, dst);
 
    ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(*src0, *src1, *dst, policy));
 
    return Status{};
}

References ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR, ARM_COMPUTE_RETURN_ON_ERROR, arm_compute::test::validation::dst, and arm_compute::cpu::kernels::validate_arguments().

Referenced by CpuAdd::validate().

---

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

• src/cpu/kernels/CpuAddKernel.h
• src/cpu/kernels/CpuAddKernel.cpp