LayerVerifierBase Class Reference

#include <SerializerTestUtils.hpp>

Inheritance diagram for LayerVerifierBase:

Public Member Functions
	LayerVerifierBase (const std::string &layerName, const std::vector< armnn::TensorInfo > &inputInfos, const std::vector< armnn::TensorInfo > &outputInfos)
void	ExecuteStrategy (const armnn::IConnectableLayer *layer, const armnn::BaseDescriptor &descriptor, const std::vector< armnn::ConstTensor > &constants, const char *name, const armnn::LayerBindingId id=0) override
Public Member Functions inherited from IStrategy
virtual void	ExecuteStrategy (const IConnectableLayer *layer, const armnn::BaseDescriptor &descriptor, const std::vector< armnn::ConstTensor > &constants, const char *name, const armnn::LayerBindingId id=0)=0
virtual void	FinishStrategy ()

Protected Member Functions
void	VerifyNameAndConnections (const armnn::IConnectableLayer *layer, const char *name)
void	VerifyConstTensors (const std::string &tensorName, const armnn::ConstTensor *expectedPtr, const armnn::ConstTensor *actualPtr)
Protected Member Functions inherited from IStrategy
	IStrategy ()
virtual	~IStrategy ()

Detailed Description

Definition at line 24 of file SerializerTestUtils.hpp.

Constructor & Destructor Documentation

LayerVerifierBase()

LayerVerifierBase	(	const std::string &	layerName,
		const std::vector< armnn::TensorInfo > &	inputInfos,
		const std::vector< armnn::TensorInfo > &	outputInfos
	)

Definition at line 13 of file SerializerTestUtils.cpp.

Referenced by TEST_SUITE().

                                     : m_LayerName(layerName)
                                     , m_InputTensorInfos(inputInfos)
                                     , m_OutputTensorInfos(outputInfos)
{}

Member Function Documentation

ExecuteStrategy()

void ExecuteStrategy ( const armnn::IConnectableLayer *  layer, const armnn::BaseDescriptor &  descriptor, const std::vector< armnn::ConstTensor > &  constants, const char *  name, const armnn::LayerBindingId  id = 0  )

override

Definition at line 21 of file SerializerTestUtils.cpp.

References IConnectableLayer::GetType(), armnn::IgnoreUnused(), armnn::Input, armnn::Output, and VerifyNameAndConnections().

Referenced by TEST_SUITE().

{
    armnn::IgnoreUnused(descriptor, constants, id);
    switch (layer->GetType())
    {
        case armnn::LayerType::Input: break;
        case armnn::LayerType::Output: break;
        default:
        {
            VerifyNameAndConnections(layer, name);
        }
    }
}

VerifyConstTensors()

void VerifyConstTensors ( const std::string &  tensorName, const armnn::ConstTensor *  expectedPtr, const armnn::ConstTensor *  actualPtr  )

protected

Definition at line 78 of file SerializerTestUtils.cpp.

References TensorInfo::GetDataType(), armnn::GetDataTypeName(), BaseTensor< MemoryType >::GetInfo(), BaseTensor< MemoryType >::GetMemoryArea(), BaseTensor< MemoryType >::GetNumBytes(), and TensorInfo::GetShape().

Referenced by TEST_SUITE().

