NeonCreateWorkloadTests.cpp File Reference

#include "NeonWorkloadFactoryHelper.hpp"
#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <armnn/utility/Assert.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include <backendsCommon/MemCopyWorkload.hpp>
#include <aclCommon/test/CreateWorkloadClNeon.hpp>
#include <neon/NeonWorkloadFactory.hpp>
#include <neon/NeonTensorHandle.hpp>
#include <neon/workloads/NeonWorkloadUtils.hpp>
#include <neon/workloads/NeonWorkloads.hpp>

Go to the source code of this file.

Functions
	BOOST_AUTO_TEST_CASE (CreateActivationFloatWorkload)
	BOOST_AUTO_TEST_CASE (CreateAdditionFloatWorkload)
	BOOST_AUTO_TEST_CASE (CreateSubtractionFloatWorkload)
	BOOST_AUTO_TEST_CASE (CreateSubtractionUint8Workload)
	BOOST_AUTO_TEST_CASE (CreateMultiplicationFloatWorkload)
	BOOST_AUTO_TEST_CASE (CreateMultiplicationUint8Workload)
	BOOST_AUTO_TEST_CASE (CreateDivisionFloatWorkloadTest)
	BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloatNchwWorkload)
	BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloatNhwcWorkload)
	BOOST_AUTO_TEST_CASE (CreateConvolution2dFloatNchwWorkload)
	BOOST_AUTO_TEST_CASE (CreateConvolution2dFloatNhwcWorkload)
	BOOST_AUTO_TEST_CASE (CreateConvolution2dFastMathEnabledWorkload)
	BOOST_AUTO_TEST_CASE (CreateDepthWiseConvolution2dFloat32NhwcWorkload)
	BOOST_AUTO_TEST_CASE (CreateFullyConnectedFloatWorkload)
	BOOST_AUTO_TEST_CASE (CreateFullyConnectedQAsymmU8Workload)
	BOOST_AUTO_TEST_CASE (CreateFullyConnectedQAsymmS8Workload)
	BOOST_AUTO_TEST_CASE (CreateNormalizationFloatNchwWorkload)
	BOOST_AUTO_TEST_CASE (CreateNormalizationFloatNhwcWorkload)
	BOOST_AUTO_TEST_CASE (CreatePooling2dFloatNchwWorkload)
	BOOST_AUTO_TEST_CASE (CreatePooling2dFloatNhwcWorkload)
	BOOST_AUTO_TEST_CASE (CreatePooling2dUint8NchwWorkload)
	BOOST_AUTO_TEST_CASE (CreatePooling2dUint8NhwcWorkload)
	BOOST_AUTO_TEST_CASE (CreatePreluFloatWorkload)
	BOOST_AUTO_TEST_CASE (CreatePreluUint8Workload)
	BOOST_AUTO_TEST_CASE (CreateReshapeFloatWorkload)
	BOOST_AUTO_TEST_CASE (CreateReshapeUint8Workload)
	BOOST_AUTO_TEST_CASE (CreateResizeFloat32NchwWorkload)
	BOOST_AUTO_TEST_CASE (CreateResizeUint8NchwWorkload)
	BOOST_AUTO_TEST_CASE (CreateResizeFloat32NhwcWorkload)
	BOOST_AUTO_TEST_CASE (CreateResizeUint8NhwcWorkload)
	BOOST_AUTO_TEST_CASE (CreateSoftmaxFloatWorkload)
	BOOST_AUTO_TEST_CASE (CreateSoftmaxQAsymmU8Workload)
	BOOST_AUTO_TEST_CASE (CreateSoftmaxQAsymmS8Workload)
	BOOST_AUTO_TEST_CASE (CreateSpaceToDepthFloat32Workload)
	BOOST_AUTO_TEST_CASE (CreateSpaceToDepthFloat16Workload)
	BOOST_AUTO_TEST_CASE (CreateSpaceToDepthQAsymm8Workload)
	BOOST_AUTO_TEST_CASE (CreateSpaceToDepthQSymm16Workload)
	BOOST_AUTO_TEST_CASE (CreateSplitterWorkload)
	BOOST_AUTO_TEST_CASE (CreateSplitterConcat)
	BOOST_AUTO_TEST_CASE (CreateSingleOutputMultipleInputs)
	BOOST_AUTO_TEST_CASE (CreateL2NormalizationNchwWorkload)
	BOOST_AUTO_TEST_CASE (CreateL2NormalizationNhwcWorkload)
	BOOST_AUTO_TEST_CASE (CreateLogSoftmaxFloatWorkload)
	BOOST_AUTO_TEST_CASE (CreateLSTMWorkloadFloatWorkload)
	BOOST_AUTO_TEST_CASE (CreateConcatDim0Float32Workload)
	BOOST_AUTO_TEST_CASE (CreateConcatDim1Float32Workload)
	BOOST_AUTO_TEST_CASE (CreateConcatDim3Float32Workload)
	BOOST_AUTO_TEST_CASE (CreateConcatDim0Uint8Workload)
	BOOST_AUTO_TEST_CASE (CreateConcatDim1Uint8Workload)
	BOOST_AUTO_TEST_CASE (CreateConcatDim3Uint8Workload)
	BOOST_AUTO_TEST_CASE (CreateStackFloat32Workload)
	BOOST_AUTO_TEST_CASE (CreateStackUint8Workload)
	BOOST_AUTO_TEST_CASE (CreateQuantizedLstmWorkload)
	BOOST_AUTO_TEST_CASE (CreateQLstmWorkloadTest)

