ParserFlatbuffersFixture Struct Reference

#include <ParserFlatbuffersFixture.hpp>

Public Member Functions
	ParserFlatbuffersFixture ()
void	Setup (bool testDynamic=true)
std::unique_ptr< tflite::ModelT >	MakeModelDynamic (std::vector< uint8_t > graphBinary)
void	loadNetwork (armnn::NetworkId networkId, bool loadDynamic)
void	SetupSingleInputSingleOutput (const std::string &inputName, const std::string &outputName)
bool	ReadStringToBinary ()
template<std::size_t NumOutputDimensions, armnn::DataType ArmnnType>
void	RunTest (size_t subgraphId, const std::vector< armnn::ResolveType< ArmnnType >> &inputData, const std::vector< armnn::ResolveType< ArmnnType >> &expectedOutputData)
	Executes the network with the given input tensor and checks the result against the given output tensor. More...
template<std::size_t NumOutputDimensions, armnn::DataType ArmnnType>
void	RunTest (size_t subgraphId, const std::map< std::string, std::vector< armnn::ResolveType< ArmnnType >>> &inputData, const std::map< std::string, std::vector< armnn::ResolveType< ArmnnType >>> &expectedOutputData)
	Executes the network with the given input tensors and checks the results against the given output tensors. More...
template<std::size_t NumOutputDimensions, armnn::DataType ArmnnType1, armnn::DataType ArmnnType2>
void	RunTest (size_t subgraphId, const std::map< std::string, std::vector< armnn::ResolveType< ArmnnType1 >>> &inputData, const std::map< std::string, std::vector< armnn::ResolveType< ArmnnType2 >>> &expectedOutputData, bool isDynamic=false)
	Multiple Inputs, Multiple Outputs w/ Variable Datatypes and different dimension sizes. More...
template<std::size_t NumOutputDimensions, armnn::DataType inputType1, armnn::DataType inputType2, armnn::DataType outputType>
void	RunTest (size_t subgraphId, const std::map< std::string, std::vector< armnn::ResolveType< inputType1 >>> &input1Data, const std::map< std::string, std::vector< armnn::ResolveType< inputType2 >>> &input2Data, const std::map< std::string, std::vector< armnn::ResolveType< outputType >>> &expectedOutputData)
	Multiple Inputs with different DataTypes, Multiple Outputs w/ Variable DataTypes Executes the network with the given input tensors and checks the results against the given output tensors. More...
template<armnn::DataType ArmnnType1, armnn::DataType ArmnnType2>
void	RunTest (std::size_t subgraphId, const std::map< std::string, std::vector< armnn::ResolveType< ArmnnType1 >>> &inputData, const std::map< std::string, std::vector< armnn::ResolveType< ArmnnType2 >>> &expectedOutputData)
	Multiple Inputs, Multiple Outputs w/ Variable Datatypes and different dimension sizes. More...
void	CheckTensors (const TensorRawPtr &tensors, size_t shapeSize, const std::vector< int32_t > &shape, tflite::TensorType tensorType, uint32_t buffer, const std::string &name, const std::vector< float > &min, const std::vector< float > &max, const std::vector< float > &scale, const std::vector< int64_t > &zeroPoint)

Static Public Member Functions
static std::string	GenerateDetectionPostProcessJsonString (const armnn::DetectionPostProcessDescriptor &descriptor)

Public Attributes
std::vector< uint8_t >	m_GraphBinary
std::string	m_JsonString
armnn::IRuntimePtr	m_Runtime
armnn::NetworkId	m_NetworkIdentifier
armnn::NetworkId	m_DynamicNetworkIdentifier
bool	m_TestDynamic
std::unique_ptr< armnnTfLiteParser::TfLiteParserImpl >	m_Parser
std::string	m_SingleInputName
	If the single-input-single-output overload of Setup() is called, these will store the input and output name so they don't need to be passed to the single-input-single-output overload of RunTest(). More...
