CpuConcatenate Class Reference

Basic function to execute concatenate tensors along a given axis. More...

#include <CpuConcatenate.h>

Collaboration diagram for CpuConcatenate:

Public Member Functions
	CpuConcatenate ()=default
void	configure (const std::vector< const ITensorInfo * > &srcs_vector, ITensorInfo *dst, size_t axis)
	Configure operator for a given list of arguments. More...
void	run (ITensorPack &tensors) override
	Run the kernels contained in the function. More...
Public Member Functions inherited from INEOperator
	INEOperator (IRuntimeContext *ctx=nullptr)
	Constructor. More...
	INEOperator (const INEOperator &)=delete
	Prevent instances of this class from being copied (As this class contains pointers) More...
	INEOperator (INEOperator &&)=default
	Default move constructor. More...
INEOperator &	operator= (const INEOperator &)=delete
	Prevent instances of this class from being copied (As this class contains pointers) More...
INEOperator &	operator= (INEOperator &&)=default
	Default move assignment operator. More...
	~INEOperator ()
	Default destructor. More...
void	prepare (ITensorPack &constants) override
	Prepare the function for executing. More...
MemoryRequirements	workspace () const override
	Return the memory requirements required by the workspace. More...
Public Member Functions inherited from IOperator
virtual	~IOperator ()=default
	Destructor. More...

Static Public Member Functions
static Status	validate (const std::vector< const ITensorInfo * > &srcs_vector, const ITensorInfo *dst, size_t axis)
	Static function to check if given info will lead to a valid configuration. More...

Detailed Description

Basic function to execute concatenate tensors along a given axis.

This function calls the following kernels:

1. kernels::CpuConcatenateWidthKernel (if underlying concatenation axis is 0).
2. kernels::CpuConcatenateHeightKernel (if underlying concatenation axis is 1).
3. kernels::CpuConcatenateDepthKernel (if underlying concatenation axis is 2).
4. kernels::CpuConcatenateBatchKernel (if underlying concatenation axis is 3).

Definition at line 43 of file CpuConcatenate.h.

Constructor & Destructor Documentation

CpuConcatenate()

CpuConcatenate ( )

default

Member Function Documentation

configure()

void configure	(	const std::vector< const ITensorInfo * > &	srcs_vector,
		ITensorInfo *	dst,
		size_t	axis
	)

Configure operator for a given list of arguments.

Note

Input and output tensor dimensions preconditions defer depending on the concatenation axis.

Preconditions can be found respectively at kernels::CpuConcatenateWidthKernel, kernels::CpuConcatenateHeightKernel, kernels::CpuConcatenateDepthKernel and kernels::CpuConcatenateBatchKernel.

Parameters

[in,out]	srcs_vector	The vectors containing all the tensors to concatenate. Data types supported: QASYMM8/QASYMM8_SIGNED/F16/F32.
[out]	dst	Output tensor. Data types supported: Same as srcs_vector.
[in]	axis	Concatenation axis. Supported underlying concatenation axis are 0, 1, 2 and 3.

Definition at line 45 of file CpuConcatenate.cpp.

{
    ARM_COMPUTE_ERROR_ON(dst == nullptr);
    ARM_COMPUTE_LOG_PARAMS(srcs_vector, dst, axis);
 
    _axis     = axis;
    _num_srcs = srcs_vector.size();
 
    TensorShape dst_shape = arm_compute::misc::shape_calculator::calculate_concatenate_shape(srcs_vector, axis);
 
    // Output auto inizialitation if not yet initialized
    auto_init_if_empty(*dst, dst_shape, 1, srcs_vector[0]->data_type());
    ARM_COMPUTE_ERROR_THROW_ON(CpuConcatenate::validate(srcs_vector, dst, axis));
 
    unsigned int offset = 0;
 
    for (unsigned int i = 0; i < _num_srcs; ++i)
    {
        switch (axis)
        {
            case Window::DimX:
            {
                auto kernel = std::make_unique<kernels::CpuConcatenateWidthKernel>();
                kernel->configure(srcs_vector.at(i), offset, dst);
                _concat_kernels.emplace_back(std::move(kernel));
                break;
            }
            case Window::DimY:
            {
                auto kernel = std::make_unique<kernels::CpuConcatenateHeightKernel>();
                kernel->configure(srcs_vector.at(i), offset, dst);
                _concat_kernels.emplace_back(std::move(kernel));
                break;
            }
            case Window::DimZ:
            {
                auto kernel = std::make_unique<kernels::CpuConcatenateDepthKernel>();
                kernel->configure(srcs_vector.at(i), offset, dst);
                _concat_kernels.emplace_back(std::move(kernel));
                break;
            }
            case 3:
            {
                auto kernel = std::make_unique<kernels::CpuConcatenateBatchKernel>();
                kernel->configure(srcs_vector.at(i), offset, dst);
                _concat_kernels.emplace_back(std::move(kernel));
                break;
            }
            default:
                ARM_COMPUTE_ERROR("Axis not supported");
        }
        offset += srcs_vector.at(i)->dimension(axis);
    }
}