Function Documentation

BOOST_AUTO_TEST_CASE() [1/54]

BOOST_AUTO_TEST_CASE

(

CreateActivationFloatWorkload

)

Definition at line 91 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateActivationWorkloadTest<DataType::Float32>();
}

BOOST_AUTO_TEST_CASE() [2/54]

BOOST_AUTO_TEST_CASE

(

CreateAdditionFloatWorkload

)

Definition at line 127 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateElementwiseWorkloadTest<NeonAdditionWorkload,
                                      AdditionQueueDescriptor,
                                      AdditionLayer,
                                      DataType::Float32>();
}

BOOST_AUTO_TEST_CASE() [3/54]

BOOST_AUTO_TEST_CASE

(

CreateSubtractionFloatWorkload

)

Definition at line 145 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateElementwiseWorkloadTest<NeonSubtractionWorkload,
                                      SubtractionQueueDescriptor,
                                      SubtractionLayer,
                                      DataType::Float32>();
}

BOOST_AUTO_TEST_CASE() [4/54]

BOOST_AUTO_TEST_CASE

(

CreateSubtractionUint8Workload

)

Definition at line 153 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateElementwiseWorkloadTest<NeonSubtractionWorkload,
                                      SubtractionQueueDescriptor,
                                      SubtractionLayer,
                                      DataType::QAsymmU8>();
}

BOOST_AUTO_TEST_CASE() [5/54]

BOOST_AUTO_TEST_CASE

(

CreateMultiplicationFloatWorkload

)

Definition at line 171 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateElementwiseWorkloadTest<NeonMultiplicationWorkload,
                                      MultiplicationQueueDescriptor,
                                      MultiplicationLayer,
                                      DataType::Float32>();
}

BOOST_AUTO_TEST_CASE() [6/54]

BOOST_AUTO_TEST_CASE

(

CreateMultiplicationUint8Workload

)

Definition at line 179 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateElementwiseWorkloadTest<NeonMultiplicationWorkload,
                                      MultiplicationQueueDescriptor,
                                      MultiplicationLayer,
                                      DataType::QAsymmU8>();
}

BOOST_AUTO_TEST_CASE() [7/54]

BOOST_AUTO_TEST_CASE

(

CreateDivisionFloatWorkloadTest

)

Definition at line 187 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateElementwiseWorkloadTest<NeonDivisionWorkload,
                                      DivisionQueueDescriptor,
                                      DivisionLayer,
                                      armnn::DataType::Float32>();
}

BOOST_AUTO_TEST_CASE() [8/54]

BOOST_AUTO_TEST_CASE

(

CreateBatchNormalizationFloatNchwWorkload

)

Definition at line 229 of file NeonCreateWorkloadTests.cpp.

References armnn::NCHW.

{
    NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float32>(DataLayout::NCHW);
}

BOOST_AUTO_TEST_CASE() [9/54]

BOOST_AUTO_TEST_CASE

(

CreateBatchNormalizationFloatNhwcWorkload

)

Definition at line 234 of file NeonCreateWorkloadTests.cpp.

References armnn::NHWC.

{
    NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float32>(DataLayout::NHWC);
}

BOOST_AUTO_TEST_CASE() [10/54]