std::string	m_SingleOutputName

Detailed Description

Definition at line 36 of file ParserFlatbuffersFixture.hpp.

Constructor & Destructor Documentation

ParserFlatbuffersFixture()

ParserFlatbuffersFixture ( )

inline

Definition at line 38 of file ParserFlatbuffersFixture.hpp.

References m_Parser.

                               :
            m_Runtime(armnn::IRuntime::Create(armnn::IRuntime::CreationOptions())),
            m_NetworkIdentifier(0),
            m_DynamicNetworkIdentifier(1)
    {
        ITfLiteParser::TfLiteParserOptions options;
        options.m_StandInLayerForUnsupported = true;
        options.m_InferAndValidate = true;

        m_Parser = std::make_unique<armnnTfLiteParser::TfLiteParserImpl>(
                        armnn::Optional<ITfLiteParser::TfLiteParserOptions>(options));
    }

Member Function Documentation

CheckTensors()

void CheckTensors ( const TensorRawPtr &  tensors, size_t  shapeSize, const std::vector< int32_t > &  shape, tflite::TensorType  tensorType, uint32_t  buffer, const std::string &  name, const std::vector< float > &  min, const std::vector< float > &  max, const std::vector< float > &  scale, const std::vector< int64_t > &  zeroPoint  )

inline

Definition at line 265 of file ParserFlatbuffersFixture.hpp.

References m_Parser, and armnn::VerifyTensorInfoDataType().

    {
        CHECK(tensors);
        CHECK_EQ(shapeSize, tensors->shape.size());
        CHECK(std::equal(shape.begin(), shape.end(), tensors->shape.begin(), tensors->shape.end()));
        CHECK_EQ(tensorType, tensors->type);
        CHECK_EQ(buffer, tensors->buffer);
        CHECK_EQ(name, tensors->name);
        CHECK(tensors->quantization);
        CHECK(std::equal(min.begin(), min.end(), tensors->quantization.get()->min.begin(),
                                      tensors->quantization.get()->min.end()));
        CHECK(std::equal(max.begin(), max.end(), tensors->quantization.get()->max.begin(),
                                      tensors->quantization.get()->max.end()));
        CHECK(std::equal(scale.begin(), scale.end(), tensors->quantization.get()->scale.begin(),
                                      tensors->quantization.get()->scale.end()));
        CHECK(std::equal(zeroPoint.begin(), zeroPoint.end(),
                                      tensors->quantization.get()->zero_point.begin(),
                                      tensors->quantization.get()->zero_point.end()));
    }

GenerateDetectionPostProcessJsonString()

static std::string GenerateDetectionPostProcessJsonString ( const armnn::DetectionPostProcessDescriptor &  descriptor )

inlinestatic

Definition at line 238 of file ParserFlatbuffersFixture.hpp.

References DetectionPostProcessDescriptor::m_DetectionsPerClass, DetectionPostProcessDescriptor::m_MaxClassesPerDetection, DetectionPostProcessDescriptor::m_MaxDetections, DetectionPostProcessDescriptor::m_NmsIouThreshold, DetectionPostProcessDescriptor::m_NmsScoreThreshold, DetectionPostProcessDescriptor::m_NumClasses, DetectionPostProcessDescriptor::m_ScaleH, DetectionPostProcessDescriptor::m_ScaleW, DetectionPostProcessDescriptor::m_ScaleX, DetectionPostProcessDescriptor::m_ScaleY, and DetectionPostProcessDescriptor::m_UseRegularNms.

    {
        flexbuffers::Builder detectPostProcess;
        detectPostProcess.Map([&]() {
            detectPostProcess.Bool("use_regular_nms", descriptor.m_UseRegularNms);
            detectPostProcess.Int("max_detections", descriptor.m_MaxDetections);
            detectPostProcess.Int("max_classes_per_detection", descriptor.m_MaxClassesPerDetection);
            detectPostProcess.Int("detections_per_class", descriptor.m_DetectionsPerClass);
            detectPostProcess.Int("num_classes", descriptor.m_NumClasses);
            detectPostProcess.Float("nms_score_threshold", descriptor.m_NmsScoreThreshold);
            detectPostProcess.Float("nms_iou_threshold", descriptor.m_NmsIouThreshold);
            detectPostProcess.Float("h_scale", descriptor.m_ScaleH);
            detectPostProcess.Float("w_scale", descriptor.m_ScaleW);
            detectPostProcess.Float("x_scale", descriptor.m_ScaleX);
            detectPostProcess.Float("y_scale", descriptor.m_ScaleY);
        });
        detectPostProcess.Finish();

        // Create JSON string
        std::stringstream strStream;
        std::vector<uint8_t> buffer = detectPostProcess.GetBuffer();
        std::copy(buffer.begin(), buffer.end(),std::ostream_iterator<int>(strStream,","));

        return strStream.str();
    }

