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 295 of file Types.hpp.

Member Typedef Documentation

ArrayType

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

Definition at line 300 of file Types.hpp.

ConstIterator

using ConstIterator = typename ArrayType::const_iterator

Definition at line 301 of file Types.hpp.

SizeType

using SizeType = unsigned int

Definition at line 299 of file Types.hpp.

ValueType

using ValueType = unsigned int

Definition at line 298 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.

References armnn::MaxNumOfTensorDimensions.

{
    // 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;
}

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 340 of file Types.hpp.

Referenced by TEST_SUITE().

{ return m_DimMappings.begin(); }

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 345 of file Types.hpp.

{ return m_DimMappings.begin() + m_NumDimMappings; }

GetSize()

SizeType GetSize ( ) const

inline

Definition at line 338 of file Types.hpp.

Referenced by armnnOnnxParser::CreateConstTensorImpl(), armnnSerializer::GetFlatBufferArgMinMaxFunction(), PermutationVector::IsInverse(), armnnUtils::Permuted(), armnn::PermuteTensor(), PermuteAsReshapeImpl::Run(), TransposeAsReshapeImpl::Run(), armnnUtils::TransposeTensorShape(), PermuteQueueDescriptor::Validate(), and TransposeQueueDescriptor::Validate().

{ return m_NumDimMappings; }

IsEqual()

bool IsEqual ( const PermutationVector &  other ) const

inline

Definition at line 347 of file Types.hpp.

Referenced by TransposeLayer::IsEqual(), PermuteLayer::IsEqual(), and PermuteInputsForConcat().

    {
        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;
    }

IsInverse()

bool IsInverse ( const PermutationVector &  other ) const

inline

Definition at line 357 of file Types.hpp.

References PermutationVector::GetSize().

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

    {
        bool isInverse = (GetSize() == other.GetSize());
        for (SizeType i = 0; isInverse && (i < GetSize()); ++i)
        {
            isInverse = (m_DimMappings[other.m_DimMappings[i]] == i);
        }
        return 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 328 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);
    }

---

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

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