BOOST_AUTO_TEST_CASE

(

CreateConvolution2dFloatNchwWorkload

)

Definition at line 271 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateConvolution2dWorkloadTest<DataType::Float32>();
}

BOOST_AUTO_TEST_CASE() [11/54]

BOOST_AUTO_TEST_CASE

(

CreateConvolution2dFloatNhwcWorkload

)

Definition at line 276 of file NeonCreateWorkloadTests.cpp.

References armnn::NHWC.

{
    NeonCreateConvolution2dWorkloadTest<DataType::Float32>(DataLayout::NHWC);
}

BOOST_AUTO_TEST_CASE() [12/54]

BOOST_AUTO_TEST_CASE

(

CreateConvolution2dFastMathEnabledWorkload

)

Definition at line 281 of file NeonCreateWorkloadTests.cpp.

References ARMNN_ASSERT, armnn::IgnoreUnused(), and armnn::NCHW.

{
    Graph graph;
    using ModelOptions = std::vector<BackendOptions>;
    ModelOptions modelOptions = {};
    BackendOptions cpuAcc("CpuAcc",
    {
        { "FastMathEnabled", true }
    });
    modelOptions.push_back(cpuAcc);
    NeonWorkloadFactory factory =
        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager(), modelOptions);

    auto workload =
        CreateConvolution2dWorkloadFastMathTest<NeonConvolution2dWorkload, armnn::DataType::Float32>(factory,
                                                                                             graph,
                                                                                             DataLayout::NCHW,
                                                                                             modelOptions);

    ARMNN_ASSERT(workload != nullptr);
    auto conv2dWorkload = PolymorphicDowncast<NeonConvolution2dWorkload*>(workload.get());
    IgnoreUnused(conv2dWorkload);
    ARMNN_ASSERT(conv2dWorkload != nullptr);
    ARMNN_ASSERT(conv2dWorkload->GetConvolutionMethod() == arm_compute::ConvolutionMethod::WINOGRAD);
}

BOOST_AUTO_TEST_CASE() [13/54]

BOOST_AUTO_TEST_CASE

(

CreateDepthWiseConvolution2dFloat32NhwcWorkload

)

Definition at line 331 of file NeonCreateWorkloadTests.cpp.

References armnn::BOOST_AUTO_TEST_CASE(), and armnn::NHWC.

{
    NeonCreateDepthWiseConvolutionWorkloadTest<DataType::Float32>(DataLayout::NHWC);
}

BOOST_AUTO_TEST_CASE() [14/54]

BOOST_AUTO_TEST_CASE

(

CreateFullyConnectedFloatWorkload

)

Definition at line 371 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::Float32>();
}

BOOST_AUTO_TEST_CASE() [15/54]

BOOST_AUTO_TEST_CASE

(

CreateFullyConnectedQAsymmU8Workload

)

Definition at line 376 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::QAsymmU8>();
}

BOOST_AUTO_TEST_CASE() [16/54]

BOOST_AUTO_TEST_CASE

(

CreateFullyConnectedQAsymmS8Workload

)

Definition at line 381 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::QAsymmS8>();
}

BOOST_AUTO_TEST_CASE() [17/54]

BOOST_AUTO_TEST_CASE

(

CreateNormalizationFloatNchwWorkload

)

Definition at line 419 of file NeonCreateWorkloadTests.cpp.

References armnn::NCHW.

{
    NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(DataLayout::NCHW);
}

BOOST_AUTO_TEST_CASE() [18/54]

BOOST_AUTO_TEST_CASE

(

CreateNormalizationFloatNhwcWorkload

)

Definition at line 424 of file NeonCreateWorkloadTests.cpp.

References armnn::NHWC.

{
    NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(DataLayout::NHWC);
}

BOOST_AUTO_TEST_CASE() [19/54]

BOOST_AUTO_TEST_CASE

(

CreatePooling2dFloatNchwWorkload

)

Definition at line 457 of file NeonCreateWorkloadTests.cpp.

References armnn::NCHW.

{
    NeonCreatePooling2dWorkloadTest<DataType::Float32>(DataLayout::NCHW);
}

BOOST_AUTO_TEST_CASE() [20/54]

BOOST_AUTO_TEST_CASE

(

CreatePooling2dFloatNhwcWorkload

)

Definition at line 462 of file NeonCreateWorkloadTests.cpp.

References armnn::NHWC.