loadNetwork()

void loadNetwork ( armnn::NetworkId  networkId, bool  loadDynamic  )

inline

Definition at line 121 of file ParserFlatbuffersFixture.hpp.

References armnn::CpuRef, MakeModelDynamic(), armnn::Optimize(), ReadStringToBinary(), and armnn::Success.

Referenced by Setup().

    {
        bool ok = ReadStringToBinary();
        if (!ok) {
            throw armnn::Exception("LoadNetwork failed while reading binary input");
        }

        armnn::INetworkPtr network = loadDynamic ? m_Parser->LoadModel(MakeModelDynamic(m_GraphBinary))
                                                 : m_Parser->CreateNetworkFromBinary(m_GraphBinary);

        if (!network) {
            throw armnn::Exception("The parser failed to create an ArmNN network");
        }

        auto optimized = Optimize(*network, { armnn::Compute::CpuRef },
                                  m_Runtime->GetDeviceSpec());
        std::string errorMessage;

        armnn::Status ret = m_Runtime->LoadNetwork(networkId, move(optimized), errorMessage);

        if (ret != armnn::Status::Success)
        {
            throw armnn::Exception(
                fmt::format("The runtime failed to load the network. "
                            "Error was: {}. in {} [{}:{}]",
                            errorMessage,
                            __func__,
                            __FILE__,
                            __LINE__));
        }
    }

MakeModelDynamic()

std::unique_ptr<tflite::ModelT> MakeModelDynamic ( std::vector< uint8_t >  graphBinary )

inline

Definition at line 75 of file ParserFlatbuffersFixture.hpp.

References CHECK_LOCATION.

Referenced by loadNetwork().

    {
        const uint8_t* binaryContent = graphBinary.data();
        const size_t len = graphBinary.size();
        if (binaryContent == nullptr)
        {
            throw armnn::InvalidArgumentException(fmt::format("Invalid (null) binary content {}",
                                                               CHECK_LOCATION().AsString()));
        }
        flatbuffers::Verifier verifier(binaryContent, len);
        if (verifier.VerifyBuffer<tflite::Model>() == false)
        {
            throw armnn::ParseException(fmt::format("Buffer doesn't conform to the expected Tensorflow Lite "
                                                    "flatbuffers format. size:{} {}",
                                                    len,
                                                    CHECK_LOCATION().AsString()));
        }
        auto model =  tflite::UnPackModel(binaryContent);

        for (auto const& subgraph : model->subgraphs)
        {
            std::vector<int32_t> inputIds = subgraph->inputs;
            for (unsigned int tensorIndex = 0; tensorIndex < subgraph->tensors.size(); ++tensorIndex)
            {
                if (std::find(inputIds.begin(), inputIds.end(), tensorIndex) != inputIds.end())
                {
                    continue;
                }
                for (auto const& tensor : subgraph->tensors)
                {
                    if (tensor->shape_signature.size() != 0)
                    {
                        continue;
                    }

                    for (unsigned int i = 0; i < tensor->shape.size(); ++i)
                    {
                        tensor->shape_signature.push_back(-1);
                    }
                }
            }
        }

        return model;
    }