{
    if (expectedPtr == nullptr)
    {
        CHECK_MESSAGE(actualPtr == nullptr, (tensorName + " should not exist"));
    }
    else
    {
        CHECK_MESSAGE(actualPtr != nullptr, (tensorName + " should have been set"));
        if (actualPtr != nullptr)
        {
            const armnn::TensorInfo& expectedInfo = expectedPtr->GetInfo();
            const armnn::TensorInfo& actualInfo = actualPtr->GetInfo();

            CHECK_MESSAGE(expectedInfo.GetShape() == actualInfo.GetShape(),
                          (tensorName + " shapes don't match"));
            CHECK_MESSAGE(
                    GetDataTypeName(expectedInfo.GetDataType()) == GetDataTypeName(actualInfo.GetDataType()),
                    (tensorName + " data types don't match"));

            CHECK_MESSAGE(expectedPtr->GetNumBytes() == actualPtr->GetNumBytes(),
                          (tensorName + " (GetNumBytes) data sizes do not match"));
            if (expectedPtr->GetNumBytes() == actualPtr->GetNumBytes())
            {
                //check the data is identical
                const char* expectedData = static_cast<const char*>(expectedPtr->GetMemoryArea());
                const char* actualData = static_cast<const char*>(actualPtr->GetMemoryArea());
                bool same = true;
                for (unsigned int i = 0; i < expectedPtr->GetNumBytes(); ++i)
                {
                    same = expectedData[i] == actualData[i];
                    if (!same)
                    {
                        break;
                    }
                }
                CHECK_MESSAGE(same, (tensorName + " data does not match"));
            }
        }
    }
}

VerifyNameAndConnections()

void VerifyNameAndConnections ( const armnn::IConnectableLayer *  layer, const char *  name  )

protected

Definition at line 40 of file SerializerTestUtils.cpp.

References IInputSlot::GetConnection(), TensorInfo::GetDataType(), armnn::GetDataTypeName(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetNumInputSlots(), IConnectableLayer::GetNumOutputSlots(), IConnectableLayer::GetOutputSlot(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), TensorInfo::GetQuantizationScales(), TensorInfo::GetShape(), IOutputSlot::GetTensorInfo(), and TensorInfo::HasMultipleQuantizationScales().

Referenced by ExecuteStrategy(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), LayerVerifierBaseWithDescriptorAndConstants< Descriptor >::ExecuteStrategy(), and TEST_SUITE().

{
    CHECK(std::string(name) == m_LayerName.c_str());

    CHECK(layer->GetNumInputSlots() == m_InputTensorInfos.size());
    CHECK(layer->GetNumOutputSlots() == m_OutputTensorInfos.size());

    for (unsigned int i = 0; i < m_InputTensorInfos.size(); i++)
    {
        const armnn::IOutputSlot* connectedOutput = layer->GetInputSlot(i).GetConnection();
        CHECK(connectedOutput);

        const armnn::TensorInfo& connectedInfo = connectedOutput->GetTensorInfo();
        CHECK(connectedInfo.GetShape() == m_InputTensorInfos[i].GetShape());
        CHECK(GetDataTypeName(connectedInfo.GetDataType()) == GetDataTypeName(m_InputTensorInfos[i].GetDataType()));

        if (connectedInfo.HasMultipleQuantizationScales())
        {
            CHECK(connectedInfo.GetQuantizationScales() == m_InputTensorInfos[i].GetQuantizationScales());
        }
        else
        {
            CHECK(connectedInfo.GetQuantizationScale() == m_InputTensorInfos[i].GetQuantizationScale());
        }
        CHECK(connectedInfo.GetQuantizationOffset() == m_InputTensorInfos[i].GetQuantizationOffset());
    }

    for (unsigned int i = 0; i < m_OutputTensorInfos.size(); i++)
    {
        const armnn::TensorInfo& outputInfo = layer->GetOutputSlot(i).GetTensorInfo();
        CHECK(outputInfo.GetShape() == m_OutputTensorInfos[i].GetShape());
        CHECK(GetDataTypeName(outputInfo.GetDataType()) == GetDataTypeName(m_OutputTensorInfos[i].GetDataType()));

        CHECK(outputInfo.GetQuantizationScale() == m_OutputTensorInfos[i].GetQuantizationScale());
        CHECK(outputInfo.GetQuantizationOffset() == m_OutputTensorInfos[i].GetQuantizationOffset());
    }
}

---

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

• src/armnnSerializer/test/SerializerTestUtils.hpp
• src/armnnSerializer/test/SerializerTestUtils.cpp