{
    NeonCreatePooling2dWorkloadTest<DataType::Float32>(DataLayout::NHWC);
}

BOOST_AUTO_TEST_CASE() [21/54]

BOOST_AUTO_TEST_CASE

(

CreatePooling2dUint8NchwWorkload

)

Definition at line 467 of file NeonCreateWorkloadTests.cpp.

References armnn::NCHW.

{
    NeonCreatePooling2dWorkloadTest<DataType::QAsymmU8>(DataLayout::NCHW);
}

BOOST_AUTO_TEST_CASE() [22/54]

BOOST_AUTO_TEST_CASE

(

CreatePooling2dUint8NhwcWorkload

)

Definition at line 472 of file NeonCreateWorkloadTests.cpp.

References armnn::NHWC.

{
    NeonCreatePooling2dWorkloadTest<DataType::QAsymmU8>(DataLayout::NHWC);
}

BOOST_AUTO_TEST_CASE() [23/54]

BOOST_AUTO_TEST_CASE

(

CreatePreluFloatWorkload

)

Definition at line 510 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float32);
}

BOOST_AUTO_TEST_CASE() [24/54]

BOOST_AUTO_TEST_CASE

(

CreatePreluUint8Workload

)

Definition at line 515 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::QAsymmU8);
}

BOOST_AUTO_TEST_CASE() [25/54]

BOOST_AUTO_TEST_CASE

(

CreateReshapeFloatWorkload

)

Definition at line 544 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateReshapeWorkloadTest<DataType::Float32>();
}

BOOST_AUTO_TEST_CASE() [26/54]

BOOST_AUTO_TEST_CASE

(

CreateReshapeUint8Workload

)

Definition at line 549 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateReshapeWorkloadTest<DataType::QAsymmU8>();
}

BOOST_AUTO_TEST_CASE() [27/54]

BOOST_AUTO_TEST_CASE

(

CreateResizeFloat32NchwWorkload

)

Definition at line 580 of file NeonCreateWorkloadTests.cpp.

References armnn::NCHW.

{
    NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
}

BOOST_AUTO_TEST_CASE() [28/54]

BOOST_AUTO_TEST_CASE

(

CreateResizeUint8NchwWorkload

)

Definition at line 585 of file NeonCreateWorkloadTests.cpp.

References armnn::NCHW.

{
    NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
}

BOOST_AUTO_TEST_CASE() [29/54]

BOOST_AUTO_TEST_CASE

(

CreateResizeFloat32NhwcWorkload

)

Definition at line 590 of file NeonCreateWorkloadTests.cpp.

References armnn::NHWC.

{
    NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
}

BOOST_AUTO_TEST_CASE() [30/54]

BOOST_AUTO_TEST_CASE

(

CreateResizeUint8NhwcWorkload

)

Definition at line 595 of file NeonCreateWorkloadTests.cpp.

References armnn::NHWC.

{
    NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
}

BOOST_AUTO_TEST_CASE() [31/54]

BOOST_AUTO_TEST_CASE

(

CreateSoftmaxFloatWorkload

)

Definition at line 635 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::Float32>();
}

BOOST_AUTO_TEST_CASE() [32/54]

BOOST_AUTO_TEST_CASE

(

CreateSoftmaxQAsymmU8Workload

)

Definition at line 640 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::QAsymmU8>();
}

BOOST_AUTO_TEST_CASE() [33/54]

BOOST_AUTO_TEST_CASE

(

CreateSoftmaxQAsymmS8Workload

)

Definition at line 645 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::QAsymmS8>();
}

BOOST_AUTO_TEST_CASE() [34/54]

BOOST_AUTO_TEST_CASE

(

CreateSpaceToDepthFloat32Workload

)

Definition at line 667 of file NeonCreateWorkloadTests.cpp.

{
    NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float32>();
}

BOOST_AUTO_TEST_CASE() [35/54]

BOOST_AUTO_TEST_CASE

(

CreateSpaceToDepthFloat16Workload

)

Definition at line 672 of file NeonCreateWorkloadTests.cpp.

{
    NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float16>();
}

BOOST_AUTO_TEST_CASE() [36/54]

BOOST_AUTO_TEST_CASE

(

CreateSpaceToDepthQAsymm8Workload

)

Definition at line 677 of file NeonCreateWorkloadTests.cpp.

{
    NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
}

BOOST_AUTO_TEST_CASE() [37/54]

