PermutationVector Class Reference

#include <Types.hpp>

Public Types
using	ValueType = unsigned int
using	SizeType = unsigned int
using	ArrayType = std::array< ValueType, MaxNumOfTensorDimensions >
using	ConstIterator = typename ArrayType::const_iterator

Public Member Functions
	PermutationVector (const ValueType *dimMappings, SizeType numDimMappings)
	PermutationVector (std::initializer_list< ValueType > dimMappings)
ValueType	operator[] (SizeType i) const
	Indexing method with out-of-bounds error checking for the m_DimMappings array. More...
SizeType	GetSize () const
ConstIterator	begin () const
ConstIterator	end () const
bool	IsEqual (const PermutationVector &other) const
bool	IsInverse (const PermutationVector &other) const

Detailed Description

Definition at line 308 of file Types.hpp.

Member Typedef Documentation

ArrayType

using ArrayType = std::array<ValueType, MaxNumOfTensorDimensions>

Definition at line 313 of file Types.hpp.

ConstIterator

using ConstIterator = typename ArrayType::const_iterator

Definition at line 314 of file Types.hpp.

SizeType

using SizeType = unsigned int

Definition at line 312 of file Types.hpp.

ValueType

using ValueType = unsigned int

Definition at line 311 of file Types.hpp.

Constructor & Destructor Documentation

PermutationVector() [1/2]

PermutationVector	(	const ValueType *	dimMappings,
		SizeType	numDimMappings
	)

Parameters

dimMappings

- Indicates how to translate tensor elements from a given source into the target destination, when source and target potentially have different memory layouts.

E.g. For a 4-d tensor laid out in a memory with the format (Batch Element, Height, Width, Channels), which is to be passed as an input to ArmNN, each source dimension is mapped to the corresponding ArmNN dimension. The Batch dimension remains the same (0 -> 0). The source Height dimension is mapped to the location of the ArmNN Height dimension (1 -> 2). Similar arguments are made for the Width and Channels (2 -> 3 and 3 -> 1). This will lead to m_DimMappings pointing to the following array: [ 0, 2, 3, 1 ].

Note that the mapping should be reversed if considering the case of ArmNN 4-d outputs (Batch Element, Channels, Height, Width) being written to a destination with the format mentioned above. We now have 0 -> 0, 2 -> 1, 3 -> 2, 1 -> 3, which, when reordered, lead to the following m_DimMappings contents: [ 0, 3, 1, 2 ].

Definition at line 20 of file Descriptors.cpp.

{
    // Validation
 
    if (numDimMappings > MaxNumOfTensorDimensions)
    {
        throw InvalidArgumentException(
            fmt::format("The number of mappings ({0}) cannot be greater "
                        "than the maximum number of dimensions supported ({1})",
                        numDimMappings,
                        MaxNumOfTensorDimensions));
    }
 
    if ((dimMappings == nullptr) && (numDimMappings != 0))
    {
        throw InvalidArgumentException("Dimension mappings must not be NULL if the number of mappings is positive");
    }
 
    for (SizeType i = 0; i < numDimMappings; ++i)
    {
        const ValueType dstIndex = dimMappings[i];
        if (dstIndex >= numDimMappings)
        {
            throw InvalidArgumentException(
                fmt::format("Dimension mapping at index {0} is invalid: "
                            "{1} is outside of the valid range [0,{2}]",
                            i,
                            dstIndex,
                            (numDimMappings - 1)));
        }
    }
 
    // Validation: Detect duplicates
    {
        std::array<bool, MaxNumOfTensorDimensions> observedDims;
        observedDims.fill(false);
 
        for (SizeType i = 0; i < numDimMappings; ++i)
        {
            const ValueType dstIndex = dimMappings[i];
            if (observedDims[dstIndex])
            {
                throw InvalidArgumentException("Invalid dimension mappings: Two or more source dimensions are mapped "
                    "to the same output dimension");
            }
            observedDims[dstIndex] = true;
        }
    }
 
    // Initialize
    for (SizeType i = 0; i < numDimMappings; ++i)
    {
        m_DimMappings[i] = dimMappings[i];
    }
    m_NumDimMappings = numDimMappings;
}

References armnn::MaxNumOfTensorDimensions.

PermutationVector() [2/2]

PermutationVector

(

std::initializer_list< ValueType >

dimMappings

)

Definition at line 77 of file Descriptors.cpp.

    : PermutationVector(dimMappings.begin(), armnn::numeric_cast<SizeType>(dimMappings.size()))
{
}

Member Function Documentation

begin()

ConstIterator begin ( ) const

inline

Definition at line 353 of file Types.hpp.

{ return m_DimMappings.begin(); }

Referenced by ConvertTransposeToTosaOperator().

end()

ConstIterator end ( ) const

inline

Returns

pointer one past the end of the number of mapping not the length of m_DimMappings.

Definition at line 358 of file Types.hpp.

{ return m_DimMappings.begin() + m_NumDimMappings; }

Referenced by ConvertTransposeToTosaOperator().

GetSize()

SizeType GetSize ( ) const

inline

Definition at line 351 of file Types.hpp.

{ return m_NumDimMappings; }

Referenced by ConstTensorPin::ConstTensorPin(), armnnOnnxParser::CreateConstTensorImpl(), PermutationVector::IsInverse(), PermutationVector::operator[](), armnnUtils::Permuted(), armnn::PermuteTensor(), armnnUtils::TransposeTensorShape(), PermuteQueueDescriptor::Validate(), and TransposeQueueDescriptor::Validate().

IsEqual()

bool IsEqual ( const PermutationVector &  other ) const

inline

Definition at line 360 of file Types.hpp.

    {
        if (m_NumDimMappings != other.m_NumDimMappings) return false;
        for (unsigned int i = 0; i < m_NumDimMappings; ++i)
        {
            if (m_DimMappings[i] != other.m_DimMappings[i]) return false;
        }
        return true;
    }

Referenced by TransposeLayer::IsEqual(), PermuteLayer::IsEqual(), PermuteDescriptor::operator==(), and TransposeDescriptor::operator==().

IsInverse()

bool IsInverse ( const PermutationVector &  other ) const

inline

Definition at line 370 of file Types.hpp.

    {
        bool isInverse = (GetSize() == other.GetSize());
        for (SizeType i = 0; isInverse && (i < GetSize()); ++i)
        {
            isInverse = (m_DimMappings[other.m_DimMappings[i]] == i);
        }
        return isInverse;
    }

References PermutationVector::GetSize().

Referenced by TransposeLayer::IsInverse(), and PermuteLayer::IsInverse().

operator[]()

ValueType operator[] ( SizeType  i ) const

inline

Indexing method with out-of-bounds error checking for the m_DimMappings array.

Parameters

i	- integer value corresponding to index of m_DimMappings array to retrieve element from.

Returns

element at index i of m_DimMappings array.

Exceptions

InvalidArgumentException

when indexing out-of-bounds index of m_DimMappings array.

Definition at line 341 of file Types.hpp.

    {
        if (i >= GetSize())
        {
            throw InvalidArgumentException("Invalid indexing of PermutationVector of size " + std::to_string(GetSize())
                                            + " at location [" + std::to_string(i) + "].");
        }
        return m_DimMappings.at(i);
    }

References PermutationVector::GetSize().

---

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

• include/armnn/Types.hpp
• src/armnn/Descriptors.cpp