ReadStringToBinary()

bool ReadStringToBinary ( )

inline

Definition at line 161 of file ParserFlatbuffersFixture.hpp.

References ARMNN_ASSERT_MSG, g_TfLiteSchemaText, g_TfLiteSchemaText_len, and RunTest().

Referenced by loadNetwork(), and TEST_SUITE().

    {
        std::string schemafile(g_TfLiteSchemaText, g_TfLiteSchemaText + g_TfLiteSchemaText_len);

        // parse schema first, so we can use it to parse the data after
        flatbuffers::Parser parser;

        bool ok = parser.Parse(schemafile.c_str());
        ARMNN_ASSERT_MSG(ok, "Failed to parse schema file");

        ok &= parser.Parse(m_JsonString.c_str());
        ARMNN_ASSERT_MSG(ok, "Failed to parse json input");

        if (!ok)
        {
            return false;
        }

        {
            const uint8_t * bufferPtr = parser.builder_.GetBufferPointer();
            size_t size = static_cast<size_t>(parser.builder_.GetSize());
            m_GraphBinary.assign(bufferPtr, bufferPtr+size);
        }
        return ok;
    }

RunTest() [1/5]

void RunTest	(	size_t	subgraphId,
		const std::vector< armnn::ResolveType< armnnType >> &	inputData,
		const std::vector< armnn::ResolveType< armnnType >> &	expectedOutputData
	)

Executes the network with the given input tensor and checks the result against the given output tensor.

Single Input, Single Output Executes the network with the given input tensor and checks the result against the given output tensor.

This assumes the network has a single input and a single output.

This overload assumes the network has a single input and a single output.

Definition at line 316 of file ParserFlatbuffersFixture.hpp.

References m_SingleInputName, and m_SingleOutputName.

Referenced by ReadStringToBinary().

{
    RunTest<NumOutputDimensions, armnnType>(subgraphId,
                                            { { m_SingleInputName, inputData } },
                                            { { m_SingleOutputName, expectedOutputData } });
}

RunTest() [2/5]

void RunTest	(	size_t	subgraphId,
		const std::map< std::string, std::vector< armnn::ResolveType< armnnType >>> &	inputData,
		const std::map< std::string, std::vector< armnn::ResolveType< armnnType >>> &	expectedOutputData
	)

Executes the network with the given input tensors and checks the results against the given output tensors.

Multiple Inputs, Multiple Outputs Executes the network with the given input tensors and checks the results against the given output tensors.

This overload supports multiple inputs and multiple outputs, identified by name.

Definition at line 330 of file ParserFlatbuffersFixture.hpp.

{
    RunTest<NumOutputDimensions, armnnType, armnnType>(subgraphId, inputData, expectedOutputData);
}

RunTest() [3/5]

void RunTest	(	size_t	subgraphId,
		const std::map< std::string, std::vector< armnn::ResolveType< armnnType1 >>> &	inputData,
		const std::map< std::string, std::vector< armnn::ResolveType< armnnType2 >>> &	expectedOutputData,
		bool	isDynamic = false
	)

Multiple Inputs, Multiple Outputs w/ Variable Datatypes and different dimension sizes.

Multiple Inputs, Multiple Outputs w/ Variable Datatypes Executes the network with the given input tensors and checks the results against the given output tensors.

Executes the network with the given input tensors and checks the results against the given output tensors. This overload supports multiple inputs and multiple outputs, identified by name along with the allowance for the input datatype to be different to the output

This overload supports multiple inputs and multiple outputs, identified by name along with the allowance for the input datatype to be different to the output

Definition at line 344 of file ParserFlatbuffersFixture.hpp.