BOOST_AUTO_TEST_CASE

(

CreateSpaceToDepthQSymm16Workload

)

Definition at line 682 of file NeonCreateWorkloadTests.cpp.

{
    NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
}

BOOST_AUTO_TEST_CASE() [38/54]

BOOST_AUTO_TEST_CASE

(

CreateSplitterWorkload

)

Definition at line 687 of file NeonCreateWorkloadTests.cpp.

References armnn::Float32.

{
    Graph graph;
    NeonWorkloadFactory factory =
        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());

    auto workload = CreateSplitterWorkloadTest<NeonSplitterWorkload, DataType::Float32>(factory, graph);

    // Checks that outputs are as we expect them (see definition of CreateSplitterWorkloadTest).
    SplitterQueueDescriptor queueDescriptor = workload->GetData();
    auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
    BOOST_TEST(TestNeonTensorHandleInfo(inputHandle, TensorInfo({5, 7, 7}, DataType::Float32)));

    auto outputHandle0 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
    BOOST_TEST(TestNeonTensorHandleInfo(outputHandle0, TensorInfo({1, 7, 7}, DataType::Float32)));

    auto outputHandle1 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
    BOOST_TEST(TestNeonTensorHandleInfo(outputHandle1, TensorInfo({2, 7, 7}, DataType::Float32)));

    auto outputHandle2 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
    BOOST_TEST(TestNeonTensorHandleInfo(outputHandle2, TensorInfo({2, 7, 7}, DataType::Float32)));
}

BOOST_AUTO_TEST_CASE() [39/54]

BOOST_AUTO_TEST_CASE

(

CreateSplitterConcat

)

Definition at line 710 of file NeonCreateWorkloadTests.cpp.

References armnn::Float32.

{
    // Tests that it is possible to decide which output of the splitter layer
    // should be lined to which input of the concat layer.
    // We tested that is is possible to specify 0th output
    // of the splitter to be the 1st input to the concat, and the 1st output of the splitter to be 0th input
    // of the concat.

    Graph graph;
    NeonWorkloadFactory factory =
        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());

    auto workloads =
        CreateSplitterConcatWorkloadTest<NeonSplitterWorkload, NeonConcatWorkload,
            DataType::Float32>(factory, graph);

    auto wlSplitter = std::move(workloads.first);
    auto wlConcat = std::move(workloads.second);

    //Checks that the index of inputs/outputs matches what we declared on InputDescriptor construction.
    armnn::IAclTensorHandle* sOut0 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[0]);
    armnn::IAclTensorHandle* sOut1 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[1]);
    armnn::IAclTensorHandle* mIn0 = dynamic_cast<armnn::IAclTensorHandle*>(wlConcat->GetData().m_Inputs[0]);
    armnn::IAclTensorHandle* mIn1 = dynamic_cast<armnn::IAclTensorHandle*>(wlConcat->GetData().m_Inputs[1]);

    BOOST_TEST(sOut0);
    BOOST_TEST(sOut1);
    BOOST_TEST(mIn0);
    BOOST_TEST(mIn1);

    bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);

    BOOST_TEST(validDataPointers);
}

BOOST_AUTO_TEST_CASE() [40/54]

BOOST_AUTO_TEST_CASE

(

CreateSingleOutputMultipleInputs

)

Definition at line 745 of file NeonCreateWorkloadTests.cpp.

References armnn::BOOST_AUTO_TEST_CASE(), and armnn::Float32.

{
    // Tests that it is possible to assign multiple (two) different layers to each of the outputs of a splitter layer.
    // We created a splitter with two outputs. That each of those outputs is used by two different activation layers

    Graph graph;
    NeonWorkloadFactory factory =
        NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());

    std::unique_ptr<NeonSplitterWorkload> wlSplitter;
    std::unique_ptr<NeonActivationWorkload> wlActiv0_0;
    std::unique_ptr<NeonActivationWorkload> wlActiv0_1;
    std::unique_ptr<NeonActivationWorkload> wlActiv1_0;
    std::unique_ptr<NeonActivationWorkload> wlActiv1_1;

    CreateSplitterMultipleInputsOneOutputWorkloadTest<NeonSplitterWorkload,
        NeonActivationWorkload, DataType::Float32>(factory, graph, wlSplitter, wlActiv0_0, wlActiv0_1,
                                                   wlActiv1_0, wlActiv1_1);

    armnn::IAclTensorHandle* sOut0 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[0]);
    armnn::IAclTensorHandle* sOut1 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[1]);
    armnn::IAclTensorHandle* activ0_0Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv0_0->GetData().m_Inputs[0]);
    armnn::IAclTensorHandle* activ0_1Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv0_1->GetData().m_Inputs[0]);
    armnn::IAclTensorHandle* activ1_0Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv1_0->GetData().m_Inputs[0]);
    armnn::IAclTensorHandle* activ1_1Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv1_1->GetData().m_Inputs[0]);


    BOOST_TEST(sOut0);
    BOOST_TEST(sOut1);
    BOOST_TEST(activ0_0Im);
    BOOST_TEST(activ0_1Im);
    BOOST_TEST(activ1_0Im);
    BOOST_TEST(activ1_1Im);

    bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
                             (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);

    BOOST_TEST(validDataPointers);
}

