IVGCVSW-1200 Division layer

	*IVGCVSW-1772 Create QueueDescriptors
	*IVGCVSW-1773 Add a CL implementation of the DivisionWorkload
	*IVGCVSW-1774 Add Neon implementation of the DivisionWorkload
	*IVGCVSW-1775 Add a Ref implementation of the DivisionWorkload
	*IVGCVSW-1776 Add a Division Layer
	* Added simple division unit tests with broadcasting

Change-Id: I05751fb7f868789f6c06f91e8d25e52b4f12ab5e

5 files changed, 138 insertions, 0 deletions

diff --git a/src/armnn/backends/test/ArmComputeCl.cpp b/src/armnn/backends/test/ArmComputeCl.cpp
index d0cb7243c3..4f6abad4e9 100644
--- a/src/armnn/backends/test/ArmComputeCl.cpp
+++ b/src/armnn/backends/test/ArmComputeCl.cpp
@@ -140,6 +140,11 @@ ARMNN_AUTO_TEST_CASE(UNSUPPORTED_L2Pooling2dSize9Uint8, L2Pooling2dSize9Uint8Tes
 ARMNN_AUTO_TEST_CASE(SimpleAdd, AdditionTest)
 ARMNN_AUTO_TEST_CASE(AddBroadcast1Element, AdditionBroadcast1ElementTest)
 
+// Div
+ARMNN_AUTO_TEST_CASE(SimpleDivision, DivisionTest)
+ARMNN_AUTO_TEST_CASE(DivisionBroadcast1Element, DivisionBroadcast1ElementTest)
+ARMNN_AUTO_TEST_CASE(DivisionBroadcast1DVector, DivisionBroadcast1DVectorTest)
+
 // Mul
 ARMNN_AUTO_TEST_CASE(SimpleMultiplication, MultiplicationTest)
 ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1Element, MultiplicationBroadcast1ElementTest)
diff --git a/src/armnn/backends/test/IsLayerSupportedTestImpl.hpp b/src/armnn/backends/test/IsLayerSupportedTestImpl.hpp
index eca3068822..406dddd934 100644
--- a/src/armnn/backends/test/IsLayerSupportedTestImpl.hpp
+++ b/src/armnn/backends/test/IsLayerSupportedTestImpl.hpp
@@ -340,6 +340,8 @@ DECLARE_LAYER_POLICY_2_PARAM(Permute)
 
 DECLARE_LAYER_POLICY_2_PARAM(Pooling2d)
 
+DECLARE_LAYER_POLICY_1_PARAM(Division)
+
 DECLARE_LAYER_POLICY_2_PARAM(ResizeBilinear)
 
 DECLARE_LAYER_POLICY_2_PARAM(Reshape)