References CompareTensors(), TensorInfo::GetNumDimensions(), TensorInfo::GetNumElements(), m_DynamicNetworkIdentifier, m_NetworkIdentifier, m_Parser, m_Runtime, and armnn::VerifyTensorInfoDataType().

{
    using DataType2 = armnn::ResolveType<armnnType2>;

    // Setup the armnn input tensors from the given vectors.
    armnn::InputTensors inputTensors;
    FillInputTensors<armnnType1>(inputTensors, inputData, subgraphId);

    // Allocate storage for the output tensors to be written to and setup the armnn output tensors.
    std::map<std::string, std::vector<DataType2>> outputStorage;
    armnn::OutputTensors outputTensors;
    for (auto&& it : expectedOutputData)
    {
        armnn::LayerBindingId outputBindingId = m_Parser->GetNetworkOutputBindingInfo(subgraphId, it.first).first;
        armnn::TensorInfo outputTensorInfo = m_Runtime->GetOutputTensorInfo(m_NetworkIdentifier, outputBindingId);

        // Check that output tensors have correct number of dimensions (NumOutputDimensions specified in test)
        auto outputNumDimensions = outputTensorInfo.GetNumDimensions();
        CHECK_MESSAGE((outputNumDimensions == NumOutputDimensions),
            fmt::format("Number of dimensions expected {}, but got {} for output layer {}",
                        NumOutputDimensions,
                        outputNumDimensions,
                        it.first));

        armnn::VerifyTensorInfoDataType(outputTensorInfo, armnnType2);
        outputStorage.emplace(it.first, std::vector<DataType2>(outputTensorInfo.GetNumElements()));
        outputTensors.push_back(
                { outputBindingId, armnn::Tensor(outputTensorInfo, outputStorage.at(it.first).data()) });
    }

    m_Runtime->EnqueueWorkload(m_NetworkIdentifier, inputTensors, outputTensors);

    // Compare each output tensor to the expected values
    for (auto&& it : expectedOutputData)
    {
        armnn::BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(subgraphId, it.first);
        auto outputExpected = it.second;
        if (std::is_same<DataType2, uint8_t>::value)
        {
            auto result = CompareTensors(outputExpected, outputStorage[it.first],
                                         bindingInfo.second.GetShape(), bindingInfo.second.GetShape(),
                                         true, isDynamic);
            CHECK_MESSAGE(result.m_Result, result.m_Message.str());
        }
        else
        {
            auto result = CompareTensors(outputExpected, outputStorage[it.first],
                                         bindingInfo.second.GetShape(), bindingInfo.second.GetShape(),
                                         false, isDynamic);
            CHECK_MESSAGE(result.m_Result, result.m_Message.str());
        }
    }

    if (isDynamic)
    {
        m_Runtime->EnqueueWorkload(m_DynamicNetworkIdentifier, inputTensors, outputTensors);

        // Compare each output tensor to the expected values
        for (auto&& it : expectedOutputData)
        {
            armnn::BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(subgraphId, it.first);
            auto outputExpected = it.second;
            auto result = CompareTensors(outputExpected, outputStorage[it.first],
                                         bindingInfo.second.GetShape(), bindingInfo.second.GetShape(),
                                         false, isDynamic);
            CHECK_MESSAGE(result.m_Result, result.m_Message.str());
        }
    }
}

RunTest() [4/5]

void RunTest	(	size_t	subgraphId,
		const std::map< std::string, std::vector< armnn::ResolveType< inputType1 >>> &	input1Data,
		const std::map< std::string, std::vector< armnn::ResolveType< inputType2 >>> &	input2Data,
		const std::map< std::string, std::vector< armnn::ResolveType< outputType >>> &	expectedOutputData
	)

Multiple Inputs with different DataTypes, Multiple Outputs w/ Variable DataTypes Executes the network with the given input tensors and checks the results against the given output tensors.

This overload supports multiple inputs and multiple outputs, identified by name along with the allowance for the input datatype to be different to the output