BOOST_AUTO_TEST_CASE() [41/54]

BOOST_AUTO_TEST_CASE

(

CreateL2NormalizationNchwWorkload

)

Definition at line 834 of file NeonCreateWorkloadTests.cpp.

References armnn::NCHW.

{
    NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(DataLayout::NCHW);
}

BOOST_AUTO_TEST_CASE() [42/54]

BOOST_AUTO_TEST_CASE

(

CreateL2NormalizationNhwcWorkload

)

Definition at line 839 of file NeonCreateWorkloadTests.cpp.

References armnn::NHWC.

{
    NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(DataLayout::NHWC);
}

BOOST_AUTO_TEST_CASE() [43/54]

BOOST_AUTO_TEST_CASE

(

CreateLogSoftmaxFloatWorkload

)

Definition at line 870 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateLogSoftmaxWorkloadTest<NeonLogSoftmaxWorkload, DataType::Float32>();
}

BOOST_AUTO_TEST_CASE() [44/54]

BOOST_AUTO_TEST_CASE

(

CreateLSTMWorkloadFloatWorkload

)

Definition at line 893 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateLstmWorkloadTest<NeonLstmFloatWorkload>();
}

BOOST_AUTO_TEST_CASE() [45/54]

BOOST_AUTO_TEST_CASE

(

CreateConcatDim0Float32Workload

)

Definition at line 918 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
}

BOOST_AUTO_TEST_CASE() [46/54]

BOOST_AUTO_TEST_CASE

(

CreateConcatDim1Float32Workload

)

Definition at line 923 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
}

BOOST_AUTO_TEST_CASE() [47/54]

BOOST_AUTO_TEST_CASE

(

CreateConcatDim3Float32Workload

)

Definition at line 928 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
}

BOOST_AUTO_TEST_CASE() [48/54]

BOOST_AUTO_TEST_CASE

(

CreateConcatDim0Uint8Workload

)

Definition at line 933 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
}

BOOST_AUTO_TEST_CASE() [49/54]

BOOST_AUTO_TEST_CASE

(

CreateConcatDim1Uint8Workload

)

Definition at line 938 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
}

BOOST_AUTO_TEST_CASE() [50/54]

BOOST_AUTO_TEST_CASE

(

CreateConcatDim3Uint8Workload

)

Definition at line 943 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
}

BOOST_AUTO_TEST_CASE() [51/54]

BOOST_AUTO_TEST_CASE

(

CreateStackFloat32Workload

)

Definition at line 976 of file NeonCreateWorkloadTests.cpp.

References armnn::BOOST_AUTO_TEST_CASE().

{
    NeonCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
}

BOOST_AUTO_TEST_CASE() [52/54]

BOOST_AUTO_TEST_CASE

(

CreateStackUint8Workload

)

Definition at line 988 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
}

BOOST_AUTO_TEST_CASE() [53/54]

BOOST_AUTO_TEST_CASE

(

CreateQuantizedLstmWorkload

)

Definition at line 1024 of file NeonCreateWorkloadTests.cpp.

{
    NeonCreateQuantizedLstmWorkloadTest<NeonQuantizedLstmWorkload>();
}

BOOST_AUTO_TEST_CASE() [54/54]

BOOST_AUTO_TEST_CASE

(

CreateQLstmWorkloadTest

)

Definition at line 1051 of file NeonCreateWorkloadTests.cpp.

References BOOST_AUTO_TEST_SUITE_END().

{
    NeonCreateQLstmWorkloadTest<NeonQLstmWorkload>();
}