From aba90cd608eb65ab459cd71a6724511a1507763b Mon Sep 17 00:00:00 2001 From: James Conroy Date: Fri, 6 Nov 2020 16:28:18 +0000 Subject: IVGCVSW-5091 Add Logical ops frontend and ref impl * Add frontend and reference implementation for logical ops NOT, AND, OR. * Unary NOT uses existing ElementwiseUnary layer and ElementwiseUnary descriptor. * Binary AND/OR uses new layer LogicalBinary and new LogicalBinary descriptor. * Add serialization/deserializion support and add missing ElementwiseUnary deserializer code. * Add additional Boolean decoder in BaseIterator.hpp. Signed-off-by: James Conroy Change-Id: Id343b01174053a166de1b98b6175e04a5065f720 --- src/backends/backendsCommon/test/CMakeLists.txt | 2 + .../test/IsLayerSupportedTestImpl.hpp | 2 + src/backends/backendsCommon/test/LayerTests.hpp | 1 + .../test/layerTests/LogicalTestImpl.cpp | 572 +++++++++++++++++++++ .../test/layerTests/LogicalTestImpl.hpp | 83 +++ 5 files changed, 660 insertions(+) create mode 100644 src/backends/backendsCommon/test/layerTests/LogicalTestImpl.cpp create mode 100644 src/backends/backendsCommon/test/layerTests/LogicalTestImpl.hpp (limited to 'src/backends/backendsCommon/test') diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt index a1271cdd99..7894895c39 100644 --- a/src/backends/backendsCommon/test/CMakeLists.txt +++ b/src/backends/backendsCommon/test/CMakeLists.txt @@ -110,6 +110,8 @@ list(APPEND armnnBackendsCommonUnitTests_sources layerTests/L2NormalizationTestImpl.cpp layerTests/L2NormalizationTestImpl.hpp layerTests/LayerTestResult.hpp + layerTests/LogicalTestImpl.cpp + layerTests/LogicalTestImpl.hpp layerTests/LogSoftmaxTestImpl.cpp layerTests/LogSoftmaxTestImpl.hpp layerTests/LstmTestImpl.cpp diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp index a8465b45f6..7c7ad5f159 100644 --- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp +++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp @@ -614,6 +614,8 @@ DECLARE_LAYER_POLICY_2_PARAM(InstanceNormalization) DECLARE_LAYER_POLICY_2_PARAM(L2Normalization) +DECLARE_LAYER_POLICY_2_PARAM(LogicalBinary) + DECLARE_LAYER_POLICY_2_PARAM(LogSoftmax) DECLARE_LAYER_POLICY_2_PARAM(Lstm) diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp index a4615914d3..e9eb5b9553 100644 --- a/src/backends/backendsCommon/test/LayerTests.hpp +++ b/src/backends/backendsCommon/test/LayerTests.hpp @@ -33,6 +33,7 @@ #include #include #include +#include #include #include #include diff --git a/src/backends/backendsCommon/test/layerTests/LogicalTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/LogicalTestImpl.cpp new file mode 100644 index 0000000000..2225de31e4 --- /dev/null +++ b/src/backends/backendsCommon/test/layerTests/LogicalTestImpl.cpp @@ -0,0 +1,572 @@ +// +// Copyright © 2020 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "LogicalTestImpl.hpp" + +#include +#include + +#include +#include + +#include +#include + +#include + +namespace { + +template +LayerTestResult LogicalUnaryTestHelper( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + armnn::UnaryOperation op, + const armnn::TensorShape& inputShape, + std::vector input, + const armnn::TensorShape& outputShape, + std::vector expectedOutput, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + ARMNN_ASSERT(inputShape.GetNumDimensions() == NumDims); + armnn::TensorInfo inputTensorInfo(inputShape, armnn::DataType::Boolean); + + ARMNN_ASSERT(outputShape.GetNumDimensions() == NumDims); + armnn::TensorInfo outputTensorInfo(outputShape, armnn::DataType::Boolean); + + auto inputTensor = MakeTensor(inputTensorInfo, input); + + LayerTestResult ret(outputTensorInfo); + + std::unique_ptr inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo); + std::unique_ptr outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo); + + armnn::ElementwiseUnaryDescriptor desc(op); + armnn::ElementwiseUnaryQueueDescriptor qDesc; + qDesc.m_Parameters = desc; + + armnn::WorkloadInfo info; + AddInputToWorkload(qDesc, info, inputTensorInfo, inputHandle.get()); + AddOutputToWorkload(qDesc, info, outputTensorInfo, outputHandle.get()); + + auto workload = workloadFactory.CreateLogicalUnary(qDesc, info); + + inputHandle->Allocate(); + outputHandle->Allocate(); + + CopyDataToITensorHandle(inputHandle.get(), inputTensor.origin()); + + workload->PostAllocationConfigure(); + ExecuteWorkload(*workload, memoryManager); + + CopyDataFromITensorHandle(ret.output.origin(), outputHandle.get()); + + ret.outputExpected = MakeTensor(outputTensorInfo, expectedOutput); + ret.compareBoolean = true; + return ret; +} + +template +LayerTestResult LogicalBinaryTestHelper( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + armnn::LogicalBinaryOperation op, + const armnn::TensorShape& inputShape0, + const armnn::TensorShape& inputShape1, + std::vector input0, + std::vector input1, + const armnn::TensorShape& outputShape, + std::vector expectedOutput, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + ARMNN_ASSERT(inputShape0.GetNumDimensions() == NumDims); + armnn::TensorInfo inputTensorInfo0(inputShape0, armnn::DataType::Boolean); + + ARMNN_ASSERT(inputShape1.GetNumDimensions() == NumDims); + armnn::TensorInfo inputTensorInfo1(inputShape1, armnn::DataType::Boolean); + + ARMNN_ASSERT(outputShape.GetNumDimensions() == NumDims); + armnn::TensorInfo outputTensorInfo(outputShape, armnn::DataType::Boolean); + + auto inputTensor0 = MakeTensor(inputTensorInfo0, input0); + auto inputTensor1 = MakeTensor(inputTensorInfo1, input1); + + LayerTestResult ret(outputTensorInfo); + + std::unique_ptr inputHandle0 = tensorHandleFactory.CreateTensorHandle(inputTensorInfo0); + std::unique_ptr inputHandle1 = tensorHandleFactory.CreateTensorHandle(inputTensorInfo1); + std::unique_ptr outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo); + + armnn::LogicalBinaryDescriptor desc(op); + armnn::LogicalBinaryQueueDescriptor qDesc; + qDesc.m_Parameters = desc; + + armnn::WorkloadInfo info; + AddInputToWorkload(qDesc, info, inputTensorInfo0, inputHandle0.get()); + AddInputToWorkload(qDesc, info, inputTensorInfo1, inputHandle1.get()); + AddOutputToWorkload(qDesc, info, outputTensorInfo, outputHandle.get()); + + auto workload = workloadFactory.CreateLogicalBinary(qDesc, info); + + inputHandle0->Allocate(); + inputHandle1->Allocate(); + outputHandle->Allocate(); + + CopyDataToITensorHandle(inputHandle0.get(), inputTensor0.origin()); + CopyDataToITensorHandle(inputHandle1.get(), inputTensor1.origin()); + + workload->PostAllocationConfigure(); + ExecuteWorkload(*workload, memoryManager); + + CopyDataFromITensorHandle(ret.output.origin(), outputHandle.get()); + + ret.outputExpected = MakeTensor(outputTensorInfo, expectedOutput); + ret.compareBoolean = true; + return ret; +} + +class UnaryTestData +{ +public: + UnaryTestData() = default; + virtual ~UnaryTestData() = default; + + armnn::TensorShape m_InputShape; + armnn::TensorShape m_OutputShape; + + std::vector m_InputData; + + std::vector m_OutputNot; +}; + +class BinaryTestData +{ +public: + BinaryTestData() = default; + virtual ~BinaryTestData() = default; + + armnn::TensorShape m_InputShape0; + armnn::TensorShape m_InputShape1; + armnn::TensorShape m_OutputShape; + + std::vector m_InputData0; + std::vector m_InputData1; + + std::vector m_OutputAnd; + std::vector m_OutputOr; +}; + +class SimpleUnaryTestData : public UnaryTestData +{ +public: + SimpleUnaryTestData() : UnaryTestData() + { + m_InputShape = { 1, 1, 1, 4 }; + m_OutputShape = m_InputShape; + + m_InputData = + { + true, false, false, true + }; + + m_OutputNot = + { + false, true, true, false + }; + } +}; + +class SimpleUnaryIntTestData : public UnaryTestData +{ +public: + SimpleUnaryIntTestData() : UnaryTestData() + { + m_InputShape = { 1, 1, 1, 4 }; + m_OutputShape = m_InputShape; + + m_InputData = + { + 1, 11, 111, 0 + }; + + m_OutputNot = + { + 0, 0, 0, 1 + }; + } +}; + +class SimpleBinaryTestData : public BinaryTestData +{ +public: + SimpleBinaryTestData() : BinaryTestData() + { + m_InputShape0 = { 1, 1, 1, 4 }; + m_InputShape1 = m_InputShape0; + m_OutputShape = m_InputShape1; + + m_InputData0 = + { + true, false, false, true + }; + + m_InputData1 = + { + true, false, true, false + }; + + m_OutputAnd = + { + true, false, false, false + }; + + m_OutputOr = + { + true, false, true, true + }; + } +}; + +class SimpleBinaryIntTestData : public BinaryTestData +{ +public: + SimpleBinaryIntTestData() : BinaryTestData() + { + m_InputShape0 = { 1, 1, 1, 4 }; + m_InputShape1 = m_InputShape0; + m_OutputShape = m_InputShape1; + + m_InputData0 = + { + 1, 11, 111, 0 + }; + + m_InputData1 = + { + 0, 111, 111, 0 + }; + + m_OutputAnd = + { + 0, 1, 1, 0 + }; + + m_OutputOr = + { + 1, 1, 1, 0 + }; + } +}; + +class BroadcastBinary1TestData : public BinaryTestData +{ +public: + BroadcastBinary1TestData() : BinaryTestData() + { + m_InputShape0 = { 1, 1, 1, 4 }; + m_InputShape1 = { 1, 1, 1, 1 }; + m_OutputShape = m_InputShape0; + + m_InputData0 = + { + true, false, false, true + }; + + m_InputData1 = + { + true + }; + + m_OutputAnd = + { + true, false, false, true + }; + + m_OutputOr = + { + true, true, true, true + }; + } +}; + +class BroadcastBinary2TestData : public BinaryTestData +{ +public: + BroadcastBinary2TestData() : BinaryTestData() + { + m_InputShape0 = { 1, 1, 1, 1 }; + m_InputShape1 = { 1, 1, 1, 4 }; + m_OutputShape = m_InputShape1; + + m_InputData0 = + { + true + }; + + m_InputData1 = + { + true, false, false, true + }; + + m_OutputAnd = + { + true, false, false, true + }; + + m_OutputOr = + { + true, true, true, true + }; + } +}; + +class BroadcastBinary3TestData : public BinaryTestData +{ +public: + BroadcastBinary3TestData() : BinaryTestData() + { + m_InputShape0 = { 1, 1, 1, 4 }; + m_InputShape1 = { 1, 1, 1, 1 }; + m_OutputShape = m_InputShape0; + + m_InputData0 = + { + true, false, false, true + }; + + m_InputData1 = + { + false + }; + + m_OutputAnd = + { + false, false, false, false + }; + + m_OutputOr = + { + true, false, false, true + }; + } +}; + +static SimpleUnaryTestData s_SimpleUnaryTestData; +static SimpleBinaryTestData s_SimpleBinaryTestData; + +static SimpleUnaryIntTestData s_SimpleUnaryIntTestData; +static SimpleBinaryIntTestData s_SimpleBinaryIntTestData; + +static BroadcastBinary1TestData s_BroadcastBinary1TestData; +static BroadcastBinary2TestData s_BroadcastBinary2TestData; +static BroadcastBinary3TestData s_BroadcastBinary3TestData; + + +} // anonymous namespace + +// Unary - Not +LayerTestResult LogicalNotTest(armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + return LogicalUnaryTestHelper<4>(workloadFactory, + memoryManager, + armnn::UnaryOperation::LogicalNot, + s_SimpleUnaryTestData.m_InputShape, + s_SimpleUnaryTestData.m_InputData, + s_SimpleUnaryTestData.m_OutputShape, + s_SimpleUnaryTestData.m_OutputNot, + tensorHandleFactory); +} + +// Unary - Not with integers +LayerTestResult LogicalNotIntTest(armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + return LogicalUnaryTestHelper<4>(workloadFactory, + memoryManager, + armnn::UnaryOperation::LogicalNot, + s_SimpleUnaryIntTestData.m_InputShape, + s_SimpleUnaryIntTestData.m_InputData, + s_SimpleUnaryIntTestData.m_OutputShape, + s_SimpleUnaryIntTestData.m_OutputNot, + tensorHandleFactory); +} + +// Binary - And +LayerTestResult LogicalAndTest(armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + return LogicalBinaryTestHelper<4>(workloadFactory, + memoryManager, + armnn::LogicalBinaryOperation::LogicalAnd, + s_SimpleBinaryTestData.m_InputShape0, + s_SimpleBinaryTestData.m_InputShape1, + s_SimpleBinaryTestData.m_InputData0, + s_SimpleBinaryTestData.m_InputData1, + s_SimpleBinaryTestData.m_OutputShape, + s_SimpleBinaryTestData.m_OutputAnd, + tensorHandleFactory); +} + +// Binary - Or +LayerTestResult LogicalOrTest(armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + return LogicalBinaryTestHelper<4>(workloadFactory, + memoryManager, + armnn::LogicalBinaryOperation::LogicalOr, + s_SimpleBinaryTestData.m_InputShape0, + s_SimpleBinaryTestData.m_InputShape1, + s_SimpleBinaryTestData.m_InputData0, + s_SimpleBinaryTestData.m_InputData1, + s_SimpleBinaryTestData.m_OutputShape, + s_SimpleBinaryTestData.m_OutputOr, + tensorHandleFactory); +} + +// Binary - And with integers +LayerTestResult LogicalAndIntTest(armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + return LogicalBinaryTestHelper<4>(workloadFactory, + memoryManager, + armnn::LogicalBinaryOperation::LogicalAnd, + s_SimpleBinaryIntTestData.m_InputShape0, + s_SimpleBinaryIntTestData.m_InputShape1, + s_SimpleBinaryIntTestData.m_InputData0, + s_SimpleBinaryIntTestData.m_InputData1, + s_SimpleBinaryIntTestData.m_OutputShape, + s_SimpleBinaryIntTestData.m_OutputAnd, + tensorHandleFactory); +} + +// Binary - Or with integers +LayerTestResult LogicalOrIntTest(armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + return LogicalBinaryTestHelper<4>(workloadFactory, + memoryManager, + armnn::LogicalBinaryOperation::LogicalOr, + s_SimpleBinaryIntTestData.m_InputShape0, + s_SimpleBinaryIntTestData.m_InputShape1, + s_SimpleBinaryIntTestData.m_InputData0, + s_SimpleBinaryIntTestData.m_InputData1, + s_SimpleBinaryIntTestData.m_OutputShape, + s_SimpleBinaryIntTestData.m_OutputOr, + tensorHandleFactory); +} + +// Binary - And Broadcast +LayerTestResult LogicalAndBroadcast1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + return LogicalBinaryTestHelper<4>(workloadFactory, + memoryManager, + armnn::LogicalBinaryOperation::LogicalAnd, + s_BroadcastBinary1TestData.m_InputShape0, + s_BroadcastBinary1TestData.m_InputShape1, + s_BroadcastBinary1TestData.m_InputData0, + s_BroadcastBinary1TestData.m_InputData1, + s_BroadcastBinary1TestData.m_OutputShape, + s_BroadcastBinary1TestData.m_OutputAnd, + tensorHandleFactory); +} + +// Binary - Or Broadcast +LayerTestResult LogicalOrBroadcast1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + return LogicalBinaryTestHelper<4>(workloadFactory, + memoryManager, + armnn::LogicalBinaryOperation::LogicalOr, + s_BroadcastBinary1TestData.m_InputShape0, + s_BroadcastBinary1TestData.m_InputShape1, + s_BroadcastBinary1TestData.m_InputData0, + s_BroadcastBinary1TestData.m_InputData1, + s_BroadcastBinary1TestData.m_OutputShape, + s_BroadcastBinary1TestData.m_OutputOr, + tensorHandleFactory); +} + +// Binary - And Broadcast +LayerTestResult LogicalAndBroadcast2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + return LogicalBinaryTestHelper<4>(workloadFactory, + memoryManager, + armnn::LogicalBinaryOperation::LogicalAnd, + s_BroadcastBinary2TestData.m_InputShape0, + s_BroadcastBinary2TestData.m_InputShape1, + s_BroadcastBinary2TestData.m_InputData0, + s_BroadcastBinary2TestData.m_InputData1, + s_BroadcastBinary2TestData.m_OutputShape, + s_BroadcastBinary2TestData.m_OutputAnd, + tensorHandleFactory); +} + +// Binary - Or Broadcast +LayerTestResult LogicalOrBroadcast2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + return LogicalBinaryTestHelper<4>(workloadFactory, + memoryManager, + armnn::LogicalBinaryOperation::LogicalOr, + s_BroadcastBinary2TestData.m_InputShape0, + s_BroadcastBinary2TestData.m_InputShape1, + s_BroadcastBinary2TestData.m_InputData0, + s_BroadcastBinary2TestData.m_InputData1, + s_BroadcastBinary2TestData.m_OutputShape, + s_BroadcastBinary2TestData.m_OutputOr, + tensorHandleFactory); +} + +// Binary - And Broadcast +LayerTestResult LogicalAndBroadcast3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + return LogicalBinaryTestHelper<4>(workloadFactory, + memoryManager, + armnn::LogicalBinaryOperation::LogicalAnd, + s_BroadcastBinary3TestData.m_InputShape0, + s_BroadcastBinary3TestData.m_InputShape1, + s_BroadcastBinary3TestData.m_InputData0, + s_BroadcastBinary3TestData.m_InputData1, + s_BroadcastBinary3TestData.m_OutputShape, + s_BroadcastBinary3TestData.m_OutputAnd, + tensorHandleFactory); +} + +// Binary - Or Broadcast +LayerTestResult LogicalOrBroadcast3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + return LogicalBinaryTestHelper<4>(workloadFactory, + memoryManager, + armnn::LogicalBinaryOperation::LogicalOr, + s_BroadcastBinary3TestData.m_InputShape0, + s_BroadcastBinary3TestData.m_InputShape1, + s_BroadcastBinary3TestData.m_InputData0, + s_BroadcastBinary3TestData.m_InputData1, + s_BroadcastBinary3TestData.m_OutputShape, + s_BroadcastBinary3TestData.m_OutputOr, + tensorHandleFactory); +} \ No newline at end of file diff --git a/src/backends/backendsCommon/test/layerTests/LogicalTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/LogicalTestImpl.hpp new file mode 100644 index 0000000000..1711d90d5a --- /dev/null +++ b/src/backends/backendsCommon/test/layerTests/LogicalTestImpl.hpp @@ -0,0 +1,83 @@ +// +// Copyright © 2020 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include "LayerTestResult.hpp" + +#include +#include + +// Unary - Logical Not +LayerTestResult LogicalNotTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Unary - Logical Not with integers +LayerTestResult LogicalNotIntTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Binary - Logical And +LayerTestResult LogicalAndTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Binary - Logical Or +LayerTestResult LogicalOrTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Binary - Logical And with integers +LayerTestResult LogicalAndIntTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Binary - Logical Or with integers +LayerTestResult LogicalOrIntTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Binary - Logical And Broadcast +LayerTestResult LogicalAndBroadcast1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Binary - Logical Or Broadcast +LayerTestResult LogicalOrBroadcast1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Binary - Logical And Broadcast +LayerTestResult LogicalAndBroadcast2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Binary - Logical Or Broadcast +LayerTestResult LogicalOrBroadcast2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Binary - Logical And Broadcast +LayerTestResult LogicalAndBroadcast3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Binary - Logical Or Broadcast +LayerTestResult LogicalOrBroadcast3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); \ No newline at end of file -- cgit v1.2.1