Definition at line 471 of file ParserFlatbuffersFixture.hpp.

References CompareTensors(), TensorInfo::GetNumDimensions(), TensorInfo::GetNumElements(), m_NetworkIdentifier, m_Parser, m_Runtime, and armnn::VerifyTensorInfoDataType().

{
    using DataType2 = armnn::ResolveType<outputType>;

    // Setup the armnn input tensors from the given vectors.
    armnn::InputTensors inputTensors;
    FillInputTensors<inputType1>(inputTensors, input1Data, subgraphId);
    FillInputTensors<inputType2>(inputTensors, input2Data, subgraphId);

    // Allocate storage for the output tensors to be written to and setup the armnn output tensors.
    std::map<std::string, std::vector<DataType2>> outputStorage;
    armnn::OutputTensors outputTensors;
    for (auto&& it : expectedOutputData)
    {
        armnn::LayerBindingId outputBindingId = m_Parser->GetNetworkOutputBindingInfo(subgraphId, it.first).first;
        armnn::TensorInfo outputTensorInfo = m_Runtime->GetOutputTensorInfo(m_NetworkIdentifier, outputBindingId);

        // Check that output tensors have correct number of dimensions (NumOutputDimensions specified in test)
        auto outputNumDimensions = outputTensorInfo.GetNumDimensions();
        CHECK_MESSAGE((outputNumDimensions == NumOutputDimensions),
            fmt::format("Number of dimensions expected {}, but got {} for output layer {}",
                        NumOutputDimensions,
                        outputNumDimensions,
                        it.first));

        armnn::VerifyTensorInfoDataType(outputTensorInfo, outputType);
        outputStorage.emplace(it.first, std::vector<DataType2>(outputTensorInfo.GetNumElements()));
        outputTensors.push_back(
                { outputBindingId, armnn::Tensor(outputTensorInfo, outputStorage.at(it.first).data()) });
    }

    m_Runtime->EnqueueWorkload(m_NetworkIdentifier, inputTensors, outputTensors);

    // Compare each output tensor to the expected values
    for (auto&& it : expectedOutputData)
    {
        armnn::BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(subgraphId, it.first);
        auto outputExpected = it.second;
        if (std::is_same<DataType2, uint8_t>::value)
        {
            auto result = CompareTensors(outputExpected, outputStorage[it.first],
                                         bindingInfo.second.GetShape(), bindingInfo.second.GetShape(), true);
            CHECK_MESSAGE(result.m_Result, result.m_Message.str());
        }
        else
        {
            auto result = CompareTensors(outputExpected, outputStorage[it.first],
                                         bindingInfo.second.GetShape(), bindingInfo.second.GetShape());
            CHECK_MESSAGE(result.m_Result, result.m_Message.str());
        }
    }
}

RunTest() [5/5]

void RunTest	(	std::size_t	subgraphId,
		const std::map< std::string, std::vector< armnn::ResolveType< armnnType1 >>> &	inputData,
		const std::map< std::string, std::vector< armnn::ResolveType< armnnType2 >>> &	expectedOutputData
	)

Multiple Inputs, Multiple Outputs w/ Variable Datatypes and different dimension sizes.

Executes the network with the given input tensors and checks the results against the given output tensors. This overload supports multiple inputs and multiple outputs, identified by name along with the allowance for the input datatype to be different to the output

Executes the network with the given input tensors and checks the results against the given output tensors. This overload supports multiple inputs and multiple outputs, identified by name along with the allowance for the input datatype to be different to the output.

Definition at line 423 of file ParserFlatbuffersFixture.hpp.

References m_NetworkIdentifier, m_Parser, m_Runtime, and armnn::VerifyTensorInfoDataType().