References ARM_COMPUTE_ERROR, ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_ERROR_THROW_ON, ARM_COMPUTE_LOG_PARAMS, arm_compute::auto_init_if_empty(), arm_compute::misc::shape_calculator::calculate_concatenate_shape(), arm_compute::test::validation::data_type, Window::DimX, Window::DimY, Window::DimZ, arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, offset(), and CpuConcatenate::validate().

run()

void run ( ITensorPack &  tensors )

overridevirtual

Run the kernels contained in the function.

Parameters

[in]

tensors

Vector that contains the tensors to operate on.

Reimplemented from INEOperator.

Definition at line 147 of file CpuConcatenate.cpp.

{
    if (tensors.empty())
    {
        ARM_COMPUTE_ERROR("No inputs provided");
    }
 
    if (static_cast<int>(tensors.size() - 1) != static_cast<int>(_num_srcs))
    {
        ARM_COMPUTE_ERROR("Configured with different number of inputs");
    }
 
    int i = 0;
    for (auto &k : _concat_kernels)
    {
        ITensorPack pack;
        pack.add_tensor(TensorType::ACL_SRC, tensors.get_const_tensor(ACL_SRC_VEC + i));
        pack.add_tensor(TensorType::ACL_DST, tensors.get_tensor(ACL_DST));
        NEScheduler::get().schedule_op(k.get(), Window::DimY, k->window(), pack);
        ++i;
    }
}

References arm_compute::ACL_DST, arm_compute::ACL_SRC, arm_compute::ACL_SRC_VEC, ITensorPack::add_tensor(), ARM_COMPUTE_ERROR, Window::DimY, ITensorPack::empty(), Scheduler::get(), ITensorPack::get_const_tensor(), ITensorPack::get_tensor(), arm_compute::test::validation::pack, IScheduler::schedule_op(), and ITensorPack::size().

validate()

Status validate ( const std::vector< const ITensorInfo * > &  srcs_vector, const ITensorInfo *  dst, size_t  axis  )

static

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

Similar to CpuConcatenate::configure()

Returns

a status

Definition at line 101 of file CpuConcatenate.cpp.

{
    ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(dst);
    ARM_COMPUTE_RETURN_ERROR_ON(srcs_vector.size() < 2);
 
    unsigned int offset = 0;
    for (const auto &src : srcs_vector)
    {
        ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(src);
        switch (axis)
        {
            case Window::DimX:
            {
                ARM_COMPUTE_RETURN_ON_ERROR(kernels::CpuConcatenateWidthKernel::validate(src, offset, dst));
                break;
            }
            case Window::DimY:
            {
                ARM_COMPUTE_RETURN_ON_ERROR(kernels::CpuConcatenateHeightKernel::validate(src, offset, dst));
                break;
            }
            case Window::DimZ:
            {
                ARM_COMPUTE_RETURN_ON_ERROR(kernels::CpuConcatenateDepthKernel::validate(src, offset, dst));
                break;
            }
            case 3:
            {
                ARM_COMPUTE_RETURN_ON_ERROR(kernels::CpuConcatenateBatchKernel::validate(src, offset, dst));
                break;
            }
            default:
                ARM_COMPUTE_ERROR("Axis not supported");
        }
        offset += src->dimension(axis);
    }
 
    if (dst->total_size() != 0)
    {
        TensorShape dst_shape = arm_compute::misc::shape_calculator::calculate_concatenate_shape(srcs_vector, axis);
        ARM_COMPUTE_RETURN_ERROR_ON(dst_shape.total_size() != dst->tensor_shape().total_size());
    }
 
    return Status{};
}

References ARM_COMPUTE_ERROR, ARM_COMPUTE_RETURN_ERROR_ON, ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR, ARM_COMPUTE_RETURN_ON_ERROR, arm_compute::misc::shape_calculator::calculate_concatenate_shape(), Window::DimX, Window::DimY, Window::DimZ, arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, offset(), arm_compute::test::validation::src, TensorShape::total_size(), CpuConcatenateBatchKernel::validate(), CpuConcatenateWidthKernel::validate(), CpuConcatenateHeightKernel::validate(), and CpuConcatenateDepthKernel::validate().

Referenced by CpuConcatenate::configure(), and NEConcatenateLayer::validate().

---

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

• src/cpu/operators/CpuConcatenate.h
• src/cpu/operators/CpuConcatenate.cpp