diff --git a/src/armnn/backends/test/LayerTests.cpp b/src/armnn/backends/test/LayerTests.cpp
index 8039ffb9b1..e916c05397 100644
--- a/src/armnn/backends/test/LayerTests.cpp
+++ b/src/armnn/backends/test/LayerTests.cpp
@@ -1070,6 +1070,128 @@ LayerTestResult<float,4> CompareAdditionTest(armnn::IWorkloadFactory& workloadFa
 }
 
 namespace {
+    LayerTestResult<float,4> DivisionTestHelper(armnn::IWorkloadFactory& workloadFactory,
+                                                      const unsigned int shape0[4],
+                                                      const std::vector<float> & values0,
+                                                      const unsigned int shape1[4],
+                                                      const std::vector<float> & values1,
+                                                      const unsigned int outShape[4],
+                                                      const std::vector<float> & outValues)
+    {
+        const size_t dimensionCount = 4;
+        armnn::TensorInfo inputTensorInfo0{dimensionCount, shape0, armnn::DataType::Float32};
+        armnn::TensorInfo inputTensorInfo1{dimensionCount, shape1, armnn::DataType::Float32};
+        armnn::TensorInfo outputTensorInfo{dimensionCount, outShape, armnn::DataType::Float32};
+
+        auto input0 = MakeTensor<float, 4>(inputTensorInfo0, values0);
+        auto input1 = MakeTensor<float, 4>(inputTensorInfo1, values1);
+
+        LayerTestResult<float,4> ret(outputTensorInfo);
+
+        std::unique_ptr<armnn::ITensorHandle> inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0);
+        std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
+        std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
+
+        armnn::DivisionQueueDescriptor data;
+        armnn::WorkloadInfo info;
+        AddInputToWorkload(data, info, inputTensorInfo0, inputHandle0.get());
+        AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
+        AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
+
+        std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateDivision(data, info);
+
+        inputHandle0->Allocate();
+        inputHandle1->Allocate();
+        outputHandle->Allocate();
+
+        CopyDataToITensorHandle(inputHandle0.get(), &input0[0][0][0][0]);
+        CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]);
+
+        workloadFactory.Finalize();
+        workload->Execute();
+
+        CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
+
+        ret.outputExpected = MakeTensor<float, 4>(outputTensorInfo, outValues);
+        return ret;
+    }
+} // anonymous namespace
+
+LayerTestResult<float,4> DivisionTest(armnn::IWorkloadFactory& workloadFactory)
+{
+    const unsigned int width = 2;
+    const unsigned int height = 2;
+    const unsigned int channelCount = 2;
+    const unsigned int batchSize = 2;
+
+    unsigned int shape[] = { batchSize, channelCount, height, width };
+
+    std::vector<float> input0({
+                                      2,  2,  2,  2,    3,  3,  3,  3,
+                                      4,  4,  4,  4,    5,  5,  5,  5 });
+
+    std::vector<float> input1({
+                                      1,  1,  1,  1,    2,  2,  2,  2,
+                                      4,  4,  4,  4,    4,  4,  4,  4 });
+
+    std::vector<float> output({
+                                      2,  2,  2,  2,    1.5,  1.5,  1.5,  1.5,
+                                      1, 1, 1, 1,  1.25, 1.25, 1.25, 1.25 });
+
+    return DivisionTestHelper(workloadFactory,
+                                    shape,
+                                    input0,
+                                    shape,
+                                    input1,
+                                    shape,
+                                    output);
+}
+
+LayerTestResult<float, 4> DivisionBroadcast1ElementTest(armnn::IWorkloadFactory& workloadFactory)
+{
+    unsigned int shape0[] = { 1, 2, 2, 2 };
+    std::vector<float> input0({ 2, 4, 6, 8, 10, 12, 14, 16});
+
+    unsigned int shape1[] = { 1, 1, 1, 1 };
+    std::vector<float> input1({ 2 });
+
+    std::vector<float> output({ 1, 2, 3, 4, 5, 6, 7, 8});
+
+    return DivisionTestHelper(workloadFactory,
+                                    shape0,
+                                    input0,
+                                    shape1,
+                                    input1,
+                                    shape0,
+                                    output);
+}
+
+LayerTestResult<float, 4> DivisionBroadcast1DVectorTest(armnn::IWorkloadFactory& workloadFactory)
+{
+    unsigned int shape0[] = { 1, 3, 3, 2 };
+    std::vector<float> input0({
+                                      1,   4,       3,  8,      5, 12,
+                                      7,   16,      9, 20,     11, 24,
+                                      13,  28,     15, 32,     17, 36});
+
+    unsigned int shape1[] = { 1, 1, 1, 2 };
+    std::vector<float> input1({ 1, 2 });
+
+    std::vector<float> output({
+                                      1,   2,      3,  4,      5,  6,
+                                      7,   8,      9, 10,     11, 12,
+                                      13, 14,     15, 16,     17, 18});
+
+    return DivisionTestHelper(workloadFactory,
+                                    shape0,
+                                    input0,
+                                    shape1,
+                                    input1,
+                                    shape0,
+                                    output);
+}
+
+namespace {
 LayerTestResult<float,4> MultiplicationTestHelper(armnn::IWorkloadFactory& workloadFactory,
                                                   const unsigned int shape0[4],
                                                   const std::vector<float> & values0,
diff --git a/src/armnn/backends/test/LayerTests.hpp b/src/armnn/backends/test/LayerTests.hpp
index 48f73e7693..a59ff05c90 100644
--- a/src/armnn/backends/test/LayerTests.hpp
+++ b/src/armnn/backends/test/LayerTests.hpp
@@ -192,6 +192,10 @@ LayerTestResult<float, 4> CompareActivationTest(armnn::IWorkloadFactory&  worklo
                                                 armnn::ActivationFunction f,
                                                 unsigned int batchSize);
 
+LayerTestResult<float, 4> DivisionTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> DivisionBroadcast1ElementTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> DivisionBroadcast1DVectorTest(armnn::IWorkloadFactory& workloadFactory);
+
 LayerTestResult<float, 4> MultiplicationTest(armnn::IWorkloadFactory& workloadFactory);
 LayerTestResult<float, 4> MultiplicationBroadcast1ElementTest(armnn::IWorkloadFactory& workloadFactory);
 LayerTestResult<float, 4> MultiplicationBroadcast1DVectorTest(armnn::IWorkloadFactory& workloadFactory);
diff --git a/src/armnn/backends/test/Reference.cpp b/src/armnn/backends/test/Reference.cpp
index dedeb50e33..b31723c3a3 100644
--- a/src/armnn/backends/test/Reference.cpp
+++ b/src/armnn/backends/test/Reference.cpp
@@ -146,6 +146,11 @@ ARMNN_AUTO_TEST_CASE(AdditionUint8, AdditionUint8Test)
 ARMNN_AUTO_TEST_CASE(AddBroadcastUint8, AdditionBroadcastUint8Test)
 ARMNN_AUTO_TEST_CASE(AddBroadcast1ElementUint8, AdditionBroadcast1ElementUint8Test)
 
+// Div
+ARMNN_AUTO_TEST_CASE(SimpleDivision, DivisionTest)
+ARMNN_AUTO_TEST_CASE(DivisionBroadcast1Element, DivisionBroadcast1ElementTest)
+ARMNN_AUTO_TEST_CASE(DivisionBroadcast1DVector, DivisionBroadcast1DVectorTest)
+
 // Mul
 ARMNN_AUTO_TEST_CASE(SimpleMultiplication, MultiplicationTest)
 ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1Element, MultiplicationBroadcast1ElementTest)