{
    using DataType2 = armnn::ResolveType<armnnType2>;

    // Setup the armnn input tensors from the given vectors.
    armnn::InputTensors inputTensors;
    FillInputTensors<armnnType1>(inputTensors, inputData, subgraphId);

    armnn::OutputTensors outputTensors;
    outputTensors.reserve(expectedOutputData.size());
    std::map<std::string, std::vector<DataType2>> outputStorage;
    for (auto&& it : expectedOutputData)
    {
        armnn::BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(subgraphId, it.first);
        armnn::VerifyTensorInfoDataType(bindingInfo.second, armnnType2);

        std::vector<DataType2> out(it.second.size());
        outputStorage.emplace(it.first, out);
        outputTensors.push_back({ bindingInfo.first,
                                  armnn::Tensor(bindingInfo.second,
                                  outputStorage.at(it.first).data()) });
    }

    m_Runtime->EnqueueWorkload(m_NetworkIdentifier, inputTensors, outputTensors);

    // Checks the results.
    for (auto&& it : expectedOutputData)
    {
        std::vector<armnn::ResolveType<armnnType2>> out = outputStorage.at(it.first);
        {
            for (unsigned int i = 0; i < out.size(); ++i)
            {
                CHECK(doctest::Approx(it.second[i]).epsilon(0.000001f) == out[i]);
            }
        }
    }
}

Setup()

void Setup ( bool  testDynamic = true )

inline

Definition at line 64 of file ParserFlatbuffersFixture.hpp.

References loadNetwork().

Referenced by SetupSingleInputSingleOutput(), and TEST_SUITE().

    {
        m_TestDynamic = testDynamic;
        loadNetwork(m_NetworkIdentifier, false);

        if (m_TestDynamic)
        {
            loadNetwork(m_DynamicNetworkIdentifier, true);
        }
    }

SetupSingleInputSingleOutput()

void SetupSingleInputSingleOutput ( const std::string &  inputName, const std::string &  outputName  )

inline

Definition at line 153 of file ParserFlatbuffersFixture.hpp.

References Setup().

Referenced by TEST_SUITE().

    {
        // Store the input and output name so they don't need to be passed to the single-input-single-output RunTest().
        m_SingleInputName = inputName;
        m_SingleOutputName = outputName;
        Setup();
    }

Member Data Documentation

m_DynamicNetworkIdentifier

armnn::NetworkId m_DynamicNetworkIdentifier

Definition at line 55 of file ParserFlatbuffersFixture.hpp.

Referenced by RunTest().

m_GraphBinary

std::vector<uint8_t> m_GraphBinary

Definition at line 51 of file ParserFlatbuffersFixture.hpp.

m_JsonString

std::string m_JsonString

Definition at line 52 of file ParserFlatbuffersFixture.hpp.

m_NetworkIdentifier

armnn::NetworkId m_NetworkIdentifier

Definition at line 54 of file ParserFlatbuffersFixture.hpp.

Referenced by RunTest().

m_Parser

std::unique_ptr<armnnTfLiteParser::TfLiteParserImpl> m_Parser

Definition at line 57 of file ParserFlatbuffersFixture.hpp.

Referenced by CheckTensors(), ParserFlatbuffersFixture(), and RunTest().

m_Runtime

armnn::IRuntimePtr m_Runtime

Definition at line 53 of file ParserFlatbuffersFixture.hpp.

Referenced by RunTest().

m_SingleInputName

std::string m_SingleInputName

If the single-input-single-output overload of Setup() is called, these will store the input and output name so they don't need to be passed to the single-input-single-output overload of RunTest().

Definition at line 61 of file ParserFlatbuffersFixture.hpp.

Referenced by RunTest().

m_SingleOutputName

std::string m_SingleOutputName

Definition at line 62 of file ParserFlatbuffersFixture.hpp.

Referenced by RunTest().

m_TestDynamic

bool m_TestDynamic

Definition at line 56 of file ParserFlatbuffersFixture.hpp.

---

The documentation for this struct was generated from the following file:

• src/armnnTfLiteParser/test/ParserFlatbuffersFixture.hpp